Make lodepng optional.

fix ci build of example

LICENSE.lodepng

@@ -0,0 +1,21 @@
+Copyright (c) 2005-2018 Lode Vandevenne
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+    

README.md

@@ -82,6 +82,7 @@ TinyGLTF uses the following third party libraries.
 * base64 : Copyright (C) 2004-2008 René Nyffenegger
 * stb_image.h : v2.08 - public domain image loader - [Github link](https://github.com/nothings/stb/blob/master/stb_image.h)
 * stb_image_write.h : v1.09 - public domain image writer - [Github link](https://github.com/nothings/stb/blob/master/stb_image_write.h)
+* lodepng : Copyright (c) 2005-2018 Lode Vandevenne. zlib license. https://lodev.org/lodepng/
 
 
 ## Build and example
@@ -129,6 +130,7 @@ if (!ret) {
 * `TINYGLTF_NO_STB_IMAGE_WRITE` : Do not write images with stb_image_write. Instead use `TinyGLTF::SetImageWriter(WriteimageDataFunction WriteImageData, void *user_data)` to set a callback for writing images.
 * `TINYGLTF_NO_EXTERNAL_IMAGE` : Do not try to load external image file. This option woulde be helpful if you do not want load image file during glTF parsing.
 * `TINYGLTF_ANDROID_LOAD_FROM_ASSETS`: Load all files from packaged app assets instead of the regular file system. **Note:** You must pass a valid asset manager from your android app to `tinygltf::asset_manager` beforehand.
+* `TINYGLTF_USE_LODEPNG` : Load 16bit PNG image with lodepng(Valid when `TINYGLTF_NO_STB_IMAGE` was **not** defined). Must defined `LODEPNG_IMPLEMENTATION` in one .cc.
 
 ### Saving gltTF 2.0 model
 * [ ] Buffers.
@@ -170,4 +172,5 @@ $ ./tester_noexcept
 
 * json.hpp : Licensed under the MIT License <http://opensource.org/licenses/MIT>. Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
 * stb_image : Public domain.
+* lodepng : zlib license
 * catch : Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. Distributed under the Boost Software License, Version 1.0.

examples/raytrace/image-impl.cc

@@ -0,0 +1,6 @@
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
+#define LODEPNG_IMPLEMENTATION
+#include "lodepng.h"

examples/raytrace/img-loaders.cc

@@ -1,3 +1,5 @@
 
 #define STB_IMAGE_IMPLEMENTATION
 #include "stb_image.h"
+#define LODEPNG_IMPLEMENTATION
+#include "lodepng.h"

examples/raytrace/premake5.lua

@@ -9,7 +9,7 @@ newoption {
 }
 
 sources = {
-   "stbi-impl.cc",
+   "img-loaders.cc",
    "main.cc",
    "render.cc",
    "render-config.cc",

loader_example.cc

@@ -4,6 +4,7 @@
 #define TINYGLTF_IMPLEMENTATION
 #define STB_IMAGE_IMPLEMENTATION
 #define STB_IMAGE_WRITE_IMPLEMENTATION
+#define LODEPNG_IMPLEMENTATION
 #include "tiny_gltf.h"
 
 #include <cstdio>

tiny_gltf.h

@@ -34,6 +34,7 @@
 //  - jsonhpp: C++ JSON library.
 //  - base64: base64 decode/encode library.
 //  - stb_image: Image loading library.
+//  - lodepng: Load 16bit PNG.
 //
 #ifndef TINY_GLTF_H_
 #define TINY_GLTF_H_
@@ -476,8 +477,10 @@ struct Image {
   std::string name;
   int width;
   int height;
-  int component;
+  int component;  // channels. e.g. RGB=3, RGBA=4
-  std::vector<unsigned char> image;
+  int bits;       // bit depth per channel. 8(byte), 16 or 32.
+  int pixel_type; // pixel type(TINYGLTF_COMPONENT_TYPE_***). usually UBYTE(bits = 8) or USHORT(bits = 16) 
+  std::vector<unsigned char> image; // width * height * component * (bits/8)
   int bufferView;        // (required if no uri)
   std::string mimeType;  // (required if no uri) ["image/jpeg", "image/png",
                          // "image/bmp", "image/gif"]
@@ -498,6 +501,8 @@ struct Image {
     width = -1;
     height = -1;
     component = -1;
+    bits = -1;
+    pixel_type = TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE;
   }
   bool operator==(const Image &) const;
 };
@@ -1070,6 +1075,10 @@ class TinyGLTF {
 #include "./stb_image_write.h"
 #endif
 
+#if defined(TINYGLTF_USE_LODEPNG)
+#include "./lodepng.h"
+#endif
+
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
@@ -1203,6 +1212,7 @@ bool Camera::operator==(const Camera &other) const {
 bool Image::operator==(const Image &other) const {
   return this->bufferView == other.bufferView &&
          this->component == other.component && this->extras == other.extras &&
+         this->bits == other.bits &&
          this->height == other.height && this->image == other.image &&
          this->mimeType == other.mimeType && this->name == other.name &&
          this->uri == other.uri && this->width == other.width;
@@ -1599,6 +1609,9 @@ bool LoadImageData(Image *image, const int image_idx, std::string *err, std::str
   // some GPU drivers do not support 24-bit images for Vulkan
   req_comp = 4;
 
+  int bits = 8;
+  int pixel_type = TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE;
+
   // if image cannot be decoded, ignore parsing and keep it by its path
   // don't break in this case
   // FIXME we should only enter this function if the image is embedded. If
@@ -1608,11 +1621,28 @@ bool LoadImageData(Image *image, const int image_idx, std::string *err, std::str
   unsigned char *data =
       stbi_load_from_memory(bytes, size, &w, &h, &comp, req_comp);
   if (!data) {
+#if defined(TINYGLTF_USE_LODEPNG)
+    // try to load as 16bit PNG RGBA
+    unsigned ret = lodepng_decode_memory(&data, reinterpret_cast<unsigned *>(&w), reinterpret_cast<unsigned *>(&h), bytes, size, LCT_RGBA, /* bitdepth*/16);
+
+    if (ret != 0) {
+      // NOTE: you can use `warn` instead of `err`
+      if (err) {
+        (*err) += "Unknown image format. STB and LodePNG cannot decode image data for image[" + std::to_string(image_idx) + "] name = \"" + image->name + "\".\n";
+      }
+      return false;
+    }
+
+    bits = 16;
+    pixel_type = TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT;
+
+#else
     // NOTE: you can use `warn` instead of `err`
     if (err) {
       (*err) += "Unknown image format. STB cannot decode image data for image[" + std::to_string(image_idx) + "] name = \"" + image->name + "\". Proably 16bit PNG?\n";
     }
     return false;
+#endif
   }
 
   if (w < 1 || h < 1) {
@@ -1646,8 +1676,10 @@ bool LoadImageData(Image *image, const int image_idx, std::string *err, std::str
   image->width = w;
   image->height = h;
   image->component = req_comp;
-  image->image.resize(static_cast<size_t>(w * h * req_comp));
+  image->bits = bits;
-  std::copy(data, data + w * h * req_comp, image->image.begin());
+  image->pixel_type = pixel_type;
+  image->image.resize(static_cast<size_t>(w * h * req_comp * (bits/8)));
+  std::copy(data, data + w * h * req_comp * (bits/8), image->image.begin());
 
   free(data);
 
@@ -2514,6 +2546,7 @@ static bool ParseImage(Image *image, const int image_idx, std::string *err, std:
     // Keep texture path (for textures that cannot be decoded)
     image->uri = uri;
 #ifdef TINYGLTF_NO_EXTERNAL_IMAGE
+    // TODO(syoyo): Call LoadImageData callback?
     return true;
 #endif
     if (!LoadExternalFile(&img, err, warn, uri, basedir, false, 0, false, fs)) {