From deaccf9a6b018c9a241b33e23501a84ed3d1a4a5 Mon Sep 17 00:00:00 2001
From: jean-claude iehl <jean-claude.iehl@liris.cnrs.fr>
Date: Tue, 12 Mar 2024 22:23:25 +0100
Subject: [PATCH] code...
---
code/gkit.lua | 67 +
code/premake4.lua | 24 +
code/src/color.cpp | 122 +
code/src/color.h | 66 +
code/src/files.cpp | 124 +
code/src/files.h | 32 +
code/src/gltf/brdf.h | 214 +
code/src/gltf/bvh.h | 675 +++
code/src/gltf/cgltf.cpp | 4 +
code/src/gltf/cgltf.h | 6695 ++++++++++++++++++++++++++
code/src/gltf/fresnel.cpp | 95 +
code/src/gltf/fresnel.h | 33 +
code/src/gltf/gltf.cpp | 666 +++
code/src/gltf/gltf.h | 160 +
code/src/gltf/scene.cpp | 289 ++
code/src/gltf/scene.h | 67 +
code/src/gltf/sources.h | 166 +
code/src/gltf/texture.h | 148 +
code/src/image.h | 126 +
code/src/image_io.cpp | 313 ++
code/src/image_io.h | 41 +
code/src/mat.cpp | 434 ++
code/src/mat.h | 126 +
code/src/orbiter.cpp | 152 +
code/src/orbiter.h | 71 +
code/src/stb_image.h | 7987 ++++++++++++++++++++++++++++++++
code/src/stb_image_write.h | 1724 +++++++
code/src/vec.cpp | 150 +
code/src/vec.h | 232 +
code/src/wavefront/materials.h | 167 +
code/src/wavefront/mesh_io.cpp | 620 +++
code/src/wavefront/mesh_io.h | 220 +
32 files changed, 22010 insertions(+)
create mode 100644 code/gkit.lua
create mode 100644 code/premake4.lua
create mode 100644 code/src/color.cpp
create mode 100644 code/src/color.h
create mode 100644 code/src/files.cpp
create mode 100644 code/src/files.h
create mode 100644 code/src/gltf/brdf.h
create mode 100644 code/src/gltf/bvh.h
create mode 100644 code/src/gltf/cgltf.cpp
create mode 100644 code/src/gltf/cgltf.h
create mode 100644 code/src/gltf/fresnel.cpp
create mode 100644 code/src/gltf/fresnel.h
create mode 100644 code/src/gltf/gltf.cpp
create mode 100644 code/src/gltf/gltf.h
create mode 100644 code/src/gltf/scene.cpp
create mode 100644 code/src/gltf/scene.h
create mode 100644 code/src/gltf/sources.h
create mode 100644 code/src/gltf/texture.h
create mode 100644 code/src/image.h
create mode 100644 code/src/image_io.cpp
create mode 100644 code/src/image_io.h
create mode 100644 code/src/mat.cpp
create mode 100644 code/src/mat.h
create mode 100755 code/src/orbiter.cpp
create mode 100755 code/src/orbiter.h
create mode 100644 code/src/stb_image.h
create mode 100644 code/src/stb_image_write.h
create mode 100644 code/src/vec.cpp
create mode 100644 code/src/vec.h
create mode 100644 code/src/wavefront/materials.h
create mode 100644 code/src/wavefront/mesh_io.cpp
create mode 100644 code/src/wavefront/mesh_io.h
diff --git a/code/gkit.lua b/code/gkit.lua
new file mode 100644
index 0000000..db07a3a
--- /dev/null
+++ b/code/gkit.lua
@@ -0,0 +1,67 @@
+solution "gKit3"
+ configurations { "debug", "release" }
+
+ includedirs { ".", "src" }
+
+ configuration "debug"
+ targetdir "bin/debug"
+ defines { "DEBUG" }
+ if _PREMAKE_VERSION >="5.0" then
+ symbols "on"
+ else
+ flags { "Symbols" }
+ end
+
+ configuration "release"
+ targetdir "bin/release"
+--~ defines { "NDEBUG" }
+--~ defines { "GK_RELEASE" }
+ if _PREMAKE_VERSION >="5.0" then
+ optimize "speed"
+ else
+ flags { "OptimizeSpeed" }
+ end
+
+ configuration "linux"
+ buildoptions { "-mtune=native -march=native" }
+ buildoptions { "-std=c++14" }
+ buildoptions { "-W -Wall -Wextra -Wsign-compare -Wno-unused-parameter -Wno-unused-function -Wno-unused-variable", "-pipe" }
+
+ configuration { "linux", "debug" }
+ buildoptions { "-g"}
+ linkoptions { "-g"}
+
+ configuration { "linux", "release" }
+ buildoptions { "-fopenmp" }
+ linkoptions { "-fopenmp" }
+ buildoptions { "-flto"}
+ linkoptions { "-flto=auto"}
+
+if _PREMAKE_VERSION >="5.0" then
+ configuration { "windows" }
+ location "build"
+ debugdir "."
+
+ defines { "WIN32", "_USE_MATH_DEFINES", "_CRT_SECURE_NO_WARNINGS" }
+ defines { "NOMINMAX" } -- allow std::min() and std::max() in vc++ :(((
+
+ configuration { "windows", "vs*" }
+ location "build"
+ debugdir "."
+
+ system "Windows"
+ architecture "x64"
+ disablewarnings { "4244", "4305" }
+ flags { "MultiProcessorCompile", "NoMinimalRebuild" }
+end
+
+ configuration "macosx"
+ frameworks= "-F /Library/Frameworks/"
+ buildoptions { "-std=c++14 -Wno-deprecated-declarations" }
+ defines { "GK_MACOS" }
+ buildoptions { frameworks }
+
+ -- description des fichiers communs
+gkit_files = { "src/**.cpp", "src/**.h" }
+
+
diff --git a/code/premake4.lua b/code/premake4.lua
new file mode 100644
index 0000000..f734f83
--- /dev/null
+++ b/code/premake4.lua
@@ -0,0 +1,24 @@
+dofile "gkit.lua"
+
+ -- description des projets
+projects = {
+ "ao",
+ "path"
+}
+
+for i, name in ipairs(projects) do
+ project(name)
+ language "C++"
+ kind "ConsoleApp"
+ targetdir "bin"
+ files ( gkit_files )
+ files { "projects/sobol_matrices.cpp" }
+ files { "projects/" .. name .. ".cpp" }
+end
+
+project("errors")
+ language "C++"
+ kind "ConsoleApp"
+ targetdir "bin"
+ files ( gkit_files )
+ files { "projects/errors.cpp" }
diff --git a/code/src/color.cpp b/code/src/color.cpp
new file mode 100644
index 0000000..6fceeca
--- /dev/null
+++ b/code/src/color.cpp
@@ -0,0 +1,122 @@
+
+#include <cmath>
+#include <algorithm>
+
+#include "color.h"
+
+
+float Color::grey( ) const
+{
+ return (r+g+b) / 3;
+}
+
+float Color::max( ) const
+{
+ return std::max(r, std::max(g, std::max(b, float(0))));
+}
+
+
+Color gamma( const Color& color, const float g )
+{
+ return Color( std::pow(color.r, g), std::pow(color.g, g), std::pow(color.b, g), color.a );
+}
+
+float srgb( const float x )
+{
+ if(x < 0.00031308f) return 12.92f * x;
+ else return std::pow(1.055f * x, 1.0f / 2.4f) - 0.055f;
+}
+
+float linear( const float x )
+{
+ if(x < 0.04045f) return x / 12.92f;
+ else return std::pow((x + 0.055f) / 1.055f, 2.4f);
+}
+
+Color srgb( const Color& color )
+{
+ return Color(srgb(color.r), srgb(color.g), srgb(color.b), color.a);
+}
+
+Color linear( const Color& color )
+{
+ return Color(linear(color.r), linear(color.g), linear(color.b), color.a);
+}
+
+
+Color Black( )
+{
+ return Color(0, 0, 0);
+}
+
+Color White( )
+{
+ return Color(1, 1, 1);
+}
+
+Color Red( )
+{
+ return Color(1, 0, 0);
+}
+
+Color Green( )
+{
+ return Color(0, 1, 0);
+}
+
+Color Blue( )
+{
+ return Color(0, 0, 1);
+}
+
+Color Yellow( )
+{
+ return Color(1, 1, 0);
+}
+
+
+Color operator+ ( const Color& a, const Color& b )
+{
+ return Color(a.r + b.r, a.g + b.g, a.b + b.b, a.a + b.a);
+}
+
+Color operator- ( const Color& c )
+{
+ return Color(-c.r, -c.g, -c.b, -c.a);
+}
+
+Color operator- ( const Color& a, const Color& b )
+{
+ return a + (-b);
+}
+
+Color operator* ( const Color& a, const Color& b )
+{
+ return Color(a.r * b.r, a.g * b.g, a.b * b.b, a.a * b.a);
+}
+
+Color operator* ( const float k, const Color& c )
+{
+ return Color(c.r * k, c.g * k, c.b * k, c.a * k);
+}
+
+Color operator* ( const Color& c, const float k )
+{
+ return k * c;
+}
+
+Color operator/ ( const Color& a, const Color& b )
+{
+ return Color(a.r / b.r, a.g / b.g, a.b / b.b, a.a / b.a);
+}
+
+Color operator/ ( const float k, const Color& c )
+{
+ return Color(k / c.r, k / c.g, k / c.b, k / c.a);
+}
+
+Color operator/ ( const Color& c, const float k )
+{
+ float kk= 1 / k;
+ return kk * c;
+}
diff --git a/code/src/color.h b/code/src/color.h
new file mode 100644
index 0000000..1766148
--- /dev/null
+++ b/code/src/color.h
@@ -0,0 +1,66 @@
+
+#pragma once
+
+#include "vec.h"
+
+//! \addtogroup image
+///@{
+
+//! \file
+//! manipulation de couleurs
+
+//! representation d'une couleur (rgba) transparente ou opaque.
+struct Color
+{
+ //! constructeur par defaut.
+ Color( ) : r(0), g(0), b(0), a(1) {}
+ explicit Color( const float _r, const float _g, const float _b, const float _a= 1 ) : r(_r), g(_g), b(_b), a(_a) {}
+ explicit Color( const float _value ) : r(_value), g(_value), b(_value), a(1) {}
+
+ //! cree une couleur avec les memes composantes que color, mais remplace sa composante alpha (color.r, color.g, color.b, alpha).
+ Color( const Color& color, const float alpha ) : r(color.r), g(color.g), b(color.b), a(alpha) {} // remplace alpha.
+
+ Color( const Vector& v ) : r(v.x), g(v.y), b(v.z), a(1) {}
+
+ float grey( ) const;
+ float max( ) const;
+
+ bool zero( ) const { return r == 0 && g == 0 && b == 0; }
+ bool black( ) const { return r == 0 && g == 0 && b == 0; }
+
+ float r, g, b, a;
+};
+
+
+//! utilitaire. transformation gamma.
+Color gamma( const Color& color, const float g );
+//! transformation gamma : rgb lineaire vers srgb
+Color srgb( const Color& color );
+//! transformation gamma : srgb vers rgb lineaire
+Color linear( const Color& color );
+
+
+//! utilitaire. renvoie une couleur noire.
+Color Black( );
+//! utilitaire. renvoie une couleur blanche.
+Color White( );
+//! utilitaire. renvoie une couleur rouge.
+Color Red( );
+//! utilitaire. renvoie une couleur verte.
+Color Green( );
+//! utilitaire. renvoie une couleur bleue.
+Color Blue( );
+//! utilitaire. renvoie une couleur jaune.
+Color Yellow( );
+
+Color operator+ ( const Color& a, const Color& b );
+Color operator- ( const Color& a, const Color& b );
+Color operator- ( const Color& c );
+Color operator* ( const Color& a, const Color& b );
+Color operator* ( const Color& c, const float k );
+Color operator* ( const float k, const Color& c );
+Color operator/ ( const Color& a, const Color& b );
+Color operator/ ( const float k, const Color& c );
+Color operator/ ( const Color& c, const float k );
+
+///@}
diff --git a/code/src/files.cpp b/code/src/files.cpp
new file mode 100644
index 0000000..b49b367
--- /dev/null
+++ b/code/src/files.cpp
@@ -0,0 +1,124 @@
+
+#ifndef _MSC_VER
+ #include <sys/stat.h>
+#else
+ #include <sys/types.h>
+ #include <sys/stat.h>
+#endif
+
+#include <string>
+#include <algorithm>
+
+#include "files.h"
+
+
+//! verifie l'existance d'un fichier.
+bool exists( const std::string& filename )
+{
+#ifndef _MSC_VER
+ struct stat info;
+ if(stat(filename.c_str(), &info) < 0)
+ return false;
+
+ // verifie aussi que c'est bien un fichier standard
+ return S_ISREG(info.st_mode);
+
+#else
+ struct _stat64 info;
+ if(_stat64(filename.c_str(), &info) < 0)
+ return false;
+
+ // verifie aussi que c'est bien un fichier standard
+ return (info.st_mode & _S_IFREG);
+#endif
+}
+
+//! renvoie la date de la derniere modification d'un fichier
+size_t timestamp( const std::string& filename )
+{
+#ifndef _MSC_VER
+ struct stat info;
+ if(stat(filename.c_str(), &info) < 0)
+ return 0;
+
+ // verifie aussi que c'est bien un fichier standard
+ if(S_ISREG(info.st_mode))
+ return size_t(info.st_mtime);
+
+#else
+ struct _stat64 info;
+ if(_stat64(filename.c_str(), &info) < 0)
+ return 0;
+
+ // verifie aussi que c'est bien un fichier standard
+ if(info.st_mode & _S_IFREG)
+ return size_t(info.st_mtime);
+#endif
+
+ return 0;
+}
+
+
+/*! renvoie le chemin d'acces a un fichier. le chemin est toujours termine par /
+ pathname("path\to\file") == "path/to/"
+ pathname("path\to/file") == "path/to/"
+ pathname("path/to/file") == "path/to/"
+ pathname("file") == "./"
+ */
+std::string pathname( const std::string& filename )
+{
+ std::string path= filename;
+#ifndef WIN32
+ std::replace(path.begin(), path.end(), '\\', '/'); // linux, macos : remplace les \ par /.
+ size_t slash = path.find_last_of( '/' );
+ if(slash != std::string::npos)
+ return path.substr(0, slash +1); // inclus le slash
+ else
+ return "./";
+#else
+ std::replace(path.begin(), path.end(), '/', '\\'); // windows : remplace les / par \.
+ size_t slash = path.find_last_of( '\\' );
+ if(slash != std::string::npos)
+ return path.substr(0, slash +1); // inclus le slash
+ else
+ return ".\\";
+#endif
+}
+
+//! remplace tous les separateurs par / (linux) ou \ (windows)
+std::string normalize_filename( const std::string& filename )
+{
+ std::string path= filename;
+#ifndef WIN32
+ std::replace(path.begin(), path.end(), '\\', '/'); // linux, macos : remplace les \ par /.
+#else
+ std::replace(path.begin(), path.end(), '/', '\\'); // windows : remplace les / par \.
+#endif
+
+ return path;
+}
+
+
+/*! renvoie un nom de fichier relatif a un chemin.
+ relative_pathname("textures/base.png", "textures") == "base.png"
+ relative_pathname("base.png", "textures") == "base.png"
+ relative_pathname("model/textures/base.png", "model/model.obj") == "textures/base.png"
+*/
+//~ const char *relative_filename( const std::string& filename, const std::string& path )
+std::string relative_filename( const std::string& filename, const std::string& path )
+{
+ unsigned i= 0;
+ while(i< filename.length() && i < path.length() && filename[i] == path[i])
+ i++;
+
+ return filename.substr(i);
+}
+
+
+std::string absolute_filename( const std::string& path, const std::string& filename )
+{
+ if(filename[0] == '.' || filename[0] == '/')
+ return normalize_filename(filename);
+ else
+ return normalize_filename(path + filename);
+}
diff --git a/code/src/files.h b/code/src/files.h
new file mode 100644
index 0000000..0a11fff
--- /dev/null
+++ b/code/src/files.h
@@ -0,0 +1,32 @@
+
+#ifndef _FILES_H
+#define _FILES_H
+
+#include <string>
+
+//! verifie l'existance d'un fichier.
+bool exists( const std::string& filename );
+
+//! renvoie la date de la derniere modification d'un fichier
+size_t timestamp( const std::string& filename );
+
+/*! renvoie le chemin d'acces a un fichier. le chemin est toujours termine par /
+ pathname("path\to\file") == "path/to/"
+ pathname("path\to/file") == "path/to/"
+ pathname("path/to/file") == "path/to/"
+ pathname("file") == "./"
+ */
+std::string pathname( const std::string& filename );
+
+//! remplace tous les separateurs par / (linux) ou \ (windows)
+std::string normalize_filename( const std::string& filename );
+
+/*! renvoie un nom de fichier relatif a un chemin.
+ relative_pathname("textures/base.png", "textures") == "base.png"
+ relative_pathname("base.png", "textures") == "base.png"
+*/
+std::string relative_filename( const std::string& filename, const std::string& path );
+
+std::string absolute_filename( const std::string& path, const std::string& filename );
+
+#endif
diff --git a/code/src/gltf/brdf.h b/code/src/gltf/brdf.h
new file mode 100644
index 0000000..39de72f
--- /dev/null
+++ b/code/src/gltf/brdf.h
@@ -0,0 +1,214 @@
+
+#pragma once
+
+#include "fresnel.h"
+
+// cf "generating a consistently oriented tangent space"
+// http://people.compute.dtu.dk/jerf/papers/abstracts/onb.html
+// cf "Building an Orthonormal Basis, Revisited", Pixar, 2017
+// http://jcgt.org/published/0006/01/01/
+struct World
+{
+ World( ) : t(), b(), n() {}
+ World( const Vector& _n ) : n(_n)
+ {
+ float sign= std::copysign(1.0f, n.z);
+ float a= -1.0f / (sign + n.z);
+ float d= n.x * n.y * a;
+ t= Vector(1.0f + sign * n.x * n.x * a, sign * d, -sign * n.x);
+ b= Vector(d, sign + n.y * n.y * a, -n.y);
+ }
+
+ // transforme le vecteur du repere local vers le repere du monde
+ Vector operator( ) ( const Vector& local ) const { return local.x * t + local.y * b + local.z * n; }
+
+ // transforme le vecteur du repere du monde vers le repere local
+ Vector local( const Vector& global ) const { return Vector(dot(global, t), dot(global, b), dot(global, n)); }
+
+ Vector t;
+ Vector b;
+ Vector n;
+};
+
+
+struct Brdf
+{
+ World world;
+ Color diffuse;
+ Color F0;
+ float metallic;
+ float alpha;
+
+ Brdf( ) = default;
+
+ // opaque
+ Brdf( const Vector& ng, const Color& _color, const float _metallic, const float _roughness ) : world(ng),
+ diffuse( (1 - _metallic) * _color ),
+ F0( (1 - _metallic) * Color(0.04) + _metallic * _color ),
+ metallic(_metallic), alpha(_roughness*_roughness)
+ {}
+
+ Color f( const Vector& l, const Vector& o ) const
+ {
+ Vector h= normalize(o + l);
+ float ndoth= std::max(float(0), dot(world.n, h));
+
+ float ndotl= std::max(float(0), dot(world.n, l));
+ float ndoto= std::max(float(0), dot(world.n, o));
+
+ // meme hemisphere
+ if(ndoto <= 0 || ndoth <= 0 || ndotl <= 0)
+ return Black();
+ float hdoto= dot(o, h);
+ float hdotl= dot(l, h);
+ if(hdoto <= 0 || hdotl <= 0)
+ return Black();
+
+ float D= ggx_d( alpha, ndoth);
+ float G2= smith_g2( alpha, ndotl, ndoto);
+ Color F= schlick_fresnel( F0, hdotl );
+
+ // brdf
+ Color fr_m= (F * D * G2) / (4 * ndoto * ndotl);
+
+ //~ Color disney_diffuse= diffuse / float(M_PI) * (1 - std::pow(1 - ndotl, 5) / 2) * (1 - std::pow(1 - ndoto, 5) / 2);
+ Color disney_diffuse= diffuse / float(M_PI);
+ Color fr_d= (Color(1) - F) * disney_diffuse + (F * D * G2) / (4 * ndoto * ndotl);
+ Color fr= (1 - metallic) * fr_d + metallic * fr_m;
+
+ return fr;
+ }
+
+ Vector sample( const float u1, const float u2, const float u3, const Vector& o ) const
+ {
+ float ndoto= dot(world.n, o);
+ if(ndoto <= 0)
+ return Vector();
+
+ // evalue le fresnel dans la direction miroir pour choisir le lobe....
+ //~ float f= schlick_fresnel(F0, ndoto).max();
+ float f= 0;
+ if(u1 < f)
+ {
+ // genere une direction ~ cos theta / pi
+ float phi= float(2*M_PI) * u2;
+ //~ float cos_theta= std::sqrt(u3);
+ float cos_theta= u3; // 1 / 2pi
+ float sin_theta= std::sqrt(1 - std::min(float(1.0), cos_theta*cos_theta));
+ return world( Vector(std::cos(phi) * sin_theta, std::sin(phi) * sin_theta, cos_theta) );
+ }
+ else
+ {
+ // genere une direction ~ D
+ //~ float walter_alpha= (float(1.2) - float(0.2)*std::sqrt(ndoto)) * alpha;
+ //~ Vector h= world( ggx_sample( walter_alpha, u2, u3 ) );
+ //~ Vector h= world( ggx_sample( alpha, u2, u3 ) ); // walter
+
+ Vector h= world( vndf_sample( world.local(o), alpha, u2, u3 ) ); // dupuy vndf sampling
+ // construit la direction reflechie
+ return reflect(o, h);
+ }
+ }
+
+ float pdf( const Vector& l, const Vector& o ) const
+ {
+ float ndotl= std::max(float(0), dot(world.n, l));
+ float ndoto= std::max(float(0), dot(world.n, o));
+ if(ndoto <= 0 || ndotl <= 0)
+ return 0;
+
+ Vector h= normalize(o + l);
+ float ndoth= std::max(float(0), dot(world.n, h));
+ float hdoto= dot(o, h);
+ float hdotl= dot(l, h);
+ if(ndoth <= 0 || hdoto <= 0 || hdotl <= 0)
+ return 0;
+
+ //~ float f= schlick_fresnel(F0, ndoto).max();
+ float f= 0;
+ float d= 1 / float(2*M_PI); // ndotl / float(M_PI);
+ //~ float m= ggx_d(alpha, ndoth) * ndoth / hdoto / 4; // walter weight, cf ggx_sample()
+ float m= ggx_d(alpha, ndoth) * smith_g1(alpha, ndoth) / (4 * ndoto); // dupuy weight, cd vndf_sample()
+
+ return (1 - f)*d + f*m;
+ }
+
+protected:
+ float ggx_d( const float alpha, const float cos_theta ) const
+ {
+ assert(cos_theta > 0);
+ float d= alpha / (1 + cos_theta*cos_theta * (alpha*alpha - 1));
+ return d*d / float(M_PI);
+ }
+
+ float smith_g1( const float alpha, const float cos_theta ) const
+ {
+ return 1 / (1 + ggx_lambda(alpha, cos_theta));
+ }
+
+ float smith_g2( const float alpha, const float cos_theta, const float cos_theta_o ) const
+ {
+ return 1 / (1 + ggx_lambda(alpha, cos_theta) + ggx_lambda(alpha, cos_theta_o));
+ }
+
+ float ggx_lambda( const float alpha, const float cos_theta ) const
+ {
+ assert(cos_theta > 0);
+ float cos2_theta= cos_theta * cos_theta;
+ float tan2_theta= std::max(float(0), 1 - cos2_theta) / cos2_theta;
+ return (std::sqrt(1 + alpha*alpha * tan2_theta) -1) / 2;
+ }
+
+ // from "Microfacet Models for Refraction through Rough Surfaces", walter 2007
+ // cf https://www.graphics.cornell.edu/~bjw/microfacetbsdf.pdf
+ Vector ggx_sample( const float alpha, const float u1, const float u2 ) const
+ {
+ float theta= std::atan( alpha * std::sqrt(u1) / std::sqrt(1 - u1) );
+ float sin_theta= std::sin(theta);
+ float cos_theta= std::cos(theta);
+
+ float phi= u2 * float(2*M_PI);
+ return Vector(std::cos(phi) * sin_theta, std::sin(phi) * sin_theta, cos_theta);
+ }
+
+ // from "Sampling Visible GGX Normals with Spherical Caps", dupuy 2023
+ // cf https://arxiv.org/pdf/2306.05044.pdf
+
+ // Sample the GGX VNDF
+ Vector vndf_sample( const Vector& wi, const float alpha, const float u1, const float u2 ) const
+ {
+ // warp to the hemisphere configuration
+ Vector wi_std = normalize(Vector(wi.x * alpha, wi.y * alpha, wi.z));
+ // sample the hemisphere
+ Vector wm_std = sample_vndf_hemisphere(wi_std, u1, u2);
+ // warp back to the ellipsoid configuration
+ Vector wm = normalize(Vector(wm_std.x * alpha, wm_std.y * alpha, wm_std.z));
+ // return final normal
+ return wm;
+ }
+
+ // Helper function: sample the visible hemisphere from a spherical cap
+ Vector sample_vndf_hemisphere( const Vector& wi, const float u1, const float u2 ) const
+ {
+ // sample a spherical cap in (-wi.z, 1]
+ float phi = u1 * float(2*M_PI);
+ // float z = fma((1.0f - u.y), (1.0f + wi.z), -wi.z);
+ float z = 1 - u2 - u2 * wi.z;
+ float sin_theta = std::sqrt(clamp(1 - z*z, 0, 1));
+ float x = sin_theta * std::cos(phi);
+ float y = sin_theta * std::sin(phi);
+ Vector c = Vector(x, y, z);
+ // compute halfway direction;
+ Vector h = c + wi;
+ // return without normalization as this is done later (see line 25)
+ return h;
+ }
+
+ float clamp( const float x, const float xmin, const float xmax ) const
+ {
+ if(x < xmin) return xmin;
+ if(x > xmax) return xmax;
+ return x;
+ }
+};
+
diff --git a/code/src/gltf/bvh.h b/code/src/gltf/bvh.h
new file mode 100644
index 0000000..088a0da
--- /dev/null
+++ b/code/src/gltf/bvh.h
@@ -0,0 +1,675 @@
+
+#pragma once
+
+#include <cfloat>
+#include <climits>
+#include <chrono>
+#include <algorithm>
+
+#include "gltf.h"
+
+
+// intersection avec un triangle
+struct Hit
+{
+ float t; //!< p(t)= o + td, position du point d'intersection sur le rayon
+ float u, v; //!< p(u, v), position du point d'intersection sur le triangle
+ int node_id; //!< indexation dans une scene gltf
+ int mesh_id;
+ int primitive_id;
+ int triangle_id;
+
+ Hit( ) : t(FLT_MAX), u(), v(), node_id(-1), mesh_id(-1), primitive_id(-1), triangle_id(-1) {}
+
+ Hit( const float _t, const float _u, const float _v, const int _node_id, const int _mesh_id, const int _primitive_id, const int _id ) : t(_t), u(_u), v(_v),
+ node_id(_node_id), mesh_id(_mesh_id), primitive_id(_primitive_id), triangle_id(_id) {}
+
+ operator bool ( ) const { return (triangle_id != -1); } // renvoie vrai si l'intersection est definie / existe
+};
+
+
+// intersection avec une boite englobante
+struct BBoxHit
+{
+ float tmin, tmax;
+
+ BBoxHit() : tmin(FLT_MAX), tmax(-FLT_MAX) {}
+ BBoxHit( const float _tmin, const float _tmax ) : tmin(_tmin), tmax(_tmax) {}
+
+ operator bool( ) const { return tmin <= tmax; } // renvoie vrai si l'intersection est definie / existe
+};
+
+
+// rayon
+struct Ray
+{
+ Point o; //!< origine
+ Vector d; //!< direction
+ float tmax; //!< tmax= 1 ou \inf, le rayon est un segment ou une demi droite infinie
+
+ Ray( const Point& _o, const Point& _e ) : o(_o), d(Vector(_o, _e)), tmax(1) {} // segment, t entre 0 et 1
+ Ray( const Point& _o, const Vector& _d ) : o(_o), d(_d), tmax(FLT_MAX) {} // demi droite, t entre 0 et \inf
+ Ray( const Point& _o, const Vector& _d, const float _tmax ) : o(_o), d(_d), tmax(_tmax) {} // explicite
+
+ Point operator() ( const Hit& hit ) const { assert(bool(hit)); return o + hit.t * d; }
+};
+
+
+// boite englobante
+struct BBox
+{
+ Point pmin, pmax;
+
+ BBox( ) : pmin(), pmax() {}
+
+ explicit BBox( const Point& p ) : pmin(p), pmax(p) {}
+ BBox( const Point& a, const Point& b ) : pmin(a), pmax(b) {}
+
+ BBox( const BBox& box ) : pmin(box.pmin), pmax(box.pmax) {}
+ BBox( const BBox& a, const BBox& b ) : pmin(min(a.pmin, b.pmin)), pmax(max(a.pmax, b.pmax)) {}
+
+ BBox& operator= ( const BBox& box ) { pmin= box.pmin; pmax= box.pmax; return *this; }
+
+ BBox& insert( const Point& p ) { pmin= min(pmin, p); pmax= max(pmax, p); return *this; }
+ BBox& insert( const BBox& box ) { pmin= min(pmin, box.pmin); pmax= max(pmax, box.pmax); return *this; }
+
+ float centroid( const int axis ) const { return (pmin(axis) + pmax(axis)) / 2; }
+ Point centroid( ) const { return (pmin + pmax) / 2; }
+
+ BBoxHit intersect( const Ray& ray, const Vector& invd, const float htmax ) const
+ {
+ Point rmin= pmin;
+ Point rmax= pmax;
+ if(ray.d.x < 0) std::swap(rmin.x, rmax.x);
+ if(ray.d.y < 0) std::swap(rmin.y, rmax.y);
+ if(ray.d.z < 0) std::swap(rmin.z, rmax.z);
+ Vector dmin= (rmin - ray.o) * invd;
+ Vector dmax= (rmax - ray.o) * invd;
+
+ float tmin= std::max(dmin.z, std::max(dmin.y, std::max(dmin.x, 0.f)));
+ float tmax= std::min(dmax.z, std::min(dmax.y, std::min(dmax.x, htmax)));
+ return BBoxHit(tmin, tmax);
+ }
+
+ bool empty( ) const { return (pmin.x >= pmax.x && pmin.y >= pmax.y && pmin.z >= pmax.z); }
+
+ float area( ) const
+ {
+ if(empty()) return 0;
+
+ Vector d(pmin, pmax);
+ return 2 * (d.x*d.y + d.x*d.z + d.y*d.z);
+ }
+};
+
+static inline
+BBox EmptyBox( ) { return BBox( Point(FLT_MAX, FLT_MAX, FLT_MAX), Point(-FLT_MAX, -FLT_MAX, -FLT_MAX) ); }
+
+
+
+// triangle pour le bvh, cf fonction bounds() et intersect()
+struct Triangle
+{
+ Point p; //!< sommet a du triangle
+ Vector e1, e2; //!< aretes ab, ac du triangle
+ int node_id; //!< indexation dans une scene gltf
+ int mesh_id;
+ int primitive_id;
+ int triangle_id;
+
+ Triangle() {}
+
+ Triangle( const vec3& a, const vec3& b, const vec3& c, const int _node_id, const int _mesh_id, const int _primitive_id, const int _id ) :
+ p(a), e1(Vector(a, b)), e2(Vector(a, c)),
+ node_id(_node_id), mesh_id(_mesh_id), primitive_id(_primitive_id), triangle_id(_id) {}
+
+ /* calcule l'intersection ray/triangle
+ cf "fast, minimum storage ray-triangle intersection"
+
+ renvoie faux s'il n'y a pas d'intersection valide (une intersection peut exister mais peut ne pas se trouver dans l'intervalle [0 tmax] du rayon.)
+ renvoie vrai + les coordonnees barycentriques (u, v) du point d'intersection + sa position le long du rayon (t).
+ convention barycentrique : p(u, v)= (1 - u - v) * a + u * b + v * c
+ */
+ Hit intersect( const Ray &ray, const float htmax ) const
+ {
+ Vector pvec= cross(ray.d, e2);
+ float det= dot(e1, pvec);
+
+ float inv_det= 1 / det;
+ Vector tvec(p, ray.o);
+
+ float u= dot(tvec, pvec) * inv_det;
+ if(u < 0 || u > 1) return Hit();
+
+ Vector qvec= cross(tvec, e1);
+ float v= dot(ray.d, qvec) * inv_det;
+ if(v < 0 || u + v > 1) return Hit();
+
+ float t= dot(e2, qvec) * inv_det;
+ if(t < 0 || t > htmax) return Hit();
+
+ return Hit(t, u, v, node_id, mesh_id, primitive_id, triangle_id);
+ }
+
+ BBox bounds( ) const
+ {
+ BBox box(p);
+ return box.insert(p+e1).insert(p+e2);
+ }
+};
+
+
+// construction de l'arbre / BVH
+struct Node
+{
+ BBox bounds;
+ int left;
+ int right;
+
+ bool internal( ) const { return right > 0; } // renvoie vrai si le noeud est un noeud interne
+ int internal_left( ) const { assert(internal()); return left; } // renvoie le fils gauche du noeud interne
+ int internal_right( ) const { assert(internal()); return right; } // renvoie le fils droit
+
+ bool leaf( ) const { return right < 0; } // renvoie vrai si le noeud est une feuille
+ int leaf_begin( ) const { assert(leaf()); return -left; } // renvoie le premier objet de la feuille
+ int leaf_end( ) const { assert(leaf()); return -right; } // renvoie le dernier objet
+};
+
+// creation d'un noeud interne
+static inline
+Node make_node( const BBox& bounds, const int left, const int right )
+{
+ Node node { bounds, left, right };
+ assert(node.internal()); // verifie que c'est bien un noeud...
+ return node;
+}
+
+// creation d'une feuille
+static inline
+Node make_leaf( const BBox& bounds, const int begin, const int end )
+{
+ Node node { bounds, -begin, -end };
+ assert(node.leaf()); // verifie que c'est bien une feuille...
+ return node;
+}
+
+
+struct BVH
+{
+ std::vector<Node> nodes;
+ std::vector<Triangle> triangles;
+ int root;
+
+ struct Primitive
+ {
+ BBox bounds;
+ Point centroid;
+ unsigned id;
+ };
+ std::vector<Primitive> primitives;
+
+ int nodes_count;
+
+ // construit un bvh pour l'ensemble de triangles
+ int build( const std::vector<Triangle>& _triangles )
+ {
+ primitives.clear();
+ triangles.clear();
+ primitives.reserve(_triangles.size());
+ triangles.reserve(_triangles.size());
+
+ nodes.resize(_triangles.size()*2);
+ root= 0;
+ nodes_count= 2;
+
+ for(unsigned i= 0; i < _triangles.size(); i++)
+ {
+ BBox bounds= _triangles[i].bounds();
+ primitives.push_back( { bounds, bounds.centroid(), i } );
+ }
+
+ auto start= std::chrono::high_resolution_clock::now();
+ {
+ //~ build(root, 0, primitives.size()); // decoupe l'axe le plus long de l'englobant
+ build_bins(root, 0, primitives.size()); // binned sah
+ }
+ auto stop= std::chrono::high_resolution_clock::now();
+ int cpu= std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count();
+ printf("BVH %dms, %lu triangles\n", cpu, primitives.size());
+
+ // re-organise les triangles
+ for(unsigned i= 0; i < primitives.size(); i++)
+ triangles.push_back(_triangles[primitives[i].id]);
+
+ // nettoyage
+ std::vector<Primitive>().swap(primitives);
+ return root;
+ }
+
+ Hit intersect( const Ray& ray ) const
+ {
+ Hit hit;
+ hit.t= ray.tmax;
+ Vector invd= Vector(1 / ray.d.x, 1 / ray.d.y, 1 / ray.d.z);
+
+ intersect(root, ray, invd, hit);
+ return hit;
+ }
+
+ bool visible( const Point& p, const Point& q ) const
+ {
+ Ray ray(p, q);
+ Vector invd= Vector(1 / ray.d.x, 1 / ray.d.y, 1 / ray.d.z);
+ return !occluded(root, ray, invd);
+ }
+
+ bool visible( const Point& p, const Vector& v ) const
+ {
+ Ray ray(p, v);
+ Vector invd= Vector(1 / ray.d.x, 1 / ray.d.y, 1 / ray.d.z);
+ return !occluded(root, ray, invd);
+ }
+
+ template < typename HitFilter >
+ Hit intersect( const Ray& ray, const HitFilter& isvalid ) const
+ {
+ Hit hit;
+ hit.t= ray.tmax;
+ Vector invd= Vector(1 / ray.d.x, 1 / ray.d.y, 1 / ray.d.z);
+
+ intersect(root, isvalid, ray, invd, hit);
+ return hit;
+ }
+
+ template < typename HitFilter >
+ bool visible( const Point& p, const Point& q, const HitFilter& isvalid ) const
+ {
+ Ray ray(p, q);
+ Vector invd= Vector(1 / ray.d.x, 1 / ray.d.y, 1 / ray.d.z);
+ return !occluded(root, isvalid, ray, invd);
+ }
+
+protected:
+ // construction d'un noeud, decoupe l'axe le plus long de l'englobant
+ void build( const unsigned index, const int begin, const int end )
+ {
+ assert(index < nodes.size());
+
+ BBox bounds= triangle_bounds(begin, end);
+ if(end - begin < 2)
+ {
+ // inserer une feuille et renvoyer son indice
+ nodes[index]= make_leaf(bounds, begin, end);
+ return;
+ }
+
+ // axe le plus etire de l'englobant
+ BBox cbounds= centroid_bounds(begin, end);
+ Vector d= Vector(cbounds.pmin, cbounds.pmax);
+ int axis;
+ if(d.x > d.y && d.x > d.z) // x plus grand que y et z ?
+ axis= 0;
+ else if(d.y > d.z) // y plus grand que z ? (et que x implicitement)
+ axis= 1;
+ else // x et y ne sont pas les plus grands...
+ axis= 2;
+
+ // coupe l'englobant au milieu
+ float cut= cbounds.centroid(axis);
+
+ // repartit les primitives
+ Primitive *pm= std::partition( primitives.data() + begin, primitives.data() + end,
+ [axis, cut]( const Primitive& primitive ) { return primitive.centroid(axis) < cut; } );
+ int m= std::distance(primitives.data(), pm);
+
+ // la repartition des triangles peut echouer, et tous les triangles sont dans la meme partie...
+ // forcer quand meme un decoupage en 2 ensembles
+ if(m == begin || m == end)
+ m= (begin + end) / 2;
+ assert(m != begin);
+ assert(m != end);
+
+ #if 1
+ if(end - begin < 32)
+ {
+ BBox bounds_left= triangle_bounds(begin, m);
+ BBox bounds_right= triangle_bounds(m, end);
+
+ float area= bounds.area();
+ float leaf_cost= (end - begin);
+ float left_cost= bounds_left.area() * (m - begin) / area;
+ float right_cost= bounds_right.area() * (end - m) / area;
+ if(left_cost + right_cost + 1 > leaf_cost)
+ // +8 equilibre le cout de parcours des noeuds vs le cout de parcours des feuilles (temps d'intersection rayon / triangles),
+ /*
+ +1 construit un arbre le plus profond possible pour essayer de separer au mieux les triangles (ie les noeuds sont rapides a parcourir)
+ ou avec +2, +4, +6, +8, etc. les noeuds sont plus long a parcourir et l'arbre devient naturellement moins profond avec plus de triangles par feuille...
+ */
+ {
+ // transforme le noeud en feuille !! construire le noeud n'est pas interressant...
+ nodes[index]= make_leaf(bounds, begin, end);
+ return;
+ }
+ }
+ #endif
+
+ int left_index= nodes_count;
+ int right_index= left_index+1;
+ nodes_count+= 2;
+
+ nodes[index]= make_node(bounds, left_index, right_index);
+
+ // construire le fils gauche
+ // les triangles se trouvent dans [begin .. m)
+ build(left_index, begin, m);
+
+ // on recommence pour le fils droit
+ // les triangles se trouvent dans [m .. end)
+ build(right_index, m, end);
+ }
+
+
+ struct Bin
+ {
+ BBox bounds;
+ int n;
+
+ Bin( ) : bounds(EmptyBox()), n(0) {}
+ };
+
+ // construction d'un noeud, binned sah
+ void build_bins( const unsigned index, const int begin, const int end )
+ {
+ assert(index < nodes.size());
+
+ if(end - begin < 2)
+ {
+ // il ne reste plus q'une seule primitive, creer une feuille et renvoyer son indice
+ nodes[index]= make_leaf( triangle_bounds(begin, end), begin, end );
+ return;
+ }
+
+ BBox cbounds= centroid_bounds(begin, end);
+ Vector d= Vector(cbounds.pmin, cbounds.pmax);
+ Vector invd= Vector(d.x ? 1 / d.x : 0, d.y ? 1 / d.y : 0, d.z ? 1 / d.z : 0);
+
+ constexpr int bins_max= 16;
+ Bin bins[bins_max][3];
+
+ // repartition de toutes les primitives
+ for(int i= begin; i < end; i++)
+ for(int axis= 0; axis < 3; axis++)
+ {
+ int b= (primitives[i].centroid(axis) - cbounds.pmin(axis)) * invd(axis) * bins_max;
+ if(b < 0) b= 0;
+ else if(b >= bins_max) b= bins_max -1;
+
+ bins[b][axis].bounds.insert(primitives[i].bounds);
+ bins[b][axis].n++;
+ }
+
+ // calcule le cout de chaque repartition
+ Bin left[3];
+ Bin primitives_left[bins_max][3];
+ for(int i= 0; i < bins_max; i++)
+ for(int axis= 0; axis < 3; axis++)
+ {
+ left[axis].bounds.insert(bins[i][axis].bounds);
+ left[axis].n+= bins[i][axis].n;
+ primitives_left[i][axis].bounds= left[axis].bounds;
+ primitives_left[i][axis].n= left[axis].n;
+ }
+
+ Bin right[3];
+ Bin primitives_right[bins_max][3];
+ for(int i= bins_max -1; i >= 0; i--)
+ for(int axis= 0; axis < 3; axis++)
+ {
+ right[axis].bounds.insert(bins[i][axis].bounds);
+ right[axis].n+= bins[i][axis].n;
+ primitives_right[i][axis].bounds= right[axis].bounds;
+ primitives_right[i][axis].n= right[axis].n;
+ }
+
+ // evalue le cout des fils
+ float cost_min= FLT_MAX;
+ int cost_index= -1;
+ int cost_axis= -1;
+
+ for(int i= 0; i < bins_max -1; i++)
+ for(int axis= 0; axis < 3; axis++)
+ {
+ // n'evalue pas la partie constante du cout...
+ float cost= primitives_left[i][axis].bounds.area() * primitives_left[i][axis].n + primitives_right[i+1][axis].bounds.area() * primitives_right[i+1][axis].n;
+
+ if(cost < cost_min)
+ {
+ cost_min=cost;
+ cost_axis= axis;
+ cost_index= i;
+ }
+ }
+
+ int m= begin;
+ if(cost_index != -1)
+ {
+ Primitive *pm= std::partition( primitives.data() + begin, primitives.data() + end,
+ [cost_axis, cost_index, cbounds, invd]( const Primitive &primitive )
+ {
+ int b= (primitive.centroid(cost_axis) - cbounds.pmin(cost_axis)) * invd(cost_axis) * bins_max;
+ if(b < 0) b= 0;
+ else if(b >= bins_max) b= bins_max -1;
+ return b <= cost_index;
+ }
+ );
+ m= std::distance(primitives.data(), pm);
+ }
+
+ // la repartition des triangles peut echouer, et tous les triangles sont dans la meme partie...
+ // forcer quand meme un decoupage en 2 ensembles
+ if(m == begin || m == end)
+ m= (begin + end) / 2;
+ assert(m != begin);
+ assert(m != end);
+
+ // construire le noeud
+ BBox bounds= EmptyBox(); // englobant du noeud, plus rapide en calculant l'union des bins...
+ for(int i= 0; i < bins_max; i++)
+ if(bins[i][0].n)
+ bounds.insert(bins[i][0].bounds);
+
+ #if 1
+ if(end - begin < 32)
+ {
+ const BBox& bounds_left= primitives_left[cost_index][cost_axis].bounds;
+ const BBox& bounds_right= primitives_right[cost_index+1][cost_axis].bounds;
+
+ float invarea= 1 / bounds.area();
+ float leaf_cost= (end - begin);
+ float left_cost= bounds_left.area() * (m - begin) * invarea;
+ float right_cost= bounds_right.area() * (end - m) *invarea;
+ if(left_cost + right_cost + 1 > leaf_cost)
+ {
+ // transforme le noeud en feuille !! construire le noeud n'est pas interressant...
+ nodes[index]= make_leaf(bounds, begin, end);
+ return;
+ /* +1 construit un arbre le plus profond possible pour essayer de separer au mieux les triangles (ie les noeuds sont rapides a parcourir)
+ ou avec +2, +4, +6, +8, etc. les noeuds sont plus long a parcourir et l'arbre devient naturellement moins profond avec plus de triangles par feuille...
+
+ +8 equilibre le cout de parcours des noeuds vs le cout de parcours des feuilles (temps d'intersection rayon / triangles),
+ */
+ }
+ }
+ #endif
+
+ int left_index= nodes_count;
+ int right_index= left_index+1;
+ nodes_count+= 2;
+
+ nodes[index]= make_node(bounds, left_index, right_index);
+
+ // construire le fils gauche
+ // les triangles se trouvent dans [begin .. m)
+ build_bins(left_index, begin, m);
+
+ // on recommence pour le fils droit
+ // les triangles se trouvent dans [m .. end)
+ build_bins(right_index, m, end);
+ }
+
+ BBox triangle_bounds( const int begin, const int end )
+ {
+ BBox bbox= primitives[begin].bounds;
+ for(int i= begin +1; i < end; i++)
+ bbox.insert(primitives[i].bounds);
+
+ return bbox;
+ }
+
+ BBox centroid_bounds( const int begin, const int end )
+ {
+ BBox bbox= BBox(primitives[begin].centroid);
+ for(int i= begin +1; i < end; i++)
+ bbox.insert(primitives[i].centroid);
+
+ return bbox;
+ }
+
+ void intersect( const int index, const Ray& ray, const Vector& invd, Hit& hit ) const
+ {
+ const Node& node= nodes[index];
+ if(node.leaf())
+ {
+ for(int i= node.leaf_begin(); i < node.leaf_end(); i++)
+ if(Hit h= triangles[i].intersect(ray, hit.t))
+ hit= h;
+ }
+ else // if(node.internal())
+ {
+ const Node& left_node= nodes[node.left];
+ const Node& right_node= nodes[node.right];
+
+ BBoxHit left= left_node.bounds.intersect(ray, invd, hit.t);
+ BBoxHit right= right_node.bounds.intersect(ray, invd, hit.t);
+ if(left && right) // les 2 fils sont touches par le rayon...
+ {
+ if(left.tmin < right.tmin) // parcours de gauche a droite
+ {
+ intersect(node.internal_left(), ray, invd, hit);
+ intersect(node.internal_right(), ray, invd, hit);
+ }
+ else // parcours de droite a gauche
+ {
+ intersect(node.internal_right(), ray, invd, hit);
+ intersect(node.internal_left(), ray, invd, hit);
+ }
+ }
+ else if(left) // uniquement le fils gauche
+ intersect(node.internal_left(), ray, invd, hit);
+ else if(right)
+ intersect(node.internal_right(), ray, invd, hit); // uniquement le fils droit
+ }
+ }
+
+
+ bool occluded( const int index, const Ray& ray, const Vector& invd ) const
+ {
+ const Node& node= nodes[index];
+ if(node.bounds.intersect(ray, invd, ray.tmax))
+ {
+ if(node.leaf())
+ {
+ for(int i= node.leaf_begin(); i < node.leaf_end(); i++)
+ if(triangles[i].intersect(ray, ray.tmax))
+ return true;
+ }
+ else // if(node.internal())
+ {
+ if(occluded(node.internal_left(), ray, invd) || occluded(node.internal_right(), ray, invd))
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+
+ template< typename HitFilter >
+ void intersect( const int index, const HitFilter& isvalid, const Ray& ray, const Vector& invd, Hit& hit ) const
+ {
+ const Node& node= nodes[index];
+ if(node.leaf())
+ {
+ for(int i= node.leaf_begin(); i < node.leaf_end(); i++)
+ {
+ Hit h= triangles[i].intersect(ray, hit.t);
+ if(h && isvalid(h))
+ hit= h;
+ }
+ }
+ else // if(node.internal())
+ {
+ const Node& left_node= nodes[node.left];
+ const Node& right_node= nodes[node.right];
+
+ BBoxHit left= left_node.bounds.intersect(ray, invd, hit.t);
+ BBoxHit right= right_node.bounds.intersect(ray, invd, hit.t);
+ if(left && right) // les 2 fils sont touches par le rayon...
+ {
+ if(left.tmin < right.tmin) // parcours de gauche a droite
+ {
+ intersect(node.internal_left(), isvalid, ray, invd, hit);
+ intersect(node.internal_right(), isvalid, ray, invd, hit);
+ }
+ else // parcours de droite a gauche
+ {
+ intersect(node.internal_right(), isvalid, ray, invd, hit);
+ intersect(node.internal_left(), isvalid, ray, invd, hit);
+ }
+ }
+ else if(left) // uniquement le fils gauche
+ intersect(node.internal_left(), isvalid, ray, invd, hit);
+ else if(right)
+ intersect(node.internal_right(), isvalid, ray, invd, hit); // uniquement le fils droit
+ }
+ }
+
+ template< typename HitFilter >
+ bool occluded( const int index, const HitFilter& isvalid, const Ray& ray, const Vector& invd ) const
+ {
+ const Node& node= nodes[index];
+ if(node.bounds.intersect(ray, invd, ray.tmax))
+ {
+ if(node.leaf())
+ {
+ for(int i= node.leaf_begin(); i < node.leaf_end(); i++)
+ {
+ Hit h= triangles[i].intersect(ray, ray.tmax);
+ if(h && isvalid(h))
+ return true;
+ }
+ }
+ else // if(node.internal())
+ {
+ if(occluded(node.internal_left(), isvalid, ray, invd) || occluded(node.internal_right(), isvalid, ray, invd))
+ return true;
+ }
+ }
+
+ return false;
+ }
+};
+
+
+//!< decale un point le long de la normale, evite l'auto intersection / ombrage...
+//!< cf https://perso.univ-lyon1.fr/jean-claude.iehl/Public/educ/M1IMAGE/html/group__precision.html
+static inline
+Point offset_point( const Point& p, const Vector& pn )
+{
+ // evalue l'epsilon relatif du point d'intersection
+ float pmax= std::max(std::abs(p.x), std::max(std::abs(p.y), std::abs(p.z)));
+ float pe= pmax * FLT_EPSILON;
+
+ // *32 pour tenir compte des autres approximations / erreurs de calculs
+ return p + 32*pe*pn;
+}
diff --git a/code/src/gltf/cgltf.cpp b/code/src/gltf/cgltf.cpp
new file mode 100644
index 0000000..bfc04aa
--- /dev/null
+++ b/code/src/gltf/cgltf.cpp
@@ -0,0 +1,4 @@
+
+#define CGLTF_IMPLEMENTATION
+#include "cgltf.h"
+
diff --git a/code/src/gltf/cgltf.h b/code/src/gltf/cgltf.h
new file mode 100644
index 0000000..f69ad77
--- /dev/null
+++ b/code/src/gltf/cgltf.h
@@ -0,0 +1,6695 @@
+/**
+ * cgltf - a single-file glTF 2.0 parser written in C99.
+ *
+ * Version: 1.12
+ *
+ * Website: https://github.com/jkuhlmann/cgltf
+ *
+ * Distributed under the MIT License, see notice at the end of this file.
+ *
+ * Building:
+ * Include this file where you need the struct and function
+ * declarations. Have exactly one source file where you define
+ * `CGLTF_IMPLEMENTATION` before including this file to get the
+ * function definitions.
+ *
+ * Reference:
+ * `cgltf_result cgltf_parse(const cgltf_options*, const void*,
+ * cgltf_size, cgltf_data**)` parses both glTF and GLB data. If
+ * this function returns `cgltf_result_success`, you have to call
+ * `cgltf_free()` on the created `cgltf_data*` variable.
+ * Note that contents of external files for buffers and images are not
+ * automatically loaded. You'll need to read these files yourself using
+ * URIs in the `cgltf_data` structure.
+ *
+ * `cgltf_options` is the struct passed to `cgltf_parse()` to control
+ * parts of the parsing process. You can use it to force the file type
+ * and provide memory allocation as well as file operation callbacks.
+ * Should be zero-initialized to trigger default behavior.
+ *
+ * `cgltf_data` is the struct allocated and filled by `cgltf_parse()`.
+ * It generally mirrors the glTF format as described by the spec (see
+ * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0).
+ *
+ * `void cgltf_free(cgltf_data*)` frees the allocated `cgltf_data`
+ * variable.
+ *
+ * `cgltf_result cgltf_load_buffers(const cgltf_options*, cgltf_data*,
+ * const char* gltf_path)` can be optionally called to open and read buffer
+ * files using the `FILE*` APIs. The `gltf_path` argument is the path to
+ * the original glTF file, which allows the parser to resolve the path to
+ * buffer files.
+ *
+ * `cgltf_result cgltf_load_buffer_base64(const cgltf_options* options,
+ * cgltf_size size, const char* base64, void** out_data)` decodes
+ * base64-encoded data content. Used internally by `cgltf_load_buffers()`.
+ * This is useful when decoding data URIs in images.
+ *
+ * `cgltf_result cgltf_parse_file(const cgltf_options* options, const
+ * char* path, cgltf_data** out_data)` can be used to open the given
+ * file using `FILE*` APIs and parse the data using `cgltf_parse()`.
+ *
+ * `cgltf_result cgltf_validate(cgltf_data*)` can be used to do additional
+ * checks to make sure the parsed glTF data is valid.
+ *
+ * `cgltf_node_transform_local` converts the translation / rotation / scale properties of a node
+ * into a mat4.
+ *
+ * `cgltf_node_transform_world` calls `cgltf_node_transform_local` on every ancestor in order
+ * to compute the root-to-node transformation.
+ *
+ * `cgltf_accessor_unpack_floats` reads in the data from an accessor, applies sparse data (if any),
+ * and converts them to floating point. Assumes that `cgltf_load_buffers` has already been called.
+ * By passing null for the output pointer, users can find out how many floats are required in the
+ * output buffer.
+ *
+ * `cgltf_accessor_num_components` is a tiny utility that tells you the dimensionality of
+ * a certain accessor type. This can be used before `cgltf_accessor_unpack_floats` to help allocate
+ * the necessary amount of memory.
+ *
+ * `cgltf_accessor_read_float` reads a certain element from a non-sparse accessor and converts it to
+ * floating point, assuming that `cgltf_load_buffers` has already been called. The passed-in element
+ * size is the number of floats in the output buffer, which should be in the range [1, 16]. Returns
+ * false if the passed-in element_size is too small, or if the accessor is sparse.
+ *
+ * `cgltf_accessor_read_uint` is similar to its floating-point counterpart, but limited to reading
+ * vector types and does not support matrix types. The passed-in element size is the number of uints
+ * in the output buffer, which should be in the range [1, 4]. Returns false if the passed-in
+ * element_size is too small, or if the accessor is sparse.
+ *
+ * `cgltf_accessor_read_index` is similar to its floating-point counterpart, but it returns size_t
+ * and only works with single-component data types.
+ *
+ * `cgltf_result cgltf_copy_extras_json(const cgltf_data*, const cgltf_extras*,
+ * char* dest, cgltf_size* dest_size)` allows users to retrieve the "extras" data that
+ * can be attached to many glTF objects (which can be arbitrary JSON data). The
+ * `cgltf_extras` struct stores the offsets of the start and end of the extras JSON data
+ * as it appears in the complete glTF JSON data. This function copies the extras data
+ * into the provided buffer. If `dest` is NULL, the length of the data is written into
+ * `dest_size`. You can then parse this data using your own JSON parser
+ * or, if you've included the cgltf implementation using the integrated JSMN JSON parser.
+ */
+#ifndef CGLTF_H_INCLUDED__
+#define CGLTF_H_INCLUDED__
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef size_t cgltf_size;
+typedef float cgltf_float;
+typedef int cgltf_int;
+typedef unsigned int cgltf_uint;
+typedef int cgltf_bool;
+
+typedef enum cgltf_file_type
+{
+ cgltf_file_type_invalid,
+ cgltf_file_type_gltf,
+ cgltf_file_type_glb,
+} cgltf_file_type;
+
+typedef enum cgltf_result
+{
+ cgltf_result_success,
+ cgltf_result_data_too_short,
+ cgltf_result_unknown_format,
+ cgltf_result_invalid_json,
+ cgltf_result_invalid_gltf,
+ cgltf_result_invalid_options,
+ cgltf_result_file_not_found,
+ cgltf_result_io_error,
+ cgltf_result_out_of_memory,
+ cgltf_result_legacy_gltf,
+} cgltf_result;
+
+typedef struct cgltf_memory_options
+{
+ void* (*alloc)(void* user, cgltf_size size);
+ void (*free) (void* user, void* ptr);
+ void* user_data;
+} cgltf_memory_options;
+
+typedef struct cgltf_file_options
+{
+ cgltf_result(*read)(const struct cgltf_memory_options* memory_options, const struct cgltf_file_options* file_options, const char* path, cgltf_size* size, void** data);
+ void (*release)(const struct cgltf_memory_options* memory_options, const struct cgltf_file_options* file_options, void* data);
+ void* user_data;
+} cgltf_file_options;
+
+typedef struct cgltf_options
+{
+ cgltf_file_type type; /* invalid == auto detect */
+ cgltf_size json_token_count; /* 0 == auto */
+ cgltf_memory_options memory;
+ cgltf_file_options file;
+} cgltf_options;
+
+typedef enum cgltf_buffer_view_type
+{
+ cgltf_buffer_view_type_invalid,
+ cgltf_buffer_view_type_indices,
+ cgltf_buffer_view_type_vertices,
+} cgltf_buffer_view_type;
+
+typedef enum cgltf_attribute_type
+{
+ cgltf_attribute_type_invalid,
+ cgltf_attribute_type_position,
+ cgltf_attribute_type_normal,
+ cgltf_attribute_type_tangent,
+ cgltf_attribute_type_texcoord,
+ cgltf_attribute_type_color,
+ cgltf_attribute_type_joints,
+ cgltf_attribute_type_weights,
+} cgltf_attribute_type;
+
+typedef enum cgltf_component_type
+{
+ cgltf_component_type_invalid,
+ cgltf_component_type_r_8, /* BYTE */
+ cgltf_component_type_r_8u, /* UNSIGNED_BYTE */
+ cgltf_component_type_r_16, /* SHORT */
+ cgltf_component_type_r_16u, /* UNSIGNED_SHORT */
+ cgltf_component_type_r_32u, /* UNSIGNED_INT */
+ cgltf_component_type_r_32f, /* FLOAT */
+} cgltf_component_type;
+
+typedef enum cgltf_type
+{
+ cgltf_type_invalid,
+ cgltf_type_scalar,
+ cgltf_type_vec2,
+ cgltf_type_vec3,
+ cgltf_type_vec4,
+ cgltf_type_mat2,
+ cgltf_type_mat3,
+ cgltf_type_mat4,
+} cgltf_type;
+
+typedef enum cgltf_primitive_type
+{
+ cgltf_primitive_type_points,
+ cgltf_primitive_type_lines,
+ cgltf_primitive_type_line_loop,
+ cgltf_primitive_type_line_strip,
+ cgltf_primitive_type_triangles,
+ cgltf_primitive_type_triangle_strip,
+ cgltf_primitive_type_triangle_fan,
+} cgltf_primitive_type;
+
+typedef enum cgltf_alpha_mode
+{
+ cgltf_alpha_mode_opaque,
+ cgltf_alpha_mode_mask,
+ cgltf_alpha_mode_blend,
+} cgltf_alpha_mode;
+
+typedef enum cgltf_animation_path_type {
+ cgltf_animation_path_type_invalid,
+ cgltf_animation_path_type_translation,
+ cgltf_animation_path_type_rotation,
+ cgltf_animation_path_type_scale,
+ cgltf_animation_path_type_weights,
+} cgltf_animation_path_type;
+
+typedef enum cgltf_interpolation_type {
+ cgltf_interpolation_type_linear,
+ cgltf_interpolation_type_step,
+ cgltf_interpolation_type_cubic_spline,
+} cgltf_interpolation_type;
+
+typedef enum cgltf_camera_type {
+ cgltf_camera_type_invalid,
+ cgltf_camera_type_perspective,
+ cgltf_camera_type_orthographic,
+} cgltf_camera_type;
+
+typedef enum cgltf_light_type {
+ cgltf_light_type_invalid,
+ cgltf_light_type_directional,
+ cgltf_light_type_point,
+ cgltf_light_type_spot,
+} cgltf_light_type;
+
+typedef enum cgltf_data_free_method {
+ cgltf_data_free_method_none,
+ cgltf_data_free_method_file_release,
+ cgltf_data_free_method_memory_free,
+} cgltf_data_free_method;
+
+typedef struct cgltf_extras {
+ cgltf_size start_offset;
+ cgltf_size end_offset;
+} cgltf_extras;
+
+typedef struct cgltf_extension {
+ char* name;
+ char* data;
+} cgltf_extension;
+
+typedef struct cgltf_buffer
+{
+ char* name;
+ cgltf_size size;
+ char* uri;
+ void* data; /* loaded by cgltf_load_buffers */
+ cgltf_data_free_method data_free_method;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_buffer;
+
+typedef enum cgltf_meshopt_compression_mode {
+ cgltf_meshopt_compression_mode_invalid,
+ cgltf_meshopt_compression_mode_attributes,
+ cgltf_meshopt_compression_mode_triangles,
+ cgltf_meshopt_compression_mode_indices,
+} cgltf_meshopt_compression_mode;
+
+typedef enum cgltf_meshopt_compression_filter {
+ cgltf_meshopt_compression_filter_none,
+ cgltf_meshopt_compression_filter_octahedral,
+ cgltf_meshopt_compression_filter_quaternion,
+ cgltf_meshopt_compression_filter_exponential,
+} cgltf_meshopt_compression_filter;
+
+typedef struct cgltf_meshopt_compression
+{
+ cgltf_buffer* buffer;
+ cgltf_size offset;
+ cgltf_size size;
+ cgltf_size stride;
+ cgltf_size count;
+ cgltf_meshopt_compression_mode mode;
+ cgltf_meshopt_compression_filter filter;
+} cgltf_meshopt_compression;
+
+typedef struct cgltf_buffer_view
+{
+ char *name;
+ cgltf_buffer* buffer;
+ cgltf_size offset;
+ cgltf_size size;
+ cgltf_size stride; /* 0 == automatically determined by accessor */
+ cgltf_buffer_view_type type;
+ void* data; /* overrides buffer->data if present, filled by extensions */
+ cgltf_bool has_meshopt_compression;
+ cgltf_meshopt_compression meshopt_compression;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_buffer_view;
+
+typedef struct cgltf_accessor_sparse
+{
+ cgltf_size count;
+ cgltf_buffer_view* indices_buffer_view;
+ cgltf_size indices_byte_offset;
+ cgltf_component_type indices_component_type;
+ cgltf_buffer_view* values_buffer_view;
+ cgltf_size values_byte_offset;
+ cgltf_extras extras;
+ cgltf_extras indices_extras;
+ cgltf_extras values_extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+ cgltf_size indices_extensions_count;
+ cgltf_extension* indices_extensions;
+ cgltf_size values_extensions_count;
+ cgltf_extension* values_extensions;
+} cgltf_accessor_sparse;
+
+typedef struct cgltf_accessor
+{
+ char* name;
+ cgltf_component_type component_type;
+ cgltf_bool normalized;
+ cgltf_type type;
+ cgltf_size offset;
+ cgltf_size count;
+ cgltf_size stride;
+ cgltf_buffer_view* buffer_view;
+ cgltf_bool has_min;
+ cgltf_float min[16];
+ cgltf_bool has_max;
+ cgltf_float max[16];
+ cgltf_bool is_sparse;
+ cgltf_accessor_sparse sparse;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_accessor;
+
+typedef struct cgltf_attribute
+{
+ char* name;
+ cgltf_attribute_type type;
+ cgltf_int index;
+ cgltf_accessor* data;
+} cgltf_attribute;
+
+typedef struct cgltf_image
+{
+ char* name;
+ char* uri;
+ cgltf_buffer_view* buffer_view;
+ char* mime_type;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_image;
+
+typedef struct cgltf_sampler
+{
+ char* name;
+ cgltf_int mag_filter;
+ cgltf_int min_filter;
+ cgltf_int wrap_s;
+ cgltf_int wrap_t;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_sampler;
+
+typedef struct cgltf_texture
+{
+ char* name;
+ cgltf_image* image;
+ cgltf_sampler* sampler;
+ cgltf_bool has_basisu;
+ cgltf_image* basisu_image;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_texture;
+
+typedef struct cgltf_texture_transform
+{
+ cgltf_float offset[2];
+ cgltf_float rotation;
+ cgltf_float scale[2];
+ cgltf_bool has_texcoord;
+ cgltf_int texcoord;
+} cgltf_texture_transform;
+
+typedef struct cgltf_texture_view
+{
+ cgltf_texture* texture;
+ cgltf_int texcoord;
+ cgltf_float scale; /* equivalent to strength for occlusion_texture */
+ cgltf_bool has_transform;
+ cgltf_texture_transform transform;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_texture_view;
+
+typedef struct cgltf_pbr_metallic_roughness
+{
+ cgltf_texture_view base_color_texture;
+ cgltf_texture_view metallic_roughness_texture;
+
+ cgltf_float base_color_factor[4];
+ cgltf_float metallic_factor;
+ cgltf_float roughness_factor;
+
+ cgltf_extras extras;
+} cgltf_pbr_metallic_roughness;
+
+typedef struct cgltf_pbr_specular_glossiness
+{
+ cgltf_texture_view diffuse_texture;
+ cgltf_texture_view specular_glossiness_texture;
+
+ cgltf_float diffuse_factor[4];
+ cgltf_float specular_factor[3];
+ cgltf_float glossiness_factor;
+} cgltf_pbr_specular_glossiness;
+
+typedef struct cgltf_clearcoat
+{
+ cgltf_texture_view clearcoat_texture;
+ cgltf_texture_view clearcoat_roughness_texture;
+ cgltf_texture_view clearcoat_normal_texture;
+
+ cgltf_float clearcoat_factor;
+ cgltf_float clearcoat_roughness_factor;
+} cgltf_clearcoat;
+
+typedef struct cgltf_transmission
+{
+ cgltf_texture_view transmission_texture;
+ cgltf_float transmission_factor;
+} cgltf_transmission;
+
+typedef struct cgltf_ior
+{
+ cgltf_float ior;
+} cgltf_ior;
+
+typedef struct cgltf_specular
+{
+ cgltf_texture_view specular_texture;
+ cgltf_texture_view specular_color_texture;
+ cgltf_float specular_color_factor[3];
+ cgltf_float specular_factor;
+} cgltf_specular;
+
+typedef struct cgltf_volume
+{
+ cgltf_texture_view thickness_texture;
+ cgltf_float thickness_factor;
+ cgltf_float attenuation_color[3];
+ cgltf_float attenuation_distance;
+} cgltf_volume;
+
+typedef struct cgltf_sheen
+{
+ cgltf_texture_view sheen_color_texture;
+ cgltf_float sheen_color_factor[3];
+ cgltf_texture_view sheen_roughness_texture;
+ cgltf_float sheen_roughness_factor;
+} cgltf_sheen;
+
+typedef struct cgltf_emissive_strength
+{
+ cgltf_float emissive_strength;
+} cgltf_emissive_strength;
+
+typedef struct cgltf_iridescence
+{
+ cgltf_float iridescence_factor;
+ cgltf_texture_view iridescence_texture;
+ cgltf_float iridescence_ior;
+ cgltf_float iridescence_thickness_min;
+ cgltf_float iridescence_thickness_max;
+ cgltf_texture_view iridescence_thickness_texture;
+} cgltf_iridescence;
+
+typedef struct cgltf_material
+{
+ char* name;
+ cgltf_bool has_pbr_metallic_roughness;
+ cgltf_bool has_pbr_specular_glossiness;
+ cgltf_bool has_clearcoat;
+ cgltf_bool has_transmission;
+ cgltf_bool has_volume;
+ cgltf_bool has_ior;
+ cgltf_bool has_specular;
+ cgltf_bool has_sheen;
+ cgltf_bool has_emissive_strength;
+ cgltf_bool has_iridescence;
+ cgltf_pbr_metallic_roughness pbr_metallic_roughness;
+ cgltf_pbr_specular_glossiness pbr_specular_glossiness;
+ cgltf_clearcoat clearcoat;
+ cgltf_ior ior;
+ cgltf_specular specular;
+ cgltf_sheen sheen;
+ cgltf_transmission transmission;
+ cgltf_volume volume;
+ cgltf_emissive_strength emissive_strength;
+ cgltf_iridescence iridescence;
+ cgltf_texture_view normal_texture;
+ cgltf_texture_view occlusion_texture;
+ cgltf_texture_view emissive_texture;
+ cgltf_float emissive_factor[3];
+ cgltf_alpha_mode alpha_mode;
+ cgltf_float alpha_cutoff;
+ cgltf_bool double_sided;
+ cgltf_bool unlit;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_material;
+
+typedef struct cgltf_material_mapping
+{
+ cgltf_size variant;
+ cgltf_material* material;
+ cgltf_extras extras;
+} cgltf_material_mapping;
+
+typedef struct cgltf_morph_target {
+ cgltf_attribute* attributes;
+ cgltf_size attributes_count;
+} cgltf_morph_target;
+
+typedef struct cgltf_draco_mesh_compression {
+ cgltf_buffer_view* buffer_view;
+ cgltf_attribute* attributes;
+ cgltf_size attributes_count;
+} cgltf_draco_mesh_compression;
+
+typedef struct cgltf_mesh_gpu_instancing {
+ cgltf_buffer_view* buffer_view;
+ cgltf_attribute* attributes;
+ cgltf_size attributes_count;
+} cgltf_mesh_gpu_instancing;
+
+typedef struct cgltf_primitive {
+ cgltf_primitive_type type;
+ cgltf_accessor* indices;
+ cgltf_material* material;
+ cgltf_attribute* attributes;
+ cgltf_size attributes_count;
+ cgltf_morph_target* targets;
+ cgltf_size targets_count;
+ cgltf_extras extras;
+ cgltf_bool has_draco_mesh_compression;
+ cgltf_draco_mesh_compression draco_mesh_compression;
+ cgltf_material_mapping* mappings;
+ cgltf_size mappings_count;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_primitive;
+
+typedef struct cgltf_mesh {
+ char* name;
+ cgltf_primitive* primitives;
+ cgltf_size primitives_count;
+ cgltf_float* weights;
+ cgltf_size weights_count;
+ char** target_names;
+ cgltf_size target_names_count;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_mesh;
+
+typedef struct cgltf_node cgltf_node;
+
+typedef struct cgltf_skin {
+ char* name;
+ cgltf_node** joints;
+ cgltf_size joints_count;
+ cgltf_node* skeleton;
+ cgltf_accessor* inverse_bind_matrices;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_skin;
+
+typedef struct cgltf_camera_perspective {
+ cgltf_bool has_aspect_ratio;
+ cgltf_float aspect_ratio;
+ cgltf_float yfov;
+ cgltf_bool has_zfar;
+ cgltf_float zfar;
+ cgltf_float znear;
+ cgltf_extras extras;
+} cgltf_camera_perspective;
+
+typedef struct cgltf_camera_orthographic {
+ cgltf_float xmag;
+ cgltf_float ymag;
+ cgltf_float zfar;
+ cgltf_float znear;
+ cgltf_extras extras;
+} cgltf_camera_orthographic;
+
+typedef struct cgltf_camera {
+ char* name;
+ cgltf_camera_type type;
+ union {
+ cgltf_camera_perspective perspective;
+ cgltf_camera_orthographic orthographic;
+ } data;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_camera;
+
+typedef struct cgltf_light {
+ char* name;
+ cgltf_float color[3];
+ cgltf_float intensity;
+ cgltf_light_type type;
+ cgltf_float range;
+ cgltf_float spot_inner_cone_angle;
+ cgltf_float spot_outer_cone_angle;
+ cgltf_extras extras;
+} cgltf_light;
+
+struct cgltf_node {
+ char* name;
+ cgltf_node* parent;
+ cgltf_node** children;
+ cgltf_size children_count;
+ cgltf_skin* skin;
+ cgltf_mesh* mesh;
+ cgltf_camera* camera;
+ cgltf_light* light;
+ cgltf_float* weights;
+ cgltf_size weights_count;
+ cgltf_bool has_translation;
+ cgltf_bool has_rotation;
+ cgltf_bool has_scale;
+ cgltf_bool has_matrix;
+ cgltf_float translation[3];
+ cgltf_float rotation[4];
+ cgltf_float scale[3];
+ cgltf_float matrix[16];
+ cgltf_extras extras;
+ cgltf_bool has_mesh_gpu_instancing;
+ cgltf_mesh_gpu_instancing mesh_gpu_instancing;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+};
+
+typedef struct cgltf_scene {
+ char* name;
+ cgltf_node** nodes;
+ cgltf_size nodes_count;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_scene;
+
+typedef struct cgltf_animation_sampler {
+ cgltf_accessor* input;
+ cgltf_accessor* output;
+ cgltf_interpolation_type interpolation;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_animation_sampler;
+
+typedef struct cgltf_animation_channel {
+ cgltf_animation_sampler* sampler;
+ cgltf_node* target_node;
+ cgltf_animation_path_type target_path;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_animation_channel;
+
+typedef struct cgltf_animation {
+ char* name;
+ cgltf_animation_sampler* samplers;
+ cgltf_size samplers_count;
+ cgltf_animation_channel* channels;
+ cgltf_size channels_count;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_animation;
+
+typedef struct cgltf_material_variant
+{
+ char* name;
+ cgltf_extras extras;
+} cgltf_material_variant;
+
+typedef struct cgltf_asset {
+ char* copyright;
+ char* generator;
+ char* version;
+ char* min_version;
+ cgltf_extras extras;
+ cgltf_size extensions_count;
+ cgltf_extension* extensions;
+} cgltf_asset;
+
+typedef struct cgltf_data
+{
+ cgltf_file_type file_type;
+ void* file_data;
+
+ cgltf_asset asset;
+
+ cgltf_mesh* meshes;
+ cgltf_size meshes_count;
+
+ cgltf_material* materials;
+ cgltf_size materials_count;
+
+ cgltf_accessor* accessors;
+ cgltf_size accessors_count;
+
+ cgltf_buffer_view* buffer_views;
+ cgltf_size buffer_views_count;
+
+ cgltf_buffer* buffers;
+ cgltf_size buffers_count;
+
+ cgltf_image* images;
+ cgltf_size images_count;
+
+ cgltf_texture* textures;
+ cgltf_size textures_count;
+
+ cgltf_sampler* samplers;
+ cgltf_size samplers_count;
+
+ cgltf_skin* skins;
+ cgltf_size skins_count;
+
+ cgltf_camera* cameras;
+ cgltf_size cameras_count;
+
+ cgltf_light* lights;
+ cgltf_size lights_count;
+
+ cgltf_node* nodes;
+ cgltf_size nodes_count;
+
+ cgltf_scene* scenes;
+ cgltf_size scenes_count;
+
+ cgltf_scene* scene;
+
+ cgltf_animation* animations;
+ cgltf_size animations_count;
+
+ cgltf_material_variant* variants;
+ cgltf_size variants_count;
+
+ cgltf_extras extras;
+
+ cgltf_size data_extensions_count;
+ cgltf_extension* data_extensions;
+
+ char** extensions_used;
+ cgltf_size extensions_used_count;
+
+ char** extensions_required;
+ cgltf_size extensions_required_count;
+
+ const char* json;
+ cgltf_size json_size;
+
+ const void* bin;
+ cgltf_size bin_size;
+
+ cgltf_memory_options memory;
+ cgltf_file_options file;
+} cgltf_data;
+
+cgltf_result cgltf_parse(
+ const cgltf_options* options,
+ const void* data,
+ cgltf_size size,
+ cgltf_data** out_data);
+
+cgltf_result cgltf_parse_file(
+ const cgltf_options* options,
+ const char* path,
+ cgltf_data** out_data);
+
+cgltf_result cgltf_load_buffers(
+ const cgltf_options* options,
+ cgltf_data* data,
+ const char* gltf_path);
+
+cgltf_result cgltf_load_buffer_base64(const cgltf_options* options, cgltf_size size, const char* base64, void** out_data);
+
+cgltf_size cgltf_decode_string(char* string);
+cgltf_size cgltf_decode_uri(char* uri);
+
+cgltf_result cgltf_validate(cgltf_data* data);
+
+void cgltf_free(cgltf_data* data);
+
+void cgltf_node_transform_local(const cgltf_node* node, cgltf_float* out_matrix);
+void cgltf_node_transform_world(const cgltf_node* node, cgltf_float* out_matrix);
+
+cgltf_bool cgltf_accessor_read_float(const cgltf_accessor* accessor, cgltf_size index, cgltf_float* out, cgltf_size element_size);
+cgltf_bool cgltf_accessor_read_uint(const cgltf_accessor* accessor, cgltf_size index, cgltf_uint* out, cgltf_size element_size);
+cgltf_size cgltf_accessor_read_index(const cgltf_accessor* accessor, cgltf_size index);
+
+cgltf_size cgltf_num_components(cgltf_type type);
+
+cgltf_size cgltf_accessor_unpack_floats(const cgltf_accessor* accessor, cgltf_float* out, cgltf_size float_count);
+
+cgltf_result cgltf_copy_extras_json(const cgltf_data* data, const cgltf_extras* extras, char* dest, cgltf_size* dest_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* #ifndef CGLTF_H_INCLUDED__ */
+
+/*
+ *
+ * Stop now, if you are only interested in the API.
+ * Below, you find the implementation.
+ *
+ */
+
+#if defined(__INTELLISENSE__) || defined(__JETBRAINS_IDE__)
+/* This makes MSVC/CLion intellisense work. */
+#define CGLTF_IMPLEMENTATION
+#endif
+
+#ifdef CGLTF_IMPLEMENTATION
+
+#include <stdint.h> /* For uint8_t, uint32_t */
+#include <string.h> /* For strncpy */
+#include <stdio.h> /* For fopen */
+#include <limits.h> /* For UINT_MAX etc */
+#include <float.h> /* For FLT_MAX */
+
+#if !defined(CGLTF_MALLOC) || !defined(CGLTF_FREE) || !defined(CGLTF_ATOI) || !defined(CGLTF_ATOF) || !defined(CGLTF_ATOLL)
+#include <stdlib.h> /* For malloc, free, atoi, atof */
+#endif
+
+/* JSMN_PARENT_LINKS is necessary to make parsing large structures linear in input size */
+#define JSMN_PARENT_LINKS
+
+/* JSMN_STRICT is necessary to reject invalid JSON documents */
+#define JSMN_STRICT
+
+/*
+ * -- jsmn.h start --
+ * Source: https://github.com/zserge/jsmn
+ * License: MIT
+ */
+typedef enum {
+ JSMN_UNDEFINED = 0,
+ JSMN_OBJECT = 1,
+ JSMN_ARRAY = 2,
+ JSMN_STRING = 3,
+ JSMN_PRIMITIVE = 4
+} jsmntype_t;
+enum jsmnerr {
+ /* Not enough tokens were provided */
+ JSMN_ERROR_NOMEM = -1,
+ /* Invalid character inside JSON string */
+ JSMN_ERROR_INVAL = -2,
+ /* The string is not a full JSON packet, more bytes expected */
+ JSMN_ERROR_PART = -3
+};
+typedef struct {
+ jsmntype_t type;
+ int start;
+ int end;
+ int size;
+#ifdef JSMN_PARENT_LINKS
+ int parent;
+#endif
+} jsmntok_t;
+typedef struct {
+ unsigned int pos; /* offset in the JSON string */
+ unsigned int toknext; /* next token to allocate */
+ int toksuper; /* superior token node, e.g parent object or array */
+} jsmn_parser;
+static void jsmn_init(jsmn_parser *parser);
+static int jsmn_parse(jsmn_parser *parser, const char *js, size_t len, jsmntok_t *tokens, size_t num_tokens);
+/*
+ * -- jsmn.h end --
+ */
+
+
+static const cgltf_size GlbHeaderSize = 12;
+static const cgltf_size GlbChunkHeaderSize = 8;
+static const uint32_t GlbVersion = 2;
+static const uint32_t GlbMagic = 0x46546C67;
+static const uint32_t GlbMagicJsonChunk = 0x4E4F534A;
+static const uint32_t GlbMagicBinChunk = 0x004E4942;
+
+#ifndef CGLTF_MALLOC
+#define CGLTF_MALLOC(size) malloc(size)
+#endif
+#ifndef CGLTF_FREE
+#define CGLTF_FREE(ptr) free(ptr)
+#endif
+#ifndef CGLTF_ATOI
+#define CGLTF_ATOI(str) atoi(str)
+#endif
+#ifndef CGLTF_ATOF
+#define CGLTF_ATOF(str) atof(str)
+#endif
+#ifndef CGLTF_ATOLL
+#define CGLTF_ATOLL(str) atoll(str)
+#endif
+#ifndef CGLTF_VALIDATE_ENABLE_ASSERTS
+#define CGLTF_VALIDATE_ENABLE_ASSERTS 0
+#endif
+
+static void* cgltf_default_alloc(void* user, cgltf_size size)
+{
+ (void)user;
+ return CGLTF_MALLOC(size);
+}
+
+static void cgltf_default_free(void* user, void* ptr)
+{
+ (void)user;
+ CGLTF_FREE(ptr);
+}
+
+static void* cgltf_calloc(cgltf_options* options, size_t element_size, cgltf_size count)
+{
+ if (SIZE_MAX / element_size < count)
+ {
+ return NULL;
+ }
+ void* result = options->memory.alloc(options->memory.user_data, element_size * count);
+ if (!result)
+ {
+ return NULL;
+ }
+ memset(result, 0, element_size * count);
+ return result;
+}
+
+static cgltf_result cgltf_default_file_read(const struct cgltf_memory_options* memory_options, const struct cgltf_file_options* file_options, const char* path, cgltf_size* size, void** data)
+{
+ (void)file_options;
+ void* (*memory_alloc)(void*, cgltf_size) = memory_options->alloc ? memory_options->alloc : &cgltf_default_alloc;
+ void (*memory_free)(void*, void*) = memory_options->free ? memory_options->free : &cgltf_default_free;
+
+ FILE* file = fopen(path, "rb");
+ if (!file)
+ {
+ return cgltf_result_file_not_found;
+ }
+
+ cgltf_size file_size = size ? *size : 0;
+
+ if (file_size == 0)
+ {
+ fseek(file, 0, SEEK_END);
+
+#ifdef _WIN32
+ __int64 length = _ftelli64(file);
+#else
+ long length = ftell(file);
+#endif
+
+ if (length < 0)
+ {
+ fclose(file);
+ return cgltf_result_io_error;
+ }
+
+ fseek(file, 0, SEEK_SET);
+ file_size = (cgltf_size)length;
+ }
+
+ char* file_data = (char*)memory_alloc(memory_options->user_data, file_size);
+ if (!file_data)
+ {
+ fclose(file);
+ return cgltf_result_out_of_memory;
+ }
+
+ cgltf_size read_size = fread(file_data, 1, file_size, file);
+
+ fclose(file);
+
+ if (read_size != file_size)
+ {
+ memory_free(memory_options->user_data, file_data);
+ return cgltf_result_io_error;
+ }
+
+ if (size)
+ {
+ *size = file_size;
+ }
+ if (data)
+ {
+ *data = file_data;
+ }
+
+ return cgltf_result_success;
+}
+
+static void cgltf_default_file_release(const struct cgltf_memory_options* memory_options, const struct cgltf_file_options* file_options, void* data)
+{
+ (void)file_options;
+ void (*memfree)(void*, void*) = memory_options->free ? memory_options->free : &cgltf_default_free;
+ memfree(memory_options->user_data, data);
+}
+
+static cgltf_result cgltf_parse_json(cgltf_options* options, const uint8_t* json_chunk, cgltf_size size, cgltf_data** out_data);
+
+cgltf_result cgltf_parse(const cgltf_options* options, const void* data, cgltf_size size, cgltf_data** out_data)
+{
+ if (size < GlbHeaderSize)
+ {
+ return cgltf_result_data_too_short;
+ }
+
+ if (options == NULL)
+ {
+ return cgltf_result_invalid_options;
+ }
+
+ cgltf_options fixed_options = *options;
+ if (fixed_options.memory.alloc == NULL)
+ {
+ fixed_options.memory.alloc = &cgltf_default_alloc;
+ }
+ if (fixed_options.memory.free == NULL)
+ {
+ fixed_options.memory.free = &cgltf_default_free;
+ }
+
+ uint32_t tmp;
+ // Magic
+ memcpy(&tmp, data, 4);
+ if (tmp != GlbMagic)
+ {
+ if (fixed_options.type == cgltf_file_type_invalid)
+ {
+ fixed_options.type = cgltf_file_type_gltf;
+ }
+ else if (fixed_options.type == cgltf_file_type_glb)
+ {
+ return cgltf_result_unknown_format;
+ }
+ }
+
+ if (fixed_options.type == cgltf_file_type_gltf)
+ {
+ cgltf_result json_result = cgltf_parse_json(&fixed_options, (const uint8_t*)data, size, out_data);
+ if (json_result != cgltf_result_success)
+ {
+ return json_result;
+ }
+
+ (*out_data)->file_type = cgltf_file_type_gltf;
+
+ return cgltf_result_success;
+ }
+
+ const uint8_t* ptr = (const uint8_t*)data;
+ // Version
+ memcpy(&tmp, ptr + 4, 4);
+ uint32_t version = tmp;
+ if (version != GlbVersion)
+ {
+ return version < GlbVersion ? cgltf_result_legacy_gltf : cgltf_result_unknown_format;
+ }
+
+ // Total length
+ memcpy(&tmp, ptr + 8, 4);
+ if (tmp > size)
+ {
+ return cgltf_result_data_too_short;
+ }
+
+ const uint8_t* json_chunk = ptr + GlbHeaderSize;
+
+ if (GlbHeaderSize + GlbChunkHeaderSize > size)
+ {
+ return cgltf_result_data_too_short;
+ }
+
+ // JSON chunk: length
+ uint32_t json_length;
+ memcpy(&json_length, json_chunk, 4);
+ if (GlbHeaderSize + GlbChunkHeaderSize + json_length > size)
+ {
+ return cgltf_result_data_too_short;
+ }
+
+ // JSON chunk: magic
+ memcpy(&tmp, json_chunk + 4, 4);
+ if (tmp != GlbMagicJsonChunk)
+ {
+ return cgltf_result_unknown_format;
+ }
+
+ json_chunk += GlbChunkHeaderSize;
+
+ const void* bin = 0;
+ cgltf_size bin_size = 0;
+
+ if (GlbHeaderSize + GlbChunkHeaderSize + json_length + GlbChunkHeaderSize <= size)
+ {
+ // We can read another chunk
+ const uint8_t* bin_chunk = json_chunk + json_length;
+
+ // Bin chunk: length
+ uint32_t bin_length;
+ memcpy(&bin_length, bin_chunk, 4);
+ if (GlbHeaderSize + GlbChunkHeaderSize + json_length + GlbChunkHeaderSize + bin_length > size)
+ {
+ return cgltf_result_data_too_short;
+ }
+
+ // Bin chunk: magic
+ memcpy(&tmp, bin_chunk + 4, 4);
+ if (tmp != GlbMagicBinChunk)
+ {
+ return cgltf_result_unknown_format;
+ }
+
+ bin_chunk += GlbChunkHeaderSize;
+
+ bin = bin_chunk;
+ bin_size = bin_length;
+ }
+
+ cgltf_result json_result = cgltf_parse_json(&fixed_options, json_chunk, json_length, out_data);
+ if (json_result != cgltf_result_success)
+ {
+ return json_result;
+ }
+
+ (*out_data)->file_type = cgltf_file_type_glb;
+ (*out_data)->bin = bin;
+ (*out_data)->bin_size = bin_size;
+
+ return cgltf_result_success;
+}
+
+cgltf_result cgltf_parse_file(const cgltf_options* options, const char* path, cgltf_data** out_data)
+{
+ if (options == NULL)
+ {
+ return cgltf_result_invalid_options;
+ }
+
+ cgltf_result (*file_read)(const struct cgltf_memory_options*, const struct cgltf_file_options*, const char*, cgltf_size*, void**) = options->file.read ? options->file.read : &cgltf_default_file_read;
+ void (*file_release)(const struct cgltf_memory_options*, const struct cgltf_file_options*, void* data) = options->file.release ? options->file.release : cgltf_default_file_release;
+
+ void* file_data = NULL;
+ cgltf_size file_size = 0;
+ cgltf_result result = file_read(&options->memory, &options->file, path, &file_size, &file_data);
+ if (result != cgltf_result_success)
+ {
+ return result;
+ }
+
+ result = cgltf_parse(options, file_data, file_size, out_data);
+
+ if (result != cgltf_result_success)
+ {
+ file_release(&options->memory, &options->file, file_data);
+ return result;
+ }
+
+ (*out_data)->file_data = file_data;
+
+ return cgltf_result_success;
+}
+
+static void cgltf_combine_paths(char* path, const char* base, const char* uri)
+{
+ const char* s0 = strrchr(base, '/');
+ const char* s1 = strrchr(base, '\\');
+ const char* slash = s0 ? (s1 && s1 > s0 ? s1 : s0) : s1;
+
+ if (slash)
+ {
+ size_t prefix = slash - base + 1;
+
+ strncpy(path, base, prefix);
+ strcpy(path + prefix, uri);
+ }
+ else
+ {
+ strcpy(path, uri);
+ }
+}
+
+static cgltf_result cgltf_load_buffer_file(const cgltf_options* options, cgltf_size size, const char* uri, const char* gltf_path, void** out_data)
+{
+ void* (*memory_alloc)(void*, cgltf_size) = options->memory.alloc ? options->memory.alloc : &cgltf_default_alloc;
+ void (*memory_free)(void*, void*) = options->memory.free ? options->memory.free : &cgltf_default_free;
+ cgltf_result (*file_read)(const struct cgltf_memory_options*, const struct cgltf_file_options*, const char*, cgltf_size*, void**) = options->file.read ? options->file.read : &cgltf_default_file_read;
+
+ char* path = (char*)memory_alloc(options->memory.user_data, strlen(uri) + strlen(gltf_path) + 1);
+ if (!path)
+ {
+ return cgltf_result_out_of_memory;
+ }
+
+ cgltf_combine_paths(path, gltf_path, uri);
+
+ // after combining, the tail of the resulting path is a uri; decode_uri converts it into path
+ cgltf_decode_uri(path + strlen(path) - strlen(uri));
+
+ void* file_data = NULL;
+ cgltf_result result = file_read(&options->memory, &options->file, path, &size, &file_data);
+
+ memory_free(options->memory.user_data, path);
+
+ *out_data = (result == cgltf_result_success) ? file_data : NULL;
+
+ return result;
+}
+
+cgltf_result cgltf_load_buffer_base64(const cgltf_options* options, cgltf_size size, const char* base64, void** out_data)
+{
+ void* (*memory_alloc)(void*, cgltf_size) = options->memory.alloc ? options->memory.alloc : &cgltf_default_alloc;
+ void (*memory_free)(void*, void*) = options->memory.free ? options->memory.free : &cgltf_default_free;
+
+ unsigned char* data = (unsigned char*)memory_alloc(options->memory.user_data, size);
+ if (!data)
+ {
+ return cgltf_result_out_of_memory;
+ }
+
+ unsigned int buffer = 0;
+ unsigned int buffer_bits = 0;
+
+ for (cgltf_size i = 0; i < size; ++i)
+ {
+ while (buffer_bits < 8)
+ {
+ char ch = *base64++;
+
+ int index =
+ (unsigned)(ch - 'A') < 26 ? (ch - 'A') :
+ (unsigned)(ch - 'a') < 26 ? (ch - 'a') + 26 :
+ (unsigned)(ch - '0') < 10 ? (ch - '0') + 52 :
+ ch == '+' ? 62 :
+ ch == '/' ? 63 :
+ -1;
+
+ if (index < 0)
+ {
+ memory_free(options->memory.user_data, data);
+ return cgltf_result_io_error;
+ }
+
+ buffer = (buffer << 6) | index;
+ buffer_bits += 6;
+ }
+
+ data[i] = (unsigned char)(buffer >> (buffer_bits - 8));
+ buffer_bits -= 8;
+ }
+
+ *out_data = data;
+
+ return cgltf_result_success;
+}
+
+static int cgltf_unhex(char ch)
+{
+ return
+ (unsigned)(ch - '0') < 10 ? (ch - '0') :
+ (unsigned)(ch - 'A') < 6 ? (ch - 'A') + 10 :
+ (unsigned)(ch - 'a') < 6 ? (ch - 'a') + 10 :
+ -1;
+}
+
+cgltf_size cgltf_decode_string(char* string)
+{
+ char* read = string + strcspn(string, "\\");
+ if (*read == 0)
+ {
+ return read - string;
+ }
+ char* write = string;
+ char* last = string;
+
+ for (;;)
+ {
+ // Copy characters since last escaped sequence
+ cgltf_size written = read - last;
+ memmove(write, last, written);
+ write += written;
+
+ if (*read++ == 0)
+ {
+ break;
+ }
+
+ // jsmn already checked that all escape sequences are valid
+ switch (*read++)
+ {
+ case '\"': *write++ = '\"'; break;
+ case '/': *write++ = '/'; break;
+ case '\\': *write++ = '\\'; break;
+ case 'b': *write++ = '\b'; break;
+ case 'f': *write++ = '\f'; break;
+ case 'r': *write++ = '\r'; break;
+ case 'n': *write++ = '\n'; break;
+ case 't': *write++ = '\t'; break;
+ case 'u':
+ {
+ // UCS-2 codepoint \uXXXX to UTF-8
+ int character = 0;
+ for (cgltf_size i = 0; i < 4; ++i)
+ {
+ character = (character << 4) + cgltf_unhex(*read++);
+ }
+
+ if (character <= 0x7F)
+ {
+ *write++ = character & 0xFF;
+ }
+ else if (character <= 0x7FF)
+ {
+ *write++ = 0xC0 | ((character >> 6) & 0xFF);
+ *write++ = 0x80 | (character & 0x3F);
+ }
+ else
+ {
+ *write++ = 0xE0 | ((character >> 12) & 0xFF);
+ *write++ = 0x80 | ((character >> 6) & 0x3F);
+ *write++ = 0x80 | (character & 0x3F);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
+ last = read;
+ read += strcspn(read, "\\");
+ }
+
+ *write = 0;
+ return write - string;
+}
+
+cgltf_size cgltf_decode_uri(char* uri)
+{
+ char* write = uri;
+ char* i = uri;
+
+ while (*i)
+ {
+ if (*i == '%')
+ {
+ int ch1 = cgltf_unhex(i[1]);
+
+ if (ch1 >= 0)
+ {
+ int ch2 = cgltf_unhex(i[2]);
+
+ if (ch2 >= 0)
+ {
+ *write++ = (char)(ch1 * 16 + ch2);
+ i += 3;
+ continue;
+ }
+ }
+ }
+
+ *write++ = *i++;
+ }
+
+ *write = 0;
+ return write - uri;
+}
+
+cgltf_result cgltf_load_buffers(const cgltf_options* options, cgltf_data* data, const char* gltf_path)
+{
+ if (options == NULL)
+ {
+ return cgltf_result_invalid_options;
+ }
+
+ if (data->buffers_count && data->buffers[0].data == NULL && data->buffers[0].uri == NULL && data->bin)
+ {
+ if (data->bin_size < data->buffers[0].size)
+ {
+ return cgltf_result_data_too_short;
+ }
+
+ data->buffers[0].data = (void*)data->bin;
+ data->buffers[0].data_free_method = cgltf_data_free_method_none;
+ }
+
+ for (cgltf_size i = 0; i < data->buffers_count; ++i)
+ {
+ if (data->buffers[i].data)
+ {
+ continue;
+ }
+
+ const char* uri = data->buffers[i].uri;
+
+ if (uri == NULL)
+ {
+ continue;
+ }
+
+ if (strncmp(uri, "data:", 5) == 0)
+ {
+ const char* comma = strchr(uri, ',');
+
+ if (comma && comma - uri >= 7 && strncmp(comma - 7, ";base64", 7) == 0)
+ {
+ cgltf_result res = cgltf_load_buffer_base64(options, data->buffers[i].size, comma + 1, &data->buffers[i].data);
+ data->buffers[i].data_free_method = cgltf_data_free_method_memory_free;
+
+ if (res != cgltf_result_success)
+ {
+ return res;
+ }
+ }
+ else
+ {
+ return cgltf_result_unknown_format;
+ }
+ }
+ else if (strstr(uri, "://") == NULL && gltf_path)
+ {
+ cgltf_result res = cgltf_load_buffer_file(options, data->buffers[i].size, uri, gltf_path, &data->buffers[i].data);
+ data->buffers[i].data_free_method = cgltf_data_free_method_file_release;
+
+ if (res != cgltf_result_success)
+ {
+ return res;
+ }
+ }
+ else
+ {
+ return cgltf_result_unknown_format;
+ }
+ }
+
+ return cgltf_result_success;
+}
+
+static cgltf_size cgltf_calc_size(cgltf_type type, cgltf_component_type component_type);
+
+static cgltf_size cgltf_calc_index_bound(cgltf_buffer_view* buffer_view, cgltf_size offset, cgltf_component_type component_type, cgltf_size count)
+{
+ char* data = (char*)buffer_view->buffer->data + offset + buffer_view->offset;
+ cgltf_size bound = 0;
+
+ switch (component_type)
+ {
+ case cgltf_component_type_r_8u:
+ for (size_t i = 0; i < count; ++i)
+ {
+ cgltf_size v = ((unsigned char*)data)[i];
+ bound = bound > v ? bound : v;
+ }
+ break;
+
+ case cgltf_component_type_r_16u:
+ for (size_t i = 0; i < count; ++i)
+ {
+ cgltf_size v = ((unsigned short*)data)[i];
+ bound = bound > v ? bound : v;
+ }
+ break;
+
+ case cgltf_component_type_r_32u:
+ for (size_t i = 0; i < count; ++i)
+ {
+ cgltf_size v = ((unsigned int*)data)[i];
+ bound = bound > v ? bound : v;
+ }
+ break;
+
+ default:
+ ;
+ }
+
+ return bound;
+}
+
+#if CGLTF_VALIDATE_ENABLE_ASSERTS
+#define CGLTF_ASSERT_IF(cond, result) assert(!(cond)); if (cond) return result;
+#else
+#define CGLTF_ASSERT_IF(cond, result) if (cond) return result;
+#endif
+
+cgltf_result cgltf_validate(cgltf_data* data)
+{
+ for (cgltf_size i = 0; i < data->accessors_count; ++i)
+ {
+ cgltf_accessor* accessor = &data->accessors[i];
+
+ cgltf_size element_size = cgltf_calc_size(accessor->type, accessor->component_type);
+
+ if (accessor->buffer_view)
+ {
+ cgltf_size req_size = accessor->offset + accessor->stride * (accessor->count - 1) + element_size;
+
+ CGLTF_ASSERT_IF(accessor->buffer_view->size < req_size, cgltf_result_data_too_short);
+ }
+
+ if (accessor->is_sparse)
+ {
+ cgltf_accessor_sparse* sparse = &accessor->sparse;
+
+ cgltf_size indices_component_size = cgltf_calc_size(cgltf_type_scalar, sparse->indices_component_type);
+ cgltf_size indices_req_size = sparse->indices_byte_offset + indices_component_size * sparse->count;
+ cgltf_size values_req_size = sparse->values_byte_offset + element_size * sparse->count;
+
+ CGLTF_ASSERT_IF(sparse->indices_buffer_view->size < indices_req_size ||
+ sparse->values_buffer_view->size < values_req_size, cgltf_result_data_too_short);
+
+ CGLTF_ASSERT_IF(sparse->indices_component_type != cgltf_component_type_r_8u &&
+ sparse->indices_component_type != cgltf_component_type_r_16u &&
+ sparse->indices_component_type != cgltf_component_type_r_32u, cgltf_result_invalid_gltf);
+
+ if (sparse->indices_buffer_view->buffer->data)
+ {
+ cgltf_size index_bound = cgltf_calc_index_bound(sparse->indices_buffer_view, sparse->indices_byte_offset, sparse->indices_component_type, sparse->count);
+
+ CGLTF_ASSERT_IF(index_bound >= accessor->count, cgltf_result_data_too_short);
+ }
+ }
+ }
+
+ for (cgltf_size i = 0; i < data->buffer_views_count; ++i)
+ {
+ cgltf_size req_size = data->buffer_views[i].offset + data->buffer_views[i].size;
+
+ CGLTF_ASSERT_IF(data->buffer_views[i].buffer && data->buffer_views[i].buffer->size < req_size, cgltf_result_data_too_short);
+
+ if (data->buffer_views[i].has_meshopt_compression)
+ {
+ cgltf_meshopt_compression* mc = &data->buffer_views[i].meshopt_compression;
+
+ CGLTF_ASSERT_IF(mc->buffer == NULL || mc->buffer->size < mc->offset + mc->size, cgltf_result_data_too_short);
+
+ CGLTF_ASSERT_IF(data->buffer_views[i].stride && mc->stride != data->buffer_views[i].stride, cgltf_result_invalid_gltf);
+
+ CGLTF_ASSERT_IF(data->buffer_views[i].size != mc->stride * mc->count, cgltf_result_invalid_gltf);
+
+ CGLTF_ASSERT_IF(mc->mode == cgltf_meshopt_compression_mode_invalid, cgltf_result_invalid_gltf);
+
+ CGLTF_ASSERT_IF(mc->mode == cgltf_meshopt_compression_mode_attributes && !(mc->stride % 4 == 0 && mc->stride <= 256), cgltf_result_invalid_gltf);
+
+ CGLTF_ASSERT_IF(mc->mode == cgltf_meshopt_compression_mode_triangles && mc->count % 3 != 0, cgltf_result_invalid_gltf);
+
+ CGLTF_ASSERT_IF((mc->mode == cgltf_meshopt_compression_mode_triangles || mc->mode == cgltf_meshopt_compression_mode_indices) && mc->stride != 2 && mc->stride != 4, cgltf_result_invalid_gltf);
+
+ CGLTF_ASSERT_IF((mc->mode == cgltf_meshopt_compression_mode_triangles || mc->mode == cgltf_meshopt_compression_mode_indices) && mc->filter != cgltf_meshopt_compression_filter_none, cgltf_result_invalid_gltf);
+
+ CGLTF_ASSERT_IF(mc->filter == cgltf_meshopt_compression_filter_octahedral && mc->stride != 4 && mc->stride != 8, cgltf_result_invalid_gltf);
+
+ CGLTF_ASSERT_IF(mc->filter == cgltf_meshopt_compression_filter_quaternion && mc->stride != 8, cgltf_result_invalid_gltf);
+ }
+ }
+
+ for (cgltf_size i = 0; i < data->meshes_count; ++i)
+ {
+ if (data->meshes[i].weights)
+ {
+ CGLTF_ASSERT_IF(data->meshes[i].primitives_count && data->meshes[i].primitives[0].targets_count != data->meshes[i].weights_count, cgltf_result_invalid_gltf);
+ }
+
+ if (data->meshes[i].target_names)
+ {
+ CGLTF_ASSERT_IF(data->meshes[i].primitives_count && data->meshes[i].primitives[0].targets_count != data->meshes[i].target_names_count, cgltf_result_invalid_gltf);
+ }
+
+ for (cgltf_size j = 0; j < data->meshes[i].primitives_count; ++j)
+ {
+ CGLTF_ASSERT_IF(data->meshes[i].primitives[j].targets_count != data->meshes[i].primitives[0].targets_count, cgltf_result_invalid_gltf);
+
+ if (data->meshes[i].primitives[j].attributes_count)
+ {
+ cgltf_accessor* first = data->meshes[i].primitives[j].attributes[0].data;
+
+ for (cgltf_size k = 0; k < data->meshes[i].primitives[j].attributes_count; ++k)
+ {
+ CGLTF_ASSERT_IF(data->meshes[i].primitives[j].attributes[k].data->count != first->count, cgltf_result_invalid_gltf);
+ }
+
+ for (cgltf_size k = 0; k < data->meshes[i].primitives[j].targets_count; ++k)
+ {
+ for (cgltf_size m = 0; m < data->meshes[i].primitives[j].targets[k].attributes_count; ++m)
+ {
+ CGLTF_ASSERT_IF(data->meshes[i].primitives[j].targets[k].attributes[m].data->count != first->count, cgltf_result_invalid_gltf);
+ }
+ }
+
+ cgltf_accessor* indices = data->meshes[i].primitives[j].indices;
+
+ CGLTF_ASSERT_IF(indices &&
+ indices->component_type != cgltf_component_type_r_8u &&
+ indices->component_type != cgltf_component_type_r_16u &&
+ indices->component_type != cgltf_component_type_r_32u, cgltf_result_invalid_gltf);
+
+ if (indices && indices->buffer_view && indices->buffer_view->buffer->data)
+ {
+ cgltf_size index_bound = cgltf_calc_index_bound(indices->buffer_view, indices->offset, indices->component_type, indices->count);
+
+ CGLTF_ASSERT_IF(index_bound >= first->count, cgltf_result_data_too_short);
+ }
+
+ for (cgltf_size k = 0; k < data->meshes[i].primitives[j].mappings_count; ++k)
+ {
+ CGLTF_ASSERT_IF(data->meshes[i].primitives[j].mappings[k].variant >= data->variants_count, cgltf_result_invalid_gltf);
+ }
+ }
+ }
+ }
+
+ for (cgltf_size i = 0; i < data->nodes_count; ++i)
+ {
+ if (data->nodes[i].weights && data->nodes[i].mesh)
+ {
+ CGLTF_ASSERT_IF (data->nodes[i].mesh->primitives_count && data->nodes[i].mesh->primitives[0].targets_count != data->nodes[i].weights_count, cgltf_result_invalid_gltf);
+ }
+ }
+
+ for (cgltf_size i = 0; i < data->nodes_count; ++i)
+ {
+ cgltf_node* p1 = data->nodes[i].parent;
+ cgltf_node* p2 = p1 ? p1->parent : NULL;
+
+ while (p1 && p2)
+ {
+ CGLTF_ASSERT_IF(p1 == p2, cgltf_result_invalid_gltf);
+
+ p1 = p1->parent;
+ p2 = p2->parent ? p2->parent->parent : NULL;
+ }
+ }
+
+ for (cgltf_size i = 0; i < data->scenes_count; ++i)
+ {
+ for (cgltf_size j = 0; j < data->scenes[i].nodes_count; ++j)
+ {
+ CGLTF_ASSERT_IF(data->scenes[i].nodes[j]->parent, cgltf_result_invalid_gltf);
+ }
+ }
+
+ for (cgltf_size i = 0; i < data->animations_count; ++i)
+ {
+ for (cgltf_size j = 0; j < data->animations[i].channels_count; ++j)
+ {
+ cgltf_animation_channel* channel = &data->animations[i].channels[j];
+
+ if (!channel->target_node)
+ {
+ continue;
+ }
+
+ cgltf_size components = 1;
+
+ if (channel->target_path == cgltf_animation_path_type_weights)
+ {
+ CGLTF_ASSERT_IF(!channel->target_node->mesh || !channel->target_node->mesh->primitives_count, cgltf_result_invalid_gltf);
+
+ components = channel->target_node->mesh->primitives[0].targets_count;
+ }
+
+ cgltf_size values = channel->sampler->interpolation == cgltf_interpolation_type_cubic_spline ? 3 : 1;
+
+ CGLTF_ASSERT_IF(channel->sampler->input->count * components * values != channel->sampler->output->count, cgltf_result_data_too_short);
+ }
+ }
+
+ return cgltf_result_success;
+}
+
+cgltf_result cgltf_copy_extras_json(const cgltf_data* data, const cgltf_extras* extras, char* dest, cgltf_size* dest_size)
+{
+ cgltf_size json_size = extras->end_offset - extras->start_offset;
+
+ if (!dest)
+ {
+ if (dest_size)
+ {
+ *dest_size = json_size + 1;
+ return cgltf_result_success;
+ }
+ return cgltf_result_invalid_options;
+ }
+
+ if (*dest_size + 1 < json_size)
+ {
+ strncpy(dest, data->json + extras->start_offset, *dest_size - 1);
+ dest[*dest_size - 1] = 0;
+ }
+ else
+ {
+ strncpy(dest, data->json + extras->start_offset, json_size);
+ dest[json_size] = 0;
+ }
+
+ return cgltf_result_success;
+}
+
+void cgltf_free_extensions(cgltf_data* data, cgltf_extension* extensions, cgltf_size extensions_count)
+{
+ for (cgltf_size i = 0; i < extensions_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, extensions[i].name);
+ data->memory.free(data->memory.user_data, extensions[i].data);
+ }
+ data->memory.free(data->memory.user_data, extensions);
+}
+
+void cgltf_free(cgltf_data* data)
+{
+ if (!data)
+ {
+ return;
+ }
+
+ void (*file_release)(const struct cgltf_memory_options*, const struct cgltf_file_options*, void* data) = data->file.release ? data->file.release : cgltf_default_file_release;
+
+ data->memory.free(data->memory.user_data, data->asset.copyright);
+ data->memory.free(data->memory.user_data, data->asset.generator);
+ data->memory.free(data->memory.user_data, data->asset.version);
+ data->memory.free(data->memory.user_data, data->asset.min_version);
+
+ cgltf_free_extensions(data, data->asset.extensions, data->asset.extensions_count);
+
+ for (cgltf_size i = 0; i < data->accessors_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->accessors[i].name);
+
+ if(data->accessors[i].is_sparse)
+ {
+ cgltf_free_extensions(data, data->accessors[i].sparse.extensions, data->accessors[i].sparse.extensions_count);
+ cgltf_free_extensions(data, data->accessors[i].sparse.indices_extensions, data->accessors[i].sparse.indices_extensions_count);
+ cgltf_free_extensions(data, data->accessors[i].sparse.values_extensions, data->accessors[i].sparse.values_extensions_count);
+ }
+ cgltf_free_extensions(data, data->accessors[i].extensions, data->accessors[i].extensions_count);
+ }
+ data->memory.free(data->memory.user_data, data->accessors);
+
+ for (cgltf_size i = 0; i < data->buffer_views_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->buffer_views[i].name);
+ data->memory.free(data->memory.user_data, data->buffer_views[i].data);
+
+ cgltf_free_extensions(data, data->buffer_views[i].extensions, data->buffer_views[i].extensions_count);
+ }
+ data->memory.free(data->memory.user_data, data->buffer_views);
+
+ for (cgltf_size i = 0; i < data->buffers_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->buffers[i].name);
+
+ if (data->buffers[i].data_free_method == cgltf_data_free_method_file_release)
+ {
+ file_release(&data->memory, &data->file, data->buffers[i].data);
+ }
+ else if (data->buffers[i].data_free_method == cgltf_data_free_method_memory_free)
+ {
+ data->memory.free(data->memory.user_data, data->buffers[i].data);
+ }
+
+ data->memory.free(data->memory.user_data, data->buffers[i].uri);
+
+ cgltf_free_extensions(data, data->buffers[i].extensions, data->buffers[i].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->buffers);
+
+ for (cgltf_size i = 0; i < data->meshes_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->meshes[i].name);
+
+ for (cgltf_size j = 0; j < data->meshes[i].primitives_count; ++j)
+ {
+ for (cgltf_size k = 0; k < data->meshes[i].primitives[j].attributes_count; ++k)
+ {
+ data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].attributes[k].name);
+ }
+
+ data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].attributes);
+
+ for (cgltf_size k = 0; k < data->meshes[i].primitives[j].targets_count; ++k)
+ {
+ for (cgltf_size m = 0; m < data->meshes[i].primitives[j].targets[k].attributes_count; ++m)
+ {
+ data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].targets[k].attributes[m].name);
+ }
+
+ data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].targets[k].attributes);
+ }
+
+ data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].targets);
+
+ if (data->meshes[i].primitives[j].has_draco_mesh_compression)
+ {
+ for (cgltf_size k = 0; k < data->meshes[i].primitives[j].draco_mesh_compression.attributes_count; ++k)
+ {
+ data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].draco_mesh_compression.attributes[k].name);
+ }
+
+ data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].draco_mesh_compression.attributes);
+ }
+
+ data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].mappings);
+
+ cgltf_free_extensions(data, data->meshes[i].primitives[j].extensions, data->meshes[i].primitives[j].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->meshes[i].primitives);
+ data->memory.free(data->memory.user_data, data->meshes[i].weights);
+
+ for (cgltf_size j = 0; j < data->meshes[i].target_names_count; ++j)
+ {
+ data->memory.free(data->memory.user_data, data->meshes[i].target_names[j]);
+ }
+
+ cgltf_free_extensions(data, data->meshes[i].extensions, data->meshes[i].extensions_count);
+
+ data->memory.free(data->memory.user_data, data->meshes[i].target_names);
+ }
+
+ data->memory.free(data->memory.user_data, data->meshes);
+
+ for (cgltf_size i = 0; i < data->materials_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->materials[i].name);
+
+ if(data->materials[i].has_pbr_metallic_roughness)
+ {
+ cgltf_free_extensions(data, data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.extensions, data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.extensions_count);
+ cgltf_free_extensions(data, data->materials[i].pbr_metallic_roughness.base_color_texture.extensions, data->materials[i].pbr_metallic_roughness.base_color_texture.extensions_count);
+ }
+ if(data->materials[i].has_pbr_specular_glossiness)
+ {
+ cgltf_free_extensions(data, data->materials[i].pbr_specular_glossiness.diffuse_texture.extensions, data->materials[i].pbr_specular_glossiness.diffuse_texture.extensions_count);
+ cgltf_free_extensions(data, data->materials[i].pbr_specular_glossiness.specular_glossiness_texture.extensions, data->materials[i].pbr_specular_glossiness.specular_glossiness_texture.extensions_count);
+ }
+ if(data->materials[i].has_clearcoat)
+ {
+ cgltf_free_extensions(data, data->materials[i].clearcoat.clearcoat_texture.extensions, data->materials[i].clearcoat.clearcoat_texture.extensions_count);
+ cgltf_free_extensions(data, data->materials[i].clearcoat.clearcoat_roughness_texture.extensions, data->materials[i].clearcoat.clearcoat_roughness_texture.extensions_count);
+ cgltf_free_extensions(data, data->materials[i].clearcoat.clearcoat_normal_texture.extensions, data->materials[i].clearcoat.clearcoat_normal_texture.extensions_count);
+ }
+ if(data->materials[i].has_specular)
+ {
+ cgltf_free_extensions(data, data->materials[i].specular.specular_texture.extensions, data->materials[i].specular.specular_texture.extensions_count);
+ cgltf_free_extensions(data, data->materials[i].specular.specular_color_texture.extensions, data->materials[i].specular.specular_color_texture.extensions_count);
+ }
+ if(data->materials[i].has_transmission)
+ {
+ cgltf_free_extensions(data, data->materials[i].transmission.transmission_texture.extensions, data->materials[i].transmission.transmission_texture.extensions_count);
+ }
+ if (data->materials[i].has_volume)
+ {
+ cgltf_free_extensions(data, data->materials[i].volume.thickness_texture.extensions, data->materials[i].volume.thickness_texture.extensions_count);
+ }
+ if(data->materials[i].has_sheen)
+ {
+ cgltf_free_extensions(data, data->materials[i].sheen.sheen_color_texture.extensions, data->materials[i].sheen.sheen_color_texture.extensions_count);
+ cgltf_free_extensions(data, data->materials[i].sheen.sheen_roughness_texture.extensions, data->materials[i].sheen.sheen_roughness_texture.extensions_count);
+ }
+ if(data->materials[i].has_iridescence)
+ {
+ cgltf_free_extensions(data, data->materials[i].iridescence.iridescence_texture.extensions, data->materials[i].iridescence.iridescence_texture.extensions_count);
+ cgltf_free_extensions(data, data->materials[i].iridescence.iridescence_thickness_texture.extensions, data->materials[i].iridescence.iridescence_thickness_texture.extensions_count);
+ }
+
+ cgltf_free_extensions(data, data->materials[i].normal_texture.extensions, data->materials[i].normal_texture.extensions_count);
+ cgltf_free_extensions(data, data->materials[i].occlusion_texture.extensions, data->materials[i].occlusion_texture.extensions_count);
+ cgltf_free_extensions(data, data->materials[i].emissive_texture.extensions, data->materials[i].emissive_texture.extensions_count);
+
+ cgltf_free_extensions(data, data->materials[i].extensions, data->materials[i].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->materials);
+
+ for (cgltf_size i = 0; i < data->images_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->images[i].name);
+ data->memory.free(data->memory.user_data, data->images[i].uri);
+ data->memory.free(data->memory.user_data, data->images[i].mime_type);
+
+ cgltf_free_extensions(data, data->images[i].extensions, data->images[i].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->images);
+
+ for (cgltf_size i = 0; i < data->textures_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->textures[i].name);
+ cgltf_free_extensions(data, data->textures[i].extensions, data->textures[i].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->textures);
+
+ for (cgltf_size i = 0; i < data->samplers_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->samplers[i].name);
+ cgltf_free_extensions(data, data->samplers[i].extensions, data->samplers[i].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->samplers);
+
+ for (cgltf_size i = 0; i < data->skins_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->skins[i].name);
+ data->memory.free(data->memory.user_data, data->skins[i].joints);
+
+ cgltf_free_extensions(data, data->skins[i].extensions, data->skins[i].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->skins);
+
+ for (cgltf_size i = 0; i < data->cameras_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->cameras[i].name);
+ cgltf_free_extensions(data, data->cameras[i].extensions, data->cameras[i].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->cameras);
+
+ for (cgltf_size i = 0; i < data->lights_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->lights[i].name);
+ }
+
+ data->memory.free(data->memory.user_data, data->lights);
+
+ for (cgltf_size i = 0; i < data->nodes_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->nodes[i].name);
+ data->memory.free(data->memory.user_data, data->nodes[i].children);
+ data->memory.free(data->memory.user_data, data->nodes[i].weights);
+ cgltf_free_extensions(data, data->nodes[i].extensions, data->nodes[i].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->nodes);
+
+ for (cgltf_size i = 0; i < data->scenes_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->scenes[i].name);
+ data->memory.free(data->memory.user_data, data->scenes[i].nodes);
+
+ cgltf_free_extensions(data, data->scenes[i].extensions, data->scenes[i].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->scenes);
+
+ for (cgltf_size i = 0; i < data->animations_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->animations[i].name);
+ for (cgltf_size j = 0; j < data->animations[i].samplers_count; ++j)
+ {
+ cgltf_free_extensions(data, data->animations[i].samplers[j].extensions, data->animations[i].samplers[j].extensions_count);
+ }
+ data->memory.free(data->memory.user_data, data->animations[i].samplers);
+
+ for (cgltf_size j = 0; j < data->animations[i].channels_count; ++j)
+ {
+ cgltf_free_extensions(data, data->animations[i].channels[j].extensions, data->animations[i].channels[j].extensions_count);
+ }
+ data->memory.free(data->memory.user_data, data->animations[i].channels);
+
+ cgltf_free_extensions(data, data->animations[i].extensions, data->animations[i].extensions_count);
+ }
+
+ data->memory.free(data->memory.user_data, data->animations);
+
+ for (cgltf_size i = 0; i < data->variants_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->variants[i].name);
+ }
+
+ data->memory.free(data->memory.user_data, data->variants);
+
+ cgltf_free_extensions(data, data->data_extensions, data->data_extensions_count);
+
+ for (cgltf_size i = 0; i < data->extensions_used_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->extensions_used[i]);
+ }
+
+ data->memory.free(data->memory.user_data, data->extensions_used);
+
+ for (cgltf_size i = 0; i < data->extensions_required_count; ++i)
+ {
+ data->memory.free(data->memory.user_data, data->extensions_required[i]);
+ }
+
+ data->memory.free(data->memory.user_data, data->extensions_required);
+
+ file_release(&data->memory, &data->file, data->file_data);
+
+ data->memory.free(data->memory.user_data, data);
+}
+
+void cgltf_node_transform_local(const cgltf_node* node, cgltf_float* out_matrix)
+{
+ cgltf_float* lm = out_matrix;
+
+ if (node->has_matrix)
+ {
+ memcpy(lm, node->matrix, sizeof(float) * 16);
+ }
+ else
+ {
+ float tx = node->translation[0];
+ float ty = node->translation[1];
+ float tz = node->translation[2];
+
+ float qx = node->rotation[0];
+ float qy = node->rotation[1];
+ float qz = node->rotation[2];
+ float qw = node->rotation[3];
+
+ float sx = node->scale[0];
+ float sy = node->scale[1];
+ float sz = node->scale[2];
+
+ lm[0] = (1 - 2 * qy*qy - 2 * qz*qz) * sx;
+ lm[1] = (2 * qx*qy + 2 * qz*qw) * sx;
+ lm[2] = (2 * qx*qz - 2 * qy*qw) * sx;
+ lm[3] = 0.f;
+
+ lm[4] = (2 * qx*qy - 2 * qz*qw) * sy;
+ lm[5] = (1 - 2 * qx*qx - 2 * qz*qz) * sy;
+ lm[6] = (2 * qy*qz + 2 * qx*qw) * sy;
+ lm[7] = 0.f;
+
+ lm[8] = (2 * qx*qz + 2 * qy*qw) * sz;
+ lm[9] = (2 * qy*qz - 2 * qx*qw) * sz;
+ lm[10] = (1 - 2 * qx*qx - 2 * qy*qy) * sz;
+ lm[11] = 0.f;
+
+ lm[12] = tx;
+ lm[13] = ty;
+ lm[14] = tz;
+ lm[15] = 1.f;
+ }
+}
+
+void cgltf_node_transform_world(const cgltf_node* node, cgltf_float* out_matrix)
+{
+ cgltf_float* lm = out_matrix;
+ cgltf_node_transform_local(node, lm);
+
+ const cgltf_node* parent = node->parent;
+
+ while (parent)
+ {
+ float pm[16];
+ cgltf_node_transform_local(parent, pm);
+
+ for (int i = 0; i < 4; ++i)
+ {
+ float l0 = lm[i * 4 + 0];
+ float l1 = lm[i * 4 + 1];
+ float l2 = lm[i * 4 + 2];
+
+ float r0 = l0 * pm[0] + l1 * pm[4] + l2 * pm[8];
+ float r1 = l0 * pm[1] + l1 * pm[5] + l2 * pm[9];
+ float r2 = l0 * pm[2] + l1 * pm[6] + l2 * pm[10];
+
+ lm[i * 4 + 0] = r0;
+ lm[i * 4 + 1] = r1;
+ lm[i * 4 + 2] = r2;
+ }
+
+ lm[12] += pm[12];
+ lm[13] += pm[13];
+ lm[14] += pm[14];
+
+ parent = parent->parent;
+ }
+}
+
+static cgltf_size cgltf_component_read_index(const void* in, cgltf_component_type component_type)
+{
+ switch (component_type)
+ {
+ case cgltf_component_type_r_16:
+ return *((const int16_t*) in);
+ case cgltf_component_type_r_16u:
+ return *((const uint16_t*) in);
+ case cgltf_component_type_r_32u:
+ return *((const uint32_t*) in);
+ case cgltf_component_type_r_32f:
+ return (cgltf_size)*((const float*) in);
+ case cgltf_component_type_r_8:
+ return *((const int8_t*) in);
+ case cgltf_component_type_r_8u:
+ return *((const uint8_t*) in);
+ default:
+ return 0;
+ }
+}
+
+static cgltf_float cgltf_component_read_float(const void* in, cgltf_component_type component_type, cgltf_bool normalized)
+{
+ if (component_type == cgltf_component_type_r_32f)
+ {
+ return *((const float*) in);
+ }
+
+ if (normalized)
+ {
+ switch (component_type)
+ {
+ // note: glTF spec doesn't currently define normalized conversions for 32-bit integers
+ case cgltf_component_type_r_16:
+ return *((const int16_t*) in) / (cgltf_float)32767;
+ case cgltf_component_type_r_16u:
+ return *((const uint16_t*) in) / (cgltf_float)65535;
+ case cgltf_component_type_r_8:
+ return *((const int8_t*) in) / (cgltf_float)127;
+ case cgltf_component_type_r_8u:
+ return *((const uint8_t*) in) / (cgltf_float)255;
+ default:
+ return 0;
+ }
+ }
+
+ return (cgltf_float)cgltf_component_read_index(in, component_type);
+}
+
+static cgltf_size cgltf_component_size(cgltf_component_type component_type);
+
+static cgltf_bool cgltf_element_read_float(const uint8_t* element, cgltf_type type, cgltf_component_type component_type, cgltf_bool normalized, cgltf_float* out, cgltf_size element_size)
+{
+ cgltf_size num_components = cgltf_num_components(type);
+
+ if (element_size < num_components) {
+ return 0;
+ }
+
+ // There are three special cases for component extraction, see #data-alignment in the 2.0 spec.
+
+ cgltf_size component_size = cgltf_component_size(component_type);
+
+ if (type == cgltf_type_mat2 && component_size == 1)
+ {
+ out[0] = cgltf_component_read_float(element, component_type, normalized);
+ out[1] = cgltf_component_read_float(element + 1, component_type, normalized);
+ out[2] = cgltf_component_read_float(element + 4, component_type, normalized);
+ out[3] = cgltf_component_read_float(element + 5, component_type, normalized);
+ return 1;
+ }
+
+ if (type == cgltf_type_mat3 && component_size == 1)
+ {
+ out[0] = cgltf_component_read_float(element, component_type, normalized);
+ out[1] = cgltf_component_read_float(element + 1, component_type, normalized);
+ out[2] = cgltf_component_read_float(element + 2, component_type, normalized);
+ out[3] = cgltf_component_read_float(element + 4, component_type, normalized);
+ out[4] = cgltf_component_read_float(element + 5, component_type, normalized);
+ out[5] = cgltf_component_read_float(element + 6, component_type, normalized);
+ out[6] = cgltf_component_read_float(element + 8, component_type, normalized);
+ out[7] = cgltf_component_read_float(element + 9, component_type, normalized);
+ out[8] = cgltf_component_read_float(element + 10, component_type, normalized);
+ return 1;
+ }
+
+ if (type == cgltf_type_mat3 && component_size == 2)
+ {
+ out[0] = cgltf_component_read_float(element, component_type, normalized);
+ out[1] = cgltf_component_read_float(element + 2, component_type, normalized);
+ out[2] = cgltf_component_read_float(element + 4, component_type, normalized);
+ out[3] = cgltf_component_read_float(element + 8, component_type, normalized);
+ out[4] = cgltf_component_read_float(element + 10, component_type, normalized);
+ out[5] = cgltf_component_read_float(element + 12, component_type, normalized);
+ out[6] = cgltf_component_read_float(element + 16, component_type, normalized);
+ out[7] = cgltf_component_read_float(element + 18, component_type, normalized);
+ out[8] = cgltf_component_read_float(element + 20, component_type, normalized);
+ return 1;
+ }
+
+ for (cgltf_size i = 0; i < num_components; ++i)
+ {
+ out[i] = cgltf_component_read_float(element + component_size * i, component_type, normalized);
+ }
+ return 1;
+}
+
+const uint8_t* cgltf_buffer_view_data(const cgltf_buffer_view* view)
+{
+ if (view->data)
+ return (const uint8_t*)view->data;
+
+ if (!view->buffer->data)
+ return NULL;
+
+ const uint8_t* result = (const uint8_t*)view->buffer->data;
+ result += view->offset;
+ return result;
+}
+
+cgltf_bool cgltf_accessor_read_float(const cgltf_accessor* accessor, cgltf_size index, cgltf_float* out, cgltf_size element_size)
+{
+ if (accessor->is_sparse)
+ {
+ return 0;
+ }
+ if (accessor->buffer_view == NULL)
+ {
+ memset(out, 0, element_size * sizeof(cgltf_float));
+ return 1;
+ }
+ const uint8_t* element = cgltf_buffer_view_data(accessor->buffer_view);
+ if (element == NULL)
+ {
+ return 0;
+ }
+ element += accessor->offset + accessor->stride * index;
+ return cgltf_element_read_float(element, accessor->type, accessor->component_type, accessor->normalized, out, element_size);
+}
+
+cgltf_size cgltf_accessor_unpack_floats(const cgltf_accessor* accessor, cgltf_float* out, cgltf_size float_count)
+{
+ cgltf_size floats_per_element = cgltf_num_components(accessor->type);
+ cgltf_size available_floats = accessor->count * floats_per_element;
+ if (out == NULL)
+ {
+ return available_floats;
+ }
+
+ float_count = available_floats < float_count ? available_floats : float_count;
+ cgltf_size element_count = float_count / floats_per_element;
+
+ // First pass: convert each element in the base accessor.
+ cgltf_float* dest = out;
+ cgltf_accessor dense = *accessor;
+ dense.is_sparse = 0;
+ for (cgltf_size index = 0; index < element_count; index++, dest += floats_per_element)
+ {
+ if (!cgltf_accessor_read_float(&dense, index, dest, floats_per_element))
+ {
+ return 0;
+ }
+ }
+
+ // Second pass: write out each element in the sparse accessor.
+ if (accessor->is_sparse)
+ {
+ const cgltf_accessor_sparse* sparse = &dense.sparse;
+
+ const uint8_t* index_data = cgltf_buffer_view_data(sparse->indices_buffer_view);
+ const uint8_t* reader_head = cgltf_buffer_view_data(sparse->values_buffer_view);
+
+ if (index_data == NULL || reader_head == NULL)
+ {
+ return 0;
+ }
+
+ index_data += sparse->indices_byte_offset;
+ reader_head += sparse->values_byte_offset;
+
+ cgltf_size index_stride = cgltf_component_size(sparse->indices_component_type);
+ for (cgltf_size reader_index = 0; reader_index < sparse->count; reader_index++, index_data += index_stride)
+ {
+ size_t writer_index = cgltf_component_read_index(index_data, sparse->indices_component_type);
+ float* writer_head = out + writer_index * floats_per_element;
+
+ if (!cgltf_element_read_float(reader_head, dense.type, dense.component_type, dense.normalized, writer_head, floats_per_element))
+ {
+ return 0;
+ }
+
+ reader_head += dense.stride;
+ }
+ }
+
+ return element_count * floats_per_element;
+}
+
+static cgltf_uint cgltf_component_read_uint(const void* in, cgltf_component_type component_type)
+{
+ switch (component_type)
+ {
+ case cgltf_component_type_r_8:
+ return *((const int8_t*) in);
+
+ case cgltf_component_type_r_8u:
+ return *((const uint8_t*) in);
+
+ case cgltf_component_type_r_16:
+ return *((const int16_t*) in);
+
+ case cgltf_component_type_r_16u:
+ return *((const uint16_t*) in);
+
+ case cgltf_component_type_r_32u:
+ return *((const uint32_t*) in);
+
+ default:
+ return 0;
+ }
+}
+
+static cgltf_bool cgltf_element_read_uint(const uint8_t* element, cgltf_type type, cgltf_component_type component_type, cgltf_uint* out, cgltf_size element_size)
+{
+ cgltf_size num_components = cgltf_num_components(type);
+
+ if (element_size < num_components)
+ {
+ return 0;
+ }
+
+ // Reading integer matrices is not a valid use case
+ if (type == cgltf_type_mat2 || type == cgltf_type_mat3 || type == cgltf_type_mat4)
+ {
+ return 0;
+ }
+
+ cgltf_size component_size = cgltf_component_size(component_type);
+
+ for (cgltf_size i = 0; i < num_components; ++i)
+ {
+ out[i] = cgltf_component_read_uint(element + component_size * i, component_type);
+ }
+ return 1;
+}
+
+cgltf_bool cgltf_accessor_read_uint(const cgltf_accessor* accessor, cgltf_size index, cgltf_uint* out, cgltf_size element_size)
+{
+ if (accessor->is_sparse)
+ {
+ return 0;
+ }
+ if (accessor->buffer_view == NULL)
+ {
+ memset(out, 0, element_size * sizeof( cgltf_uint ));
+ return 1;
+ }
+ const uint8_t* element = cgltf_buffer_view_data(accessor->buffer_view);
+ if (element == NULL)
+ {
+ return 0;
+ }
+ element += accessor->offset + accessor->stride * index;
+ return cgltf_element_read_uint(element, accessor->type, accessor->component_type, out, element_size);
+}
+
+cgltf_size cgltf_accessor_read_index(const cgltf_accessor* accessor, cgltf_size index)
+{
+ if (accessor->is_sparse)
+ {
+ return 0; // This is an error case, but we can't communicate the error with existing interface.
+ }
+ if (accessor->buffer_view == NULL)
+ {
+ return 0;
+ }
+ const uint8_t* element = cgltf_buffer_view_data(accessor->buffer_view);
+ if (element == NULL)
+ {
+ return 0; // This is an error case, but we can't communicate the error with existing interface.
+ }
+ element += accessor->offset + accessor->stride * index;
+ return cgltf_component_read_index(element, accessor->component_type);
+}
+
+#define CGLTF_ERROR_JSON -1
+#define CGLTF_ERROR_NOMEM -2
+#define CGLTF_ERROR_LEGACY -3
+
+#define CGLTF_CHECK_TOKTYPE(tok_, type_) if ((tok_).type != (type_)) { return CGLTF_ERROR_JSON; }
+#define CGLTF_CHECK_TOKTYPE_RETTYPE(tok_, type_, ret_) if ((tok_).type != (type_)) { return (ret_)CGLTF_ERROR_JSON; }
+#define CGLTF_CHECK_KEY(tok_) if ((tok_).type != JSMN_STRING || (tok_).size == 0) { return CGLTF_ERROR_JSON; } /* checking size for 0 verifies that a value follows the key */
+
+#define CGLTF_PTRINDEX(type, idx) (type*)((cgltf_size)idx + 1)
+#define CGLTF_PTRFIXUP(var, data, size) if (var) { if ((cgltf_size)var > size) { return CGLTF_ERROR_JSON; } var = &data[(cgltf_size)var-1]; }
+#define CGLTF_PTRFIXUP_REQ(var, data, size) if (!var || (cgltf_size)var > size) { return CGLTF_ERROR_JSON; } var = &data[(cgltf_size)var-1];
+
+static int cgltf_json_strcmp(jsmntok_t const* tok, const uint8_t* json_chunk, const char* str)
+{
+ CGLTF_CHECK_TOKTYPE(*tok, JSMN_STRING);
+ size_t const str_len = strlen(str);
+ size_t const name_length = tok->end - tok->start;
+ return (str_len == name_length) ? strncmp((const char*)json_chunk + tok->start, str, str_len) : 128;
+}
+
+static int cgltf_json_to_int(jsmntok_t const* tok, const uint8_t* json_chunk)
+{
+ CGLTF_CHECK_TOKTYPE(*tok, JSMN_PRIMITIVE);
+ char tmp[128];
+ int size = (cgltf_size)(tok->end - tok->start) < sizeof(tmp) ? tok->end - tok->start : (int)(sizeof(tmp) - 1);
+ strncpy(tmp, (const char*)json_chunk + tok->start, size);
+ tmp[size] = 0;
+ return CGLTF_ATOI(tmp);
+}
+
+static cgltf_size cgltf_json_to_size(jsmntok_t const* tok, const uint8_t* json_chunk)
+{
+ CGLTF_CHECK_TOKTYPE_RETTYPE(*tok, JSMN_PRIMITIVE, cgltf_size);
+ char tmp[128];
+ int size = (cgltf_size)(tok->end - tok->start) < sizeof(tmp) ? tok->end - tok->start : (int)(sizeof(tmp) - 1);
+ strncpy(tmp, (const char*)json_chunk + tok->start, size);
+ tmp[size] = 0;
+ return (cgltf_size)CGLTF_ATOLL(tmp);
+}
+
+static cgltf_float cgltf_json_to_float(jsmntok_t const* tok, const uint8_t* json_chunk)
+{
+ CGLTF_CHECK_TOKTYPE(*tok, JSMN_PRIMITIVE);
+ char tmp[128];
+ int size = (cgltf_size)(tok->end - tok->start) < sizeof(tmp) ? tok->end - tok->start : (int)(sizeof(tmp) - 1);
+ strncpy(tmp, (const char*)json_chunk + tok->start, size);
+ tmp[size] = 0;
+ return (cgltf_float)CGLTF_ATOF(tmp);
+}
+
+static cgltf_bool cgltf_json_to_bool(jsmntok_t const* tok, const uint8_t* json_chunk)
+{
+ int size = tok->end - tok->start;
+ return size == 4 && memcmp(json_chunk + tok->start, "true", 4) == 0;
+}
+
+static int cgltf_skip_json(jsmntok_t const* tokens, int i)
+{
+ int end = i + 1;
+
+ while (i < end)
+ {
+ switch (tokens[i].type)
+ {
+ case JSMN_OBJECT:
+ end += tokens[i].size * 2;
+ break;
+
+ case JSMN_ARRAY:
+ end += tokens[i].size;
+ break;
+
+ case JSMN_PRIMITIVE:
+ case JSMN_STRING:
+ break;
+
+ default:
+ return -1;
+ }
+
+ i++;
+ }
+
+ return i;
+}
+
+static void cgltf_fill_float_array(float* out_array, int size, float value)
+{
+ for (int j = 0; j < size; ++j)
+ {
+ out_array[j] = value;
+ }
+}
+
+static int cgltf_parse_json_float_array(jsmntok_t const* tokens, int i, const uint8_t* json_chunk, float* out_array, int size)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_ARRAY);
+ if (tokens[i].size != size)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+ ++i;
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
+ out_array[j] = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ return i;
+}
+
+static int cgltf_parse_json_string(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, char** out_string)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_STRING);
+ if (*out_string)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+ int size = tokens[i].end - tokens[i].start;
+ char* result = (char*)options->memory.alloc(options->memory.user_data, size + 1);
+ if (!result)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+ strncpy(result, (const char*)json_chunk + tokens[i].start, size);
+ result[size] = 0;
+ *out_string = result;
+ return i + 1;
+}
+
+static int cgltf_parse_json_array(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, size_t element_size, void** out_array, cgltf_size* out_size)
+{
+ (void)json_chunk;
+ if (tokens[i].type != JSMN_ARRAY)
+ {
+ return tokens[i].type == JSMN_OBJECT ? CGLTF_ERROR_LEGACY : CGLTF_ERROR_JSON;
+ }
+ if (*out_array)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+ int size = tokens[i].size;
+ void* result = cgltf_calloc(options, element_size, size);
+ if (!result)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+ *out_array = result;
+ *out_size = size;
+ return i + 1;
+}
+
+static int cgltf_parse_json_string_array(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, char*** out_array, cgltf_size* out_size)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_ARRAY);
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(char*), (void**)out_array, out_size);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < *out_size; ++j)
+ {
+ i = cgltf_parse_json_string(options, tokens, i, json_chunk, j + (*out_array));
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static void cgltf_parse_attribute_type(const char* name, cgltf_attribute_type* out_type, int* out_index)
+{
+ const char* us = strchr(name, '_');
+ size_t len = us ? (size_t)(us - name) : strlen(name);
+
+ if (len == 8 && strncmp(name, "POSITION", 8) == 0)
+ {
+ *out_type = cgltf_attribute_type_position;
+ }
+ else if (len == 6 && strncmp(name, "NORMAL", 6) == 0)
+ {
+ *out_type = cgltf_attribute_type_normal;
+ }
+ else if (len == 7 && strncmp(name, "TANGENT", 7) == 0)
+ {
+ *out_type = cgltf_attribute_type_tangent;
+ }
+ else if (len == 8 && strncmp(name, "TEXCOORD", 8) == 0)
+ {
+ *out_type = cgltf_attribute_type_texcoord;
+ }
+ else if (len == 5 && strncmp(name, "COLOR", 5) == 0)
+ {
+ *out_type = cgltf_attribute_type_color;
+ }
+ else if (len == 6 && strncmp(name, "JOINTS", 6) == 0)
+ {
+ *out_type = cgltf_attribute_type_joints;
+ }
+ else if (len == 7 && strncmp(name, "WEIGHTS", 7) == 0)
+ {
+ *out_type = cgltf_attribute_type_weights;
+ }
+ else
+ {
+ *out_type = cgltf_attribute_type_invalid;
+ }
+
+ if (us && *out_type != cgltf_attribute_type_invalid)
+ {
+ *out_index = CGLTF_ATOI(us + 1);
+ }
+}
+
+static int cgltf_parse_json_attribute_list(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_attribute** out_attributes, cgltf_size* out_attributes_count)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ if (*out_attributes)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ *out_attributes_count = tokens[i].size;
+ *out_attributes = (cgltf_attribute*)cgltf_calloc(options, sizeof(cgltf_attribute), *out_attributes_count);
+ ++i;
+
+ if (!*out_attributes)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+
+ for (cgltf_size j = 0; j < *out_attributes_count; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ i = cgltf_parse_json_string(options, tokens, i, json_chunk, &(*out_attributes)[j].name);
+ if (i < 0)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ cgltf_parse_attribute_type((*out_attributes)[j].name, &(*out_attributes)[j].type, &(*out_attributes)[j].index);
+
+ (*out_attributes)[j].data = CGLTF_PTRINDEX(cgltf_accessor, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_extras(jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_extras* out_extras)
+{
+ (void)json_chunk;
+ out_extras->start_offset = tokens[i].start;
+ out_extras->end_offset = tokens[i].end;
+ i = cgltf_skip_json(tokens, i);
+ return i;
+}
+
+static int cgltf_parse_json_unprocessed_extension(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_extension* out_extension)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_STRING);
+ CGLTF_CHECK_TOKTYPE(tokens[i+1], JSMN_OBJECT);
+ if (out_extension->name)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ cgltf_size name_length = tokens[i].end - tokens[i].start;
+ out_extension->name = (char*)options->memory.alloc(options->memory.user_data, name_length + 1);
+ if (!out_extension->name)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+ strncpy(out_extension->name, (const char*)json_chunk + tokens[i].start, name_length);
+ out_extension->name[name_length] = 0;
+ i++;
+
+ size_t start = tokens[i].start;
+ size_t size = tokens[i].end - start;
+ out_extension->data = (char*)options->memory.alloc(options->memory.user_data, size + 1);
+ if (!out_extension->data)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+ strncpy(out_extension->data, (const char*)json_chunk + start, size);
+ out_extension->data[size] = '\0';
+
+ i = cgltf_skip_json(tokens, i);
+
+ return i;
+}
+
+static int cgltf_parse_json_unprocessed_extensions(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_size* out_extensions_count, cgltf_extension** out_extensions)
+{
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ if(*out_extensions)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ int extensions_size = tokens[i].size;
+ *out_extensions_count = 0;
+ *out_extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
+
+ if (!*out_extensions)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+
+ ++i;
+
+ for (int j = 0; j < extensions_size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ cgltf_size extension_index = (*out_extensions_count)++;
+ cgltf_extension* extension = &((*out_extensions)[extension_index]);
+ i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, extension);
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_draco_mesh_compression(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_draco_mesh_compression* out_draco_mesh_compression)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "attributes") == 0)
+ {
+ i = cgltf_parse_json_attribute_list(options, tokens, i + 1, json_chunk, &out_draco_mesh_compression->attributes, &out_draco_mesh_compression->attributes_count);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "bufferView") == 0)
+ {
+ ++i;
+ out_draco_mesh_compression->buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_mesh_gpu_instancing(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_mesh_gpu_instancing* out_mesh_gpu_instancing)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "attributes") == 0)
+ {
+ i = cgltf_parse_json_attribute_list(options, tokens, i + 1, json_chunk, &out_mesh_gpu_instancing->attributes, &out_mesh_gpu_instancing->attributes_count);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "bufferView") == 0)
+ {
+ ++i;
+ out_mesh_gpu_instancing->buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_material_mapping_data(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_material_mapping* out_mappings, cgltf_size* offset)
+{
+ (void)options;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_ARRAY);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int obj_size = tokens[i].size;
+ ++i;
+
+ int material = -1;
+ int variants_tok = -1;
+ cgltf_extras extras = {0, 0};
+
+ for (int k = 0; k < obj_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "material") == 0)
+ {
+ ++i;
+ material = cgltf_json_to_int(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "variants") == 0)
+ {
+ variants_tok = i+1;
+ CGLTF_CHECK_TOKTYPE(tokens[variants_tok], JSMN_ARRAY);
+
+ i = cgltf_skip_json(tokens, i+1);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &extras);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ if (material < 0 || variants_tok < 0)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ if (out_mappings)
+ {
+ for (int k = 0; k < tokens[variants_tok].size; ++k)
+ {
+ int variant = cgltf_json_to_int(&tokens[variants_tok + 1 + k], json_chunk);
+ if (variant < 0)
+ return variant;
+
+ out_mappings[*offset].material = CGLTF_PTRINDEX(cgltf_material, material);
+ out_mappings[*offset].variant = variant;
+ out_mappings[*offset].extras = extras;
+
+ (*offset)++;
+ }
+ }
+ else
+ {
+ (*offset) += tokens[variants_tok].size;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_material_mappings(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_primitive* out_prim)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "mappings") == 0)
+ {
+ if (out_prim->mappings)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ cgltf_size mappings_offset = 0;
+ int k = cgltf_parse_json_material_mapping_data(options, tokens, i + 1, json_chunk, NULL, &mappings_offset);
+ if (k < 0)
+ {
+ return k;
+ }
+
+ out_prim->mappings_count = mappings_offset;
+ out_prim->mappings = (cgltf_material_mapping*)cgltf_calloc(options, sizeof(cgltf_material_mapping), out_prim->mappings_count);
+
+ mappings_offset = 0;
+ i = cgltf_parse_json_material_mapping_data(options, tokens, i + 1, json_chunk, out_prim->mappings, &mappings_offset);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_primitive(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_primitive* out_prim)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ out_prim->type = cgltf_primitive_type_triangles;
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "mode") == 0)
+ {
+ ++i;
+ out_prim->type
+ = (cgltf_primitive_type)
+ cgltf_json_to_int(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "indices") == 0)
+ {
+ ++i;
+ out_prim->indices = CGLTF_PTRINDEX(cgltf_accessor, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "material") == 0)
+ {
+ ++i;
+ out_prim->material = CGLTF_PTRINDEX(cgltf_material, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "attributes") == 0)
+ {
+ i = cgltf_parse_json_attribute_list(options, tokens, i + 1, json_chunk, &out_prim->attributes, &out_prim->attributes_count);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "targets") == 0)
+ {
+ i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_morph_target), (void**)&out_prim->targets, &out_prim->targets_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size k = 0; k < out_prim->targets_count; ++k)
+ {
+ i = cgltf_parse_json_attribute_list(options, tokens, i, json_chunk, &out_prim->targets[k].attributes, &out_prim->targets[k].attributes_count);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_prim->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ if(out_prim->extensions)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ int extensions_size = tokens[i].size;
+ out_prim->extensions_count = 0;
+ out_prim->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
+
+ if (!out_prim->extensions)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+
+ ++i;
+ for (int k = 0; k < extensions_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_draco_mesh_compression") == 0)
+ {
+ out_prim->has_draco_mesh_compression = 1;
+ i = cgltf_parse_json_draco_mesh_compression(options, tokens, i + 1, json_chunk, &out_prim->draco_mesh_compression);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_variants") == 0)
+ {
+ i = cgltf_parse_json_material_mappings(options, tokens, i + 1, json_chunk, out_prim);
+ }
+ else
+ {
+ i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_prim->extensions[out_prim->extensions_count++]));
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_mesh(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_mesh* out_mesh)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_mesh->name);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "primitives") == 0)
+ {
+ i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_primitive), (void**)&out_mesh->primitives, &out_mesh->primitives_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size prim_index = 0; prim_index < out_mesh->primitives_count; ++prim_index)
+ {
+ i = cgltf_parse_json_primitive(options, tokens, i, json_chunk, &out_mesh->primitives[prim_index]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "weights") == 0)
+ {
+ i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_float), (void**)&out_mesh->weights, &out_mesh->weights_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ i = cgltf_parse_json_float_array(tokens, i - 1, json_chunk, out_mesh->weights, (int)out_mesh->weights_count);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ ++i;
+
+ out_mesh->extras.start_offset = tokens[i].start;
+ out_mesh->extras.end_offset = tokens[i].end;
+
+ if (tokens[i].type == JSMN_OBJECT)
+ {
+ int extras_size = tokens[i].size;
+ ++i;
+
+ for (int k = 0; k < extras_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "targetNames") == 0 && tokens[i+1].type == JSMN_ARRAY)
+ {
+ i = cgltf_parse_json_string_array(options, tokens, i + 1, json_chunk, &out_mesh->target_names, &out_mesh->target_names_count);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i);
+ }
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_mesh->extensions_count, &out_mesh->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_meshes(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_mesh), (void**)&out_data->meshes, &out_data->meshes_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->meshes_count; ++j)
+ {
+ i = cgltf_parse_json_mesh(options, tokens, i, json_chunk, &out_data->meshes[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static cgltf_component_type cgltf_json_to_component_type(jsmntok_t const* tok, const uint8_t* json_chunk)
+{
+ int type = cgltf_json_to_int(tok, json_chunk);
+
+ switch (type)
+ {
+ case 5120:
+ return cgltf_component_type_r_8;
+ case 5121:
+ return cgltf_component_type_r_8u;
+ case 5122:
+ return cgltf_component_type_r_16;
+ case 5123:
+ return cgltf_component_type_r_16u;
+ case 5125:
+ return cgltf_component_type_r_32u;
+ case 5126:
+ return cgltf_component_type_r_32f;
+ default:
+ return cgltf_component_type_invalid;
+ }
+}
+
+static int cgltf_parse_json_accessor_sparse(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_accessor_sparse* out_sparse)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "count") == 0)
+ {
+ ++i;
+ out_sparse->count = cgltf_json_to_int(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "indices") == 0)
+ {
+ ++i;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int indices_size = tokens[i].size;
+ ++i;
+
+ for (int k = 0; k < indices_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "bufferView") == 0)
+ {
+ ++i;
+ out_sparse->indices_buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteOffset") == 0)
+ {
+ ++i;
+ out_sparse->indices_byte_offset = cgltf_json_to_size(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "componentType") == 0)
+ {
+ ++i;
+ out_sparse->indices_component_type = cgltf_json_to_component_type(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_sparse->indices_extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sparse->indices_extensions_count, &out_sparse->indices_extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "values") == 0)
+ {
+ ++i;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int values_size = tokens[i].size;
+ ++i;
+
+ for (int k = 0; k < values_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "bufferView") == 0)
+ {
+ ++i;
+ out_sparse->values_buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteOffset") == 0)
+ {
+ ++i;
+ out_sparse->values_byte_offset = cgltf_json_to_size(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_sparse->values_extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sparse->values_extensions_count, &out_sparse->values_extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_sparse->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sparse->extensions_count, &out_sparse->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_accessor(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_accessor* out_accessor)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_accessor->name);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "bufferView") == 0)
+ {
+ ++i;
+ out_accessor->buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteOffset") == 0)
+ {
+ ++i;
+ out_accessor->offset =
+ cgltf_json_to_size(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "componentType") == 0)
+ {
+ ++i;
+ out_accessor->component_type = cgltf_json_to_component_type(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "normalized") == 0)
+ {
+ ++i;
+ out_accessor->normalized = cgltf_json_to_bool(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "count") == 0)
+ {
+ ++i;
+ out_accessor->count =
+ cgltf_json_to_int(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "type") == 0)
+ {
+ ++i;
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "SCALAR") == 0)
+ {
+ out_accessor->type = cgltf_type_scalar;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "VEC2") == 0)
+ {
+ out_accessor->type = cgltf_type_vec2;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "VEC3") == 0)
+ {
+ out_accessor->type = cgltf_type_vec3;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "VEC4") == 0)
+ {
+ out_accessor->type = cgltf_type_vec4;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "MAT2") == 0)
+ {
+ out_accessor->type = cgltf_type_mat2;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "MAT3") == 0)
+ {
+ out_accessor->type = cgltf_type_mat3;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "MAT4") == 0)
+ {
+ out_accessor->type = cgltf_type_mat4;
+ }
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "min") == 0)
+ {
+ ++i;
+ out_accessor->has_min = 1;
+ // note: we can't parse the precise number of elements since type may not have been computed yet
+ int min_size = tokens[i].size > 16 ? 16 : tokens[i].size;
+ i = cgltf_parse_json_float_array(tokens, i, json_chunk, out_accessor->min, min_size);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "max") == 0)
+ {
+ ++i;
+ out_accessor->has_max = 1;
+ // note: we can't parse the precise number of elements since type may not have been computed yet
+ int max_size = tokens[i].size > 16 ? 16 : tokens[i].size;
+ i = cgltf_parse_json_float_array(tokens, i, json_chunk, out_accessor->max, max_size);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "sparse") == 0)
+ {
+ out_accessor->is_sparse = 1;
+ i = cgltf_parse_json_accessor_sparse(options, tokens, i + 1, json_chunk, &out_accessor->sparse);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_accessor->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_accessor->extensions_count, &out_accessor->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_texture_transform(jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_texture_transform* out_texture_transform)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "offset") == 0)
+ {
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_texture_transform->offset, 2);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "rotation") == 0)
+ {
+ ++i;
+ out_texture_transform->rotation = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "scale") == 0)
+ {
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_texture_transform->scale, 2);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "texCoord") == 0)
+ {
+ ++i;
+ out_texture_transform->has_texcoord = 1;
+ out_texture_transform->texcoord = cgltf_json_to_int(tokens + i, json_chunk);
+ ++i;
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_texture_view(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_texture_view* out_texture_view)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ out_texture_view->scale = 1.0f;
+ cgltf_fill_float_array(out_texture_view->transform.scale, 2, 1.0f);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "index") == 0)
+ {
+ ++i;
+ out_texture_view->texture = CGLTF_PTRINDEX(cgltf_texture, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "texCoord") == 0)
+ {
+ ++i;
+ out_texture_view->texcoord = cgltf_json_to_int(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "scale") == 0)
+ {
+ ++i;
+ out_texture_view->scale = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "strength") == 0)
+ {
+ ++i;
+ out_texture_view->scale = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_texture_view->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ if(out_texture_view->extensions)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ int extensions_size = tokens[i].size;
+ out_texture_view->extensions_count = 0;
+ out_texture_view->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
+
+ if (!out_texture_view->extensions)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+
+ ++i;
+
+ for (int k = 0; k < extensions_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_texture_transform") == 0)
+ {
+ out_texture_view->has_transform = 1;
+ i = cgltf_parse_json_texture_transform(tokens, i + 1, json_chunk, &out_texture_view->transform);
+ }
+ else
+ {
+ i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_texture_view->extensions[out_texture_view->extensions_count++]));
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_pbr_metallic_roughness(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_pbr_metallic_roughness* out_pbr)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "metallicFactor") == 0)
+ {
+ ++i;
+ out_pbr->metallic_factor =
+ cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "roughnessFactor") == 0)
+ {
+ ++i;
+ out_pbr->roughness_factor =
+ cgltf_json_to_float(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "baseColorFactor") == 0)
+ {
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_pbr->base_color_factor, 4);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "baseColorTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk,
+ &out_pbr->base_color_texture);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "metallicRoughnessTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk,
+ &out_pbr->metallic_roughness_texture);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_pbr->extras);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_pbr_specular_glossiness(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_pbr_specular_glossiness* out_pbr)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "diffuseFactor") == 0)
+ {
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_pbr->diffuse_factor, 4);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "specularFactor") == 0)
+ {
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_pbr->specular_factor, 3);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "glossinessFactor") == 0)
+ {
+ ++i;
+ out_pbr->glossiness_factor = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "diffuseTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_pbr->diffuse_texture);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "specularGlossinessTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_pbr->specular_glossiness_texture);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_clearcoat(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_clearcoat* out_clearcoat)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "clearcoatFactor") == 0)
+ {
+ ++i;
+ out_clearcoat->clearcoat_factor = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "clearcoatRoughnessFactor") == 0)
+ {
+ ++i;
+ out_clearcoat->clearcoat_roughness_factor = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "clearcoatTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_clearcoat->clearcoat_texture);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "clearcoatRoughnessTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_clearcoat->clearcoat_roughness_texture);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "clearcoatNormalTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_clearcoat->clearcoat_normal_texture);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_ior(jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_ior* out_ior)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ int size = tokens[i].size;
+ ++i;
+
+ // Default values
+ out_ior->ior = 1.5f;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "ior") == 0)
+ {
+ ++i;
+ out_ior->ior = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_specular(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_specular* out_specular)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ int size = tokens[i].size;
+ ++i;
+
+ // Default values
+ out_specular->specular_factor = 1.0f;
+ cgltf_fill_float_array(out_specular->specular_color_factor, 3, 1.0f);
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "specularFactor") == 0)
+ {
+ ++i;
+ out_specular->specular_factor = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "specularColorFactor") == 0)
+ {
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_specular->specular_color_factor, 3);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "specularTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_specular->specular_texture);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "specularColorTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_specular->specular_color_texture);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_transmission(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_transmission* out_transmission)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "transmissionFactor") == 0)
+ {
+ ++i;
+ out_transmission->transmission_factor = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "transmissionTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_transmission->transmission_texture);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_volume(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_volume* out_volume)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "thicknessFactor") == 0)
+ {
+ ++i;
+ out_volume->thickness_factor = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "thicknessTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_volume->thickness_texture);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "attenuationColor") == 0)
+ {
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_volume->attenuation_color, 3);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "attenuationDistance") == 0)
+ {
+ ++i;
+ out_volume->attenuation_distance = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_sheen(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_sheen* out_sheen)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "sheenColorFactor") == 0)
+ {
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_sheen->sheen_color_factor, 3);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "sheenColorTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_sheen->sheen_color_texture);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "sheenRoughnessFactor") == 0)
+ {
+ ++i;
+ out_sheen->sheen_roughness_factor = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "sheenRoughnessTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_sheen->sheen_roughness_texture);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_emissive_strength(jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_emissive_strength* out_emissive_strength)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ int size = tokens[i].size;
+ ++i;
+
+ // Default
+ out_emissive_strength->emissive_strength = 1.f;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "emissiveStrength") == 0)
+ {
+ ++i;
+ out_emissive_strength->emissive_strength = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_iridescence(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_iridescence* out_iridescence)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ int size = tokens[i].size;
+ ++i;
+
+ // Default
+ out_iridescence->iridescence_ior = 1.3f;
+ out_iridescence->iridescence_thickness_min = 100.f;
+ out_iridescence->iridescence_thickness_max = 400.f;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "iridescenceFactor") == 0)
+ {
+ ++i;
+ out_iridescence->iridescence_factor = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "iridescenceTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_iridescence->iridescence_texture);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "iridescenceIor") == 0)
+ {
+ ++i;
+ out_iridescence->iridescence_ior = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "iridescenceThicknessMinimum") == 0)
+ {
+ ++i;
+ out_iridescence->iridescence_thickness_min = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "iridescenceThicknessMaximum") == 0)
+ {
+ ++i;
+ out_iridescence->iridescence_thickness_max = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "iridescenceThicknessTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_iridescence->iridescence_thickness_texture);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_image(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_image* out_image)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "uri") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_image->uri);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "bufferView") == 0)
+ {
+ ++i;
+ out_image->buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "mimeType") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_image->mime_type);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_image->name);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_image->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_image->extensions_count, &out_image->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_sampler(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_sampler* out_sampler)
+{
+ (void)options;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ out_sampler->wrap_s = 10497;
+ out_sampler->wrap_t = 10497;
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_sampler->name);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "magFilter") == 0)
+ {
+ ++i;
+ out_sampler->mag_filter
+ = cgltf_json_to_int(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "minFilter") == 0)
+ {
+ ++i;
+ out_sampler->min_filter
+ = cgltf_json_to_int(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "wrapS") == 0)
+ {
+ ++i;
+ out_sampler->wrap_s
+ = cgltf_json_to_int(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "wrapT") == 0)
+ {
+ ++i;
+ out_sampler->wrap_t
+ = cgltf_json_to_int(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_sampler->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sampler->extensions_count, &out_sampler->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_texture(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_texture* out_texture)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_texture->name);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "sampler") == 0)
+ {
+ ++i;
+ out_texture->sampler = CGLTF_PTRINDEX(cgltf_sampler, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "source") == 0)
+ {
+ ++i;
+ out_texture->image = CGLTF_PTRINDEX(cgltf_image, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_texture->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ if (out_texture->extensions)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ int extensions_size = tokens[i].size;
+ ++i;
+ out_texture->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
+ out_texture->extensions_count = 0;
+
+ if (!out_texture->extensions)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+
+ for (int k = 0; k < extensions_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "KHR_texture_basisu") == 0)
+ {
+ out_texture->has_basisu = 1;
+ ++i;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ int num_properties = tokens[i].size;
+ ++i;
+
+ for (int t = 0; t < num_properties; ++t)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "source") == 0)
+ {
+ ++i;
+ out_texture->basisu_image = CGLTF_PTRINDEX(cgltf_image, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else
+ {
+ i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_texture->extensions[out_texture->extensions_count++]));
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_material(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_material* out_material)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ cgltf_fill_float_array(out_material->pbr_metallic_roughness.base_color_factor, 4, 1.0f);
+ out_material->pbr_metallic_roughness.metallic_factor = 1.0f;
+ out_material->pbr_metallic_roughness.roughness_factor = 1.0f;
+
+ cgltf_fill_float_array(out_material->pbr_specular_glossiness.diffuse_factor, 4, 1.0f);
+ cgltf_fill_float_array(out_material->pbr_specular_glossiness.specular_factor, 3, 1.0f);
+ out_material->pbr_specular_glossiness.glossiness_factor = 1.0f;
+
+ cgltf_fill_float_array(out_material->volume.attenuation_color, 3, 1.0f);
+ out_material->volume.attenuation_distance = FLT_MAX;
+
+ out_material->alpha_cutoff = 0.5f;
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_material->name);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "pbrMetallicRoughness") == 0)
+ {
+ out_material->has_pbr_metallic_roughness = 1;
+ i = cgltf_parse_json_pbr_metallic_roughness(options, tokens, i + 1, json_chunk, &out_material->pbr_metallic_roughness);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "emissiveFactor") == 0)
+ {
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_material->emissive_factor, 3);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "normalTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk,
+ &out_material->normal_texture);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "occlusionTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk,
+ &out_material->occlusion_texture);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "emissiveTexture") == 0)
+ {
+ i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk,
+ &out_material->emissive_texture);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "alphaMode") == 0)
+ {
+ ++i;
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "OPAQUE") == 0)
+ {
+ out_material->alpha_mode = cgltf_alpha_mode_opaque;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "MASK") == 0)
+ {
+ out_material->alpha_mode = cgltf_alpha_mode_mask;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "BLEND") == 0)
+ {
+ out_material->alpha_mode = cgltf_alpha_mode_blend;
+ }
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "alphaCutoff") == 0)
+ {
+ ++i;
+ out_material->alpha_cutoff = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "doubleSided") == 0)
+ {
+ ++i;
+ out_material->double_sided =
+ cgltf_json_to_bool(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_material->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ if(out_material->extensions)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ int extensions_size = tokens[i].size;
+ ++i;
+ out_material->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
+ out_material->extensions_count= 0;
+
+ if (!out_material->extensions)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+
+ for (int k = 0; k < extensions_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_pbrSpecularGlossiness") == 0)
+ {
+ out_material->has_pbr_specular_glossiness = 1;
+ i = cgltf_parse_json_pbr_specular_glossiness(options, tokens, i + 1, json_chunk, &out_material->pbr_specular_glossiness);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_unlit") == 0)
+ {
+ out_material->unlit = 1;
+ i = cgltf_skip_json(tokens, i+1);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_clearcoat") == 0)
+ {
+ out_material->has_clearcoat = 1;
+ i = cgltf_parse_json_clearcoat(options, tokens, i + 1, json_chunk, &out_material->clearcoat);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_ior") == 0)
+ {
+ out_material->has_ior = 1;
+ i = cgltf_parse_json_ior(tokens, i + 1, json_chunk, &out_material->ior);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_specular") == 0)
+ {
+ out_material->has_specular = 1;
+ i = cgltf_parse_json_specular(options, tokens, i + 1, json_chunk, &out_material->specular);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_transmission") == 0)
+ {
+ out_material->has_transmission = 1;
+ i = cgltf_parse_json_transmission(options, tokens, i + 1, json_chunk, &out_material->transmission);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "KHR_materials_volume") == 0)
+ {
+ out_material->has_volume = 1;
+ i = cgltf_parse_json_volume(options, tokens, i + 1, json_chunk, &out_material->volume);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_sheen") == 0)
+ {
+ out_material->has_sheen = 1;
+ i = cgltf_parse_json_sheen(options, tokens, i + 1, json_chunk, &out_material->sheen);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "KHR_materials_emissive_strength") == 0)
+ {
+ out_material->has_emissive_strength = 1;
+ i = cgltf_parse_json_emissive_strength(tokens, i + 1, json_chunk, &out_material->emissive_strength);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "KHR_materials_iridescence") == 0)
+ {
+ out_material->has_iridescence = 1;
+ i = cgltf_parse_json_iridescence(options, tokens, i + 1, json_chunk, &out_material->iridescence);
+ }
+ else
+ {
+ i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_material->extensions[out_material->extensions_count++]));
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_accessors(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_accessor), (void**)&out_data->accessors, &out_data->accessors_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->accessors_count; ++j)
+ {
+ i = cgltf_parse_json_accessor(options, tokens, i, json_chunk, &out_data->accessors[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_materials(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_material), (void**)&out_data->materials, &out_data->materials_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->materials_count; ++j)
+ {
+ i = cgltf_parse_json_material(options, tokens, i, json_chunk, &out_data->materials[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_images(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_image), (void**)&out_data->images, &out_data->images_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->images_count; ++j)
+ {
+ i = cgltf_parse_json_image(options, tokens, i, json_chunk, &out_data->images[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_textures(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_texture), (void**)&out_data->textures, &out_data->textures_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->textures_count; ++j)
+ {
+ i = cgltf_parse_json_texture(options, tokens, i, json_chunk, &out_data->textures[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_samplers(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_sampler), (void**)&out_data->samplers, &out_data->samplers_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->samplers_count; ++j)
+ {
+ i = cgltf_parse_json_sampler(options, tokens, i, json_chunk, &out_data->samplers[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_meshopt_compression(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_meshopt_compression* out_meshopt_compression)
+{
+ (void)options;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "buffer") == 0)
+ {
+ ++i;
+ out_meshopt_compression->buffer = CGLTF_PTRINDEX(cgltf_buffer, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteOffset") == 0)
+ {
+ ++i;
+ out_meshopt_compression->offset = cgltf_json_to_size(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteLength") == 0)
+ {
+ ++i;
+ out_meshopt_compression->size = cgltf_json_to_size(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteStride") == 0)
+ {
+ ++i;
+ out_meshopt_compression->stride = cgltf_json_to_size(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "count") == 0)
+ {
+ ++i;
+ out_meshopt_compression->count = cgltf_json_to_int(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "mode") == 0)
+ {
+ ++i;
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "ATTRIBUTES") == 0)
+ {
+ out_meshopt_compression->mode = cgltf_meshopt_compression_mode_attributes;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "TRIANGLES") == 0)
+ {
+ out_meshopt_compression->mode = cgltf_meshopt_compression_mode_triangles;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "INDICES") == 0)
+ {
+ out_meshopt_compression->mode = cgltf_meshopt_compression_mode_indices;
+ }
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "filter") == 0)
+ {
+ ++i;
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "NONE") == 0)
+ {
+ out_meshopt_compression->filter = cgltf_meshopt_compression_filter_none;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "OCTAHEDRAL") == 0)
+ {
+ out_meshopt_compression->filter = cgltf_meshopt_compression_filter_octahedral;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "QUATERNION") == 0)
+ {
+ out_meshopt_compression->filter = cgltf_meshopt_compression_filter_quaternion;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "EXPONENTIAL") == 0)
+ {
+ out_meshopt_compression->filter = cgltf_meshopt_compression_filter_exponential;
+ }
+ ++i;
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_buffer_view(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_buffer_view* out_buffer_view)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_buffer_view->name);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "buffer") == 0)
+ {
+ ++i;
+ out_buffer_view->buffer = CGLTF_PTRINDEX(cgltf_buffer, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteOffset") == 0)
+ {
+ ++i;
+ out_buffer_view->offset =
+ cgltf_json_to_size(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteLength") == 0)
+ {
+ ++i;
+ out_buffer_view->size =
+ cgltf_json_to_size(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteStride") == 0)
+ {
+ ++i;
+ out_buffer_view->stride =
+ cgltf_json_to_size(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "target") == 0)
+ {
+ ++i;
+ int type = cgltf_json_to_int(tokens+i, json_chunk);
+ switch (type)
+ {
+ case 34962:
+ type = cgltf_buffer_view_type_vertices;
+ break;
+ case 34963:
+ type = cgltf_buffer_view_type_indices;
+ break;
+ default:
+ type = cgltf_buffer_view_type_invalid;
+ break;
+ }
+ out_buffer_view->type = (cgltf_buffer_view_type)type;
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_buffer_view->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ if(out_buffer_view->extensions)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ int extensions_size = tokens[i].size;
+ out_buffer_view->extensions_count = 0;
+ out_buffer_view->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
+
+ if (!out_buffer_view->extensions)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+
+ ++i;
+ for (int k = 0; k < extensions_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "EXT_meshopt_compression") == 0)
+ {
+ out_buffer_view->has_meshopt_compression = 1;
+ i = cgltf_parse_json_meshopt_compression(options, tokens, i + 1, json_chunk, &out_buffer_view->meshopt_compression);
+ }
+ else
+ {
+ i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_buffer_view->extensions[out_buffer_view->extensions_count++]));
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_buffer_views(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_buffer_view), (void**)&out_data->buffer_views, &out_data->buffer_views_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->buffer_views_count; ++j)
+ {
+ i = cgltf_parse_json_buffer_view(options, tokens, i, json_chunk, &out_data->buffer_views[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_buffer(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_buffer* out_buffer)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_buffer->name);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteLength") == 0)
+ {
+ ++i;
+ out_buffer->size =
+ cgltf_json_to_size(tokens+i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "uri") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_buffer->uri);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_buffer->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_buffer->extensions_count, &out_buffer->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_buffers(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_buffer), (void**)&out_data->buffers, &out_data->buffers_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->buffers_count; ++j)
+ {
+ i = cgltf_parse_json_buffer(options, tokens, i, json_chunk, &out_data->buffers[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_skin(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_skin* out_skin)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_skin->name);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "joints") == 0)
+ {
+ i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_node*), (void**)&out_skin->joints, &out_skin->joints_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size k = 0; k < out_skin->joints_count; ++k)
+ {
+ out_skin->joints[k] = CGLTF_PTRINDEX(cgltf_node, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "skeleton") == 0)
+ {
+ ++i;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
+ out_skin->skeleton = CGLTF_PTRINDEX(cgltf_node, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "inverseBindMatrices") == 0)
+ {
+ ++i;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
+ out_skin->inverse_bind_matrices = CGLTF_PTRINDEX(cgltf_accessor, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_skin->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_skin->extensions_count, &out_skin->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_skins(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_skin), (void**)&out_data->skins, &out_data->skins_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->skins_count; ++j)
+ {
+ i = cgltf_parse_json_skin(options, tokens, i, json_chunk, &out_data->skins[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_camera(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_camera* out_camera)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_camera->name);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "type") == 0)
+ {
+ ++i;
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "perspective") == 0)
+ {
+ out_camera->type = cgltf_camera_type_perspective;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "orthographic") == 0)
+ {
+ out_camera->type = cgltf_camera_type_orthographic;
+ }
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "perspective") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int data_size = tokens[i].size;
+ ++i;
+
+ out_camera->type = cgltf_camera_type_perspective;
+
+ for (int k = 0; k < data_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "aspectRatio") == 0)
+ {
+ ++i;
+ out_camera->data.perspective.has_aspect_ratio = 1;
+ out_camera->data.perspective.aspect_ratio = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "yfov") == 0)
+ {
+ ++i;
+ out_camera->data.perspective.yfov = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "zfar") == 0)
+ {
+ ++i;
+ out_camera->data.perspective.has_zfar = 1;
+ out_camera->data.perspective.zfar = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "znear") == 0)
+ {
+ ++i;
+ out_camera->data.perspective.znear = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_camera->data.perspective.extras);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "orthographic") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int data_size = tokens[i].size;
+ ++i;
+
+ out_camera->type = cgltf_camera_type_orthographic;
+
+ for (int k = 0; k < data_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "xmag") == 0)
+ {
+ ++i;
+ out_camera->data.orthographic.xmag = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "ymag") == 0)
+ {
+ ++i;
+ out_camera->data.orthographic.ymag = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "zfar") == 0)
+ {
+ ++i;
+ out_camera->data.orthographic.zfar = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "znear") == 0)
+ {
+ ++i;
+ out_camera->data.orthographic.znear = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_camera->data.orthographic.extras);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_camera->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_camera->extensions_count, &out_camera->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_cameras(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_camera), (void**)&out_data->cameras, &out_data->cameras_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->cameras_count; ++j)
+ {
+ i = cgltf_parse_json_camera(options, tokens, i, json_chunk, &out_data->cameras[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_light(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_light* out_light)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ out_light->color[0] = 1.f;
+ out_light->color[1] = 1.f;
+ out_light->color[2] = 1.f;
+ out_light->intensity = 1.f;
+
+ out_light->spot_inner_cone_angle = 0.f;
+ out_light->spot_outer_cone_angle = 3.1415926535f / 4.0f;
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_light->name);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "color") == 0)
+ {
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_light->color, 3);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "intensity") == 0)
+ {
+ ++i;
+ out_light->intensity = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "type") == 0)
+ {
+ ++i;
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "directional") == 0)
+ {
+ out_light->type = cgltf_light_type_directional;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "point") == 0)
+ {
+ out_light->type = cgltf_light_type_point;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "spot") == 0)
+ {
+ out_light->type = cgltf_light_type_spot;
+ }
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "range") == 0)
+ {
+ ++i;
+ out_light->range = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "spot") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int data_size = tokens[i].size;
+ ++i;
+
+ for (int k = 0; k < data_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "innerConeAngle") == 0)
+ {
+ ++i;
+ out_light->spot_inner_cone_angle = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "outerConeAngle") == 0)
+ {
+ ++i;
+ out_light->spot_outer_cone_angle = cgltf_json_to_float(tokens + i, json_chunk);
+ ++i;
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_light->extras);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_lights(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_light), (void**)&out_data->lights, &out_data->lights_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->lights_count; ++j)
+ {
+ i = cgltf_parse_json_light(options, tokens, i, json_chunk, &out_data->lights[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_node(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_node* out_node)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ out_node->rotation[3] = 1.0f;
+ out_node->scale[0] = 1.0f;
+ out_node->scale[1] = 1.0f;
+ out_node->scale[2] = 1.0f;
+ out_node->matrix[0] = 1.0f;
+ out_node->matrix[5] = 1.0f;
+ out_node->matrix[10] = 1.0f;
+ out_node->matrix[15] = 1.0f;
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_node->name);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "children") == 0)
+ {
+ i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_node*), (void**)&out_node->children, &out_node->children_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size k = 0; k < out_node->children_count; ++k)
+ {
+ out_node->children[k] = CGLTF_PTRINDEX(cgltf_node, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "mesh") == 0)
+ {
+ ++i;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
+ out_node->mesh = CGLTF_PTRINDEX(cgltf_mesh, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "skin") == 0)
+ {
+ ++i;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
+ out_node->skin = CGLTF_PTRINDEX(cgltf_skin, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "camera") == 0)
+ {
+ ++i;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
+ out_node->camera = CGLTF_PTRINDEX(cgltf_camera, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "translation") == 0)
+ {
+ out_node->has_translation = 1;
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_node->translation, 3);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "rotation") == 0)
+ {
+ out_node->has_rotation = 1;
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_node->rotation, 4);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "scale") == 0)
+ {
+ out_node->has_scale = 1;
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_node->scale, 3);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "matrix") == 0)
+ {
+ out_node->has_matrix = 1;
+ i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_node->matrix, 16);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "weights") == 0)
+ {
+ i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_float), (void**)&out_node->weights, &out_node->weights_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ i = cgltf_parse_json_float_array(tokens, i - 1, json_chunk, out_node->weights, (int)out_node->weights_count);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_node->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ if(out_node->extensions)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ int extensions_size = tokens[i].size;
+ out_node->extensions_count= 0;
+ out_node->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
+
+ if (!out_node->extensions)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+
+ ++i;
+
+ for (int k = 0; k < extensions_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_lights_punctual") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int data_size = tokens[i].size;
+ ++i;
+
+ for (int m = 0; m < data_size; ++m)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "light") == 0)
+ {
+ ++i;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
+ out_node->light = CGLTF_PTRINDEX(cgltf_light, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "EXT_mesh_gpu_instancing") == 0)
+ {
+ out_node->has_mesh_gpu_instancing = 1;
+ i = cgltf_parse_json_mesh_gpu_instancing(options, tokens, i + 1, json_chunk, &out_node->mesh_gpu_instancing);
+ }
+ else
+ {
+ i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_node->extensions[out_node->extensions_count++]));
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_nodes(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_node), (void**)&out_data->nodes, &out_data->nodes_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->nodes_count; ++j)
+ {
+ i = cgltf_parse_json_node(options, tokens, i, json_chunk, &out_data->nodes[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_scene(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_scene* out_scene)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_scene->name);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "nodes") == 0)
+ {
+ i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_node*), (void**)&out_scene->nodes, &out_scene->nodes_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size k = 0; k < out_scene->nodes_count; ++k)
+ {
+ out_scene->nodes[k] = CGLTF_PTRINDEX(cgltf_node, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_scene->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_scene->extensions_count, &out_scene->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_scenes(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_scene), (void**)&out_data->scenes, &out_data->scenes_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->scenes_count; ++j)
+ {
+ i = cgltf_parse_json_scene(options, tokens, i, json_chunk, &out_data->scenes[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_animation_sampler(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_animation_sampler* out_sampler)
+{
+ (void)options;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "input") == 0)
+ {
+ ++i;
+ out_sampler->input = CGLTF_PTRINDEX(cgltf_accessor, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "output") == 0)
+ {
+ ++i;
+ out_sampler->output = CGLTF_PTRINDEX(cgltf_accessor, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "interpolation") == 0)
+ {
+ ++i;
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "LINEAR") == 0)
+ {
+ out_sampler->interpolation = cgltf_interpolation_type_linear;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "STEP") == 0)
+ {
+ out_sampler->interpolation = cgltf_interpolation_type_step;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "CUBICSPLINE") == 0)
+ {
+ out_sampler->interpolation = cgltf_interpolation_type_cubic_spline;
+ }
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_sampler->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sampler->extensions_count, &out_sampler->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_animation_channel(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_animation_channel* out_channel)
+{
+ (void)options;
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "sampler") == 0)
+ {
+ ++i;
+ out_channel->sampler = CGLTF_PTRINDEX(cgltf_animation_sampler, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "target") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int target_size = tokens[i].size;
+ ++i;
+
+ for (int k = 0; k < target_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "node") == 0)
+ {
+ ++i;
+ out_channel->target_node = CGLTF_PTRINDEX(cgltf_node, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "path") == 0)
+ {
+ ++i;
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "translation") == 0)
+ {
+ out_channel->target_path = cgltf_animation_path_type_translation;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "rotation") == 0)
+ {
+ out_channel->target_path = cgltf_animation_path_type_rotation;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "scale") == 0)
+ {
+ out_channel->target_path = cgltf_animation_path_type_scale;
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "weights") == 0)
+ {
+ out_channel->target_path = cgltf_animation_path_type_weights;
+ }
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_channel->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_channel->extensions_count, &out_channel->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_animation(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_animation* out_animation)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_animation->name);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "samplers") == 0)
+ {
+ i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_animation_sampler), (void**)&out_animation->samplers, &out_animation->samplers_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size k = 0; k < out_animation->samplers_count; ++k)
+ {
+ i = cgltf_parse_json_animation_sampler(options, tokens, i, json_chunk, &out_animation->samplers[k]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "channels") == 0)
+ {
+ i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_animation_channel), (void**)&out_animation->channels, &out_animation->channels_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size k = 0; k < out_animation->channels_count; ++k)
+ {
+ i = cgltf_parse_json_animation_channel(options, tokens, i, json_chunk, &out_animation->channels[k]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_animation->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_animation->extensions_count, &out_animation->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_animations(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_animation), (void**)&out_data->animations, &out_data->animations_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->animations_count; ++j)
+ {
+ i = cgltf_parse_json_animation(options, tokens, i, json_chunk, &out_data->animations[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_variant(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_material_variant* out_variant)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_variant->name);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_variant->extras);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+static int cgltf_parse_json_variants(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_material_variant), (void**)&out_data->variants, &out_data->variants_count);
+ if (i < 0)
+ {
+ return i;
+ }
+
+ for (cgltf_size j = 0; j < out_data->variants_count; ++j)
+ {
+ i = cgltf_parse_json_variant(options, tokens, i, json_chunk, &out_data->variants[j]);
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+static int cgltf_parse_json_asset(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_asset* out_asset)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "copyright") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_asset->copyright);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "generator") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_asset->generator);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "version") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_asset->version);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "minVersion") == 0)
+ {
+ i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_asset->min_version);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_asset->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_asset->extensions_count, &out_asset->extensions);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i+1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ if (out_asset->version && CGLTF_ATOF(out_asset->version) < 2)
+ {
+ return CGLTF_ERROR_LEGACY;
+ }
+
+ return i;
+}
+
+cgltf_size cgltf_num_components(cgltf_type type) {
+ switch (type)
+ {
+ case cgltf_type_vec2:
+ return 2;
+ case cgltf_type_vec3:
+ return 3;
+ case cgltf_type_vec4:
+ return 4;
+ case cgltf_type_mat2:
+ return 4;
+ case cgltf_type_mat3:
+ return 9;
+ case cgltf_type_mat4:
+ return 16;
+ case cgltf_type_invalid:
+ case cgltf_type_scalar:
+ default:
+ return 1;
+ }
+}
+
+static cgltf_size cgltf_component_size(cgltf_component_type component_type) {
+ switch (component_type)
+ {
+ case cgltf_component_type_r_8:
+ case cgltf_component_type_r_8u:
+ return 1;
+ case cgltf_component_type_r_16:
+ case cgltf_component_type_r_16u:
+ return 2;
+ case cgltf_component_type_r_32u:
+ case cgltf_component_type_r_32f:
+ return 4;
+ case cgltf_component_type_invalid:
+ default:
+ return 0;
+ }
+}
+
+static cgltf_size cgltf_calc_size(cgltf_type type, cgltf_component_type component_type)
+{
+ cgltf_size component_size = cgltf_component_size(component_type);
+ if (type == cgltf_type_mat2 && component_size == 1)
+ {
+ return 8 * component_size;
+ }
+ else if (type == cgltf_type_mat3 && (component_size == 1 || component_size == 2))
+ {
+ return 12 * component_size;
+ }
+ return component_size * cgltf_num_components(type);
+}
+
+static int cgltf_fixup_pointers(cgltf_data* out_data);
+
+static int cgltf_parse_json_root(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
+{
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int size = tokens[i].size;
+ ++i;
+
+ for (int j = 0; j < size; ++j)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "asset") == 0)
+ {
+ i = cgltf_parse_json_asset(options, tokens, i + 1, json_chunk, &out_data->asset);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "meshes") == 0)
+ {
+ i = cgltf_parse_json_meshes(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "accessors") == 0)
+ {
+ i = cgltf_parse_json_accessors(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "bufferViews") == 0)
+ {
+ i = cgltf_parse_json_buffer_views(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "buffers") == 0)
+ {
+ i = cgltf_parse_json_buffers(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "materials") == 0)
+ {
+ i = cgltf_parse_json_materials(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "images") == 0)
+ {
+ i = cgltf_parse_json_images(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "textures") == 0)
+ {
+ i = cgltf_parse_json_textures(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "samplers") == 0)
+ {
+ i = cgltf_parse_json_samplers(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "skins") == 0)
+ {
+ i = cgltf_parse_json_skins(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "cameras") == 0)
+ {
+ i = cgltf_parse_json_cameras(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "nodes") == 0)
+ {
+ i = cgltf_parse_json_nodes(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "scenes") == 0)
+ {
+ i = cgltf_parse_json_scenes(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "scene") == 0)
+ {
+ ++i;
+ out_data->scene = CGLTF_PTRINDEX(cgltf_scene, cgltf_json_to_int(tokens + i, json_chunk));
+ ++i;
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "animations") == 0)
+ {
+ i = cgltf_parse_json_animations(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "extras") == 0)
+ {
+ i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_data->extras);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+ if(out_data->data_extensions)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ int extensions_size = tokens[i].size;
+ out_data->data_extensions_count = 0;
+ out_data->data_extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
+
+ if (!out_data->data_extensions)
+ {
+ return CGLTF_ERROR_NOMEM;
+ }
+
+ ++i;
+
+ for (int k = 0; k < extensions_size; ++k)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_lights_punctual") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int data_size = tokens[i].size;
+ ++i;
+
+ for (int m = 0; m < data_size; ++m)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "lights") == 0)
+ {
+ i = cgltf_parse_json_lights(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_variants") == 0)
+ {
+ ++i;
+
+ CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
+
+ int data_size = tokens[i].size;
+ ++i;
+
+ for (int m = 0; m < data_size; ++m)
+ {
+ CGLTF_CHECK_KEY(tokens[i]);
+
+ if (cgltf_json_strcmp(tokens + i, json_chunk, "variants") == 0)
+ {
+ i = cgltf_parse_json_variants(options, tokens, i + 1, json_chunk, out_data);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else
+ {
+ i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_data->data_extensions[out_data->data_extensions_count++]));
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensionsUsed") == 0)
+ {
+ i = cgltf_parse_json_string_array(options, tokens, i + 1, json_chunk, &out_data->extensions_used, &out_data->extensions_used_count);
+ }
+ else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensionsRequired") == 0)
+ {
+ i = cgltf_parse_json_string_array(options, tokens, i + 1, json_chunk, &out_data->extensions_required, &out_data->extensions_required_count);
+ }
+ else
+ {
+ i = cgltf_skip_json(tokens, i + 1);
+ }
+
+ if (i < 0)
+ {
+ return i;
+ }
+ }
+
+ return i;
+}
+
+cgltf_result cgltf_parse_json(cgltf_options* options, const uint8_t* json_chunk, cgltf_size size, cgltf_data** out_data)
+{
+ jsmn_parser parser = { 0, 0, 0 };
+
+ if (options->json_token_count == 0)
+ {
+ int token_count = jsmn_parse(&parser, (const char*)json_chunk, size, NULL, 0);
+
+ if (token_count <= 0)
+ {
+ return cgltf_result_invalid_json;
+ }
+
+ options->json_token_count = token_count;
+ }
+
+ jsmntok_t* tokens = (jsmntok_t*)options->memory.alloc(options->memory.user_data, sizeof(jsmntok_t) * (options->json_token_count + 1));
+
+ if (!tokens)
+ {
+ return cgltf_result_out_of_memory;
+ }
+
+ jsmn_init(&parser);
+
+ int token_count = jsmn_parse(&parser, (const char*)json_chunk, size, tokens, options->json_token_count);
+
+ if (token_count <= 0)
+ {
+ options->memory.free(options->memory.user_data, tokens);
+ return cgltf_result_invalid_json;
+ }
+
+ // this makes sure that we always have an UNDEFINED token at the end of the stream
+ // for invalid JSON inputs this makes sure we don't perform out of bound reads of token data
+ tokens[token_count].type = JSMN_UNDEFINED;
+
+ cgltf_data* data = (cgltf_data*)options->memory.alloc(options->memory.user_data, sizeof(cgltf_data));
+
+ if (!data)
+ {
+ options->memory.free(options->memory.user_data, tokens);
+ return cgltf_result_out_of_memory;
+ }
+
+ memset(data, 0, sizeof(cgltf_data));
+ data->memory = options->memory;
+ data->file = options->file;
+
+ int i = cgltf_parse_json_root(options, tokens, 0, json_chunk, data);
+
+ options->memory.free(options->memory.user_data, tokens);
+
+ if (i < 0)
+ {
+ cgltf_free(data);
+
+ switch (i)
+ {
+ case CGLTF_ERROR_NOMEM: return cgltf_result_out_of_memory;
+ case CGLTF_ERROR_LEGACY: return cgltf_result_legacy_gltf;
+ default: return cgltf_result_invalid_gltf;
+ }
+ }
+
+ if (cgltf_fixup_pointers(data) < 0)
+ {
+ cgltf_free(data);
+ return cgltf_result_invalid_gltf;
+ }
+
+ data->json = (const char*)json_chunk;
+ data->json_size = size;
+
+ *out_data = data;
+
+ return cgltf_result_success;
+}
+
+static int cgltf_fixup_pointers(cgltf_data* data)
+{
+ for (cgltf_size i = 0; i < data->meshes_count; ++i)
+ {
+ for (cgltf_size j = 0; j < data->meshes[i].primitives_count; ++j)
+ {
+ CGLTF_PTRFIXUP(data->meshes[i].primitives[j].indices, data->accessors, data->accessors_count);
+ CGLTF_PTRFIXUP(data->meshes[i].primitives[j].material, data->materials, data->materials_count);
+
+ for (cgltf_size k = 0; k < data->meshes[i].primitives[j].attributes_count; ++k)
+ {
+ CGLTF_PTRFIXUP_REQ(data->meshes[i].primitives[j].attributes[k].data, data->accessors, data->accessors_count);
+ }
+
+ for (cgltf_size k = 0; k < data->meshes[i].primitives[j].targets_count; ++k)
+ {
+ for (cgltf_size m = 0; m < data->meshes[i].primitives[j].targets[k].attributes_count; ++m)
+ {
+ CGLTF_PTRFIXUP_REQ(data->meshes[i].primitives[j].targets[k].attributes[m].data, data->accessors, data->accessors_count);
+ }
+ }
+
+ if (data->meshes[i].primitives[j].has_draco_mesh_compression)
+ {
+ CGLTF_PTRFIXUP_REQ(data->meshes[i].primitives[j].draco_mesh_compression.buffer_view, data->buffer_views, data->buffer_views_count);
+ for (cgltf_size m = 0; m < data->meshes[i].primitives[j].draco_mesh_compression.attributes_count; ++m)
+ {
+ CGLTF_PTRFIXUP_REQ(data->meshes[i].primitives[j].draco_mesh_compression.attributes[m].data, data->accessors, data->accessors_count);
+ }
+ }
+
+ for (cgltf_size k = 0; k < data->meshes[i].primitives[j].mappings_count; ++k)
+ {
+ CGLTF_PTRFIXUP_REQ(data->meshes[i].primitives[j].mappings[k].material, data->materials, data->materials_count);
+ }
+ }
+ }
+
+ for (cgltf_size i = 0; i < data->accessors_count; ++i)
+ {
+ CGLTF_PTRFIXUP(data->accessors[i].buffer_view, data->buffer_views, data->buffer_views_count);
+
+ if (data->accessors[i].is_sparse)
+ {
+ CGLTF_PTRFIXUP_REQ(data->accessors[i].sparse.indices_buffer_view, data->buffer_views, data->buffer_views_count);
+ CGLTF_PTRFIXUP_REQ(data->accessors[i].sparse.values_buffer_view, data->buffer_views, data->buffer_views_count);
+ }
+
+ if (data->accessors[i].buffer_view)
+ {
+ data->accessors[i].stride = data->accessors[i].buffer_view->stride;
+ }
+
+ if (data->accessors[i].stride == 0)
+ {
+ data->accessors[i].stride = cgltf_calc_size(data->accessors[i].type, data->accessors[i].component_type);
+ }
+ }
+
+ for (cgltf_size i = 0; i < data->textures_count; ++i)
+ {
+ CGLTF_PTRFIXUP(data->textures[i].image, data->images, data->images_count);
+ CGLTF_PTRFIXUP(data->textures[i].basisu_image, data->images, data->images_count);
+ CGLTF_PTRFIXUP(data->textures[i].sampler, data->samplers, data->samplers_count);
+ }
+
+ for (cgltf_size i = 0; i < data->images_count; ++i)
+ {
+ CGLTF_PTRFIXUP(data->images[i].buffer_view, data->buffer_views, data->buffer_views_count);
+ }
+
+ for (cgltf_size i = 0; i < data->materials_count; ++i)
+ {
+ CGLTF_PTRFIXUP(data->materials[i].normal_texture.texture, data->textures, data->textures_count);
+ CGLTF_PTRFIXUP(data->materials[i].emissive_texture.texture, data->textures, data->textures_count);
+ CGLTF_PTRFIXUP(data->materials[i].occlusion_texture.texture, data->textures, data->textures_count);
+
+ CGLTF_PTRFIXUP(data->materials[i].pbr_metallic_roughness.base_color_texture.texture, data->textures, data->textures_count);
+ CGLTF_PTRFIXUP(data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture, data->textures, data->textures_count);
+
+ CGLTF_PTRFIXUP(data->materials[i].pbr_specular_glossiness.diffuse_texture.texture, data->textures, data->textures_count);
+ CGLTF_PTRFIXUP(data->materials[i].pbr_specular_glossiness.specular_glossiness_texture.texture, data->textures, data->textures_count);
+
+ CGLTF_PTRFIXUP(data->materials[i].clearcoat.clearcoat_texture.texture, data->textures, data->textures_count);
+ CGLTF_PTRFIXUP(data->materials[i].clearcoat.clearcoat_roughness_texture.texture, data->textures, data->textures_count);
+ CGLTF_PTRFIXUP(data->materials[i].clearcoat.clearcoat_normal_texture.texture, data->textures, data->textures_count);
+
+ CGLTF_PTRFIXUP(data->materials[i].specular.specular_texture.texture, data->textures, data->textures_count);
+ CGLTF_PTRFIXUP(data->materials[i].specular.specular_color_texture.texture, data->textures, data->textures_count);
+
+ CGLTF_PTRFIXUP(data->materials[i].transmission.transmission_texture.texture, data->textures, data->textures_count);
+
+ CGLTF_PTRFIXUP(data->materials[i].volume.thickness_texture.texture, data->textures, data->textures_count);
+
+ CGLTF_PTRFIXUP(data->materials[i].sheen.sheen_color_texture.texture, data->textures, data->textures_count);
+ CGLTF_PTRFIXUP(data->materials[i].sheen.sheen_roughness_texture.texture, data->textures, data->textures_count);
+
+ CGLTF_PTRFIXUP(data->materials[i].iridescence.iridescence_texture.texture, data->textures, data->textures_count);
+ CGLTF_PTRFIXUP(data->materials[i].iridescence.iridescence_thickness_texture.texture, data->textures, data->textures_count);
+ }
+
+ for (cgltf_size i = 0; i < data->buffer_views_count; ++i)
+ {
+ CGLTF_PTRFIXUP_REQ(data->buffer_views[i].buffer, data->buffers, data->buffers_count);
+
+ if (data->buffer_views[i].has_meshopt_compression)
+ {
+ CGLTF_PTRFIXUP_REQ(data->buffer_views[i].meshopt_compression.buffer, data->buffers, data->buffers_count);
+ }
+ }
+
+ for (cgltf_size i = 0; i < data->skins_count; ++i)
+ {
+ for (cgltf_size j = 0; j < data->skins[i].joints_count; ++j)
+ {
+ CGLTF_PTRFIXUP_REQ(data->skins[i].joints[j], data->nodes, data->nodes_count);
+ }
+
+ CGLTF_PTRFIXUP(data->skins[i].skeleton, data->nodes, data->nodes_count);
+ CGLTF_PTRFIXUP(data->skins[i].inverse_bind_matrices, data->accessors, data->accessors_count);
+ }
+
+ for (cgltf_size i = 0; i < data->nodes_count; ++i)
+ {
+ for (cgltf_size j = 0; j < data->nodes[i].children_count; ++j)
+ {
+ CGLTF_PTRFIXUP_REQ(data->nodes[i].children[j], data->nodes, data->nodes_count);
+
+ if (data->nodes[i].children[j]->parent)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+
+ data->nodes[i].children[j]->parent = &data->nodes[i];
+ }
+
+ CGLTF_PTRFIXUP(data->nodes[i].mesh, data->meshes, data->meshes_count);
+ CGLTF_PTRFIXUP(data->nodes[i].skin, data->skins, data->skins_count);
+ CGLTF_PTRFIXUP(data->nodes[i].camera, data->cameras, data->cameras_count);
+ CGLTF_PTRFIXUP(data->nodes[i].light, data->lights, data->lights_count);
+
+ if (data->nodes[i].has_mesh_gpu_instancing)
+ {
+ CGLTF_PTRFIXUP_REQ(data->nodes[i].mesh_gpu_instancing.buffer_view, data->buffer_views, data->buffer_views_count);
+ for (cgltf_size m = 0; m < data->nodes[i].mesh_gpu_instancing.attributes_count; ++m)
+ {
+ CGLTF_PTRFIXUP_REQ(data->nodes[i].mesh_gpu_instancing.attributes[m].data, data->accessors, data->accessors_count);
+ }
+ }
+ }
+
+ for (cgltf_size i = 0; i < data->scenes_count; ++i)
+ {
+ for (cgltf_size j = 0; j < data->scenes[i].nodes_count; ++j)
+ {
+ CGLTF_PTRFIXUP_REQ(data->scenes[i].nodes[j], data->nodes, data->nodes_count);
+
+ if (data->scenes[i].nodes[j]->parent)
+ {
+ return CGLTF_ERROR_JSON;
+ }
+ }
+ }
+
+ CGLTF_PTRFIXUP(data->scene, data->scenes, data->scenes_count);
+
+ for (cgltf_size i = 0; i < data->animations_count; ++i)
+ {
+ for (cgltf_size j = 0; j < data->animations[i].samplers_count; ++j)
+ {
+ CGLTF_PTRFIXUP_REQ(data->animations[i].samplers[j].input, data->accessors, data->accessors_count);
+ CGLTF_PTRFIXUP_REQ(data->animations[i].samplers[j].output, data->accessors, data->accessors_count);
+ }
+
+ for (cgltf_size j = 0; j < data->animations[i].channels_count; ++j)
+ {
+ CGLTF_PTRFIXUP_REQ(data->animations[i].channels[j].sampler, data->animations[i].samplers, data->animations[i].samplers_count);
+ CGLTF_PTRFIXUP(data->animations[i].channels[j].target_node, data->nodes, data->nodes_count);
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * -- jsmn.c start --
+ * Source: https://github.com/zserge/jsmn
+ * License: MIT
+ *
+ * Copyright (c) 2010 Serge A. Zaitsev
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * Allocates a fresh unused token from the token pull.
+ */
+static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
+ jsmntok_t *tokens, size_t num_tokens) {
+ jsmntok_t *tok;
+ if (parser->toknext >= num_tokens) {
+ return NULL;
+ }
+ tok = &tokens[parser->toknext++];
+ tok->start = tok->end = -1;
+ tok->size = 0;
+#ifdef JSMN_PARENT_LINKS
+ tok->parent = -1;
+#endif
+ return tok;
+}
+
+/**
+ * Fills token type and boundaries.
+ */
+static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
+ int start, int end) {
+ token->type = type;
+ token->start = start;
+ token->end = end;
+ token->size = 0;
+}
+
+/**
+ * Fills next available token with JSON primitive.
+ */
+static int jsmn_parse_primitive(jsmn_parser *parser, const char *js,
+ size_t len, jsmntok_t *tokens, size_t num_tokens) {
+ jsmntok_t *token;
+ int start;
+
+ start = parser->pos;
+
+ for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
+ switch (js[parser->pos]) {
+#ifndef JSMN_STRICT
+ /* In strict mode primitive must be followed by "," or "}" or "]" */
+ case ':':
+#endif
+ case '\t' : case '\r' : case '\n' : case ' ' :
+ case ',' : case ']' : case '}' :
+ goto found;
+ }
+ if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
+ parser->pos = start;
+ return JSMN_ERROR_INVAL;
+ }
+ }
+#ifdef JSMN_STRICT
+ /* In strict mode primitive must be followed by a comma/object/array */
+ parser->pos = start;
+ return JSMN_ERROR_PART;
+#endif
+
+found:
+ if (tokens == NULL) {
+ parser->pos--;
+ return 0;
+ }
+ token = jsmn_alloc_token(parser, tokens, num_tokens);
+ if (token == NULL) {
+ parser->pos = start;
+ return JSMN_ERROR_NOMEM;
+ }
+ jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
+#ifdef JSMN_PARENT_LINKS
+ token->parent = parser->toksuper;
+#endif
+ parser->pos--;
+ return 0;
+}
+
+/**
+ * Fills next token with JSON string.
+ */
+static int jsmn_parse_string(jsmn_parser *parser, const char *js,
+ size_t len, jsmntok_t *tokens, size_t num_tokens) {
+ jsmntok_t *token;
+
+ int start = parser->pos;
+
+ parser->pos++;
+
+ /* Skip starting quote */
+ for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
+ char c = js[parser->pos];
+
+ /* Quote: end of string */
+ if (c == '\"') {
+ if (tokens == NULL) {
+ return 0;
+ }
+ token = jsmn_alloc_token(parser, tokens, num_tokens);
+ if (token == NULL) {
+ parser->pos = start;
+ return JSMN_ERROR_NOMEM;
+ }
+ jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos);
+#ifdef JSMN_PARENT_LINKS
+ token->parent = parser->toksuper;
+#endif
+ return 0;
+ }
+
+ /* Backslash: Quoted symbol expected */
+ if (c == '\\' && parser->pos + 1 < len) {
+ int i;
+ parser->pos++;
+ switch (js[parser->pos]) {
+ /* Allowed escaped symbols */
+ case '\"': case '/' : case '\\' : case 'b' :
+ case 'f' : case 'r' : case 'n' : case 't' :
+ break;
+ /* Allows escaped symbol \uXXXX */
+ case 'u':
+ parser->pos++;
+ for(i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; i++) {
+ /* If it isn't a hex character we have an error */
+ if(!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
+ (js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
+ (js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */
+ parser->pos = start;
+ return JSMN_ERROR_INVAL;
+ }
+ parser->pos++;
+ }
+ parser->pos--;
+ break;
+ /* Unexpected symbol */
+ default:
+ parser->pos = start;
+ return JSMN_ERROR_INVAL;
+ }
+ }
+ }
+ parser->pos = start;
+ return JSMN_ERROR_PART;
+}
+
+/**
+ * Parse JSON string and fill tokens.
+ */
+static int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
+ jsmntok_t *tokens, size_t num_tokens) {
+ int r;
+ int i;
+ jsmntok_t *token;
+ int count = parser->toknext;
+
+ for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
+ char c;
+ jsmntype_t type;
+
+ c = js[parser->pos];
+ switch (c) {
+ case '{': case '[':
+ count++;
+ if (tokens == NULL) {
+ break;
+ }
+ token = jsmn_alloc_token(parser, tokens, num_tokens);
+ if (token == NULL)
+ return JSMN_ERROR_NOMEM;
+ if (parser->toksuper != -1) {
+ tokens[parser->toksuper].size++;
+#ifdef JSMN_PARENT_LINKS
+ token->parent = parser->toksuper;
+#endif
+ }
+ token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
+ token->start = parser->pos;
+ parser->toksuper = parser->toknext - 1;
+ break;
+ case '}': case ']':
+ if (tokens == NULL)
+ break;
+ type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
+#ifdef JSMN_PARENT_LINKS
+ if (parser->toknext < 1) {
+ return JSMN_ERROR_INVAL;
+ }
+ token = &tokens[parser->toknext - 1];
+ for (;;) {
+ if (token->start != -1 && token->end == -1) {
+ if (token->type != type) {
+ return JSMN_ERROR_INVAL;
+ }
+ token->end = parser->pos + 1;
+ parser->toksuper = token->parent;
+ break;
+ }
+ if (token->parent == -1) {
+ if(token->type != type || parser->toksuper == -1) {
+ return JSMN_ERROR_INVAL;
+ }
+ break;
+ }
+ token = &tokens[token->parent];
+ }
+#else
+ for (i = parser->toknext - 1; i >= 0; i--) {
+ token = &tokens[i];
+ if (token->start != -1 && token->end == -1) {
+ if (token->type != type) {
+ return JSMN_ERROR_INVAL;
+ }
+ parser->toksuper = -1;
+ token->end = parser->pos + 1;
+ break;
+ }
+ }
+ /* Error if unmatched closing bracket */
+ if (i == -1) return JSMN_ERROR_INVAL;
+ for (; i >= 0; i--) {
+ token = &tokens[i];
+ if (token->start != -1 && token->end == -1) {
+ parser->toksuper = i;
+ break;
+ }
+ }
+#endif
+ break;
+ case '\"':
+ r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
+ if (r < 0) return r;
+ count++;
+ if (parser->toksuper != -1 && tokens != NULL)
+ tokens[parser->toksuper].size++;
+ break;
+ case '\t' : case '\r' : case '\n' : case ' ':
+ break;
+ case ':':
+ parser->toksuper = parser->toknext - 1;
+ break;
+ case ',':
+ if (tokens != NULL && parser->toksuper != -1 &&
+ tokens[parser->toksuper].type != JSMN_ARRAY &&
+ tokens[parser->toksuper].type != JSMN_OBJECT) {
+#ifdef JSMN_PARENT_LINKS
+ parser->toksuper = tokens[parser->toksuper].parent;
+#else
+ for (i = parser->toknext - 1; i >= 0; i--) {
+ if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) {
+ if (tokens[i].start != -1 && tokens[i].end == -1) {
+ parser->toksuper = i;
+ break;
+ }
+ }
+ }
+#endif
+ }
+ break;
+#ifdef JSMN_STRICT
+ /* In strict mode primitives are: numbers and booleans */
+ case '-': case '0': case '1' : case '2': case '3' : case '4':
+ case '5': case '6': case '7' : case '8': case '9':
+ case 't': case 'f': case 'n' :
+ /* And they must not be keys of the object */
+ if (tokens != NULL && parser->toksuper != -1) {
+ jsmntok_t *t = &tokens[parser->toksuper];
+ if (t->type == JSMN_OBJECT ||
+ (t->type == JSMN_STRING && t->size != 0)) {
+ return JSMN_ERROR_INVAL;
+ }
+ }
+#else
+ /* In non-strict mode every unquoted value is a primitive */
+ default:
+#endif
+ r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
+ if (r < 0) return r;
+ count++;
+ if (parser->toksuper != -1 && tokens != NULL)
+ tokens[parser->toksuper].size++;
+ break;
+
+#ifdef JSMN_STRICT
+ /* Unexpected char in strict mode */
+ default:
+ return JSMN_ERROR_INVAL;
+#endif
+ }
+ }
+
+ if (tokens != NULL) {
+ for (i = parser->toknext - 1; i >= 0; i--) {
+ /* Unmatched opened object or array */
+ if (tokens[i].start != -1 && tokens[i].end == -1) {
+ return JSMN_ERROR_PART;
+ }
+ }
+ }
+
+ return count;
+}
+
+/**
+ * Creates a new parser based over a given buffer with an array of tokens
+ * available.
+ */
+static void jsmn_init(jsmn_parser *parser) {
+ parser->pos = 0;
+ parser->toknext = 0;
+ parser->toksuper = -1;
+}
+/*
+ * -- jsmn.c end --
+ */
+
+#endif /* #ifdef CGLTF_IMPLEMENTATION */
+
+/* cgltf is distributed under MIT license:
+ *
+ * Copyright (c) 2018-2021 Johannes Kuhlmann
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
diff --git a/code/src/gltf/fresnel.cpp b/code/src/gltf/fresnel.cpp
new file mode 100644
index 0000000..8528387
--- /dev/null
+++ b/code/src/gltf/fresnel.cpp
@@ -0,0 +1,95 @@
+
+#include <cassert>
+#include <cmath>
+
+#include "fresnel.h"
+
+
+Vector reflect( const Vector& w, const Vector& n )
+{
+ return 2*dot(w, n) * n - w;
+}
+
+bool can_refract( const float ni, const float nt, const Vector& w, const Vector& n )
+{
+ float cos_theta= dot(n, w);
+ // cf http://www.pbr-book.org/3ed-2018/Reflection_Models/Specular_Reflection_and_Transmission.html
+ float sin2_theta= std::max(float(0), 1 - cos_theta*cos_theta);
+ float inv_eta= ni / nt;
+ float sin2_theta_t= inv_eta*inv_eta * sin2_theta;
+ return sin2_theta_t < 1;
+}
+
+Vector refract( const float ni, const float nt, const Vector& w, const Vector& n )
+{
+ float cos_theta= dot(n, w);
+ // cf http://www.pbr-book.org/3ed-2018/Reflection_Models/Specular_Reflection_and_Transmission.html
+ float sin2_theta= std::max(float(0), 1 - cos_theta*cos_theta);
+ float inv_eta= ni / nt;
+ float sin2_theta_t= inv_eta*inv_eta * sin2_theta;
+ assert(sin2_theta_t <= 1);
+ float cos_theta_t= std::sqrt(std::max(float(0), 1 - sin2_theta_t));
+ return -inv_eta * w + (inv_eta * cos_theta - cos_theta_t) * n;
+}
+
+
+static
+float sqr( const float x ) { return x*x; }
+
+float fresnel( const float ni, const float nt, const Vector& w, const Vector& n )
+{
+ float eta= nt / ni;
+ float c= std::abs(dot(n, w));
+ float g= eta*eta + c*c -1;
+ if(g < 0)
+ return 1; // reflexion totale
+
+ g= std::sqrt(g);
+ return sqr( g-c ) / sqr( g+c ) / 2 * ( 1 + sqr( c*(g+c) -1 ) / sqr( c*(g-c)+1 ) );
+}
+
+Color schlick_fresnel( const Color& F0, const float cos_theta )
+{
+ return F0 + (Color(1) - F0) * std::pow(std::max(float(0), 1 - cos_theta), float(5));
+}
+
+Color schlick_fresnel( const float ni, const float nt, const Vector& w, const Vector& n )
+{
+ // dot(n, reflect)
+ float cos_theta= dot(n, w);
+
+ if(ni > nt)
+ {
+ // re-evalue l'approximation lorsque ni > nt...
+ float sin2_theta= std::max(float(0), 1 - cos_theta*cos_theta);
+ float inv_eta= ni / nt;
+ float sin2_theta_t= inv_eta*inv_eta * sin2_theta;
+ if(sin2_theta_t > 1)
+ // reflexion totale...
+ return White();
+
+ // dot(n, refract)
+ cos_theta= std::sqrt(std::max(float(0), 1 - sin2_theta_t));
+ }
+
+ return schlick_fresnel( Color(schlick_f0(ni, nt)), cos_theta);
+}
+
+float schlick_f0( const float ior )
+{
+ float f= (ior -1) / (ior +1);
+ return f*f;
+}
+
+float schlick_f0( const float ni, const float nt )
+{
+ float f= (nt - ni) / (nt + ni);
+ return f*f;
+}
+
+float schlick_ior( const float f0 )
+{
+ float f= std::sqrt(f0);
+ return (1 + f ) / (1 - f);
+}
+
diff --git a/code/src/gltf/fresnel.h b/code/src/gltf/fresnel.h
new file mode 100644
index 0000000..2236760
--- /dev/null
+++ b/code/src/gltf/fresnel.h
@@ -0,0 +1,33 @@
+
+#pragma once
+
+#include "vec.h"
+#include "color.h"
+
+//!< renvoie la direction miroir de w, par rapport a n.
+Vector reflect( const Vector& w, const Vector& n );
+
+//!< verifie qu'une refraction est possible.
+bool can_refract( const float ni, const float nt, const Vector& w, const Vector& n );
+
+//!< renvoie la direction refractee de w, par rapport a n.
+Vector refract( const float ni, const float nt, const Vector& w, const Vector& n );
+
+//!< renvoie le coefficient de reflexion de fresnel.
+float fresnel( const float ni, const float nt, const Vector& w, const Vector& n );
+
+//!< renvoie l'approximation du coefficient de fresnel. reflexion.
+Color schlick_fresnel( const Color& F0, const float cos_theta );
+
+//!< renvoie l'approximation du coefficient de fresnel. reflexion et refraction.
+Color schlick_fresnel( const float ni, const float nt, const Vector& w, const Vector& n );
+
+//!< renvoie F0, coeff de Fresnel a incidence normale.
+float schlick_f0( const float ior );
+
+//!< renvoie F0, coeff de Fresnel a incidence normale.
+float schlick_f0( const float ni, const float nt );
+
+//!< renvoie estime un coefficient de refraction a partir de F0.
+float schlick_ior( const float f0 );
+
diff --git a/code/src/gltf/gltf.cpp b/code/src/gltf/gltf.cpp
new file mode 100644
index 0000000..2df6fd2
--- /dev/null
+++ b/code/src/gltf/gltf.cpp
@@ -0,0 +1,666 @@
+
+#include <cstdio>
+#include <cstring>
+#include <cfloat>
+
+#include "files.h"
+#include "image.h"
+#include "image_io.h"
+#include "stb_image.h"
+
+#include "cgltf.h"
+#include "gltf.h"
+
+
+static
+std::vector<GLTFCamera> read_cameras( cgltf_data *data )
+{
+ std::vector<GLTFCamera> cameras;
+ for(unsigned i= 0; i < data->nodes_count; i++)
+ {
+ cgltf_node *node= &data->nodes[i];
+ if(node->camera == nullptr)
+ continue;
+
+ cgltf_camera_perspective *perspective= &node->camera->data.perspective;
+
+ Transform projection= Perspective(degrees(perspective->yfov), perspective->aspect_ratio, perspective->znear, perspective->zfar);
+
+ float model_matrix[16];
+ cgltf_node_transform_world(node, model_matrix); // transformation globale
+
+ Transform model;
+ model.column_major(model_matrix); // gltf organise les 16 floats par colonne...
+ Transform view= Inverse(model); // view= inverse(model)
+
+ Point position= model( Point(0, 0, 0) );
+ Vector direction= model( Vector(0, 0, -1) );
+ //~ printf("cameras[%d] position %f %f %f, direction %f %f %f\n", int(std::distance(data->cameras, node->camera)),
+ //~ position.x, position.y, position.z, direction.x, direction.y, direction.z);
+
+ //~ if(perspective->has_aspect_ratio)
+ //~ printf(" aspect ratio %f\n", perspective->aspect_ratio);
+ //~ printf(" yfov %f\n", degrees(perspective->yfov));
+ //~ printf(" znear %f", perspective->znear);
+ //~ if(perspective->has_zfar)
+ //~ printf(", zfar %f", perspective->zfar);
+ //~ printf("\n");
+
+
+ cameras.push_back( { degrees(perspective->yfov), perspective->aspect_ratio, perspective->znear, perspective->zfar, view, projection } );
+ }
+
+ return cameras;
+}
+
+std::vector<GLTFCamera> read_gltf_cameras( const char *filename )
+{
+ printf("loading glTF camera '%s'...\n", filename);
+
+ cgltf_options options= { };
+ cgltf_data *data= nullptr;
+ cgltf_result code= cgltf_parse_file(&options, filename, &data);
+ if(code != cgltf_result_success)
+ {
+ printf("[error] loading glTF mesh '%s'...\n", filename);
+ return {};
+ }
+
+ if(cgltf_validate(data) != cgltf_result_success)
+ {
+ printf("[error] invalid glTF mesh '%s'...\n", filename);
+ return {};
+ }
+
+ if(data->cameras_count == 0)
+ {
+ printf("[warning] no camera...\n");
+ return {};
+ }
+
+ std::vector<GLTFCamera> cameras= read_cameras(data);
+ cgltf_free(data);
+ return cameras;
+}
+
+
+static
+std::vector<GLTFLight> read_lights( cgltf_data *data )
+{
+ std::vector<GLTFLight> lights;
+ // retrouve les transformations associees aux sources
+ for(unsigned i= 0; i < data->nodes_count; i++)
+ {
+ cgltf_node *node= &data->nodes[i];
+ if(node->light == nullptr)
+ continue;
+
+ // proprietes de la source
+ int light_id= int(std::distance(data->lights, node->light));
+
+ cgltf_light *light= node->light;
+ Color emission= Color(light->color[0], light->color[1], light->color[2]) * light->intensity;
+ printf("lights[%d]: emission %f %f %f\n", light_id, emission.r, emission.g, emission.b);
+
+ // position de la source
+ float model_matrix[16];
+ cgltf_node_transform_world(node, model_matrix); // transformation globale
+
+ Transform model;
+ model.column_major(model_matrix); // gltf organise les 16 floats par colonne...
+ Point position;
+ Vector direction;
+
+ if(light->type == cgltf_light_type_directional)
+ {
+ printf(" direction %f %f %f\n", direction.x, direction.y, direction.z);
+ direction= model( Vector(0, 0, 1) );
+ }
+ if(light->type == cgltf_light_type_point)
+ {
+ printf(" position %f %f %f\n", position.x, position.y, position.z);
+ position= model( Point(0, 0, 0) );
+ }
+
+ lights.push_back( { position, direction, emission } );
+ }
+
+ return lights;
+}
+
+std::vector<GLTFLight> read_gltf_lights( const char *filename )
+{
+ printf("loading glTF lights '%s'...\n", filename);
+
+ cgltf_options options= { };
+ cgltf_data *data= nullptr;
+ cgltf_result code= cgltf_parse_file(&options, filename, &data);
+ if(code != cgltf_result_success)
+ {
+ printf("[error] loading glTF mesh '%s'...\n", filename);
+ return {};
+ }
+
+ if(cgltf_validate(data) != cgltf_result_success)
+ {
+ printf("[error] invalid glTF mesh '%s'...\n", filename);
+ return {};
+ }
+
+ if(data->lights_count == 0)
+ {
+ printf("[warning] no lights...\n");
+ return {};
+ }
+
+ std::vector<GLTFLight> lights= read_lights(data);
+ cgltf_free(data);
+ return lights;
+}
+
+
+static
+std::vector<GLTFMaterial> read_materials( cgltf_data *data )
+{
+ std::vector<GLTFMaterial> materials;
+ for(unsigned i= 0; i < data->materials_count; i++)
+ {
+ cgltf_material *material= &data->materials[i];
+ //~ printf("materials[%u] '%s'\n", i, material->name);
+
+ GLTFMaterial m= { };
+ m.color= Color(0.8, 0.8, 0.8, 1);
+ m.emission= Color(0);
+ m.metallic= 0;
+ m.roughness= 1;
+ m.transmission= 0;
+ m.ior= 0;
+ m.specular= 0;
+ m.specular_color= Black();
+ m.thickness= 0;
+ m.attenuation_distance= 0;
+ m.attenuation_color= Black();
+ m.color_texture= -1;
+ m.metallic_roughness_texture= -1;
+ m.occlusion_texture= -1;
+ m.normal_texture= -1;
+ m.emission_texture= -1;
+ m.transmission_texture= -1;
+ m.specular_texture= -1;
+ m.specular_color_texture= -1;
+ m.thickness_texture= -1;
+
+ if(material->has_pbr_metallic_roughness)
+ {
+ cgltf_pbr_metallic_roughness *pbr= &material->pbr_metallic_roughness;
+
+ m.color= Color(pbr->base_color_factor[0], pbr->base_color_factor[1], pbr->base_color_factor[2], pbr->base_color_factor[3]);
+ if(pbr->base_color_texture.texture && pbr->base_color_texture.texture->image)
+ m.color_texture= int(std::distance(data->images, pbr->base_color_texture.texture->image));
+
+ m.metallic= pbr->metallic_factor;
+ m.roughness= pbr->roughness_factor;
+ if(pbr->metallic_roughness_texture.texture && pbr->metallic_roughness_texture.texture->image)
+ m.metallic_roughness_texture= int(std::distance(data->images, pbr->metallic_roughness_texture.texture->image));
+
+ //~ printf(" pbr metallic roughness\n");
+ //~ printf(" base color %f %f %f, texture %d\n", m.color.r, m.color.g, m.color.b, m.color_texture);
+ //~ printf(" metallic %f, roughness %f, texture %d\n", m.metallic, m.roughness, m.metallic_roughness_texture);
+ }
+ //~ if(material->has_clearcoat)
+ //~ printf(" clearcoat\n");
+ //~ if(material->has_sheen)
+ //~ printf(" sheen\n");
+
+ if(material->normal_texture.texture && material->normal_texture.texture->image)
+ {
+ //~ printf(" normal texture %d\n", int(std::distance(data->images, material->normal_texture.texture->image)));
+ m.normal_texture= int(std::distance(data->images, material->normal_texture.texture->image));
+ }
+
+ m.emission= Color(material->emissive_factor[0], material->emissive_factor[1], material->emissive_factor[2]);
+ if(material->has_emissive_strength)
+ m.emission= m.emission * material->emissive_strength.emissive_strength;
+
+ if(material->emissive_texture.texture && material->emissive_texture.texture->image)
+ {
+ //~ printf(" emissive color %f %f %f\n", material->emissive_factor[0], material->emissive_factor[1], material->emissive_factor[2]);
+ //~ printf(" texture %d\n", int(std::distance(data->images, material->emissive_texture.texture->image)));
+ m.emission_texture= int(std::distance(data->images, material->emissive_texture.texture->image));
+ }
+
+ if(material->has_ior)
+ {
+ m.ior= material->ior.ior;
+ if(m.ior == float(1.5))
+ m.ior= 0; // valeur par defaut
+
+ //~ if(m.ior)
+ //~ printf(" ior %f\n", m.ior);
+ }
+
+ if(material->has_specular)
+ {
+ m.specular= material->specular.specular_factor;
+ if(material->specular.specular_texture.texture && material->specular.specular_texture.texture->image)
+ m.specular_texture= std::distance(data->images, material->specular.specular_texture.texture->image);
+
+ m.specular_color= Color(material->specular.specular_color_factor[0], material->specular.specular_color_factor[1], material->specular.specular_color_factor[2]);
+ if(material->specular.specular_color_texture.texture && material->specular.specular_color_texture.texture->image)
+ m.specular_color_texture= std::distance(data->images, material->specular.specular_color_texture.texture->image);
+
+ if(m.specular_color.r*m.specular +m.specular_color.g*m.specular +m.specular_color.b*m.specular == 0)
+ {
+ // parametres incoherents... valeur par defaut / desactive ce comportement
+ m.specular= 0;
+ m.specular_color= Black();
+ }
+
+ //~ if(m.specular)
+ //~ printf(" specular %f color %f %f %f, texture %d\n", m.specular, m.specular_color.r, m.specular_color.g, m.specular_color.b, m.specular_texture);
+ }
+
+ if(material->has_transmission)
+ {
+ m.transmission= material->transmission.transmission_factor;
+ if(material->transmission.transmission_texture.texture && material->transmission.transmission_texture.texture->image)
+ m.transmission_texture= std::distance(data->images, material->transmission.transmission_texture.texture->image);
+
+ if(m.transmission)
+ printf(" transmission %f, texture %d\n", m.transmission, m.transmission_texture);
+ }
+
+ if(material->has_volume)
+ {
+ m.thickness= material->volume.thickness_factor;
+ if(material->volume.thickness_texture.texture && material->volume.thickness_texture.texture->image)
+ m.thickness_texture= std::distance(data->images, material->volume.thickness_texture.texture->image);
+
+ m.attenuation_distance= material->volume.attenuation_distance;
+ m.attenuation_color= Color(material->volume.attenuation_color[0], material->volume.attenuation_color[1], material->volume.attenuation_color[2]);
+ //~ printf(" volume thickness %f, texture %d\n",m.thickness, m.thickness_texture);
+ //~ printf(" volume attenation distance %f, color %f %f %f\n", m.attenuation_distance, m.attenuation_color.r, m.attenuation_color.g, m.attenuation_color.b);
+ }
+
+ materials.push_back(m);
+ }
+
+ return materials;
+}
+
+std::vector<GLTFMaterial> read_gltf_materials( const char *filename )
+{
+ printf("loading glTF materials '%s'...\n", filename);
+
+ cgltf_options options= { };
+ cgltf_data *data= nullptr;
+ cgltf_result code= cgltf_parse_file(&options, filename, &data);
+ if(code != cgltf_result_success)
+ {
+ printf("[error] loading glTF mesh '%s'...\n", filename);
+ return {};
+ }
+
+ if(cgltf_validate(data) != cgltf_result_success)
+ {
+ printf("[error] invalid glTF mesh '%s'...\n", filename);
+ return {};
+ }
+
+ if(data->materials_count ==0)
+ {
+ printf("[warning] no materials...\n");
+ return {};
+ }
+
+ std::vector<GLTFMaterial> materials= read_materials(data);
+ cgltf_free(data);
+ return materials;
+}
+
+
+std::vector<Image> read_gltf_images( const char *filename, const int width_max, const int height_max )
+{
+ printf("loading glTF images '%s'...\n", filename);
+
+ cgltf_options options= { };
+ cgltf_data *data= nullptr;
+ cgltf_result code= cgltf_parse_file(&options, filename, &data);
+ if(code != cgltf_result_success)
+ {
+ printf("[error] loading glTF mesh '%s'...\n", filename);
+ return {};
+ }
+
+ if(cgltf_validate(data) != cgltf_result_success)
+ {
+ printf("[error] invalid glTF mesh '%s'...\n", filename);
+ return {};
+ }
+
+ if(data->images_count == 0)
+ return {};
+
+ // detecte s'il faut charger aussi les buffers... textures internes / .glb
+ for(unsigned i= 0; i < data->images_count; i++)
+ if(!data->images[i].uri)
+ {
+ code= cgltf_load_buffers(&options, data, filename);
+ if(code != cgltf_result_success)
+ {
+ printf("[error] loading glTF internal images...\n");
+ cgltf_free(data);
+ return {};
+ }
+
+ break;
+ }
+
+ // marque les textures a convertir srgb -> rgb
+ std::vector<int> convert(data->images_count, 0);
+ for(unsigned i= 0; i < data->materials_count; i++)
+ {
+ cgltf_material *material= &data->materials[i];
+ if(material->has_pbr_metallic_roughness)
+ {
+ cgltf_pbr_metallic_roughness *pbr= &material->pbr_metallic_roughness;
+
+ if(pbr->base_color_texture.texture && pbr->base_color_texture.texture->image)
+ {
+ int texture_id= int(std::distance(data->images, pbr->base_color_texture.texture->image));
+ convert[texture_id]= 1;
+ }
+ // les autres textures ne sont pas des couleurs...
+ }
+ }
+
+ // charge toutes les images en parallele
+ std::vector<Image> images(data->images_count);
+
+#pragma omp parallel for schedule(dynamic, 1)
+ for(unsigned i= 0; i < data->images_count; i++)
+ {
+ if(data->images[i].uri)
+ {
+ // charge le fichier
+ //~ printf(" [%u] %s\n", i, data->images[i].uri);
+ std::string image_filename= pathname(filename) + std::string(data->images[i].uri);
+
+ stbi_ldr_to_hdr_scale(1.0);
+ stbi_ldr_to_hdr_gamma(1.0);
+ if(convert[i])
+ stbi_ldr_to_hdr_gamma(2.2);
+
+ int width, height, channels;
+ float *tmp= stbi_loadf(image_filename.c_str(), &width, &height, &channels, 4);
+ assert(tmp);
+
+ // \todo : remplacer le vector d'image par un pointeur et virer la copie...
+ // ou en profiter pour utiliser les conversion srgb -> rgb plus precises que gamma(2.2)...
+ images[i]= Image(width, height);
+ {
+ Image& image= images[i];
+ for(unsigned p= 0, offset= 0; p < image.size(); p++, offset+= 4)
+ {
+ Color pixel= Color(
+ tmp[offset],
+ tmp[offset + 1],
+ tmp[offset + 2],
+ tmp[offset + 3]);
+ image(p)= pixel;
+ }
+ }
+
+ stbi_image_free(tmp);
+ }
+ else if(data->images[i].buffer_view)
+ {
+ // extraire l'image du glb...
+ cgltf_buffer_view *view= data->images[i].buffer_view;
+ assert(view->buffer->data);
+ //~ printf(" [%u] %s offset %lu\n", i, data->images[i].name, view->offset);
+ //~ printf(" [%u] %s\n", i, data->images[i].name);
+
+ stbi_ldr_to_hdr_scale(1.0);
+ stbi_ldr_to_hdr_gamma(1.0);
+ if(convert[i])
+ stbi_ldr_to_hdr_gamma(2.2);
+
+ int width, height, channels;
+ float *tmp= stbi_loadf_from_memory((const unsigned char *) view->buffer->data + view->offset, view->size, &width, &height, &channels, 4);
+ assert(tmp);
+
+ //~ printf(" images[%u] '%s' %dx%dx%d...\n", i, data->images[i].name, width, height, channels);
+ // \todo : remplacer le vector d'image par un pointeur et virer la copie...
+ images[i]= Image(width, height);
+ {
+ Image& image= images[i];
+ for(unsigned p= 0, offset= 0; p < image.size(); p++, offset+= 4)
+ {
+ Color pixel= Color(
+ tmp[offset],
+ tmp[offset + 1],
+ tmp[offset + 2],
+ tmp[offset + 3]);
+ image(p)= pixel;
+ }
+ }
+
+ stbi_image_free(tmp);
+ }
+
+ // reduit la taille des textures, si necessaire...
+ if(width_max && height_max)
+ {
+ while(images[i].width() > width_max * 2 && images[i].height() > height_max * 2)
+ images[i]= downscale(images[i]);
+ }
+ }
+
+ cgltf_free(data);
+ return images;
+}
+
+
+GLTFScene read_gltf_scene( const char *filename )
+{
+ printf("loading glTF scene '%s'...\n", filename);
+
+ cgltf_options options= { };
+ cgltf_data *data= nullptr;
+ cgltf_result code= cgltf_parse_file(&options, filename, &data);
+ if(code != cgltf_result_success)
+ {
+ printf("[error] loading glTF mesh '%s'...\n", filename);
+ return { };
+ }
+
+ if(cgltf_validate(data) != cgltf_result_success)
+ {
+ printf("[error] invalid glTF mesh '%s'...\n", filename);
+ return { };
+ }
+
+ code= cgltf_load_buffers(&options, data, filename);
+ if(code != cgltf_result_success)
+ {
+ printf("[error] loading glTF buffers...\n");
+ return { };
+ }
+
+ //
+ GLTFScene scene;
+
+// etape 1 : construire les meshs et les groupes de triangles / primitives
+ int primitives_index= 0;
+ std::vector<float> buffer;
+
+ // parcourir tous les meshs de la scene
+ for(unsigned mesh_id= 0; mesh_id < data->meshes_count; mesh_id++)
+ {
+ GLTFMesh m= { };
+ m.pmin= Point(FLT_MAX, FLT_MAX, FLT_MAX);
+ m.pmax= Point(-FLT_MAX, -FLT_MAX, -FLT_MAX);
+
+ cgltf_mesh *mesh= &data->meshes[mesh_id];
+ // parcourir les groupes de triangles du mesh...
+ for(unsigned primitive_id= 0; primitive_id < mesh->primitives_count; primitive_id++)
+ {
+ cgltf_primitive *primitives= &mesh->primitives[primitive_id];
+ assert(primitives->type == cgltf_primitive_type_triangles);
+
+ GLTFPrimitives p= { };
+
+ // matiere associee au groupe de triangles
+ p.material_index= -1;
+ if(primitives->material)
+ p.material_index= std::distance(data->materials, primitives->material);
+
+ // indices
+ if(primitives->indices)
+ {
+ for(unsigned i= 0; i < primitives->indices->count; i++)
+ p.indices.push_back(cgltf_accessor_read_index(primitives->indices, i));
+ assert(p.indices.size() % 3 == 0);
+ }
+
+ // attributs
+ for(unsigned attribute_id= 0; attribute_id < primitives->attributes_count; attribute_id++)
+ {
+ cgltf_attribute *attribute= &primitives->attributes[attribute_id];
+
+ if(attribute->type == cgltf_attribute_type_position)
+ {
+ assert(attribute->data->type == cgltf_type_vec3);
+
+ buffer.resize(cgltf_accessor_unpack_floats(attribute->data, nullptr, 0));
+ cgltf_accessor_unpack_floats(attribute->data, buffer.data(), buffer.size());
+
+ // transforme les positions des sommets
+ for(unsigned i= 0; i+2 < buffer.size(); i+= 3)
+ p.positions.push_back( vec3(buffer[i], buffer[i+1], buffer[i+2]) );
+
+ #if 1
+ // englobant des primitives
+ assert(attribute->data->has_min);
+ assert(attribute->data->has_max);
+ p.pmin= Point(attribute->data->min[0], attribute->data->min[1], attribute->data->min[2]);
+ p.pmax= Point(attribute->data->max[0], attribute->data->max[1], attribute->data->max[2]);
+ #else
+ p.pmin= p.positions[0];
+ p.pmax= p.positions[0];
+ for(unsigned i= 1; i < p.positions.size(); i++)
+ {
+ p.pmin= min(p.pmin, p.positions[i]);
+ p.pmax= max(p.pmax, p.positions[i]);
+ }
+ #endif
+
+ // englobant du mesh
+ m.pmin= min(m.pmin, p.pmin);
+ m.pmax= max(m.pmax, p.pmax);
+ }
+
+ if(attribute->type == cgltf_attribute_type_normal)
+ {
+ assert(attribute->data->type == cgltf_type_vec3);
+
+ buffer.resize(cgltf_accessor_unpack_floats(attribute->data, nullptr, 0));
+ cgltf_accessor_unpack_floats(attribute->data, buffer.data(), buffer.size());
+
+ // transforme les normales des sommets
+ for(unsigned i= 0; i+2 < buffer.size(); i+= 3)
+ p.normals.push_back( vec3(buffer[i], buffer[i+1], buffer[i+2]) );
+ }
+
+ if(attribute->type == cgltf_attribute_type_texcoord)
+ {
+ assert(attribute->data->type == cgltf_type_vec2);
+
+ buffer.resize(cgltf_accessor_unpack_floats(attribute->data, nullptr, 0));
+ cgltf_accessor_unpack_floats(attribute->data, buffer.data(), buffer.size());
+
+ for(unsigned i= 0; i+1 < buffer.size(); i+= 2)
+ p.texcoords.push_back( vec2(buffer[i], buffer[i+1]) );
+ }
+ }
+
+ p.primitives_index= primitives_index++;
+ m.primitives.push_back(p);
+ }
+
+ scene.meshes.push_back(m);
+ }
+
+// etape 2 : parcourir les noeuds, retrouver les transforms pour placer les meshes
+ for(unsigned node_id= 0; node_id < data->nodes_count; node_id++)
+ {
+ cgltf_node *node= &data->nodes[node_id];
+ if(node->mesh== nullptr)
+ // pas de mesh associe, rien a dessiner
+ continue;
+
+ // recuperer la transformation pour placer le mesh dans la scene
+ float model_matrix[16];
+ cgltf_node_transform_world(node, model_matrix);
+
+ Transform model;
+ model.column_major(model_matrix); // gltf organise les 16 floats par colonne...
+ Transform normal= model.normal(); // transformation pour les normales
+
+ int mesh_index= std::distance(data->meshes, node->mesh);
+ scene.nodes.push_back( {model, normal, mesh_index} );
+ }
+
+// etape 3 : recuperer les autres infos...
+ scene.materials= read_materials(data);
+ scene.lights= read_lights(data);
+ scene.cameras= read_cameras(data);
+
+// etape : nettoyage...
+ cgltf_free(data);
+
+ return scene;
+}
+
+std::vector<GLTFInstances> GLTFScene::instances( ) const
+{
+ std::vector<GLTFInstances> instances(meshes.size());
+ for(unsigned i= 0; i < meshes.size(); i++)
+ instances[i].mesh_index= i;
+
+ for(unsigned i= 0; i < nodes.size(); i++)
+ {
+ int index= nodes[i].mesh_index;
+ assert(index < int(instances.size()));
+ instances[index].transforms.push_back( nodes[i].model );
+ }
+
+ return instances;
+}
+
+
+void GLTFScene::bounds( Point& pmin, Point& pmax ) const
+{
+ pmin= Point(FLT_MAX, FLT_MAX, FLT_MAX);
+ pmax= Point(-FLT_MAX, -FLT_MAX, -FLT_MAX);
+
+ for(unsigned node_id= 0; node_id < nodes.size(); node_id++)
+ {
+ const GLTFNode& node= nodes[node_id];
+ const GLTFMesh& mesh= meshes[node.mesh_index];
+
+ // transforme la bbox du mesh dans le repere la scene
+ for(int i= 0; i < 8; i++)
+ {
+ Point p= mesh.pmin;
+ if(i & 1) p.x= mesh.pmax.x;
+ if(i & 2) p.y= mesh.pmax.y;
+ if(i & 4) p.z= mesh.pmax.z;
+
+ p= node.model(p);
+ pmin= min(pmin, p);
+ pmax= max(pmax, p);
+ }
+ }
+}
diff --git a/code/src/gltf/gltf.h b/code/src/gltf/gltf.h
new file mode 100644
index 0000000..12f4eee
--- /dev/null
+++ b/code/src/gltf/gltf.h
@@ -0,0 +1,160 @@
+
+//! \file gltf.h scene glTF.
+
+#pragma once
+
+#include <vector>
+
+#include "vec.h"
+#include "mat.h"
+#include "color.h"
+#include "image.h"
+
+
+//! description d'une camera.
+struct GLTFCamera
+{
+ float fov;
+ float aspect;
+ float znear;
+ float zfar;
+
+ Transform view;
+ Transform projection;
+};
+
+//! charge un fichier .gltf renvoie les cameras.
+std::vector<GLTFCamera> read_gltf_cameras( const char *filename );
+
+//! description d'une source de lumiere.
+struct GLTFLight
+{
+ Point position;
+ Vector direction;
+ Color emission;
+
+ // \todo transform et les autres parametres...
+};
+
+//! charge un fichier .gltf et renvoie les sources de lumiere ponctuelles.
+std::vector<GLTFLight> read_gltf_lights( const char *filename );
+
+/*! description d'une matiere PBR / Principled BRDF.
+
+ cf specification glTF / implementation : https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#appendix-b-brdf-implementation
+
+ utilise les extensions / parametres supplementaires :\n
+ - KHR_materials_ior : https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_ior
+ - KHR_materials_specular : https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_specular
+ - KHR_materials_transmission : https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_transmission
+
+ - KHR_materials_clearcoat : https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_clearcoat
+ */
+
+struct GLTFMaterial
+{
+ Color color; //!< base color.
+ Color emission; //!< emission pour les sources de lumieres ou pas (= noir).
+ float metallic; //!< metallic / dielectrique.
+ float roughness; //!< rugosite de la micro surface.
+ float transmission; //!< transmission, transparent ou pas (= 0)
+ float ior; //!< indice de refraction des dielectriques ou pas (= 0)
+ float specular; //!< modification de la reflexion speculaire des dielectriques ou pas (= 0)
+ Color specular_color; //!< modification de la reflexion speculaire des dielectriques ou pas (= 0)
+ float thickness; //!< epaisseur des surfaces transparentes
+ float attenuation_distance; //!<
+ Color attenuation_color; //!<
+ // \todo coating
+
+ int color_texture; //!< indice de la texture ou -1. cf read_gltf_images() pour charger les textures dans le bon ordre...
+ int metallic_roughness_texture; //!< indice de la texture ou -1. les valeurs RGB representent les parametres du modele : B= metallic, G= roughness, et R= ambient occlusion.
+ int emission_texture; //!< indice de la texture ou -1.
+ int occlusion_texture; //!< indice de la texture ou -1. // \todo probablement pas necessaire, cf canal rouge de metallic_roughness_texture
+ int normal_texture; //!< indice de la texture ou -1.
+ int transmission_texture; //!< indice de la texture ou -1.
+ int specular_texture; //!< indice de la texture ou -1.
+ int specular_color_texture; //!< indice de la texture ou -1.
+ int thickness_texture;
+
+ GLTFMaterial( ) :
+ color(White()), emission(), metallic(), roughness(0.8), transmission(), ior(), specular(), specular_color(), thickness(), attenuation_distance(), attenuation_color(),
+ color_texture(-1), metallic_roughness_texture(-1), emission_texture(-1), occlusion_texture(-1), normal_texture(-1),
+ transmission_texture(-1), specular_texture(-1), specular_color_texture(-1), thickness_texture(-1)
+ {}
+};
+
+//! charge un fichier .gltf et renvoie les matieres.
+std::vector<GLTFMaterial> read_gltf_materials( const char *filename );
+
+//! charge un fichier .gltf et charge les images referencees par les matieres.
+std::vector<Image> read_gltf_images( const char *filename, const int width= 0, const int height= 0 );
+
+
+//! groupe de triangles d'un maillage. chaque groupe est associe a une matiere.
+struct GLTFPrimitives
+{
+ int primitives_mode; //!< triangles.
+ int primitives_index; //!< indice unique.
+ int material_index; //!< indice de la matiere des primitives.
+
+ Point pmin, pmax; //!< points extremes de l'englobant dans le repere objet
+
+ // buffers...
+ std::vector<unsigned> indices;
+ std::vector<vec3> positions;
+ std::vector<vec2> texcoords;
+ std::vector<vec3> normals;
+};
+
+//! description d'un maillage.
+struct GLTFMesh
+{
+ std::vector<GLTFPrimitives> primitives; //!< groupes de triangles associes a une matiere.
+ Point pmin, pmax; //!< points extremes de l'englobant dans le repere objet
+};
+
+//! instances d'un maillage.
+struct GLTFInstances
+{
+ std::vector<Transform> transforms; //!< transformation model de chaque instance
+ int mesh_index; //!< indice du maillage instancie.
+};
+
+//! position et orientation d'un maillage dans la scene.
+struct GLTFNode
+{
+ Transform model; //!< transformation model pour les positions des sommets.
+ Transform normal; //!< transformation model pour les normales des sommets.
+ int mesh_index; //!< indice du maillage.
+};
+
+
+/*! representation d'une scene statique glTF.
+
+ resume du format glTF : https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/README.md
+
+ specification complete : https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html
+
+ parser gltf : https://github.com/jkuhlmann/cgltf
+
+ une scene est un ensemble de maillages places et orientes dans un repere.
+ un GLTFNode permet de dessiner un maillage GLTFMesh a sa place.
+ un maillage est un ensemble de groupes de triangles / primitives. cf GLTFPrimitives.
+ un groupe de primitives est associe a une matiere. cf GLTFMaterial.
+ */
+struct GLTFScene
+{
+ std::vector<GLTFMesh> meshes; //!< ensemble de maillages.
+ std::vector<GLTFNode> nodes; //!< noeuds / position et orientation des maillages dans la scene.
+
+ std::vector<GLTFMaterial> materials; //!< matieres.
+ std::vector<GLTFLight> lights; //!< lumieres.
+ std::vector<GLTFCamera> cameras; //!< cameras.
+
+ void bounds( Point& pmin, Point& pmax) const; //!< calcule les points extremes de la scene, utile pour regler un orbiter.
+ std::vector<GLTFInstances> instances( ) const; //!< regroupe les instances de chaque maillage.
+};
+
+//! charge un fichier .gltf et construit une scene statique, sans animation.
+GLTFScene read_gltf_scene( const char *filename );
+
diff --git a/code/src/gltf/scene.cpp b/code/src/gltf/scene.cpp
new file mode 100644
index 0000000..f82c2ae
--- /dev/null
+++ b/code/src/gltf/scene.cpp
@@ -0,0 +1,289 @@
+
+#include "gltf/scene.h"
+
+
+Scene read_scene( const char *filename )
+{
+ Scene scene;
+ scene.gltf= read_gltf_scene(filename);
+
+ // camera
+ if(scene.gltf.cameras.empty())
+ return {}; // pas de camera, pas d'image
+ scene.camera= scene.gltf.cameras[0];
+
+ // extrait les triangles
+ if(scene.gltf.nodes.empty())
+ return {}; // pas de triangles, pas d'image
+
+ std::vector<Triangle> triangles;
+ std::vector<Source> sources;
+ for(unsigned node_id= 0; node_id < scene.gltf.nodes.size(); node_id++)
+ {
+ const GLTFNode& node= scene.gltf.nodes[node_id];
+
+ const Transform& model= node.model;
+ int mesh_id= node.mesh_index;
+
+ const GLTFMesh& mesh= scene.gltf.meshes[mesh_id];
+ for(unsigned primitive_id= 0; primitive_id < mesh.primitives.size(); primitive_id++)
+ {
+ const GLTFPrimitives& primitives= mesh.primitives[primitive_id];
+
+ int material_id= primitives.material_index;
+ assert(material_id != -1);
+ const GLTFMaterial& material= scene.gltf.materials[material_id];
+ bool emissive= (material.emission.max() > 0);
+
+ for(unsigned i= 0; i +2 < primitives.indices.size(); i+= 3)
+ {
+ // indice des sommets
+ int a= primitives.indices[i];
+ int b= primitives.indices[i+1];
+ int c= primitives.indices[i+2];
+
+ // transforme les sommets dans le repere de la scene
+ Point pa= model( Point(primitives.positions[a]) );
+ Point pb= model( Point(primitives.positions[b]) );
+ Point pc= model( Point(primitives.positions[c]) );
+
+ // verifie que le triangle n'est pas degenere
+ float area= length( cross( Vector(pa, pb), Vector(pa, pc) ) );
+ if(area > 0)
+ {
+ triangles.push_back( Triangle(pa, pb, pc, node_id, mesh_id, primitive_id, i/3) );
+
+ // construit aussi les sources / triangles emissifs
+ if(emissive)
+ sources.push_back( Source(pa, pb, pc, material.emission) );
+ }
+ }
+ }
+ }
+ assert(triangles.size());
+
+ // et construit le bvh
+ scene.bvh.build(triangles);
+ // et la cdf des sources
+ scene.sources.build(sources);
+
+ return scene;
+}
+
+
+int read_textures( const char *filename, Scene& scene, const int width, const int height )
+{
+ std::vector<Image> images= read_gltf_images(filename, width, height);
+
+ scene.textures.resize(images.size());
+
+#pragma omp parallel for schedule(dynamic, 1)
+ for(unsigned i=0; i < images.size(); i++)
+ {
+ scene.textures[i]= Texture(images[i]);
+ images[i]= Image(); // nettoyage...
+ }
+
+ // filtrage des textures
+ scene.image_width= width;
+ scene.image_height= height;
+ scene.pixel_cone_angle= std::atan( std::tan(radians(scene.camera.fov)) / scene.image_height );
+ scene.view= scene.camera.view; // transformation dans le repere camera pour evaluer la distance / lod
+
+ printf("%d textures...\n", int(scene.textures.size()));
+ return int(scene.textures.size());
+}
+
+const GLTFMaterial& Scene::material( const Hit& hit ) const
+{
+ assert(bool(hit));
+ const GLTFMesh& mesh= gltf.meshes[hit.mesh_id];
+ const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
+
+ int id= primitives.material_index;
+ assert(id != -1);
+ return gltf.materials[id];
+}
+
+float Scene::triangle_area( const Hit& hit ) const
+{
+ assert(bool(hit));
+ const GLTFNode& node= gltf.nodes[hit.node_id];
+ const GLTFMesh& mesh= gltf.meshes[hit.mesh_id];
+ const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
+
+ // indice des sommets
+ int first= 3*hit.triangle_id;
+ int a= primitives.indices[first];
+ int b= primitives.indices[first+1];
+ int c= primitives.indices[first+2];
+
+ // positions des sommets
+ assert(primitives.positions.size());
+ Point pa= node.model( Point(primitives.positions[a]) );
+ Point pb= node.model( Point(primitives.positions[b]) );
+ Point pc= node.model( Point(primitives.positions[c]) );
+ Vector ng= cross( Vector(pa, pb), Vector(pa, pc) );
+ return length(ng) / 2;
+}
+
+
+Brdf Scene::brdf( const Hit& hit, const Vector& n ) const
+{
+ assert(bool(hit));
+
+ const GLTFMaterial& m= material(hit);
+ //~ Color color= White();
+ Color color= m.color;
+ float roughness= m.roughness;
+ float metallic= m.metallic;
+ //~ float roughness= 1;
+ //~ float metallic= 1;
+
+ // ajuste les parametres en fonction des textures...
+ if(m.color_texture != -1 || m.metallic_roughness_texture != -1)
+ {
+ vec3 uv_lod= texcoords_lod(hit);
+ if(m.color_texture != -1)
+ color= color * textures[m.color_texture].sample(uv_lod.x, uv_lod.y, uv_lod.z);
+
+ if(m.metallic_roughness_texture != -1)
+ {
+ Color pixel= textures[m.metallic_roughness_texture].sample(uv_lod.x, uv_lod.y, uv_lod.z);
+ metallic= metallic * pixel.b;
+ roughness= roughness * pixel.g;
+ }
+ }
+
+ return Brdf(n, color, metallic, roughness);
+}
+
+
+// renvoie la normale interpolee au point d'intersection
+Point Scene::position( const Hit& hit ) const
+{
+ assert(bool(hit));
+ const GLTFNode& node= gltf.nodes[hit.node_id];
+ const GLTFMesh& mesh= gltf.meshes[hit.mesh_id];
+ const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
+
+ // indice des sommets
+ int first= 3*hit.triangle_id;
+ int a= primitives.indices[first];
+ int b= primitives.indices[first+1];
+ int c= primitives.indices[first+2];
+
+ // positions des sommets
+ assert(primitives.positions.size());
+ Point pa= primitives.positions[a];
+ Point pb= primitives.positions[b];
+ Point pc= primitives.positions[c];
+
+ // interpole au point d'intersection
+ Point p= (1 - hit.u - hit.v) * pa + hit.u * pb + hit.v * pc;
+
+ // transforme dans le repere de la scene
+ return node.model(p);
+}
+
+// renvoie les coordonnees de texture interpolee au point d'intersection
+vec2 Scene::texcoords( const Hit& hit ) const
+{
+ assert(bool(hit));
+ const GLTFMesh& mesh= gltf.meshes[hit.mesh_id];
+ const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
+
+ // indice des sommets
+ int first= 3*hit.triangle_id;
+ int a= primitives.indices[first];
+ int b= primitives.indices[first+1];
+ int c= primitives.indices[first+2];
+
+ // texcoords des sommets
+ assert(primitives.texcoords.size());
+ vec2 ta= primitives.texcoords[a];
+ vec2 tb= primitives.texcoords[b];
+ vec2 tc= primitives.texcoords[c];
+
+ // interpole au point d'intersection
+ float tx= (1 - hit.u - hit.v) * ta.x + hit.u * tb.x + hit.v * tc.x;
+ float ty= (1 - hit.u - hit.v) * ta.y + hit.u * tb.y + hit.v * tc.y;
+ return vec2(tx, ty);
+}
+
+
+// renvoie les coordonnees de texture interpolee au point d'intersection + lod
+vec3 Scene::texcoords_lod( const Hit& hit ) const
+{
+ assert(bool(hit));
+ const GLTFNode& node= gltf.nodes[hit.node_id];
+ const GLTFMesh& mesh= gltf.meshes[hit.mesh_id];
+ const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
+
+ // indice des sommets
+ int first= 3*hit.triangle_id;
+ int a= primitives.indices[first];
+ int b= primitives.indices[first+1];
+ int c= primitives.indices[first+2];
+
+ // texcoords
+ assert(primitives.texcoords.size());
+ vec2 ta= primitives.texcoords[a];
+ vec2 tb= primitives.texcoords[b];
+ vec2 tc= primitives.texcoords[c];
+
+ float tx= (1 - hit.u - hit.v) * ta.x + hit.u * tb.x + hit.v * tc.x;
+ float ty= (1 - hit.u - hit.v) * ta.y + hit.u * tb.y + hit.v * tc.y;
+
+ // positions
+ assert(primitives.positions.size());
+ Point pa= Point(primitives.positions[a]);
+ Point pb= Point(primitives.positions[b]);
+ Point pc= Point(primitives.positions[c]);
+ Point p= (1 - hit.u - hit.v) * pa + hit.u * pb + hit.v * pc;
+
+ Transform mv= view * node.model;
+ Vector d= Vector( mv(p) );
+
+ // estime le filtrage des textures
+ // "Texture Level of Detail Strategies for Real-Time Ray Tracing", ray tracing gems 1, chapitre 20
+ // https://media.contentapi.ea.com/content/dam/ea/seed/presentations/2019-ray-tracing-gems-chapter-20-akenine-moller-et-al.pdf
+ float texarea= length( cross( Vector(Point(ta, 0), Point(tb, 0)), Vector(Point(ta, 0), Point(tc, 0)) ));
+ float area= length( cross( Vector(pa, pb), Vector(pa, pc) ) );
+ float lod= std::log2( std::sqrt(texarea/area) * pixel_cone_angle * length(d) );
+ // todo stocker area dans les triangles du bvh ??
+
+ return vec3(tx, ty, lod);
+ //~ return vec3(tx, ty, 0);
+}
+
+
+// renvoie la normale interpolee au point d'intersection
+Vector Scene::normal( const Hit& hit ) const
+{
+ assert(bool(hit));
+ const GLTFNode& node= gltf.nodes[hit.node_id];
+ const GLTFMesh& mesh= gltf.meshes[hit.mesh_id];
+ const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
+
+ // indice des sommets
+ int first= 3*hit.triangle_id;
+ int a= primitives.indices[first];
+ int b= primitives.indices[first+1];
+ int c= primitives.indices[first+2];
+
+ // normales des sommets
+ assert(primitives.normals.size());
+ Vector na= primitives.normals[a];
+ Vector nb= primitives.normals[b];
+ Vector nc= primitives.normals[c];
+
+ // interpole la normale au point d'intersection
+ Vector n= (1 - hit.u - hit.v) * na + hit.u * nb + hit.v * nc;
+
+ // transforme la normale dans le repere de la scene
+ return normalize( node.normal(n) );
+}
+
+//~ Source& Scene::source( const Hit& hit ); // todo
+
diff --git a/code/src/gltf/scene.h b/code/src/gltf/scene.h
new file mode 100644
index 0000000..c2c6f42
--- /dev/null
+++ b/code/src/gltf/scene.h
@@ -0,0 +1,67 @@
+
+#pragma once
+
+#include <cassert>
+#include <random>
+
+#include "vec.h"
+#include "mat.h"
+#include "gltf/gltf.h"
+#include "gltf/bvh.h"
+#include "gltf/brdf.h"
+#include "gltf/sources.h"
+#include "gltf/texture.h"
+
+
+struct Scene
+{
+ GLTFScene gltf;
+ GLTFCamera camera;
+
+ BVH bvh;
+ Sources sources;
+
+ // textures
+ std::vector<Texture> textures;
+
+ // filtrage
+ Transform view;
+ int image_width, image_height;
+ float pixel_cone_angle;
+
+ // renvoie la matiere du point d'intersection
+ const GLTFMaterial& material( const Hit& hit ) const;
+ float triangle_area( const Hit& hit ) const;
+
+ // renvoie la brdf du point d'intersection
+ Brdf brdf( const Hit& hit, const Vector& n ) const;
+
+ // renvoie les coordonnees de texture interpolee au point d'intersection + lod
+ vec3 texcoords_lod( const Hit& hit ) const;
+
+ // renvoie la normale interpolee au point d'intersection
+ Vector normal( const Hit& hit ) const;
+
+ // renvoie les coordonnees de texture interpolees au point d'intersection
+ vec2 texcoords( const Hit& hit ) const;
+
+ // renvoie le point d'intersection interpole sur le triangle.
+ Point position( const Hit& hit ) const;
+
+ // renvoie le point d'intersection interpole sur le rayon.
+ Point position( const Hit& hit, const Ray& ray ) const { return ray(hit); }
+
+ //~ Source& source( const Hit& hit ); // todo
+
+ bool visible( const Point& p, const Point& q ) const { return bvh.visible(p, q); }
+ bool visible( const Point& p, const Vector& d ) const { return bvh.visible(p, d); }
+ Hit intersect( const Ray& ray ) const { return bvh.intersect(ray); }
+
+ // anyhit filter, cf alpha_filter
+ template< typename Filter > bool visible( const Point& p, const Vector& d, const Filter& filter ) const { return bvh.visible(p, d, filter); }
+ template< typename Filter > Hit intersect( const Ray& ray, const Filter& filter ) const { return bvh.intersect(ray, filter); }
+};
+
+
+Scene read_scene( const char *filename );
+int read_textures( const char *filename, Scene& scene, const int width, const int height );
diff --git a/code/src/gltf/sources.h b/code/src/gltf/sources.h
new file mode 100644
index 0000000..7777ae2
--- /dev/null
+++ b/code/src/gltf/sources.h
@@ -0,0 +1,166 @@
+
+#pragma once
+
+#include <unordered_map>
+#include <vector>
+
+#include "vec.h"
+#include "color.h"
+
+
+// triangle abc + emission
+struct Source
+{
+ Point a, b, c;
+ Color emission;
+ Vector n; // normale
+ float area; // aire
+
+ Source( ) : a(), b(), c(), emission(), n(), area() {}
+
+ Source( const Point& _a, const Point& _b, const Point& _c, const Color& _color ) : a(_a), b(_b), c(_c), emission(_color)
+ {
+ // normale geometrique du triangle abc, produit vectoriel des aretes ab et ac
+ Vector ng= cross(Vector(a, b), Vector(a, c));
+ n= normalize(ng);
+ area= length(ng) / 2;
+
+ assert(area * emission.max() > 0);
+ }
+
+ Point sample( const float u1, const float u2 ) const
+ {
+ #if 0
+ // cf GI compendium eq 18, https://people.cs.kuleuven.be/~philip.dutre/GI/TotalCompendium.pdf
+ // ou PBRT http://www.pbr-book.org/3ed-2018/Monte_Carlo_Integration/2D_Sampling_with_Multidimensional_Transformations.html#SamplingaTriangle
+ float r1= std::sqrt(u1);
+ float alpha= 1 - r1;
+ float beta= (1 - u2) * r1;
+ float gamma= u2 * r1;
+
+ return alpha*a + beta*b + gamma*c;
+ #else
+
+ // "A Low-Distortion Map Between Triangle and Square"
+ // cf https://pharr.org/matt/blog/2019/03/13/triangle-sampling-1.5.html
+ // cf https://drive.google.com/file/d/1J-183vt4BrN9wmqItECIjjLIKwm29qSg/view
+ float b0= u1 / 2;
+ float b1= u2 / 2;
+ float offset= b1 - b0;
+ if(offset > 0)
+ b1= b1 + offset;
+ else
+ b0= b0 - offset;
+ float b2= 1 - b0 - b1;
+
+ return b0*a + b1*b + b2*c;
+ #endif
+ }
+
+ float pdf( const Point& p ) const
+ {
+ // todo : devrait renvoyer 0 pour les points a l'exterieur du triangle...
+ return 1 / area;
+ }
+};
+
+
+// ensemble de sources
+struct Sources
+{
+ std::vector<Source> sources;
+ std::vector<float> cdf;
+ float area; // aire totale des sources
+
+ void build( const std::vector<Source>& triangles )
+ {
+ area= 0;
+ sources.clear();
+ for(unsigned id= 0; id < triangles.size(); id++)
+ {
+ if(triangles[id].area > 0)
+ {
+ area= area + triangles[id].area;
+
+ sources.push_back( triangles[id] );
+ cdf.push_back( area );
+ }
+ }
+
+ printf("%d emissive triangles...\n", int(sources.size()));
+ }
+
+ int count( ) const { return int(sources.size()); }
+ const Source& operator() ( const int id ) const { assert(id >= 0); assert(id < int(sources.size())); return sources[id]; }
+
+ const Source& sample( const float& u1 ) const
+ {
+ float r= u1 * area;
+
+ // recherche dichotomique
+ int begin= 0;
+ int end= int(cdf.size()) -1;
+ while(begin < end)
+ {
+ int m= (begin + end) / 2;
+ if(cdf[m] < r)
+ begin= m+1;
+ else
+ end= m;
+ }
+ assert(begin >= 0 && begin < int(cdf.size()));
+
+ return sources[begin];
+ }
+
+ const Source& sample_reuse( float& u1 ) const
+ {
+ float r= u1 * area;
+
+ // recherche dichotomique
+ int begin= 0;
+ int end= int(cdf.size()) -1;
+ while(begin < end)
+ {
+ int m= (begin + end) / 2;
+ if(cdf[m] < r)
+ begin= m+1;
+ else
+ end= m;
+ }
+ assert(begin >= 0 && begin < int(cdf.size()));
+
+ #if 0
+ {
+ // check
+ int i;
+ for(i= 0; i < int(cdf.size()); i++)
+ if(r <= cdf[i])
+ break;
+
+ if(i < int(cdf.size()) && begin != i)
+ {
+ #pragma omp critical
+ {
+ printf("i %u %f < %f < %f\n", i, (i-1 >= 0) ? cdf[i-1] : 0, r, cdf[i]);
+ printf("b %u %f < %f < %f\n", begin, (begin-1 >= 0) ? cdf[begin-1] : 0, r, cdf[begin]);
+ exit(1);
+ }
+ }
+ }
+ #endif
+
+ // renormalise u1
+ if(begin > 0)
+ u1= (r - cdf[begin-1]) / (cdf[begin] - cdf[begin-1]);
+ else
+ u1= r / cdf[begin];
+
+ return sources[begin];
+ }
+
+ float pdf( const Source& s ) const
+ {
+ return s.area / area;
+ }
+};
diff --git a/code/src/gltf/texture.h b/code/src/gltf/texture.h
new file mode 100644
index 0000000..d300d98
--- /dev/null
+++ b/code/src/gltf/texture.h
@@ -0,0 +1,148 @@
+
+#pragma once
+
+#include <vector>
+
+#include "image.h"
+#include "image_io.h"
+
+
+struct Texture
+{
+ std::vector<Image> mips;
+ bool opaque;
+
+ Texture( ) : mips(), opaque(true) {}
+
+ Texture( const Image& mip0 ) : mips(), opaque(true)
+ {
+ assert(mip0.size());
+ mips.push_back(mip0);
+
+ // verifie l'opacite de la texture...
+ for(unsigned i= 0; i < mip0.size(); i++)
+ if(mip0(i).a < float(0.5))
+ {
+ opaque= false;
+ break;
+ }
+
+ Image mip= mip0;
+ while(mip.width() / 2 > 1 || mip.height() / 2 > 1)
+ {
+ mip= downscale(mip);
+ mips.push_back(mip);
+ }
+ }
+
+ Color sample( const float u, const float v ) const
+ {
+ return sample_repeat(u, v, 0);
+ }
+
+ Color sample( const float u, const float v, const float lod ) const
+ {
+ return sample_repeat(u, v, lod); // par defaut
+ }
+
+ // adressage des textures lorsque les coordonnees ne sont pas entre 0 et 1
+ // https://registry.khronos.org/OpenGL/specs/gl/glspec46.core.pdf#subsection.8.14.2
+ int clamp( const int x, const int size ) const
+ {
+ if(x < 0) return 0;
+ if(x > size) return size;
+ return x;
+ }
+
+#if 0
+ // % n'est pas modulo...
+ int mod( const int x, const int size ) const
+ {
+ return (x % size + size) % size;
+ }
+
+ int nearest( const int x, const int size ) const
+ {
+ return x;
+ }
+
+ int repeat( const int x, const int size ) const
+ {
+ return mod(x, size);
+ }
+
+ int mirror( const int x ) const
+ {
+ if(x >= 0) return x;
+ return -(1 + x);
+ }
+
+ int mirror_repeat( const int x, const int size ) const
+ {
+ return (size - 1) + mirror(mod(x, 2*size) - size);
+ }
+#else
+ float mod( const float x, const int size ) const
+ {
+ return std::fmod(std::abs(x), float(size));
+ }
+
+ float nearest( const float x, const int size ) const
+ {
+ return std::floor(std::abs(x));
+ }
+
+ float repeat( const float x, const int size ) const
+ {
+ return mod(x, size);
+ }
+
+ float mirror( const float x ) const
+ {
+ if(x >= 0) return x;
+ return -(1 + x);
+ }
+
+ float mirror_repeat( const float x, const int size ) const
+ {
+ return mod(x, size);
+ }
+
+#endif
+
+ // cf GL_NEAREST
+ Color sample_nearest( const float u, const float v, const float lod ) const
+ {
+ int level= clamp(std::floor(lod), mips.size() -1);
+ int w= mips[level].width();
+ int h= mips[level].height();
+ return mips[level].sample(nearest(u * w, w), nearest(v * h, h));
+ }
+
+ // cf GL_REPEAT
+ Color sample_repeat( const float u, const float v, const float lod ) const
+ {
+ int level= clamp(std::floor(lod), mips.size() -1);
+ int w= mips[level].width();
+ int h= mips[level].height();
+ return mips[level].sample(repeat(u * w, w), repeat(v * h, h));
+ }
+
+ //~ // cf GL_MIRRORED_REPEAT
+ //~ Color sample_mirror_repeat( const float u, const float v, const float lod ) const
+ //~ {
+ //~ int level= clamp(std::floor(lod), mips.size() -1);
+ //~ int w= mips[level].width();
+ //~ int h= mips[level].height();
+ //~ return mips[level].sample(mirror_repeat(u * w, w), mirror_repeat(v * h, h));
+ //~ }
+
+ // cf GL_CLAMP_TO_XXX
+ Color sample_clamp( const float u, const float v, const float lod ) const
+ {
+ int level= clamp(std::floor(lod), mips.size() -1);
+ int w= mips[level].width();
+ int h= mips[level].height();
+ return mips[level].sample(clamp(u * w, w), clamp(v * h, h));
+ }
+};
diff --git a/code/src/image.h b/code/src/image.h
new file mode 100644
index 0000000..d72b487
--- /dev/null
+++ b/code/src/image.h
@@ -0,0 +1,126 @@
+
+#pragma once
+
+#include <cmath>
+#include <cassert>
+#include <vector>
+#include <algorithm>
+
+#include "color.h"
+
+
+//! \addtogroup image utilitaires pour manipuler des images
+///@{
+
+//! \file
+//! manipulation simplifiee d'images
+
+//! representation d'une image.
+class Image
+{
+protected:
+ std::vector<Color> m_pixels;
+ int m_width;
+ int m_height;
+
+public:
+ Image( ) : m_pixels(), m_width(0), m_height(0) {}
+ Image( const int w, const int h, const Color& color= Black() ) : m_pixels(w*h, color), m_width(w), m_height(h) {}
+
+ /*! renvoie une reference sur la couleur d'un pixel de l'image.
+ permet de modifier et/ou de connaitre la couleur d'un pixel :
+ \code
+ Image image(512, 512);
+
+ image(10, 10)= Red(); // le pixel (10, 10) devient rouge
+ image(0, 0)= image(10, 10); // le pixel (0, 0) recupere la couleur du pixel (10, 10)
+ \endcode
+ */
+ Color& operator() ( const int x, const int y )
+ {
+ return m_pixels[offset(x, y)];
+ }
+
+ //! renvoie la couleur d'un pixel de l'image (image non modifiable).
+ Color operator() ( const int x, const int y ) const
+ {
+ return m_pixels[offset(x, y)];
+ }
+
+ //! renvoie une reference sur le ieme pixel de l'image.
+ Color& operator() ( const unsigned offset )
+ {
+ assert(offset < m_pixels.size());
+ return m_pixels[offset];
+ }
+
+ //! renvoie lacouleur du ieme pixel de l'image.
+ Color operator() ( const unsigned offset ) const
+ {
+ assert(offset < m_pixels.size());
+ return m_pixels[offset];
+ }
+
+ //! renvoie la couleur interpolee a la position (x, y) [0 .. width]x[0 .. height].
+ Color sample( const float x, const float y ) const
+ {
+ assert(x >= 0 && x < m_width);
+ assert(y>= 0 && y < m_height);
+
+ // interpolation bilineaire
+ int ix= x;
+ int iy= y;
+ float u= x - std::floor(x);
+ float v= y - std::floor(y);
+
+ return (*this)(ix, iy) * ((1 - u) * (1 - v))
+ + (*this)(ix+1, iy) * (u * (1 - v))
+ + (*this)(ix, iy+1) * ((1 - u) * v)
+ + (*this)(ix+1, iy+1) * (u * v);
+ }
+
+ //! renvoie la couleur interpolee aux coordonnees normalisees (x, y) [0 .. 1]x[0 .. 1].
+ Color texture( const float x, const float y ) const
+ {
+ return sample(x * m_width, y * m_height);
+ }
+
+ //! renvoie un const pointeur sur le stockage des couleurs des pixels.
+ const float *data( ) const
+ {
+ assert(!m_pixels.empty());
+ return (const float *) m_pixels.data();
+ }
+
+ //! renvoie un pointeur sur le stockage des couleurs des pixels.
+ float *data( )
+ {
+ assert(!m_pixels.empty());
+ return (float *) m_pixels.data();
+ }
+
+ //! renvoie la largeur de l'image.
+ int width( ) const { return m_width; }
+ //! renvoie la hauteur de l'image.
+ int height( ) const { return m_height; }
+ //! renvoie le nombre de pixels de l'image.
+ unsigned size( ) const { return m_width * m_height; }
+
+ //! renvoie l'indice du pixel (x, y) [0 .. width]x[0 .. height].
+ //! renvoie le pixel le plus proche si (x, y) est en dehors de l'image...
+ unsigned offset( const int x, const int y ) const
+ {
+ int px= x;
+ if(px < 0) px= 0;
+ if(px > m_width-1) px= m_width-1;
+ int py= y;
+ if(py < 0) py= 0;
+ if(py > m_height-1) py= m_height-1;
+
+ unsigned p= py * m_width + px;
+ assert(p < m_pixels.size());
+ return p;
+ }
+};
+
+///@}
diff --git a/code/src/image_io.cpp b/code/src/image_io.cpp
new file mode 100644
index 0000000..a9f7b7c
--- /dev/null
+++ b/code/src/image_io.cpp
@@ -0,0 +1,313 @@
+
+#include <cfloat>
+
+#include "color.h"
+#include "image.h"
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
+
+
+float range( const Image& image )
+{
+ float gmin= FLT_MAX;
+ float gmax= 0;
+ for(unsigned i= 0; i < image.size(); i++)
+ {
+ Color color= image(i);
+ float g= color.r + color.g + color.b;
+
+ if(g < gmin) gmin= g;
+ if(g > gmax) gmax= g;
+ }
+
+ // \todo utiliser un log2 pour l'histogramme
+ int bins[100] = {};
+ for(unsigned i= 0; i < image.size(); i++)
+ {
+ Color color= image(i);
+ float g= color.r + color.g + color.b;
+
+ int b= (g - gmin) * 100 / (gmax - gmin);
+ if(b >= 99) b= 99;
+ if(b < 0) b= 0;
+ bins[b]++;
+ }
+
+ float saturation= 0;
+ float qbins= 0;
+ for(unsigned i= 0; i < 100; i++)
+ {
+ qbins= qbins + float(bins[i]) / float(image.size());
+ if(qbins > .75f)
+ return gmin + float(i+1) / 100 * (gmax - gmin);
+ }
+
+ return gmax;
+}
+
+
+Image tone( const Image& image, const float saturation )
+{
+ Image tmp(image.width(), image.height());
+
+ float k= 1 / std::pow(saturation, 1 / float(2.2));
+ for(unsigned i= 0; i < image.size(); i++)
+ {
+ Color color= image(i);
+ if(std::isnan(color.r) || std::isnan(color.g) || std::isnan(color.b))
+ // marque les pixels pourris avec une couleur improbable...
+ color= Color(1, 0, 1);
+ else
+ // sinon transformation rgb -> srgb, mais preserve alpha, pas de transformation...
+ color= srgb(k * color);
+
+ tmp(i)= Color(color, 1);
+ }
+
+ return tmp;
+}
+
+
+Image read_image( const char *filename, const bool flipY )
+{
+ stbi_set_flip_vertically_on_load(flipY);
+
+ if(!stbi_is_hdr(filename))
+ {
+ int width, height, channels;
+ unsigned char *data= stbi_load(filename, &width, &height, &channels, 4);
+ if(!data)
+ {
+ printf("[error] loading '%s'...\n", filename);
+ return {};
+ }
+
+ Image image(width, height);
+ for(unsigned i= 0, offset= 0; i < image.size(); i++, offset+= 4)
+ {
+ Color pixel= Color(
+ data[offset],
+ data[offset + 1],
+ data[offset + 2],
+ data[offset + 3]) / 255;
+ image(i)= pixel;
+ }
+
+ stbi_image_free(data);
+ return image;
+
+ // \todo utiliser stbi_loadf() dans tous les cas, + parametres de conversion
+ // cf read_gltf_images()...
+ // stbi_ldr_to_hdr_scale(1.0f);
+ // stbi_ldr_to_hdr_gamma(2.2f);
+
+ }
+ else
+ {
+ int width, height, channels;
+ float *data= stbi_loadf(filename, &width, &height, &channels, 4);
+ if(!data)
+ {
+ printf("[error] loading '%s'...\n", filename);
+ return {};
+ }
+
+ Image image(width, height);
+ for(unsigned i= 0, offset= 0; i < image.size(); i++, offset+= 4)
+ {
+ Color pixel= Color(
+ data[offset],
+ data[offset + 1],
+ data[offset + 2],
+ data[offset + 3]);
+ image(i)= pixel;
+ }
+
+ stbi_image_free(data);
+ return image;
+ }
+
+ return {};
+}
+
+inline float clamp( const float x, const float min, const float max )
+{
+ if(x < min) return min;
+ else if(x > max) return max;
+ else return x;
+}
+
+
+bool write_image_png( const Image& image, const char *filename, const bool flipY )
+{
+ if(image.size() == 0)
+ return false;
+
+ std::vector<unsigned char> tmp(image.width()*image.height()*4);
+ for(unsigned i= 0, offset= 0; i < image.size(); i++, offset+= 4)
+ {
+ Color pixel= image(i) * 255;
+ tmp[offset ]= clamp(pixel.r, 0, 255);
+ tmp[offset +1]= clamp(pixel.g, 0, 255);
+ tmp[offset +2]= clamp(pixel.b, 0, 255);
+ tmp[offset +3]= clamp(pixel.a, 0, 255);
+ }
+
+ stbi_flip_vertically_on_write(flipY);
+ return stbi_write_png(filename, image.width(), image.height(), 4, tmp.data(), image.width() * 4) != 0;
+}
+
+bool write_image( const Image& image, const char *filename, const bool flipY )
+{
+ return write_image_png(image, filename, flipY );
+}
+
+bool write_image_bmp( const Image& image, const char *filename, const bool flipY )
+{
+ if(image.size() == 0)
+ return false;
+
+ std::vector<unsigned char> tmp(image.width()*image.height()*4);
+ for(unsigned i= 0, offset= 0; i < image.size(); i++, offset+= 4)
+ {
+ Color pixel= image(i) * 255;
+ tmp[offset ]= clamp(pixel.r, 0, 255);
+ tmp[offset +1]= clamp(pixel.g, 0, 255);
+ tmp[offset +2]= clamp(pixel.b, 0, 255);
+ tmp[offset +3]= clamp(pixel.a, 0, 255);
+ }
+
+ stbi_flip_vertically_on_write(flipY);
+ return stbi_write_bmp(filename, image.width(), image.height(), 4, tmp.data()) != 0;
+}
+
+bool write_image_hdr( const Image& image, const char *filename, const bool flipY )
+{
+ if(image.size() == 0)
+ return false;
+
+ stbi_flip_vertically_on_write(flipY);
+ return stbi_write_hdr(filename, image.width(), image.height(), 4, image.data()) != 0;
+}
+
+
+bool write_image_pfm( const Image& image, const char *filename, const bool flipY )
+{
+ if(image.size() == 0)
+ return false;
+
+ FILE *out= fopen(filename, "wb");
+ if(out == nullptr)
+ {
+ printf("[error] writing pfm image '%s'...\n", filename);
+ return -1;
+ }
+
+ fprintf(out, "PF\xa%d %d\xa-1\xa", image.width(), image.height());
+
+ for(int y= 0; y < image.height(); y++)
+ for(int x= 0; x < image.width(); x++)
+ {
+ Color pixel= image(x, y);
+ fwrite(&pixel.r, sizeof(float), 3, out);
+ }
+ fclose(out);
+
+ return true;
+}
+
+bool pfm_image( const char *filename )
+{
+ const char *ext= strrchr(filename, '.');
+ if(ext == nullptr)
+ return false;
+
+ return strcmp(ext, ".pfm") == 0;
+}
+
+Image read_image_pfm( const char *filename, const bool flipY )
+{
+ FILE *in= fopen(filename, "rb");
+ if(in == nullptr)
+ {
+ printf("[error] loading pfm image '%s'...\n", filename);
+ return {};
+ }
+
+ int w, h;
+ float endian= 0;
+ if(fscanf(in, "PF\xa%d %d\xa%f[^\xa]", &w, &h, &endian) != 3 || endian != -1)
+ {
+ printf("[error] loading pfm image '%s'...\n", filename);
+ return Image();
+ }
+
+ // saute la fin de l'entete
+ unsigned char c= fgetc(in);
+ while(c != '\xa')
+ c= fgetc(in);
+
+ // pourquoi aussi tordu ? fscanf(in, "PF\n%d %d\n%f\n") consomme les espaces apres le \n... ce qui est un poil genant pour relire les floats...
+
+ printf("loading pfm image '%s' %dx%d...\n", filename, w, h);
+
+ std::vector<float> pixels(w*h*3);
+ if(fread(pixels.data(), sizeof(float)*3, w*h, in) != size_t(w*h))
+ {
+ printf("[error] reading pfm image '%s'...\n", filename);
+ fclose(in);
+ return {};
+ }
+ fclose(in);
+
+ Image image(w, h);
+ if(flipY)
+ {
+ for(int y= 0; y < h; y++)
+ {
+ for(int x= 0; x < w; x++)
+ {
+ unsigned offset= (h-1 - y) * w * 3 + x *3;
+ image(x, y)= Color(pixels[offset], pixels[offset+1], pixels[offset+2]);
+ }
+ }
+ }
+ else
+ {
+ for(unsigned i= 0, offset= 0; i < image.size(); i++, offset+= 3)
+ image(i)= Color(pixels[offset], pixels[offset+1], pixels[offset+2]);
+ }
+
+ return image;
+}
+
+
+bool write_image_preview( const Image& image, const char *filename, const bool flipY )
+{
+ if(image.size() == 0)
+ return false;
+
+ Image tmp= tone(image, range(image));
+ return write_image_png(tmp, filename, flipY);
+}
+
+
+Image downscale( const Image& image )
+{
+ Image mip(std::max(1, image.width()/2), std::max(1, image.height()/2));
+
+ for(int y= 0; y < mip.height(); y++)
+ for(int x= 0; x < mip.width(); x++)
+ mip(x, y)= (
+ image(2*x, 2*y)
+ + image(2*x+1, 2*y)
+ + image(2*x, 2*y+1)
+ + image(2*x+1, 2*y+1)
+ ) / 4;
+
+ return mip;
+}
diff --git a/code/src/image_io.h b/code/src/image_io.h
new file mode 100644
index 0000000..2851beb
--- /dev/null
+++ b/code/src/image_io.h
@@ -0,0 +1,41 @@
+
+#pragma once
+
+//! \addtogroup image utilitaires pour manipuler des images
+///@{
+
+
+#include "image.h"
+
+//! charge une image .bmp .tga .jpeg .png ou .hdr
+Image read_image( const char *filename, const bool flipY= true );
+
+//! enregistre une image au format .png
+bool write_image( const Image& image, const char *filename, const bool flipY= true );
+//! enregistre une image au format .png
+bool write_image_png( const Image& image, const char *filename, const bool flipY= true );
+//! enregistre une image au format .bmp
+bool write_image_bmp( const Image& image, const char *filename, const bool flipY= true );
+//! enregistre une image au format .hdr
+bool write_image_hdr( const Image& image, const char *filename, const bool flipY= true );
+
+//! enregistre une image au format .pfm
+bool write_image_pfm( const Image& image, const char *filename, const bool flipY= true );
+//! charge une image .pfm
+Image read_image_pfm( const char *filename, const bool flipY= true );
+
+bool pfm_image( const char *filename );
+
+
+//! raccourci pour write_image_png(tone(image, range(image)), "image.png")
+bool write_image_preview( const Image& image, const char *filename, const bool flipY= true );
+
+//! evalue l'exposition d'une image.
+float range( const Image& image );
+//! correction de l'exposition d'une image + transformation rgb -> srgb.
+Image tone( const Image& image, const float saturation );
+
+//! reduit les dimensions d'une image.
+Image downscale( const Image& image );
+
+///@}
diff --git a/code/src/mat.cpp b/code/src/mat.cpp
new file mode 100644
index 0000000..8ab375b
--- /dev/null
+++ b/code/src/mat.cpp
@@ -0,0 +1,434 @@
+
+#include <cassert>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+
+#include "mat.h"
+
+
+float radians( const float deg )
+{
+ return ((float) M_PI / 180) * deg;
+}
+
+float degrees( const float rad )
+{
+ return (180 / (float) M_PI) * rad;
+}
+
+Transform::Transform (
+ const float t00, const float t01, const float t02, const float t03,
+ const float t10, const float t11, const float t12, const float t13,
+ const float t20, const float t21, const float t22, const float t23,
+ const float t30, const float t31, const float t32, const float t33 )
+{
+ m[0][0]= t00; m[0][1]= t01; m[0][2]= t02; m[0][3]= t03;
+ m[1][0]= t10; m[1][1]= t11; m[1][2]= t12; m[1][3]= t13;
+ m[2][0]= t20; m[2][1]= t21; m[2][2]= t22; m[2][3]= t23;
+ m[3][0]= t30; m[3][1]= t31; m[3][2]= t32; m[3][3]= t33;
+}
+
+Transform& Transform::column( const int id, const float t0, const float t1, const float t2, const float t3 )
+{
+ m[0][id]= t0;
+ m[1][id]= t1;
+ m[2][id]= t2;
+ m[3][id]= t3;
+ return *this;
+}
+
+Transform& Transform::row( const int id, const float t0, const float t1, const float t2, const float t3 )
+{
+ m[id][0]= t0;
+ m[id][1]= t1;
+ m[id][2]= t2;
+ m[id][3]= t3;
+ return *this;
+}
+
+Transform& Transform::column_major( const float matrix[16] )
+{
+ for(int i= 0; i < 4; i++)
+ column(i, matrix[4*i], matrix[4*i+1], matrix[4*i+2], matrix[4*i+3]);
+ return *this;
+}
+
+Transform& Transform::row_major( const float matrix[16] )
+{
+ for(int i= 0; i < 4; i++)
+ row(i, matrix[4*i], matrix[4*i+1], matrix[4*i+2], matrix[4*i+3]);
+ return *this;
+}
+
+Transform::Transform( const Vector& x, const Vector& y, const Vector& z, const Vector& w )
+{
+ m[0][0] = x.x; m[0][1] = y.x; m[0][2] = z.x; m[0][3] = w.x;
+ m[1][0] = x.y; m[1][1] = y.y; m[1][2] = z.y; m[1][3] = w.y;
+ m[2][0] = x.z; m[2][1] = y.z; m[2][2] = z.z; m[2][3] = w.z;
+ m[3][0] = 0; m[3][1] = 0; m[3][2] = 0; m[3][3] = 1;
+}
+
+Vector Transform::operator[] ( const int c ) const
+{
+ assert(c >= 0 && c <= 3);
+ return Vector(m[0][c], m[1][c], m[2][c]);
+}
+
+
+//! renvoie le point transforme.
+Point Transform::operator() ( const Point& p ) const
+{
+ float x= p.x;
+ float y= p.y;
+ float z= p.z;
+
+ float xt= m[0][0] * x + m[0][1] * y + m[0][2] * z + m[0][3]; // dot(vec4(m[0]), vec4(p, 1))
+ float yt= m[1][0] * x + m[1][1] * y + m[1][2] * z + m[1][3]; // dot(vec4(m[1]), vec4(p, 1))
+ float zt= m[2][0] * x + m[2][1] * y + m[2][2] * z + m[2][3]; // dot(vec4(m[2]), vec4(p, 1))
+ float wt= m[3][0] * x + m[3][1] * y + m[3][2] * z + m[3][3]; // dot(vec4(m[3]), vec4(p, 1))
+
+ assert(wt != 0);
+ float w= 1.f / wt;
+ if(wt == 1.f)
+ return Point(xt, yt, zt);
+ else
+ return Point(xt*w, yt*w, zt*w);
+}
+
+//! renvoie le vecteur transforme.
+Vector Transform::operator() ( const Vector& v ) const
+{
+ float x= v.x;
+ float y= v.y;
+ float z= v.z;
+
+ float xt= m[0][0] * x + m[0][1] * y + m[0][2] * z; // dot(vec4(m[0]), vec4(v, 0))
+ float yt= m[1][0] * x + m[1][1] * y + m[1][2] * z; // dot(vec4(m[1]), vec4(v, 0))
+ float zt= m[2][0] * x + m[2][1] * y + m[2][2] * z; // dot(vec4(m[2]), vec4(v, 0))
+ // dot(vec4(m[3]), vec4(v, 0)) == dot(vec4(0, 0, 0, 1), vec4(v, 0)) == 0 par definition
+
+ return Vector(xt, yt, zt);
+}
+
+//! renvoie le point/vecteur homogene transforme.
+vec4 Transform::operator() ( const vec4& v ) const
+{
+ float x= v.x;
+ float y= v.y;
+ float z= v.z;
+ float w= v.w;
+
+ float xt= m[0][0] * x + m[0][1] * y + m[0][2] * z + m[0][3] * w; // dot(vec4(m[0]), v)
+ float yt= m[1][0] * x + m[1][1] * y + m[1][2] * z + m[1][3] * w; // dot(vec4(m[1]), v)
+ float zt= m[2][0] * x + m[2][1] * y + m[2][2] * z + m[2][3] * w; // dot(vec4(m[2]), v)
+ float wt= m[3][0] * x + m[3][1] * y + m[3][2] * z + m[3][3] * w; // dot(vec4(m[3]), v)
+
+ return vec4(xt, yt, zt, wt);
+}
+
+//! renvoie la transposee de la matrice.
+Transform Transform::transpose( ) const
+{
+ return Transform(
+ m[0][0], m[1][0], m[2][0], m[3][0],
+ m[0][1], m[1][1], m[2][1], m[3][1],
+ m[0][2], m[1][2], m[2][2], m[3][2],
+ m[0][3], m[1][3], m[2][3], m[3][3]);
+}
+
+
+Transform Transform::operator() ( const Transform& b ) const
+{
+ return compose_transform(*this, b);
+}
+
+//! renvoie la transformation a appliquer aux normales d'un objet transforme par la matrice m.
+Transform Transform::normal( ) const
+{
+ return inverse().transpose();
+}
+
+
+Transform Identity( )
+{
+ return Transform();
+}
+
+Transform Transpose( const Transform& m )
+{
+ return m.transpose();
+}
+
+Transform Inverse( const Transform& m )
+{
+ return m.inverse();
+}
+
+Transform Normal( const Transform& m )
+{
+ return m.normal();
+}
+
+Transform Scale( const float x, const float y, const float z )
+{
+ return Transform(
+ x, 0, 0, 0,
+ 0, y, 0, 0,
+ 0, 0, z, 0,
+ 0, 0, 0, 1);
+}
+
+Transform Translation( const Vector& v )
+{
+ return Transform(
+ 1, 0, 0, v.x,
+ 0, 1, 0, v.y,
+ 0, 0, 1, v.z,
+ 0, 0, 0, 1);
+}
+
+Transform Translation( const float x, const float y, const float z )
+{
+ return Translation( Vector(x, y, z) );
+}
+
+Transform RotationX( const float a )
+{
+ float sin_t= sinf(radians(a));
+ float cos_t= cosf(radians(a));
+
+ return Transform(
+ 1, 0, 0, 0,
+ 0, cos_t, -sin_t, 0,
+ 0, sin_t, cos_t, 0,
+ 0, 0, 0, 1 );
+}
+
+Transform RotationY( const float a )
+{
+ float sin_t= sinf(radians(a));
+ float cos_t= cosf(radians(a));
+
+ return Transform(
+ cos_t, 0, sin_t, 0,
+ 0, 1, 0, 0,
+ -sin_t, 0, cos_t, 0,
+ 0, 0, 0, 1 );
+}
+
+Transform RotationZ( const float a )
+{
+ float sin_t= sinf(radians(a));
+ float cos_t= cosf(radians(a));
+
+ return Transform(
+ cos_t, -sin_t, 0, 0,
+ sin_t, cos_t, 0, 0,
+ 0, 0, 1, 0,
+ 0, 0, 0, 1 );
+}
+
+Transform Rotation( const Vector& axis, const float angle )
+{
+ Vector a= normalize(axis);
+ float s= sinf(radians(angle));
+ float c= cosf(radians(angle));
+
+ return Transform(
+ a.x * a.x + (1 - a.x * a.x ) * c,
+ a.x * a.y * (1 - c ) - a.z * s,
+ a.x * a.z * (1 - c ) + a.y * s,
+ 0,
+
+ a.x * a.y * (1 - c ) + a.z * s,
+ a.y * a.y + (1 - a.y * a.y ) * c,
+ a.y * a.z * (1 - c ) - a.x * s,
+ 0,
+
+ a.x * a.z * (1 - c ) - a.y * s,
+ a.y * a.z * (1 - c ) + a.x * s,
+ a.z * a.z + (1 - a.z * a.z ) * c,
+ 0,
+
+ 0, 0, 0, 1);
+}
+
+
+Transform Rotation( const Vector& u, const Vector& v )
+{
+ Vector a= normalize(u);
+ Vector b= normalize(v);
+ Vector w= cross(a, b); // rotation autour de w, un vecteur perpendiculaire a u et v
+ float s= length(w); // sin theta
+ float c= dot(a, b); // cos theta
+
+ // si u et v sont colineaires, pas d'axe de rotation, renvoyer +1 ou -1
+ if(s < float(0.00001))
+ //! \todo ajuster epsilon, ou trouver une autre formulation non degeneree...
+ return Scale(std::copysign(c, 1));
+
+ // normalise l'axe de rotation
+ w= w / s;
+
+ // meme matrice de rotation qu'au dessus , cf Rotation(axis, angle), l'axe est le vecteur w, s et c sont le sinus et le cosinus de l'angle
+ return Transform(
+ w.x * w.x + (1 - w.x * w.x ) * c,
+ w.x * w.y * (1 - c ) - w.z * s,
+ w.x * w.z * (1 - c ) + w.y * s,
+ 0,
+
+ w.x * w.y * (1 - c ) + w.z * s,
+ w.y * w.y + (1 - w.y * w.y ) * c,
+ w.y * w.z * (1 - c ) - w.x * s,
+ 0,
+
+ w.x * w.z * (1 - c ) - w.y * s,
+ w.y * w.z * (1 - c ) + w.x * s,
+ w.z * w.z + (1 - w.z * w.z ) * c,
+ 0,
+
+ 0, 0, 0, 1);
+}
+
+
+Transform Perspective( const float fov, const float aspect, const float znear, const float zfar )
+{
+ // perspective, openGL version
+ float itan= 1 / tanf(radians(fov) * 0.5f);
+ float id= 1 / (znear - zfar);
+
+ return Transform(
+ itan/aspect, 0, 0, 0,
+ 0, itan, 0, 0,
+ 0, 0, (zfar+znear)*id, 2.f*zfar*znear*id,
+ 0, 0, -1, 0);
+}
+
+
+Transform Ortho( const float left, const float right, const float bottom, const float top, const float znear, const float zfar )
+{
+ float tx= - (right + left) / (right - left);
+ float ty= - (top + bottom) / (top - bottom);
+ float tz= - (zfar + znear) / (zfar - znear);
+
+ return Transform(
+ 2.f / (right - left), 0, 0, tx,
+ 0, 2.f / (top - bottom), 0, ty,
+ 0, 0, -2.f / (zfar - znear), tz,
+ 0, 0, 0, 1);
+}
+
+
+Transform Viewport( const float width, const float height )
+{
+ float w= width / 2.f;
+ float h= height / 2.f;
+
+ return Transform(
+ w, 0, 0, w,
+ 0, h, 0, h,
+ 0, 0, .5f, .5f,
+ 0, 0, 0, 1);
+}
+
+Transform Lookat( const Point& from, const Point& to, const Vector& up )
+{
+ Vector dir= normalize( Vector(from, to) );
+ Vector right= normalize( cross(dir, normalize(up)) );
+ Vector newUp= normalize( cross(right, dir) );
+
+ Transform m(
+ right.x, newUp.x, -dir.x, from.x,
+ right.y, newUp.y, -dir.y, from.y,
+ right.z, newUp.z, -dir.z, from.z,
+ 0, 0, 0, 1);
+
+ return m.inverse();
+}
+
+Transform compose_transform( const Transform& a, const Transform& b )
+{
+ Transform m;
+ for(int i = 0; i < 4; i++)
+ for(int j = 0; j < 4; j++)
+ m.m[i][j]= a.m[i][0] * b.m[0][j] + a.m[i][1] * b.m[1][j] + a.m[i][2] * b.m[2][j] + a.m[i][3] * b.m[3][j];
+
+ return m;
+}
+
+Transform operator* ( const Transform& a, const Transform& b )
+{
+ return compose_transform(a, b);
+}
+
+Transform Transform::inverse( ) const
+{
+ Transform minv= *this;
+
+ int indxc[4], indxr[4];
+ int ipiv[4] = { 0, 0, 0, 0 };
+
+ for (int i = 0; i < 4; i++) {
+ int irow = -1, icol = -1;
+ float big = 0.f;
+
+ // Choose pivot
+ for (int j = 0; j < 4; j++) {
+ if (ipiv[j] != 1) {
+ for (int k = 0; k < 4; k++) {
+ if (ipiv[k] == 0) {
+ if (fabsf(minv.m[j][k]) >= big) {
+ big = std::abs(minv.m[j][k]);
+ irow = j;
+ icol = k;
+ }
+ }
+ else if (ipiv[k] > 1)
+ printf("singular matrix in Transform::inverse()\n");
+ }
+ }
+ }
+
+ assert(irow >= 0 && irow < 4);
+ assert(icol >= 0 && icol < 4);
+
+ ++ipiv[icol];
+ // Swap rows _irow_ and _icol_ for pivot
+ if (irow != icol) {
+ for (int k = 0; k < 4; ++k)
+ std::swap(minv.m[irow][k], minv.m[icol][k]);
+ }
+
+ indxr[i] = irow;
+ indxc[i] = icol;
+ if (minv.m[icol][icol] == 0.)
+ printf("singular matrix in Transform::inverse()\n");
+
+ // Set $m[icol][icol]$ to one by scaling row _icol_ appropriately
+ float pivinv = 1.f / minv.m[icol][icol];
+ minv.m[icol][icol] = 1.f;
+ for (int j = 0; j < 4; j++)
+ minv.m[icol][j] *= pivinv;
+
+ // Subtract this row from others to zero out their columns
+ for (int j = 0; j < 4; j++) {
+ if (j != icol) {
+ float save = minv.m[j][icol];
+ minv.m[j][icol] = 0;
+ for (int k = 0; k < 4; k++)
+ minv.m[j][k] -= minv.m[icol][k]*save;
+ }
+ }
+ }
+
+ // Swap columns to reflect permutation
+ for (int j = 3; j >= 0; j--) {
+ if (indxr[j] != indxc[j]) {
+ for (int k = 0; k < 4; k++)
+ std::swap(minv.m[k][indxr[j]], minv.m[k][indxc[j]]);
+ }
+ }
+
+ return minv;
+}
diff --git a/code/src/mat.h b/code/src/mat.h
new file mode 100644
index 0000000..bc99fb3
--- /dev/null
+++ b/code/src/mat.h
@@ -0,0 +1,126 @@
+
+#pragma once
+
+#include "vec.h"
+
+
+//! \addtogroup math manipulations de points, vecteur, matrices, transformations
+///@{
+
+//! \file
+//! transformation de points et vecteurs
+
+//! conversion en radians.
+float radians( const float deg );
+//! conversion en degres.
+float degrees( const float rad );
+
+//! representation d'une transformation, une matrice 4x4, organisee par ligne / row major.
+struct Transform
+{
+ //! constructeur.
+ Transform (
+ const float t00= 1, const float t01= 0, const float t02= 0, const float t03= 0,
+ const float t10= 0, const float t11= 1, const float t12= 0, const float t13= 0,
+ const float t20= 0, const float t21= 0, const float t22= 1, const float t23= 0,
+ const float t30= 0, const float t31= 0, const float t32= 0, const float t33= 1 );
+
+ //! constructeur a partir de 4 Vector colonnes, met (0, 0, 0, 1) dans la 4e ligne
+ Transform( const Vector& x, const Vector& y, const Vector& z, const Vector& w );
+
+ //! initialise une colonne de la matrice a partir de 4 floats.
+ Transform& column( const int id, const float t0, const float t1, const float t2, const float t3 );
+
+ //! initialise une ligne de la matrice.
+ Transform& row( const int id, const float t0, const float t1, const float t2, const float t3 );
+
+ //! initialise la matrice avec 16 floats organises par colonne.
+ Transform& column_major( const float matrix[16] );
+
+ //! initialise la matrice avec 16 floats organises par ligne.
+ Transform& row_major( const float matrix[16] );
+
+ //! renvoie le Vector colonne c de la matrice
+ Vector operator[] ( const int c ) const;
+
+ //! renvoie le point transforme.
+ Point operator() ( const Point& p ) const;
+ //! renvoie le vecteur transforme.
+ Vector operator() ( const Vector& v ) const;
+ //! renvoie le point/vecteur homogene transforme.
+ vec4 operator() ( const vec4& v ) const;
+
+ //! renvoie la composition de la transformation this et b, t = this * b. permet de transformer un point sans "ambiguite" Point q= a(b(c(p)));
+ Transform operator() ( const Transform& b ) const;
+
+ //! renvoie la transposee de la matrice.
+ Transform transpose( ) const;
+ //! renvoie l'inverse de la matrice.
+ Transform inverse( ) const;
+ //! renvoie la transformation a appliquer aux normales d'un objet transforme par la matrice m.
+ Transform normal( ) const;
+
+ //! renvoie l'adresse de la premiere valeur de la matrice.
+ const float *data( ) const { return &m[0][0]; }
+
+ float m[4][4];
+};
+
+//! construit la transformation identite.
+Transform Identity( );
+
+//! renvoie la transposee de la matrice.
+Transform Transpose( const Transform& m );
+//! renvoie l'inverse de la matrice.
+Transform Inverse( const Transform& m );
+//! renvoie la transformation a appliquer aux normales d'un objet transforme par la matrice m.
+Transform Normal( const Transform& m );
+
+//! renvoie la matrice representant une mise a l'echelle / etirement.
+Transform Scale( const float x, const float y, const float z );
+inline Transform Scale( const float s ) { return Scale(s, s, s); }
+
+//! renvoie la matrice representant une translation par un vecteur.
+Transform Translation( const Vector& v );
+//! renvoie la matrice representant une translation par un vecteur x y z.
+Transform Translation( const float x, const float y, const float z );
+
+//! renvoie la matrice representation une rotation de angle degree autour de l'axe X.
+Transform RotationX( const float angle );
+//! renvoie la matrice representation une rotation de a degree autour de l'axe Y.
+Transform RotationY( const float angle );
+//! renvoie la matrice representation une rotation de angle degree autour de l'axe Z.
+Transform RotationZ( const float angle );
+//! renvoie la matrice representation une rotation de angle degree autour de l'axe axis.
+Transform Rotation( const Vector& axis, const float angle );
+
+//! renvoie la matrice de rotation entre u et v.
+Transform Rotation( const Vector&u, const Vector& v );
+
+//! renvoie la matrice representant une transformation viewport.
+Transform Viewport( const float width, const float height );
+//! renvoie la matrice representant une transformation projection perspective.
+Transform Perspective( const float fov, const float aspect, const float znear, const float zfar );
+//! renvoie la matrice representant une transformation orthographique, passage d'un cube []x[]x[] vers [-1 1]x[-1 1]x[-1 1].
+Transform Ortho( const float left, const float right, const float bottom, const float top, const float znear, const float zfar );
+//! renvoie la matrice representant le placement et l'orientation d'une camera pour observer le point to.
+Transform Lookat( const Point& from, const Point& to, const Vector& up );
+
+//! renvoie la composition des transformations a et b, t= a * b.
+Transform compose_transform( const Transform& a, const Transform& b );
+//! renvoie la composition des transformations a et b, t = a * b.
+Transform operator* ( const Transform& a, const Transform& b );
+
+//
+#include <iostream>
+
+inline std::ostream& operator<<(std::ostream& o, const Transform& t)
+{
+ o << t.m[0][0] << " " << t.m[0][1] << " " << t.m[0][2] << " " << t.m[0][3] << " " << std::endl;
+ o << t.m[1][0] << " " << t.m[1][1] << " " << t.m[1][2] << " " << t.m[1][3] << " " << std::endl;
+ o << t.m[2][0] << " " << t.m[2][1] << " " << t.m[2][2] << " " << t.m[2][3] << " " << std::endl;
+ o << t.m[3][0] << " " << t.m[3][1] << " " << t.m[3][2] << " " << t.m[3][3] << " " << std::endl;
+ return o;
+}
+
+///@}
diff --git a/code/src/orbiter.cpp b/code/src/orbiter.cpp
new file mode 100755
index 0000000..1316bda
--- /dev/null
+++ b/code/src/orbiter.cpp
@@ -0,0 +1,152 @@
+
+#include <cstdio>
+#include <algorithm>
+
+#include "orbiter.h"
+
+void Orbiter::lookat( const Point& center, const float size )
+{
+ m_center= center;
+ m_position= vec2(0, 0);
+ m_rotation= vec2(0, 180);
+ m_size= size;
+ m_radius= size;
+}
+
+void Orbiter::lookat( const Point& pmin, const Point& pmax )
+{
+ lookat(center(pmin, pmax), distance(pmin, pmax));
+}
+
+void Orbiter::rotation( const float x, const float y )
+{
+ m_rotation.x= m_rotation.x + y;
+ m_rotation.y= m_rotation.y + x;
+}
+
+void Orbiter::translation( const float x, const float y )
+{
+ m_position.x= m_position.x - m_size * x;
+ m_position.y= m_position.y + m_size * y;
+}
+
+void Orbiter::move( const float z )
+{
+ m_size= m_size - m_size * 0.01f * z;
+ if(m_size < 0.001f)
+ m_size= 0.001f;
+}
+
+Transform Orbiter::view( ) const
+{
+ return Translation( -m_position.x, -m_position.y, -m_size )
+ * RotationX(m_rotation.x) * RotationY(m_rotation.y)
+ * Translation( -m_center.x, -m_center.y, -m_center.z );
+}
+
+Transform Orbiter::projection( const int width, const int height, const float fov )
+{
+ m_width= width;
+ m_height= height;
+ m_fov= fov;
+
+ return projection();
+}
+
+float Orbiter::znear( ) const
+{
+ // calcule la distance entre le centre de l'objet et la camera
+ float d= distance(m_center, Point(m_position.x, m_position.y, m_size));
+ return std::max(float(0.1), d - m_radius);
+}
+
+float Orbiter::zfar( ) const
+{
+ // calcule la distance entre le centre de l'objet et la camera
+ float d= distance(m_center, Point(m_position.x, m_position.y, m_size));
+ return std::max(float(1), d + m_radius);
+}
+
+
+Transform Orbiter::projection( ) const
+{
+ // regle near et far en fonction du centre et du rayon englobant l'objet
+ return Perspective(m_fov, m_width / m_height, znear(), zfar());
+}
+
+Transform Orbiter::viewport( ) const
+{
+ return Viewport(m_width, m_height);
+}
+
+//! renvoie l'aspect de la camera.
+float Orbiter::aspect( ) const
+{
+ return float(m_width) / float(m_height);
+}
+
+//! renvoie l'ouverture de la camera.
+float Orbiter::fovy( ) const
+{
+ return m_fov;
+}
+
+Point Orbiter::position( )
+{
+ Transform t= view(); // passage monde vers camera
+ Transform tinv= t.inverse(); // l'inverse, passage camera vers monde
+
+ return tinv(Point(0, 0, 0)); // la camera se trouve a l'origine, dans le repere camera...
+}
+
+bool Orbiter::read_orbiter( const char *filename )
+{
+ FILE *in= fopen(filename, "rt");
+ if(in == nullptr)
+ {
+ printf("[error] loading orbiter '%s'...\n", filename);
+ return false;
+ }
+
+ printf("loading orbiter '%s'...\n", filename);
+
+ bool errors= false;
+ if(fscanf(in, " c %f %f %f \n", &m_center.x, &m_center.y, &m_center.z) != 3)
+ errors= true;
+ if(fscanf(in, " p %f %f\n", &m_position.x, &m_position.y) != 2)
+ errors= true;
+ if(fscanf(in, " r %f %f\n", &m_rotation.x, &m_rotation.y) != 2)
+ errors= true;
+ if(fscanf(in, " s %f %f\n", &m_size, &m_radius) != 2)
+ errors= true;
+
+ if(fscanf(in, " f %f %f %f\n", &m_fov, &m_width, &m_height) != 3)
+ errors= true;
+
+ fclose(in);
+ if(errors)
+ printf("[error] loading orbiter '%s'...\n", filename);
+
+ return !errors;
+}
+
+bool Orbiter::write_orbiter( const char *filename )
+{
+ FILE *out= fopen(filename, "wt");
+ if(out == nullptr)
+ {
+ printf("[error] writing orbiter '%s'...\n", filename);
+ return false;
+ }
+
+ printf("writing orbiter '%s'...\n", filename);
+
+ fprintf(out, "c %f %f %f\n", m_center.x, m_center.y, m_center.z);
+ fprintf(out, "p %f %f\n", m_position.x, m_position.y);
+ fprintf(out, "r %f %f\n", m_rotation.x, m_rotation.y);
+ fprintf(out, "s %f %f\n", m_size, m_radius);
+ fprintf(out, "f %f %f %f\n", m_fov, m_width, m_height);
+
+ fclose(out);
+ return true;
+}
diff --git a/code/src/orbiter.h b/code/src/orbiter.h
new file mode 100755
index 0000000..e520681
--- /dev/null
+++ b/code/src/orbiter.h
@@ -0,0 +1,71 @@
+
+#ifndef _ORBITER_H
+#define _ORBITER_H
+
+#include "vec.h"
+#include "mat.h"
+
+
+//! representation d'une camera, type orbiter, placee sur une sphere autour du centre de l'objet.
+class Orbiter
+{
+public:
+ //! cree une camera par defaut. observe le centre (0, 0, 0) a une distance 5.
+ Orbiter( ) : m_center(), m_position(), m_rotation(), m_size(5.f), m_radius(5.f), m_width(1), m_height(1), m_fov(45) {}
+
+ //! observe le point center a une distance size.
+ void lookat( const Point& center, const float size );
+ //! observe le centre d'une boite englobante.
+ void lookat( const Point& pmin, const Point& pmax );
+
+ //! fixe la projection reglee pour une image d'aspect width / height, et une demi ouverture de fov degres.
+ Transform projection( const int width, const int height, const float fov );
+ //! renvoie le plan proche de la projection. distance min des points dans le frustum de la camera (valeur dans le repere camera).
+ float znear( ) const;
+ //! revnvoie le plan loin de la projection. distance max des points dans le frustum de la camera (valeur dans le repere camera).
+ float zfar( ) const;
+
+ //! change le point de vue / la direction d'observation.
+ void rotation( const float x, const float y );
+ //! deplace le centre / le point observe.
+ void translation( const float x, const float y );
+ //! rapproche / eloigne la camera du centre.
+ void move( const float z );
+
+ //! renvoie la transformation vue.
+ Transform view( ) const;
+ //! renvoie la transformation projection actuelle. doit etre initialise par projection(width, height, fov).
+ Transform projection( ) const;
+ //! renvoie la transformation viewport actuelle. doit etre initialise par projection(width, height, fov).
+ Transform viewport( ) const;
+ //! renvoie l'aspect de la camera.
+ float aspect( ) const;
+ //! renvoie la demi ouverture de la camera en degres.
+ float fovy( ) const;
+
+ //! renvoie la position de la camera dans le repere du monde.
+ Point position( );
+
+ //! relit la position de l'orbiter depuis un fichier texte.
+ bool read_orbiter( const char *filename );
+
+ //! enregistre la position de l'orbiter dans un fichier texte.
+ bool write_orbiter( const char *filename );
+
+ //! renvoie le rayon de la scene.
+ float radius() const { return m_radius; }
+
+protected:
+ Point m_center;
+ vec2 m_position;
+ vec2 m_rotation;
+ float m_size;
+ float m_radius;
+
+ float m_width;
+ float m_height;
+ float m_fov;
+};
+
+///@}
+#endif
diff --git a/code/src/stb_image.h b/code/src/stb_image.h
new file mode 100644
index 0000000..5e807a0
--- /dev/null
+++ b/code/src/stb_image.h
@@ -0,0 +1,7987 @@
+/* stb_image - v2.28 - public domain image loader - http://nothings.org/stb
+ no warranty implied; use at your own risk
+
+ Do this:
+ #define STB_IMAGE_IMPLEMENTATION
+ before you include this file in *one* C or C++ file to create the implementation.
+
+ // i.e. it should look like this:
+ #include ...
+ #include ...
+ #include ...
+ #define STB_IMAGE_IMPLEMENTATION
+ #include "stb_image.h"
+
+ You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
+ And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
+
+
+ QUICK NOTES:
+ Primarily of interest to game developers and other people who can
+ avoid problematic images and only need the trivial interface
+
+ JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
+ PNG 1/2/4/8/16-bit-per-channel
+
+ TGA (not sure what subset, if a subset)
+ BMP non-1bpp, non-RLE
+ PSD (composited view only, no extra channels, 8/16 bit-per-channel)
+
+ GIF (*comp always reports as 4-channel)
+ HDR (radiance rgbE format)
+ PIC (Softimage PIC)
+ PNM (PPM and PGM binary only)
+
+ Animated GIF still needs a proper API, but here's one way to do it:
+ http://gist.github.com/urraka/685d9a6340b26b830d49
+
+ - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+ - decode from arbitrary I/O callbacks
+ - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
+
+ Full documentation under "DOCUMENTATION" below.
+
+
+LICENSE
+
+ See end of file for license information.
+
+RECENT REVISION HISTORY:
+
+ 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff
+ 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes
+ 2.26 (2020-07-13) many minor fixes
+ 2.25 (2020-02-02) fix warnings
+ 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically
+ 2.23 (2019-08-11) fix clang static analysis warning
+ 2.22 (2019-03-04) gif fixes, fix warnings
+ 2.21 (2019-02-25) fix typo in comment
+ 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
+ 2.19 (2018-02-11) fix warning
+ 2.18 (2018-01-30) fix warnings
+ 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
+ 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
+ 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
+ 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+ 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
+ 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+ 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
+ RGB-format JPEG; remove white matting in PSD;
+ allocate large structures on the stack;
+ correct channel count for PNG & BMP
+ 2.10 (2016-01-22) avoid warning introduced in 2.09
+ 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
+
+ See end of file for full revision history.
+
+
+ ============================ Contributors =========================
+
+ Image formats Extensions, features
+ Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info)
+ Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info)
+ Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG)
+ Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks)
+ Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG)
+ Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip)
+ Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD)
+ github:urraka (animated gif) Junggon Kim (PNM comments)
+ Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA)
+ socks-the-fox (16-bit PNG)
+ Jeremy Sawicki (handle all ImageNet JPGs)
+ Optimizations & bugfixes Mikhail Morozov (1-bit BMP)
+ Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query)
+ Arseny Kapoulkine Simon Breuss (16-bit PNM)
+ John-Mark Allen
+ Carmelo J Fdez-Aguera
+
+ Bug & warning fixes
+ Marc LeBlanc David Woo Guillaume George Martins Mozeiko
+ Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski
+ Phil Jordan Dave Moore Roy Eltham
+ Hayaki Saito Nathan Reed Won Chun
+ Luke Graham Johan Duparc Nick Verigakis the Horde3D community
+ Thomas Ruf Ronny Chevalier github:rlyeh
+ Janez Zemva John Bartholomew Michal Cichon github:romigrou
+ Jonathan Blow Ken Hamada Tero Hanninen github:svdijk
+ Eugene Golushkov Laurent Gomila Cort Stratton github:snagar
+ Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex
+ Cass Everitt Ryamond Barbiero github:grim210
+ Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw
+ Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus
+ Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo
+ Julian Raschke Gregory Mullen Christian Floisand github:darealshinji
+ Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007
+ Brad Weinberger Matvey Cherevko github:mosra
+ Luca Sas Alexander Veselov Zack Middleton [reserved]
+ Ryan C. Gordon [reserved] [reserved]
+ DO NOT ADD YOUR NAME HERE
+
+ Jacko Dirks
+
+ To add your name to the credits, pick a random blank space in the middle and fill it.
+ 80% of merge conflicts on stb PRs are due to people adding their name at the end
+ of the credits.
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// DOCUMENTATION
+//
+// Limitations:
+// - no 12-bit-per-channel JPEG
+// - no JPEGs with arithmetic coding
+// - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below for HDR usage):
+// int x,y,n;
+// unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+// // ... process data if not NULL ...
+// // ... x = width, y = height, n = # 8-bit components per pixel ...
+// // ... replace '0' with '1'..'4' to force that many components per pixel
+// // ... but 'n' will always be the number that it would have been if you said 0
+// stbi_image_free(data);
+//
+// Standard parameters:
+// int *x -- outputs image width in pixels
+// int *y -- outputs image height in pixels
+// int *channels_in_file -- outputs # of image components in image file
+// int desired_channels -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data, or NULL on an allocation failure or if the image is
+// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'desired_channels' if desired_channels is non-zero, or
+// *channels_in_file otherwise. If desired_channels is non-zero,
+// *channels_in_file has the number of components that _would_ have been
+// output otherwise. E.g. if you set desired_channels to 4, you will always
+// get RGBA output, but you can check *channels_in_file to see if it's trivially
+// opaque because e.g. there were only 3 channels in the source image.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+// N=#comp components
+// 1 grey
+// 2 grey, alpha
+// 3 red, green, blue
+// 4 red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *channels_in_file will be unchanged. The function
+// stbi_failure_reason() can be queried for an extremely brief, end-user
+// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS
+// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+//
+// To query the width, height and component count of an image without having to
+// decode the full file, you can use the stbi_info family of functions:
+//
+// int x,y,n,ok;
+// ok = stbi_info(filename, &x, &y, &n);
+// // returns ok=1 and sets x, y, n if image is a supported format,
+// // 0 otherwise.
+//
+// Note that stb_image pervasively uses ints in its public API for sizes,
+// including sizes of memory buffers. This is now part of the API and thus
+// hard to change without causing breakage. As a result, the various image
+// loaders all have certain limits on image size; these differ somewhat
+// by format but generally boil down to either just under 2GB or just under
+// 1GB. When the decoded image would be larger than this, stb_image decoding
+// will fail.
+//
+// Additionally, stb_image will reject image files that have any of their
+// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS,
+// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit,
+// the only way to have an image with such dimensions load correctly
+// is for it to have a rather extreme aspect ratio. Either way, the
+// assumption here is that such larger images are likely to be malformed
+// or malicious. If you do need to load an image with individual dimensions
+// larger than that, and it still fits in the overall size limit, you can
+// #define STBI_MAX_DIMENSIONS on your own to be something larger.
+//
+// ===========================================================================
+//
+// UNICODE:
+//
+// If compiling for Windows and you wish to use Unicode filenames, compile
+// with
+// #define STBI_WINDOWS_UTF8
+// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
+// Windows wchar_t filenames to utf8.
+//
+// ===========================================================================
+//
+// Philosophy
+//
+// stb libraries are designed with the following priorities:
+//
+// 1. easy to use
+// 2. easy to maintain
+// 3. good performance
+//
+// Sometimes I let "good performance" creep up in priority over "easy to maintain",
+// and for best performance I may provide less-easy-to-use APIs that give higher
+// performance, in addition to the easy-to-use ones. Nevertheless, it's important
+// to keep in mind that from the standpoint of you, a client of this library,
+// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
+//
+// Some secondary priorities arise directly from the first two, some of which
+// provide more explicit reasons why performance can't be emphasized.
+//
+// - Portable ("ease of use")
+// - Small source code footprint ("easy to maintain")
+// - No dependencies ("ease of use")
+//
+// ===========================================================================
+//
+// I/O callbacks
+//
+// I/O callbacks allow you to read from arbitrary sources, like packaged
+// files or some other source. Data read from callbacks are processed
+// through a small internal buffer (currently 128 bytes) to try to reduce
+// overhead.
+//
+// The three functions you must define are "read" (reads some bytes of data),
+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
+//
+// ===========================================================================
+//
+// SIMD support
+//
+// The JPEG decoder will try to automatically use SIMD kernels on x86 when
+// supported by the compiler. For ARM Neon support, you must explicitly
+// request it.
+//
+// (The old do-it-yourself SIMD API is no longer supported in the current
+// code.)
+//
+// On x86, SSE2 will automatically be used when available based on a run-time
+// test; if not, the generic C versions are used as a fall-back. On ARM targets,
+// the typical path is to have separate builds for NEON and non-NEON devices
+// (at least this is true for iOS and Android). Therefore, the NEON support is
+// toggled by a build flag: define STBI_NEON to get NEON loops.
+//
+// If for some reason you do not want to use any of SIMD code, or if
+// you have issues compiling it, you can disable it entirely by
+// defining STBI_NO_SIMD.
+//
+// ===========================================================================
+//
+// HDR image support (disable by defining STBI_NO_HDR)
+//
+// stb_image supports loading HDR images in general, and currently the Radiance
+// .HDR file format specifically. You can still load any file through the existing
+// interface; if you attempt to load an HDR file, it will be automatically remapped
+// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+// stbi_hdr_to_ldr_gamma(2.2f);
+// stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+// float *data = stbi_loadf(filename, &x, &y, &n, 0);
+//
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+// stbi_ldr_to_hdr_scale(1.0f);
+// stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+// stbi_is_hdr(char *filename);
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// We optionally support converting iPhone-formatted PNGs (which store
+// premultiplied BGRA) back to RGB, even though they're internally encoded
+// differently. To enable this conversion, call
+// stbi_convert_iphone_png_to_rgb(1).
+//
+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
+// pixel to remove any premultiplied alpha *only* if the image file explicitly
+// says there's premultiplied data (currently only happens in iPhone images,
+// and only if iPhone convert-to-rgb processing is on).
+//
+// ===========================================================================
+//
+// ADDITIONAL CONFIGURATION
+//
+// - You can suppress implementation of any of the decoders to reduce
+// your code footprint by #defining one or more of the following
+// symbols before creating the implementation.
+//
+// STBI_NO_JPEG
+// STBI_NO_PNG
+// STBI_NO_BMP
+// STBI_NO_PSD
+// STBI_NO_TGA
+// STBI_NO_GIF
+// STBI_NO_HDR
+// STBI_NO_PIC
+// STBI_NO_PNM (.ppm and .pgm)
+//
+// - You can request *only* certain decoders and suppress all other ones
+// (this will be more forward-compatible, as addition of new decoders
+// doesn't require you to disable them explicitly):
+//
+// STBI_ONLY_JPEG
+// STBI_ONLY_PNG
+// STBI_ONLY_BMP
+// STBI_ONLY_PSD
+// STBI_ONLY_TGA
+// STBI_ONLY_GIF
+// STBI_ONLY_HDR
+// STBI_ONLY_PIC
+// STBI_ONLY_PNM (.ppm and .pgm)
+//
+// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
+// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
+//
+// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater
+// than that size (in either width or height) without further processing.
+// This is to let programs in the wild set an upper bound to prevent
+// denial-of-service attacks on untrusted data, as one could generate a
+// valid image of gigantic dimensions and force stb_image to allocate a
+// huge block of memory and spend disproportionate time decoding it. By
+// default this is set to (1 << 24), which is 16777216, but that's still
+// very big.
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif // STBI_NO_STDIO
+
+#define STBI_VERSION 1
+
+enum
+{
+ STBI_default = 0, // only used for desired_channels
+
+ STBI_grey = 1,
+ STBI_grey_alpha = 2,
+ STBI_rgb = 3,
+ STBI_rgb_alpha = 4
+};
+
+#include <stdlib.h>
+typedef unsigned char stbi_uc;
+typedef unsigned short stbi_us;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef STBIDEF
+#ifdef STB_IMAGE_STATIC
+#define STBIDEF static
+#else
+#define STBIDEF extern
+#endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PRIMARY API - works on images of any type
+//
+
+//
+// load image by filename, open file, or memory buffer
+//
+
+typedef struct
+{
+ int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read
+ void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
+ int (*eof) (void *user); // returns nonzero if we are at end of file/data
+} stbi_io_callbacks;
+
+////////////////////////////////////
+//
+// 8-bits-per-channel interface
+//
+
+STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+#endif
+
+#ifdef STBI_WINDOWS_UTF8
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
+#endif
+
+////////////////////////////////////
+//
+// 16-bits-per-channel interface
+//
+
+STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+#endif
+
+////////////////////////////////////
+//
+// float-per-channel interface
+//
+#ifndef STBI_NO_LINEAR
+ STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+ STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+ #ifndef STBI_NO_STDIO
+ STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+ STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+ #endif
+#endif
+
+#ifndef STBI_NO_HDR
+ STBIDEF void stbi_hdr_to_ldr_gamma(float gamma);
+ STBIDEF void stbi_hdr_to_ldr_scale(float scale);
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_LINEAR
+ STBIDEF void stbi_ldr_to_hdr_gamma(float gamma);
+ STBIDEF void stbi_ldr_to_hdr_scale(float scale);
+#endif // STBI_NO_LINEAR
+
+// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
+STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_is_hdr (char const *filename);
+STBIDEF int stbi_is_hdr_from_file(FILE *f);
+#endif // STBI_NO_STDIO
+
+
+// get a VERY brief reason for failure
+// on most compilers (and ALL modern mainstream compilers) this is threadsafe
+STBIDEF const char *stbi_failure_reason (void);
+
+// free the loaded image -- this is just free()
+STBIDEF void stbi_image_free (void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp);
+STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);
+STBIDEF int stbi_is_16_bit (char const *filename);
+STBIDEF int stbi_is_16_bit_from_file(FILE *f);
+#endif
+
+
+
+// for image formats that explicitly notate that they have premultiplied alpha,
+// we just return the colors as stored in the file. set this flag to force
+// unpremultiplication. results are undefined if the unpremultiply overflow.
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
+
+// indicate whether we should process iphone images back to canonical format,
+// or just pass them through "as-is"
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+// flip the image vertically, so the first pixel in the output array is the bottom left
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
+
+// as above, but only applies to images loaded on the thread that calls the function
+// this function is only available if your compiler supports thread-local variables;
+// calling it will fail to link if your compiler doesn't
+STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply);
+STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert);
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);
+
+// ZLIB client - used by PNG, available for other purposes
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
+STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+//// end header file /////////////////////////////////////////////////////
+#endif // STBI_INCLUDE_STB_IMAGE_H
+
+#ifdef STB_IMAGE_IMPLEMENTATION
+
+#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
+ || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
+ || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
+ || defined(STBI_ONLY_ZLIB)
+ #ifndef STBI_ONLY_JPEG
+ #define STBI_NO_JPEG
+ #endif
+ #ifndef STBI_ONLY_PNG
+ #define STBI_NO_PNG
+ #endif
+ #ifndef STBI_ONLY_BMP
+ #define STBI_NO_BMP
+ #endif
+ #ifndef STBI_ONLY_PSD
+ #define STBI_NO_PSD
+ #endif
+ #ifndef STBI_ONLY_TGA
+ #define STBI_NO_TGA
+ #endif
+ #ifndef STBI_ONLY_GIF
+ #define STBI_NO_GIF
+ #endif
+ #ifndef STBI_ONLY_HDR
+ #define STBI_NO_HDR
+ #endif
+ #ifndef STBI_ONLY_PIC
+ #define STBI_NO_PIC
+ #endif
+ #ifndef STBI_ONLY_PNM
+ #define STBI_NO_PNM
+ #endif
+#endif
+
+#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
+#define STBI_NO_ZLIB
+#endif
+
+
+#include <stdarg.h>
+#include <stddef.h> // ptrdiff_t on osx
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+#include <math.h> // ldexp, pow
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifndef STBI_ASSERT
+#include <assert.h>
+#define STBI_ASSERT(x) assert(x)
+#endif
+
+#ifdef __cplusplus
+#define STBI_EXTERN extern "C"
+#else
+#define STBI_EXTERN extern
+#endif
+
+
+#ifndef _MSC_VER
+ #ifdef __cplusplus
+ #define stbi_inline inline
+ #else
+ #define stbi_inline
+ #endif
+#else
+ #define stbi_inline __forceinline
+#endif
+
+#ifndef STBI_NO_THREAD_LOCALS
+ #if defined(__cplusplus) && __cplusplus >= 201103L
+ #define STBI_THREAD_LOCAL thread_local
+ #elif defined(__GNUC__) && __GNUC__ < 5
+ #define STBI_THREAD_LOCAL __thread
+ #elif defined(_MSC_VER)
+ #define STBI_THREAD_LOCAL __declspec(thread)
+ #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
+ #define STBI_THREAD_LOCAL _Thread_local
+ #endif
+
+ #ifndef STBI_THREAD_LOCAL
+ #if defined(__GNUC__)
+ #define STBI_THREAD_LOCAL __thread
+ #endif
+ #endif
+#endif
+
+#if defined(_MSC_VER) || defined(__SYMBIAN32__)
+typedef unsigned short stbi__uint16;
+typedef signed short stbi__int16;
+typedef unsigned int stbi__uint32;
+typedef signed int stbi__int32;
+#else
+#include <stdint.h>
+typedef uint16_t stbi__uint16;
+typedef int16_t stbi__int16;
+typedef uint32_t stbi__uint32;
+typedef int32_t stbi__int32;
+#endif
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
+
+#ifdef _MSC_VER
+#define STBI_NOTUSED(v) (void)(v)
+#else
+#define STBI_NOTUSED(v) (void)sizeof(v)
+#endif
+
+#ifdef _MSC_VER
+#define STBI_HAS_LROTL
+#endif
+
+#ifdef STBI_HAS_LROTL
+ #define stbi_lrot(x,y) _lrotl(x,y)
+#else
+ #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31)))
+#endif
+
+#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
+// ok
+#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
+// ok
+#else
+#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
+#endif
+
+#ifndef STBI_MALLOC
+#define STBI_MALLOC(sz) malloc(sz)
+#define STBI_REALLOC(p,newsz) realloc(p,newsz)
+#define STBI_FREE(p) free(p)
+#endif
+
+#ifndef STBI_REALLOC_SIZED
+#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
+#endif
+
+// x86/x64 detection
+#if defined(__x86_64__) || defined(_M_X64)
+#define STBI__X64_TARGET
+#elif defined(__i386) || defined(_M_IX86)
+#define STBI__X86_TARGET
+#endif
+
+#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
+// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
+// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
+// but previous attempts to provide the SSE2 functions with runtime
+// detection caused numerous issues. The way architecture extensions are
+// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
+// New behavior: if compiled with -msse2, we use SSE2 without any
+// detection; if not, we don't use it at all.
+#define STBI_NO_SIMD
+#endif
+
+#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
+// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
+//
+// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
+// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
+// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
+// simultaneously enabling "-mstackrealign".
+//
+// See https://github.com/nothings/stb/issues/81 for more information.
+//
+// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
+// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
+#define STBI_NO_SIMD
+#endif
+
+#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
+#define STBI_SSE2
+#include <emmintrin.h>
+
+#ifdef _MSC_VER
+
+#if _MSC_VER >= 1400 // not VC6
+#include <intrin.h> // __cpuid
+static int stbi__cpuid3(void)
+{
+ int info[4];
+ __cpuid(info,1);
+ return info[3];
+}
+#else
+static int stbi__cpuid3(void)
+{
+ int res;
+ __asm {
+ mov eax,1
+ cpuid
+ mov res,edx
+ }
+ return res;
+}
+#endif
+
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+ int info3 = stbi__cpuid3();
+ return ((info3 >> 26) & 1) != 0;
+}
+#endif
+
+#else // assume GCC-style if not VC++
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+ // If we're even attempting to compile this on GCC/Clang, that means
+ // -msse2 is on, which means the compiler is allowed to use SSE2
+ // instructions at will, and so are we.
+ return 1;
+}
+#endif
+
+#endif
+#endif
+
+// ARM NEON
+#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
+#undef STBI_NEON
+#endif
+
+#ifdef STBI_NEON
+#include <arm_neon.h>
+#ifdef _MSC_VER
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+#else
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+#endif
+#endif
+
+#ifndef STBI_SIMD_ALIGN
+#define STBI_SIMD_ALIGN(type, name) type name
+#endif
+
+#ifndef STBI_MAX_DIMENSIONS
+#define STBI_MAX_DIMENSIONS (1 << 24)
+#endif
+
+///////////////////////////////////////////////
+//
+// stbi__context struct and start_xxx functions
+
+// stbi__context structure is our basic context used by all images, so it
+// contains all the IO context, plus some basic image information
+typedef struct
+{
+ stbi__uint32 img_x, img_y;
+ int img_n, img_out_n;
+
+ stbi_io_callbacks io;
+ void *io_user_data;
+
+ int read_from_callbacks;
+ int buflen;
+ stbi_uc buffer_start[128];
+ int callback_already_read;
+
+ stbi_uc *img_buffer, *img_buffer_end;
+ stbi_uc *img_buffer_original, *img_buffer_original_end;
+} stbi__context;
+
+
+static void stbi__refill_buffer(stbi__context *s);
+
+// initialize a memory-decode context
+static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
+{
+ s->io.read = NULL;
+ s->read_from_callbacks = 0;
+ s->callback_already_read = 0;
+ s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
+ s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
+}
+
+// initialize a callback-based context
+static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
+{
+ s->io = *c;
+ s->io_user_data = user;
+ s->buflen = sizeof(s->buffer_start);
+ s->read_from_callbacks = 1;
+ s->callback_already_read = 0;
+ s->img_buffer = s->img_buffer_original = s->buffer_start;
+ stbi__refill_buffer(s);
+ s->img_buffer_original_end = s->img_buffer_end;
+}
+
+#ifndef STBI_NO_STDIO
+
+static int stbi__stdio_read(void *user, char *data, int size)
+{
+ return (int) fread(data,1,size,(FILE*) user);
+}
+
+static void stbi__stdio_skip(void *user, int n)
+{
+ int ch;
+ fseek((FILE*) user, n, SEEK_CUR);
+ ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */
+ if (ch != EOF) {
+ ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */
+ }
+}
+
+static int stbi__stdio_eof(void *user)
+{
+ return feof((FILE*) user) || ferror((FILE *) user);
+}
+
+static stbi_io_callbacks stbi__stdio_callbacks =
+{
+ stbi__stdio_read,
+ stbi__stdio_skip,
+ stbi__stdio_eof,
+};
+
+static void stbi__start_file(stbi__context *s, FILE *f)
+{
+ stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
+}
+
+//static void stop_file(stbi__context *s) { }
+
+#endif // !STBI_NO_STDIO
+
+static void stbi__rewind(stbi__context *s)
+{
+ // conceptually rewind SHOULD rewind to the beginning of the stream,
+ // but we just rewind to the beginning of the initial buffer, because
+ // we only use it after doing 'test', which only ever looks at at most 92 bytes
+ s->img_buffer = s->img_buffer_original;
+ s->img_buffer_end = s->img_buffer_original_end;
+}
+
+enum
+{
+ STBI_ORDER_RGB,
+ STBI_ORDER_BGR
+};
+
+typedef struct
+{
+ int bits_per_channel;
+ int num_channels;
+ int channel_order;
+} stbi__result_info;
+
+#ifndef STBI_NO_JPEG
+static int stbi__jpeg_test(stbi__context *s);
+static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNG
+static int stbi__png_test(stbi__context *s);
+static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
+static int stbi__png_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_test(stbi__context *s);
+static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_TGA
+static int stbi__tga_test(stbi__context *s);
+static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_test(stbi__context *s);
+static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);
+static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
+static int stbi__psd_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_HDR
+static int stbi__hdr_test(stbi__context *s);
+static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_test(stbi__context *s);
+static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_GIF
+static int stbi__gif_test(stbi__context *s);
+static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNM
+static int stbi__pnm_test(stbi__context *s);
+static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
+static int stbi__pnm_is16(stbi__context *s);
+#endif
+
+static
+#ifdef STBI_THREAD_LOCAL
+STBI_THREAD_LOCAL
+#endif
+const char *stbi__g_failure_reason;
+
+STBIDEF const char *stbi_failure_reason(void)
+{
+ return stbi__g_failure_reason;
+}
+
+#ifndef STBI_NO_FAILURE_STRINGS
+static int stbi__err(const char *str)
+{
+ stbi__g_failure_reason = str;
+ return 0;
+}
+#endif
+
+static void *stbi__malloc(size_t size)
+{
+ return STBI_MALLOC(size);
+}
+
+// stb_image uses ints pervasively, including for offset calculations.
+// therefore the largest decoded image size we can support with the
+// current code, even on 64-bit targets, is INT_MAX. this is not a
+// significant limitation for the intended use case.
+//
+// we do, however, need to make sure our size calculations don't
+// overflow. hence a few helper functions for size calculations that
+// multiply integers together, making sure that they're non-negative
+// and no overflow occurs.
+
+// return 1 if the sum is valid, 0 on overflow.
+// negative terms are considered invalid.
+static int stbi__addsizes_valid(int a, int b)
+{
+ if (b < 0) return 0;
+ // now 0 <= b <= INT_MAX, hence also
+ // 0 <= INT_MAX - b <= INTMAX.
+ // And "a + b <= INT_MAX" (which might overflow) is the
+ // same as a <= INT_MAX - b (no overflow)
+ return a <= INT_MAX - b;
+}
+
+// returns 1 if the product is valid, 0 on overflow.
+// negative factors are considered invalid.
+static int stbi__mul2sizes_valid(int a, int b)
+{
+ if (a < 0 || b < 0) return 0;
+ if (b == 0) return 1; // mul-by-0 is always safe
+ // portable way to check for no overflows in a*b
+ return a <= INT_MAX/b;
+}
+
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
+// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad2sizes_valid(int a, int b, int add)
+{
+ return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
+}
+#endif
+
+// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad3sizes_valid(int a, int b, int c, int add)
+{
+ return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+ stbi__addsizes_valid(a*b*c, add);
+}
+
+// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
+static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
+{
+ return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+ stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
+}
+#endif
+
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
+// mallocs with size overflow checking
+static void *stbi__malloc_mad2(int a, int b, int add)
+{
+ if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
+ return stbi__malloc(a*b + add);
+}
+#endif
+
+static void *stbi__malloc_mad3(int a, int b, int c, int add)
+{
+ if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
+ return stbi__malloc(a*b*c + add);
+}
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
+static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
+{
+ if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
+ return stbi__malloc(a*b*c*d + add);
+}
+#endif
+
+// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.
+static int stbi__addints_valid(int a, int b)
+{
+ if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow
+ if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.
+ return a <= INT_MAX - b;
+}
+
+// returns 1 if the product of two signed shorts is valid, 0 on overflow.
+static int stbi__mul2shorts_valid(short a, short b)
+{
+ if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow
+ if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid
+ if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN
+ return a >= SHRT_MIN / b;
+}
+
+// stbi__err - error
+// stbi__errpf - error returning pointer to float
+// stbi__errpuc - error returning pointer to unsigned char
+
+#ifdef STBI_NO_FAILURE_STRINGS
+ #define stbi__err(x,y) 0
+#elif defined(STBI_FAILURE_USERMSG)
+ #define stbi__err(x,y) stbi__err(y)
+#else
+ #define stbi__err(x,y) stbi__err(x)
+#endif
+
+#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
+#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
+
+STBIDEF void stbi_image_free(void *retval_from_stbi_load)
+{
+ STBI_FREE(retval_from_stbi_load);
+}
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
+#endif
+
+#ifndef STBI_NO_HDR
+static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);
+#endif
+
+static int stbi__vertically_flip_on_load_global = 0;
+
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
+{
+ stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
+}
+
+#ifndef STBI_THREAD_LOCAL
+#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global
+#else
+static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
+
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
+{
+ stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
+ stbi__vertically_flip_on_load_set = 1;
+}
+
+#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \
+ ? stbi__vertically_flip_on_load_local \
+ : stbi__vertically_flip_on_load_global)
+#endif // STBI_THREAD_LOCAL
+
+static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+ memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
+ ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
+ ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
+ ri->num_channels = 0;
+
+ // test the formats with a very explicit header first (at least a FOURCC
+ // or distinctive magic number first)
+ #ifndef STBI_NO_PNG
+ if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri);
+ #endif
+ #ifndef STBI_NO_BMP
+ if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri);
+ #endif
+ #ifndef STBI_NO_GIF
+ if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri);
+ #endif
+ #ifndef STBI_NO_PSD
+ if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
+ #else
+ STBI_NOTUSED(bpc);
+ #endif
+ #ifndef STBI_NO_PIC
+ if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri);
+ #endif
+
+ // then the formats that can end up attempting to load with just 1 or 2
+ // bytes matching expectations; these are prone to false positives, so
+ // try them later
+ #ifndef STBI_NO_JPEG
+ if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
+ #endif
+ #ifndef STBI_NO_PNM
+ if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri);
+ #endif
+
+ #ifndef STBI_NO_HDR
+ if (stbi__hdr_test(s)) {
+ float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
+ return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+ }
+ #endif
+
+ #ifndef STBI_NO_TGA
+ // test tga last because it's a crappy test!
+ if (stbi__tga_test(s))
+ return stbi__tga_load(s,x,y,comp,req_comp, ri);
+ #endif
+
+ return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
+{
+ int i;
+ int img_len = w * h * channels;
+ stbi_uc *reduced;
+
+ reduced = (stbi_uc *) stbi__malloc(img_len);
+ if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
+
+ for (i = 0; i < img_len; ++i)
+ reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
+
+ STBI_FREE(orig);
+ return reduced;
+}
+
+static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
+{
+ int i;
+ int img_len = w * h * channels;
+ stbi__uint16 *enlarged;
+
+ enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
+ if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+
+ for (i = 0; i < img_len; ++i)
+ enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
+
+ STBI_FREE(orig);
+ return enlarged;
+}
+
+static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
+{
+ int row;
+ size_t bytes_per_row = (size_t)w * bytes_per_pixel;
+ stbi_uc temp[2048];
+ stbi_uc *bytes = (stbi_uc *)image;
+
+ for (row = 0; row < (h>>1); row++) {
+ stbi_uc *row0 = bytes + row*bytes_per_row;
+ stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
+ // swap row0 with row1
+ size_t bytes_left = bytes_per_row;
+ while (bytes_left) {
+ size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
+ memcpy(temp, row0, bytes_copy);
+ memcpy(row0, row1, bytes_copy);
+ memcpy(row1, temp, bytes_copy);
+ row0 += bytes_copy;
+ row1 += bytes_copy;
+ bytes_left -= bytes_copy;
+ }
+ }
+}
+
+#ifndef STBI_NO_GIF
+static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
+{
+ int slice;
+ int slice_size = w * h * bytes_per_pixel;
+
+ stbi_uc *bytes = (stbi_uc *)image;
+ for (slice = 0; slice < z; ++slice) {
+ stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
+ bytes += slice_size;
+ }
+}
+#endif
+
+static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+ stbi__result_info ri;
+ void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
+
+ if (result == NULL)
+ return NULL;
+
+ // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
+ STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
+
+ if (ri.bits_per_channel != 8) {
+ result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+ ri.bits_per_channel = 8;
+ }
+
+ // @TODO: move stbi__convert_format to here
+
+ if (stbi__vertically_flip_on_load) {
+ int channels = req_comp ? req_comp : *comp;
+ stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
+ }
+
+ return (unsigned char *) result;
+}
+
+static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+ stbi__result_info ri;
+ void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
+
+ if (result == NULL)
+ return NULL;
+
+ // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
+ STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
+
+ if (ri.bits_per_channel != 16) {
+ result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+ ri.bits_per_channel = 16;
+ }
+
+ // @TODO: move stbi__convert_format16 to here
+ // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
+
+ if (stbi__vertically_flip_on_load) {
+ int channels = req_comp ? req_comp : *comp;
+ stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
+ }
+
+ return (stbi__uint16 *) result;
+}
+
+#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
+static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
+{
+ if (stbi__vertically_flip_on_load && result != NULL) {
+ int channels = req_comp ? req_comp : *comp;
+ stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
+ }
+}
+#endif
+
+#ifndef STBI_NO_STDIO
+
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
+STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
+#endif
+
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
+{
+ return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbi__fopen(char const *filename, char const *mode)
+{
+ FILE *f;
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+ wchar_t wMode[64];
+ wchar_t wFilename[1024];
+ if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
+ return 0;
+
+ if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
+ return 0;
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+ if (0 != _wfopen_s(&f, wFilename, wMode))
+ f = 0;
+#else
+ f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+ if (0 != fopen_s(&f, filename, mode))
+ f=0;
+#else
+ f = fopen(filename, mode);
+#endif
+ return f;
+}
+
+
+STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+ FILE *f = stbi__fopen(filename, "rb");
+ unsigned char *result;
+ if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
+ result = stbi_load_from_file(f,x,y,comp,req_comp);
+ fclose(f);
+ return result;
+}
+
+STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+ unsigned char *result;
+ stbi__context s;
+ stbi__start_file(&s,f);
+ result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+ if (result) {
+ // need to 'unget' all the characters in the IO buffer
+ fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+ }
+ return result;
+}
+
+STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+ stbi__uint16 *result;
+ stbi__context s;
+ stbi__start_file(&s,f);
+ result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
+ if (result) {
+ // need to 'unget' all the characters in the IO buffer
+ fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+ }
+ return result;
+}
+
+STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+ FILE *f = stbi__fopen(filename, "rb");
+ stbi__uint16 *result;
+ if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
+ result = stbi_load_from_file_16(f,x,y,comp,req_comp);
+ fclose(f);
+ return result;
+}
+
+
+#endif //!STBI_NO_STDIO
+
+STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+ stbi__context s;
+ stbi__start_mem(&s,buffer,len);
+ return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+ stbi__context s;
+ stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+ return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+ stbi__context s;
+ stbi__start_mem(&s,buffer,len);
+ return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+ stbi__context s;
+ stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+ return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+ unsigned char *result;
+ stbi__context s;
+ stbi__start_mem(&s,buffer,len);
+
+ result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
+ if (stbi__vertically_flip_on_load) {
+ stbi__vertical_flip_slices( result, *x, *y, *z, *comp );
+ }
+
+ return result;
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+ unsigned char *data;
+ #ifndef STBI_NO_HDR
+ if (stbi__hdr_test(s)) {
+ stbi__result_info ri;
+ float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
+ if (hdr_data)
+ stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
+ return hdr_data;
+ }
+ #endif
+ data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
+ if (data)
+ return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+ return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
+}
+
+STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+ stbi__context s;
+ stbi__start_mem(&s,buffer,len);
+ return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+ stbi__context s;
+ stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+ return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+ float *result;
+ FILE *f = stbi__fopen(filename, "rb");
+ if (!f) return stbi__errpf("can't fopen", "Unable to open file");
+ result = stbi_loadf_from_file(f,x,y,comp,req_comp);
+ fclose(f);
+ return result;
+}
+
+STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+ stbi__context s;
+ stbi__start_file(&s,f);
+ return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+#endif // !STBI_NO_STDIO
+
+#endif // !STBI_NO_LINEAR
+
+// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
+// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
+// reports false!
+
+STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
+{
+ #ifndef STBI_NO_HDR
+ stbi__context s;
+ stbi__start_mem(&s,buffer,len);
+ return stbi__hdr_test(&s);
+ #else
+ STBI_NOTUSED(buffer);
+ STBI_NOTUSED(len);
+ return 0;
+ #endif
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_is_hdr (char const *filename)
+{
+ FILE *f = stbi__fopen(filename, "rb");
+ int result=0;
+ if (f) {
+ result = stbi_is_hdr_from_file(f);
+ fclose(f);
+ }
+ return result;
+}
+
+STBIDEF int stbi_is_hdr_from_file(FILE *f)
+{
+ #ifndef STBI_NO_HDR
+ long pos = ftell(f);
+ int res;
+ stbi__context s;
+ stbi__start_file(&s,f);
+ res = stbi__hdr_test(&s);
+ fseek(f, pos, SEEK_SET);
+ return res;
+ #else
+ STBI_NOTUSED(f);
+ return 0;
+ #endif
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+{
+ #ifndef STBI_NO_HDR
+ stbi__context s;
+ stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+ return stbi__hdr_test(&s);
+ #else
+ STBI_NOTUSED(clbk);
+ STBI_NOTUSED(user);
+ return 0;
+ #endif
+}
+
+#ifndef STBI_NO_LINEAR
+static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
+
+STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
+STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
+#endif
+
+static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
+
+STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
+STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Common code used by all image loaders
+//
+
+enum
+{
+ STBI__SCAN_load=0,
+ STBI__SCAN_type,
+ STBI__SCAN_header
+};
+
+static void stbi__refill_buffer(stbi__context *s)
+{
+ int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
+ s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
+ if (n == 0) {
+ // at end of file, treat same as if from memory, but need to handle case
+ // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
+ s->read_from_callbacks = 0;
+ s->img_buffer = s->buffer_start;
+ s->img_buffer_end = s->buffer_start+1;
+ *s->img_buffer = 0;
+ } else {
+ s->img_buffer = s->buffer_start;
+ s->img_buffer_end = s->buffer_start + n;
+ }
+}
+
+stbi_inline static stbi_uc stbi__get8(stbi__context *s)
+{
+ if (s->img_buffer < s->img_buffer_end)
+ return *s->img_buffer++;
+ if (s->read_from_callbacks) {
+ stbi__refill_buffer(s);
+ return *s->img_buffer++;
+ }
+ return 0;
+}
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+stbi_inline static int stbi__at_eof(stbi__context *s)
+{
+ if (s->io.read) {
+ if (!(s->io.eof)(s->io_user_data)) return 0;
+ // if feof() is true, check if buffer = end
+ // special case: we've only got the special 0 character at the end
+ if (s->read_from_callbacks == 0) return 1;
+ }
+
+ return s->img_buffer >= s->img_buffer_end;
+}
+#endif
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
+// nothing
+#else
+static void stbi__skip(stbi__context *s, int n)
+{
+ if (n == 0) return; // already there!
+ if (n < 0) {
+ s->img_buffer = s->img_buffer_end;
+ return;
+ }
+ if (s->io.read) {
+ int blen = (int) (s->img_buffer_end - s->img_buffer);
+ if (blen < n) {
+ s->img_buffer = s->img_buffer_end;
+ (s->io.skip)(s->io_user_data, n - blen);
+ return;
+ }
+ }
+ s->img_buffer += n;
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
+// nothing
+#else
+static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
+{
+ if (s->io.read) {
+ int blen = (int) (s->img_buffer_end - s->img_buffer);
+ if (blen < n) {
+ int res, count;
+
+ memcpy(buffer, s->img_buffer, blen);
+
+ count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
+ res = (count == (n-blen));
+ s->img_buffer = s->img_buffer_end;
+ return res;
+ }
+ }
+
+ if (s->img_buffer+n <= s->img_buffer_end) {
+ memcpy(buffer, s->img_buffer, n);
+ s->img_buffer += n;
+ return 1;
+ } else
+ return 0;
+}
+#endif
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
+static int stbi__get16be(stbi__context *s)
+{
+ int z = stbi__get8(s);
+ return (z << 8) + stbi__get8(s);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
+static stbi__uint32 stbi__get32be(stbi__context *s)
+{
+ stbi__uint32 z = stbi__get16be(s);
+ return (z << 16) + stbi__get16be(s);
+}
+#endif
+
+#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
+// nothing
+#else
+static int stbi__get16le(stbi__context *s)
+{
+ int z = stbi__get8(s);
+ return z + (stbi__get8(s) << 8);
+}
+#endif
+
+#ifndef STBI_NO_BMP
+static stbi__uint32 stbi__get32le(stbi__context *s)
+{
+ stbi__uint32 z = stbi__get16le(s);
+ z += (stbi__uint32)stbi__get16le(s) << 16;
+ return z;
+}
+#endif
+
+#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+//////////////////////////////////////////////////////////////////////////////
+//
+// generic converter from built-in img_n to req_comp
+// individual types do this automatically as much as possible (e.g. jpeg
+// does all cases internally since it needs to colorspace convert anyway,
+// and it never has alpha, so very few cases ). png can automatically
+// interleave an alpha=255 channel, but falls back to this for other cases
+//
+// assume data buffer is malloced, so malloc a new one and free that one
+// only failure mode is malloc failing
+
+static stbi_uc stbi__compute_y(int r, int g, int b)
+{
+ return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+ int i,j;
+ unsigned char *good;
+
+ if (req_comp == img_n) return data;
+ STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+ good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
+ if (good == NULL) {
+ STBI_FREE(data);
+ return stbi__errpuc("outofmem", "Out of memory");
+ }
+
+ for (j=0; j < (int) y; ++j) {
+ unsigned char *src = data + j * x * img_n ;
+ unsigned char *dest = good + j * x * req_comp;
+
+ #define STBI__COMBO(a,b) ((a)*8+(b))
+ #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+ // convert source image with img_n components to one with req_comp components;
+ // avoid switch per pixel, so use switch per scanline and massive macros
+ switch (STBI__COMBO(img_n, req_comp)) {
+ STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break;
+ STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
+ STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break;
+ STBI__CASE(2,1) { dest[0]=src[0]; } break;
+ STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
+ STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
+ STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break;
+ STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
+ STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break;
+ STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
+ STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+ STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
+ default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
+ }
+ #undef STBI__CASE
+ }
+
+ STBI_FREE(data);
+ return good;
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
+static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
+{
+ return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
+static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+ int i,j;
+ stbi__uint16 *good;
+
+ if (req_comp == img_n) return data;
+ STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+ good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
+ if (good == NULL) {
+ STBI_FREE(data);
+ return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+ }
+
+ for (j=0; j < (int) y; ++j) {
+ stbi__uint16 *src = data + j * x * img_n ;
+ stbi__uint16 *dest = good + j * x * req_comp;
+
+ #define STBI__COMBO(a,b) ((a)*8+(b))
+ #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+ // convert source image with img_n components to one with req_comp components;
+ // avoid switch per pixel, so use switch per scanline and massive macros
+ switch (STBI__COMBO(img_n, req_comp)) {
+ STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break;
+ STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
+ STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break;
+ STBI__CASE(2,1) { dest[0]=src[0]; } break;
+ STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
+ STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
+ STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break;
+ STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;
+ STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
+ STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;
+ STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+ STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
+ default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");
+ }
+ #undef STBI__CASE
+ }
+
+ STBI_FREE(data);
+ return good;
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
+{
+ int i,k,n;
+ float *output;
+ if (!data) return NULL;
+ output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
+ if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
+ // compute number of non-alpha components
+ if (comp & 1) n = comp; else n = comp-1;
+ for (i=0; i < x*y; ++i) {
+ for (k=0; k < n; ++k) {
+ output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
+ }
+ }
+ if (n < comp) {
+ for (i=0; i < x*y; ++i) {
+ output[i*comp + n] = data[i*comp + n]/255.0f;
+ }
+ }
+ STBI_FREE(data);
+ return output;
+}
+#endif
+
+#ifndef STBI_NO_HDR
+#define stbi__float2int(x) ((int) (x))
+static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)
+{
+ int i,k,n;
+ stbi_uc *output;
+ if (!data) return NULL;
+ output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
+ if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
+ // compute number of non-alpha components
+ if (comp & 1) n = comp; else n = comp-1;
+ for (i=0; i < x*y; ++i) {
+ for (k=0; k < n; ++k) {
+ float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
+ if (z < 0) z = 0;
+ if (z > 255) z = 255;
+ output[i*comp + k] = (stbi_uc) stbi__float2int(z);
+ }
+ if (k < comp) {
+ float z = data[i*comp+k] * 255 + 0.5f;
+ if (z < 0) z = 0;
+ if (z > 255) z = 255;
+ output[i*comp + k] = (stbi_uc) stbi__float2int(z);
+ }
+ }
+ STBI_FREE(data);
+ return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// "baseline" JPEG/JFIF decoder
+//
+// simple implementation
+// - doesn't support delayed output of y-dimension
+// - simple interface (only one output format: 8-bit interleaved RGB)
+// - doesn't try to recover corrupt jpegs
+// - doesn't allow partial loading, loading multiple at once
+// - still fast on x86 (copying globals into locals doesn't help x86)
+// - allocates lots of intermediate memory (full size of all components)
+// - non-interleaved case requires this anyway
+// - allows good upsampling (see next)
+// high-quality
+// - upsampled channels are bilinearly interpolated, even across blocks
+// - quality integer IDCT derived from IJG's 'slow'
+// performance
+// - fast huffman; reasonable integer IDCT
+// - some SIMD kernels for common paths on targets with SSE2/NEON
+// - uses a lot of intermediate memory, could cache poorly
+
+#ifndef STBI_NO_JPEG
+
+// huffman decoding acceleration
+#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
+
+typedef struct
+{
+ stbi_uc fast[1 << FAST_BITS];
+ // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+ stbi__uint16 code[256];
+ stbi_uc values[256];
+ stbi_uc size[257];
+ unsigned int maxcode[18];
+ int delta[17]; // old 'firstsymbol' - old 'firstcode'
+} stbi__huffman;
+
+typedef struct
+{
+ stbi__context *s;
+ stbi__huffman huff_dc[4];
+ stbi__huffman huff_ac[4];
+ stbi__uint16 dequant[4][64];
+ stbi__int16 fast_ac[4][1 << FAST_BITS];
+
+// sizes for components, interleaved MCUs
+ int img_h_max, img_v_max;
+ int img_mcu_x, img_mcu_y;
+ int img_mcu_w, img_mcu_h;
+
+// definition of jpeg image component
+ struct
+ {
+ int id;
+ int h,v;
+ int tq;
+ int hd,ha;
+ int dc_pred;
+
+ int x,y,w2,h2;
+ stbi_uc *data;
+ void *raw_data, *raw_coeff;
+ stbi_uc *linebuf;
+ short *coeff; // progressive only
+ int coeff_w, coeff_h; // number of 8x8 coefficient blocks
+ } img_comp[4];
+
+ stbi__uint32 code_buffer; // jpeg entropy-coded buffer
+ int code_bits; // number of valid bits
+ unsigned char marker; // marker seen while filling entropy buffer
+ int nomore; // flag if we saw a marker so must stop
+
+ int progressive;
+ int spec_start;
+ int spec_end;
+ int succ_high;
+ int succ_low;
+ int eob_run;
+ int jfif;
+ int app14_color_transform; // Adobe APP14 tag
+ int rgb;
+
+ int scan_n, order[4];
+ int restart_interval, todo;
+
+// kernels
+ void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
+ void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
+ stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
+} stbi__jpeg;
+
+static int stbi__build_huffman(stbi__huffman *h, int *count)
+{
+ int i,j,k=0;
+ unsigned int code;
+ // build size list for each symbol (from JPEG spec)
+ for (i=0; i < 16; ++i) {
+ for (j=0; j < count[i]; ++j) {
+ h->size[k++] = (stbi_uc) (i+1);
+ if(k >= 257) return stbi__err("bad size list","Corrupt JPEG");
+ }
+ }
+ h->size[k] = 0;
+
+ // compute actual symbols (from jpeg spec)
+ code = 0;
+ k = 0;
+ for(j=1; j <= 16; ++j) {
+ // compute delta to add to code to compute symbol id
+ h->delta[j] = k - code;
+ if (h->size[k] == j) {
+ while (h->size[k] == j)
+ h->code[k++] = (stbi__uint16) (code++);
+ if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");
+ }
+ // compute largest code + 1 for this size, preshifted as needed later
+ h->maxcode[j] = code << (16-j);
+ code <<= 1;
+ }
+ h->maxcode[j] = 0xffffffff;
+
+ // build non-spec acceleration table; 255 is flag for not-accelerated
+ memset(h->fast, 255, 1 << FAST_BITS);
+ for (i=0; i < k; ++i) {
+ int s = h->size[i];
+ if (s <= FAST_BITS) {
+ int c = h->code[i] << (FAST_BITS-s);
+ int m = 1 << (FAST_BITS-s);
+ for (j=0; j < m; ++j) {
+ h->fast[c+j] = (stbi_uc) i;
+ }
+ }
+ }
+ return 1;
+}
+
+// build a table that decodes both magnitude and value of small ACs in
+// one go.
+static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
+{
+ int i;
+ for (i=0; i < (1 << FAST_BITS); ++i) {
+ stbi_uc fast = h->fast[i];
+ fast_ac[i] = 0;
+ if (fast < 255) {
+ int rs = h->values[fast];
+ int run = (rs >> 4) & 15;
+ int magbits = rs & 15;
+ int len = h->size[fast];
+
+ if (magbits && len + magbits <= FAST_BITS) {
+ // magnitude code followed by receive_extend code
+ int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
+ int m = 1 << (magbits - 1);
+ if (k < m) k += (~0U << magbits) + 1;
+ // if the result is small enough, we can fit it in fast_ac table
+ if (k >= -128 && k <= 127)
+ fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
+ }
+ }
+ }
+}
+
+static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
+{
+ do {
+ unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
+ if (b == 0xff) {
+ int c = stbi__get8(j->s);
+ while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
+ if (c != 0) {
+ j->marker = (unsigned char) c;
+ j->nomore = 1;
+ return;
+ }
+ }
+ j->code_buffer |= b << (24 - j->code_bits);
+ j->code_bits += 8;
+ } while (j->code_bits <= 24);
+}
+
+// (1 << n) - 1
+static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
+
+// decode a jpeg huffman value from the bitstream
+stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
+{
+ unsigned int temp;
+ int c,k;
+
+ if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+ // look at the top FAST_BITS and determine what symbol ID it is,
+ // if the code is <= FAST_BITS
+ c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+ k = h->fast[c];
+ if (k < 255) {
+ int s = h->size[k];
+ if (s > j->code_bits)
+ return -1;
+ j->code_buffer <<= s;
+ j->code_bits -= s;
+ return h->values[k];
+ }
+
+ // naive test is to shift the code_buffer down so k bits are
+ // valid, then test against maxcode. To speed this up, we've
+ // preshifted maxcode left so that it has (16-k) 0s at the
+ // end; in other words, regardless of the number of bits, it
+ // wants to be compared against something shifted to have 16;
+ // that way we don't need to shift inside the loop.
+ temp = j->code_buffer >> 16;
+ for (k=FAST_BITS+1 ; ; ++k)
+ if (temp < h->maxcode[k])
+ break;
+ if (k == 17) {
+ // error! code not found
+ j->code_bits -= 16;
+ return -1;
+ }
+
+ if (k > j->code_bits)
+ return -1;
+
+ // convert the huffman code to the symbol id
+ c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
+ if(c < 0 || c >= 256) // symbol id out of bounds!
+ return -1;
+ STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
+
+ // convert the id to a symbol
+ j->code_bits -= k;
+ j->code_buffer <<= k;
+ return h->values[c];
+}
+
+// bias[n] = (-1<<n) + 1
+static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
+{
+ unsigned int k;
+ int sgn;
+ if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+ if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
+
+ sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)
+ k = stbi_lrot(j->code_buffer, n);
+ j->code_buffer = k & ~stbi__bmask[n];
+ k &= stbi__bmask[n];
+ j->code_bits -= n;
+ return k + (stbi__jbias[n] & (sgn - 1));
+}
+
+// get some unsigned bits
+stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
+{
+ unsigned int k;
+ if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+ if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
+ k = stbi_lrot(j->code_buffer, n);
+ j->code_buffer = k & ~stbi__bmask[n];
+ k &= stbi__bmask[n];
+ j->code_bits -= n;
+ return k;
+}
+
+stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
+{
+ unsigned int k;
+ if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
+ if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing
+ k = j->code_buffer;
+ j->code_buffer <<= 1;
+ --j->code_bits;
+ return k & 0x80000000;
+}
+
+// given a value that's at position X in the zigzag stream,
+// where does it appear in the 8x8 matrix coded as row-major?
+static const stbi_uc stbi__jpeg_dezigzag[64+15] =
+{
+ 0, 1, 8, 16, 9, 2, 3, 10,
+ 17, 24, 32, 25, 18, 11, 4, 5,
+ 12, 19, 26, 33, 40, 48, 41, 34,
+ 27, 20, 13, 6, 7, 14, 21, 28,
+ 35, 42, 49, 56, 57, 50, 43, 36,
+ 29, 22, 15, 23, 30, 37, 44, 51,
+ 58, 59, 52, 45, 38, 31, 39, 46,
+ 53, 60, 61, 54, 47, 55, 62, 63,
+ // let corrupt input sample past end
+ 63, 63, 63, 63, 63, 63, 63, 63,
+ 63, 63, 63, 63, 63, 63, 63
+};
+
+// decode one 64-entry block--
+static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
+{
+ int diff,dc,k;
+ int t;
+
+ if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+ t = stbi__jpeg_huff_decode(j, hdc);
+ if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG");
+
+ // 0 all the ac values now so we can do it 32-bits at a time
+ memset(data,0,64*sizeof(data[0]));
+
+ diff = t ? stbi__extend_receive(j, t) : 0;
+ if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG");
+ dc = j->img_comp[b].dc_pred + diff;
+ j->img_comp[b].dc_pred = dc;
+ if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+ data[0] = (short) (dc * dequant[0]);
+
+ // decode AC components, see JPEG spec
+ k = 1;
+ do {
+ unsigned int zig;
+ int c,r,s;
+ if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+ c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+ r = fac[c];
+ if (r) { // fast-AC path
+ k += (r >> 4) & 15; // run
+ s = r & 15; // combined length
+ if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
+ j->code_buffer <<= s;
+ j->code_bits -= s;
+ // decode into unzigzag'd location
+ zig = stbi__jpeg_dezigzag[k++];
+ data[zig] = (short) ((r >> 8) * dequant[zig]);
+ } else {
+ int rs = stbi__jpeg_huff_decode(j, hac);
+ if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+ s = rs & 15;
+ r = rs >> 4;
+ if (s == 0) {
+ if (rs != 0xf0) break; // end block
+ k += 16;
+ } else {
+ k += r;
+ // decode into unzigzag'd location
+ zig = stbi__jpeg_dezigzag[k++];
+ data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
+ }
+ }
+ } while (k < 64);
+ return 1;
+}
+
+static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
+{
+ int diff,dc;
+ int t;
+ if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+ if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+ if (j->succ_high == 0) {
+ // first scan for DC coefficient, must be first
+ memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
+ t = stbi__jpeg_huff_decode(j, hdc);
+ if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+ diff = t ? stbi__extend_receive(j, t) : 0;
+
+ if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG");
+ dc = j->img_comp[b].dc_pred + diff;
+ j->img_comp[b].dc_pred = dc;
+ if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+ data[0] = (short) (dc * (1 << j->succ_low));
+ } else {
+ // refinement scan for DC coefficient
+ if (stbi__jpeg_get_bit(j))
+ data[0] += (short) (1 << j->succ_low);
+ }
+ return 1;
+}
+
+// @OPTIMIZE: store non-zigzagged during the decode passes,
+// and only de-zigzag when dequantizing
+static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
+{
+ int k;
+ if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+ if (j->succ_high == 0) {
+ int shift = j->succ_low;
+
+ if (j->eob_run) {
+ --j->eob_run;
+ return 1;
+ }
+
+ k = j->spec_start;
+ do {
+ unsigned int zig;
+ int c,r,s;
+ if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+ c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+ r = fac[c];
+ if (r) { // fast-AC path
+ k += (r >> 4) & 15; // run
+ s = r & 15; // combined length
+ if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
+ j->code_buffer <<= s;
+ j->code_bits -= s;
+ zig = stbi__jpeg_dezigzag[k++];
+ data[zig] = (short) ((r >> 8) * (1 << shift));
+ } else {
+ int rs = stbi__jpeg_huff_decode(j, hac);
+ if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+ s = rs & 15;
+ r = rs >> 4;
+ if (s == 0) {
+ if (r < 15) {
+ j->eob_run = (1 << r);
+ if (r)
+ j->eob_run += stbi__jpeg_get_bits(j, r);
+ --j->eob_run;
+ break;
+ }
+ k += 16;
+ } else {
+ k += r;
+ zig = stbi__jpeg_dezigzag[k++];
+ data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift));
+ }
+ }
+ } while (k <= j->spec_end);
+ } else {
+ // refinement scan for these AC coefficients
+
+ short bit = (short) (1 << j->succ_low);
+
+ if (j->eob_run) {
+ --j->eob_run;
+ for (k = j->spec_start; k <= j->spec_end; ++k) {
+ short *p = &data[stbi__jpeg_dezigzag[k]];
+ if (*p != 0)
+ if (stbi__jpeg_get_bit(j))
+ if ((*p & bit)==0) {
+ if (*p > 0)
+ *p += bit;
+ else
+ *p -= bit;
+ }
+ }
+ } else {
+ k = j->spec_start;
+ do {
+ int r,s;
+ int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
+ if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+ s = rs & 15;
+ r = rs >> 4;
+ if (s == 0) {
+ if (r < 15) {
+ j->eob_run = (1 << r) - 1;
+ if (r)
+ j->eob_run += stbi__jpeg_get_bits(j, r);
+ r = 64; // force end of block
+ } else {
+ // r=15 s=0 should write 16 0s, so we just do
+ // a run of 15 0s and then write s (which is 0),
+ // so we don't have to do anything special here
+ }
+ } else {
+ if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
+ // sign bit
+ if (stbi__jpeg_get_bit(j))
+ s = bit;
+ else
+ s = -bit;
+ }
+
+ // advance by r
+ while (k <= j->spec_end) {
+ short *p = &data[stbi__jpeg_dezigzag[k++]];
+ if (*p != 0) {
+ if (stbi__jpeg_get_bit(j))
+ if ((*p & bit)==0) {
+ if (*p > 0)
+ *p += bit;
+ else
+ *p -= bit;
+ }
+ } else {
+ if (r == 0) {
+ *p = (short) s;
+ break;
+ }
+ --r;
+ }
+ }
+ } while (k <= j->spec_end);
+ }
+ }
+ return 1;
+}
+
+// take a -128..127 value and stbi__clamp it and convert to 0..255
+stbi_inline static stbi_uc stbi__clamp(int x)
+{
+ // trick to use a single test to catch both cases
+ if ((unsigned int) x > 255) {
+ if (x < 0) return 0;
+ if (x > 255) return 255;
+ }
+ return (stbi_uc) x;
+}
+
+#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))
+#define stbi__fsh(x) ((x) * 4096)
+
+// derived from jidctint -- DCT_ISLOW
+#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
+ int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
+ p2 = s2; \
+ p3 = s6; \
+ p1 = (p2+p3) * stbi__f2f(0.5411961f); \
+ t2 = p1 + p3*stbi__f2f(-1.847759065f); \
+ t3 = p1 + p2*stbi__f2f( 0.765366865f); \
+ p2 = s0; \
+ p3 = s4; \
+ t0 = stbi__fsh(p2+p3); \
+ t1 = stbi__fsh(p2-p3); \
+ x0 = t0+t3; \
+ x3 = t0-t3; \
+ x1 = t1+t2; \
+ x2 = t1-t2; \
+ t0 = s7; \
+ t1 = s5; \
+ t2 = s3; \
+ t3 = s1; \
+ p3 = t0+t2; \
+ p4 = t1+t3; \
+ p1 = t0+t3; \
+ p2 = t1+t2; \
+ p5 = (p3+p4)*stbi__f2f( 1.175875602f); \
+ t0 = t0*stbi__f2f( 0.298631336f); \
+ t1 = t1*stbi__f2f( 2.053119869f); \
+ t2 = t2*stbi__f2f( 3.072711026f); \
+ t3 = t3*stbi__f2f( 1.501321110f); \
+ p1 = p5 + p1*stbi__f2f(-0.899976223f); \
+ p2 = p5 + p2*stbi__f2f(-2.562915447f); \
+ p3 = p3*stbi__f2f(-1.961570560f); \
+ p4 = p4*stbi__f2f(-0.390180644f); \
+ t3 += p1+p4; \
+ t2 += p2+p3; \
+ t1 += p2+p4; \
+ t0 += p1+p3;
+
+static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
+{
+ int i,val[64],*v=val;
+ stbi_uc *o;
+ short *d = data;
+
+ // columns
+ for (i=0; i < 8; ++i,++d, ++v) {
+ // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
+ if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
+ && d[40]==0 && d[48]==0 && d[56]==0) {
+ // no shortcut 0 seconds
+ // (1|2|3|4|5|6|7)==0 0 seconds
+ // all separate -0.047 seconds
+ // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds
+ int dcterm = d[0]*4;
+ v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+ } else {
+ STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
+ // constants scaled things up by 1<<12; let's bring them back
+ // down, but keep 2 extra bits of precision
+ x0 += 512; x1 += 512; x2 += 512; x3 += 512;
+ v[ 0] = (x0+t3) >> 10;
+ v[56] = (x0-t3) >> 10;
+ v[ 8] = (x1+t2) >> 10;
+ v[48] = (x1-t2) >> 10;
+ v[16] = (x2+t1) >> 10;
+ v[40] = (x2-t1) >> 10;
+ v[24] = (x3+t0) >> 10;
+ v[32] = (x3-t0) >> 10;
+ }
+ }
+
+ for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
+ // no fast case since the first 1D IDCT spread components out
+ STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
+ // constants scaled things up by 1<<12, plus we had 1<<2 from first
+ // loop, plus horizontal and vertical each scale by sqrt(8) so together
+ // we've got an extra 1<<3, so 1<<17 total we need to remove.
+ // so we want to round that, which means adding 0.5 * 1<<17,
+ // aka 65536. Also, we'll end up with -128 to 127 that we want
+ // to encode as 0..255 by adding 128, so we'll add that before the shift
+ x0 += 65536 + (128<<17);
+ x1 += 65536 + (128<<17);
+ x2 += 65536 + (128<<17);
+ x3 += 65536 + (128<<17);
+ // tried computing the shifts into temps, or'ing the temps to see
+ // if any were out of range, but that was slower
+ o[0] = stbi__clamp((x0+t3) >> 17);
+ o[7] = stbi__clamp((x0-t3) >> 17);
+ o[1] = stbi__clamp((x1+t2) >> 17);
+ o[6] = stbi__clamp((x1-t2) >> 17);
+ o[2] = stbi__clamp((x2+t1) >> 17);
+ o[5] = stbi__clamp((x2-t1) >> 17);
+ o[3] = stbi__clamp((x3+t0) >> 17);
+ o[4] = stbi__clamp((x3-t0) >> 17);
+ }
+}
+
+#ifdef STBI_SSE2
+// sse2 integer IDCT. not the fastest possible implementation but it
+// produces bit-identical results to the generic C version so it's
+// fully "transparent".
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+ // This is constructed to match our regular (generic) integer IDCT exactly.
+ __m128i row0, row1, row2, row3, row4, row5, row6, row7;
+ __m128i tmp;
+
+ // dot product constant: even elems=x, odd elems=y
+ #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
+
+ // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit)
+ // out(1) = c1[even]*x + c1[odd]*y
+ #define dct_rot(out0,out1, x,y,c0,c1) \
+ __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
+ __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
+ __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
+ __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
+ __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
+ __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
+
+ // out = in << 12 (in 16-bit, out 32-bit)
+ #define dct_widen(out, in) \
+ __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
+ __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
+
+ // wide add
+ #define dct_wadd(out, a, b) \
+ __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
+ __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
+
+ // wide sub
+ #define dct_wsub(out, a, b) \
+ __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
+ __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
+
+ // butterfly a/b, add bias, then shift by "s" and pack
+ #define dct_bfly32o(out0, out1, a,b,bias,s) \
+ { \
+ __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
+ __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
+ dct_wadd(sum, abiased, b); \
+ dct_wsub(dif, abiased, b); \
+ out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
+ out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
+ }
+
+ // 8-bit interleave step (for transposes)
+ #define dct_interleave8(a, b) \
+ tmp = a; \
+ a = _mm_unpacklo_epi8(a, b); \
+ b = _mm_unpackhi_epi8(tmp, b)
+
+ // 16-bit interleave step (for transposes)
+ #define dct_interleave16(a, b) \
+ tmp = a; \
+ a = _mm_unpacklo_epi16(a, b); \
+ b = _mm_unpackhi_epi16(tmp, b)
+
+ #define dct_pass(bias,shift) \
+ { \
+ /* even part */ \
+ dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
+ __m128i sum04 = _mm_add_epi16(row0, row4); \
+ __m128i dif04 = _mm_sub_epi16(row0, row4); \
+ dct_widen(t0e, sum04); \
+ dct_widen(t1e, dif04); \
+ dct_wadd(x0, t0e, t3e); \
+ dct_wsub(x3, t0e, t3e); \
+ dct_wadd(x1, t1e, t2e); \
+ dct_wsub(x2, t1e, t2e); \
+ /* odd part */ \
+ dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
+ dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
+ __m128i sum17 = _mm_add_epi16(row1, row7); \
+ __m128i sum35 = _mm_add_epi16(row3, row5); \
+ dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
+ dct_wadd(x4, y0o, y4o); \
+ dct_wadd(x5, y1o, y5o); \
+ dct_wadd(x6, y2o, y5o); \
+ dct_wadd(x7, y3o, y4o); \
+ dct_bfly32o(row0,row7, x0,x7,bias,shift); \
+ dct_bfly32o(row1,row6, x1,x6,bias,shift); \
+ dct_bfly32o(row2,row5, x2,x5,bias,shift); \
+ dct_bfly32o(row3,row4, x3,x4,bias,shift); \
+ }
+
+ __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
+ __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
+ __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
+ __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
+ __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
+ __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
+ __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
+ __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
+
+ // rounding biases in column/row passes, see stbi__idct_block for explanation.
+ __m128i bias_0 = _mm_set1_epi32(512);
+ __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
+
+ // load
+ row0 = _mm_load_si128((const __m128i *) (data + 0*8));
+ row1 = _mm_load_si128((const __m128i *) (data + 1*8));
+ row2 = _mm_load_si128((const __m128i *) (data + 2*8));
+ row3 = _mm_load_si128((const __m128i *) (data + 3*8));
+ row4 = _mm_load_si128((const __m128i *) (data + 4*8));
+ row5 = _mm_load_si128((const __m128i *) (data + 5*8));
+ row6 = _mm_load_si128((const __m128i *) (data + 6*8));
+ row7 = _mm_load_si128((const __m128i *) (data + 7*8));
+
+ // column pass
+ dct_pass(bias_0, 10);
+
+ {
+ // 16bit 8x8 transpose pass 1
+ dct_interleave16(row0, row4);
+ dct_interleave16(row1, row5);
+ dct_interleave16(row2, row6);
+ dct_interleave16(row3, row7);
+
+ // transpose pass 2
+ dct_interleave16(row0, row2);
+ dct_interleave16(row1, row3);
+ dct_interleave16(row4, row6);
+ dct_interleave16(row5, row7);
+
+ // transpose pass 3
+ dct_interleave16(row0, row1);
+ dct_interleave16(row2, row3);
+ dct_interleave16(row4, row5);
+ dct_interleave16(row6, row7);
+ }
+
+ // row pass
+ dct_pass(bias_1, 17);
+
+ {
+ // pack
+ __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
+ __m128i p1 = _mm_packus_epi16(row2, row3);
+ __m128i p2 = _mm_packus_epi16(row4, row5);
+ __m128i p3 = _mm_packus_epi16(row6, row7);
+
+ // 8bit 8x8 transpose pass 1
+ dct_interleave8(p0, p2); // a0e0a1e1...
+ dct_interleave8(p1, p3); // c0g0c1g1...
+
+ // transpose pass 2
+ dct_interleave8(p0, p1); // a0c0e0g0...
+ dct_interleave8(p2, p3); // b0d0f0h0...
+
+ // transpose pass 3
+ dct_interleave8(p0, p2); // a0b0c0d0...
+ dct_interleave8(p1, p3); // a4b4c4d4...
+
+ // store
+ _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
+ _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
+ _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
+ _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
+ _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
+ _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
+ _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
+ _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
+ }
+
+#undef dct_const
+#undef dct_rot
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_interleave8
+#undef dct_interleave16
+#undef dct_pass
+}
+
+#endif // STBI_SSE2
+
+#ifdef STBI_NEON
+
+// NEON integer IDCT. should produce bit-identical
+// results to the generic C version.
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+ int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
+
+ int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
+ int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
+ int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
+ int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
+ int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
+ int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
+ int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
+ int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
+ int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
+ int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
+ int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
+ int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
+
+#define dct_long_mul(out, inq, coeff) \
+ int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
+ int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
+
+#define dct_long_mac(out, acc, inq, coeff) \
+ int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
+ int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
+
+#define dct_widen(out, inq) \
+ int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
+ int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
+
+// wide add
+#define dct_wadd(out, a, b) \
+ int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
+ int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
+
+// wide sub
+#define dct_wsub(out, a, b) \
+ int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
+ int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
+
+// butterfly a/b, then shift using "shiftop" by "s" and pack
+#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
+ { \
+ dct_wadd(sum, a, b); \
+ dct_wsub(dif, a, b); \
+ out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
+ out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
+ }
+
+#define dct_pass(shiftop, shift) \
+ { \
+ /* even part */ \
+ int16x8_t sum26 = vaddq_s16(row2, row6); \
+ dct_long_mul(p1e, sum26, rot0_0); \
+ dct_long_mac(t2e, p1e, row6, rot0_1); \
+ dct_long_mac(t3e, p1e, row2, rot0_2); \
+ int16x8_t sum04 = vaddq_s16(row0, row4); \
+ int16x8_t dif04 = vsubq_s16(row0, row4); \
+ dct_widen(t0e, sum04); \
+ dct_widen(t1e, dif04); \
+ dct_wadd(x0, t0e, t3e); \
+ dct_wsub(x3, t0e, t3e); \
+ dct_wadd(x1, t1e, t2e); \
+ dct_wsub(x2, t1e, t2e); \
+ /* odd part */ \
+ int16x8_t sum15 = vaddq_s16(row1, row5); \
+ int16x8_t sum17 = vaddq_s16(row1, row7); \
+ int16x8_t sum35 = vaddq_s16(row3, row5); \
+ int16x8_t sum37 = vaddq_s16(row3, row7); \
+ int16x8_t sumodd = vaddq_s16(sum17, sum35); \
+ dct_long_mul(p5o, sumodd, rot1_0); \
+ dct_long_mac(p1o, p5o, sum17, rot1_1); \
+ dct_long_mac(p2o, p5o, sum35, rot1_2); \
+ dct_long_mul(p3o, sum37, rot2_0); \
+ dct_long_mul(p4o, sum15, rot2_1); \
+ dct_wadd(sump13o, p1o, p3o); \
+ dct_wadd(sump24o, p2o, p4o); \
+ dct_wadd(sump23o, p2o, p3o); \
+ dct_wadd(sump14o, p1o, p4o); \
+ dct_long_mac(x4, sump13o, row7, rot3_0); \
+ dct_long_mac(x5, sump24o, row5, rot3_1); \
+ dct_long_mac(x6, sump23o, row3, rot3_2); \
+ dct_long_mac(x7, sump14o, row1, rot3_3); \
+ dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
+ dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
+ dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
+ dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
+ }
+
+ // load
+ row0 = vld1q_s16(data + 0*8);
+ row1 = vld1q_s16(data + 1*8);
+ row2 = vld1q_s16(data + 2*8);
+ row3 = vld1q_s16(data + 3*8);
+ row4 = vld1q_s16(data + 4*8);
+ row5 = vld1q_s16(data + 5*8);
+ row6 = vld1q_s16(data + 6*8);
+ row7 = vld1q_s16(data + 7*8);
+
+ // add DC bias
+ row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
+
+ // column pass
+ dct_pass(vrshrn_n_s32, 10);
+
+ // 16bit 8x8 transpose
+ {
+// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
+// whether compilers actually get this is another story, sadly.
+#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
+#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
+
+ // pass 1
+ dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
+ dct_trn16(row2, row3);
+ dct_trn16(row4, row5);
+ dct_trn16(row6, row7);
+
+ // pass 2
+ dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
+ dct_trn32(row1, row3);
+ dct_trn32(row4, row6);
+ dct_trn32(row5, row7);
+
+ // pass 3
+ dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
+ dct_trn64(row1, row5);
+ dct_trn64(row2, row6);
+ dct_trn64(row3, row7);
+
+#undef dct_trn16
+#undef dct_trn32
+#undef dct_trn64
+ }
+
+ // row pass
+ // vrshrn_n_s32 only supports shifts up to 16, we need
+ // 17. so do a non-rounding shift of 16 first then follow
+ // up with a rounding shift by 1.
+ dct_pass(vshrn_n_s32, 16);
+
+ {
+ // pack and round
+ uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
+ uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
+ uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
+ uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
+ uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
+ uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
+ uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
+ uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
+
+ // again, these can translate into one instruction, but often don't.
+#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
+#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
+
+ // sadly can't use interleaved stores here since we only write
+ // 8 bytes to each scan line!
+
+ // 8x8 8-bit transpose pass 1
+ dct_trn8_8(p0, p1);
+ dct_trn8_8(p2, p3);
+ dct_trn8_8(p4, p5);
+ dct_trn8_8(p6, p7);
+
+ // pass 2
+ dct_trn8_16(p0, p2);
+ dct_trn8_16(p1, p3);
+ dct_trn8_16(p4, p6);
+ dct_trn8_16(p5, p7);
+
+ // pass 3
+ dct_trn8_32(p0, p4);
+ dct_trn8_32(p1, p5);
+ dct_trn8_32(p2, p6);
+ dct_trn8_32(p3, p7);
+
+ // store
+ vst1_u8(out, p0); out += out_stride;
+ vst1_u8(out, p1); out += out_stride;
+ vst1_u8(out, p2); out += out_stride;
+ vst1_u8(out, p3); out += out_stride;
+ vst1_u8(out, p4); out += out_stride;
+ vst1_u8(out, p5); out += out_stride;
+ vst1_u8(out, p6); out += out_stride;
+ vst1_u8(out, p7);
+
+#undef dct_trn8_8
+#undef dct_trn8_16
+#undef dct_trn8_32
+ }
+
+#undef dct_long_mul
+#undef dct_long_mac
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_pass
+}
+
+#endif // STBI_NEON
+
+#define STBI__MARKER_none 0xff
+// if there's a pending marker from the entropy stream, return that
+// otherwise, fetch from the stream and get a marker. if there's no
+// marker, return 0xff, which is never a valid marker value
+static stbi_uc stbi__get_marker(stbi__jpeg *j)
+{
+ stbi_uc x;
+ if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
+ x = stbi__get8(j->s);
+ if (x != 0xff) return STBI__MARKER_none;
+ while (x == 0xff)
+ x = stbi__get8(j->s); // consume repeated 0xff fill bytes
+ return x;
+}
+
+// in each scan, we'll have scan_n components, and the order
+// of the components is specified by order[]
+#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
+
+// after a restart interval, stbi__jpeg_reset the entropy decoder and
+// the dc prediction
+static void stbi__jpeg_reset(stbi__jpeg *j)
+{
+ j->code_bits = 0;
+ j->code_buffer = 0;
+ j->nomore = 0;
+ j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;
+ j->marker = STBI__MARKER_none;
+ j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
+ j->eob_run = 0;
+ // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
+ // since we don't even allow 1<<30 pixels
+}
+
+static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
+{
+ stbi__jpeg_reset(z);
+ if (!z->progressive) {
+ if (z->scan_n == 1) {
+ int i,j;
+ STBI_SIMD_ALIGN(short, data[64]);
+ int n = z->order[0];
+ // non-interleaved data, we just need to process one block at a time,
+ // in trivial scanline order
+ // number of blocks to do just depends on how many actual "pixels" this
+ // component has, independent of interleaved MCU blocking and such
+ int w = (z->img_comp[n].x+7) >> 3;
+ int h = (z->img_comp[n].y+7) >> 3;
+ for (j=0; j < h; ++j) {
+ for (i=0; i < w; ++i) {
+ int ha = z->img_comp[n].ha;
+ if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+ z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+ // every data block is an MCU, so countdown the restart interval
+ if (--z->todo <= 0) {
+ if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+ // if it's NOT a restart, then just bail, so we get corrupt data
+ // rather than no data
+ if (!STBI__RESTART(z->marker)) return 1;
+ stbi__jpeg_reset(z);
+ }
+ }
+ }
+ return 1;
+ } else { // interleaved
+ int i,j,k,x,y;
+ STBI_SIMD_ALIGN(short, data[64]);
+ for (j=0; j < z->img_mcu_y; ++j) {
+ for (i=0; i < z->img_mcu_x; ++i) {
+ // scan an interleaved mcu... process scan_n components in order
+ for (k=0; k < z->scan_n; ++k) {
+ int n = z->order[k];
+ // scan out an mcu's worth of this component; that's just determined
+ // by the basic H and V specified for the component
+ for (y=0; y < z->img_comp[n].v; ++y) {
+ for (x=0; x < z->img_comp[n].h; ++x) {
+ int x2 = (i*z->img_comp[n].h + x)*8;
+ int y2 = (j*z->img_comp[n].v + y)*8;
+ int ha = z->img_comp[n].ha;
+ if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+ z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
+ }
+ }
+ }
+ // after all interleaved components, that's an interleaved MCU,
+ // so now count down the restart interval
+ if (--z->todo <= 0) {
+ if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+ if (!STBI__RESTART(z->marker)) return 1;
+ stbi__jpeg_reset(z);
+ }
+ }
+ }
+ return 1;
+ }
+ } else {
+ if (z->scan_n == 1) {
+ int i,j;
+ int n = z->order[0];
+ // non-interleaved data, we just need to process one block at a time,
+ // in trivial scanline order
+ // number of blocks to do just depends on how many actual "pixels" this
+ // component has, independent of interleaved MCU blocking and such
+ int w = (z->img_comp[n].x+7) >> 3;
+ int h = (z->img_comp[n].y+7) >> 3;
+ for (j=0; j < h; ++j) {
+ for (i=0; i < w; ++i) {
+ short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+ if (z->spec_start == 0) {
+ if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+ return 0;
+ } else {
+ int ha = z->img_comp[n].ha;
+ if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
+ return 0;
+ }
+ // every data block is an MCU, so countdown the restart interval
+ if (--z->todo <= 0) {
+ if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+ if (!STBI__RESTART(z->marker)) return 1;
+ stbi__jpeg_reset(z);
+ }
+ }
+ }
+ return 1;
+ } else { // interleaved
+ int i,j,k,x,y;
+ for (j=0; j < z->img_mcu_y; ++j) {
+ for (i=0; i < z->img_mcu_x; ++i) {
+ // scan an interleaved mcu... process scan_n components in order
+ for (k=0; k < z->scan_n; ++k) {
+ int n = z->order[k];
+ // scan out an mcu's worth of this component; that's just determined
+ // by the basic H and V specified for the component
+ for (y=0; y < z->img_comp[n].v; ++y) {
+ for (x=0; x < z->img_comp[n].h; ++x) {
+ int x2 = (i*z->img_comp[n].h + x);
+ int y2 = (j*z->img_comp[n].v + y);
+ short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
+ if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+ return 0;
+ }
+ }
+ }
+ // after all interleaved components, that's an interleaved MCU,
+ // so now count down the restart interval
+ if (--z->todo <= 0) {
+ if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+ if (!STBI__RESTART(z->marker)) return 1;
+ stbi__jpeg_reset(z);
+ }
+ }
+ }
+ return 1;
+ }
+ }
+}
+
+static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
+{
+ int i;
+ for (i=0; i < 64; ++i)
+ data[i] *= dequant[i];
+}
+
+static void stbi__jpeg_finish(stbi__jpeg *z)
+{
+ if (z->progressive) {
+ // dequantize and idct the data
+ int i,j,n;
+ for (n=0; n < z->s->img_n; ++n) {
+ int w = (z->img_comp[n].x+7) >> 3;
+ int h = (z->img_comp[n].y+7) >> 3;
+ for (j=0; j < h; ++j) {
+ for (i=0; i < w; ++i) {
+ short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+ stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
+ z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+ }
+ }
+ }
+ }
+}
+
+static int stbi__process_marker(stbi__jpeg *z, int m)
+{
+ int L;
+ switch (m) {
+ case STBI__MARKER_none: // no marker found
+ return stbi__err("expected marker","Corrupt JPEG");
+
+ case 0xDD: // DRI - specify restart interval
+ if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
+ z->restart_interval = stbi__get16be(z->s);
+ return 1;
+
+ case 0xDB: // DQT - define quantization table
+ L = stbi__get16be(z->s)-2;
+ while (L > 0) {
+ int q = stbi__get8(z->s);
+ int p = q >> 4, sixteen = (p != 0);
+ int t = q & 15,i;
+ if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");
+ if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
+
+ for (i=0; i < 64; ++i)
+ z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
+ L -= (sixteen ? 129 : 65);
+ }
+ return L==0;
+
+ case 0xC4: // DHT - define huffman table
+ L = stbi__get16be(z->s)-2;
+ while (L > 0) {
+ stbi_uc *v;
+ int sizes[16],i,n=0;
+ int q = stbi__get8(z->s);
+ int tc = q >> 4;
+ int th = q & 15;
+ if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
+ for (i=0; i < 16; ++i) {
+ sizes[i] = stbi__get8(z->s);
+ n += sizes[i];
+ }
+ if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values!
+ L -= 17;
+ if (tc == 0) {
+ if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
+ v = z->huff_dc[th].values;
+ } else {
+ if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
+ v = z->huff_ac[th].values;
+ }
+ for (i=0; i < n; ++i)
+ v[i] = stbi__get8(z->s);
+ if (tc != 0)
+ stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
+ L -= n;
+ }
+ return L==0;
+ }
+
+ // check for comment block or APP blocks
+ if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+ L = stbi__get16be(z->s);
+ if (L < 2) {
+ if (m == 0xFE)
+ return stbi__err("bad COM len","Corrupt JPEG");
+ else
+ return stbi__err("bad APP len","Corrupt JPEG");
+ }
+ L -= 2;
+
+ if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
+ static const unsigned char tag[5] = {'J','F','I','F','\0'};
+ int ok = 1;
+ int i;
+ for (i=0; i < 5; ++i)
+ if (stbi__get8(z->s) != tag[i])
+ ok = 0;
+ L -= 5;
+ if (ok)
+ z->jfif = 1;
+ } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
+ static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
+ int ok = 1;
+ int i;
+ for (i=0; i < 6; ++i)
+ if (stbi__get8(z->s) != tag[i])
+ ok = 0;
+ L -= 6;
+ if (ok) {
+ stbi__get8(z->s); // version
+ stbi__get16be(z->s); // flags0
+ stbi__get16be(z->s); // flags1
+ z->app14_color_transform = stbi__get8(z->s); // color transform
+ L -= 6;
+ }
+ }
+
+ stbi__skip(z->s, L);
+ return 1;
+ }
+
+ return stbi__err("unknown marker","Corrupt JPEG");
+}
+
+// after we see SOS
+static int stbi__process_scan_header(stbi__jpeg *z)
+{
+ int i;
+ int Ls = stbi__get16be(z->s);
+ z->scan_n = stbi__get8(z->s);
+ if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");
+ if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
+ for (i=0; i < z->scan_n; ++i) {
+ int id = stbi__get8(z->s), which;
+ int q = stbi__get8(z->s);
+ for (which = 0; which < z->s->img_n; ++which)
+ if (z->img_comp[which].id == id)
+ break;
+ if (which == z->s->img_n) return 0; // no match
+ z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
+ z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
+ z->order[i] = which;
+ }
+
+ {
+ int aa;
+ z->spec_start = stbi__get8(z->s);
+ z->spec_end = stbi__get8(z->s); // should be 63, but might be 0
+ aa = stbi__get8(z->s);
+ z->succ_high = (aa >> 4);
+ z->succ_low = (aa & 15);
+ if (z->progressive) {
+ if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
+ return stbi__err("bad SOS", "Corrupt JPEG");
+ } else {
+ if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
+ if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
+ z->spec_end = 63;
+ }
+ }
+
+ return 1;
+}
+
+static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
+{
+ int i;
+ for (i=0; i < ncomp; ++i) {
+ if (z->img_comp[i].raw_data) {
+ STBI_FREE(z->img_comp[i].raw_data);
+ z->img_comp[i].raw_data = NULL;
+ z->img_comp[i].data = NULL;
+ }
+ if (z->img_comp[i].raw_coeff) {
+ STBI_FREE(z->img_comp[i].raw_coeff);
+ z->img_comp[i].raw_coeff = 0;
+ z->img_comp[i].coeff = 0;
+ }
+ if (z->img_comp[i].linebuf) {
+ STBI_FREE(z->img_comp[i].linebuf);
+ z->img_comp[i].linebuf = NULL;
+ }
+ }
+ return why;
+}
+
+static int stbi__process_frame_header(stbi__jpeg *z, int scan)
+{
+ stbi__context *s = z->s;
+ int Lf,p,i,q, h_max=1,v_max=1,c;
+ Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
+ p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
+ s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
+ s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
+ if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+ if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+ c = stbi__get8(s);
+ if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
+ s->img_n = c;
+ for (i=0; i < c; ++i) {
+ z->img_comp[i].data = NULL;
+ z->img_comp[i].linebuf = NULL;
+ }
+
+ if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");
+
+ z->rgb = 0;
+ for (i=0; i < s->img_n; ++i) {
+ static const unsigned char rgb[3] = { 'R', 'G', 'B' };
+ z->img_comp[i].id = stbi__get8(s);
+ if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
+ ++z->rgb;
+ q = stbi__get8(s);
+ z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");
+ z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");
+ z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
+ }
+
+ if (scan != STBI__SCAN_load) return 1;
+
+ if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");
+
+ for (i=0; i < s->img_n; ++i) {
+ if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
+ if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
+ }
+
+ // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios
+ // and I've never seen a non-corrupted JPEG file actually use them
+ for (i=0; i < s->img_n; ++i) {
+ if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG");
+ if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG");
+ }
+
+ // compute interleaved mcu info
+ z->img_h_max = h_max;
+ z->img_v_max = v_max;
+ z->img_mcu_w = h_max * 8;
+ z->img_mcu_h = v_max * 8;
+ // these sizes can't be more than 17 bits
+ z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
+ z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
+
+ for (i=0; i < s->img_n; ++i) {
+ // number of effective pixels (e.g. for non-interleaved MCU)
+ z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
+ z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
+ // to simplify generation, we'll allocate enough memory to decode
+ // the bogus oversized data from using interleaved MCUs and their
+ // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
+ // discard the extra data until colorspace conversion
+ //
+ // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
+ // so these muls can't overflow with 32-bit ints (which we require)
+ z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
+ z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
+ z->img_comp[i].coeff = 0;
+ z->img_comp[i].raw_coeff = 0;
+ z->img_comp[i].linebuf = NULL;
+ z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
+ if (z->img_comp[i].raw_data == NULL)
+ return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+ // align blocks for idct using mmx/sse
+ z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
+ if (z->progressive) {
+ // w2, h2 are multiples of 8 (see above)
+ z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
+ z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
+ z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
+ if (z->img_comp[i].raw_coeff == NULL)
+ return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+ z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
+ }
+ }
+
+ return 1;
+}
+
+// use comparisons since in some cases we handle more than one case (e.g. SOF)
+#define stbi__DNL(x) ((x) == 0xdc)
+#define stbi__SOI(x) ((x) == 0xd8)
+#define stbi__EOI(x) ((x) == 0xd9)
+#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
+#define stbi__SOS(x) ((x) == 0xda)
+
+#define stbi__SOF_progressive(x) ((x) == 0xc2)
+
+static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
+{
+ int m;
+ z->jfif = 0;
+ z->app14_color_transform = -1; // valid values are 0,1,2
+ z->marker = STBI__MARKER_none; // initialize cached marker to empty
+ m = stbi__get_marker(z);
+ if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
+ if (scan == STBI__SCAN_type) return 1;
+ m = stbi__get_marker(z);
+ while (!stbi__SOF(m)) {
+ if (!stbi__process_marker(z,m)) return 0;
+ m = stbi__get_marker(z);
+ while (m == STBI__MARKER_none) {
+ // some files have extra padding after their blocks, so ok, we'll scan
+ if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
+ m = stbi__get_marker(z);
+ }
+ }
+ z->progressive = stbi__SOF_progressive(m);
+ if (!stbi__process_frame_header(z, scan)) return 0;
+ return 1;
+}
+
+static int stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)
+{
+ // some JPEGs have junk at end, skip over it but if we find what looks
+ // like a valid marker, resume there
+ while (!stbi__at_eof(j->s)) {
+ int x = stbi__get8(j->s);
+ while (x == 255) { // might be a marker
+ if (stbi__at_eof(j->s)) return STBI__MARKER_none;
+ x = stbi__get8(j->s);
+ if (x != 0x00 && x != 0xff) {
+ // not a stuffed zero or lead-in to another marker, looks
+ // like an actual marker, return it
+ return x;
+ }
+ // stuffed zero has x=0 now which ends the loop, meaning we go
+ // back to regular scan loop.
+ // repeated 0xff keeps trying to read the next byte of the marker.
+ }
+ }
+ return STBI__MARKER_none;
+}
+
+// decode image to YCbCr format
+static int stbi__decode_jpeg_image(stbi__jpeg *j)
+{
+ int m;
+ for (m = 0; m < 4; m++) {
+ j->img_comp[m].raw_data = NULL;
+ j->img_comp[m].raw_coeff = NULL;
+ }
+ j->restart_interval = 0;
+ if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
+ m = stbi__get_marker(j);
+ while (!stbi__EOI(m)) {
+ if (stbi__SOS(m)) {
+ if (!stbi__process_scan_header(j)) return 0;
+ if (!stbi__parse_entropy_coded_data(j)) return 0;
+ if (j->marker == STBI__MARKER_none ) {
+ j->marker = stbi__skip_jpeg_junk_at_end(j);
+ // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
+ }
+ m = stbi__get_marker(j);
+ if (STBI__RESTART(m))
+ m = stbi__get_marker(j);
+ } else if (stbi__DNL(m)) {
+ int Ld = stbi__get16be(j->s);
+ stbi__uint32 NL = stbi__get16be(j->s);
+ if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
+ if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
+ m = stbi__get_marker(j);
+ } else {
+ if (!stbi__process_marker(j, m)) return 1;
+ m = stbi__get_marker(j);
+ }
+ }
+ if (j->progressive)
+ stbi__jpeg_finish(j);
+ return 1;
+}
+
+// static jfif-centered resampling (across block boundaries)
+
+typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
+ int w, int hs);
+
+#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
+
+static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+ STBI_NOTUSED(out);
+ STBI_NOTUSED(in_far);
+ STBI_NOTUSED(w);
+ STBI_NOTUSED(hs);
+ return in_near;
+}
+
+static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+ // need to generate two samples vertically for every one in input
+ int i;
+ STBI_NOTUSED(hs);
+ for (i=0; i < w; ++i)
+ out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
+ return out;
+}
+
+static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+ // need to generate two samples horizontally for every one in input
+ int i;
+ stbi_uc *input = in_near;
+
+ if (w == 1) {
+ // if only one sample, can't do any interpolation
+ out[0] = out[1] = input[0];
+ return out;
+ }
+
+ out[0] = input[0];
+ out[1] = stbi__div4(input[0]*3 + input[1] + 2);
+ for (i=1; i < w-1; ++i) {
+ int n = 3*input[i]+2;
+ out[i*2+0] = stbi__div4(n+input[i-1]);
+ out[i*2+1] = stbi__div4(n+input[i+1]);
+ }
+ out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
+ out[i*2+1] = input[w-1];
+
+ STBI_NOTUSED(in_far);
+ STBI_NOTUSED(hs);
+
+ return out;
+}
+
+#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
+
+static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+ // need to generate 2x2 samples for every one in input
+ int i,t0,t1;
+ if (w == 1) {
+ out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+ return out;
+ }
+
+ t1 = 3*in_near[0] + in_far[0];
+ out[0] = stbi__div4(t1+2);
+ for (i=1; i < w; ++i) {
+ t0 = t1;
+ t1 = 3*in_near[i]+in_far[i];
+ out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+ out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
+ }
+ out[w*2-1] = stbi__div4(t1+2);
+
+ STBI_NOTUSED(hs);
+
+ return out;
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+ // need to generate 2x2 samples for every one in input
+ int i=0,t0,t1;
+
+ if (w == 1) {
+ out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+ return out;
+ }
+
+ t1 = 3*in_near[0] + in_far[0];
+ // process groups of 8 pixels for as long as we can.
+ // note we can't handle the last pixel in a row in this loop
+ // because we need to handle the filter boundary conditions.
+ for (; i < ((w-1) & ~7); i += 8) {
+#if defined(STBI_SSE2)
+ // load and perform the vertical filtering pass
+ // this uses 3*x + y = 4*x + (y - x)
+ __m128i zero = _mm_setzero_si128();
+ __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i));
+ __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
+ __m128i farw = _mm_unpacklo_epi8(farb, zero);
+ __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
+ __m128i diff = _mm_sub_epi16(farw, nearw);
+ __m128i nears = _mm_slli_epi16(nearw, 2);
+ __m128i curr = _mm_add_epi16(nears, diff); // current row
+
+ // horizontal filter works the same based on shifted vers of current
+ // row. "prev" is current row shifted right by 1 pixel; we need to
+ // insert the previous pixel value (from t1).
+ // "next" is current row shifted left by 1 pixel, with first pixel
+ // of next block of 8 pixels added in.
+ __m128i prv0 = _mm_slli_si128(curr, 2);
+ __m128i nxt0 = _mm_srli_si128(curr, 2);
+ __m128i prev = _mm_insert_epi16(prv0, t1, 0);
+ __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
+
+ // horizontal filter, polyphase implementation since it's convenient:
+ // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+ // odd pixels = 3*cur + next = cur*4 + (next - cur)
+ // note the shared term.
+ __m128i bias = _mm_set1_epi16(8);
+ __m128i curs = _mm_slli_epi16(curr, 2);
+ __m128i prvd = _mm_sub_epi16(prev, curr);
+ __m128i nxtd = _mm_sub_epi16(next, curr);
+ __m128i curb = _mm_add_epi16(curs, bias);
+ __m128i even = _mm_add_epi16(prvd, curb);
+ __m128i odd = _mm_add_epi16(nxtd, curb);
+
+ // interleave even and odd pixels, then undo scaling.
+ __m128i int0 = _mm_unpacklo_epi16(even, odd);
+ __m128i int1 = _mm_unpackhi_epi16(even, odd);
+ __m128i de0 = _mm_srli_epi16(int0, 4);
+ __m128i de1 = _mm_srli_epi16(int1, 4);
+
+ // pack and write output
+ __m128i outv = _mm_packus_epi16(de0, de1);
+ _mm_storeu_si128((__m128i *) (out + i*2), outv);
+#elif defined(STBI_NEON)
+ // load and perform the vertical filtering pass
+ // this uses 3*x + y = 4*x + (y - x)
+ uint8x8_t farb = vld1_u8(in_far + i);
+ uint8x8_t nearb = vld1_u8(in_near + i);
+ int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
+ int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
+ int16x8_t curr = vaddq_s16(nears, diff); // current row
+
+ // horizontal filter works the same based on shifted vers of current
+ // row. "prev" is current row shifted right by 1 pixel; we need to
+ // insert the previous pixel value (from t1).
+ // "next" is current row shifted left by 1 pixel, with first pixel
+ // of next block of 8 pixels added in.
+ int16x8_t prv0 = vextq_s16(curr, curr, 7);
+ int16x8_t nxt0 = vextq_s16(curr, curr, 1);
+ int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
+ int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
+
+ // horizontal filter, polyphase implementation since it's convenient:
+ // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+ // odd pixels = 3*cur + next = cur*4 + (next - cur)
+ // note the shared term.
+ int16x8_t curs = vshlq_n_s16(curr, 2);
+ int16x8_t prvd = vsubq_s16(prev, curr);
+ int16x8_t nxtd = vsubq_s16(next, curr);
+ int16x8_t even = vaddq_s16(curs, prvd);
+ int16x8_t odd = vaddq_s16(curs, nxtd);
+
+ // undo scaling and round, then store with even/odd phases interleaved
+ uint8x8x2_t o;
+ o.val[0] = vqrshrun_n_s16(even, 4);
+ o.val[1] = vqrshrun_n_s16(odd, 4);
+ vst2_u8(out + i*2, o);
+#endif
+
+ // "previous" value for next iter
+ t1 = 3*in_near[i+7] + in_far[i+7];
+ }
+
+ t0 = t1;
+ t1 = 3*in_near[i] + in_far[i];
+ out[i*2] = stbi__div16(3*t1 + t0 + 8);
+
+ for (++i; i < w; ++i) {
+ t0 = t1;
+ t1 = 3*in_near[i]+in_far[i];
+ out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+ out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
+ }
+ out[w*2-1] = stbi__div4(t1+2);
+
+ STBI_NOTUSED(hs);
+
+ return out;
+}
+#endif
+
+static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+ // resample with nearest-neighbor
+ int i,j;
+ STBI_NOTUSED(in_far);
+ for (i=0; i < w; ++i)
+ for (j=0; j < hs; ++j)
+ out[i*hs+j] = in_near[i];
+ return out;
+}
+
+// this is a reduced-precision calculation of YCbCr-to-RGB introduced
+// to make sure the code produces the same results in both SIMD and scalar
+#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)
+static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
+{
+ int i;
+ for (i=0; i < count; ++i) {
+ int y_fixed = (y[i] << 20) + (1<<19); // rounding
+ int r,g,b;
+ int cr = pcr[i] - 128;
+ int cb = pcb[i] - 128;
+ r = y_fixed + cr* stbi__float2fixed(1.40200f);
+ g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+ b = y_fixed + cb* stbi__float2fixed(1.77200f);
+ r >>= 20;
+ g >>= 20;
+ b >>= 20;
+ if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+ if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+ if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+ out[0] = (stbi_uc)r;
+ out[1] = (stbi_uc)g;
+ out[2] = (stbi_uc)b;
+ out[3] = 255;
+ out += step;
+ }
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
+{
+ int i = 0;
+
+#ifdef STBI_SSE2
+ // step == 3 is pretty ugly on the final interleave, and i'm not convinced
+ // it's useful in practice (you wouldn't use it for textures, for example).
+ // so just accelerate step == 4 case.
+ if (step == 4) {
+ // this is a fairly straightforward implementation and not super-optimized.
+ __m128i signflip = _mm_set1_epi8(-0x80);
+ __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f));
+ __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
+ __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
+ __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f));
+ __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
+ __m128i xw = _mm_set1_epi16(255); // alpha channel
+
+ for (; i+7 < count; i += 8) {
+ // load
+ __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
+ __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
+ __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
+ __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
+ __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
+
+ // unpack to short (and left-shift cr, cb by 8)
+ __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes);
+ __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
+ __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
+
+ // color transform
+ __m128i yws = _mm_srli_epi16(yw, 4);
+ __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
+ __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
+ __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
+ __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
+ __m128i rws = _mm_add_epi16(cr0, yws);
+ __m128i gwt = _mm_add_epi16(cb0, yws);
+ __m128i bws = _mm_add_epi16(yws, cb1);
+ __m128i gws = _mm_add_epi16(gwt, cr1);
+
+ // descale
+ __m128i rw = _mm_srai_epi16(rws, 4);
+ __m128i bw = _mm_srai_epi16(bws, 4);
+ __m128i gw = _mm_srai_epi16(gws, 4);
+
+ // back to byte, set up for transpose
+ __m128i brb = _mm_packus_epi16(rw, bw);
+ __m128i gxb = _mm_packus_epi16(gw, xw);
+
+ // transpose to interleave channels
+ __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
+ __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
+ __m128i o0 = _mm_unpacklo_epi16(t0, t1);
+ __m128i o1 = _mm_unpackhi_epi16(t0, t1);
+
+ // store
+ _mm_storeu_si128((__m128i *) (out + 0), o0);
+ _mm_storeu_si128((__m128i *) (out + 16), o1);
+ out += 32;
+ }
+ }
+#endif
+
+#ifdef STBI_NEON
+ // in this version, step=3 support would be easy to add. but is there demand?
+ if (step == 4) {
+ // this is a fairly straightforward implementation and not super-optimized.
+ uint8x8_t signflip = vdup_n_u8(0x80);
+ int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f));
+ int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
+ int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
+ int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f));
+
+ for (; i+7 < count; i += 8) {
+ // load
+ uint8x8_t y_bytes = vld1_u8(y + i);
+ uint8x8_t cr_bytes = vld1_u8(pcr + i);
+ uint8x8_t cb_bytes = vld1_u8(pcb + i);
+ int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
+ int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
+
+ // expand to s16
+ int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
+ int16x8_t crw = vshll_n_s8(cr_biased, 7);
+ int16x8_t cbw = vshll_n_s8(cb_biased, 7);
+
+ // color transform
+ int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
+ int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
+ int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
+ int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
+ int16x8_t rws = vaddq_s16(yws, cr0);
+ int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
+ int16x8_t bws = vaddq_s16(yws, cb1);
+
+ // undo scaling, round, convert to byte
+ uint8x8x4_t o;
+ o.val[0] = vqrshrun_n_s16(rws, 4);
+ o.val[1] = vqrshrun_n_s16(gws, 4);
+ o.val[2] = vqrshrun_n_s16(bws, 4);
+ o.val[3] = vdup_n_u8(255);
+
+ // store, interleaving r/g/b/a
+ vst4_u8(out, o);
+ out += 8*4;
+ }
+ }
+#endif
+
+ for (; i < count; ++i) {
+ int y_fixed = (y[i] << 20) + (1<<19); // rounding
+ int r,g,b;
+ int cr = pcr[i] - 128;
+ int cb = pcb[i] - 128;
+ r = y_fixed + cr* stbi__float2fixed(1.40200f);
+ g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+ b = y_fixed + cb* stbi__float2fixed(1.77200f);
+ r >>= 20;
+ g >>= 20;
+ b >>= 20;
+ if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+ if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+ if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+ out[0] = (stbi_uc)r;
+ out[1] = (stbi_uc)g;
+ out[2] = (stbi_uc)b;
+ out[3] = 255;
+ out += step;
+ }
+}
+#endif
+
+// set up the kernels
+static void stbi__setup_jpeg(stbi__jpeg *j)
+{
+ j->idct_block_kernel = stbi__idct_block;
+ j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
+ j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
+
+#ifdef STBI_SSE2
+ if (stbi__sse2_available()) {
+ j->idct_block_kernel = stbi__idct_simd;
+ j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+ j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+ }
+#endif
+
+#ifdef STBI_NEON
+ j->idct_block_kernel = stbi__idct_simd;
+ j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+ j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+#endif
+}
+
+// clean up the temporary component buffers
+static void stbi__cleanup_jpeg(stbi__jpeg *j)
+{
+ stbi__free_jpeg_components(j, j->s->img_n, 0);
+}
+
+typedef struct
+{
+ resample_row_func resample;
+ stbi_uc *line0,*line1;
+ int hs,vs; // expansion factor in each axis
+ int w_lores; // horizontal pixels pre-expansion
+ int ystep; // how far through vertical expansion we are
+ int ypos; // which pre-expansion row we're on
+} stbi__resample;
+
+// fast 0..255 * 0..255 => 0..255 rounded multiplication
+static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
+{
+ unsigned int t = x*y + 128;
+ return (stbi_uc) ((t + (t >>8)) >> 8);
+}
+
+static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
+{
+ int n, decode_n, is_rgb;
+ z->s->img_n = 0; // make stbi__cleanup_jpeg safe
+
+ // validate req_comp
+ if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+
+ // load a jpeg image from whichever source, but leave in YCbCr format
+ if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
+
+ // determine actual number of components to generate
+ n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
+
+ is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
+
+ if (z->s->img_n == 3 && n < 3 && !is_rgb)
+ decode_n = 1;
+ else
+ decode_n = z->s->img_n;
+
+ // nothing to do if no components requested; check this now to avoid
+ // accessing uninitialized coutput[0] later
+ if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; }
+
+ // resample and color-convert
+ {
+ int k;
+ unsigned int i,j;
+ stbi_uc *output;
+ stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
+
+ stbi__resample res_comp[4];
+
+ for (k=0; k < decode_n; ++k) {
+ stbi__resample *r = &res_comp[k];
+
+ // allocate line buffer big enough for upsampling off the edges
+ // with upsample factor of 4
+ z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
+ if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+ r->hs = z->img_h_max / z->img_comp[k].h;
+ r->vs = z->img_v_max / z->img_comp[k].v;
+ r->ystep = r->vs >> 1;
+ r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
+ r->ypos = 0;
+ r->line0 = r->line1 = z->img_comp[k].data;
+
+ if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
+ else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
+ else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
+ else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
+ else r->resample = stbi__resample_row_generic;
+ }
+
+ // can't error after this so, this is safe
+ output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
+ if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+ // now go ahead and resample
+ for (j=0; j < z->s->img_y; ++j) {
+ stbi_uc *out = output + n * z->s->img_x * j;
+ for (k=0; k < decode_n; ++k) {
+ stbi__resample *r = &res_comp[k];
+ int y_bot = r->ystep >= (r->vs >> 1);
+ coutput[k] = r->resample(z->img_comp[k].linebuf,
+ y_bot ? r->line1 : r->line0,
+ y_bot ? r->line0 : r->line1,
+ r->w_lores, r->hs);
+ if (++r->ystep >= r->vs) {
+ r->ystep = 0;
+ r->line0 = r->line1;
+ if (++r->ypos < z->img_comp[k].y)
+ r->line1 += z->img_comp[k].w2;
+ }
+ }
+ if (n >= 3) {
+ stbi_uc *y = coutput[0];
+ if (z->s->img_n == 3) {
+ if (is_rgb) {
+ for (i=0; i < z->s->img_x; ++i) {
+ out[0] = y[i];
+ out[1] = coutput[1][i];
+ out[2] = coutput[2][i];
+ out[3] = 255;
+ out += n;
+ }
+ } else {
+ z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+ }
+ } else if (z->s->img_n == 4) {
+ if (z->app14_color_transform == 0) { // CMYK
+ for (i=0; i < z->s->img_x; ++i) {
+ stbi_uc m = coutput[3][i];
+ out[0] = stbi__blinn_8x8(coutput[0][i], m);
+ out[1] = stbi__blinn_8x8(coutput[1][i], m);
+ out[2] = stbi__blinn_8x8(coutput[2][i], m);
+ out[3] = 255;
+ out += n;
+ }
+ } else if (z->app14_color_transform == 2) { // YCCK
+ z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+ for (i=0; i < z->s->img_x; ++i) {
+ stbi_uc m = coutput[3][i];
+ out[0] = stbi__blinn_8x8(255 - out[0], m);
+ out[1] = stbi__blinn_8x8(255 - out[1], m);
+ out[2] = stbi__blinn_8x8(255 - out[2], m);
+ out += n;
+ }
+ } else { // YCbCr + alpha? Ignore the fourth channel for now
+ z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+ }
+ } else
+ for (i=0; i < z->s->img_x; ++i) {
+ out[0] = out[1] = out[2] = y[i];
+ out[3] = 255; // not used if n==3
+ out += n;
+ }
+ } else {
+ if (is_rgb) {
+ if (n == 1)
+ for (i=0; i < z->s->img_x; ++i)
+ *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+ else {
+ for (i=0; i < z->s->img_x; ++i, out += 2) {
+ out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+ out[1] = 255;
+ }
+ }
+ } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
+ for (i=0; i < z->s->img_x; ++i) {
+ stbi_uc m = coutput[3][i];
+ stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
+ stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
+ stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
+ out[0] = stbi__compute_y(r, g, b);
+ out[1] = 255;
+ out += n;
+ }
+ } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
+ for (i=0; i < z->s->img_x; ++i) {
+ out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
+ out[1] = 255;
+ out += n;
+ }
+ } else {
+ stbi_uc *y = coutput[0];
+ if (n == 1)
+ for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
+ else
+ for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
+ }
+ }
+ }
+ stbi__cleanup_jpeg(z);
+ *out_x = z->s->img_x;
+ *out_y = z->s->img_y;
+ if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
+ return output;
+ }
+}
+
+static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+ unsigned char* result;
+ stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
+ if (!j) return stbi__errpuc("outofmem", "Out of memory");
+ memset(j, 0, sizeof(stbi__jpeg));
+ STBI_NOTUSED(ri);
+ j->s = s;
+ stbi__setup_jpeg(j);
+ result = load_jpeg_image(j, x,y,comp,req_comp);
+ STBI_FREE(j);
+ return result;
+}
+
+static int stbi__jpeg_test(stbi__context *s)
+{
+ int r;
+ stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
+ if (!j) return stbi__err("outofmem", "Out of memory");
+ memset(j, 0, sizeof(stbi__jpeg));
+ j->s = s;
+ stbi__setup_jpeg(j);
+ r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
+ stbi__rewind(s);
+ STBI_FREE(j);
+ return r;
+}
+
+static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
+{
+ if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
+ stbi__rewind( j->s );
+ return 0;
+ }
+ if (x) *x = j->s->img_x;
+ if (y) *y = j->s->img_y;
+ if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
+ return 1;
+}
+
+static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
+{
+ int result;
+ stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
+ if (!j) return stbi__err("outofmem", "Out of memory");
+ memset(j, 0, sizeof(stbi__jpeg));
+ j->s = s;
+ result = stbi__jpeg_info_raw(j, x, y, comp);
+ STBI_FREE(j);
+ return result;
+}
+#endif
+
+// public domain zlib decode v0.2 Sean Barrett 2006-11-18
+// simple implementation
+// - all input must be provided in an upfront buffer
+// - all output is written to a single output buffer (can malloc/realloc)
+// performance
+// - fast huffman
+
+#ifndef STBI_NO_ZLIB
+
+// fast-way is faster to check than jpeg huffman, but slow way is slower
+#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables
+#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
+#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet
+
+// zlib-style huffman encoding
+// (jpegs packs from left, zlib from right, so can't share code)
+typedef struct
+{
+ stbi__uint16 fast[1 << STBI__ZFAST_BITS];
+ stbi__uint16 firstcode[16];
+ int maxcode[17];
+ stbi__uint16 firstsymbol[16];
+ stbi_uc size[STBI__ZNSYMS];
+ stbi__uint16 value[STBI__ZNSYMS];
+} stbi__zhuffman;
+
+stbi_inline static int stbi__bitreverse16(int n)
+{
+ n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
+ n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
+ n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
+ n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
+ return n;
+}
+
+stbi_inline static int stbi__bit_reverse(int v, int bits)
+{
+ STBI_ASSERT(bits <= 16);
+ // to bit reverse n bits, reverse 16 and shift
+ // e.g. 11 bits, bit reverse and shift away 5
+ return stbi__bitreverse16(v) >> (16-bits);
+}
+
+static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
+{
+ int i,k=0;
+ int code, next_code[16], sizes[17];
+
+ // DEFLATE spec for generating codes
+ memset(sizes, 0, sizeof(sizes));
+ memset(z->fast, 0, sizeof(z->fast));
+ for (i=0; i < num; ++i)
+ ++sizes[sizelist[i]];
+ sizes[0] = 0;
+ for (i=1; i < 16; ++i)
+ if (sizes[i] > (1 << i))
+ return stbi__err("bad sizes", "Corrupt PNG");
+ code = 0;
+ for (i=1; i < 16; ++i) {
+ next_code[i] = code;
+ z->firstcode[i] = (stbi__uint16) code;
+ z->firstsymbol[i] = (stbi__uint16) k;
+ code = (code + sizes[i]);
+ if (sizes[i])
+ if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
+ z->maxcode[i] = code << (16-i); // preshift for inner loop
+ code <<= 1;
+ k += sizes[i];
+ }
+ z->maxcode[16] = 0x10000; // sentinel
+ for (i=0; i < num; ++i) {
+ int s = sizelist[i];
+ if (s) {
+ int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
+ stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
+ z->size [c] = (stbi_uc ) s;
+ z->value[c] = (stbi__uint16) i;
+ if (s <= STBI__ZFAST_BITS) {
+ int j = stbi__bit_reverse(next_code[s],s);
+ while (j < (1 << STBI__ZFAST_BITS)) {
+ z->fast[j] = fastv;
+ j += (1 << s);
+ }
+ }
+ ++next_code[s];
+ }
+ }
+ return 1;
+}
+
+// zlib-from-memory implementation for PNG reading
+// because PNG allows splitting the zlib stream arbitrarily,
+// and it's annoying structurally to have PNG call ZLIB call PNG,
+// we require PNG read all the IDATs and combine them into a single
+// memory buffer
+
+typedef struct
+{
+ stbi_uc *zbuffer, *zbuffer_end;
+ int num_bits;
+ stbi__uint32 code_buffer;
+
+ char *zout;
+ char *zout_start;
+ char *zout_end;
+ int z_expandable;
+
+ stbi__zhuffman z_length, z_distance;
+} stbi__zbuf;
+
+stbi_inline static int stbi__zeof(stbi__zbuf *z)
+{
+ return (z->zbuffer >= z->zbuffer_end);
+}
+
+stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
+{
+ return stbi__zeof(z) ? 0 : *z->zbuffer++;
+}
+
+static void stbi__fill_bits(stbi__zbuf *z)
+{
+ do {
+ if (z->code_buffer >= (1U << z->num_bits)) {
+ z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */
+ return;
+ }
+ z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
+ z->num_bits += 8;
+ } while (z->num_bits <= 24);
+}
+
+stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
+{
+ unsigned int k;
+ if (z->num_bits < n) stbi__fill_bits(z);
+ k = z->code_buffer & ((1 << n) - 1);
+ z->code_buffer >>= n;
+ z->num_bits -= n;
+ return k;
+}
+
+static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
+{
+ int b,s,k;
+ // not resolved by fast table, so compute it the slow way
+ // use jpeg approach, which requires MSbits at top
+ k = stbi__bit_reverse(a->code_buffer, 16);
+ for (s=STBI__ZFAST_BITS+1; ; ++s)
+ if (k < z->maxcode[s])
+ break;
+ if (s >= 16) return -1; // invalid code!
+ // code size is s, so:
+ b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
+ if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere!
+ if (z->size[b] != s) return -1; // was originally an assert, but report failure instead.
+ a->code_buffer >>= s;
+ a->num_bits -= s;
+ return z->value[b];
+}
+
+stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
+{
+ int b,s;
+ if (a->num_bits < 16) {
+ if (stbi__zeof(a)) {
+ return -1; /* report error for unexpected end of data. */
+ }
+ stbi__fill_bits(a);
+ }
+ b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
+ if (b) {
+ s = b >> 9;
+ a->code_buffer >>= s;
+ a->num_bits -= s;
+ return b & 511;
+ }
+ return stbi__zhuffman_decode_slowpath(a, z);
+}
+
+static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes
+{
+ char *q;
+ unsigned int cur, limit, old_limit;
+ z->zout = zout;
+ if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
+ cur = (unsigned int) (z->zout - z->zout_start);
+ limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
+ if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
+ while (cur + n > limit) {
+ if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
+ limit *= 2;
+ }
+ q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
+ STBI_NOTUSED(old_limit);
+ if (q == NULL) return stbi__err("outofmem", "Out of memory");
+ z->zout_start = q;
+ z->zout = q + cur;
+ z->zout_end = q + limit;
+ return 1;
+}
+
+static const int stbi__zlength_base[31] = {
+ 3,4,5,6,7,8,9,10,11,13,
+ 15,17,19,23,27,31,35,43,51,59,
+ 67,83,99,115,131,163,195,227,258,0,0 };
+
+static const int stbi__zlength_extra[31]=
+{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
+
+static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
+257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
+
+static const int stbi__zdist_extra[32] =
+{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+static int stbi__parse_huffman_block(stbi__zbuf *a)
+{
+ char *zout = a->zout;
+ for(;;) {
+ int z = stbi__zhuffman_decode(a, &a->z_length);
+ if (z < 256) {
+ if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
+ if (zout >= a->zout_end) {
+ if (!stbi__zexpand(a, zout, 1)) return 0;
+ zout = a->zout;
+ }
+ *zout++ = (char) z;
+ } else {
+ stbi_uc *p;
+ int len,dist;
+ if (z == 256) {
+ a->zout = zout;
+ return 1;
+ }
+ if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data
+ z -= 257;
+ len = stbi__zlength_base[z];
+ if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
+ z = stbi__zhuffman_decode(a, &a->z_distance);
+ if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data
+ dist = stbi__zdist_base[z];
+ if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
+ if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
+ if (zout + len > a->zout_end) {
+ if (!stbi__zexpand(a, zout, len)) return 0;
+ zout = a->zout;
+ }
+ p = (stbi_uc *) (zout - dist);
+ if (dist == 1) { // run of one byte; common in images.
+ stbi_uc v = *p;
+ if (len) { do *zout++ = v; while (--len); }
+ } else {
+ if (len) { do *zout++ = *p++; while (--len); }
+ }
+ }
+ }
+}
+
+static int stbi__compute_huffman_codes(stbi__zbuf *a)
+{
+ static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+ stbi__zhuffman z_codelength;
+ stbi_uc lencodes[286+32+137];//padding for maximum single op
+ stbi_uc codelength_sizes[19];
+ int i,n;
+
+ int hlit = stbi__zreceive(a,5) + 257;
+ int hdist = stbi__zreceive(a,5) + 1;
+ int hclen = stbi__zreceive(a,4) + 4;
+ int ntot = hlit + hdist;
+
+ memset(codelength_sizes, 0, sizeof(codelength_sizes));
+ for (i=0; i < hclen; ++i) {
+ int s = stbi__zreceive(a,3);
+ codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
+ }
+ if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
+
+ n = 0;
+ while (n < ntot) {
+ int c = stbi__zhuffman_decode(a, &z_codelength);
+ if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");
+ if (c < 16)
+ lencodes[n++] = (stbi_uc) c;
+ else {
+ stbi_uc fill = 0;
+ if (c == 16) {
+ c = stbi__zreceive(a,2)+3;
+ if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
+ fill = lencodes[n-1];
+ } else if (c == 17) {
+ c = stbi__zreceive(a,3)+3;
+ } else if (c == 18) {
+ c = stbi__zreceive(a,7)+11;
+ } else {
+ return stbi__err("bad codelengths", "Corrupt PNG");
+ }
+ if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
+ memset(lencodes+n, fill, c);
+ n += c;
+ }
+ }
+ if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");
+ if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
+ if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
+ return 1;
+}
+
+static int stbi__parse_uncompressed_block(stbi__zbuf *a)
+{
+ stbi_uc header[4];
+ int len,nlen,k;
+ if (a->num_bits & 7)
+ stbi__zreceive(a, a->num_bits & 7); // discard
+ // drain the bit-packed data into header
+ k = 0;
+ while (a->num_bits > 0) {
+ header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
+ a->code_buffer >>= 8;
+ a->num_bits -= 8;
+ }
+ if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");
+ // now fill header the normal way
+ while (k < 4)
+ header[k++] = stbi__zget8(a);
+ len = header[1] * 256 + header[0];
+ nlen = header[3] * 256 + header[2];
+ if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
+ if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
+ if (a->zout + len > a->zout_end)
+ if (!stbi__zexpand(a, a->zout, len)) return 0;
+ memcpy(a->zout, a->zbuffer, len);
+ a->zbuffer += len;
+ a->zout += len;
+ return 1;
+}
+
+static int stbi__parse_zlib_header(stbi__zbuf *a)
+{
+ int cmf = stbi__zget8(a);
+ int cm = cmf & 15;
+ /* int cinfo = cmf >> 4; */
+ int flg = stbi__zget8(a);
+ if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
+ if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
+ if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
+ if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
+ // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+ return 1;
+}
+
+static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =
+{
+ 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+ 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+ 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+ 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+ 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8
+};
+static const stbi_uc stbi__zdefault_distance[32] =
+{
+ 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
+};
+/*
+Init algorithm:
+{
+ int i; // use <= to match clearly with spec
+ for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8;
+ for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9;
+ for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7;
+ for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8;
+
+ for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5;
+}
+*/
+
+static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
+{
+ int final, type;
+ if (parse_header)
+ if (!stbi__parse_zlib_header(a)) return 0;
+ a->num_bits = 0;
+ a->code_buffer = 0;
+ do {
+ final = stbi__zreceive(a,1);
+ type = stbi__zreceive(a,2);
+ if (type == 0) {
+ if (!stbi__parse_uncompressed_block(a)) return 0;
+ } else if (type == 3) {
+ return 0;
+ } else {
+ if (type == 1) {
+ // use fixed code lengths
+ if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0;
+ if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0;
+ } else {
+ if (!stbi__compute_huffman_codes(a)) return 0;
+ }
+ if (!stbi__parse_huffman_block(a)) return 0;
+ }
+ } while (!final);
+ return 1;
+}
+
+static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
+{
+ a->zout_start = obuf;
+ a->zout = obuf;
+ a->zout_end = obuf + olen;
+ a->z_expandable = exp;
+
+ return stbi__parse_zlib(a, parse_header);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
+{
+ stbi__zbuf a;
+ char *p = (char *) stbi__malloc(initial_size);
+ if (p == NULL) return NULL;
+ a.zbuffer = (stbi_uc *) buffer;
+ a.zbuffer_end = (stbi_uc *) buffer + len;
+ if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
+ if (outlen) *outlen = (int) (a.zout - a.zout_start);
+ return a.zout_start;
+ } else {
+ STBI_FREE(a.zout_start);
+ return NULL;
+ }
+}
+
+STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
+{
+ return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+{
+ stbi__zbuf a;
+ char *p = (char *) stbi__malloc(initial_size);
+ if (p == NULL) return NULL;
+ a.zbuffer = (stbi_uc *) buffer;
+ a.zbuffer_end = (stbi_uc *) buffer + len;
+ if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
+ if (outlen) *outlen = (int) (a.zout - a.zout_start);
+ return a.zout_start;
+ } else {
+ STBI_FREE(a.zout_start);
+ return NULL;
+ }
+}
+
+STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
+{
+ stbi__zbuf a;
+ a.zbuffer = (stbi_uc *) ibuffer;
+ a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+ if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
+ return (int) (a.zout - a.zout_start);
+ else
+ return -1;
+}
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
+{
+ stbi__zbuf a;
+ char *p = (char *) stbi__malloc(16384);
+ if (p == NULL) return NULL;
+ a.zbuffer = (stbi_uc *) buffer;
+ a.zbuffer_end = (stbi_uc *) buffer+len;
+ if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
+ if (outlen) *outlen = (int) (a.zout - a.zout_start);
+ return a.zout_start;
+ } else {
+ STBI_FREE(a.zout_start);
+ return NULL;
+ }
+}
+
+STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
+{
+ stbi__zbuf a;
+ a.zbuffer = (stbi_uc *) ibuffer;
+ a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+ if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
+ return (int) (a.zout - a.zout_start);
+ else
+ return -1;
+}
+#endif
+
+// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18
+// simple implementation
+// - only 8-bit samples
+// - no CRC checking
+// - allocates lots of intermediate memory
+// - avoids problem of streaming data between subsystems
+// - avoids explicit window management
+// performance
+// - uses stb_zlib, a PD zlib implementation with fast huffman decoding
+
+#ifndef STBI_NO_PNG
+typedef struct
+{
+ stbi__uint32 length;
+ stbi__uint32 type;
+} stbi__pngchunk;
+
+static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
+{
+ stbi__pngchunk c;
+ c.length = stbi__get32be(s);
+ c.type = stbi__get32be(s);
+ return c;
+}
+
+static int stbi__check_png_header(stbi__context *s)
+{
+ static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
+ int i;
+ for (i=0; i < 8; ++i)
+ if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
+ return 1;
+}
+
+typedef struct
+{
+ stbi__context *s;
+ stbi_uc *idata, *expanded, *out;
+ int depth;
+} stbi__png;
+
+
+enum {
+ STBI__F_none=0,
+ STBI__F_sub=1,
+ STBI__F_up=2,
+ STBI__F_avg=3,
+ STBI__F_paeth=4,
+ // synthetic filters used for first scanline to avoid needing a dummy row of 0s
+ STBI__F_avg_first,
+ STBI__F_paeth_first
+};
+
+static stbi_uc first_row_filter[5] =
+{
+ STBI__F_none,
+ STBI__F_sub,
+ STBI__F_none,
+ STBI__F_avg_first,
+ STBI__F_paeth_first
+};
+
+static int stbi__paeth(int a, int b, int c)
+{
+ int p = a + b - c;
+ int pa = abs(p-a);
+ int pb = abs(p-b);
+ int pc = abs(p-c);
+ if (pa <= pb && pa <= pc) return a;
+ if (pb <= pc) return b;
+ return c;
+}
+
+static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
+
+// create the png data from post-deflated data
+static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
+{
+ int bytes = (depth == 16? 2 : 1);
+ stbi__context *s = a->s;
+ stbi__uint32 i,j,stride = x*out_n*bytes;
+ stbi__uint32 img_len, img_width_bytes;
+ int k;
+ int img_n = s->img_n; // copy it into a local for later
+
+ int output_bytes = out_n*bytes;
+ int filter_bytes = img_n*bytes;
+ int width = x;
+
+ STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
+ a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
+ if (!a->out) return stbi__err("outofmem", "Out of memory");
+
+ if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
+ img_width_bytes = (((img_n * x * depth) + 7) >> 3);
+ img_len = (img_width_bytes + 1) * y;
+
+ // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
+ // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
+ // so just check for raw_len < img_len always.
+ if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
+
+ for (j=0; j < y; ++j) {
+ stbi_uc *cur = a->out + stride*j;
+ stbi_uc *prior;
+ int filter = *raw++;
+
+ if (filter > 4)
+ return stbi__err("invalid filter","Corrupt PNG");
+
+ if (depth < 8) {
+ if (img_width_bytes > x) return stbi__err("invalid width","Corrupt PNG");
+ cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place
+ filter_bytes = 1;
+ width = img_width_bytes;
+ }
+ prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above
+
+ // if first row, use special filter that doesn't sample previous row
+ if (j == 0) filter = first_row_filter[filter];
+
+ // handle first byte explicitly
+ for (k=0; k < filter_bytes; ++k) {
+ switch (filter) {
+ case STBI__F_none : cur[k] = raw[k]; break;
+ case STBI__F_sub : cur[k] = raw[k]; break;
+ case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
+ case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
+ case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;
+ case STBI__F_avg_first : cur[k] = raw[k]; break;
+ case STBI__F_paeth_first: cur[k] = raw[k]; break;
+ }
+ }
+
+ if (depth == 8) {
+ if (img_n != out_n)
+ cur[img_n] = 255; // first pixel
+ raw += img_n;
+ cur += out_n;
+ prior += out_n;
+ } else if (depth == 16) {
+ if (img_n != out_n) {
+ cur[filter_bytes] = 255; // first pixel top byte
+ cur[filter_bytes+1] = 255; // first pixel bottom byte
+ }
+ raw += filter_bytes;
+ cur += output_bytes;
+ prior += output_bytes;
+ } else {
+ raw += 1;
+ cur += 1;
+ prior += 1;
+ }
+
+ // this is a little gross, so that we don't switch per-pixel or per-component
+ if (depth < 8 || img_n == out_n) {
+ int nk = (width - 1)*filter_bytes;
+ #define STBI__CASE(f) \
+ case f: \
+ for (k=0; k < nk; ++k)
+ switch (filter) {
+ // "none" filter turns into a memcpy here; make that explicit.
+ case STBI__F_none: memcpy(cur, raw, nk); break;
+ STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;
+ STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
+ STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;
+ STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;
+ STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;
+ STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break;
+ }
+ #undef STBI__CASE
+ raw += nk;
+ } else {
+ STBI_ASSERT(img_n+1 == out_n);
+ #define STBI__CASE(f) \
+ case f: \
+ for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
+ for (k=0; k < filter_bytes; ++k)
+ switch (filter) {
+ STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break;
+ STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;
+ STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
+ STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;
+ STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;
+ STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;
+ STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break;
+ }
+ #undef STBI__CASE
+
+ // the loop above sets the high byte of the pixels' alpha, but for
+ // 16 bit png files we also need the low byte set. we'll do that here.
+ if (depth == 16) {
+ cur = a->out + stride*j; // start at the beginning of the row again
+ for (i=0; i < x; ++i,cur+=output_bytes) {
+ cur[filter_bytes+1] = 255;
+ }
+ }
+ }
+ }
+
+ // we make a separate pass to expand bits to pixels; for performance,
+ // this could run two scanlines behind the above code, so it won't
+ // intefere with filtering but will still be in the cache.
+ if (depth < 8) {
+ for (j=0; j < y; ++j) {
+ stbi_uc *cur = a->out + stride*j;
+ stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes;
+ // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit
+ // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop
+ stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
+
+ // note that the final byte might overshoot and write more data than desired.
+ // we can allocate enough data that this never writes out of memory, but it
+ // could also overwrite the next scanline. can it overwrite non-empty data
+ // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.
+ // so we need to explicitly clamp the final ones
+
+ if (depth == 4) {
+ for (k=x*img_n; k >= 2; k-=2, ++in) {
+ *cur++ = scale * ((*in >> 4) );
+ *cur++ = scale * ((*in ) & 0x0f);
+ }
+ if (k > 0) *cur++ = scale * ((*in >> 4) );
+ } else if (depth == 2) {
+ for (k=x*img_n; k >= 4; k-=4, ++in) {
+ *cur++ = scale * ((*in >> 6) );
+ *cur++ = scale * ((*in >> 4) & 0x03);
+ *cur++ = scale * ((*in >> 2) & 0x03);
+ *cur++ = scale * ((*in ) & 0x03);
+ }
+ if (k > 0) *cur++ = scale * ((*in >> 6) );
+ if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
+ if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
+ } else if (depth == 1) {
+ for (k=x*img_n; k >= 8; k-=8, ++in) {
+ *cur++ = scale * ((*in >> 7) );
+ *cur++ = scale * ((*in >> 6) & 0x01);
+ *cur++ = scale * ((*in >> 5) & 0x01);
+ *cur++ = scale * ((*in >> 4) & 0x01);
+ *cur++ = scale * ((*in >> 3) & 0x01);
+ *cur++ = scale * ((*in >> 2) & 0x01);
+ *cur++ = scale * ((*in >> 1) & 0x01);
+ *cur++ = scale * ((*in ) & 0x01);
+ }
+ if (k > 0) *cur++ = scale * ((*in >> 7) );
+ if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
+ if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
+ if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
+ if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
+ if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
+ if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
+ }
+ if (img_n != out_n) {
+ int q;
+ // insert alpha = 255
+ cur = a->out + stride*j;
+ if (img_n == 1) {
+ for (q=x-1; q >= 0; --q) {
+ cur[q*2+1] = 255;
+ cur[q*2+0] = cur[q];
+ }
+ } else {
+ STBI_ASSERT(img_n == 3);
+ for (q=x-1; q >= 0; --q) {
+ cur[q*4+3] = 255;
+ cur[q*4+2] = cur[q*3+2];
+ cur[q*4+1] = cur[q*3+1];
+ cur[q*4+0] = cur[q*3+0];
+ }
+ }
+ }
+ }
+ } else if (depth == 16) {
+ // force the image data from big-endian to platform-native.
+ // this is done in a separate pass due to the decoding relying
+ // on the data being untouched, but could probably be done
+ // per-line during decode if care is taken.
+ stbi_uc *cur = a->out;
+ stbi__uint16 *cur16 = (stbi__uint16*)cur;
+
+ for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
+ *cur16 = (cur[0] << 8) | cur[1];
+ }
+ }
+
+ return 1;
+}
+
+static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
+{
+ int bytes = (depth == 16 ? 2 : 1);
+ int out_bytes = out_n * bytes;
+ stbi_uc *final;
+ int p;
+ if (!interlaced)
+ return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
+
+ // de-interlacing
+ final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
+ if (!final) return stbi__err("outofmem", "Out of memory");
+ for (p=0; p < 7; ++p) {
+ int xorig[] = { 0,4,0,2,0,1,0 };
+ int yorig[] = { 0,0,4,0,2,0,1 };
+ int xspc[] = { 8,8,4,4,2,2,1 };
+ int yspc[] = { 8,8,8,4,4,2,2 };
+ int i,j,x,y;
+ // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
+ x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
+ y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
+ if (x && y) {
+ stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
+ if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
+ STBI_FREE(final);
+ return 0;
+ }
+ for (j=0; j < y; ++j) {
+ for (i=0; i < x; ++i) {
+ int out_y = j*yspc[p]+yorig[p];
+ int out_x = i*xspc[p]+xorig[p];
+ memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
+ a->out + (j*x+i)*out_bytes, out_bytes);
+ }
+ }
+ STBI_FREE(a->out);
+ image_data += img_len;
+ image_data_len -= img_len;
+ }
+ }
+ a->out = final;
+
+ return 1;
+}
+
+static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
+{
+ stbi__context *s = z->s;
+ stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+ stbi_uc *p = z->out;
+
+ // compute color-based transparency, assuming we've
+ // already got 255 as the alpha value in the output
+ STBI_ASSERT(out_n == 2 || out_n == 4);
+
+ if (out_n == 2) {
+ for (i=0; i < pixel_count; ++i) {
+ p[1] = (p[0] == tc[0] ? 0 : 255);
+ p += 2;
+ }
+ } else {
+ for (i=0; i < pixel_count; ++i) {
+ if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+ p[3] = 0;
+ p += 4;
+ }
+ }
+ return 1;
+}
+
+static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
+{
+ stbi__context *s = z->s;
+ stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+ stbi__uint16 *p = (stbi__uint16*) z->out;
+
+ // compute color-based transparency, assuming we've
+ // already got 65535 as the alpha value in the output
+ STBI_ASSERT(out_n == 2 || out_n == 4);
+
+ if (out_n == 2) {
+ for (i = 0; i < pixel_count; ++i) {
+ p[1] = (p[0] == tc[0] ? 0 : 65535);
+ p += 2;
+ }
+ } else {
+ for (i = 0; i < pixel_count; ++i) {
+ if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+ p[3] = 0;
+ p += 4;
+ }
+ }
+ return 1;
+}
+
+static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
+{
+ stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+ stbi_uc *p, *temp_out, *orig = a->out;
+
+ p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
+ if (p == NULL) return stbi__err("outofmem", "Out of memory");
+
+ // between here and free(out) below, exitting would leak
+ temp_out = p;
+
+ if (pal_img_n == 3) {
+ for (i=0; i < pixel_count; ++i) {
+ int n = orig[i]*4;
+ p[0] = palette[n ];
+ p[1] = palette[n+1];
+ p[2] = palette[n+2];
+ p += 3;
+ }
+ } else {
+ for (i=0; i < pixel_count; ++i) {
+ int n = orig[i]*4;
+ p[0] = palette[n ];
+ p[1] = palette[n+1];
+ p[2] = palette[n+2];
+ p[3] = palette[n+3];
+ p += 4;
+ }
+ }
+ STBI_FREE(a->out);
+ a->out = temp_out;
+
+ STBI_NOTUSED(len);
+
+ return 1;
+}
+
+static int stbi__unpremultiply_on_load_global = 0;
+static int stbi__de_iphone_flag_global = 0;
+
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+{
+ stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
+{
+ stbi__de_iphone_flag_global = flag_true_if_should_convert;
+}
+
+#ifndef STBI_THREAD_LOCAL
+#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global
+#define stbi__de_iphone_flag stbi__de_iphone_flag_global
+#else
+static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;
+static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;
+
+STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
+{
+ stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
+ stbi__unpremultiply_on_load_set = 1;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)
+{
+ stbi__de_iphone_flag_local = flag_true_if_should_convert;
+ stbi__de_iphone_flag_set = 1;
+}
+
+#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \
+ ? stbi__unpremultiply_on_load_local \
+ : stbi__unpremultiply_on_load_global)
+#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \
+ ? stbi__de_iphone_flag_local \
+ : stbi__de_iphone_flag_global)
+#endif // STBI_THREAD_LOCAL
+
+static void stbi__de_iphone(stbi__png *z)
+{
+ stbi__context *s = z->s;
+ stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+ stbi_uc *p = z->out;
+
+ if (s->img_out_n == 3) { // convert bgr to rgb
+ for (i=0; i < pixel_count; ++i) {
+ stbi_uc t = p[0];
+ p[0] = p[2];
+ p[2] = t;
+ p += 3;
+ }
+ } else {
+ STBI_ASSERT(s->img_out_n == 4);
+ if (stbi__unpremultiply_on_load) {
+ // convert bgr to rgb and unpremultiply
+ for (i=0; i < pixel_count; ++i) {
+ stbi_uc a = p[3];
+ stbi_uc t = p[0];
+ if (a) {
+ stbi_uc half = a / 2;
+ p[0] = (p[2] * 255 + half) / a;
+ p[1] = (p[1] * 255 + half) / a;
+ p[2] = ( t * 255 + half) / a;
+ } else {
+ p[0] = p[2];
+ p[2] = t;
+ }
+ p += 4;
+ }
+ } else {
+ // convert bgr to rgb
+ for (i=0; i < pixel_count; ++i) {
+ stbi_uc t = p[0];
+ p[0] = p[2];
+ p[2] = t;
+ p += 4;
+ }
+ }
+ }
+}
+
+#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
+
+static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
+{
+ stbi_uc palette[1024], pal_img_n=0;
+ stbi_uc has_trans=0, tc[3]={0};
+ stbi__uint16 tc16[3];
+ stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
+ int first=1,k,interlace=0, color=0, is_iphone=0;
+ stbi__context *s = z->s;
+
+ z->expanded = NULL;
+ z->idata = NULL;
+ z->out = NULL;
+
+ if (!stbi__check_png_header(s)) return 0;
+
+ if (scan == STBI__SCAN_type) return 1;
+
+ for (;;) {
+ stbi__pngchunk c = stbi__get_chunk_header(s);
+ switch (c.type) {
+ case STBI__PNG_TYPE('C','g','B','I'):
+ is_iphone = 1;
+ stbi__skip(s, c.length);
+ break;
+ case STBI__PNG_TYPE('I','H','D','R'): {
+ int comp,filter;
+ if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
+ first = 0;
+ if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
+ s->img_x = stbi__get32be(s);
+ s->img_y = stbi__get32be(s);
+ if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+ if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+ z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
+ color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG");
+ if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG");
+ if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
+ comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG");
+ filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG");
+ interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
+ if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
+ if (!pal_img_n) {
+ s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
+ if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
+ } else {
+ // if paletted, then pal_n is our final components, and
+ // img_n is # components to decompress/filter.
+ s->img_n = 1;
+ if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
+ }
+ // even with SCAN_header, have to scan to see if we have a tRNS
+ break;
+ }
+
+ case STBI__PNG_TYPE('P','L','T','E'): {
+ if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+ if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
+ pal_len = c.length / 3;
+ if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
+ for (i=0; i < pal_len; ++i) {
+ palette[i*4+0] = stbi__get8(s);
+ palette[i*4+1] = stbi__get8(s);
+ palette[i*4+2] = stbi__get8(s);
+ palette[i*4+3] = 255;
+ }
+ break;
+ }
+
+ case STBI__PNG_TYPE('t','R','N','S'): {
+ if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+ if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
+ if (pal_img_n) {
+ if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
+ if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
+ if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
+ pal_img_n = 4;
+ for (i=0; i < c.length; ++i)
+ palette[i*4+3] = stbi__get8(s);
+ } else {
+ if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
+ if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
+ has_trans = 1;
+ // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.
+ if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }
+ if (z->depth == 16) {
+ for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
+ } else {
+ for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
+ }
+ }
+ break;
+ }
+
+ case STBI__PNG_TYPE('I','D','A','T'): {
+ if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+ if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
+ if (scan == STBI__SCAN_header) {
+ // header scan definitely stops at first IDAT
+ if (pal_img_n)
+ s->img_n = pal_img_n;
+ return 1;
+ }
+ if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes");
+ if ((int)(ioff + c.length) < (int)ioff) return 0;
+ if (ioff + c.length > idata_limit) {
+ stbi__uint32 idata_limit_old = idata_limit;
+ stbi_uc *p;
+ if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
+ while (ioff + c.length > idata_limit)
+ idata_limit *= 2;
+ STBI_NOTUSED(idata_limit_old);
+ p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
+ z->idata = p;
+ }
+ if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
+ ioff += c.length;
+ break;
+ }
+
+ case STBI__PNG_TYPE('I','E','N','D'): {
+ stbi__uint32 raw_len, bpl;
+ if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+ if (scan != STBI__SCAN_load) return 1;
+ if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
+ // initial guess for decoded data size to avoid unnecessary reallocs
+ bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
+ raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
+ z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
+ if (z->expanded == NULL) return 0; // zlib should set error
+ STBI_FREE(z->idata); z->idata = NULL;
+ if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
+ s->img_out_n = s->img_n+1;
+ else
+ s->img_out_n = s->img_n;
+ if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
+ if (has_trans) {
+ if (z->depth == 16) {
+ if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
+ } else {
+ if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
+ }
+ }
+ if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
+ stbi__de_iphone(z);
+ if (pal_img_n) {
+ // pal_img_n == 3 or 4
+ s->img_n = pal_img_n; // record the actual colors we had
+ s->img_out_n = pal_img_n;
+ if (req_comp >= 3) s->img_out_n = req_comp;
+ if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
+ return 0;
+ } else if (has_trans) {
+ // non-paletted image with tRNS -> source image has (constant) alpha
+ ++s->img_n;
+ }
+ STBI_FREE(z->expanded); z->expanded = NULL;
+ // end of PNG chunk, read and skip CRC
+ stbi__get32be(s);
+ return 1;
+ }
+
+ default:
+ // if critical, fail
+ if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+ if ((c.type & (1 << 29)) == 0) {
+ #ifndef STBI_NO_FAILURE_STRINGS
+ // not threadsafe
+ static char invalid_chunk[] = "XXXX PNG chunk not known";
+ invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
+ invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
+ invalid_chunk[2] = STBI__BYTECAST(c.type >> 8);
+ invalid_chunk[3] = STBI__BYTECAST(c.type >> 0);
+ #endif
+ return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
+ }
+ stbi__skip(s, c.length);
+ break;
+ }
+ // end of PNG chunk, read and skip CRC
+ stbi__get32be(s);
+ }
+}
+
+static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
+{
+ void *result=NULL;
+ if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+ if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
+ if (p->depth <= 8)
+ ri->bits_per_channel = 8;
+ else if (p->depth == 16)
+ ri->bits_per_channel = 16;
+ else
+ return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth");
+ result = p->out;
+ p->out = NULL;
+ if (req_comp && req_comp != p->s->img_out_n) {
+ if (ri->bits_per_channel == 8)
+ result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+ else
+ result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+ p->s->img_out_n = req_comp;
+ if (result == NULL) return result;
+ }
+ *x = p->s->img_x;
+ *y = p->s->img_y;
+ if (n) *n = p->s->img_n;
+ }
+ STBI_FREE(p->out); p->out = NULL;
+ STBI_FREE(p->expanded); p->expanded = NULL;
+ STBI_FREE(p->idata); p->idata = NULL;
+
+ return result;
+}
+
+static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+ stbi__png p;
+ p.s = s;
+ return stbi__do_png(&p, x,y,comp,req_comp, ri);
+}
+
+static int stbi__png_test(stbi__context *s)
+{
+ int r;
+ r = stbi__check_png_header(s);
+ stbi__rewind(s);
+ return r;
+}
+
+static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
+{
+ if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
+ stbi__rewind( p->s );
+ return 0;
+ }
+ if (x) *x = p->s->img_x;
+ if (y) *y = p->s->img_y;
+ if (comp) *comp = p->s->img_n;
+ return 1;
+}
+
+static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
+{
+ stbi__png p;
+ p.s = s;
+ return stbi__png_info_raw(&p, x, y, comp);
+}
+
+static int stbi__png_is16(stbi__context *s)
+{
+ stbi__png p;
+ p.s = s;
+ if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
+ return 0;
+ if (p.depth != 16) {
+ stbi__rewind(p.s);
+ return 0;
+ }
+ return 1;
+}
+#endif
+
+// Microsoft/Windows BMP image
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_test_raw(stbi__context *s)
+{
+ int r;
+ int sz;
+ if (stbi__get8(s) != 'B') return 0;
+ if (stbi__get8(s) != 'M') return 0;
+ stbi__get32le(s); // discard filesize
+ stbi__get16le(s); // discard reserved
+ stbi__get16le(s); // discard reserved
+ stbi__get32le(s); // discard data offset
+ sz = stbi__get32le(s);
+ r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
+ return r;
+}
+
+static int stbi__bmp_test(stbi__context *s)
+{
+ int r = stbi__bmp_test_raw(s);
+ stbi__rewind(s);
+ return r;
+}
+
+
+// returns 0..31 for the highest set bit
+static int stbi__high_bit(unsigned int z)
+{
+ int n=0;
+ if (z == 0) return -1;
+ if (z >= 0x10000) { n += 16; z >>= 16; }
+ if (z >= 0x00100) { n += 8; z >>= 8; }
+ if (z >= 0x00010) { n += 4; z >>= 4; }
+ if (z >= 0x00004) { n += 2; z >>= 2; }
+ if (z >= 0x00002) { n += 1;/* >>= 1;*/ }
+ return n;
+}
+
+static int stbi__bitcount(unsigned int a)
+{
+ a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2
+ a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4
+ a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
+ a = (a + (a >> 8)); // max 16 per 8 bits
+ a = (a + (a >> 16)); // max 32 per 8 bits
+ return a & 0xff;
+}
+
+// extract an arbitrarily-aligned N-bit value (N=bits)
+// from v, and then make it 8-bits long and fractionally
+// extend it to full full range.
+static int stbi__shiftsigned(unsigned int v, int shift, int bits)
+{
+ static unsigned int mul_table[9] = {
+ 0,
+ 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
+ 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
+ };
+ static unsigned int shift_table[9] = {
+ 0, 0,0,1,0,2,4,6,0,
+ };
+ if (shift < 0)
+ v <<= -shift;
+ else
+ v >>= shift;
+ STBI_ASSERT(v < 256);
+ v >>= (8-bits);
+ STBI_ASSERT(bits >= 0 && bits <= 8);
+ return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
+}
+
+typedef struct
+{
+ int bpp, offset, hsz;
+ unsigned int mr,mg,mb,ma, all_a;
+ int extra_read;
+} stbi__bmp_data;
+
+static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)
+{
+ // BI_BITFIELDS specifies masks explicitly, don't override
+ if (compress == 3)
+ return 1;
+
+ if (compress == 0) {
+ if (info->bpp == 16) {
+ info->mr = 31u << 10;
+ info->mg = 31u << 5;
+ info->mb = 31u << 0;
+ } else if (info->bpp == 32) {
+ info->mr = 0xffu << 16;
+ info->mg = 0xffu << 8;
+ info->mb = 0xffu << 0;
+ info->ma = 0xffu << 24;
+ info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
+ } else {
+ // otherwise, use defaults, which is all-0
+ info->mr = info->mg = info->mb = info->ma = 0;
+ }
+ return 1;
+ }
+ return 0; // error
+}
+
+static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
+{
+ int hsz;
+ if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
+ stbi__get32le(s); // discard filesize
+ stbi__get16le(s); // discard reserved
+ stbi__get16le(s); // discard reserved
+ info->offset = stbi__get32le(s);
+ info->hsz = hsz = stbi__get32le(s);
+ info->mr = info->mg = info->mb = info->ma = 0;
+ info->extra_read = 14;
+
+ if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP");
+
+ if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
+ if (hsz == 12) {
+ s->img_x = stbi__get16le(s);
+ s->img_y = stbi__get16le(s);
+ } else {
+ s->img_x = stbi__get32le(s);
+ s->img_y = stbi__get32le(s);
+ }
+ if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
+ info->bpp = stbi__get16le(s);
+ if (hsz != 12) {
+ int compress = stbi__get32le(s);
+ if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
+ if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes
+ if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel
+ stbi__get32le(s); // discard sizeof
+ stbi__get32le(s); // discard hres
+ stbi__get32le(s); // discard vres
+ stbi__get32le(s); // discard colorsused
+ stbi__get32le(s); // discard max important
+ if (hsz == 40 || hsz == 56) {
+ if (hsz == 56) {
+ stbi__get32le(s);
+ stbi__get32le(s);
+ stbi__get32le(s);
+ stbi__get32le(s);
+ }
+ if (info->bpp == 16 || info->bpp == 32) {
+ if (compress == 0) {
+ stbi__bmp_set_mask_defaults(info, compress);
+ } else if (compress == 3) {
+ info->mr = stbi__get32le(s);
+ info->mg = stbi__get32le(s);
+ info->mb = stbi__get32le(s);
+ info->extra_read += 12;
+ // not documented, but generated by photoshop and handled by mspaint
+ if (info->mr == info->mg && info->mg == info->mb) {
+ // ?!?!?
+ return stbi__errpuc("bad BMP", "bad BMP");
+ }
+ } else
+ return stbi__errpuc("bad BMP", "bad BMP");
+ }
+ } else {
+ // V4/V5 header
+ int i;
+ if (hsz != 108 && hsz != 124)
+ return stbi__errpuc("bad BMP", "bad BMP");
+ info->mr = stbi__get32le(s);
+ info->mg = stbi__get32le(s);
+ info->mb = stbi__get32le(s);
+ info->ma = stbi__get32le(s);
+ if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs
+ stbi__bmp_set_mask_defaults(info, compress);
+ stbi__get32le(s); // discard color space
+ for (i=0; i < 12; ++i)
+ stbi__get32le(s); // discard color space parameters
+ if (hsz == 124) {
+ stbi__get32le(s); // discard rendering intent
+ stbi__get32le(s); // discard offset of profile data
+ stbi__get32le(s); // discard size of profile data
+ stbi__get32le(s); // discard reserved
+ }
+ }
+ }
+ return (void *) 1;
+}
+
+
+static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+ stbi_uc *out;
+ unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
+ stbi_uc pal[256][4];
+ int psize=0,i,j,width;
+ int flip_vertically, pad, target;
+ stbi__bmp_data info;
+ STBI_NOTUSED(ri);
+
+ info.all_a = 255;
+ if (stbi__bmp_parse_header(s, &info) == NULL)
+ return NULL; // error code already set
+
+ flip_vertically = ((int) s->img_y) > 0;
+ s->img_y = abs((int) s->img_y);
+
+ if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+ if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+ mr = info.mr;
+ mg = info.mg;
+ mb = info.mb;
+ ma = info.ma;
+ all_a = info.all_a;
+
+ if (info.hsz == 12) {
+ if (info.bpp < 24)
+ psize = (info.offset - info.extra_read - 24) / 3;
+ } else {
+ if (info.bpp < 16)
+ psize = (info.offset - info.extra_read - info.hsz) >> 2;
+ }
+ if (psize == 0) {
+ // accept some number of extra bytes after the header, but if the offset points either to before
+ // the header ends or implies a large amount of extra data, reject the file as malformed
+ int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);
+ int header_limit = 1024; // max we actually read is below 256 bytes currently.
+ int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.
+ if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {
+ return stbi__errpuc("bad header", "Corrupt BMP");
+ }
+ // we established that bytes_read_so_far is positive and sensible.
+ // the first half of this test rejects offsets that are either too small positives, or
+ // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn
+ // ensures the number computed in the second half of the test can't overflow.
+ if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {
+ return stbi__errpuc("bad offset", "Corrupt BMP");
+ } else {
+ stbi__skip(s, info.offset - bytes_read_so_far);
+ }
+ }
+
+ if (info.bpp == 24 && ma == 0xff000000)
+ s->img_n = 3;
+ else
+ s->img_n = ma ? 4 : 3;
+ if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
+ target = req_comp;
+ else
+ target = s->img_n; // if they want monochrome, we'll post-convert
+
+ // sanity-check size
+ if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
+ return stbi__errpuc("too large", "Corrupt BMP");
+
+ out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
+ if (!out) return stbi__errpuc("outofmem", "Out of memory");
+ if (info.bpp < 16) {
+ int z=0;
+ if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
+ for (i=0; i < psize; ++i) {
+ pal[i][2] = stbi__get8(s);
+ pal[i][1] = stbi__get8(s);
+ pal[i][0] = stbi__get8(s);
+ if (info.hsz != 12) stbi__get8(s);
+ pal[i][3] = 255;
+ }
+ stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
+ if (info.bpp == 1) width = (s->img_x + 7) >> 3;
+ else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
+ else if (info.bpp == 8) width = s->img_x;
+ else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
+ pad = (-width)&3;
+ if (info.bpp == 1) {
+ for (j=0; j < (int) s->img_y; ++j) {
+ int bit_offset = 7, v = stbi__get8(s);
+ for (i=0; i < (int) s->img_x; ++i) {
+ int color = (v>>bit_offset)&0x1;
+ out[z++] = pal[color][0];
+ out[z++] = pal[color][1];
+ out[z++] = pal[color][2];
+ if (target == 4) out[z++] = 255;
+ if (i+1 == (int) s->img_x) break;
+ if((--bit_offset) < 0) {
+ bit_offset = 7;
+ v = stbi__get8(s);
+ }
+ }
+ stbi__skip(s, pad);
+ }
+ } else {
+ for (j=0; j < (int) s->img_y; ++j) {
+ for (i=0; i < (int) s->img_x; i += 2) {
+ int v=stbi__get8(s),v2=0;
+ if (info.bpp == 4) {
+ v2 = v & 15;
+ v >>= 4;
+ }
+ out[z++] = pal[v][0];
+ out[z++] = pal[v][1];
+ out[z++] = pal[v][2];
+ if (target == 4) out[z++] = 255;
+ if (i+1 == (int) s->img_x) break;
+ v = (info.bpp == 8) ? stbi__get8(s) : v2;
+ out[z++] = pal[v][0];
+ out[z++] = pal[v][1];
+ out[z++] = pal[v][2];
+ if (target == 4) out[z++] = 255;
+ }
+ stbi__skip(s, pad);
+ }
+ }
+ } else {
+ int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
+ int z = 0;
+ int easy=0;
+ stbi__skip(s, info.offset - info.extra_read - info.hsz);
+ if (info.bpp == 24) width = 3 * s->img_x;
+ else if (info.bpp == 16) width = 2*s->img_x;
+ else /* bpp = 32 and pad = 0 */ width=0;
+ pad = (-width) & 3;
+ if (info.bpp == 24) {
+ easy = 1;
+ } else if (info.bpp == 32) {
+ if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+ easy = 2;
+ }
+ if (!easy) {
+ if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
+ // right shift amt to put high bit in position #7
+ rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
+ gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
+ bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
+ ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
+ if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
+ }
+ for (j=0; j < (int) s->img_y; ++j) {
+ if (easy) {
+ for (i=0; i < (int) s->img_x; ++i) {
+ unsigned char a;
+ out[z+2] = stbi__get8(s);
+ out[z+1] = stbi__get8(s);
+ out[z+0] = stbi__get8(s);
+ z += 3;
+ a = (easy == 2 ? stbi__get8(s) : 255);
+ all_a |= a;
+ if (target == 4) out[z++] = a;
+ }
+ } else {
+ int bpp = info.bpp;
+ for (i=0; i < (int) s->img_x; ++i) {
+ stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
+ unsigned int a;
+ out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
+ out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
+ out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
+ a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
+ all_a |= a;
+ if (target == 4) out[z++] = STBI__BYTECAST(a);
+ }
+ }
+ stbi__skip(s, pad);
+ }
+ }
+
+ // if alpha channel is all 0s, replace with all 255s
+ if (target == 4 && all_a == 0)
+ for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
+ out[i] = 255;
+
+ if (flip_vertically) {
+ stbi_uc t;
+ for (j=0; j < (int) s->img_y>>1; ++j) {
+ stbi_uc *p1 = out + j *s->img_x*target;
+ stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
+ for (i=0; i < (int) s->img_x*target; ++i) {
+ t = p1[i]; p1[i] = p2[i]; p2[i] = t;
+ }
+ }
+ }
+
+ if (req_comp && req_comp != target) {
+ out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
+ if (out == NULL) return out; // stbi__convert_format frees input on failure
+ }
+
+ *x = s->img_x;
+ *y = s->img_y;
+ if (comp) *comp = s->img_n;
+ return out;
+}
+#endif
+
+// Targa Truevision - TGA
+// by Jonathan Dummer
+#ifndef STBI_NO_TGA
+// returns STBI_rgb or whatever, 0 on error
+static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
+{
+ // only RGB or RGBA (incl. 16bit) or grey allowed
+ if (is_rgb16) *is_rgb16 = 0;
+ switch(bits_per_pixel) {
+ case 8: return STBI_grey;
+ case 16: if(is_grey) return STBI_grey_alpha;
+ // fallthrough
+ case 15: if(is_rgb16) *is_rgb16 = 1;
+ return STBI_rgb;
+ case 24: // fallthrough
+ case 32: return bits_per_pixel/8;
+ default: return 0;
+ }
+}
+
+static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
+{
+ int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
+ int sz, tga_colormap_type;
+ stbi__get8(s); // discard Offset
+ tga_colormap_type = stbi__get8(s); // colormap type
+ if( tga_colormap_type > 1 ) {
+ stbi__rewind(s);
+ return 0; // only RGB or indexed allowed
+ }
+ tga_image_type = stbi__get8(s); // image type
+ if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
+ if (tga_image_type != 1 && tga_image_type != 9) {
+ stbi__rewind(s);
+ return 0;
+ }
+ stbi__skip(s,4); // skip index of first colormap entry and number of entries
+ sz = stbi__get8(s); // check bits per palette color entry
+ if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
+ stbi__rewind(s);
+ return 0;
+ }
+ stbi__skip(s,4); // skip image x and y origin
+ tga_colormap_bpp = sz;
+ } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
+ if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
+ stbi__rewind(s);
+ return 0; // only RGB or grey allowed, +/- RLE
+ }
+ stbi__skip(s,9); // skip colormap specification and image x/y origin
+ tga_colormap_bpp = 0;
+ }
+ tga_w = stbi__get16le(s);
+ if( tga_w < 1 ) {
+ stbi__rewind(s);
+ return 0; // test width
+ }
+ tga_h = stbi__get16le(s);
+ if( tga_h < 1 ) {
+ stbi__rewind(s);
+ return 0; // test height
+ }
+ tga_bits_per_pixel = stbi__get8(s); // bits per pixel
+ stbi__get8(s); // ignore alpha bits
+ if (tga_colormap_bpp != 0) {
+ if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
+ // when using a colormap, tga_bits_per_pixel is the size of the indexes
+ // I don't think anything but 8 or 16bit indexes makes sense
+ stbi__rewind(s);
+ return 0;
+ }
+ tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
+ } else {
+ tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
+ }
+ if(!tga_comp) {
+ stbi__rewind(s);
+ return 0;
+ }
+ if (x) *x = tga_w;
+ if (y) *y = tga_h;
+ if (comp) *comp = tga_comp;
+ return 1; // seems to have passed everything
+}
+
+static int stbi__tga_test(stbi__context *s)
+{
+ int res = 0;
+ int sz, tga_color_type;
+ stbi__get8(s); // discard Offset
+ tga_color_type = stbi__get8(s); // color type
+ if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed
+ sz = stbi__get8(s); // image type
+ if ( tga_color_type == 1 ) { // colormapped (paletted) image
+ if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
+ stbi__skip(s,4); // skip index of first colormap entry and number of entries
+ sz = stbi__get8(s); // check bits per palette color entry
+ if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+ stbi__skip(s,4); // skip image x and y origin
+ } else { // "normal" image w/o colormap
+ if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
+ stbi__skip(s,9); // skip colormap specification and image x/y origin
+ }
+ if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width
+ if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height
+ sz = stbi__get8(s); // bits per pixel
+ if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
+ if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+
+ res = 1; // if we got this far, everything's good and we can return 1 instead of 0
+
+errorEnd:
+ stbi__rewind(s);
+ return res;
+}
+
+// read 16bit value and convert to 24bit RGB
+static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
+{
+ stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
+ stbi__uint16 fiveBitMask = 31;
+ // we have 3 channels with 5bits each
+ int r = (px >> 10) & fiveBitMask;
+ int g = (px >> 5) & fiveBitMask;
+ int b = px & fiveBitMask;
+ // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
+ out[0] = (stbi_uc)((r * 255)/31);
+ out[1] = (stbi_uc)((g * 255)/31);
+ out[2] = (stbi_uc)((b * 255)/31);
+
+ // some people claim that the most significant bit might be used for alpha
+ // (possibly if an alpha-bit is set in the "image descriptor byte")
+ // but that only made 16bit test images completely translucent..
+ // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
+}
+
+static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+ // read in the TGA header stuff
+ int tga_offset = stbi__get8(s);
+ int tga_indexed = stbi__get8(s);
+ int tga_image_type = stbi__get8(s);
+ int tga_is_RLE = 0;
+ int tga_palette_start = stbi__get16le(s);
+ int tga_palette_len = stbi__get16le(s);
+ int tga_palette_bits = stbi__get8(s);
+ int tga_x_origin = stbi__get16le(s);
+ int tga_y_origin = stbi__get16le(s);
+ int tga_width = stbi__get16le(s);
+ int tga_height = stbi__get16le(s);
+ int tga_bits_per_pixel = stbi__get8(s);
+ int tga_comp, tga_rgb16=0;
+ int tga_inverted = stbi__get8(s);
+ // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
+ // image data
+ unsigned char *tga_data;
+ unsigned char *tga_palette = NULL;
+ int i, j;
+ unsigned char raw_data[4] = {0};
+ int RLE_count = 0;
+ int RLE_repeating = 0;
+ int read_next_pixel = 1;
+ STBI_NOTUSED(ri);
+ STBI_NOTUSED(tga_x_origin); // @TODO
+ STBI_NOTUSED(tga_y_origin); // @TODO
+
+ if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+ if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+ // do a tiny bit of precessing
+ if ( tga_image_type >= 8 )
+ {
+ tga_image_type -= 8;
+ tga_is_RLE = 1;
+ }
+ tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+ // If I'm paletted, then I'll use the number of bits from the palette
+ if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
+ else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
+
+ if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
+ return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
+
+ // tga info
+ *x = tga_width;
+ *y = tga_height;
+ if (comp) *comp = tga_comp;
+
+ if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
+ return stbi__errpuc("too large", "Corrupt TGA");
+
+ tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
+ if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
+
+ // skip to the data's starting position (offset usually = 0)
+ stbi__skip(s, tga_offset );
+
+ if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
+ for (i=0; i < tga_height; ++i) {
+ int row = tga_inverted ? tga_height -i - 1 : i;
+ stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
+ stbi__getn(s, tga_row, tga_width * tga_comp);
+ }
+ } else {
+ // do I need to load a palette?
+ if ( tga_indexed)
+ {
+ if (tga_palette_len == 0) { /* you have to have at least one entry! */
+ STBI_FREE(tga_data);
+ return stbi__errpuc("bad palette", "Corrupt TGA");
+ }
+
+ // any data to skip? (offset usually = 0)
+ stbi__skip(s, tga_palette_start );
+ // load the palette
+ tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
+ if (!tga_palette) {
+ STBI_FREE(tga_data);
+ return stbi__errpuc("outofmem", "Out of memory");
+ }
+ if (tga_rgb16) {
+ stbi_uc *pal_entry = tga_palette;
+ STBI_ASSERT(tga_comp == STBI_rgb);
+ for (i=0; i < tga_palette_len; ++i) {
+ stbi__tga_read_rgb16(s, pal_entry);
+ pal_entry += tga_comp;
+ }
+ } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
+ STBI_FREE(tga_data);
+ STBI_FREE(tga_palette);
+ return stbi__errpuc("bad palette", "Corrupt TGA");
+ }
+ }
+ // load the data
+ for (i=0; i < tga_width * tga_height; ++i)
+ {
+ // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
+ if ( tga_is_RLE )
+ {
+ if ( RLE_count == 0 )
+ {
+ // yep, get the next byte as a RLE command
+ int RLE_cmd = stbi__get8(s);
+ RLE_count = 1 + (RLE_cmd & 127);
+ RLE_repeating = RLE_cmd >> 7;
+ read_next_pixel = 1;
+ } else if ( !RLE_repeating )
+ {
+ read_next_pixel = 1;
+ }
+ } else
+ {
+ read_next_pixel = 1;
+ }
+ // OK, if I need to read a pixel, do it now
+ if ( read_next_pixel )
+ {
+ // load however much data we did have
+ if ( tga_indexed )
+ {
+ // read in index, then perform the lookup
+ int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
+ if ( pal_idx >= tga_palette_len ) {
+ // invalid index
+ pal_idx = 0;
+ }
+ pal_idx *= tga_comp;
+ for (j = 0; j < tga_comp; ++j) {
+ raw_data[j] = tga_palette[pal_idx+j];
+ }
+ } else if(tga_rgb16) {
+ STBI_ASSERT(tga_comp == STBI_rgb);
+ stbi__tga_read_rgb16(s, raw_data);
+ } else {
+ // read in the data raw
+ for (j = 0; j < tga_comp; ++j) {
+ raw_data[j] = stbi__get8(s);
+ }
+ }
+ // clear the reading flag for the next pixel
+ read_next_pixel = 0;
+ } // end of reading a pixel
+
+ // copy data
+ for (j = 0; j < tga_comp; ++j)
+ tga_data[i*tga_comp+j] = raw_data[j];
+
+ // in case we're in RLE mode, keep counting down
+ --RLE_count;
+ }
+ // do I need to invert the image?
+ if ( tga_inverted )
+ {
+ for (j = 0; j*2 < tga_height; ++j)
+ {
+ int index1 = j * tga_width * tga_comp;
+ int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
+ for (i = tga_width * tga_comp; i > 0; --i)
+ {
+ unsigned char temp = tga_data[index1];
+ tga_data[index1] = tga_data[index2];
+ tga_data[index2] = temp;
+ ++index1;
+ ++index2;
+ }
+ }
+ }
+ // clear my palette, if I had one
+ if ( tga_palette != NULL )
+ {
+ STBI_FREE( tga_palette );
+ }
+ }
+
+ // swap RGB - if the source data was RGB16, it already is in the right order
+ if (tga_comp >= 3 && !tga_rgb16)
+ {
+ unsigned char* tga_pixel = tga_data;
+ for (i=0; i < tga_width * tga_height; ++i)
+ {
+ unsigned char temp = tga_pixel[0];
+ tga_pixel[0] = tga_pixel[2];
+ tga_pixel[2] = temp;
+ tga_pixel += tga_comp;
+ }
+ }
+
+ // convert to target component count
+ if (req_comp && req_comp != tga_comp)
+ tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
+
+ // the things I do to get rid of an error message, and yet keep
+ // Microsoft's C compilers happy... [8^(
+ tga_palette_start = tga_palette_len = tga_palette_bits =
+ tga_x_origin = tga_y_origin = 0;
+ STBI_NOTUSED(tga_palette_start);
+ // OK, done
+ return tga_data;
+}
+#endif
+
+// *************************************************************************************************
+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_test(stbi__context *s)
+{
+ int r = (stbi__get32be(s) == 0x38425053);
+ stbi__rewind(s);
+ return r;
+}
+
+static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
+{
+ int count, nleft, len;
+
+ count = 0;
+ while ((nleft = pixelCount - count) > 0) {
+ len = stbi__get8(s);
+ if (len == 128) {
+ // No-op.
+ } else if (len < 128) {
+ // Copy next len+1 bytes literally.
+ len++;
+ if (len > nleft) return 0; // corrupt data
+ count += len;
+ while (len) {
+ *p = stbi__get8(s);
+ p += 4;
+ len--;
+ }
+ } else if (len > 128) {
+ stbi_uc val;
+ // Next -len+1 bytes in the dest are replicated from next source byte.
+ // (Interpret len as a negative 8-bit int.)
+ len = 257 - len;
+ if (len > nleft) return 0; // corrupt data
+ val = stbi__get8(s);
+ count += len;
+ while (len) {
+ *p = val;
+ p += 4;
+ len--;
+ }
+ }
+ }
+
+ return 1;
+}
+
+static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+ int pixelCount;
+ int channelCount, compression;
+ int channel, i;
+ int bitdepth;
+ int w,h;
+ stbi_uc *out;
+ STBI_NOTUSED(ri);
+
+ // Check identifier
+ if (stbi__get32be(s) != 0x38425053) // "8BPS"
+ return stbi__errpuc("not PSD", "Corrupt PSD image");
+
+ // Check file type version.
+ if (stbi__get16be(s) != 1)
+ return stbi__errpuc("wrong version", "Unsupported version of PSD image");
+
+ // Skip 6 reserved bytes.
+ stbi__skip(s, 6 );
+
+ // Read the number of channels (R, G, B, A, etc).
+ channelCount = stbi__get16be(s);
+ if (channelCount < 0 || channelCount > 16)
+ return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
+
+ // Read the rows and columns of the image.
+ h = stbi__get32be(s);
+ w = stbi__get32be(s);
+
+ if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+ if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+ // Make sure the depth is 8 bits.
+ bitdepth = stbi__get16be(s);
+ if (bitdepth != 8 && bitdepth != 16)
+ return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
+
+ // Make sure the color mode is RGB.
+ // Valid options are:
+ // 0: Bitmap
+ // 1: Grayscale
+ // 2: Indexed color
+ // 3: RGB color
+ // 4: CMYK color
+ // 7: Multichannel
+ // 8: Duotone
+ // 9: Lab color
+ if (stbi__get16be(s) != 3)
+ return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
+
+ // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.)
+ stbi__skip(s,stbi__get32be(s) );
+
+ // Skip the image resources. (resolution, pen tool paths, etc)
+ stbi__skip(s, stbi__get32be(s) );
+
+ // Skip the reserved data.
+ stbi__skip(s, stbi__get32be(s) );
+
+ // Find out if the data is compressed.
+ // Known values:
+ // 0: no compression
+ // 1: RLE compressed
+ compression = stbi__get16be(s);
+ if (compression > 1)
+ return stbi__errpuc("bad compression", "PSD has an unknown compression format");
+
+ // Check size
+ if (!stbi__mad3sizes_valid(4, w, h, 0))
+ return stbi__errpuc("too large", "Corrupt PSD");
+
+ // Create the destination image.
+
+ if (!compression && bitdepth == 16 && bpc == 16) {
+ out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
+ ri->bits_per_channel = 16;
+ } else
+ out = (stbi_uc *) stbi__malloc(4 * w*h);
+
+ if (!out) return stbi__errpuc("outofmem", "Out of memory");
+ pixelCount = w*h;
+
+ // Initialize the data to zero.
+ //memset( out, 0, pixelCount * 4 );
+
+ // Finally, the image data.
+ if (compression) {
+ // RLE as used by .PSD and .TIFF
+ // Loop until you get the number of unpacked bytes you are expecting:
+ // Read the next source byte into n.
+ // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
+ // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
+ // Else if n is 128, noop.
+ // Endloop
+
+ // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
+ // which we're going to just skip.
+ stbi__skip(s, h * channelCount * 2 );
+
+ // Read the RLE data by channel.
+ for (channel = 0; channel < 4; channel++) {
+ stbi_uc *p;
+
+ p = out+channel;
+ if (channel >= channelCount) {
+ // Fill this channel with default data.
+ for (i = 0; i < pixelCount; i++, p += 4)
+ *p = (channel == 3 ? 255 : 0);
+ } else {
+ // Read the RLE data.
+ if (!stbi__psd_decode_rle(s, p, pixelCount)) {
+ STBI_FREE(out);
+ return stbi__errpuc("corrupt", "bad RLE data");
+ }
+ }
+ }
+
+ } else {
+ // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)
+ // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
+
+ // Read the data by channel.
+ for (channel = 0; channel < 4; channel++) {
+ if (channel >= channelCount) {
+ // Fill this channel with default data.
+ if (bitdepth == 16 && bpc == 16) {
+ stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+ stbi__uint16 val = channel == 3 ? 65535 : 0;
+ for (i = 0; i < pixelCount; i++, q += 4)
+ *q = val;
+ } else {
+ stbi_uc *p = out+channel;
+ stbi_uc val = channel == 3 ? 255 : 0;
+ for (i = 0; i < pixelCount; i++, p += 4)
+ *p = val;
+ }
+ } else {
+ if (ri->bits_per_channel == 16) { // output bpc
+ stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+ for (i = 0; i < pixelCount; i++, q += 4)
+ *q = (stbi__uint16) stbi__get16be(s);
+ } else {
+ stbi_uc *p = out+channel;
+ if (bitdepth == 16) { // input bpc
+ for (i = 0; i < pixelCount; i++, p += 4)
+ *p = (stbi_uc) (stbi__get16be(s) >> 8);
+ } else {
+ for (i = 0; i < pixelCount; i++, p += 4)
+ *p = stbi__get8(s);
+ }
+ }
+ }
+ }
+ }
+
+ // remove weird white matte from PSD
+ if (channelCount >= 4) {
+ if (ri->bits_per_channel == 16) {
+ for (i=0; i < w*h; ++i) {
+ stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
+ if (pixel[3] != 0 && pixel[3] != 65535) {
+ float a = pixel[3] / 65535.0f;
+ float ra = 1.0f / a;
+ float inv_a = 65535.0f * (1 - ra);
+ pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
+ pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
+ pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
+ }
+ }
+ } else {
+ for (i=0; i < w*h; ++i) {
+ unsigned char *pixel = out + 4*i;
+ if (pixel[3] != 0 && pixel[3] != 255) {
+ float a = pixel[3] / 255.0f;
+ float ra = 1.0f / a;
+ float inv_a = 255.0f * (1 - ra);
+ pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);
+ pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);
+ pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);
+ }
+ }
+ }
+ }
+
+ // convert to desired output format
+ if (req_comp && req_comp != 4) {
+ if (ri->bits_per_channel == 16)
+ out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
+ else
+ out = stbi__convert_format(out, 4, req_comp, w, h);
+ if (out == NULL) return out; // stbi__convert_format frees input on failure
+ }
+
+ if (comp) *comp = 4;
+ *y = h;
+ *x = w;
+
+ return out;
+}
+#endif
+
+// *************************************************************************************************
+// Softimage PIC loader
+// by Tom Seddon
+//
+// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
+// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_is4(stbi__context *s,const char *str)
+{
+ int i;
+ for (i=0; i<4; ++i)
+ if (stbi__get8(s) != (stbi_uc)str[i])
+ return 0;
+
+ return 1;
+}
+
+static int stbi__pic_test_core(stbi__context *s)
+{
+ int i;
+
+ if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
+ return 0;
+
+ for(i=0;i<84;++i)
+ stbi__get8(s);
+
+ if (!stbi__pic_is4(s,"PICT"))
+ return 0;
+
+ return 1;
+}
+
+typedef struct
+{
+ stbi_uc size,type,channel;
+} stbi__pic_packet;
+
+static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
+{
+ int mask=0x80, i;
+
+ for (i=0; i<4; ++i, mask>>=1) {
+ if (channel & mask) {
+ if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
+ dest[i]=stbi__get8(s);
+ }
+ }
+
+ return dest;
+}
+
+static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
+{
+ int mask=0x80,i;
+
+ for (i=0;i<4; ++i, mask>>=1)
+ if (channel&mask)
+ dest[i]=src[i];
+}
+
+static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
+{
+ int act_comp=0,num_packets=0,y,chained;
+ stbi__pic_packet packets[10];
+
+ // this will (should...) cater for even some bizarre stuff like having data
+ // for the same channel in multiple packets.
+ do {
+ stbi__pic_packet *packet;
+
+ if (num_packets==sizeof(packets)/sizeof(packets[0]))
+ return stbi__errpuc("bad format","too many packets");
+
+ packet = &packets[num_packets++];
+
+ chained = stbi__get8(s);
+ packet->size = stbi__get8(s);
+ packet->type = stbi__get8(s);
+ packet->channel = stbi__get8(s);
+
+ act_comp |= packet->channel;
+
+ if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)");
+ if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp");
+ } while (chained);
+
+ *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
+
+ for(y=0; y<height; ++y) {
+ int packet_idx;
+
+ for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
+ stbi__pic_packet *packet = &packets[packet_idx];
+ stbi_uc *dest = result+y*width*4;
+
+ switch (packet->type) {
+ default:
+ return stbi__errpuc("bad format","packet has bad compression type");
+
+ case 0: {//uncompressed
+ int x;
+
+ for(x=0;x<width;++x, dest+=4)
+ if (!stbi__readval(s,packet->channel,dest))
+ return 0;
+ break;
+ }
+
+ case 1://Pure RLE
+ {
+ int left=width, i;
+
+ while (left>0) {
+ stbi_uc count,value[4];
+
+ count=stbi__get8(s);
+ if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)");
+
+ if (count > left)
+ count = (stbi_uc) left;
+
+ if (!stbi__readval(s,packet->channel,value)) return 0;
+
+ for(i=0; i<count; ++i,dest+=4)
+ stbi__copyval(packet->channel,dest,value);
+ left -= count;
+ }
+ }
+ break;
+
+ case 2: {//Mixed RLE
+ int left=width;
+ while (left>0) {
+ int count = stbi__get8(s), i;
+ if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)");
+
+ if (count >= 128) { // Repeated
+ stbi_uc value[4];
+
+ if (count==128)
+ count = stbi__get16be(s);
+ else
+ count -= 127;
+ if (count > left)
+ return stbi__errpuc("bad file","scanline overrun");
+
+ if (!stbi__readval(s,packet->channel,value))
+ return 0;
+
+ for(i=0;i<count;++i, dest += 4)
+ stbi__copyval(packet->channel,dest,value);
+ } else { // Raw
+ ++count;
+ if (count>left) return stbi__errpuc("bad file","scanline overrun");
+
+ for(i=0;i<count;++i, dest+=4)
+ if (!stbi__readval(s,packet->channel,dest))
+ return 0;
+ }
+ left-=count;
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ return result;
+}
+
+static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)
+{
+ stbi_uc *result;
+ int i, x,y, internal_comp;
+ STBI_NOTUSED(ri);
+
+ if (!comp) comp = &internal_comp;
+
+ for (i=0; i<92; ++i)
+ stbi__get8(s);
+
+ x = stbi__get16be(s);
+ y = stbi__get16be(s);
+
+ if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+ if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+ if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)");
+ if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
+
+ stbi__get32be(s); //skip `ratio'
+ stbi__get16be(s); //skip `fields'
+ stbi__get16be(s); //skip `pad'
+
+ // intermediate buffer is RGBA
+ result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
+ if (!result) return stbi__errpuc("outofmem", "Out of memory");
+ memset(result, 0xff, x*y*4);
+
+ if (!stbi__pic_load_core(s,x,y,comp, result)) {
+ STBI_FREE(result);
+ result=0;
+ }
+ *px = x;
+ *py = y;
+ if (req_comp == 0) req_comp = *comp;
+ result=stbi__convert_format(result,4,req_comp,x,y);
+
+ return result;
+}
+
+static int stbi__pic_test(stbi__context *s)
+{
+ int r = stbi__pic_test_core(s);
+ stbi__rewind(s);
+ return r;
+}
+#endif
+
+// *************************************************************************************************
+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
+
+#ifndef STBI_NO_GIF
+typedef struct
+{
+ stbi__int16 prefix;
+ stbi_uc first;
+ stbi_uc suffix;
+} stbi__gif_lzw;
+
+typedef struct
+{
+ int w,h;
+ stbi_uc *out; // output buffer (always 4 components)
+ stbi_uc *background; // The current "background" as far as a gif is concerned
+ stbi_uc *history;
+ int flags, bgindex, ratio, transparent, eflags;
+ stbi_uc pal[256][4];
+ stbi_uc lpal[256][4];
+ stbi__gif_lzw codes[8192];
+ stbi_uc *color_table;
+ int parse, step;
+ int lflags;
+ int start_x, start_y;
+ int max_x, max_y;
+ int cur_x, cur_y;
+ int line_size;
+ int delay;
+} stbi__gif;
+
+static int stbi__gif_test_raw(stbi__context *s)
+{
+ int sz;
+ if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
+ sz = stbi__get8(s);
+ if (sz != '9' && sz != '7') return 0;
+ if (stbi__get8(s) != 'a') return 0;
+ return 1;
+}
+
+static int stbi__gif_test(stbi__context *s)
+{
+ int r = stbi__gif_test_raw(s);
+ stbi__rewind(s);
+ return r;
+}
+
+static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
+{
+ int i;
+ for (i=0; i < num_entries; ++i) {
+ pal[i][2] = stbi__get8(s);
+ pal[i][1] = stbi__get8(s);
+ pal[i][0] = stbi__get8(s);
+ pal[i][3] = transp == i ? 0 : 255;
+ }
+}
+
+static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
+{
+ stbi_uc version;
+ if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
+ return stbi__err("not GIF", "Corrupt GIF");
+
+ version = stbi__get8(s);
+ if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF");
+ if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF");
+
+ stbi__g_failure_reason = "";
+ g->w = stbi__get16le(s);
+ g->h = stbi__get16le(s);
+ g->flags = stbi__get8(s);
+ g->bgindex = stbi__get8(s);
+ g->ratio = stbi__get8(s);
+ g->transparent = -1;
+
+ if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+ if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+
+ if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments
+
+ if (is_info) return 1;
+
+ if (g->flags & 0x80)
+ stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
+
+ return 1;
+}
+
+static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
+{
+ stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
+ if (!g) return stbi__err("outofmem", "Out of memory");
+ if (!stbi__gif_header(s, g, comp, 1)) {
+ STBI_FREE(g);
+ stbi__rewind( s );
+ return 0;
+ }
+ if (x) *x = g->w;
+ if (y) *y = g->h;
+ STBI_FREE(g);
+ return 1;
+}
+
+static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
+{
+ stbi_uc *p, *c;
+ int idx;
+
+ // recurse to decode the prefixes, since the linked-list is backwards,
+ // and working backwards through an interleaved image would be nasty
+ if (g->codes[code].prefix >= 0)
+ stbi__out_gif_code(g, g->codes[code].prefix);
+
+ if (g->cur_y >= g->max_y) return;
+
+ idx = g->cur_x + g->cur_y;
+ p = &g->out[idx];
+ g->history[idx / 4] = 1;
+
+ c = &g->color_table[g->codes[code].suffix * 4];
+ if (c[3] > 128) { // don't render transparent pixels;
+ p[0] = c[2];
+ p[1] = c[1];
+ p[2] = c[0];
+ p[3] = c[3];
+ }
+ g->cur_x += 4;
+
+ if (g->cur_x >= g->max_x) {
+ g->cur_x = g->start_x;
+ g->cur_y += g->step;
+
+ while (g->cur_y >= g->max_y && g->parse > 0) {
+ g->step = (1 << g->parse) * g->line_size;
+ g->cur_y = g->start_y + (g->step >> 1);
+ --g->parse;
+ }
+ }
+}
+
+static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
+{
+ stbi_uc lzw_cs;
+ stbi__int32 len, init_code;
+ stbi__uint32 first;
+ stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+ stbi__gif_lzw *p;
+
+ lzw_cs = stbi__get8(s);
+ if (lzw_cs > 12) return NULL;
+ clear = 1 << lzw_cs;
+ first = 1;
+ codesize = lzw_cs + 1;
+ codemask = (1 << codesize) - 1;
+ bits = 0;
+ valid_bits = 0;
+ for (init_code = 0; init_code < clear; init_code++) {
+ g->codes[init_code].prefix = -1;
+ g->codes[init_code].first = (stbi_uc) init_code;
+ g->codes[init_code].suffix = (stbi_uc) init_code;
+ }
+
+ // support no starting clear code
+ avail = clear+2;
+ oldcode = -1;
+
+ len = 0;
+ for(;;) {
+ if (valid_bits < codesize) {
+ if (len == 0) {
+ len = stbi__get8(s); // start new block
+ if (len == 0)
+ return g->out;
+ }
+ --len;
+ bits |= (stbi__int32) stbi__get8(s) << valid_bits;
+ valid_bits += 8;
+ } else {
+ stbi__int32 code = bits & codemask;
+ bits >>= codesize;
+ valid_bits -= codesize;
+ // @OPTIMIZE: is there some way we can accelerate the non-clear path?
+ if (code == clear) { // clear code
+ codesize = lzw_cs + 1;
+ codemask = (1 << codesize) - 1;
+ avail = clear + 2;
+ oldcode = -1;
+ first = 0;
+ } else if (code == clear + 1) { // end of stream code
+ stbi__skip(s, len);
+ while ((len = stbi__get8(s)) > 0)
+ stbi__skip(s,len);
+ return g->out;
+ } else if (code <= avail) {
+ if (first) {
+ return stbi__errpuc("no clear code", "Corrupt GIF");
+ }
+
+ if (oldcode >= 0) {
+ p = &g->codes[avail++];
+ if (avail > 8192) {
+ return stbi__errpuc("too many codes", "Corrupt GIF");
+ }
+
+ p->prefix = (stbi__int16) oldcode;
+ p->first = g->codes[oldcode].first;
+ p->suffix = (code == avail) ? p->first : g->codes[code].first;
+ } else if (code == avail)
+ return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+
+ stbi__out_gif_code(g, (stbi__uint16) code);
+
+ if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+ codesize++;
+ codemask = (1 << codesize) - 1;
+ }
+
+ oldcode = code;
+ } else {
+ return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+ }
+ }
+ }
+}
+
+// this function is designed to support animated gifs, although stb_image doesn't support it
+// two back is the image from two frames ago, used for a very specific disposal format
+static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
+{
+ int dispose;
+ int first_frame;
+ int pi;
+ int pcount;
+ STBI_NOTUSED(req_comp);
+
+ // on first frame, any non-written pixels get the background colour (non-transparent)
+ first_frame = 0;
+ if (g->out == 0) {
+ if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
+ if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
+ return stbi__errpuc("too large", "GIF image is too large");
+ pcount = g->w * g->h;
+ g->out = (stbi_uc *) stbi__malloc(4 * pcount);
+ g->background = (stbi_uc *) stbi__malloc(4 * pcount);
+ g->history = (stbi_uc *) stbi__malloc(pcount);
+ if (!g->out || !g->background || !g->history)
+ return stbi__errpuc("outofmem", "Out of memory");
+
+ // image is treated as "transparent" at the start - ie, nothing overwrites the current background;
+ // background colour is only used for pixels that are not rendered first frame, after that "background"
+ // color refers to the color that was there the previous frame.
+ memset(g->out, 0x00, 4 * pcount);
+ memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
+ memset(g->history, 0x00, pcount); // pixels that were affected previous frame
+ first_frame = 1;
+ } else {
+ // second frame - how do we dispose of the previous one?
+ dispose = (g->eflags & 0x1C) >> 2;
+ pcount = g->w * g->h;
+
+ if ((dispose == 3) && (two_back == 0)) {
+ dispose = 2; // if I don't have an image to revert back to, default to the old background
+ }
+
+ if (dispose == 3) { // use previous graphic
+ for (pi = 0; pi < pcount; ++pi) {
+ if (g->history[pi]) {
+ memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
+ }
+ }
+ } else if (dispose == 2) {
+ // restore what was changed last frame to background before that frame;
+ for (pi = 0; pi < pcount; ++pi) {
+ if (g->history[pi]) {
+ memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
+ }
+ }
+ } else {
+ // This is a non-disposal case eithe way, so just
+ // leave the pixels as is, and they will become the new background
+ // 1: do not dispose
+ // 0: not specified.
+ }
+
+ // background is what out is after the undoing of the previou frame;
+ memcpy( g->background, g->out, 4 * g->w * g->h );
+ }
+
+ // clear my history;
+ memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame
+
+ for (;;) {
+ int tag = stbi__get8(s);
+ switch (tag) {
+ case 0x2C: /* Image Descriptor */
+ {
+ stbi__int32 x, y, w, h;
+ stbi_uc *o;
+
+ x = stbi__get16le(s);
+ y = stbi__get16le(s);
+ w = stbi__get16le(s);
+ h = stbi__get16le(s);
+ if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+ return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
+
+ g->line_size = g->w * 4;
+ g->start_x = x * 4;
+ g->start_y = y * g->line_size;
+ g->max_x = g->start_x + w * 4;
+ g->max_y = g->start_y + h * g->line_size;
+ g->cur_x = g->start_x;
+ g->cur_y = g->start_y;
+
+ // if the width of the specified rectangle is 0, that means
+ // we may not see *any* pixels or the image is malformed;
+ // to make sure this is caught, move the current y down to
+ // max_y (which is what out_gif_code checks).
+ if (w == 0)
+ g->cur_y = g->max_y;
+
+ g->lflags = stbi__get8(s);
+
+ if (g->lflags & 0x40) {
+ g->step = 8 * g->line_size; // first interlaced spacing
+ g->parse = 3;
+ } else {
+ g->step = g->line_size;
+ g->parse = 0;
+ }
+
+ if (g->lflags & 0x80) {
+ stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
+ g->color_table = (stbi_uc *) g->lpal;
+ } else if (g->flags & 0x80) {
+ g->color_table = (stbi_uc *) g->pal;
+ } else
+ return stbi__errpuc("missing color table", "Corrupt GIF");
+
+ o = stbi__process_gif_raster(s, g);
+ if (!o) return NULL;
+
+ // if this was the first frame,
+ pcount = g->w * g->h;
+ if (first_frame && (g->bgindex > 0)) {
+ // if first frame, any pixel not drawn to gets the background color
+ for (pi = 0; pi < pcount; ++pi) {
+ if (g->history[pi] == 0) {
+ g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;
+ memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
+ }
+ }
+ }
+
+ return o;
+ }
+
+ case 0x21: // Comment Extension.
+ {
+ int len;
+ int ext = stbi__get8(s);
+ if (ext == 0xF9) { // Graphic Control Extension.
+ len = stbi__get8(s);
+ if (len == 4) {
+ g->eflags = stbi__get8(s);
+ g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
+
+ // unset old transparent
+ if (g->transparent >= 0) {
+ g->pal[g->transparent][3] = 255;
+ }
+ if (g->eflags & 0x01) {
+ g->transparent = stbi__get8(s);
+ if (g->transparent >= 0) {
+ g->pal[g->transparent][3] = 0;
+ }
+ } else {
+ // don't need transparent
+ stbi__skip(s, 1);
+ g->transparent = -1;
+ }
+ } else {
+ stbi__skip(s, len);
+ break;
+ }
+ }
+ while ((len = stbi__get8(s)) != 0) {
+ stbi__skip(s, len);
+ }
+ break;
+ }
+
+ case 0x3B: // gif stream termination code
+ return (stbi_uc *) s; // using '1' causes warning on some compilers
+
+ default:
+ return stbi__errpuc("unknown code", "Corrupt GIF");
+ }
+ }
+}
+
+static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)
+{
+ STBI_FREE(g->out);
+ STBI_FREE(g->history);
+ STBI_FREE(g->background);
+
+ if (out) STBI_FREE(out);
+ if (delays && *delays) STBI_FREE(*delays);
+ return stbi__errpuc("outofmem", "Out of memory");
+}
+
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+ if (stbi__gif_test(s)) {
+ int layers = 0;
+ stbi_uc *u = 0;
+ stbi_uc *out = 0;
+ stbi_uc *two_back = 0;
+ stbi__gif g;
+ int stride;
+ int out_size = 0;
+ int delays_size = 0;
+
+ STBI_NOTUSED(out_size);
+ STBI_NOTUSED(delays_size);
+
+ memset(&g, 0, sizeof(g));
+ if (delays) {
+ *delays = 0;
+ }
+
+ do {
+ u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
+ if (u == (stbi_uc *) s) u = 0; // end of animated gif marker
+
+ if (u) {
+ *x = g.w;
+ *y = g.h;
+ ++layers;
+ stride = g.w * g.h * 4;
+
+ if (out) {
+ void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride );
+ if (!tmp)
+ return stbi__load_gif_main_outofmem(&g, out, delays);
+ else {
+ out = (stbi_uc*) tmp;
+ out_size = layers * stride;
+ }
+
+ if (delays) {
+ int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers );
+ if (!new_delays)
+ return stbi__load_gif_main_outofmem(&g, out, delays);
+ *delays = new_delays;
+ delays_size = layers * sizeof(int);
+ }
+ } else {
+ out = (stbi_uc*)stbi__malloc( layers * stride );
+ if (!out)
+ return stbi__load_gif_main_outofmem(&g, out, delays);
+ out_size = layers * stride;
+ if (delays) {
+ *delays = (int*) stbi__malloc( layers * sizeof(int) );
+ if (!*delays)
+ return stbi__load_gif_main_outofmem(&g, out, delays);
+ delays_size = layers * sizeof(int);
+ }
+ }
+ memcpy( out + ((layers - 1) * stride), u, stride );
+ if (layers >= 2) {
+ two_back = out - 2 * stride;
+ }
+
+ if (delays) {
+ (*delays)[layers - 1U] = g.delay;
+ }
+ }
+ } while (u != 0);
+
+ // free temp buffer;
+ STBI_FREE(g.out);
+ STBI_FREE(g.history);
+ STBI_FREE(g.background);
+
+ // do the final conversion after loading everything;
+ if (req_comp && req_comp != 4)
+ out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
+
+ *z = layers;
+ return out;
+ } else {
+ return stbi__errpuc("not GIF", "Image was not as a gif type.");
+ }
+}
+
+static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+ stbi_uc *u = 0;
+ stbi__gif g;
+ memset(&g, 0, sizeof(g));
+ STBI_NOTUSED(ri);
+
+ u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
+ if (u == (stbi_uc *) s) u = 0; // end of animated gif marker
+ if (u) {
+ *x = g.w;
+ *y = g.h;
+
+ // moved conversion to after successful load so that the same
+ // can be done for multiple frames.
+ if (req_comp && req_comp != 4)
+ u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
+ } else if (g.out) {
+ // if there was an error and we allocated an image buffer, free it!
+ STBI_FREE(g.out);
+ }
+
+ // free buffers needed for multiple frame loading;
+ STBI_FREE(g.history);
+ STBI_FREE(g.background);
+
+ return u;
+}
+
+static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
+{
+ return stbi__gif_info_raw(s,x,y,comp);
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR loader
+// originally by Nicolas Schulz
+#ifndef STBI_NO_HDR
+static int stbi__hdr_test_core(stbi__context *s, const char *signature)
+{
+ int i;
+ for (i=0; signature[i]; ++i)
+ if (stbi__get8(s) != signature[i])
+ return 0;
+ stbi__rewind(s);
+ return 1;
+}
+
+static int stbi__hdr_test(stbi__context* s)
+{
+ int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
+ stbi__rewind(s);
+ if(!r) {
+ r = stbi__hdr_test_core(s, "#?RGBE\n");
+ stbi__rewind(s);
+ }
+ return r;
+}
+
+#define STBI__HDR_BUFLEN 1024
+static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
+{
+ int len=0;
+ char c = '\0';
+
+ c = (char) stbi__get8(z);
+
+ while (!stbi__at_eof(z) && c != '\n') {
+ buffer[len++] = c;
+ if (len == STBI__HDR_BUFLEN-1) {
+ // flush to end of line
+ while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
+ ;
+ break;
+ }
+ c = (char) stbi__get8(z);
+ }
+
+ buffer[len] = 0;
+ return buffer;
+}
+
+static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
+{
+ if ( input[3] != 0 ) {
+ float f1;
+ // Exponent
+ f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
+ if (req_comp <= 2)
+ output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
+ else {
+ output[0] = input[0] * f1;
+ output[1] = input[1] * f1;
+ output[2] = input[2] * f1;
+ }
+ if (req_comp == 2) output[1] = 1;
+ if (req_comp == 4) output[3] = 1;
+ } else {
+ switch (req_comp) {
+ case 4: output[3] = 1; /* fallthrough */
+ case 3: output[0] = output[1] = output[2] = 0;
+ break;
+ case 2: output[1] = 1; /* fallthrough */
+ case 1: output[0] = 0;
+ break;
+ }
+ }
+}
+
+static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+ char buffer[STBI__HDR_BUFLEN];
+ char *token;
+ int valid = 0;
+ int width, height;
+ stbi_uc *scanline;
+ float *hdr_data;
+ int len;
+ unsigned char count, value;
+ int i, j, k, c1,c2, z;
+ const char *headerToken;
+ STBI_NOTUSED(ri);
+
+ // Check identifier
+ headerToken = stbi__hdr_gettoken(s,buffer);
+ if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
+ return stbi__errpf("not HDR", "Corrupt HDR image");
+
+ // Parse header
+ for(;;) {
+ token = stbi__hdr_gettoken(s,buffer);
+ if (token[0] == 0) break;
+ if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+ }
+
+ if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format");
+
+ // Parse width and height
+ // can't use sscanf() if we're not using stdio!
+ token = stbi__hdr_gettoken(s,buffer);
+ if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+ token += 3;
+ height = (int) strtol(token, &token, 10);
+ while (*token == ' ') ++token;
+ if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+ token += 3;
+ width = (int) strtol(token, NULL, 10);
+
+ if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
+ if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
+
+ *x = width;
+ *y = height;
+
+ if (comp) *comp = 3;
+ if (req_comp == 0) req_comp = 3;
+
+ if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
+ return stbi__errpf("too large", "HDR image is too large");
+
+ // Read data
+ hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
+ if (!hdr_data)
+ return stbi__errpf("outofmem", "Out of memory");
+
+ // Load image data
+ // image data is stored as some number of sca
+ if ( width < 8 || width >= 32768) {
+ // Read flat data
+ for (j=0; j < height; ++j) {
+ for (i=0; i < width; ++i) {
+ stbi_uc rgbe[4];
+ main_decode_loop:
+ stbi__getn(s, rgbe, 4);
+ stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+ }
+ }
+ } else {
+ // Read RLE-encoded data
+ scanline = NULL;
+
+ for (j = 0; j < height; ++j) {
+ c1 = stbi__get8(s);
+ c2 = stbi__get8(s);
+ len = stbi__get8(s);
+ if (c1 != 2 || c2 != 2 || (len & 0x80)) {
+ // not run-length encoded, so we have to actually use THIS data as a decoded
+ // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
+ stbi_uc rgbe[4];
+ rgbe[0] = (stbi_uc) c1;
+ rgbe[1] = (stbi_uc) c2;
+ rgbe[2] = (stbi_uc) len;
+ rgbe[3] = (stbi_uc) stbi__get8(s);
+ stbi__hdr_convert(hdr_data, rgbe, req_comp);
+ i = 1;
+ j = 0;
+ STBI_FREE(scanline);
+ goto main_decode_loop; // yes, this makes no sense
+ }
+ len <<= 8;
+ len |= stbi__get8(s);
+ if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
+ if (scanline == NULL) {
+ scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);
+ if (!scanline) {
+ STBI_FREE(hdr_data);
+ return stbi__errpf("outofmem", "Out of memory");
+ }
+ }
+
+ for (k = 0; k < 4; ++k) {
+ int nleft;
+ i = 0;
+ while ((nleft = width - i) > 0) {
+ count = stbi__get8(s);
+ if (count > 128) {
+ // Run
+ value = stbi__get8(s);
+ count -= 128;
+ if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+ for (z = 0; z < count; ++z)
+ scanline[i++ * 4 + k] = value;
+ } else {
+ // Dump
+ if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+ for (z = 0; z < count; ++z)
+ scanline[i++ * 4 + k] = stbi__get8(s);
+ }
+ }
+ }
+ for (i=0; i < width; ++i)
+ stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
+ }
+ if (scanline)
+ STBI_FREE(scanline);
+ }
+
+ return hdr_data;
+}
+
+static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
+{
+ char buffer[STBI__HDR_BUFLEN];
+ char *token;
+ int valid = 0;
+ int dummy;
+
+ if (!x) x = &dummy;
+ if (!y) y = &dummy;
+ if (!comp) comp = &dummy;
+
+ if (stbi__hdr_test(s) == 0) {
+ stbi__rewind( s );
+ return 0;
+ }
+
+ for(;;) {
+ token = stbi__hdr_gettoken(s,buffer);
+ if (token[0] == 0) break;
+ if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+ }
+
+ if (!valid) {
+ stbi__rewind( s );
+ return 0;
+ }
+ token = stbi__hdr_gettoken(s,buffer);
+ if (strncmp(token, "-Y ", 3)) {
+ stbi__rewind( s );
+ return 0;
+ }
+ token += 3;
+ *y = (int) strtol(token, &token, 10);
+ while (*token == ' ') ++token;
+ if (strncmp(token, "+X ", 3)) {
+ stbi__rewind( s );
+ return 0;
+ }
+ token += 3;
+ *x = (int) strtol(token, NULL, 10);
+ *comp = 3;
+ return 1;
+}
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
+{
+ void *p;
+ stbi__bmp_data info;
+
+ info.all_a = 255;
+ p = stbi__bmp_parse_header(s, &info);
+ if (p == NULL) {
+ stbi__rewind( s );
+ return 0;
+ }
+ if (x) *x = s->img_x;
+ if (y) *y = s->img_y;
+ if (comp) {
+ if (info.bpp == 24 && info.ma == 0xff000000)
+ *comp = 3;
+ else
+ *comp = info.ma ? 4 : 3;
+ }
+ return 1;
+}
+#endif
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
+{
+ int channelCount, dummy, depth;
+ if (!x) x = &dummy;
+ if (!y) y = &dummy;
+ if (!comp) comp = &dummy;
+ if (stbi__get32be(s) != 0x38425053) {
+ stbi__rewind( s );
+ return 0;
+ }
+ if (stbi__get16be(s) != 1) {
+ stbi__rewind( s );
+ return 0;
+ }
+ stbi__skip(s, 6);
+ channelCount = stbi__get16be(s);
+ if (channelCount < 0 || channelCount > 16) {
+ stbi__rewind( s );
+ return 0;
+ }
+ *y = stbi__get32be(s);
+ *x = stbi__get32be(s);
+ depth = stbi__get16be(s);
+ if (depth != 8 && depth != 16) {
+ stbi__rewind( s );
+ return 0;
+ }
+ if (stbi__get16be(s) != 3) {
+ stbi__rewind( s );
+ return 0;
+ }
+ *comp = 4;
+ return 1;
+}
+
+static int stbi__psd_is16(stbi__context *s)
+{
+ int channelCount, depth;
+ if (stbi__get32be(s) != 0x38425053) {
+ stbi__rewind( s );
+ return 0;
+ }
+ if (stbi__get16be(s) != 1) {
+ stbi__rewind( s );
+ return 0;
+ }
+ stbi__skip(s, 6);
+ channelCount = stbi__get16be(s);
+ if (channelCount < 0 || channelCount > 16) {
+ stbi__rewind( s );
+ return 0;
+ }
+ STBI_NOTUSED(stbi__get32be(s));
+ STBI_NOTUSED(stbi__get32be(s));
+ depth = stbi__get16be(s);
+ if (depth != 16) {
+ stbi__rewind( s );
+ return 0;
+ }
+ return 1;
+}
+#endif
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
+{
+ int act_comp=0,num_packets=0,chained,dummy;
+ stbi__pic_packet packets[10];
+
+ if (!x) x = &dummy;
+ if (!y) y = &dummy;
+ if (!comp) comp = &dummy;
+
+ if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
+ stbi__rewind(s);
+ return 0;
+ }
+
+ stbi__skip(s, 88);
+
+ *x = stbi__get16be(s);
+ *y = stbi__get16be(s);
+ if (stbi__at_eof(s)) {
+ stbi__rewind( s);
+ return 0;
+ }
+ if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
+ stbi__rewind( s );
+ return 0;
+ }
+
+ stbi__skip(s, 8);
+
+ do {
+ stbi__pic_packet *packet;
+
+ if (num_packets==sizeof(packets)/sizeof(packets[0]))
+ return 0;
+
+ packet = &packets[num_packets++];
+ chained = stbi__get8(s);
+ packet->size = stbi__get8(s);
+ packet->type = stbi__get8(s);
+ packet->channel = stbi__get8(s);
+ act_comp |= packet->channel;
+
+ if (stbi__at_eof(s)) {
+ stbi__rewind( s );
+ return 0;
+ }
+ if (packet->size != 8) {
+ stbi__rewind( s );
+ return 0;
+ }
+ } while (chained);
+
+ *comp = (act_comp & 0x10 ? 4 : 3);
+
+ return 1;
+}
+#endif
+
+// *************************************************************************************************
+// Portable Gray Map and Portable Pixel Map loader
+// by Ken Miller
+//
+// PGM: http://netpbm.sourceforge.net/doc/pgm.html
+// PPM: http://netpbm.sourceforge.net/doc/ppm.html
+//
+// Known limitations:
+// Does not support comments in the header section
+// Does not support ASCII image data (formats P2 and P3)
+
+#ifndef STBI_NO_PNM
+
+static int stbi__pnm_test(stbi__context *s)
+{
+ char p, t;
+ p = (char) stbi__get8(s);
+ t = (char) stbi__get8(s);
+ if (p != 'P' || (t != '5' && t != '6')) {
+ stbi__rewind( s );
+ return 0;
+ }
+ return 1;
+}
+
+static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+ stbi_uc *out;
+ STBI_NOTUSED(ri);
+
+ ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);
+ if (ri->bits_per_channel == 0)
+ return 0;
+
+ if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+ if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+ *x = s->img_x;
+ *y = s->img_y;
+ if (comp) *comp = s->img_n;
+
+ if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))
+ return stbi__errpuc("too large", "PNM too large");
+
+ out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);
+ if (!out) return stbi__errpuc("outofmem", "Out of memory");
+ if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {
+ STBI_FREE(out);
+ return stbi__errpuc("bad PNM", "PNM file truncated");
+ }
+
+ if (req_comp && req_comp != s->img_n) {
+ if (ri->bits_per_channel == 16) {
+ out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y);
+ } else {
+ out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
+ }
+ if (out == NULL) return out; // stbi__convert_format frees input on failure
+ }
+ return out;
+}
+
+static int stbi__pnm_isspace(char c)
+{
+ return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+}
+
+static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)
+{
+ for (;;) {
+ while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
+ *c = (char) stbi__get8(s);
+
+ if (stbi__at_eof(s) || *c != '#')
+ break;
+
+ while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
+ *c = (char) stbi__get8(s);
+ }
+}
+
+static int stbi__pnm_isdigit(char c)
+{
+ return c >= '0' && c <= '9';
+}
+
+static int stbi__pnm_getinteger(stbi__context *s, char *c)
+{
+ int value = 0;
+
+ while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
+ value = value*10 + (*c - '0');
+ *c = (char) stbi__get8(s);
+ if((value > 214748364) || (value == 214748364 && *c > '7'))
+ return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int");
+ }
+
+ return value;
+}
+
+static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
+{
+ int maxv, dummy;
+ char c, p, t;
+
+ if (!x) x = &dummy;
+ if (!y) y = &dummy;
+ if (!comp) comp = &dummy;
+
+ stbi__rewind(s);
+
+ // Get identifier
+ p = (char) stbi__get8(s);
+ t = (char) stbi__get8(s);
+ if (p != 'P' || (t != '5' && t != '6')) {
+ stbi__rewind(s);
+ return 0;
+ }
+
+ *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm
+
+ c = (char) stbi__get8(s);
+ stbi__pnm_skip_whitespace(s, &c);
+
+ *x = stbi__pnm_getinteger(s, &c); // read width
+ if(*x == 0)
+ return stbi__err("invalid width", "PPM image header had zero or overflowing width");
+ stbi__pnm_skip_whitespace(s, &c);
+
+ *y = stbi__pnm_getinteger(s, &c); // read height
+ if (*y == 0)
+ return stbi__err("invalid width", "PPM image header had zero or overflowing width");
+ stbi__pnm_skip_whitespace(s, &c);
+
+ maxv = stbi__pnm_getinteger(s, &c); // read max value
+ if (maxv > 65535)
+ return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");
+ else if (maxv > 255)
+ return 16;
+ else
+ return 8;
+}
+
+static int stbi__pnm_is16(stbi__context *s)
+{
+ if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)
+ return 1;
+ return 0;
+}
+#endif
+
+static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
+{
+ #ifndef STBI_NO_JPEG
+ if (stbi__jpeg_info(s, x, y, comp)) return 1;
+ #endif
+
+ #ifndef STBI_NO_PNG
+ if (stbi__png_info(s, x, y, comp)) return 1;
+ #endif
+
+ #ifndef STBI_NO_GIF
+ if (stbi__gif_info(s, x, y, comp)) return 1;
+ #endif
+
+ #ifndef STBI_NO_BMP
+ if (stbi__bmp_info(s, x, y, comp)) return 1;
+ #endif
+
+ #ifndef STBI_NO_PSD
+ if (stbi__psd_info(s, x, y, comp)) return 1;
+ #endif
+
+ #ifndef STBI_NO_PIC
+ if (stbi__pic_info(s, x, y, comp)) return 1;
+ #endif
+
+ #ifndef STBI_NO_PNM
+ if (stbi__pnm_info(s, x, y, comp)) return 1;
+ #endif
+
+ #ifndef STBI_NO_HDR
+ if (stbi__hdr_info(s, x, y, comp)) return 1;
+ #endif
+
+ // test tga last because it's a crappy test!
+ #ifndef STBI_NO_TGA
+ if (stbi__tga_info(s, x, y, comp))
+ return 1;
+ #endif
+ return stbi__err("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static int stbi__is_16_main(stbi__context *s)
+{
+ #ifndef STBI_NO_PNG
+ if (stbi__png_is16(s)) return 1;
+ #endif
+
+ #ifndef STBI_NO_PSD
+ if (stbi__psd_is16(s)) return 1;
+ #endif
+
+ #ifndef STBI_NO_PNM
+ if (stbi__pnm_is16(s)) return 1;
+ #endif
+ return 0;
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
+{
+ FILE *f = stbi__fopen(filename, "rb");
+ int result;
+ if (!f) return stbi__err("can't fopen", "Unable to open file");
+ result = stbi_info_from_file(f, x, y, comp);
+ fclose(f);
+ return result;
+}
+
+STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
+{
+ int r;
+ stbi__context s;
+ long pos = ftell(f);
+ stbi__start_file(&s, f);
+ r = stbi__info_main(&s,x,y,comp);
+ fseek(f,pos,SEEK_SET);
+ return r;
+}
+
+STBIDEF int stbi_is_16_bit(char const *filename)
+{
+ FILE *f = stbi__fopen(filename, "rb");
+ int result;
+ if (!f) return stbi__err("can't fopen", "Unable to open file");
+ result = stbi_is_16_bit_from_file(f);
+ fclose(f);
+ return result;
+}
+
+STBIDEF int stbi_is_16_bit_from_file(FILE *f)
+{
+ int r;
+ stbi__context s;
+ long pos = ftell(f);
+ stbi__start_file(&s, f);
+ r = stbi__is_16_main(&s);
+ fseek(f,pos,SEEK_SET);
+ return r;
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
+{
+ stbi__context s;
+ stbi__start_mem(&s,buffer,len);
+ return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
+{
+ stbi__context s;
+ stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+ return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
+{
+ stbi__context s;
+ stbi__start_mem(&s,buffer,len);
+ return stbi__is_16_main(&s);
+}
+
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)
+{
+ stbi__context s;
+ stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+ return stbi__is_16_main(&s);
+}
+
+#endif // STB_IMAGE_IMPLEMENTATION
+
+/*
+ revision history:
+ 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
+ 2.19 (2018-02-11) fix warning
+ 2.18 (2018-01-30) fix warnings
+ 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
+ 1-bit BMP
+ *_is_16_bit api
+ avoid warnings
+ 2.16 (2017-07-23) all functions have 16-bit variants;
+ STBI_NO_STDIO works again;
+ compilation fixes;
+ fix rounding in unpremultiply;
+ optimize vertical flip;
+ disable raw_len validation;
+ documentation fixes
+ 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
+ warning fixes; disable run-time SSE detection on gcc;
+ uniform handling of optional "return" values;
+ thread-safe initialization of zlib tables
+ 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+ 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now
+ 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+ 2.11 (2016-04-02) allocate large structures on the stack
+ remove white matting for transparent PSD
+ fix reported channel count for PNG & BMP
+ re-enable SSE2 in non-gcc 64-bit
+ support RGB-formatted JPEG
+ read 16-bit PNGs (only as 8-bit)
+ 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
+ 2.09 (2016-01-16) allow comments in PNM files
+ 16-bit-per-pixel TGA (not bit-per-component)
+ info() for TGA could break due to .hdr handling
+ info() for BMP to shares code instead of sloppy parse
+ can use STBI_REALLOC_SIZED if allocator doesn't support realloc
+ code cleanup
+ 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
+ 2.07 (2015-09-13) fix compiler warnings
+ partial animated GIF support
+ limited 16-bpc PSD support
+ #ifdef unused functions
+ bug with < 92 byte PIC,PNM,HDR,TGA
+ 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value
+ 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning
+ 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit
+ 2.03 (2015-04-12) extra corruption checking (mmozeiko)
+ stbi_set_flip_vertically_on_load (nguillemot)
+ fix NEON support; fix mingw support
+ 2.02 (2015-01-19) fix incorrect assert, fix warning
+ 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
+ 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
+ 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
+ progressive JPEG (stb)
+ PGM/PPM support (Ken Miller)
+ STBI_MALLOC,STBI_REALLOC,STBI_FREE
+ GIF bugfix -- seemingly never worked
+ STBI_NO_*, STBI_ONLY_*
+ 1.48 (2014-12-14) fix incorrectly-named assert()
+ 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
+ optimize PNG (ryg)
+ fix bug in interlaced PNG with user-specified channel count (stb)
+ 1.46 (2014-08-26)
+ fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
+ 1.45 (2014-08-16)
+ fix MSVC-ARM internal compiler error by wrapping malloc
+ 1.44 (2014-08-07)
+ various warning fixes from Ronny Chevalier
+ 1.43 (2014-07-15)
+ fix MSVC-only compiler problem in code changed in 1.42
+ 1.42 (2014-07-09)
+ don't define _CRT_SECURE_NO_WARNINGS (affects user code)
+ fixes to stbi__cleanup_jpeg path
+ added STBI_ASSERT to avoid requiring assert.h
+ 1.41 (2014-06-25)
+ fix search&replace from 1.36 that messed up comments/error messages
+ 1.40 (2014-06-22)
+ fix gcc struct-initialization warning
+ 1.39 (2014-06-15)
+ fix to TGA optimization when req_comp != number of components in TGA;
+ fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
+ add support for BMP version 5 (more ignored fields)
+ 1.38 (2014-06-06)
+ suppress MSVC warnings on integer casts truncating values
+ fix accidental rename of 'skip' field of I/O
+ 1.37 (2014-06-04)
+ remove duplicate typedef
+ 1.36 (2014-06-03)
+ convert to header file single-file library
+ if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
+ 1.35 (2014-05-27)
+ various warnings
+ fix broken STBI_SIMD path
+ fix bug where stbi_load_from_file no longer left file pointer in correct place
+ fix broken non-easy path for 32-bit BMP (possibly never used)
+ TGA optimization by Arseny Kapoulkine
+ 1.34 (unknown)
+ use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
+ 1.33 (2011-07-14)
+ make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
+ 1.32 (2011-07-13)
+ support for "info" function for all supported filetypes (SpartanJ)
+ 1.31 (2011-06-20)
+ a few more leak fixes, bug in PNG handling (SpartanJ)
+ 1.30 (2011-06-11)
+ added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
+ removed deprecated format-specific test/load functions
+ removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
+ error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
+ fix inefficiency in decoding 32-bit BMP (David Woo)
+ 1.29 (2010-08-16)
+ various warning fixes from Aurelien Pocheville
+ 1.28 (2010-08-01)
+ fix bug in GIF palette transparency (SpartanJ)
+ 1.27 (2010-08-01)
+ cast-to-stbi_uc to fix warnings
+ 1.26 (2010-07-24)
+ fix bug in file buffering for PNG reported by SpartanJ
+ 1.25 (2010-07-17)
+ refix trans_data warning (Won Chun)
+ 1.24 (2010-07-12)
+ perf improvements reading from files on platforms with lock-heavy fgetc()
+ minor perf improvements for jpeg
+ deprecated type-specific functions so we'll get feedback if they're needed
+ attempt to fix trans_data warning (Won Chun)
+ 1.23 fixed bug in iPhone support
+ 1.22 (2010-07-10)
+ removed image *writing* support
+ stbi_info support from Jetro Lauha
+ GIF support from Jean-Marc Lienher
+ iPhone PNG-extensions from James Brown
+ warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
+ 1.21 fix use of 'stbi_uc' in header (reported by jon blow)
+ 1.20 added support for Softimage PIC, by Tom Seddon
+ 1.19 bug in interlaced PNG corruption check (found by ryg)
+ 1.18 (2008-08-02)
+ fix a threading bug (local mutable static)
+ 1.17 support interlaced PNG
+ 1.16 major bugfix - stbi__convert_format converted one too many pixels
+ 1.15 initialize some fields for thread safety
+ 1.14 fix threadsafe conversion bug
+ header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
+ 1.13 threadsafe
+ 1.12 const qualifiers in the API
+ 1.11 Support installable IDCT, colorspace conversion routines
+ 1.10 Fixes for 64-bit (don't use "unsigned long")
+ optimized upsampling by Fabian "ryg" Giesen
+ 1.09 Fix format-conversion for PSD code (bad global variables!)
+ 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz
+ 1.07 attempt to fix C++ warning/errors again
+ 1.06 attempt to fix C++ warning/errors again
+ 1.05 fix TGA loading to return correct *comp and use good luminance calc
+ 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free
+ 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR
+ 1.02 support for (subset of) HDR files, float interface for preferred access to them
+ 1.01 fix bug: possible bug in handling right-side up bmps... not sure
+ fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
+ 1.00 interface to zlib that skips zlib header
+ 0.99 correct handling of alpha in palette
+ 0.98 TGA loader by lonesock; dynamically add loaders (untested)
+ 0.97 jpeg errors on too large a file; also catch another malloc failure
+ 0.96 fix detection of invalid v value - particleman@mollyrocket forum
+ 0.95 during header scan, seek to markers in case of padding
+ 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same
+ 0.93 handle jpegtran output; verbose errors
+ 0.92 read 4,8,16,24,32-bit BMP files of several formats
+ 0.91 output 24-bit Windows 3.0 BMP files
+ 0.90 fix a few more warnings; bump version number to approach 1.0
+ 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd
+ 0.60 fix compiling as c++
+ 0.59 fix warnings: merge Dave Moore's -Wall fixes
+ 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian
+ 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
+ 0.56 fix bug: zlib uncompressed mode len vs. nlen
+ 0.55 fix bug: restart_interval not initialized to 0
+ 0.54 allow NULL for 'int *comp'
+ 0.53 fix bug in png 3->4; speedup png decoding
+ 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments
+ 0.51 obey req_comp requests, 1-component jpegs return as 1-component,
+ on 'test' only check type, not whether we support this variant
+ 0.50 (2006-11-19)
+ first released version
+*/
+
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
diff --git a/code/src/stb_image_write.h b/code/src/stb_image_write.h
new file mode 100644
index 0000000..15a6c4d
--- /dev/null
+++ b/code/src/stb_image_write.h
@@ -0,0 +1,1724 @@
+/* stb_image_write - v1.16 - public domain - http://nothings.org/stb
+ writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015
+ no warranty implied; use at your own risk
+
+ Before #including,
+
+ #define STB_IMAGE_WRITE_IMPLEMENTATION
+
+ in the file that you want to have the implementation.
+
+ Will probably not work correctly with strict-aliasing optimizations.
+
+ABOUT:
+
+ This header file is a library for writing images to C stdio or a callback.
+
+ The PNG output is not optimal; it is 20-50% larger than the file
+ written by a decent optimizing implementation; though providing a custom
+ zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that.
+ This library is designed for source code compactness and simplicity,
+ not optimal image file size or run-time performance.
+
+BUILDING:
+
+ You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h.
+ You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace
+ malloc,realloc,free.
+ You can #define STBIW_MEMMOVE() to replace memmove()
+ You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function
+ for PNG compression (instead of the builtin one), it must have the following signature:
+ unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality);
+ The returned data will be freed with STBIW_FREE() (free() by default),
+ so it must be heap allocated with STBIW_MALLOC() (malloc() by default),
+
+UNICODE:
+
+ If compiling for Windows and you wish to use Unicode filenames, compile
+ with
+ #define STBIW_WINDOWS_UTF8
+ and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert
+ Windows wchar_t filenames to utf8.
+
+USAGE:
+
+ There are five functions, one for each image file format:
+
+ int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+ int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+ int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+ int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality);
+ int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
+
+ void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically
+
+ There are also five equivalent functions that use an arbitrary write function. You are
+ expected to open/close your file-equivalent before and after calling these:
+
+ int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes);
+ int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
+ int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
+ int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
+ int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);
+
+ where the callback is:
+ void stbi_write_func(void *context, void *data, int size);
+
+ You can configure it with these global variables:
+ int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE
+ int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression
+ int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode
+
+
+ You can define STBI_WRITE_NO_STDIO to disable the file variant of these
+ functions, so the library will not use stdio.h at all. However, this will
+ also disable HDR writing, because it requires stdio for formatted output.
+
+ Each function returns 0 on failure and non-0 on success.
+
+ The functions create an image file defined by the parameters. The image
+ is a rectangle of pixels stored from left-to-right, top-to-bottom.
+ Each pixel contains 'comp' channels of data stored interleaved with 8-bits
+ per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
+ monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
+ The *data pointer points to the first byte of the top-left-most pixel.
+ For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
+ a row of pixels to the first byte of the next row of pixels.
+
+ PNG creates output files with the same number of components as the input.
+ The BMP format expands Y to RGB in the file format and does not
+ output alpha.
+
+ PNG supports writing rectangles of data even when the bytes storing rows of
+ data are not consecutive in memory (e.g. sub-rectangles of a larger image),
+ by supplying the stride between the beginning of adjacent rows. The other
+ formats do not. (Thus you cannot write a native-format BMP through the BMP
+ writer, both because it is in BGR order and because it may have padding
+ at the end of the line.)
+
+ PNG allows you to set the deflate compression level by setting the global
+ variable 'stbi_write_png_compression_level' (it defaults to 8).
+
+ HDR expects linear float data. Since the format is always 32-bit rgb(e)
+ data, alpha (if provided) is discarded, and for monochrome data it is
+ replicated across all three channels.
+
+ TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed
+ data, set the global variable 'stbi_write_tga_with_rle' to 0.
+
+ JPEG does ignore alpha channels in input data; quality is between 1 and 100.
+ Higher quality looks better but results in a bigger image.
+ JPEG baseline (no JPEG progressive).
+
+CREDITS:
+
+
+ Sean Barrett - PNG/BMP/TGA
+ Baldur Karlsson - HDR
+ Jean-Sebastien Guay - TGA monochrome
+ Tim Kelsey - misc enhancements
+ Alan Hickman - TGA RLE
+ Emmanuel Julien - initial file IO callback implementation
+ Jon Olick - original jo_jpeg.cpp code
+ Daniel Gibson - integrate JPEG, allow external zlib
+ Aarni Koskela - allow choosing PNG filter
+
+ bugfixes:
+ github:Chribba
+ Guillaume Chereau
+ github:jry2
+ github:romigrou
+ Sergio Gonzalez
+ Jonas Karlsson
+ Filip Wasil
+ Thatcher Ulrich
+ github:poppolopoppo
+ Patrick Boettcher
+ github:xeekworx
+ Cap Petschulat
+ Simon Rodriguez
+ Ivan Tikhonov
+ github:ignotion
+ Adam Schackart
+ Andrew Kensler
+
+LICENSE
+
+ See end of file for license information.
+
+*/
+
+#ifndef INCLUDE_STB_IMAGE_WRITE_H
+#define INCLUDE_STB_IMAGE_WRITE_H
+
+#include <stdlib.h>
+
+// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline'
+#ifndef STBIWDEF
+#ifdef STB_IMAGE_WRITE_STATIC
+#define STBIWDEF static
+#else
+#ifdef __cplusplus
+#define STBIWDEF extern "C"
+#else
+#define STBIWDEF extern
+#endif
+#endif
+#endif
+
+#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations
+STBIWDEF int stbi_write_tga_with_rle;
+STBIWDEF int stbi_write_png_compression_level;
+STBIWDEF int stbi_write_force_png_filter;
+#endif
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
+STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality);
+
+#ifdef STBIW_WINDOWS_UTF8
+STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
+#endif
+#endif
+
+typedef void stbi_write_func(void *context, void *data, int size);
+
+STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes);
+STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
+STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
+STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
+STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);
+
+STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
+
+#endif//INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef STB_IMAGE_WRITE_IMPLEMENTATION
+
+#ifdef _WIN32
+ #ifndef _CRT_SECURE_NO_WARNINGS
+ #define _CRT_SECURE_NO_WARNINGS
+ #endif
+ #ifndef _CRT_NONSTDC_NO_DEPRECATE
+ #define _CRT_NONSTDC_NO_DEPRECATE
+ #endif
+#endif
+
+#ifndef STBI_WRITE_NO_STDIO
+#include <stdio.h>
+#endif // STBI_WRITE_NO_STDIO
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED))
+// ok
+#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED)
+// ok
+#else
+#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)."
+#endif
+
+#ifndef STBIW_MALLOC
+#define STBIW_MALLOC(sz) malloc(sz)
+#define STBIW_REALLOC(p,newsz) realloc(p,newsz)
+#define STBIW_FREE(p) free(p)
+#endif
+
+#ifndef STBIW_REALLOC_SIZED
+#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)
+#endif
+
+
+#ifndef STBIW_MEMMOVE
+#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)
+#endif
+
+
+#ifndef STBIW_ASSERT
+#include <assert.h>
+#define STBIW_ASSERT(x) assert(x)
+#endif
+
+#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)
+
+#ifdef STB_IMAGE_WRITE_STATIC
+static int stbi_write_png_compression_level = 8;
+static int stbi_write_tga_with_rle = 1;
+static int stbi_write_force_png_filter = -1;
+#else
+int stbi_write_png_compression_level = 8;
+int stbi_write_tga_with_rle = 1;
+int stbi_write_force_png_filter = -1;
+#endif
+
+static int stbi__flip_vertically_on_write = 0;
+
+STBIWDEF void stbi_flip_vertically_on_write(int flag)
+{
+ stbi__flip_vertically_on_write = flag;
+}
+
+typedef struct
+{
+ stbi_write_func *func;
+ void *context;
+ unsigned char buffer[64];
+ int buf_used;
+} stbi__write_context;
+
+// initialize a callback-based context
+static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context)
+{
+ s->func = c;
+ s->context = context;
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+
+static void stbi__stdio_write(void *context, void *data, int size)
+{
+ fwrite(data,1,size,(FILE*) context);
+}
+
+#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)
+#ifdef __cplusplus
+#define STBIW_EXTERN extern "C"
+#else
+#define STBIW_EXTERN extern
+#endif
+STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
+STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
+
+STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
+{
+ return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbiw__fopen(char const *filename, char const *mode)
+{
+ FILE *f;
+#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)
+ wchar_t wMode[64];
+ wchar_t wFilename[1024];
+ if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
+ return 0;
+
+ if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
+ return 0;
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+ if (0 != _wfopen_s(&f, wFilename, wMode))
+ f = 0;
+#else
+ f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+ if (0 != fopen_s(&f, filename, mode))
+ f=0;
+#else
+ f = fopen(filename, mode);
+#endif
+ return f;
+}
+
+static int stbi__start_write_file(stbi__write_context *s, const char *filename)
+{
+ FILE *f = stbiw__fopen(filename, "wb");
+ stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f);
+ return f != NULL;
+}
+
+static void stbi__end_write_file(stbi__write_context *s)
+{
+ fclose((FILE *)s->context);
+}
+
+#endif // !STBI_WRITE_NO_STDIO
+
+typedef unsigned int stbiw_uint32;
+typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
+
+static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)
+{
+ while (*fmt) {
+ switch (*fmt++) {
+ case ' ': break;
+ case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int));
+ s->func(s->context,&x,1);
+ break; }
+ case '2': { int x = va_arg(v,int);
+ unsigned char b[2];
+ b[0] = STBIW_UCHAR(x);
+ b[1] = STBIW_UCHAR(x>>8);
+ s->func(s->context,b,2);
+ break; }
+ case '4': { stbiw_uint32 x = va_arg(v,int);
+ unsigned char b[4];
+ b[0]=STBIW_UCHAR(x);
+ b[1]=STBIW_UCHAR(x>>8);
+ b[2]=STBIW_UCHAR(x>>16);
+ b[3]=STBIW_UCHAR(x>>24);
+ s->func(s->context,b,4);
+ break; }
+ default:
+ STBIW_ASSERT(0);
+ return;
+ }
+ }
+}
+
+static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)
+{
+ va_list v;
+ va_start(v, fmt);
+ stbiw__writefv(s, fmt, v);
+ va_end(v);
+}
+
+static void stbiw__write_flush(stbi__write_context *s)
+{
+ if (s->buf_used) {
+ s->func(s->context, &s->buffer, s->buf_used);
+ s->buf_used = 0;
+ }
+}
+
+static void stbiw__putc(stbi__write_context *s, unsigned char c)
+{
+ s->func(s->context, &c, 1);
+}
+
+static void stbiw__write1(stbi__write_context *s, unsigned char a)
+{
+ if ((size_t)s->buf_used + 1 > sizeof(s->buffer))
+ stbiw__write_flush(s);
+ s->buffer[s->buf_used++] = a;
+}
+
+static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)
+{
+ int n;
+ if ((size_t)s->buf_used + 3 > sizeof(s->buffer))
+ stbiw__write_flush(s);
+ n = s->buf_used;
+ s->buf_used = n+3;
+ s->buffer[n+0] = a;
+ s->buffer[n+1] = b;
+ s->buffer[n+2] = c;
+}
+
+static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)
+{
+ unsigned char bg[3] = { 255, 0, 255}, px[3];
+ int k;
+
+ if (write_alpha < 0)
+ stbiw__write1(s, d[comp - 1]);
+
+ switch (comp) {
+ case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case
+ case 1:
+ if (expand_mono)
+ stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp
+ else
+ stbiw__write1(s, d[0]); // monochrome TGA
+ break;
+ case 4:
+ if (!write_alpha) {
+ // composite against pink background
+ for (k = 0; k < 3; ++k)
+ px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;
+ stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);
+ break;
+ }
+ /* FALLTHROUGH */
+ case 3:
+ stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);
+ break;
+ }
+ if (write_alpha > 0)
+ stbiw__write1(s, d[comp - 1]);
+}
+
+static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)
+{
+ stbiw_uint32 zero = 0;
+ int i,j, j_end;
+
+ if (y <= 0)
+ return;
+
+ if (stbi__flip_vertically_on_write)
+ vdir *= -1;
+
+ if (vdir < 0) {
+ j_end = -1; j = y-1;
+ } else {
+ j_end = y; j = 0;
+ }
+
+ for (; j != j_end; j += vdir) {
+ for (i=0; i < x; ++i) {
+ unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
+ stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d);
+ }
+ stbiw__write_flush(s);
+ s->func(s->context, &zero, scanline_pad);
+ }
+}
+
+static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)
+{
+ if (y < 0 || x < 0) {
+ return 0;
+ } else {
+ va_list v;
+ va_start(v, fmt);
+ stbiw__writefv(s, fmt, v);
+ va_end(v);
+ stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono);
+ return 1;
+ }
+}
+
+static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)
+{
+ if (comp != 4) {
+ // write RGB bitmap
+ int pad = (-x*3) & 3;
+ return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad,
+ "11 4 22 4" "4 44 22 444444",
+ 'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header
+ 40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header
+ } else {
+ // RGBA bitmaps need a v4 header
+ // use BI_BITFIELDS mode with 32bpp and alpha mask
+ // (straight BI_RGB with alpha mask doesn't work in most readers)
+ return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0,
+ "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444",
+ 'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header
+ 108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header
+ }
+}
+
+STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
+{
+ stbi__write_context s = { };
+ stbi__start_write_callbacks(&s, func, context);
+ return stbi_write_bmp_core(&s, x, y, comp, data);
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
+{
+ stbi__write_context s = { };
+ if (stbi__start_write_file(&s,filename)) {
+ int r = stbi_write_bmp_core(&s, x, y, comp, data);
+ stbi__end_write_file(&s);
+ return r;
+ } else
+ return 0;
+}
+#endif //!STBI_WRITE_NO_STDIO
+
+static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)
+{
+ int has_alpha = (comp == 2 || comp == 4);
+ int colorbytes = has_alpha ? comp-1 : comp;
+ int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3
+
+ if (y < 0 || x < 0)
+ return 0;
+
+ if (!stbi_write_tga_with_rle) {
+ return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0,
+ "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8);
+ } else {
+ int i,j,k;
+ int jend, jdir;
+
+ stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8);
+
+ if (stbi__flip_vertically_on_write) {
+ j = 0;
+ jend = y;
+ jdir = 1;
+ } else {
+ j = y-1;
+ jend = -1;
+ jdir = -1;
+ }
+ for (; j != jend; j += jdir) {
+ unsigned char *row = (unsigned char *) data + j * x * comp;
+ int len;
+
+ for (i = 0; i < x; i += len) {
+ unsigned char *begin = row + i * comp;
+ int diff = 1;
+ len = 1;
+
+ if (i < x - 1) {
+ ++len;
+ diff = memcmp(begin, row + (i + 1) * comp, comp);
+ if (diff) {
+ const unsigned char *prev = begin;
+ for (k = i + 2; k < x && len < 128; ++k) {
+ if (memcmp(prev, row + k * comp, comp)) {
+ prev += comp;
+ ++len;
+ } else {
+ --len;
+ break;
+ }
+ }
+ } else {
+ for (k = i + 2; k < x && len < 128; ++k) {
+ if (!memcmp(begin, row + k * comp, comp)) {
+ ++len;
+ } else {
+ break;
+ }
+ }
+ }
+ }
+
+ if (diff) {
+ unsigned char header = STBIW_UCHAR(len - 1);
+ stbiw__write1(s, header);
+ for (k = 0; k < len; ++k) {
+ stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp);
+ }
+ } else {
+ unsigned char header = STBIW_UCHAR(len - 129);
+ stbiw__write1(s, header);
+ stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin);
+ }
+ }
+ }
+ stbiw__write_flush(s);
+ }
+ return 1;
+}
+
+STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
+{
+ stbi__write_context s = { };
+ stbi__start_write_callbacks(&s, func, context);
+ return stbi_write_tga_core(&s, x, y, comp, (void *) data);
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
+{
+ stbi__write_context s = { };
+ if (stbi__start_write_file(&s,filename)) {
+ int r = stbi_write_tga_core(&s, x, y, comp, (void *) data);
+ stbi__end_write_file(&s);
+ return r;
+ } else
+ return 0;
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR writer
+// by Baldur Karlsson
+
+#define stbiw__max(a, b) ((a) > (b) ? (a) : (b))
+
+#ifndef STBI_WRITE_NO_STDIO
+
+static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
+{
+ int exponent;
+ float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));
+
+ if (maxcomp < 1e-32f) {
+ rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
+ } else {
+ float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp;
+
+ rgbe[0] = (unsigned char)(linear[0] * normalize);
+ rgbe[1] = (unsigned char)(linear[1] * normalize);
+ rgbe[2] = (unsigned char)(linear[2] * normalize);
+ rgbe[3] = (unsigned char)(exponent + 128);
+ }
+}
+
+static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
+{
+ unsigned char lengthbyte = STBIW_UCHAR(length+128);
+ STBIW_ASSERT(length+128 <= 255);
+ s->func(s->context, &lengthbyte, 1);
+ s->func(s->context, &databyte, 1);
+}
+
+static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
+{
+ unsigned char lengthbyte = STBIW_UCHAR(length);
+ STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
+ s->func(s->context, &lengthbyte, 1);
+ s->func(s->context, data, length);
+}
+
+static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)
+{
+ unsigned char scanlineheader[4] = { 2, 2, 0, 0 };
+ unsigned char rgbe[4];
+ float linear[3];
+ int x;
+
+ scanlineheader[2] = (width&0xff00)>>8;
+ scanlineheader[3] = (width&0x00ff);
+
+ /* skip RLE for images too small or large */
+ if (width < 8 || width >= 32768) {
+ for (x=0; x < width; x++) {
+ switch (ncomp) {
+ case 4: /* fallthrough */
+ case 3: linear[2] = scanline[x*ncomp + 2];
+ linear[1] = scanline[x*ncomp + 1];
+ linear[0] = scanline[x*ncomp + 0];
+ break;
+ default:
+ linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];
+ break;
+ }
+ stbiw__linear_to_rgbe(rgbe, linear);
+ s->func(s->context, rgbe, 4);
+ }
+ } else {
+ int c,r;
+ /* encode into scratch buffer */
+ for (x=0; x < width; x++) {
+ switch(ncomp) {
+ case 4: /* fallthrough */
+ case 3: linear[2] = scanline[x*ncomp + 2];
+ linear[1] = scanline[x*ncomp + 1];
+ linear[0] = scanline[x*ncomp + 0];
+ break;
+ default:
+ linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];
+ break;
+ }
+ stbiw__linear_to_rgbe(rgbe, linear);
+ scratch[x + width*0] = rgbe[0];
+ scratch[x + width*1] = rgbe[1];
+ scratch[x + width*2] = rgbe[2];
+ scratch[x + width*3] = rgbe[3];
+ }
+
+ s->func(s->context, scanlineheader, 4);
+
+ /* RLE each component separately */
+ for (c=0; c < 4; c++) {
+ unsigned char *comp = &scratch[width*c];
+
+ x = 0;
+ while (x < width) {
+ // find first run
+ r = x;
+ while (r+2 < width) {
+ if (comp[r] == comp[r+1] && comp[r] == comp[r+2])
+ break;
+ ++r;
+ }
+ if (r+2 >= width)
+ r = width;
+ // dump up to first run
+ while (x < r) {
+ int len = r-x;
+ if (len > 128) len = 128;
+ stbiw__write_dump_data(s, len, &comp[x]);
+ x += len;
+ }
+ // if there's a run, output it
+ if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd
+ // find next byte after run
+ while (r < width && comp[r] == comp[x])
+ ++r;
+ // output run up to r
+ while (x < r) {
+ int len = r-x;
+ if (len > 127) len = 127;
+ stbiw__write_run_data(s, len, comp[x]);
+ x += len;
+ }
+ }
+ }
+ }
+ }
+}
+
+static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
+{
+ if (y <= 0 || x <= 0 || data == NULL)
+ return 0;
+ else {
+ // Each component is stored separately. Allocate scratch space for full output scanline.
+ unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
+ int i, len;
+ char buffer[128];
+ char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
+ s->func(s->context, header, sizeof(header)-1);
+
+#ifdef __STDC_LIB_EXT1__
+ len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
+#else
+ len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
+#endif
+ s->func(s->context, buffer, len);
+
+ for(i=0; i < y; i++)
+ stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i));
+ STBIW_FREE(scratch);
+ return 1;
+ }
+}
+
+STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)
+{
+ stbi__write_context s = { };
+ stbi__start_write_callbacks(&s, func, context);
+ return stbi_write_hdr_core(&s, x, y, comp, (float *) data);
+}
+
+STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
+{
+ stbi__write_context s = { };
+ if (stbi__start_write_file(&s,filename)) {
+ int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data);
+ stbi__end_write_file(&s);
+ return r;
+ } else
+ return 0;
+}
+#endif // STBI_WRITE_NO_STDIO
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PNG writer
+//
+
+#ifndef STBIW_ZLIB_COMPRESS
+// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size()
+#define stbiw__sbraw(a) ((int *) (void *) (a) - 2)
+#define stbiw__sbm(a) stbiw__sbraw(a)[0]
+#define stbiw__sbn(a) stbiw__sbraw(a)[1]
+
+#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))
+#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)
+#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))
+
+#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))
+#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0)
+#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)
+
+static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
+{
+ int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
+ void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
+ STBIW_ASSERT(p);
+ if (p) {
+ if (!*arr) ((int *) p)[1] = 0;
+ *arr = (void *) ((int *) p + 2);
+ stbiw__sbm(*arr) = m;
+ }
+ return *arr;
+}
+
+static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
+{
+ while (*bitcount >= 8) {
+ stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));
+ *bitbuffer >>= 8;
+ *bitcount -= 8;
+ }
+ return data;
+}
+
+static int stbiw__zlib_bitrev(int code, int codebits)
+{
+ int res=0;
+ while (codebits--) {
+ res = (res << 1) | (code & 1);
+ code >>= 1;
+ }
+ return res;
+}
+
+static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)
+{
+ int i;
+ for (i=0; i < limit && i < 258; ++i)
+ if (a[i] != b[i]) break;
+ return i;
+}
+
+static unsigned int stbiw__zhash(unsigned char *data)
+{
+ stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
+ hash ^= hash << 3;
+ hash += hash >> 5;
+ hash ^= hash << 4;
+ hash += hash >> 17;
+ hash ^= hash << 25;
+ hash += hash >> 6;
+ return hash;
+}
+
+#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))
+#define stbiw__zlib_add(code,codebits) \
+ (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush())
+#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)
+// default huffman tables
+#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8)
+#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9)
+#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7)
+#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8)
+#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))
+#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))
+
+#define stbiw__ZHASH 16384
+
+#endif // STBIW_ZLIB_COMPRESS
+
+STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
+{
+#ifdef STBIW_ZLIB_COMPRESS
+ // user provided a zlib compress implementation, use that
+ return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
+#else // use builtin
+ static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
+ static unsigned char lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 };
+ static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
+ static unsigned char disteb[] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 };
+ unsigned int bitbuf=0;
+ int i,j, bitcount=0;
+ unsigned char *out = NULL;
+ unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**));
+ if (hash_table == NULL)
+ return NULL;
+ if (quality < 5) quality = 5;
+
+ stbiw__sbpush(out, 0x78); // DEFLATE 32K window
+ stbiw__sbpush(out, 0x5e); // FLEVEL = 1
+ stbiw__zlib_add(1,1); // BFINAL = 1
+ stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman
+
+ for (i=0; i < stbiw__ZHASH; ++i)
+ hash_table[i] = NULL;
+
+ i=0;
+ while (i < data_len-3) {
+ // hash next 3 bytes of data to be compressed
+ int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3;
+ unsigned char *bestloc = 0;
+ unsigned char **hlist = hash_table[h];
+ int n = stbiw__sbcount(hlist);
+ for (j=0; j < n; ++j) {
+ if (hlist[j]-data > i-32768) { // if entry lies within window
+ int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i);
+ if (d >= best) { best=d; bestloc=hlist[j]; }
+ }
+ }
+ // when hash table entry is too long, delete half the entries
+ if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) {
+ STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
+ stbiw__sbn(hash_table[h]) = quality;
+ }
+ stbiw__sbpush(hash_table[h],data+i);
+
+ if (bestloc) {
+ // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
+ h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1);
+ hlist = hash_table[h];
+ n = stbiw__sbcount(hlist);
+ for (j=0; j < n; ++j) {
+ if (hlist[j]-data > i-32767) {
+ int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1);
+ if (e > best) { // if next match is better, bail on current match
+ bestloc = NULL;
+ break;
+ }
+ }
+ }
+ }
+
+ if (bestloc) {
+ int d = (int) (data+i - bestloc); // distance back
+ STBIW_ASSERT(d <= 32767 && best <= 258);
+ for (j=0; best > lengthc[j+1]-1; ++j);
+ stbiw__zlib_huff(j+257);
+ if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]);
+ for (j=0; d > distc[j+1]-1; ++j);
+ stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5);
+ if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]);
+ i += best;
+ } else {
+ stbiw__zlib_huffb(data[i]);
+ ++i;
+ }
+ }
+ // write out final bytes
+ for (;i < data_len; ++i)
+ stbiw__zlib_huffb(data[i]);
+ stbiw__zlib_huff(256); // end of block
+ // pad with 0 bits to byte boundary
+ while (bitcount)
+ stbiw__zlib_add(0,1);
+
+ for (i=0; i < stbiw__ZHASH; ++i)
+ (void) stbiw__sbfree(hash_table[i]);
+ STBIW_FREE(hash_table);
+
+ // store uncompressed instead if compression was worse
+ if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) {
+ stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1
+ for (j = 0; j < data_len;) {
+ int blocklen = data_len - j;
+ if (blocklen > 32767) blocklen = 32767;
+ stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression
+ stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN
+ stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8));
+ stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN
+ stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8));
+ memcpy(out+stbiw__sbn(out), data+j, blocklen);
+ stbiw__sbn(out) += blocklen;
+ j += blocklen;
+ }
+ }
+
+ {
+ // compute adler32 on input
+ unsigned int s1=1, s2=0;
+ int blocklen = (int) (data_len % 5552);
+ j=0;
+ while (j < data_len) {
+ for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; }
+ s1 %= 65521; s2 %= 65521;
+ j += blocklen;
+ blocklen = 5552;
+ }
+ stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8));
+ stbiw__sbpush(out, STBIW_UCHAR(s2));
+ stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8));
+ stbiw__sbpush(out, STBIW_UCHAR(s1));
+ }
+ *out_len = stbiw__sbn(out);
+ // make returned pointer freeable
+ STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len);
+ return (unsigned char *) stbiw__sbraw(out);
+#endif // STBIW_ZLIB_COMPRESS
+}
+
+static unsigned int stbiw__crc32(unsigned char *buffer, int len)
+{
+#ifdef STBIW_CRC32
+ return STBIW_CRC32(buffer, len);
+#else
+ static unsigned int crc_table[256] =
+ {
+ 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+ 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+ 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+ 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+ 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+ 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+ 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+ 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+ 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+ 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+ 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+ 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+ 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+ 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+ 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+ 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+ 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+ 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+ 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+ 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+ 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+ 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+ 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+ 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+ 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+ 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+ 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+ 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+ 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+ 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+ 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+ 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+ };
+
+ unsigned int crc = ~0u;
+ int i;
+ for (i=0; i < len; ++i)
+ crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
+ return ~crc;
+#endif
+}
+
+#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)
+#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));
+#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])
+
+static void stbiw__wpcrc(unsigned char **data, int len)
+{
+ unsigned int crc = stbiw__crc32(*data - len - 4, len+4);
+ stbiw__wp32(*data, crc);
+}
+
+static unsigned char stbiw__paeth(int a, int b, int c)
+{
+ int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
+ if (pa <= pb && pa <= pc) return STBIW_UCHAR(a);
+ if (pb <= pc) return STBIW_UCHAR(b);
+ return STBIW_UCHAR(c);
+}
+
+// @OPTIMIZE: provide an option that always forces left-predict or paeth predict
+static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer)
+{
+ static int mapping[] = { 0,1,2,3,4 };
+ static int firstmap[] = { 0,1,0,5,6 };
+ int *mymap = (y != 0) ? mapping : firstmap;
+ int i;
+ int type = mymap[filter_type];
+ unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y);
+ int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes;
+
+ if (type==0) {
+ memcpy(line_buffer, z, width*n);
+ return;
+ }
+
+ // first loop isn't optimized since it's just one pixel
+ for (i = 0; i < n; ++i) {
+ switch (type) {
+ case 1: line_buffer[i] = z[i]; break;
+ case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break;
+ case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break;
+ case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break;
+ case 5: line_buffer[i] = z[i]; break;
+ case 6: line_buffer[i] = z[i]; break;
+ }
+ }
+ switch (type) {
+ case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break;
+ case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break;
+ case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break;
+ case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break;
+ case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break;
+ case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break;
+ }
+}
+
+STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
+{
+ int force_filter = stbi_write_force_png_filter;
+ int ctype[5] = { -1, 0, 4, 2, 6 };
+ unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
+ unsigned char *out,*o, *filt, *zlib;
+ signed char *line_buffer;
+ int j,zlen;
+
+ if (stride_bytes == 0)
+ stride_bytes = x * n;
+
+ if (force_filter >= 5) {
+ force_filter = -1;
+ }
+
+ filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0;
+ line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; }
+ for (j=0; j < y; ++j) {
+ int filter_type;
+ if (force_filter > -1) {
+ filter_type = force_filter;
+ stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer);
+ } else { // Estimate the best filter by running through all of them:
+ int best_filter = 0, best_filter_val = 0x7fffffff, est, i;
+ for (filter_type = 0; filter_type < 5; filter_type++) {
+ stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer);
+
+ // Estimate the entropy of the line using this filter; the less, the better.
+ est = 0;
+ for (i = 0; i < x*n; ++i) {
+ est += abs((signed char) line_buffer[i]);
+ }
+ if (est < best_filter_val) {
+ best_filter_val = est;
+ best_filter = filter_type;
+ }
+ }
+ if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it
+ stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer);
+ filter_type = best_filter;
+ }
+ }
+ // when we get here, filter_type contains the filter type, and line_buffer contains the data
+ filt[j*(x*n+1)] = (unsigned char) filter_type;
+ STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n);
+ }
+ STBIW_FREE(line_buffer);
+ zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level);
+ STBIW_FREE(filt);
+ if (!zlib) return 0;
+
+ // each tag requires 12 bytes of overhead
+ out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12);
+ if (!out) return 0;
+ *out_len = 8 + 12+13 + 12+zlen + 12;
+
+ o=out;
+ STBIW_MEMMOVE(o,sig,8); o+= 8;
+ stbiw__wp32(o, 13); // header length
+ stbiw__wptag(o, "IHDR");
+ stbiw__wp32(o, x);
+ stbiw__wp32(o, y);
+ *o++ = 8;
+ *o++ = STBIW_UCHAR(ctype[n]);
+ *o++ = 0;
+ *o++ = 0;
+ *o++ = 0;
+ stbiw__wpcrc(&o,13);
+
+ stbiw__wp32(o, zlen);
+ stbiw__wptag(o, "IDAT");
+ STBIW_MEMMOVE(o, zlib, zlen);
+ o += zlen;
+ STBIW_FREE(zlib);
+ stbiw__wpcrc(&o, zlen);
+
+ stbiw__wp32(o,0);
+ stbiw__wptag(o, "IEND");
+ stbiw__wpcrc(&o,0);
+
+ STBIW_ASSERT(o == out + *out_len);
+
+ return out;
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
+{
+ FILE *f;
+ int len;
+ unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
+ if (png == NULL) return 0;
+
+ f = stbiw__fopen(filename, "wb");
+ if (!f) { STBIW_FREE(png); return 0; }
+ fwrite(png, 1, len, f);
+ fclose(f);
+ STBIW_FREE(png);
+ return 1;
+}
+#endif
+
+STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
+{
+ int len;
+ unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
+ if (png == NULL) return 0;
+ func(context, png, len);
+ STBIW_FREE(png);
+ return 1;
+}
+
+
+/* ***************************************************************************
+ *
+ * JPEG writer
+ *
+ * This is based on Jon Olick's jo_jpeg.cpp:
+ * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html
+ */
+
+static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18,
+ 24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 };
+
+static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {
+ int bitBuf = *bitBufP, bitCnt = *bitCntP;
+ bitCnt += bs[1];
+ bitBuf |= bs[0] << (24 - bitCnt);
+ while(bitCnt >= 8) {
+ unsigned char c = (bitBuf >> 16) & 255;
+ stbiw__putc(s, c);
+ if(c == 255) {
+ stbiw__putc(s, 0);
+ }
+ bitBuf <<= 8;
+ bitCnt -= 8;
+ }
+ *bitBufP = bitBuf;
+ *bitCntP = bitCnt;
+}
+
+static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {
+ float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p;
+ float z1, z2, z3, z4, z5, z11, z13;
+
+ float tmp0 = d0 + d7;
+ float tmp7 = d0 - d7;
+ float tmp1 = d1 + d6;
+ float tmp6 = d1 - d6;
+ float tmp2 = d2 + d5;
+ float tmp5 = d2 - d5;
+ float tmp3 = d3 + d4;
+ float tmp4 = d3 - d4;
+
+ // Even part
+ float tmp10 = tmp0 + tmp3; // phase 2
+ float tmp13 = tmp0 - tmp3;
+ float tmp11 = tmp1 + tmp2;
+ float tmp12 = tmp1 - tmp2;
+
+ d0 = tmp10 + tmp11; // phase 3
+ d4 = tmp10 - tmp11;
+
+ z1 = (tmp12 + tmp13) * 0.707106781f; // c4
+ d2 = tmp13 + z1; // phase 5
+ d6 = tmp13 - z1;
+
+ // Odd part
+ tmp10 = tmp4 + tmp5; // phase 2
+ tmp11 = tmp5 + tmp6;
+ tmp12 = tmp6 + tmp7;
+
+ // The rotator is modified from fig 4-8 to avoid extra negations.
+ z5 = (tmp10 - tmp12) * 0.382683433f; // c6
+ z2 = tmp10 * 0.541196100f + z5; // c2-c6
+ z4 = tmp12 * 1.306562965f + z5; // c2+c6
+ z3 = tmp11 * 0.707106781f; // c4
+
+ z11 = tmp7 + z3; // phase 5
+ z13 = tmp7 - z3;
+
+ *d5p = z13 + z2; // phase 6
+ *d3p = z13 - z2;
+ *d1p = z11 + z4;
+ *d7p = z11 - z4;
+
+ *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6;
+}
+
+static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
+ int tmp1 = val < 0 ? -val : val;
+ val = val < 0 ? val-1 : val;
+ bits[1] = 1;
+ while(tmp1 >>= 1) {
+ ++bits[1];
+ }
+ bits[0] = val & ((1<<bits[1])-1);
+}
+
+static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, int du_stride, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {
+ const unsigned short EOB[2] = { HTAC[0x00][0], HTAC[0x00][1] };
+ const unsigned short M16zeroes[2] = { HTAC[0xF0][0], HTAC[0xF0][1] };
+ int dataOff, i, j, n, diff, end0pos, x, y;
+ int DU[64];
+
+ // DCT rows
+ for(dataOff=0, n=du_stride*8; dataOff<n; dataOff+=du_stride) {
+ stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+1], &CDU[dataOff+2], &CDU[dataOff+3], &CDU[dataOff+4], &CDU[dataOff+5], &CDU[dataOff+6], &CDU[dataOff+7]);
+ }
+ // DCT columns
+ for(dataOff=0; dataOff<8; ++dataOff) {
+ stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+du_stride], &CDU[dataOff+du_stride*2], &CDU[dataOff+du_stride*3], &CDU[dataOff+du_stride*4],
+ &CDU[dataOff+du_stride*5], &CDU[dataOff+du_stride*6], &CDU[dataOff+du_stride*7]);
+ }
+ // Quantize/descale/zigzag the coefficients
+ for(y = 0, j=0; y < 8; ++y) {
+ for(x = 0; x < 8; ++x,++j) {
+ float v;
+ i = y*du_stride+x;
+ v = CDU[i]*fdtbl[j];
+ // DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));
+ // ceilf() and floorf() are C99, not C89, but I /think/ they're not needed here anyway?
+ DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? v - 0.5f : v + 0.5f);
+ }
+ }
+
+ // Encode DC
+ diff = DU[0] - DC;
+ if (diff == 0) {
+ stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[0]);
+ } else {
+ unsigned short bits[2];
+ stbiw__jpg_calcBits(diff, bits);
+ stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[bits[1]]);
+ stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
+ }
+ // Encode ACs
+ end0pos = 63;
+ for(; (end0pos>0)&&(DU[end0pos]==0); --end0pos) {
+ }
+ // end0pos = first element in reverse order !=0
+ if(end0pos == 0) {
+ stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
+ return DU[0];
+ }
+ for(i = 1; i <= end0pos; ++i) {
+ int startpos = i;
+ int nrzeroes;
+ unsigned short bits[2];
+ for (; DU[i]==0 && i<=end0pos; ++i) {
+ }
+ nrzeroes = i-startpos;
+ if ( nrzeroes >= 16 ) {
+ int lng = nrzeroes>>4;
+ int nrmarker;
+ for (nrmarker=1; nrmarker <= lng; ++nrmarker)
+ stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes);
+ nrzeroes &= 15;
+ }
+ stbiw__jpg_calcBits(DU[i], bits);
+ stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]);
+ stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
+ }
+ if(end0pos != 63) {
+ stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
+ }
+ return DU[0];
+}
+
+static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {
+ // Constants that don't pollute global namespace
+ static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0};
+ static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
+ static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d};
+ static const unsigned char std_ac_luminance_values[] = {
+ 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,
+ 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,
+ 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,
+ 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
+ 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,
+ 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,
+ 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
+ };
+ static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0};
+ static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
+ static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77};
+ static const unsigned char std_ac_chrominance_values[] = {
+ 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,
+ 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,
+ 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,
+ 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
+ 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,
+ 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,
+ 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
+ };
+ // Huffman tables
+ static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}};
+ static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}};
+ static const unsigned short YAC_HT[256][2] = {
+ {10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0}
+ };
+ static const unsigned short UVAC_HT[256][2] = {
+ {0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0},
+ {1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0}
+ };
+ static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22,
+ 37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99};
+ static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,
+ 99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99};
+ static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f,
+ 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f };
+
+ int row, col, i, k, subsample;
+ float fdtbl_Y[64], fdtbl_UV[64];
+ unsigned char YTable[64], UVTable[64];
+
+ if(!data || !width || !height || comp > 4 || comp < 1) {
+ return 0;
+ }
+
+ quality = quality ? quality : 90;
+ subsample = quality <= 90 ? 1 : 0;
+ quality = quality < 1 ? 1 : quality > 100 ? 100 : quality;
+ quality = quality < 50 ? 5000 / quality : 200 - quality * 2;
+
+ for(i = 0; i < 64; ++i) {
+ int uvti, yti = (YQT[i]*quality+50)/100;
+ YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti);
+ uvti = (UVQT[i]*quality+50)/100;
+ UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti);
+ }
+
+ for(row = 0, k = 0; row < 8; ++row) {
+ for(col = 0; col < 8; ++col, ++k) {
+ fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
+ fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
+ }
+ }
+
+ // Write Headers
+ {
+ static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 };
+ static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 };
+ const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width),
+ 3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 };
+ s->func(s->context, (void*)head0, sizeof(head0));
+ s->func(s->context, (void*)YTable, sizeof(YTable));
+ stbiw__putc(s, 1);
+ s->func(s->context, UVTable, sizeof(UVTable));
+ s->func(s->context, (void*)head1, sizeof(head1));
+ s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1);
+ s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values));
+ stbiw__putc(s, 0x10); // HTYACinfo
+ s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1);
+ s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values));
+ stbiw__putc(s, 1); // HTUDCinfo
+ s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1);
+ s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values));
+ stbiw__putc(s, 0x11); // HTUACinfo
+ s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1);
+ s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values));
+ s->func(s->context, (void*)head2, sizeof(head2));
+ }
+
+ // Encode 8x8 macroblocks
+ {
+ static const unsigned short fillBits[] = {0x7F, 7};
+ int DCY=0, DCU=0, DCV=0;
+ int bitBuf=0, bitCnt=0;
+ // comp == 2 is grey+alpha (alpha is ignored)
+ int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0;
+ const unsigned char *dataR = (const unsigned char *)data;
+ const unsigned char *dataG = dataR + ofsG;
+ const unsigned char *dataB = dataR + ofsB;
+ int x, y, pos;
+ if(subsample) {
+ for(y = 0; y < height; y += 16) {
+ for(x = 0; x < width; x += 16) {
+ float Y[256], U[256], V[256];
+ for(row = y, pos = 0; row < y+16; ++row) {
+ // row >= height => use last input row
+ int clamped_row = (row < height) ? row : height - 1;
+ int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
+ for(col = x; col < x+16; ++col, ++pos) {
+ // if col >= width => use pixel from last input column
+ int p = base_p + ((col < width) ? col : (width-1))*comp;
+ float r = dataR[p], g = dataG[p], b = dataB[p];
+ Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
+ U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;
+ V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;
+ }
+ }
+ DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+ DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+ DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+ DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+
+ // subsample U,V
+ {
+ float subU[64], subV[64];
+ int yy, xx;
+ for(yy = 0, pos = 0; yy < 8; ++yy) {
+ for(xx = 0; xx < 8; ++xx, ++pos) {
+ int j = yy*32+xx*2;
+ subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f;
+ subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f;
+ }
+ }
+ DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
+ DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
+ }
+ }
+ }
+ } else {
+ for(y = 0; y < height; y += 8) {
+ for(x = 0; x < width; x += 8) {
+ float Y[64], U[64], V[64];
+ for(row = y, pos = 0; row < y+8; ++row) {
+ // row >= height => use last input row
+ int clamped_row = (row < height) ? row : height - 1;
+ int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
+ for(col = x; col < x+8; ++col, ++pos) {
+ // if col >= width => use pixel from last input column
+ int p = base_p + ((col < width) ? col : (width-1))*comp;
+ float r = dataR[p], g = dataG[p], b = dataB[p];
+ Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
+ U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;
+ V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;
+ }
+ }
+
+ DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+ DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
+ DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
+ }
+ }
+ }
+
+ // Do the bit alignment of the EOI marker
+ stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits);
+ }
+
+ // EOI
+ stbiw__putc(s, 0xFF);
+ stbiw__putc(s, 0xD9);
+
+ return 1;
+}
+
+STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)
+{
+ stbi__write_context s = { };
+ stbi__start_write_callbacks(&s, func, context);
+ return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality);
+}
+
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
+{
+ stbi__write_context s = { };
+ if (stbi__start_write_file(&s,filename)) {
+ int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
+ stbi__end_write_file(&s);
+ return r;
+ } else
+ return 0;
+}
+#endif
+
+#endif // STB_IMAGE_WRITE_IMPLEMENTATION
+
+/* Revision history
+ 1.16 (2021-07-11)
+ make Deflate code emit uncompressed blocks when it would otherwise expand
+ support writing BMPs with alpha channel
+ 1.15 (2020-07-13) unknown
+ 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels
+ 1.13
+ 1.12
+ 1.11 (2019-08-11)
+
+ 1.10 (2019-02-07)
+ support utf8 filenames in Windows; fix warnings and platform ifdefs
+ 1.09 (2018-02-11)
+ fix typo in zlib quality API, improve STB_I_W_STATIC in C++
+ 1.08 (2018-01-29)
+ add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter
+ 1.07 (2017-07-24)
+ doc fix
+ 1.06 (2017-07-23)
+ writing JPEG (using Jon Olick's code)
+ 1.05 ???
+ 1.04 (2017-03-03)
+ monochrome BMP expansion
+ 1.03 ???
+ 1.02 (2016-04-02)
+ avoid allocating large structures on the stack
+ 1.01 (2016-01-16)
+ STBIW_REALLOC_SIZED: support allocators with no realloc support
+ avoid race-condition in crc initialization
+ minor compile issues
+ 1.00 (2015-09-14)
+ installable file IO function
+ 0.99 (2015-09-13)
+ warning fixes; TGA rle support
+ 0.98 (2015-04-08)
+ added STBIW_MALLOC, STBIW_ASSERT etc
+ 0.97 (2015-01-18)
+ fixed HDR asserts, rewrote HDR rle logic
+ 0.96 (2015-01-17)
+ add HDR output
+ fix monochrome BMP
+ 0.95 (2014-08-17)
+ add monochrome TGA output
+ 0.94 (2014-05-31)
+ rename private functions to avoid conflicts with stb_image.h
+ 0.93 (2014-05-27)
+ warning fixes
+ 0.92 (2010-08-01)
+ casts to unsigned char to fix warnings
+ 0.91 (2010-07-17)
+ first public release
+ 0.90 first internal release
+*/
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
diff --git a/code/src/vec.cpp b/code/src/vec.cpp
new file mode 100644
index 0000000..f97fc8b
--- /dev/null
+++ b/code/src/vec.cpp
@@ -0,0 +1,150 @@
+
+#include <algorithm>
+#include <cmath>
+
+#include "vec.h"
+
+
+Point Origin( )
+{
+ return Point(0, 0, 0);
+}
+
+
+float distance( const Point& a, const Point& b )
+{
+ return length(a - b);
+}
+
+float distance2( const Point& a, const Point& b )
+{
+ return length2(a - b);
+}
+
+Point center( const Point& a, const Point& b )
+{
+ return Point((a.x + b.x) / 2, (a.y + b.y) / 2, (a.z + b.z) / 2);
+}
+
+
+Point min( const Point& a, const Point& b )
+{
+ return Point( std::min(a.x, b.x), std::min(a.y, b.y), std::min(a.z, b.z) );
+}
+
+Point max( const Point& a, const Point& b )
+{
+ return Point( std::max(a.x, b.x), std::max(a.y, b.y), std::max(a.z, b.z) );
+}
+
+
+Vector operator- ( const Point& a, const Point& b )
+{
+ return Vector(a.x - b.x, a.y - b.y, a.z - b.z);
+}
+
+Point operator* ( const float k, const Point& a )
+{
+ return Point(k * a.x, k * a.y, k * a.z);
+}
+
+Point operator* ( const Point& a, const float k )
+{
+ return k * a;
+}
+
+Point operator/ ( const Point& a, const float k )
+{
+ float kk= 1.f / k;
+ return kk * a;
+}
+
+Point operator+ ( const Point& a, const Point& b )
+{
+ return Point(a.x + b.x, a.y + b.y, a.z + b.z);
+}
+
+Vector operator- ( const Vector& v )
+{
+ return Vector(-v.x, -v.y, -v.z);
+}
+
+Point operator+ ( const Point& a, const Vector& v )
+{
+ return Point(a.x + v.x, a.y + v.y, a.z + v.z);
+}
+
+Point operator+ ( const Vector& v, const Point& a )
+{
+ return a + v;
+}
+
+Point operator- ( const Vector& v, const Point& a )
+{
+ return a + (-v);
+}
+
+Point operator- ( const Point& a, const Vector& v )
+{
+ return a + (-v);
+}
+
+Vector operator+ ( const Vector& u, const Vector& v )
+{
+ return Vector(u.x + v.x, u.y + v.y, u.z + v.z);
+}
+
+Vector operator- ( const Vector& u, const Vector& v )
+{
+ return Vector(u.x - v.x, u.y - v.y, u.z - v.z);
+}
+
+Vector operator* ( const float k, const Vector& v )
+{
+ return Vector(k * v.x, k * v.y, k * v.z);
+}
+
+Vector operator* ( const Vector& v, const float k )
+{
+ return k * v;
+}
+
+Vector operator* ( const Vector& a, const Vector& b )
+{
+ return Vector(a.x * b.x, a.y * b.y, a.z * b.z);
+}
+
+Vector operator/ ( const Vector& v, const float k )
+{
+ float kk= 1 / k;
+ return kk * v;
+}
+
+Vector normalize( const Vector& v )
+{
+ float kk= 1 / length(v);
+ return kk * v;
+}
+
+Vector cross( const Vector& u, const Vector& v )
+{
+ return Vector(
+ (u.y * v.z) - (u.z * v.y),
+ (u.z * v.x) - (u.x * v.z),
+ (u.x * v.y) - (u.y * v.x));
+}
+
+float dot( const Vector& u, const Vector& v )
+{
+ return u.x * v.x + u.y * v.y + u.z * v.z;
+}
+
+float length( const Vector& v )
+{
+ return std::sqrt(length2(v));
+}
+
+float length2( const Vector& v )
+{
+ return v.x * v.x + v.y * v.y + v.z * v.z;
+}
diff --git a/code/src/vec.h b/code/src/vec.h
new file mode 100644
index 0000000..3f2e5b8
--- /dev/null
+++ b/code/src/vec.h
@@ -0,0 +1,232 @@
+
+#pragma once
+
+//! \addtogroup math
+///@{
+
+//! \file
+//! operations sur points et vecteurs
+
+//! declarations anticipees.
+struct vec2;
+struct vec3;
+struct vec4;
+struct Vector;
+struct Point;
+
+//! representation d'un point 3d.
+struct Point
+{
+ //! constructeur par defaut.
+ Point( ) : x(0), y(0), z(0) {}
+ Point( const float _x, const float _y, const float _z ) : x(_x), y(_y), z(_z) {}
+
+ //! cree un point a partir des coordonnees du vecteur generique (v.x, v.y, v.z).
+ Point( const vec2& v, const float z ); // l'implementation se trouve en fin de fichier, la structure vec2 n'est pas encore connue.
+ Point( const vec3& v ); // l'implementation se trouve en fin de fichier, la structure vec3 n'est pas encore connue.
+ Point( const vec4& v ); // l'implementation se trouve en fin de fichier, la structure vec4 n'est pas encore connue.
+ //! cree un point a partir des coordonnes du vecteur (v.x, v.y, v.z).
+ explicit Point( const Vector& v ); // l'implementation se trouve en fin de fichier, la structure vector n'est pas encore connue.
+
+ //! renvoie la ieme composante du point.
+ float operator() ( const unsigned int i ) const; // l'implementation se trouve en fin de fichier
+ float& operator() ( const unsigned int i ); // l'implementation se trouve en fin de fichier
+
+ bool zero( ) const { return x == 0 && y == 0 && z == 0; }
+
+ float x, y, z;
+};
+
+//! renvoie le point origine (0, 0, 0)
+Point Origin( );
+
+//! renvoie la distance etre 2 points.
+float distance( const Point& a, const Point& b );
+//! renvoie le carre de la distance etre 2 points.
+float distance2( const Point& a, const Point& b );
+
+//! renvoie le milieu du segment ab.
+Point center( const Point& a, const Point& b );
+
+//! renvoie la plus petite composante de chaque point. x, y, z= min(a.x, b.x), min(a.y, b.y), min(a.z, b.z).
+Point min( const Point& a, const Point& b );
+//! renvoie la plus grande composante de chaque point. x, y, z= max(a.x, b.x), max(a.y, b.y), max(a.z, b.z).
+Point max( const Point& a, const Point& b );
+
+
+//! representation d'un vecteur 3d.
+struct Vector
+{
+ //! constructeur par defaut.
+ Vector( ) : x(0), y(0), z(0) {}
+ Vector( const float _x, const float _y, const float _z ) : x(_x), y(_y), z(_z) {}
+
+ //! cree le vecteur ab.
+ Vector( const Point& a, const Point& b ) : x(b.x - a.x), y(b.y - a.y), z(b.z - a.z) {}
+
+ //! cree un vecteur a partir des coordonnees du vecteur generique (v.x, v.y, v.z).
+ Vector( const vec2& v, const float z ); // l'implementation se trouve en fin de fichier, la structure vec2 n'est pas encore connue.
+ Vector( const vec3& v ); // l'implementation se trouve en fin de fichier, la structure vec3 n'est pas encore connue.
+ Vector( const vec4& v ); // l'implementation se trouve en fin de fichier, la structure vec4 n'est pas encore connue.
+ //! cree un vecteur a partir des coordonnes du point (a.x, a.y, a.z).
+ explicit Vector( const Point& a ); // l'implementation se trouve en fin de fichier.
+
+ //! renvoie la ieme composante du vecteur.
+ float operator() ( const unsigned int i ) const; // l'implementation se trouve en fin de fichier
+ float& operator() ( const unsigned int i ); // l'implementation se trouve en fin de fichier
+
+ bool zero( ) const { return x == 0 && y == 0 && z == 0; }
+
+ float x, y, z;
+};
+
+//! renvoie un vecteur unitaire / longueur == 1.
+Vector normalize( const Vector& v );
+//! renvoie le produit vectoriel de 2 vecteurs.
+Vector cross( const Vector& u, const Vector& v );
+//! renvoie le produit scalaire de 2 vecteurs.
+float dot( const Vector& u, const Vector& v );
+//! renvoie la longueur d'un vecteur.
+float length( const Vector& v );
+//! renvoie la carre de la longueur d'un vecteur.
+float length2( const Vector& v );
+
+//! renvoie le vecteur a - b.
+Vector operator- ( const Point& a, const Point& b );
+
+//! renvoie le "point" a + b.
+Point operator+ ( const Point& a, const Point& b );
+
+//! renvoie le "point" k*a;
+Point operator* ( const float k, const Point& a );
+//! renvoie le "point" a*k;
+Point operator* ( const Point& a, const float k );
+//! renvoie le "point" v/k;
+Point operator/ ( const Point& a, const float k );
+
+//! renvoie le vecteur -v.
+Vector operator- ( const Vector& v );
+
+//! renvoie le point a+v.
+Point operator+ ( const Point& a, const Vector& v );
+//! renvoie le point a+v.
+Point operator+ ( const Vector& v, const Point& a );
+//! renvoie le point a-v.
+Point operator- ( const Vector& v, const Point& a );
+//! renvoie le point a-v.
+Point operator- ( const Point& a, const Vector& v );
+//! renvoie le vecteur u+v.
+Vector operator+ ( const Vector& u, const Vector& v );
+//! renvoie le vecteur u-v.
+Vector operator- ( const Vector& u, const Vector& v );
+//! renvoie le vecteur k*u;
+Vector operator* ( const float k, const Vector& v );
+//! renvoie le vecteur k*v;
+Vector operator* ( const Vector& v, const float k );
+//! renvoie le vecteur (a.x*b.x, a.y*b.y, a.z*b.z ).
+Vector operator* ( const Vector& a, const Vector& b );
+//! renvoie le vecteur v/k;
+Vector operator/ ( const Vector& v, const float k );
+
+
+//! vecteur generique, utilitaire.
+struct vec2
+{
+ //! constructeur par defaut.
+ vec2( ) : x(0), y(0) {}
+ vec2( const float _x, const float _y ) : x(_x), y(_y) {}
+
+ //! renvoie la ieme composante du vecteur.
+ float operator() ( const unsigned int i ) const { return (&x)[i]; }
+ float& operator() ( const unsigned int i ) { return (&x)[i]; }
+
+ float x, y;
+};
+
+
+//! vecteur generique, utilitaire.
+struct vec3
+{
+ //! constructeur par defaut.
+ vec3( ) : x(0), y(0), z(0) {}
+ vec3( const float _x, const float _y, const float _z ) : x(_x), y(_y), z(_z) {}
+ //! constructeur par defaut.
+ vec3( const vec2& a, const float _z ) : x(a.x), y(a.y), z(_z) {}
+
+ //! cree un vecteur generique a partir des coordonnees du point a.
+ vec3( const Point& a ); // l'implementation se trouve en fin de fichier.
+ //! cree un vecteur generique a partir des coordonnees du vecteur v.
+ vec3( const Vector& v ); // l'implementation se trouve en fin de fichier.
+
+ //! renvoie la ieme composante du vecteur.
+ float operator() ( const unsigned int i ) const { return (&x)[i]; }
+ float& operator() ( const unsigned int i ) { return (&x)[i]; }
+
+ float x, y, z;
+};
+
+
+//! vecteur generique 4d, ou 3d homogene, utilitaire.
+struct vec4
+{
+ //! constructeur par defaut.
+ vec4( ) : x(0), y(0), z(0), w(0) {}
+ vec4( const float _x, const float _y, const float _z, const float _w ) : x(_x), y(_y), z(_z), w(_w) {}
+ //! constructeur par defaut.
+ vec4( const vec2& v, const float _z= 0, const float _w= 0 ) : x(v.x), y(v.y), z(_z), w(_w) {}
+ //! constructeur par defaut.
+ vec4( const vec3& v, const float _w= 0 ) : x(v.x), y(v.y), z(v.z), w(_w) {}
+
+ //! cree un vecteur generique a partir des coordonnees du point a, (a.x, a.y, a.z, 1).
+ vec4( const Point& a ); // l'implementation se trouve en fin de fichier.
+ //! cree un vecteur generique a partir des coordonnees du vecteur v, (v.x, v.y, v.z, 0).
+ vec4( const Vector& v ); // l'implementation se trouve en fin de fichier.
+
+ //! renvoie la ieme composante du vecteur.
+ float operator() ( const unsigned int i ) const { return (&x)[i]; }
+ float& operator() ( const unsigned int i ) { return (&x)[i]; }
+
+ float x, y, z, w;
+};
+
+
+// implementation des constructeurs explicites.
+inline Point::Point( const vec2& v, const float _z ) : x(v.x), y(v.y), z(_z) {}
+inline Point::Point( const vec3& v ) : x(v.x), y(v.y), z(v.z) {}
+inline Point::Point( const vec4& v ) : x(v.x), y(v.y), z(v.z) {}
+inline Point::Point( const Vector& v ) : x(v.x), y(v.y), z(v.z) {}
+
+inline Vector::Vector( const vec2& v, const float _z ) : x(v.x), y(v.y), z(_z) {}
+inline Vector::Vector( const vec3& v ) : x(v.x), y(v.y), z(v.z) {}
+inline Vector::Vector( const vec4& v ) : x(v.x), y(v.y), z(v.z) {}
+inline Vector::Vector( const Point& a ) : x(a.x), y(a.y), z(a.z) {}
+
+inline vec3::vec3( const Point& a ) : x(a.x), y(a.y), z(a.z) {}
+inline vec3::vec3( const Vector& v ) : x(v.x), y(v.y), z(v.z) {}
+
+inline vec4::vec4( const Point& a ) : x(a.x), y(a.y), z(a.z), w(1.f) {}
+inline vec4::vec4( const Vector& v ) : x(v.x), y(v.y), z(v.z), w(0.f) {}
+
+//
+inline float Point::operator( ) ( const unsigned int i ) const { return (&x)[i]; }
+inline float Vector::operator( ) ( const unsigned int i ) const { return (&x)[i]; }
+
+inline float& Point::operator( ) ( const unsigned int i ) { return (&x)[i]; }
+inline float& Vector::operator( ) ( const unsigned int i ) { return (&x)[i]; }
+
+//
+#include <iostream>
+
+inline std::ostream& operator<<(std::ostream& o, const Point& p)
+{
+ o<<"p("<<p.x<<","<<p.y<<","<<p.z<<")";
+ return o;
+}
+
+inline std::ostream& operator<<(std::ostream& o, const Vector& v)
+{
+ o<<"v("<<v.x<<","<<v.y<<","<<v.z<<")";
+ return o;
+}
+
+///@}
diff --git a/code/src/wavefront/materials.h b/code/src/wavefront/materials.h
new file mode 100644
index 0000000..b737ec5
--- /dev/null
+++ b/code/src/wavefront/materials.h
@@ -0,0 +1,167 @@
+
+#ifndef _MATERIALS_H
+#define _MATERIALS_H
+
+#include <string>
+#include <vector>
+#include <cassert>
+
+#include "color.h"
+
+
+/*! representation d'une matiere d'un groupe de triangles d'un Mesh.
+parametres des matieres Blinn-Phong, cf \ref matiere pour les explications et \ref brdf pour le code...
+*/
+struct Material
+{
+ Color diffuse; //!< couleur diffuse / de base.
+ Color specular; //!< couleur du reflet.
+ Color emission; //!< pour une source de lumiere.
+ float ns; //!< concentration des reflets, exposant pour les reflets blinn-phong.
+ float ni; //!< indice de refraction, cf coefficients de Fresnel.
+ Color transmission; //!< transmission, "couleur" des objets transparents.
+
+ int diffuse_texture; //!< indice de la texture de la couleur de base, ou -1.
+ int specular_texture; //!< indice de la texture, ou -1.
+ int ns_texture; //!< indice de la texture, ou -1.
+
+ //! constructeur par defaut. noir.
+ Material( ) : diffuse(), specular(), emission(), ns(0), ni(0), transmission(), diffuse_texture(-1), specular_texture(-1), ns_texture(-1) {}
+ //! matiere diffuse.
+ Material( const Color& color ) : diffuse(color), specular(), emission(), ns(0), ni(0), transmission(), diffuse_texture(-1), specular_texture(-1), ns_texture(-1) {}
+};
+
+
+/*! ensemble de matieres d'un Mesh. + ensemble de textures referencees par les descriptions de matieres.
+
+ `names[id]` est le nom de la matiere `materials[id]`, utiliser name() et material() pour recuperer la description d'une matiere d'indice `id`.
+
+ les textures sont indexees separemment. chaque matiere reference une ou plusieurs textures, par exemple diffuse_texture et specular_texture.
+ ces indices correspondent aux noms de fichiers (uniques) des images a charger : filename() renvoie le nom du fichier.
+ filename( material.diffuse_texture ) renvoie le nom de l'image a charger qui correspond a la texture diffuse de la matiere.
+
+ pourquoi cette indexation supplementaire ? pour eviter de charger plusieurs fois une image / creer plusieurs fois une texture.
+*/
+struct Materials
+{
+ std::vector<std::string> names; //!< noms des matieres.
+ std::vector<Material> materials; //!< description des matieres.
+ std::vector<std::string> texture_filenames; //!< noms des textures a charger.
+ int default_material_id; //!< indice de la matiere par defaut dans materials.
+
+ Materials( ) : names(), materials(), texture_filenames(), default_material_id(-1) {}
+
+ void clear( )
+ {
+ names.clear();
+ materials.clear();
+ texture_filenames.clear();
+ default_material_id= -1;
+ }
+
+ //! ajoute une matiere.
+ int insert( const Material& material, const char *name )
+ {
+ int id= find(name);
+ if(id == -1)
+ {
+ id= int(materials.size());
+ names.push_back(name);
+ materials.push_back(material);
+ }
+ assert(materials.size() == names.size());
+ return id;
+ }
+
+ //! ajoute une texture / nom du fichier.
+ int insert_texture( const char *filename )
+ {
+ int id= find_texture(filename);
+ if(id == -1)
+ {
+ id= int(texture_filenames.size());
+ texture_filenames.push_back(filename);
+ }
+ return id;
+ }
+
+ //! recherche une matiere avec son nom. renvoie son indice dans materials, ou -1.
+ int find( const char *name )
+ {
+ if(name == nullptr || name[0] == 0)
+ return -1;
+
+ for(int i= 0; i < int(names.size()); i++)
+ {
+ if(names[i] == name)
+ return i;
+ }
+ return -1;
+ }
+
+ //! nombre de matieres.
+ int count( ) const { return int(materials.size()); }
+
+ //! renvoie le nom de la ieme matiere.
+ const char *name( const int id ) const { assert(id != -1); assert(id < int(materials.size())); return names[id].c_str(); }
+ //! renvoie le nom de la ieme matiere.
+ const char *name( const int id ) { assert(id != -1); assert(id < int(materials.size())); return names[id].c_str(); }
+
+ //! renvoie la ieme matiere.
+ const Material& material( const int id ) const { assert(id != -1); assert(id < int(materials.size())); return materials[id]; }
+ //! renvoie la ieme matiere.
+ Material& material( const int id ) { assert(id != -1); assert(id < int(materials.size())); return materials[id]; }
+
+ //! renvoie la ieme matiere.
+ const Material& operator() ( const int id ) const { return material(id); }
+ //! renvoie la ieme matiere.
+ Material& operator() ( const int id ) { return material(id); }
+
+ //! renvoie la matiere 'name', si elle existe. ou la matiere par defaut.
+ const Material& material( const char *name )
+ {
+ int id= find(name);
+ if(id != -1)
+ // renvoie la matiere
+ return materials[id];
+ else
+ // ou renvoie la matiere par defaut...
+ return default_material();
+ }
+
+ //! renvoie une matiere par defaut.
+ const Material& default_material( )
+ {
+ return material(default_material_index());
+ }
+
+ //! indice de la matiere par defaut dans le tableau materials.
+ int default_material_index( )
+ {
+ if(default_material_id == -1)
+ default_material_id= insert(Material(Color(0.8)), "default");
+
+ return default_material_id;
+ }
+
+ //! renvoie le nombre de noms de fichiers de textures.
+ int filename_count( ) const { return int(texture_filenames.size()); }
+ //! renvoie le nom de fichier d'une texture.
+ const char *filename( const int id ) const { if(id < 0) return nullptr; assert(id < int(texture_filenames.size())); return texture_filenames[id].c_str(); }
+
+ //! renvoie l'indice d'une texture, si elle existe.
+ int find_texture( const char *filename )
+ {
+ if(filename == nullptr || filename[0] == 0)
+ return -1;
+
+ for(int i= 0; i < int(texture_filenames.size()); i++)
+ {
+ if(texture_filenames[i] == filename)
+ return i;
+ }
+ return -1;
+ }
+};
+
+#endif
diff --git a/code/src/wavefront/mesh_io.cpp b/code/src/wavefront/mesh_io.cpp
new file mode 100644
index 0000000..84386d7
--- /dev/null
+++ b/code/src/wavefront/mesh_io.cpp
@@ -0,0 +1,620 @@
+
+#include <cstdlib>
+#include <cassert>
+#include <map>
+
+#include "mesh_io.h"
+
+#include "image.h"
+#include "image_io.h"
+
+
+bool read_positions( const char *filename, std::vector<Point>& positions )
+{
+ positions.clear();
+
+ FILE *in= fopen(filename, "rt");
+ if(!in)
+ {
+ printf("[error] loading mesh '%s'...\n", filename);
+ return false;
+ }
+
+ printf("loading mesh '%s'...\n", filename);
+
+ std::vector<Point> wpositions;
+ std::vector<int> wp;
+
+ char line_buffer[1024];
+ bool error= true;
+ for(;;)
+ {
+ // charge une ligne du fichier
+ if(!fgets(line_buffer, sizeof(line_buffer), in))
+ {
+ error= false; // fin du fichier, pas d'erreur detectee
+ break;
+ }
+
+ // force la fin de la ligne, au cas ou
+ line_buffer[sizeof(line_buffer) -1]= 0;
+
+ // saute les espaces en debut de ligne
+ char *line= line_buffer;
+ while(*line && isspace(*line))
+ line++;
+
+ if(line[0] == 'v')
+ {
+ float x, y, z;
+ if(line[1] == ' ') // position x y z
+ {
+ if(sscanf(line, "v %f %f %f", &x, &y, &z) != 3)
+ break;
+ wpositions.push_back( Point(x, y, z) );
+ }
+ }
+
+ else if(line[0] == 'f') // triangle a b c, les sommets sont numerotes a partir de 1 ou de la fin du tableau (< 0)
+ {
+ wp.clear();
+
+ int next= 0;
+ for(line= line +1; ; line= line + next)
+ {
+ wp.push_back(0);
+
+ // analyse les attributs du sommet : p/t/n ou p//n ou p/t ou p...
+ next= 0;
+ int wt= 0;
+ int wn= 0;
+ if(sscanf(line, " %d/%d/%d %n", &wp.back(), &wt, &wn, &next) == 3)
+ continue;
+ else if(sscanf(line, " %d/%d %n", &wp.back(), &wt, &next) == 2)
+ continue;
+ else if(sscanf(line, " %d//%d %n", &wp.back(), &wn, &next) == 2)
+ continue;
+ else if(sscanf(line, " %d %n", &wp.back(), &next) == 1)
+ continue;
+ else if(next == 0) // fin de ligne
+ break;
+ }
+
+ // triangule la face
+ for(unsigned v= 2; v +1 < wp.size(); v++)
+ {
+ unsigned idv[3]= { 0, v -1, v };
+ for(unsigned i= 0; i < 3; i++)
+ {
+ unsigned k= idv[i];
+ int p= (wp[k] < 0) ? int(wpositions.size()) + wp[k] : wp[k] -1;
+ if(p < 0) break; // error
+
+ // et duplique les positions...
+ assert(p < int(wpositions.size()));
+ positions.push_back(wpositions[p]);
+ }
+ }
+ }
+ }
+
+ fclose(in);
+
+ if(error)
+ printf("[error] loading mesh '%s'...\n%s\n\n", filename, line_buffer);
+ else
+ printf("mesh '%s': %d positions\n", filename, int(positions.size()));
+
+ return !error;
+}
+
+
+bool read_indexed_positions( const char *filename, std::vector<Point>& positions, std::vector<int>& indices )
+{
+ positions.clear();
+ indices.clear();
+
+ FILE *in= fopen(filename, "rt");
+ if(!in)
+ {
+ printf("[error] loading indexed mesh '%s'...\n", filename);
+ return false;
+ }
+
+ printf("loading indexed mesh '%s'...\n", filename);
+
+ std::vector<int> wp;
+
+ char line_buffer[1024];
+ bool error= true;
+ for(;;)
+ {
+ // charge une ligne du fichier
+ if(!fgets(line_buffer, sizeof(line_buffer), in))
+ {
+ error= false; // fin du fichier, pas d'erreur detectee
+ break;
+ }
+
+ // force la fin de la ligne, au cas ou
+ line_buffer[sizeof(line_buffer) -1]= 0;
+
+ // saute les espaces en debut de ligne
+ char *line= line_buffer;
+ while(*line && isspace(*line))
+ line++;
+
+ if(line[0] == 'v')
+ {
+ float x, y, z;
+ if(line[1] == ' ') // position x y z
+ {
+ if(sscanf(line, "v %f %f %f", &x, &y, &z) != 3)
+ break;
+ positions.push_back( Point(x, y, z) );
+ }
+ }
+
+ else if(line[0] == 'f') // triangle a b c, les sommets sont numerotes a partir de 1 ou de la fin du tableau (< 0)
+ {
+ wp.clear();
+
+ int next= 0;
+ for(line= line +1; ; line= line + next)
+ {
+ wp.push_back(0);
+
+ // analyse les attributs du sommet : p/t/n ou p//n ou p/t ou p...
+ next= 0;
+ int wt= 0;
+ int wn= 0;
+ if(sscanf(line, " %d/%d/%d %n", &wp.back(), &wt, &wn, &next) == 3)
+ continue;
+ else if(sscanf(line, " %d/%d %n", &wp.back(), &wt, &next) == 2)
+ continue;
+ else if(sscanf(line, " %d//%d %n", &wp.back(), &wn, &next) == 2)
+ continue;
+ else if(sscanf(line, " %d %n", &wp.back(), &next) == 1)
+ continue;
+ else if(next == 0) // fin de ligne
+ break;
+ }
+
+ // triangule la face
+ for(unsigned v= 2; v +1 < wp.size(); v++)
+ {
+ unsigned idv[3]= { 0, v -1, v };
+ for(unsigned i= 0; i < 3; i++)
+ {
+ unsigned k= idv[i];
+ int p= (wp[k] < 0) ? int(positions.size()) + wp[k] : wp[k] -1;
+ if(p < 0) break; // error
+
+ assert(p < int(positions.size()));
+ indices.push_back(p);
+ }
+ }
+ }
+ }
+
+ fclose(in);
+
+ if(error)
+ printf("[error] loading indexed mesh '%s'...\n%s\n\n", filename, line_buffer);
+ else
+ printf("indexed mesh '%s': %d positions, %d indices\n", filename, int(positions.size()), int(indices.size()));
+
+ return !error;
+}
+
+
+bool read_materials_mtl( const char *filename, Materials& materials )
+{
+ FILE *in= fopen(filename, "rt");
+ if(!in)
+ {
+ printf("[error] loading materials '%s'...\n", filename);
+ return false;
+ }
+
+ printf("loading materials '%s'...\n", filename);
+
+ Material *material= nullptr;
+ char tmp[1024];
+ char line_buffer[1024];
+ bool error= true;
+ for(;;)
+ {
+ // charge une ligne du fichier
+ if(!fgets(line_buffer, sizeof(line_buffer), in))
+ {
+ error= false; // fin du fichier, pas d'erreur detectee
+ break;
+ }
+
+ // force la fin de la ligne, au cas ou
+ line_buffer[sizeof(line_buffer) -1]= 0;
+
+ // saute les espaces en debut de ligne
+ char *line= line_buffer;
+ while(*line && isspace(*line))
+ line++;
+
+ if(line[0] == 'n')
+ {
+ if(sscanf(line, "newmtl %[^\r\n]", tmp) == 1)
+ {
+ int id= materials.insert(Material(Black()), tmp);
+ material= &materials.material(id);
+ }
+ }
+
+ if(material == nullptr)
+ continue;
+
+ if(line[0] == 'K')
+ {
+ float r, g, b;
+ if(sscanf(line, "Kd %f %f %f", &r, &g, &b) == 3)
+ material->diffuse= Color(r, g, b);
+ else if(sscanf(line, "Ks %f %f %f", &r, &g, &b) == 3)
+ material->specular= Color(r, g, b);
+ else if(sscanf(line, "Ke %f %f %f", &r, &g, &b) == 3)
+ material->emission= Color(r, g, b);
+ }
+
+ else if(line[0] == 'N')
+ {
+ float n;
+ if(sscanf(line, "Ns %f", &n) == 1) // Ns, puissance / concentration du reflet, modele blinn phong
+ material->ns= n;
+ if(sscanf(line, "Ni %f", &n) == 1) // Ni, indice de refraction / fresnel
+ material->ni= n;
+ }
+ else if(line[0] == 'T')
+ {
+ float r, g, b;
+ if(sscanf(line, "Tf %f %f %f", &r, &g, &b) == 3) // Tf, couleur de l'objet transparent
+ material->transmission= Color(r, g, b);
+ }
+
+ else if(line[0] == 'm')
+ {
+ if(sscanf(line, "map_Kd %[^\r\n]", tmp) == 1)
+ material->diffuse_texture= materials.insert_texture( absolute_filename(pathname(filename), tmp).c_str() );
+
+ else if(sscanf(line, "map_Ks %[^\r\n]", tmp) == 1)
+ material->specular_texture= materials.insert_texture( absolute_filename(pathname(filename), tmp).c_str() );
+
+ else if(sscanf(line, "map_Ns %[^\r\n]", tmp) == 1)
+ material->ns_texture= materials.insert_texture( absolute_filename(pathname(filename), tmp).c_str() );
+ }
+ }
+
+ fclose(in);
+
+ if(error)
+ printf("[error] parsing line :\n%s\n", line_buffer);
+
+ return !error;
+}
+
+bool read_materials( const char *filename, Materials& materials, std::vector<int>& indices )
+{
+ indices.clear();
+
+ FILE *in= fopen(filename, "rt");
+ if(!in)
+ {
+ printf("[error] loading materials '%s'...\n", filename);
+ return false;
+ }
+
+ printf("loading materials '%s'...\n", filename);
+
+ std::vector<int> wp;
+ int material_id= -1;
+
+ char tmp[1024];
+ char line_buffer[1024];
+ bool error= true;
+ for(;;)
+ {
+ // charge une ligne du fichier
+ if(!fgets(line_buffer, sizeof(line_buffer), in))
+ {
+ error= false; // fin du fichier, pas d'erreur detectee
+ break;
+ }
+
+ // force la fin de la ligne, au cas ou
+ line_buffer[sizeof(line_buffer) -1]= 0;
+
+ // saute les espaces en debut de ligne
+ char *line= line_buffer;
+ while(*line && isspace(*line))
+ line++;
+
+ if(line[0] == 'f') // triangle a b c
+ {
+ wp.clear();
+
+ int next= 0;
+ for(line= line +1; ; line= line + next)
+ {
+ wp.push_back(0);
+
+ // analyse les attributs du sommet : p/t/n ou p//n ou p/t ou p...
+ next= 0;
+ int wt= 0;
+ int wn= 0;
+ if(sscanf(line, " %d/%d/%d %n", &wp.back(), &wt, &wn, &next) == 3)
+ continue;
+ else if(sscanf(line, " %d/%d %n", &wp.back(), &wt, &next) == 2)
+ continue;
+ else if(sscanf(line, " %d//%d %n", &wp.back(), &wn, &next) == 2)
+ continue;
+ else if(sscanf(line, " %d %n", &wp.back(), &next) == 1)
+ continue;
+ else if(next == 0) // fin de ligne
+ break;
+ }
+
+ // force une matiere par defaut, si necessaire
+ if(material_id == -1)
+ material_id= materials.default_material_index();
+
+ // triangule la face
+ for(unsigned v= 2; v +1 < wp.size(); v++)
+ // indice de la matiere de chaque triangle
+ indices.push_back(material_id);
+ }
+ else if(line[0] == 'm')
+ {
+ if(sscanf(line, "mtllib %[^\r\n]", tmp) == 1)
+ {
+ std::string materials_filename;
+ if(tmp[0] != '/' && tmp[1] != ':') // windows c:\ pour les chemins complets...
+ materials_filename= normalize_filename(pathname(filename) + tmp);
+ else
+ materials_filename= std::string(tmp);
+
+ // charge les matieres
+ if(!read_materials_mtl( materials_filename.c_str(), materials ))
+ break;
+ }
+ }
+
+ else if(line[0] == 'u')
+ {
+ if(sscanf(line, "usemtl %[^\r\n]", tmp) == 1)
+ material_id= materials.find(tmp);
+ }
+ }
+
+ fclose(in);
+
+ if(error)
+ printf("[error] loading materials '%s'...\n%s\n\n", filename, line_buffer);
+
+ return !error;
+}
+
+
+// representation de l'indexation complete d'un sommet .obj / wavefront
+struct vertex
+{
+ int material;
+ int position;
+ int texcoord;
+ int normal;
+
+ vertex( ) : material(-1), position(-1), texcoord(-1), normal(-1) {}
+ vertex( const int m, const int p, const int t, const int n ) : material(m), position(p), texcoord(t), normal(n) {}
+
+ // comparaison lexicographique de 2 sommets / des indices de leurs attributs
+ bool operator< ( const vertex& b ) const
+ {
+ if(material != b.material) return material < b.material;
+ if(position != b.position) return position < b.position;
+ if(texcoord != b.texcoord) return texcoord < b.texcoord;
+ if(normal != b.normal) return normal < b.normal;
+ return false;
+ }
+};
+
+MeshIOData read_meshio_data( const char *filename )
+{
+ FILE *in= fopen(filename, "rt");
+ if(!in)
+ {
+ printf("[error] loading indexed mesh '%s'...\n", filename);
+ return {};
+ }
+
+ printf("loading indexed mesh '%s'...\n", filename);
+
+ MeshIOData data;
+
+ std::vector<Point> wpositions;
+ std::vector<Point> wtexcoords;
+ std::vector<Vector> wnormals;
+
+ std::vector<int> wp;
+ std::vector<int> wt;
+ std::vector<int> wn;
+
+ std::map<vertex, int> remap;
+ int material_id= -1;
+
+ char tmp[1024];
+ char line_buffer[1024];
+ bool error= true;
+ for(;;)
+ {
+ // charge une ligne du fichier
+ if(!fgets(line_buffer, sizeof(line_buffer), in))
+ {
+ error= false; // fin du fichier, pas d'erreur detectee
+ break;
+ }
+
+ // force la fin de la ligne, au cas ou
+ line_buffer[sizeof(line_buffer) -1]= 0;
+
+ // saute les espaces en debut de ligne
+ char *line= line_buffer;
+ while(*line && isspace(*line))
+ line++;
+
+ if(line[0] == 'v')
+ {
+ float x, y, z;
+ if(line[1] == ' ') // position x y z
+ {
+ if(sscanf(line, "v %f %f %f", &x, &y, &z) != 3)
+ break;
+ wpositions.push_back( Point(x, y, z) );
+ }
+ else if(line[1] == 'n') // normal x y z
+ {
+ if(sscanf(line, "vn %f %f %f", &x, &y, &z) != 3)
+ break;
+ wnormals.push_back( Vector(x, y, z) );
+ }
+ else if(line[1] == 't') // texcoord x y
+ {
+ if(sscanf(line, "vt %f %f", &x, &y) != 2)
+ break;
+ wtexcoords.push_back( Point(x, y, 0) );
+ }
+ }
+ else if(line[0] == 'f') // triangle a b c, les sommets sont numerotes a partir de 1 ou de la fin du tableau (< 0)
+ {
+ wp.clear();
+ wt.clear();
+ wn.clear();
+
+ int next;
+ for(line= line +1; ; line= line + next)
+ {
+ wp.push_back(0);
+ wt.push_back(0);
+ wn.push_back(0); // 0: invalid index
+
+ // analyse les attributs du sommet : p/t/n ou p//n ou p/t ou p...
+ next= 0;
+ if(sscanf(line, " %d/%d/%d %n", &wp.back(), &wt.back(), &wn.back(), &next) == 3)
+ continue;
+ else if(sscanf(line, " %d/%d %n", &wp.back(), &wt.back(), &next) == 2)
+ continue;
+ else if(sscanf(line, " %d//%d %n", &wp.back(), &wn.back(), &next) == 2)
+ continue;
+ else if(sscanf(line, " %d %n", &wp.back(), &next) == 1)
+ continue;
+ else if(next == 0) // fin de ligne
+ break;
+ }
+
+ // force une matiere par defaut, si necessaire
+ if(material_id == -1)
+ material_id= data.materials.default_material_index();
+
+ // triangule la face
+ for(unsigned v= 2; v +1 < wp.size(); v++)
+ {
+ data.material_indices.push_back(material_id);
+
+ unsigned idv[3]= { 0, v -1, v };
+ for(unsigned i= 0; i < 3; i++)
+ {
+ unsigned k= idv[i];
+ // indices des attributs du sommet
+ int p= (wp[k] < 0) ? wpositions.size() + wp[k] : wp[k] -1;
+ int t= (wt[k] < 0) ? wtexcoords.size() + wt[k] : wt[k] -1;
+ int n= (wn[k] < 0) ? wnormals.size() + wn[k] : wn[k] -1;
+
+ if(p < 0) break; // error
+
+ // recherche / insere le sommet
+ auto found= remap.insert( std::make_pair(vertex(material_id, p, t, n), int(remap.size())) );
+ if(found.second)
+ {
+ // pas trouve, copie les nouveaux attributs
+ if(t != -1) data.texcoords.push_back(wtexcoords[t]);
+ if(n != -1) data.normals.push_back(wnormals[n]);
+ data.positions.push_back(wpositions[p]);
+ }
+
+ // construit l'index buffer
+ assert(found.first->second < int(data.positions.size()));
+ data.indices.push_back(found.first->second);
+ }
+ }
+ }
+
+ else if(line[0] == 'm')
+ {
+ if(sscanf(line, "mtllib %[^\r\n]", tmp) == 1)
+ {
+ std::string materials_filename;
+ if(tmp[0] != '/' && tmp[1] != ':') // windows c:\ pour les chemins complets...
+ materials_filename= normalize_filename(pathname(filename) + tmp);
+ else
+ materials_filename= std::string(tmp);
+
+ // charge les matieres
+ if(!read_materials_mtl( materials_filename.c_str(), data.materials ))
+ break;
+ }
+ }
+
+ else if(line[0] == 'u')
+ {
+ if(sscanf(line, "usemtl %[^\r\n]", tmp) == 1)
+ material_id= data.materials.find(tmp);
+ }
+ }
+
+ fclose(in);
+
+ if(error)
+ {
+ printf("[error] loading indexed mesh '%s'...\n%s\n\n", filename, line_buffer);
+ return {};
+ }
+
+ printf(" %d indices, %d positions %d texcoords %d normals\n",
+ int(data.indices.size()), int(data.positions.size()), int(data.texcoords.size()), int(data.normals.size()));
+ printf(" %d materials, %d textures\n", data.materials.count(), data.materials.filename_count());
+ return data;
+}
+
+
+bool read_images( const Materials& materials, std::vector<Image>& images )
+{
+ int n= materials.filename_count();
+ if(n == 0) // pas de textures
+ return true;
+
+ images.resize(n);
+
+#pragma omp parallel for
+ for(int i= 0; i < n; i++)
+ {
+ //~ printf("loading '%s'...\n", materials.filename(i));
+ images[i]= read_image(materials.filename(i));
+ }
+
+ return true;
+}
+
+
+bool read_images( MeshIOData& data )
+{
+ return read_images(data.materials, data.images);
+}
+
+
+
+
diff --git a/code/src/wavefront/mesh_io.h b/code/src/wavefront/mesh_io.h
new file mode 100644
index 0000000..3cf74fa
--- /dev/null
+++ b/code/src/wavefront/mesh_io.h
@@ -0,0 +1,220 @@
+
+#ifndef _MESH_IO_H
+#define _MESH_IO_H
+
+#include <vector>
+
+#include "vec.h"
+#include "materials.h"
+#include "image.h"
+#include "files.h"
+
+//! \addtogroup objet3D utilitaires pour manipuler des objets 3d
+///@{
+
+/*! charge les positions des sommets des triangles d'un objet. format .obj / wavefront. un triangle est represente par 3 positions successives.
+
+exemple : charger un fichier .obj et parcourir tous les triangles
+\code
+ std::vector<Point> positions;
+ if(!read_positions("data/robot.obj", positions))
+ return "erreur";
+
+ // parcours les triangles
+ for(unsigned i= 0; i +2 < positions.size(); i+= 3)
+ {
+ // triangle abc
+ Point a= positions[ i];
+ Point b= positions[ i +1 ];
+ Point c= positions[ i +2 ];
+
+ // par exemple, calcule la normale du triangle
+ Vector n= normalize( cross( Vector(a, b), Vector(a, c) ) );
+ ...
+ }
+\endcode
+
+on peut facilement recuperer les sommets du triangle numero id :
+\code
+ std::vector<Point> positions;
+ if(!read_positions("data/robot.obj", positions))
+ return "erreur";
+
+ int id= ... ;
+ Point a= positions[ 3*id ];
+ Point b= positions[ 3*id +1 ];
+ Point c= positions[ 3*id +2 ];
+\endcode
+ */
+bool read_positions( const char *filename, std::vector<Point>& positions );
+
+/*! version indexee de read_positions(). un triangle est represente par 3 indices successifs dans indices[].
+
+exemple : charger un fichier .obj et parcourir tous les triangles
+\code
+ std::vector<int> indices;
+ std::vector<Point> positions;
+ if(!read_indexed_positions("data/robot.obj", positions, indices))
+ return "erreur";
+
+ // parcours les triangles indexes
+ for(unsigned i= 0; i +2 < indices.size(); i+= 3)
+ {
+ // triangle abc
+ Point a= positions[ indices[i] ];
+ Point b= positions[ indices[i+1] ];
+ Point c= positions[ indices[i+2] ];
+
+ // par exemple, calcule la normale du triangle
+ Vector n= normalize( cross( Vector(a, b), Vector(a, c) ) );
+ ...
+ }
+\endcode
+
+on peut recuperer directement les sommets du triangle numero id :
+\code
+ std::vector<int> indices;
+ std::vector<Point> positions;
+ if(!read_indexed_positions("data/robot.obj", positions, indices))
+ return "erreur";
+
+ int id= ... ;
+ Point a= positions[ indices[ 3*id ] ];
+ Point b= positions[ indices[ 3*id +1 ] ];
+ Point c= positions[ indices[ 3*id +2 ] ];
+\endcode
+*/
+bool read_indexed_positions( const char *filename, std::vector<Point>& positions, std::vector<int>& indices );
+
+
+/*! charge les matieres associees aux triangles d'un fichier .obj / wavefront. renvoie l'ensemble de matieres et l'indice de la matiere pour chaque triangle.
+
+exemple :
+\code
+ #include "materials.h"
+
+ Materials materials;
+ std::vector<int> material_indices; // indices des matieres
+ if(!read_materials("data/robot.obj", materials, material_indices)) // !! oui c'est bien le fichier .obj !!
+ return "erreur";
+
+ // recuperer la matiere du triangle numero id :
+ int material_id= material_indices[ id ];
+ Material& material= materials( material_id );
+\endcode
+
+exemple plus complet, charge un objet, ses matieres et recupere la couleur de chaque triangle
+\code
+ #include "mesh_io.h"
+ #include "materials.h"
+
+ std::vector<Point> positions;
+ if(!read_positions("data/robot.obj", positions))
+ return "erreur";
+
+ Materials materials;
+ std::vector<int> material_indices; // indices des matieres
+ if(!read_materials(data/robot.obj", materials, material_indices))
+ return "erreur";
+
+ // recuperer les sommets du triangle numero id
+ int id= ... ;
+ Point a= positions[ 3*id ];
+ Point b= positions[ 3*id +1 ];
+ Point c= positions[ 3*id +2 ];
+
+ // recuperer la matiere du triangle numero id
+ int material_id= material_indices[ id ];
+ Material& material= materials( material_id );
+
+ // recuperer la couleur (de la matiere) du triangle
+ Color color= material.diffuse;
+\endcode
+*/
+bool read_materials( const char *filename, Materials& materials, std::vector<int>& indices );
+
+/*! charge les images / textures referencees par les matieres d'un objet.
+
+exemple :
+\code
+ #include "mesh_io.h"
+ #include "materials.h"
+
+ std::vector<Point> positions;
+ if(!read_positions("data/robot.obj", positions))
+ return "erreur";
+
+ Materials materials;
+ std::vector<int> material_indices; // indices des matieres
+ if(!read_materials("data/robot.obj", materials, material_indices)) // !! oui c'est bien le fichier .obj !!
+ return "erreur";
+
+ std::vector<Image> images;
+ if(!read_images(materials, images))
+ return "erreur";
+\endcode
+*/
+bool read_images( const Materials& materials, std::vector<Image>& images );
+
+
+struct MeshIOData
+{
+ std::vector<Point> positions;
+ std::vector<Point> texcoords;
+ std::vector<Vector> normals;
+ std::vector<int> indices;
+ std::vector<int> material_indices;
+
+ Materials materials;
+ std::vector<Image> images;
+};
+
+/*! charge tous les attributs et les matieres. en une seule fois.
+
+exemple :
+\code
+ MeshIOData data= read_meshio_data( "data/robot.obj" );
+ if(data.positions.empty())
+ return "erreur";
+
+ // recuperer les sommets du triangle d'indice id :
+ // triangle abc
+ Point a= data.positions[ data.indices[3*id] ];
+ Point b= data.positions[ data.indices[3*id+1] ];
+ Point c= data.positions[ data.indices[3*id+2] ];
+
+ // et recuperer sa matiere / couleur
+ int material_id= data.material_indices[ id ];
+ Material& material= data.materials( material_id );
+
+ // recuperer la couleur (de la matiere) du triangle
+ Color color= material.diffuse;
+ ...
+\endcode
+
+utiliser read_meshio_data() est equivalent a :
+\code
+ const char *filename= "... .obj";
+
+ std::vector<Point> positions;
+ std::vector<int> indices;
+ read_indexed_positions( filename, positions, indices );
+
+ Materials materials;
+ std::vector<int> material_indices;
+ read_materials( filename, materials, materials_indices );
+
+ std::vector<Image> images;
+ read_images( filename, images );
+\endcode
+
+ mais toutes les infos sont chargees en seule fois, et sont stockees dans une seule structure, cf MeshIOData, plus simple a manipuler.
+*/
+MeshIOData read_meshio_data( const char *filename );
+
+//! charge les images referencees par les matieres de l'objet.
+bool read_images( MeshIOData& data );
+
+///@}
+
+#endif
--
GitLab