fggl/math/shapes.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "fggl/math/shapes.hpp"
+#include <vector>
+
+namespace fggl::math::phs3d {
+
+	void AABB::emtpy() {
+		min = {FLT_MAX, FLT_MAX, FLT_MAX};
+		max = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
+	}
+
+	void AABB::add(const math::vec3 &point) {
+		min = minElm(min, point);
+		max = maxElm(max, point);
+	}
+
+	auto AABB::fromPoints(const std::vector<math::vec3> &points) -> AABB {
+		AABB box;
+		for (const auto &point : points) {
+			box.add(point);
+		}
+		return box;
+	}
+
+	void AABB::set(const AABB &other, const math::mat4 &m) {
+		// TODO this needs testing, I'm not sure if our vectors are oriented the same as 9.4.4
+		min = max = m[3]; // should be the translation component of the matrix
+
+		// this feels like something that should be vectorizable...
+		for (int i = 0; i < 3; i++) {
+			for (int j = 0; j < 3; j++) {
+				if (m[i][j] > 0.0F) {
+					min[j] += m[i][j] * other.min[j];
+					max[j] += m[i][j] * other.max[j];
+				} else {
+					min[j] += m[i][j] * other.max[j];
+					max[j] += m[i][j] * other.min[j];
+				}
+			}
+		}
+	}
+
+	auto Plane::fromPoints(const math::vec3 p1, const math::vec3 p2, const math::vec3 p3) -> Plane {
+		const auto e3 = p2 - p1;
+		const auto e1 = p3 - p2;
+		auto normal = glm::normalize(glm::cross(e3, e1));
+		auto d = glm::dot(p2, normal);
+		return {normal, d};
+	}
+
+	static auto bestFitNormal(const std::vector<math::vec3> &points) -> math::vec3 {
+		assert(!points.empty());
+
+		math::vec3 result;
+
+		math::vec3 p = points.back();
+		for (std::size_t i = 0; i < points.size(); ++i) {
+			math::vec3 c = points[i];
+
+			result.x += (p.z + c.z) * (p.y - c.y);
+			result.y += (p.x + c.x) * (p.z - c.z);
+			result.z += (p.y + c.y) - (p.x - c.x);
+
+			p = c;
+		}
+
+		return glm::normalize(result);
+	};
+
+	static auto bestFitD(const std::vector<math::vec3> &points, glm::vec3 normal) -> float {
+		math::vec3 sum;
+		for (const auto &point : points) {
+			sum += point;
+		}
+		sum *= 1.0F / points.size();
+		return glm::dot(sum, normal);
+	}
+
+	const char X = 0;
+	const char Y = 1;
+	const char Z = 2;
+
+	struct bary_axis {
+		const char a;
+		const char b;
+	};
+
+	static auto baryCalcAxis(const math::vec3 &normal) -> bary_axis {
+		if ((fabs(normal.x) >= fabs(normal.y)) && (fabs(normal.x) >= fabs(normal.z))) {
+			// discard x
+			return {Y, Z};
+		} else if (fabs(normal.y) >= fabs(normal.z)) {
+			// discard y
+			return {Z, X};
+		} else {
+			// discard z
+			return {X, Y};
+		}
+	}
+
+	auto Triangle::CartToBarycentric(const math::vec3 &cart, Barycentric &outVal) -> bool {
+		// everything is const because I'm paying the compiler is smarter than me...
+
+		const auto d1 = v[1] - v[0];
+		const auto d2 = v[2] - v[1];
+		const auto n = glm::cross(d1, d2);
+
+		// 0 = x, 1 = y, 2 = z
+		const auto ax = baryCalcAxis(n);
+
+		// first axis
+		const float u1 = v[0][ax.a] - v[2][ax.a];
+		const float u2 = v[1][ax.a] - v[2][ax.a];
+		const float u3 = cart[ax.a] - v[0][ax.a];
+		const float u4 = cart[ax.a] - v[2][ax.a];
+
+		// second axis
+		const float v1 = v[0][ax.b] - v[2][ax.b];
+		const float v2 = v[1][ax.b] - v[2][ax.b];
+		const float v3 = cart[ax.b] - v[0][ax.b];
+		const float v4 = cart[ax.b] - v[2][ax.b];
+
+		const float denom = v1 * u2 - v2 * u1;
+		if (denom == 0.0F) {
+			return false;
+		}
+
+		// finally, we can work it out
+		const float oneOverDenom = 1.0F / denom;
+		outVal.b[0] = (v4 * u2 - v2 * u4) * oneOverDenom;
+		outVal.b[1] = (v1 * u3 - v3 * u1) * oneOverDenom;
+		outVal.b[2] = 1.0F - outVal.b[0] - outVal.b[1];
+		return true;
+	}
+
+	auto Triangle::CartToBarycentric2(const math::vec3 &cart, Barycentric &outVal) -> bool {
+		const auto e1 = v[2] - v[1];
+		const auto e2 = v[0] - v[2];
+		const auto e3 = v[1] - v[0];
+
+		const auto d1 = cart - v[0];
+		const auto d2 = cart - v[1];
+		const auto d3 = cart - v[2];
+
+		const auto normal = glm::normalize(glm::cross(e1, e2));
+		const auto denom = glm::dot(glm::cross(e1, e2), normal);
+		assert(denom != 0.0F);
+
+		outVal.b[0] = glm::dot(glm::cross(e1, d3), normal) / denom;
+		outVal.b[1] = glm::dot(glm::cross(e2, d1), normal) / denom;
+		outVal.b[2] = glm::dot(glm::cross(e3, d2), normal) / denom;
+		return true;
+	}
+
+} // namespace fggl::math::phys3d
\ No newline at end of file

fggl/math/triangulation.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "fggl/math/triangulation.hpp"
+
+namespace fggl::math {
+
+	/**
+	 * Fast Triangulation for convex polygons.
+	 */
+	void fan_triangulation(const PolygonVertex &polygon, data::Mesh2D &mesh) {
+		assert(polygon.size() >= 3);
+
+		// add the first two points to the mesh
+		auto firstIdx = mesh.add_vertex(polygon[0]);
+		auto prevIdx = mesh.add_vertex(polygon[1]);
+
+		// deal with the indices
+		const auto nTris = polygon.size() - 2;
+		for (auto i = 0U; i < nTris; i++) {
+			mesh.add_index(firstIdx);
+			mesh.add_index(prevIdx);
+
+			auto currIdx = mesh.add_vertex(polygon[i + 2]);
+			mesh.add_index(currIdx);
+			prevIdx = currIdx;
+		}
+	}
+
+} // namespace fggl::math
+

fggl/phys/CMakeLists.txt

+target_sources(fggl
+        PRIVATE
+        null.cpp
+        )
\ No newline at end of file

fggl/phys/null.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 20/08/22.
+//
+
+#include "fggl/phys/null.hpp"
+
+namespace fggl::phys {
+
+	auto NullPhysics::factory(modules::ServiceName serviceName, modules::Services &serviceManager) -> bool {
+		if (serviceName == phys::PhysicsProvider::service) {
+			serviceManager.bind<phys::PhysicsProvider, NullPhysicsProvider>();
+			return true;
+		}
+		return false;
+	}
+}
\ No newline at end of file

fggl/platform/CMakeLists.txt

+if (CMAKE_SYSTEM_NAME MATCHES "Linux")
+    add_subdirectory(linux)
+else ()
+    add_subdirectory(fallback)
+endif ()
\ No newline at end of file

fggl/platform/fallback/paths.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 26/06/22.
+//
+
+#define FGGL_PLATFORM_PATHS fallback
+
+#include <cstdlib>
+
+#include "fggl/platform/fallback/paths.hpp"
+
+namespace fggl::platform {
+
+	inline static std::filesystem::path get_user_path(const char *env, const char *fallback) {
+		const char *path = std::getenv(env);
+		if (path != nullptr) {
+			return {path};
+		}
+		return std::filesystem::current_path() / fallback;
+	}
+
+	EnginePaths calc_engine_paths(const char *base) {
+		return EnginePaths{
+			get_user_path(ENV_USER_CONFIG, DEFAULT_USER_CONFIG) / base,
+			get_user_path(ENV_USER_DATA, DEFAULT_USER_DATA) / base,
+			std::filesystem::temp_directory_path() / base
+		};
+	}
+
+	std::filesystem::path locate_data(const EnginePaths &paths, const std::filesystem::path &relPath) {
+		auto userPath = paths.userData / relPath;
+		if (std::filesystem::exists(userPath)) {
+			return userPath;
+		}
+
+		// if debug mode, try CWD as well.
+		auto debugPath = std::filesystem::current_path() / "data" / relPath;
+		if (std::filesystem::exists(debugPath)) {
+			return debugPath;
+		}
+
+		// if the file existed, it should exist in the user space
+		return userPath;
+	}
+
+	std::filesystem::path locate_config(const EnginePaths &paths, const std::filesystem::path &relPath) {
+		return paths.userConfig / relPath;
+	}
+
+	std::filesystem::path locate_cache(const EnginePaths &paths, const std::filesystem::path &relPath) {
+		return paths.userCache / relPath;
+	}
+
+} // namespace fggl::platform

fggl/platform/linux/CMakeLists.txt

+#find_package(Fontconfig)
+#target_link_libraries(fggl PRIVATE Fontconfig::Fontconfig)
+
+target_sources(fggl
+        PRIVATE
+        #       fonts.cpp
+        paths.cpp
+        )
\ No newline at end of file

fggl/platform/linux/fonts.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 23/06/22.
+//
+
+#include <fontconfig/fontconfig.h>
+
+namespace fggl::platform::Linux {
+
+	void get_font() {
+		/*	FcConfig *config = FcInitLoadConfigAndFonts();
+			FcPattern* pat = FcPatternCreate();
+			FcObjectSet* os = FcObjectSetBuild(FC_FAMILY, FC_STYLE, FC_WEIGHT, FC_SLANT, FC_PIXEL_SIZE, FC_SIZE, nullptr);
+			FcFontSet* fs = FcFontList(config, pat, os);
+
+			if ( fs ) {
+				FcFontSetDestroy(fs);
+			}*/
+	}
+
+} // namespace fggl::platform::linux
\ No newline at end of file

fggl/platform/linux/paths.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 26/06/22.
+//
+
+#include <cstdlib>
+
+#define FGGL_PLATFORM_PATHS linux
+
+#include "fggl/platform/linux/paths.hpp"
+#include "fggl/debug/logging.hpp"
+
+namespace fggl::platform {
+
+	namespace {
+		inline auto get_user_path(const char *env, const char *fallback) -> std::filesystem::path {
+			const char *path = std::getenv(env);
+			if (path != nullptr) {
+				return {path};
+			}
+			return {fallback};
+		}
+
+		auto get_path_list(const char *env, const char *folderName) -> std::vector<std::filesystem::path> {
+			const char *pathList = std::getenv(env);
+			std::vector<std::filesystem::path> paths;
+			if (pathList) {
+				std::string pathListStr(pathList);
+				std::string::size_type pos = 0;
+				while (pos < pathListStr.size()) {
+					std::string::size_type nextPos = pathListStr.find(':', pos);
+					if (nextPos == std::string::npos) {
+						nextPos = pathListStr.size();
+					}
+					std::string path = pathListStr.substr(pos, nextPos - pos);
+					paths.push_back(std::filesystem::path(path) / folderName);
+					pos = nextPos + 1;
+				}
+			}
+			return paths;
+		}
+	}
+
+	auto calc_engine_paths(const char *base) -> EnginePaths {
+		auto dataDirs = get_path_list(ENV_DATA_DIRS, base);
+		if (dataDirs.empty()) {
+			for (const auto &defaultDir : DEFAULT_DATA_DIRS) {
+				dataDirs.push_back(std::filesystem::path(defaultDir) / base);
+			}
+		}
+
+		auto configDirs = get_path_list(ENV_CONFIG_DIRS, base);
+		if (configDirs.empty()) {
+			for (const auto &defaultDir : DEFAULT_CONFIG_DIRS) {
+				configDirs.push_back(std::filesystem::path(defaultDir) / base);
+			}
+		}
+
+		return EnginePaths{
+			get_user_path(ENV_USER_CONFIG, DEFAULT_USER_CONFIG) / base,
+			get_user_path(ENV_USER_DATA, DEFAULT_USER_DATA) / base,
+			get_user_path(ENV_USER_CACHE, DEFAULT_USER_CACHE) / base,
+			dataDirs,
+			configDirs
+		};
+	}
+
+	auto locate_data(const EnginePaths &paths, const std::filesystem::path &relPath) -> std::filesystem::path {
+		auto userPath = paths.userData / relPath;
+		if (std::filesystem::exists(userPath)) {
+			return userPath;
+		}
+
+		// check system paths
+		for (const auto &path : paths.dataDirs) {
+			auto fullPath = path / relPath;
+			debug::trace("Checking data path: {}, exists: {}", fullPath.c_str(), std::filesystem::exists(fullPath));
+			if (std::filesystem::exists(fullPath)) {
+				return fullPath;
+			}
+		}
+
+		// if debug mode, try CWD as well.
+		auto debugPath = std::filesystem::current_path() / "data" / relPath;
+		if (std::filesystem::exists(debugPath)) {
+			debug::trace("Checking debug path: {}, exists: {}", debugPath.c_str(), std::filesystem::exists(debugPath));
+			return debugPath;
+		}
+
+		// if the file existed, it should exist in the user space
+		return userPath;
+	}
+
+	auto locate_config(const EnginePaths &paths, const std::filesystem::path &relPath) -> std::filesystem::path {
+		auto userPath = paths.userConfig / relPath;
+		if (std::filesystem::exists(userPath)) {
+			return userPath;
+		}
+
+		// check system paths
+		for (const auto &path : paths.configDirs) {
+			auto fullPath = path / relPath;
+			if (std::filesystem::exists(fullPath)) {
+				return fullPath;
+			}
+		}
+
+		// if the file existed, it should exist in the user space
+		return userPath;
+	}
+
+	auto locate_cache(const EnginePaths &paths, const std::filesystem::path &relPath) -> std::filesystem::path {
+		auto userPath = paths.userCache / relPath;
+		if (std::filesystem::exists(userPath)) {
+			return userPath;
+		}
+
+		// check system paths
+		for (const auto &path : paths.configDirs) {
+			auto fullPath = path / relPath;
+			if (std::filesystem::exists(fullPath)) {
+				return fullPath;
+			}
+		}
+
+		// if the file existed, it should exist in the user space
+		return userPath;
+	}
+} // namespace fggl::platform::linux

fggl/scenes/Scene.cpp

-//
-// Created by webpigeon on 20/11/2021.
-//
-
-#include "Scene.h"
-
-#include <utility>
-
-namespace fggl::scenes {
-
-    void SceneManager::create(const std::string &name, std::shared_ptr<Scene> scene) {
-        m_scenes[name] = std::move(scene);
-    }
-
-    void SceneManager::activate(const std::string &name) {
-        auto newScene = m_scenes.at(name);
-        if ( m_active != nullptr ) {
-            m_active->cleanup();
-            m_active = nullptr;
-        }
-        newScene->setup();
-        m_active = newScene;
-    }
-
-}
\ No newline at end of file

fggl/scenes/Scene.h

-//
-// Created by webpigeon on 20/11/2021.
-//
-
-#ifndef FGGL_SCENE_H
-#define FGGL_SCENE_H
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-
-namespace fggl::scenes {
-
-    class Scene {
-        public:
-            virtual ~Scene() = default;
-
-            virtual void setup() = 0;
-            virtual void cleanup() = 0;
-
-            virtual void update() = 0;
-            virtual void render() = 0;
-    };
-
-    class SceneManager {
-        public:
-            SceneManager() = default;
-
-            void create(const std::string& name, std::shared_ptr<Scene> scene);
-            void activate(const std::string& name);
-
-            inline void update() {
-                if ( m_active == nullptr ) { return; }
-                m_active->update();
-            }
-
-            inline void render() {
-                if ( m_active == nullptr ) { return; }
-                m_active->render();
-            }
-
-        private:
-            std::shared_ptr<Scene> m_active;
-            std::unordered_map<std::string, std::shared_ptr<Scene>> m_scenes;
-    };
-
-}
-
-#endif //FGGL_SCENE_H

fggl/scenes/game.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 23/04/22.
+//
+
+#include "fggl/scenes/game.hpp"
+
+#if __has_include("fggl/phys/bullet/bullet.hpp")
+	#include "fggl/phys/bullet/bullet.hpp"
+#endif
+
+namespace fggl::scenes {
+
+	GameBase::GameBase(fggl::App& app) : AppState(app) {
+		m_input = app.service<input::Input>();
+	}
+
+	void GameBase::update(float /*dt*/) {
+		// detect the user quitting
+		if (m_input != nullptr) {
+			bool escapePressed = m_input->keyboard.pressed(glfwGetKeyScancode(GLFW_KEY_ESCAPE));
+			if (escapePressed) {
+				m_owner.change_state(m_previous);
+			}
+		}
+	}
+
+	Game::Game(fggl::App &app) : AppState(app) {
+		m_input = app.service<input::Input>();
+	}
+
+	void Game::activate() {
+		fggl::AppState::activate();
+
+		// setup the scene
+		m_world = std::make_unique<entity::EntityManager>();
+
+		#ifdef FGGL_MODULE_BULLET
+		// FIXME this ties bullet to the game state - which shouldn't be the case
+		m_phys = std::make_unique<fggl::phys::bullet::BulletPhysicsEngine>(m_world.get());
+		#endif
+	}
+
+	void Game::deactivate() {
+		m_phys.reset();
+		m_world.reset();
+	}
+
+	void Game::update(float /*dt*/) {
+		assert(m_world && "called game update, but there was no world - was activate called?");
+
+		if (m_input != nullptr) {
+			bool escapePressed = m_input->keyboard.pressed(glfwGetKeyScancode(GLFW_KEY_ESCAPE));
+			if (escapePressed) {
+				m_owner.change_state(m_previous);
+			}
+
+			if ( m_input->keyboard.pressed(glfwGetKeyScancode(GLFW_KEY_F2)) ) {
+				m_debug = !m_debug;
+			}
+		}
+
+		if (m_phys != nullptr) {
+			m_phys->step();
+		}
+
+		// debug render toggle
+		//m_world->reapEntities();
+	}
+
+	void Game::render(fggl::gfx::Graphics &gfx) {
+		if (m_world != nullptr) {
+			gfx.drawScene(*m_world, m_debug);
+		}
+	}
+
+} // namespace demo
+

fggl/scenes/menu.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <fggl/scenes/menu.hpp>
+#include <fggl/gui/gui.hpp>
+
+#include <spdlog/spdlog.h>
+
+namespace fggl::scenes {
+
+	using fggl::input::MouseButton;
+	using fggl::input::MouseAxis;
+
+	constexpr float SCREEN_WIDTH = 1920.0F;
+	constexpr float SCREEN_HEIGHT = 1080.0F;
+
+	BasicMenu::BasicMenu(fggl::App &app) : AppState(app), m_inputs(app.service<input::Input>()), m_active(), m_cursorPos(), m_hover(nullptr) {
+	}
+
+	void BasicMenu::update(float /*dt*/) {
+		if (m_inputs != nullptr) {
+			m_cursorPos.x = m_inputs->mouse.axis(MouseAxis::X);
+			m_cursorPos.y = m_inputs->mouse.axis(MouseAxis::Y);
+
+			// in canvas space
+			math::vec2 projected;
+			projected.x = math::rescale_ndc(m_cursorPos.x, 0, SCREEN_WIDTH);
+			projected.y = math::rescale_ndc(m_cursorPos.y, 0, SCREEN_HEIGHT);
+			m_canvas.onMouseOver(projected);
+
+			if (m_inputs->mouse.pressed(MouseButton::LEFT)) {
+				auto* widget = m_canvas.getChildAt(projected);
+				if (widget != nullptr) {
+					widget->activate();
+				}
+			}
+		}
+	}
+
+	void BasicMenu::render(gfx::Graphics &gfx) {
+		// render the 2D scene (we don't have a 3D scene to worry about in menus)
+		gfx::Paint paint;
+		m_canvas.render(paint);
+		gfx.draw2D(paint);
+	}
+
+	void BasicMenu::activate() {
+
+	}
+
+	void BasicMenu::deactivate() {
+
+	}
+
+	void BasicMenu::add(const std::string &name, const Callback& callback) {
+		m_items[name] = callback;
+
+		const math::vec2 btnSize{150.0F, 30.0F};
+		const float spacing = 5;
+		const float padX = 50.0F;
+		const float padY = 50.0F;
+
+		// figure out the position based off the old logic
+		// FIXME should be the container's job
+		math::vec2 pos{SCREEN_WIDTH - (padX + btnSize.x), padY};
+		pos.y += ( (m_items.size()-1.0F) * (btnSize.y + spacing));
+
+		// build the button
+		auto btn = std::make_unique<gui::Button>(pos, btnSize);
+		btn->label(name);
+		btn->addCallback(callback);
+		m_canvas.add(std::move(btn));
+	}
+
+};

fggl/stb/stb_connected_components.h

+// stb_connected_components - v0.96 - public domain connected components on grids
+//                                                 http://github.com/nothings/stb
+//
+// Finds connected components on 2D grids for testing reachability between
+// two points, with fast updates when changing reachability (e.g. on one machine
+// it was typically 0.2ms w/ 1024x1024 grid). Each grid square must be "open" or
+// "closed" (traversable or untraversable), and grid squares are only connected
+// to their orthogonal neighbors, not diagonally.
+//
+// In one source file, create the implementation by doing something like this:
+//
+//   #define STBCC_GRID_COUNT_X_LOG2    10
+//   #define STBCC_GRID_COUNT_Y_LOG2    10
+//   #define STB_CONNECTED_COMPONENTS_IMPLEMENTATION
+//   #include "stb_connected_components.h"
+//
+// The above creates an implementation that can run on maps up to 1024x1024.
+// Map sizes must be a multiple of (1<<(LOG2/2)) on each axis (e.g. 32 if LOG2=10,
+// 16 if LOG2=8, etc.) (You can just pad your map with untraversable space.)
+//
+// MEMORY USAGE
+//
+//   Uses about 6-7 bytes per grid square (e.g. 7MB for a 1024x1024 grid).
+//   Uses a single worst-case allocation which you pass in.
+//
+// PERFORMANCE
+//
+//   On a core i7-2700K at 3.5 Ghz, for a particular 1024x1024 map (map_03.png):
+//
+//       Creating map                   : 44.85 ms
+//       Making one square   traversable:  0.27 ms    (average over 29,448 calls)
+//       Making one square untraversable:  0.23 ms    (average over 30,123 calls)
+//       Reachability query:               0.00001 ms (average over 4,000,000 calls)
+//
+//   On non-degenerate maps update time is O(N^0.5), but on degenerate maps like
+//   checkerboards or 50% random, update time is O(N^0.75) (~2ms on above machine).
+//
+// CHANGELOG
+//
+//    0.96  (2019-03-04)  Fix warnings
+//    0.95  (2016-10-16)  Bugfix if multiple clumps in one cluster connect to same clump in another
+//    0.94  (2016-04-17)  Bugfix & optimize worst case (checkerboard & random)
+//    0.93  (2016-04-16)  Reduce memory by 10x for 1Kx1K map; small speedup
+//    0.92  (2016-04-16)  Compute sqrt(N) cluster size by default
+//    0.91  (2016-04-15)  Initial release
+//
+// TODO:
+//    - better API documentation
+//    - more comments
+//    - try re-integrating naive algorithm & compare performance
+//    - more optimized batching (current approach still recomputes local clumps many times)
+//    - function for setting a grid of squares at once (just use batching)
+//
+// LICENSE
+//
+//   See end of file for license information.
+//
+// ALGORITHM
+//
+//   The NxN grid map is split into sqrt(N) x sqrt(N) blocks called
+//  "clusters". Each cluster independently computes a set of connected
+//   components within that cluster (ignoring all connectivity out of
+//   that cluster) using a union-find disjoint set forest. This produces a bunch
+//   of locally connected components called "clumps". Each clump is (a) connected
+//   within its cluster, (b) does not directly connect to any other clumps in the
+//   cluster (though it may connect to them by paths that lead outside the cluster,
+//   but those are ignored at this step), and (c) maintains an adjacency list of
+//   all clumps in adjacent clusters that it _is_ connected to. Then a second
+//   union-find disjoint set forest is used to compute connected clumps
+//   globally, across the whole map. Reachability is then computed by
+//   finding which clump each input point belongs to, and checking whether
+//   those clumps are in the same "global" connected component.
+//
+//   The above data structure can be updated efficiently; on a change
+//   of a single grid square on the map, only one cluster changes its
+//   purely-local state, so only one cluster needs its clumps fully
+//   recomputed. Clumps in adjacent clusters need their adjacency lists
+//   updated: first to remove all references to the old clumps in the
+//   rebuilt cluster, then to add new references to the new clumps. Both
+//   of these operations can use the existing "find which clump each input
+//   point belongs to" query to compute that adjacency information rapidly.
+
+#ifndef INCLUDE_STB_CONNECTED_COMPONENTS_H
+#define INCLUDE_STB_CONNECTED_COMPONENTS_H
+
+#include <stdlib.h>
+
+typedef struct st_stbcc_grid stbcc_grid;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//
+//  initialization
+//
+
+// you allocate the grid data structure to this size (note that it will be very big!!!)
+extern size_t stbcc_grid_sizeof(void);
+
+// initialize the grid, value of map[] is 0 = traversable, non-0 is solid
+extern void stbcc_init_grid(stbcc_grid *g, unsigned char *map, int w, int h);
+
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//
+//  main functionality
+//
+
+// update a grid square state, 0 = traversable, non-0 is solid
+// i can add a batch-update if it's needed
+extern void stbcc_update_grid(stbcc_grid *g, int x, int y, int solid);
+
+// query if two grid squares are reachable from each other
+extern int stbcc_query_grid_node_connection(stbcc_grid *g, int x1, int y1, int x2, int y2);
+
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//
+//  bonus functions
+//
+
+// wrap multiple stbcc_update_grid calls in these function to compute
+// multiple updates more efficiently; cannot make queries inside batch
+extern void stbcc_update_batch_begin(stbcc_grid *g);
+extern void stbcc_update_batch_end(stbcc_grid *g);
+
+// query the grid data structure for whether a given square is open or not
+extern int stbcc_query_grid_open(stbcc_grid *g, int x, int y);
+
+// get a unique id for the connected component this is in; it's not necessarily
+// small, you'll need a hash table or something to remap it (or just use
+extern unsigned int stbcc_get_unique_id(stbcc_grid *g, int x, int y);
+#define STBCC_NULL_UNIQUE_ID 0xffffffff // returned for closed map squares
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // INCLUDE_STB_CONNECTED_COMPONENTS_H
+
+#ifdef STB_CONNECTED_COMPONENTS_IMPLEMENTATION
+
+#include <assert.h>
+#include <string.h> // memset
+
+#if !defined(STBCC_GRID_COUNT_X_LOG2) || !defined(STBCC_GRID_COUNT_Y_LOG2)
+	#error "You must define STBCC_GRID_COUNT_X_LOG2 and STBCC_GRID_COUNT_Y_LOG2 to define the max grid supported."
+#endif
+
+#define STBCC__GRID_COUNT_X (1 << STBCC_GRID_COUNT_X_LOG2)
+#define STBCC__GRID_COUNT_Y (1 << STBCC_GRID_COUNT_Y_LOG2)
+
+#define STBCC__MAP_STRIDE   (1 << (STBCC_GRID_COUNT_X_LOG2-3))
+
+#ifndef STBCC_CLUSTER_SIZE_X_LOG2
+	#define STBCC_CLUSTER_SIZE_X_LOG2   (STBCC_GRID_COUNT_X_LOG2/2) // log2(sqrt(2^N)) = 1/2 * log2(2^N)) = 1/2 * N
+	#if STBCC_CLUSTER_SIZE_X_LOG2 > 6
+		#undef STBCC_CLUSTER_SIZE_X_LOG2
+		#define STBCC_CLUSTER_SIZE_X_LOG2 6
+	#endif
+#endif
+
+#ifndef STBCC_CLUSTER_SIZE_Y_LOG2
+	#define STBCC_CLUSTER_SIZE_Y_LOG2   (STBCC_GRID_COUNT_Y_LOG2/2)
+	#if STBCC_CLUSTER_SIZE_Y_LOG2 > 6
+		#undef STBCC_CLUSTER_SIZE_Y_LOG2
+		#define STBCC_CLUSTER_SIZE_Y_LOG2 6
+	#endif
+#endif
+
+#define STBCC__CLUSTER_SIZE_X   (1 << STBCC_CLUSTER_SIZE_X_LOG2)
+#define STBCC__CLUSTER_SIZE_Y   (1 << STBCC_CLUSTER_SIZE_Y_LOG2)
+
+#define STBCC__CLUSTER_COUNT_X_LOG2   (STBCC_GRID_COUNT_X_LOG2 - STBCC_CLUSTER_SIZE_X_LOG2)
+#define STBCC__CLUSTER_COUNT_Y_LOG2   (STBCC_GRID_COUNT_Y_LOG2 - STBCC_CLUSTER_SIZE_Y_LOG2)
+
+#define STBCC__CLUSTER_COUNT_X  (1 << STBCC__CLUSTER_COUNT_X_LOG2)
+#define STBCC__CLUSTER_COUNT_Y  (1 << STBCC__CLUSTER_COUNT_Y_LOG2)
+
+#if STBCC__CLUSTER_SIZE_X >= STBCC__GRID_COUNT_X || STBCC__CLUSTER_SIZE_Y >= STBCC__GRID_COUNT_Y
+	#error "STBCC_CLUSTER_SIZE_X/Y_LOG2 must be smaller than STBCC_GRID_COUNT_X/Y_LOG2"
+#endif
+
+// worst case # of clumps per cluster
+#define STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2   (STBCC_CLUSTER_SIZE_X_LOG2 + STBCC_CLUSTER_SIZE_Y_LOG2-1)
+#define STBCC__MAX_CLUMPS_PER_CLUSTER        (1 << STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2)
+#define STBCC__MAX_CLUMPS                    (STBCC__MAX_CLUMPS_PER_CLUSTER * STBCC__CLUSTER_COUNT_X * STBCC__CLUSTER_COUNT_Y)
+#define STBCC__NULL_CLUMPID                  STBCC__MAX_CLUMPS_PER_CLUSTER
+
+#define STBCC__CLUSTER_X_FOR_COORD_X(x)  ((x) >> STBCC_CLUSTER_SIZE_X_LOG2)
+#define STBCC__CLUSTER_Y_FOR_COORD_Y(y)  ((y) >> STBCC_CLUSTER_SIZE_Y_LOG2)
+
+#define STBCC__MAP_BYTE_MASK(x,y)       (1 << ((x) & 7))
+#define STBCC__MAP_BYTE(g,x,y)          ((g)->map[y][(x) >> 3])
+#define STBCC__MAP_OPEN(g,x,y)          (STBCC__MAP_BYTE(g,x,y) & STBCC__MAP_BYTE_MASK(x,y))
+
+typedef unsigned short stbcc__clumpid;
+typedef unsigned char stbcc__verify_max_clumps[STBCC__MAX_CLUMPS_PER_CLUSTER < (1 << (8*sizeof(stbcc__clumpid))) ? 1 : -1];
+
+#define STBCC__MAX_EXITS_PER_CLUSTER   (STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y)   // 64 for 32x32
+#define STBCC__MAX_EXITS_PER_CLUMP     (STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y)   // 64 for 32x32
+#define STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER  (STBCC__MAX_EXITS_PER_CLUMP)
+
+// 2^19 * 2^6 => 2^25 exits => 2^26  => 64MB for 1024x1024
+
+// Logic for above on 4x4 grid:
+//
+// Many clumps:      One clump:
+//   + +               +  +
+//  +X.X.             +XX.X+
+//   .X.X+             .XXX
+//  +X.X.              XXX.
+//   .X.X+            +X.XX+
+//    + +              +  +
+//
+// 8 exits either way
+
+typedef unsigned char stbcc__verify_max_exits[STBCC__MAX_EXITS_PER_CLUMP <= 256];
+
+typedef struct
+{
+   unsigned short clump_index:12;
+	 signed short cluster_dx:2;
+	 signed short cluster_dy:2;
+} stbcc__relative_clumpid;
+
+typedef union
+{
+   struct {
+	  unsigned int clump_index:12;
+	  unsigned int cluster_x:10;
+	  unsigned int cluster_y:10;
+   } f;
+   unsigned int c;
+} stbcc__global_clumpid;
+
+// rebuilt cluster 3,4
+
+// what changes in cluster 2,4
+
+typedef struct
+{
+   stbcc__global_clumpid global_label;        // 4
+   unsigned char num_adjacent;                // 1
+   unsigned char max_adjacent;                // 1
+   unsigned char adjacent_clump_list_index;   // 1
+   unsigned char reserved;
+} stbcc__clump; // 8
+
+#define STBCC__CLUSTER_ADJACENCY_COUNT   (STBCC__MAX_EXITS_PER_CLUSTER*2)
+typedef struct
+{
+   short num_clumps;
+   unsigned char num_edge_clumps;
+   unsigned char rebuild_adjacency;
+   stbcc__clump clump[STBCC__MAX_CLUMPS_PER_CLUSTER];       // 8 * 2^9 = 4KB
+   stbcc__relative_clumpid adjacency_storage[STBCC__CLUSTER_ADJACENCY_COUNT]; // 256 bytes
+} stbcc__cluster;
+
+struct st_stbcc_grid
+{
+   int w,h,cw,ch;
+   int in_batched_update;
+   //unsigned char cluster_dirty[STBCC__CLUSTER_COUNT_Y][STBCC__CLUSTER_COUNT_X]; // could bitpack, but: 1K x 1K => 1KB
+   unsigned char map[STBCC__GRID_COUNT_Y][STBCC__MAP_STRIDE]; // 1K x 1K => 1K x 128 => 128KB
+   stbcc__clumpid clump_for_node[STBCC__GRID_COUNT_Y][STBCC__GRID_COUNT_X];  // 1K x 1K x 2 = 2MB
+   stbcc__cluster cluster[STBCC__CLUSTER_COUNT_Y][STBCC__CLUSTER_COUNT_X]; //  1K x 4.5KB = 4.5MB
+};
+
+int stbcc_query_grid_node_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)
+{
+   stbcc__global_clumpid label1, label2;
+   stbcc__clumpid c1 = g->clump_for_node[y1][x1];
+   stbcc__clumpid c2 = g->clump_for_node[y2][x2];
+   int cx1 = STBCC__CLUSTER_X_FOR_COORD_X(x1);
+   int cy1 = STBCC__CLUSTER_Y_FOR_COORD_Y(y1);
+   int cx2 = STBCC__CLUSTER_X_FOR_COORD_X(x2);
+   int cy2 = STBCC__CLUSTER_Y_FOR_COORD_Y(y2);
+   assert(!g->in_batched_update);
+   if (c1 == STBCC__NULL_CLUMPID || c2 == STBCC__NULL_CLUMPID)
+	  return 0;
+   label1 = g->cluster[cy1][cx1].clump[c1].global_label;
+   label2 = g->cluster[cy2][cx2].clump[c2].global_label;
+   if (label1.c == label2.c)
+	  return 1;
+   return 0;
+}
+
+int stbcc_query_grid_open(stbcc_grid *g, int x, int y)
+{
+   return STBCC__MAP_OPEN(g, x, y) != 0;
+}
+
+unsigned int stbcc_get_unique_id(stbcc_grid *g, int x, int y)
+{
+   stbcc__clumpid c = g->clump_for_node[y][x];
+   int cx = STBCC__CLUSTER_X_FOR_COORD_X(x);
+   int cy = STBCC__CLUSTER_Y_FOR_COORD_Y(y);
+   assert(!g->in_batched_update);
+   if (c == STBCC__NULL_CLUMPID) return STBCC_NULL_UNIQUE_ID;
+   return g->cluster[cy][cx].clump[c].global_label.c;
+}
+
+typedef struct
+{
+   unsigned char x,y;
+} stbcc__tinypoint;
+
+typedef struct
+{
+   stbcc__tinypoint parent[STBCC__CLUSTER_SIZE_Y][STBCC__CLUSTER_SIZE_X]; // 32x32 => 2KB
+   stbcc__clumpid   label[STBCC__CLUSTER_SIZE_Y][STBCC__CLUSTER_SIZE_X];
+} stbcc__cluster_build_info;
+
+static void stbcc__build_clumps_for_cluster(stbcc_grid *g, int cx, int cy);
+static void stbcc__remove_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy);
+static void stbcc__add_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy);
+
+static stbcc__global_clumpid stbcc__clump_find(stbcc_grid *g, stbcc__global_clumpid n)
+{
+   stbcc__global_clumpid q;
+   stbcc__clump *c = &g->cluster[n.f.cluster_y][n.f.cluster_x].clump[n.f.clump_index];
+
+   if (c->global_label.c == n.c)
+	  return n;
+
+   q = stbcc__clump_find(g, c->global_label);
+   c->global_label = q;
+   return q;
+}
+
+typedef struct
+{
+   unsigned int cluster_x;
+   unsigned int cluster_y;
+   unsigned int clump_index;
+} stbcc__unpacked_clumpid;
+
+static void stbcc__clump_union(stbcc_grid *g, stbcc__unpacked_clumpid m, int x, int y, int idx)
+{
+   stbcc__clump *mc = &g->cluster[m.cluster_y][m.cluster_x].clump[m.clump_index];
+   stbcc__clump *nc = &g->cluster[y][x].clump[idx];
+   stbcc__global_clumpid mp = stbcc__clump_find(g, mc->global_label);
+   stbcc__global_clumpid np = stbcc__clump_find(g, nc->global_label);
+
+   if (mp.c == np.c)
+	  return;
+
+   g->cluster[mp.f.cluster_y][mp.f.cluster_x].clump[mp.f.clump_index].global_label = np;
+}
+
+static void stbcc__build_connected_components_for_clumps(stbcc_grid *g)
+{
+   int i,j,k,h;
+
+   for (j=0; j < STBCC__CLUSTER_COUNT_Y; ++j) {
+	  for (i=0; i < STBCC__CLUSTER_COUNT_X; ++i) {
+		 stbcc__cluster *cluster = &g->cluster[j][i];
+		 for (k=0; k < (int) cluster->num_edge_clumps; ++k) {
+			stbcc__global_clumpid m;
+			m.f.clump_index = k;
+			m.f.cluster_x = i;
+			m.f.cluster_y = j;
+			assert((int) m.f.clump_index == k && (int) m.f.cluster_x == i && (int) m.f.cluster_y == j);
+			cluster->clump[k].global_label = m;
+		 }
+	  }
+   }
+
+   for (j=0; j < STBCC__CLUSTER_COUNT_Y; ++j) {
+	  for (i=0; i < STBCC__CLUSTER_COUNT_X; ++i) {
+		 stbcc__cluster *cluster = &g->cluster[j][i];
+		 for (k=0; k < (int) cluster->num_edge_clumps; ++k) {
+			stbcc__clump *clump = &cluster->clump[k];
+			stbcc__unpacked_clumpid m;
+			stbcc__relative_clumpid *adj;
+			m.clump_index = k;
+			m.cluster_x = i;
+			m.cluster_y = j;
+			adj = &cluster->adjacency_storage[clump->adjacent_clump_list_index];
+			for (h=0; h < clump->num_adjacent; ++h) {
+			   unsigned int clump_index = adj[h].clump_index;
+			   unsigned int x = adj[h].cluster_dx + i;
+			   unsigned int y = adj[h].cluster_dy + j;
+			   stbcc__clump_union(g, m, x, y, clump_index);
+			}
+		 }
+	  }
+   }
+
+   for (j=0; j < STBCC__CLUSTER_COUNT_Y; ++j) {
+	  for (i=0; i < STBCC__CLUSTER_COUNT_X; ++i) {
+		 stbcc__cluster *cluster = &g->cluster[j][i];
+		 for (k=0; k < (int) cluster->num_edge_clumps; ++k) {
+			stbcc__global_clumpid m;
+			m.f.clump_index = k;
+			m.f.cluster_x = i;
+			m.f.cluster_y = j;
+			stbcc__clump_find(g, m);
+		 }
+	  }
+   }
+}
+
+static void stbcc__build_all_connections_for_cluster(stbcc_grid *g, int cx, int cy)
+{
+   // in this particular case, we are fully non-incremental. that means we
+   // can discover the correct sizes for the arrays, but requires we build
+   // the data into temporary data structures, or just count the sizes, so
+   // for simplicity we do the latter
+   stbcc__cluster *cluster = &g->cluster[cy][cx];
+   unsigned char connected[STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER][STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER/8]; // 64 x 8 => 1KB
+   unsigned char num_adj[STBCC__MAX_CLUMPS_PER_CLUSTER] = { 0 };
+   int x = cx * STBCC__CLUSTER_SIZE_X;
+   int y = cy * STBCC__CLUSTER_SIZE_Y;
+   int step_x, step_y=0, i, j, k, n, m, dx, dy, total;
+   int extra;
+
+   g->cluster[cy][cx].rebuild_adjacency = 0;
+
+   total = 0;
+   for (m=0; m < 4; ++m) {
+	  switch (m) {
+		 case 0:
+			dx = 1, dy = 0;
+			step_x = 0, step_y = 1;
+			i = STBCC__CLUSTER_SIZE_X-1;
+			j = 0;
+			n = STBCC__CLUSTER_SIZE_Y;
+			break;
+		 case 1:
+			dx = -1, dy = 0;
+			i = 0;
+			j = 0;
+			step_x = 0;
+			step_y = 1;
+			n = STBCC__CLUSTER_SIZE_Y;
+			break;
+		 case 2:
+			dy = -1, dx = 0;
+			i = 0;
+			j = 0;
+			step_x = 1;
+			step_y = 0;
+			n = STBCC__CLUSTER_SIZE_X;
+			break;
+		 case 3:
+			dy = 1, dx = 0;
+			i = 0;
+			j = STBCC__CLUSTER_SIZE_Y-1;
+			step_x = 1;
+			step_y = 0;
+			n = STBCC__CLUSTER_SIZE_X;
+			break;
+	  }
+
+	  if (cx+dx < 0 || cx+dx >= g->cw || cy+dy < 0 || cy+dy >= g->ch)
+		 continue;
+
+	  memset(connected, 0, sizeof(connected));
+	  for (k=0; k < n; ++k) {
+		 if (STBCC__MAP_OPEN(g, x+i, y+j) && STBCC__MAP_OPEN(g, x+i+dx, y+j+dy)) {
+			stbcc__clumpid src = g->clump_for_node[y+j][x+i];
+			stbcc__clumpid dest = g->clump_for_node[y+j+dy][x+i+dx];
+			if (0 == (connected[src][dest>>3] & (1 << (dest & 7)))) {
+			   connected[src][dest>>3] |= 1 << (dest & 7);
+			   ++num_adj[src];
+			   ++total;
+			}
+		 }
+		 i += step_x;
+		 j += step_y;
+	  }
+   }
+
+   assert(total <= STBCC__CLUSTER_ADJACENCY_COUNT);
+
+   // decide how to apportion unused adjacency slots; only clumps that lie
+   // on the edges of the cluster need adjacency slots, so divide them up
+   // evenly between those clumps
+
+   // we want:
+   //    extra = (STBCC__CLUSTER_ADJACENCY_COUNT - total) / cluster->num_edge_clumps;
+   // but we efficiently approximate this without a divide, because
+   // ignoring edge-vs-non-edge with 'num_adj[i]*2' was faster than
+   // 'num_adj[i]+extra' with the divide
+   if      (total + (cluster->num_edge_clumps<<2) <= STBCC__CLUSTER_ADJACENCY_COUNT)
+	  extra = 4;
+   else if (total + (cluster->num_edge_clumps<<1) <= STBCC__CLUSTER_ADJACENCY_COUNT)
+	  extra = 2;
+   else if (total + (cluster->num_edge_clumps<<0) <= STBCC__CLUSTER_ADJACENCY_COUNT)
+	  extra = 1;
+   else
+	  extra = 0;
+
+   total = 0;
+   for (i=0; i < (int) cluster->num_edge_clumps; ++i) {
+	  int alloc = num_adj[i]+extra;
+	  if (alloc > STBCC__MAX_EXITS_PER_CLUSTER)
+		 alloc = STBCC__MAX_EXITS_PER_CLUSTER;
+	  assert(total < 256); // must fit in byte
+	  cluster->clump[i].adjacent_clump_list_index = (unsigned char) total;
+	  cluster->clump[i].max_adjacent = alloc;
+	  cluster->clump[i].num_adjacent = 0;
+	  total += alloc;
+   }
+   assert(total <= STBCC__CLUSTER_ADJACENCY_COUNT);
+
+   stbcc__add_connections_to_adjacent_cluster(g, cx, cy, -1, 0);
+   stbcc__add_connections_to_adjacent_cluster(g, cx, cy,  1, 0);
+   stbcc__add_connections_to_adjacent_cluster(g, cx, cy,  0,-1);
+   stbcc__add_connections_to_adjacent_cluster(g, cx, cy,  0, 1);
+   // make sure all of the above succeeded.
+   assert(g->cluster[cy][cx].rebuild_adjacency == 0);
+}
+
+static void stbcc__add_connections_to_adjacent_cluster_with_rebuild(stbcc_grid *g, int cx, int cy, int dx, int dy)
+{
+   if (cx >= 0 && cx < g->cw && cy >= 0 && cy < g->ch) {
+	  stbcc__add_connections_to_adjacent_cluster(g, cx, cy, dx, dy);
+	  if (g->cluster[cy][cx].rebuild_adjacency)
+		 stbcc__build_all_connections_for_cluster(g, cx, cy);
+   }
+}
+
+void stbcc_update_grid(stbcc_grid *g, int x, int y, int solid)
+{
+   int cx,cy;
+
+   if (!solid) {
+	  if (STBCC__MAP_OPEN(g,x,y))
+		 return;
+   } else {
+	  if (!STBCC__MAP_OPEN(g,x,y))
+		 return;
+   }
+
+   cx = STBCC__CLUSTER_X_FOR_COORD_X(x);
+   cy = STBCC__CLUSTER_Y_FOR_COORD_Y(y);
+
+   stbcc__remove_connections_to_adjacent_cluster(g, cx-1, cy,  1, 0);
+   stbcc__remove_connections_to_adjacent_cluster(g, cx+1, cy, -1, 0);
+   stbcc__remove_connections_to_adjacent_cluster(g, cx, cy-1,  0, 1);
+   stbcc__remove_connections_to_adjacent_cluster(g, cx, cy+1,  0,-1);
+
+   if (!solid)
+	  STBCC__MAP_BYTE(g,x,y) |= STBCC__MAP_BYTE_MASK(x,y);
+   else
+	  STBCC__MAP_BYTE(g,x,y) &= ~STBCC__MAP_BYTE_MASK(x,y);
+
+   stbcc__build_clumps_for_cluster(g, cx, cy);
+   stbcc__build_all_connections_for_cluster(g, cx, cy);
+
+   stbcc__add_connections_to_adjacent_cluster_with_rebuild(g, cx-1, cy,  1, 0);
+   stbcc__add_connections_to_adjacent_cluster_with_rebuild(g, cx+1, cy, -1, 0);
+   stbcc__add_connections_to_adjacent_cluster_with_rebuild(g, cx, cy-1,  0, 1);
+   stbcc__add_connections_to_adjacent_cluster_with_rebuild(g, cx, cy+1,  0,-1);
+
+   if (!g->in_batched_update)
+	  stbcc__build_connected_components_for_clumps(g);
+#if 0
+   else
+	  g->cluster_dirty[cy][cx] = 1;
+#endif
+}
+
+void stbcc_update_batch_begin(stbcc_grid *g)
+{
+   assert(!g->in_batched_update);
+   g->in_batched_update = 1;
+}
+
+void stbcc_update_batch_end(stbcc_grid *g)
+{
+   assert(g->in_batched_update);
+   g->in_batched_update =  0;
+   stbcc__build_connected_components_for_clumps(g); // @OPTIMIZE: only do this if update was non-empty
+}
+
+size_t stbcc_grid_sizeof(void)
+{
+   return sizeof(stbcc_grid);
+}
+
+void stbcc_init_grid(stbcc_grid *g, unsigned char *map, int w, int h)
+{
+   int i,j,k;
+   assert(w % STBCC__CLUSTER_SIZE_X == 0);
+   assert(h % STBCC__CLUSTER_SIZE_Y == 0);
+   assert(w % 8 == 0);
+
+   g->w = w;
+   g->h = h;
+   g->cw = w >> STBCC_CLUSTER_SIZE_X_LOG2;
+   g->ch = h >> STBCC_CLUSTER_SIZE_Y_LOG2;
+   g->in_batched_update = 0;
+
+#if 0
+   for (j=0; j < STBCC__CLUSTER_COUNT_Y; ++j)
+	  for (i=0; i < STBCC__CLUSTER_COUNT_X; ++i)
+		 g->cluster_dirty[j][i] = 0;
+#endif
+
+   for (j=0; j < h; ++j) {
+	  for (i=0; i < w; i += 8) {
+		 unsigned char c = 0;
+		 for (k=0; k < 8; ++k)
+			if (map[j*w + (i+k)] == 0)
+			   c |= (1 << k);
+		 g->map[j][i>>3] = c;
+	  }
+   }
+
+   for (j=0; j < g->ch; ++j)
+	  for (i=0; i < g->cw; ++i)
+		 stbcc__build_clumps_for_cluster(g, i, j);
+
+   for (j=0; j < g->ch; ++j)
+	  for (i=0; i < g->cw; ++i)
+		 stbcc__build_all_connections_for_cluster(g, i, j);
+
+   stbcc__build_connected_components_for_clumps(g);
+
+   for (j=0; j < g->h; ++j)
+	  for (i=0; i < g->w; ++i)
+		 assert(g->clump_for_node[j][i] <= STBCC__NULL_CLUMPID);
+}
+
+
+static void stbcc__add_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)
+{
+   stbcc__cluster *cluster;
+   stbcc__clump *clump;
+
+   int cx1 = STBCC__CLUSTER_X_FOR_COORD_X(x1);
+   int cy1 = STBCC__CLUSTER_Y_FOR_COORD_Y(y1);
+   int cx2 = STBCC__CLUSTER_X_FOR_COORD_X(x2);
+   int cy2 = STBCC__CLUSTER_Y_FOR_COORD_Y(y2);
+
+   stbcc__clumpid c1 = g->clump_for_node[y1][x1];
+   stbcc__clumpid c2 = g->clump_for_node[y2][x2];
+
+   stbcc__relative_clumpid rc;
+
+   assert(cx1 != cx2 || cy1 != cy2);
+   assert(abs(cx1-cx2) + abs(cy1-cy2) == 1);
+
+   // add connection to c2 in c1
+
+   rc.clump_index = c2;
+   rc.cluster_dx = x2-x1;
+   rc.cluster_dy = y2-y1;
+
+   cluster = &g->cluster[cy1][cx1];
+   clump = &cluster->clump[c1];
+   assert(clump->num_adjacent <= clump->max_adjacent);
+   if (clump->num_adjacent == clump->max_adjacent)
+	  g->cluster[cy1][cx1].rebuild_adjacency = 1;
+   else {
+	  stbcc__relative_clumpid *adj = &cluster->adjacency_storage[clump->adjacent_clump_list_index];
+	  assert(clump->num_adjacent < STBCC__MAX_EXITS_PER_CLUMP);
+	  assert(clump->adjacent_clump_list_index + clump->num_adjacent <= STBCC__CLUSTER_ADJACENCY_COUNT);
+	  adj[clump->num_adjacent++] = rc;
+   }
+}
+
+static void stbcc__remove_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)
+{
+   stbcc__cluster *cluster;
+   stbcc__clump *clump;
+   stbcc__relative_clumpid *adj;
+   int i;
+
+   int cx1 = STBCC__CLUSTER_X_FOR_COORD_X(x1);
+   int cy1 = STBCC__CLUSTER_Y_FOR_COORD_Y(y1);
+   int cx2 = STBCC__CLUSTER_X_FOR_COORD_X(x2);
+   int cy2 = STBCC__CLUSTER_Y_FOR_COORD_Y(y2);
+
+   stbcc__clumpid c1 = g->clump_for_node[y1][x1];
+   stbcc__clumpid c2 = g->clump_for_node[y2][x2];
+
+   stbcc__relative_clumpid rc;
+
+   assert(cx1 != cx2 || cy1 != cy2);
+   assert(abs(cx1-cx2) + abs(cy1-cy2) == 1);
+
+   // add connection to c2 in c1
+
+   rc.clump_index = c2;
+   rc.cluster_dx = x2-x1;
+   rc.cluster_dy = y2-y1;
+
+   cluster = &g->cluster[cy1][cx1];
+   clump = &cluster->clump[c1];
+   adj = &cluster->adjacency_storage[clump->adjacent_clump_list_index];
+
+   for (i=0; i < clump->num_adjacent; ++i)
+	  if (rc.clump_index == adj[i].clump_index &&
+		  rc.cluster_dx  == adj[i].cluster_dx  &&
+		  rc.cluster_dy  == adj[i].cluster_dy)
+		 break;
+
+   if (i < clump->num_adjacent)
+	  adj[i] = adj[--clump->num_adjacent];
+   else
+	  assert(0);
+}
+
+static void stbcc__add_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy)
+{
+   unsigned char connected[STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER][STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER/8] = { { 0 } };
+   int x = cx * STBCC__CLUSTER_SIZE_X;
+   int y = cy * STBCC__CLUSTER_SIZE_Y;
+   int step_x, step_y=0, i, j, k, n;
+
+   if (cx < 0 || cx >= g->cw || cy < 0 || cy >= g->ch)
+	  return;
+
+   if (cx+dx < 0 || cx+dx >= g->cw || cy+dy < 0 || cy+dy >= g->ch)
+	  return;
+
+   if (g->cluster[cy][cx].rebuild_adjacency)
+	  return;
+
+   assert(abs(dx) + abs(dy) == 1);
+
+   if (dx == 1) {
+	  i = STBCC__CLUSTER_SIZE_X-1;
+	  j = 0;
+	  step_x = 0;
+	  step_y = 1;
+	  n = STBCC__CLUSTER_SIZE_Y;
+   } else if (dx == -1) {
+	  i = 0;
+	  j = 0;
+	  step_x = 0;
+	  step_y = 1;
+	  n = STBCC__CLUSTER_SIZE_Y;
+   } else if (dy == -1) {
+	  i = 0;
+	  j = 0;
+	  step_x = 1;
+	  step_y = 0;
+	  n = STBCC__CLUSTER_SIZE_X;
+   } else if (dy == 1) {
+	  i = 0;
+	  j = STBCC__CLUSTER_SIZE_Y-1;
+	  step_x = 1;
+	  step_y = 0;
+	  n = STBCC__CLUSTER_SIZE_X;
+   } else {
+	  assert(0);
+	  return;
+   }
+
+   for (k=0; k < n; ++k) {
+	  if (STBCC__MAP_OPEN(g, x+i, y+j) && STBCC__MAP_OPEN(g, x+i+dx, y+j+dy)) {
+		 stbcc__clumpid src = g->clump_for_node[y+j][x+i];
+		 stbcc__clumpid dest = g->clump_for_node[y+j+dy][x+i+dx];
+		 if (0 == (connected[src][dest>>3] & (1 << (dest & 7)))) {
+			assert((dest>>3) < sizeof(connected));
+			connected[src][dest>>3] |= 1 << (dest & 7);
+			stbcc__add_clump_connection(g, x+i, y+j, x+i+dx, y+j+dy);
+			if (g->cluster[cy][cx].rebuild_adjacency)
+			   break;
+		 }
+	  }
+	  i += step_x;
+	  j += step_y;
+   }
+}
+
+static void stbcc__remove_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy)
+{
+   unsigned char disconnected[STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER][STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER/8] = { { 0 } };
+   int x = cx * STBCC__CLUSTER_SIZE_X;
+   int y = cy * STBCC__CLUSTER_SIZE_Y;
+   int step_x, step_y=0, i, j, k, n;
+
+   if (cx < 0 || cx >= g->cw || cy < 0 || cy >= g->ch)
+	  return;
+
+   if (cx+dx < 0 || cx+dx >= g->cw || cy+dy < 0 || cy+dy >= g->ch)
+	  return;
+
+   assert(abs(dx) + abs(dy) == 1);
+
+   if (dx == 1) {
+	  i = STBCC__CLUSTER_SIZE_X-1;
+	  j = 0;
+	  step_x = 0;
+	  step_y = 1;
+	  n = STBCC__CLUSTER_SIZE_Y;
+   } else if (dx == -1) {
+	  i = 0;
+	  j = 0;
+	  step_x = 0;
+	  step_y = 1;
+	  n = STBCC__CLUSTER_SIZE_Y;
+   } else if (dy == -1) {
+	  i = 0;
+	  j = 0;
+	  step_x = 1;
+	  step_y = 0;
+	  n = STBCC__CLUSTER_SIZE_X;
+   } else if (dy == 1) {
+	  i = 0;
+	  j = STBCC__CLUSTER_SIZE_Y-1;
+	  step_x = 1;
+	  step_y = 0;
+	  n = STBCC__CLUSTER_SIZE_X;
+   } else {
+	  assert(0);
+	  return;
+   }
+
+   for (k=0; k < n; ++k) {
+	  if (STBCC__MAP_OPEN(g, x+i, y+j) && STBCC__MAP_OPEN(g, x+i+dx, y+j+dy)) {
+		 stbcc__clumpid src = g->clump_for_node[y+j][x+i];
+		 stbcc__clumpid dest = g->clump_for_node[y+j+dy][x+i+dx];
+		 if (0 == (disconnected[src][dest>>3] & (1 << (dest & 7)))) {
+			disconnected[src][dest>>3] |= 1 << (dest & 7);
+			stbcc__remove_clump_connection(g, x+i, y+j, x+i+dx, y+j+dy);
+		 }
+	  }
+	  i += step_x;
+	  j += step_y;
+   }
+}
+
+static stbcc__tinypoint stbcc__incluster_find(stbcc__cluster_build_info *cbi, int x, int y)
+{
+   stbcc__tinypoint p,q;
+   p = cbi->parent[y][x];
+   if (p.x == x && p.y == y)
+	  return p;
+   q = stbcc__incluster_find(cbi, p.x, p.y);
+   cbi->parent[y][x] = q;
+   return q;
+}
+
+static void stbcc__incluster_union(stbcc__cluster_build_info *cbi, int x1, int y1, int x2, int y2)
+{
+   stbcc__tinypoint p = stbcc__incluster_find(cbi, x1,y1);
+   stbcc__tinypoint q = stbcc__incluster_find(cbi, x2,y2);
+
+   if (p.x == q.x && p.y == q.y)
+	  return;
+
+   cbi->parent[p.y][p.x] = q;
+}
+
+static void stbcc__switch_root(stbcc__cluster_build_info *cbi, int x, int y, stbcc__tinypoint p)
+{
+   cbi->parent[p.y][p.x].x = x;
+   cbi->parent[p.y][p.x].y = y;
+   cbi->parent[y][x].x = x;
+   cbi->parent[y][x].y = y;
+}
+
+static void stbcc__build_clumps_for_cluster(stbcc_grid *g, int cx, int cy)
+{
+   stbcc__cluster *c;
+   stbcc__cluster_build_info cbi;
+   int label=0;
+   int i,j;
+   int x = cx * STBCC__CLUSTER_SIZE_X;
+   int y = cy * STBCC__CLUSTER_SIZE_Y;
+
+   // set initial disjoint set forest state
+   for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j) {
+	  for (i=0; i < STBCC__CLUSTER_SIZE_X; ++i) {
+		 cbi.parent[j][i].x = i;
+		 cbi.parent[j][i].y = j;
+	  }
+   }
+
+   // join all sets that are connected
+   for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j) {
+	  // check down only if not on bottom row
+	  if (j < STBCC__CLUSTER_SIZE_Y-1)
+		 for (i=0; i < STBCC__CLUSTER_SIZE_X; ++i)
+			if (STBCC__MAP_OPEN(g,x+i,y+j) && STBCC__MAP_OPEN(g,x+i  ,y+j+1))
+			   stbcc__incluster_union(&cbi, i,j, i,j+1);
+	  // check right for everything but rightmost column
+	  for (i=0; i < STBCC__CLUSTER_SIZE_X-1; ++i)
+		 if (STBCC__MAP_OPEN(g,x+i,y+j) && STBCC__MAP_OPEN(g,x+i+1,y+j  ))
+			stbcc__incluster_union(&cbi, i,j, i+1,j);
+   }
+
+   // label all non-empty clumps along edges so that all edge clumps are first
+   // in list; this means in degenerate case we can skip traversing non-edge clumps.
+   // because in the first pass we only label leaders, we swap the leader to the
+   // edge first
+
+   // first put solid labels on all the edges; these will get overwritten if they're open
+   for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j)
+	  cbi.label[j][0] = cbi.label[j][STBCC__CLUSTER_SIZE_X-1] = STBCC__NULL_CLUMPID;
+   for (i=0; i < STBCC__CLUSTER_SIZE_X; ++i)
+	  cbi.label[0][i] = cbi.label[STBCC__CLUSTER_SIZE_Y-1][i] = STBCC__NULL_CLUMPID;
+
+   for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j) {
+	  i = 0;
+	  if (STBCC__MAP_OPEN(g, x+i, y+j)) {
+		 stbcc__tinypoint p = stbcc__incluster_find(&cbi, i,j);
+		 if (p.x == i && p.y == j)
+			// if this is the leader, give it a label
+			cbi.label[j][i] = label++;
+		 else if (!(p.x == 0 || p.x == STBCC__CLUSTER_SIZE_X-1 || p.y == 0 || p.y == STBCC__CLUSTER_SIZE_Y-1)) {
+			// if leader is in interior, promote this edge node to leader and label
+			stbcc__switch_root(&cbi, i, j, p);
+			cbi.label[j][i] = label++;
+		 }
+		 // else if leader is on edge, do nothing (it'll get labelled when we reach it)
+	  }
+	  i = STBCC__CLUSTER_SIZE_X-1;
+	  if (STBCC__MAP_OPEN(g, x+i, y+j)) {
+		 stbcc__tinypoint p = stbcc__incluster_find(&cbi, i,j);
+		 if (p.x == i && p.y == j)
+			cbi.label[j][i] = label++;
+		 else if (!(p.x == 0 || p.x == STBCC__CLUSTER_SIZE_X-1 || p.y == 0 || p.y == STBCC__CLUSTER_SIZE_Y-1)) {
+			stbcc__switch_root(&cbi, i, j, p);
+			cbi.label[j][i] = label++;
+		 }
+	  }
+   }
+
+   for (i=1; i < STBCC__CLUSTER_SIZE_Y-1; ++i) {
+	  j = 0;
+	  if (STBCC__MAP_OPEN(g, x+i, y+j)) {
+		 stbcc__tinypoint p = stbcc__incluster_find(&cbi, i,j);
+		 if (p.x == i && p.y == j)
+			cbi.label[j][i] = label++;
+		 else if (!(p.x == 0 || p.x == STBCC__CLUSTER_SIZE_X-1 || p.y == 0 || p.y == STBCC__CLUSTER_SIZE_Y-1)) {
+			stbcc__switch_root(&cbi, i, j, p);
+			cbi.label[j][i] = label++;
+		 }
+	  }
+	  j = STBCC__CLUSTER_SIZE_Y-1;
+	  if (STBCC__MAP_OPEN(g, x+i, y+j)) {
+		 stbcc__tinypoint p = stbcc__incluster_find(&cbi, i,j);
+		 if (p.x == i && p.y == j)
+			cbi.label[j][i] = label++;
+		 else if (!(p.x == 0 || p.x == STBCC__CLUSTER_SIZE_X-1 || p.y == 0 || p.y == STBCC__CLUSTER_SIZE_Y-1)) {
+			stbcc__switch_root(&cbi, i, j, p);
+			cbi.label[j][i] = label++;
+		 }
+	  }
+   }
+
+   c = &g->cluster[cy][cx];
+   c->num_edge_clumps = label;
+
+   // label any internal clusters
+   for (j=1; j < STBCC__CLUSTER_SIZE_Y-1; ++j) {
+	  for (i=1; i < STBCC__CLUSTER_SIZE_X-1; ++i) {
+		 stbcc__tinypoint p = cbi.parent[j][i];
+		 if (p.x == i && p.y == j) {
+			if (STBCC__MAP_OPEN(g,x+i,y+j))
+			   cbi.label[j][i] = label++;
+			else
+			   cbi.label[j][i] = STBCC__NULL_CLUMPID;
+		 }
+	  }
+   }
+
+   // label all other nodes
+   for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j) {
+	  for (i=0; i < STBCC__CLUSTER_SIZE_X; ++i) {
+		 stbcc__tinypoint p = stbcc__incluster_find(&cbi, i,j);
+		 if (p.x != i || p.y != j) {
+			if (STBCC__MAP_OPEN(g,x+i,y+j))
+			   cbi.label[j][i] = cbi.label[p.y][p.x];
+		 }
+		 if (STBCC__MAP_OPEN(g,x+i,y+j))
+			assert(cbi.label[j][i] != STBCC__NULL_CLUMPID);
+	  }
+   }
+
+   c->num_clumps = label;
+
+   for (i=0; i < label; ++i) {
+	  c->clump[i].num_adjacent = 0;
+	  c->clump[i].max_adjacent = 0;
+   }
+
+   for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j)
+	  for (i=0; i < STBCC__CLUSTER_SIZE_X; ++i) {
+		 g->clump_for_node[y+j][x+i] = cbi.label[j][i]; // @OPTIMIZE: remove cbi.label entirely
+		 assert(g->clump_for_node[y+j][x+i] <= STBCC__NULL_CLUMPID);
+	  }
+
+   // set the global label for all interior clumps since they can't have connections,
+   // so we don't have to do this on the global pass (brings from O(N) to O(N^0.75))
+   for (i=(int) c->num_edge_clumps; i < (int) c->num_clumps; ++i) {
+	  stbcc__global_clumpid gc;
+	  gc.f.cluster_x = cx;
+	  gc.f.cluster_y = cy;
+	  gc.f.clump_index = i;
+	  c->clump[i].global_label = gc;
+   }
+
+   c->rebuild_adjacency = 1; // flag that it has no valid adjacency data
+}
+
+#endif // STB_CONNECTED_COMPONENTS_IMPLEMENTATION
+/*
+------------------------------------------------------------------------------
+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.
+------------------------------------------------------------------------------
+*/

fggl/stb/stb_divide.h

+// stb_divide.h - v0.94 - public domain - Sean Barrett, Feb 2010
+// Three kinds of divide/modulus of signed integers.
+//
+// HISTORY
+//
+//   v0.94              Fix integer overflow issues
+//   v0.93  2020-02-02  Write useful exit() value from main()
+//   v0.92  2019-02-25  Fix warning
+//   v0.91  2010-02-27  Fix euclidean division by INT_MIN for non-truncating C
+//                      Check result with 64-bit math to catch such cases
+//   v0.90  2010-02-24  First public release
+//
+// USAGE
+//
+// In *ONE* source file, put:
+//
+//    #define STB_DIVIDE_IMPLEMENTATION
+//    // #define C_INTEGER_DIVISION_TRUNCATES  // see Note 1
+//    // #define C_INTEGER_DIVISION_FLOORS     // see Note 2
+//    #include "stb_divide.h"
+//
+// Other source files should just include stb_divide.h
+//
+// Note 1: On platforms/compilers that you know signed C division
+// truncates, you can #define C_INTEGER_DIVISION_TRUNCATES.
+//
+// Note 2: On platforms/compilers that you know signed C division
+// floors (rounds to negative infinity), you can #define
+// C_INTEGER_DIVISION_FLOORS.
+//
+// You can #define STB_DIVIDE_TEST in which case the implementation
+// will generate a main() and compiling the result will create a
+// program that tests the implementation. Run it with no arguments
+// and any output indicates an error; run it with any argument and
+// it will also print the test results. Define STB_DIVIDE_TEST_64
+// to a 64-bit integer type to avoid overflows in the result-checking
+// which give false negatives.
+//
+// ABOUT
+//
+// This file provides three different consistent divide/mod pairs
+// implemented on top of arbitrary C/C++ division, including correct
+// handling of overflow of intermediate calculations:
+//
+//     trunc:   a/b truncates to 0,           a%b has same sign as a
+//     floor:   a/b truncates to -inf,        a%b has same sign as b
+//     eucl:    a/b truncates to sign(b)*inf, a%b is non-negative
+//
+// Not necessarily optimal; I tried to keep it generally efficient,
+// but there may be better ways.
+//
+// Briefly, for those who are not familiar with the problem, we note
+// the reason these divides exist and are interesting:
+//
+//     'trunc' is easy to implement in hardware (strip the signs,
+//          compute, reapply the signs), thus is commonly defined
+//          by many languages (including C99)
+//
+//     'floor' is simple to define and better behaved than trunc;
+//          for example it divides integers into fixed-size buckets
+//          without an extra-wide bucket at 0, and for a fixed
+//          divisor N there are only |N| possible moduli.
+//
+//     'eucl' guarantees fixed-sized buckets *and* a non-negative
+//          modulus and defines division to be whatever is needed
+//          to achieve that result.
+//
+// See "The Euclidean definition of the functions div and mod"
+// by Raymond Boute (1992), or "Division and Modulus for Computer
+// Scientists" by Daan Leijen (2001)
+//
+// We assume of the built-in C division:
+//     (a) modulus is the remainder for the corresponding division
+//     (b) a/b truncates if a and b are the same sign
+//
+// Property (a) requires (a/b)*b + (a%b)==a, and is required by C.
+// Property (b) seems to be true of all hardware but is *not* satisfied
+// by the euclidean division operator we define, so it's possibly not
+// always true. If any such platform turns up, we can add more cases.
+// (Possibly only stb_div_trunc currently relies on property (b).)
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+
+#ifndef INCLUDE_STB_DIVIDE_H
+#define INCLUDE_STB_DIVIDE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int stb_div_trunc(int value_to_be_divided, int value_to_divide_by);
+extern int stb_div_floor(int value_to_be_divided, int value_to_divide_by);
+extern int stb_div_eucl(int value_to_be_divided, int value_to_divide_by);
+extern int stb_mod_trunc(int value_to_be_divided, int value_to_divide_by);
+extern int stb_mod_floor(int value_to_be_divided, int value_to_divide_by);
+extern int stb_mod_eucl(int value_to_be_divided, int value_to_divide_by);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef STB_DIVIDE_IMPLEMENTATION
+
+#if defined(__STDC_VERSION) && __STDC_VERSION__ >= 19901
+	#ifndef C_INTEGER_DIVISION_TRUNCATES
+		#define C_INTEGER_DIVISION_TRUNCATES
+	#endif
+#endif
+
+#ifndef INT_MIN
+#include <limits.h> // if you have no limits.h, #define INT_MIN yourself
+#endif
+
+// the following macros are designed to allow testing
+// other platforms by simulating them
+#ifndef STB_DIVIDE_TEST_FLOOR
+	#define stb__div(a,b)  ((a)/(b))
+	#define stb__mod(a,b)  ((a)%(b))
+#else
+   // implement floor-style divide on trunc platform
+	#ifndef C_INTEGER_DIVISION_TRUNCATES
+		#error "floor test requires truncating division"
+	#endif
+	#undef C_INTEGER_DIVISION_TRUNCATES
+   int stb__div(int v1, int v2)
+   {
+	  int q = v1/v2, r = v1%v2;
+	  if ((r > 0 && v2 < 0) || (r < 0 && v2 > 0))
+		 return q-1;
+	  else
+		 return q;
+   }
+
+   int stb__mod(int v1, int v2)
+   {
+	  int r = v1%v2;
+	  if ((r > 0 && v2 < 0) || (r < 0 && v2 > 0))
+		 return r+v2;
+	  else
+		 return r;
+   }
+#endif
+
+int stb_div_trunc(int v1, int v2)
+{
+#ifdef C_INTEGER_DIVISION_TRUNCATES
+   return v1/v2;
+#else
+   if (v1 >= 0 && v2 <= 0)
+	  return -stb__div(-v1,v2);  // both negative to avoid overflow
+   if (v1 <= 0 && v2 >= 0)
+	  if (v1 != INT_MIN)
+		 return -stb__div(v1,-v2);    // both negative to avoid overflow
+	  else
+		 return -stb__div(v1+v2,-v2)-1; // push v1 away from wrap point
+   else
+	  return v1/v2;            // same sign, so expect truncation
+#endif
+}
+
+int stb_div_floor(int v1, int v2)
+{
+#ifdef C_INTEGER_DIVISION_FLOORS
+   return v1/v2;
+#else
+   if (v1 >= 0 && v2 < 0) {
+	  if (v2 + 1 >= INT_MIN + v1) // check if increasing v1's magnitude overflows
+		 return -stb__div((v2+1)-v1,v2); // nope, so just compute it
+	  else
+		 return -stb__div(-v1,v2) + ((-v1)%v2 ? -1 : 0);
+   }
+   if (v1 < 0 && v2 >= 0) {
+	  if (v1 != INT_MIN) {
+		 if (v1 + 1 >= INT_MIN + v2) // check if increasing v1's magnitude overflows
+			return -stb__div((v1+1)-v2,-v2); // nope, so just compute it
+		 else
+			return -stb__div(-v1,v2) + (stb__mod(v1,-v2) ? -1 : 0);
+	  } else // it must be possible to compute -(v1+v2) without overflowing
+		 return -stb__div(-(v1+v2),v2) + (stb__mod(-(v1+v2),v2) ? -2 : -1);
+   } else
+	  return v1/v2;           // same sign, so expect truncation
+#endif
+}
+
+int stb_div_eucl(int v1, int v2)
+{
+   int q,r;
+#ifdef C_INTEGER_DIVISION_TRUNCATES
+   q = v1/v2;
+   r = v1%v2;
+#else
+   // handle every quadrant separately, since we can't rely on q and r flor
+   if (v1 >= 0)
+	  if (v2 >= 0)
+		 return stb__div(v1,v2);
+	  else if (v2 != INT_MIN)
+		 q = -stb__div(v1,-v2), r = stb__mod(v1,-v2);
+	  else
+		 q = 0, r = v1;
+   else if (v1 != INT_MIN)
+	  if (v2 >= 0)
+		 q = -stb__div(-v1,v2), r = -stb__mod(-v1,v2);
+	  else if (v2 != INT_MIN)
+		 q = stb__div(-v1,-v2), r = -stb__mod(-v1,-v2);
+	  else // if v2 is INT_MIN, then we can't use -v2, but we can't divide by v2
+		 q = 1, r = v1-q*v2;
+   else // if v1 is INT_MIN, we have to move away from overflow place
+	  if (v2 >= 0)
+		 q = -stb__div(-(v1+v2),v2)-1, r = -stb__mod(-(v1+v2),v2);
+	  else if (v2 != INT_MIN)
+		 q = stb__div(-(v1-v2),-v2)+1, r = -stb__mod(-(v1-v2),-v2);
+	  else // for INT_MIN / INT_MIN, we need to be extra-careful to avoid overflow
+		 q = 1, r = 0;
+#endif
+   if (r >= 0)
+	  return q;
+   else
+	  return q + (v2 > 0 ? -1 : 1);
+}
+
+int stb_mod_trunc(int v1, int v2)
+{
+#ifdef C_INTEGER_DIVISION_TRUNCATES
+   return v1%v2;
+#else
+   if (v1 >= 0) { // modulus result should always be positive
+	  int r = stb__mod(v1,v2);
+	  if (r >= 0)
+		 return r;
+	  else
+		 return r - (v2 < 0 ? v2 : -v2);
+   } else {    // modulus result should always be negative
+	  int r = stb__mod(v1,v2);
+	  if (r <= 0)
+		 return r;
+	  else
+		 return r + (v2 < 0 ? v2 : -v2);
+   }
+#endif
+}
+
+int stb_mod_floor(int v1, int v2)
+{
+#ifdef C_INTEGER_DIVISION_FLOORS
+   return v1%v2;
+#else
+   if (v2 >= 0) { // result should always be positive
+	  int r = stb__mod(v1,v2);
+	  if (r >= 0)
+		 return r;
+	  else
+		 return r + v2;
+   } else { // result should always be negative
+	  int r = stb__mod(v1,v2);
+	  if (r <= 0)
+		 return r;
+	  else
+		 return r + v2;
+   }
+#endif
+}
+
+int stb_mod_eucl(int v1, int v2)
+{
+   int r = stb__mod(v1,v2);
+
+   if (r >= 0)
+	  return r;
+   else
+	  return r - (v2 < 0 ? v2 : -v2); // negative abs() [to avoid overflow]
+}
+
+#ifdef STB_DIVIDE_TEST
+#include <stdio.h>
+#include <math.h>
+#include <limits.h>
+
+int show=0;
+int err=0;
+
+void stbdiv_check(int q, int r, int a, int b, char *type, int dir)
+{
+   if ((dir > 0 && r < 0) || (dir < 0 && r > 0)) {
+	  fprintf(stderr, "FAILED: %s(%d,%d) remainder %d in wrong direction\n", type,a,b,r);
+	  err++;
+   } else
+	  if (b != INT_MIN) // can't compute abs(), but if b==INT_MIN all remainders are valid
+		 if (r <= -abs(b) || r >= abs(b)) {
+			fprintf(stderr, "FAILED: %s(%d,%d) remainder %d out of range\n", type,a,b,r);
+			err++;
+		 }
+#ifdef STB_DIVIDE_TEST_64
+   {
+	  STB_DIVIDE_TEST_64 q64 = q, r64=r, a64=a, b64=b;
+	  if (q64*b64+r64 != a64) {
+		 fprintf(stderr, "FAILED: %s(%d,%d) remainder %d doesn't match quotient %d\n", type,a,b,r,q);
+		 err++;
+	  }
+   }
+#else
+   if (q*b+r != a) {
+	  fprintf(stderr, "FAILED: %s(%d,%d) remainder %d doesn't match quotient %d\n", type,a,b,r,q);
+	  err++;
+   }
+#endif
+}
+
+void test(int a, int b)
+{
+   int q,r;
+   if (show) printf("(%+11d,%+d) |  ", a,b);
+   q = stb_div_trunc(a,b), r = stb_mod_trunc(a,b);
+   if (show) printf("(%+11d,%+2d)  ", q,r); stbdiv_check(q,r,a,b, "trunc",a);
+   q = stb_div_floor(a,b), r = stb_mod_floor(a,b);
+   if (show) printf("(%+11d,%+2d)  ", q,r); stbdiv_check(q,r,a,b, "floor",b);
+   q = stb_div_eucl (a,b), r = stb_mod_eucl (a,b);
+   if (show) printf("(%+11d,%+2d)\n", q,r); stbdiv_check(q,r,a,b, "euclidean",1);
+}
+
+void testh(int a, int b)
+{
+   int q,r;
+   if (show) printf("(%08x,%08x) |\n", a,b);
+   q = stb_div_trunc(a,b), r = stb_mod_trunc(a,b); stbdiv_check(q,r,a,b, "trunc",a);
+   if (show) printf("             (%08x,%08x)", q,r);
+   q = stb_div_floor(a,b), r = stb_mod_floor(a,b); stbdiv_check(q,r,a,b, "floor",b);
+   if (show) printf("   (%08x,%08x)", q,r);
+   q = stb_div_eucl (a,b), r = stb_mod_eucl (a,b); stbdiv_check(q,r,a,b, "euclidean",1);
+   if (show) printf("   (%08x,%08x)\n ", q,r);
+}
+
+int main(int argc, char **argv)
+{
+   if (argc > 1) show=1;
+
+   test(8,3);
+   test(8,-3);
+   test(-8,3);
+   test(-8,-3);
+   test(1,2);
+   test(1,-2);
+   test(-1,2);
+   test(-1,-2);
+   test(8,4);
+   test(8,-4);
+   test(-8,4);
+   test(-8,-4);
+
+   test(INT_MAX,1);
+   test(INT_MIN,1);
+   test(INT_MIN+1,1);
+   test(INT_MAX,-1);
+   //test(INT_MIN,-1); // this traps in MSVC, so we leave it untested
+   test(INT_MIN+1,-1);
+   test(INT_MIN,-2);
+   test(INT_MIN+1,2);
+   test(INT_MIN+1,-2);
+   test(INT_MAX,2);
+   test(INT_MAX,-2);
+   test(INT_MIN+1,2);
+   test(INT_MIN+1,-2);
+   test(INT_MIN,2);
+   test(INT_MIN,-2);
+   test(INT_MIN,7);
+   test(INT_MIN,-7);
+   test(INT_MIN+1,4);
+   test(INT_MIN+1,-4);
+
+   testh(-7, INT_MIN);
+   testh(-1, INT_MIN);
+   testh(1, INT_MIN);
+   testh(7, INT_MIN);
+
+   testh(INT_MAX-1, INT_MIN);
+   testh(INT_MAX,   INT_MIN);
+   testh(INT_MIN,   INT_MIN);
+   testh(INT_MIN+1, INT_MIN);
+
+   testh(INT_MAX-1, INT_MAX);
+   testh(INT_MAX  , INT_MAX);
+   testh(INT_MIN  , INT_MAX);
+   testh(INT_MIN+1, INT_MAX);
+
+   return err > 0 ? 1 : 0;
+}
+#endif // STB_DIVIDE_TEST
+#endif // STB_DIVIDE_IMPLEMENTATION
+#endif // INCLUDE_STB_DIVIDE_H
+
+/*
+------------------------------------------------------------------------------
+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.
+------------------------------------------------------------------------------
+*/

fggl/stb/stb_hexwave.h

+// stb_hexwave - v0.5 - public domain, initial release 2021-04-01
+//
+// A flexible anti-aliased (bandlimited) digital audio oscillator.
+//
+// This library generates waveforms of a variety of shapes made of
+// line segments. It does not do envelopes, LFO effects, etc.; it
+// merely tries to solve the problem of generating an artifact-free
+// morphable digital waveform with a variety of spectra, and leaves
+// it to the user to rescale the waveform and mix multiple voices, etc.
+//
+// Compiling:
+//
+//   In one C/C++ file that #includes this file, do
+//
+//      #define STB_HEXWAVE_IMPLEMENTATION
+//      #include "stb_hexwave.h"
+//
+//   Optionally, #define STB_HEXWAVE_STATIC before including
+//   the header to cause the definitions to be private to the
+//   implementation file (i.e. to be "static" instead of "extern").
+//
+// Notes:
+//
+//   Optionally performs memory allocation during initialization,
+//   never allocates otherwise.
+//
+// License:
+//
+//   See end of file for license information.
+//
+// Usage:
+//
+//   Initialization:
+//
+//     hexwave_init(32,16,NULL); // read "header section" for alternatives
+//
+//   Create oscillator:
+//
+//     HexWave *osc = malloc(sizeof(*osc)); // or "new HexWave", or declare globally or on stack
+//     hexwave_create(osc, reflect_flag, peak_time, half_height, zero_wait);
+//       see "Waveform shapes" below for the meaning of these parameters
+//
+//   Generate audio:
+//
+//     hexwave_generate_samples(output, number_of_samples, osc, oscillator_freq)
+//       where:
+//         output is a buffer where the library will store floating point audio samples
+//         number_of_samples is the number of audio samples to generate
+//         osc is a pointer to a Hexwave
+//         oscillator_freq is the frequency of the oscillator divided by the sample rate
+//
+//       The output samples will continue from where the samples generated by the
+//       previous hexwave_generate_samples() on this oscillator ended.
+//
+//   Change oscillator waveform:
+//
+//     hexwave_change(osc, reflect_flag, peak_time, half_height, zero_wait);
+//       can call in between calls to hexwave_generate_samples
+//
+// Waveform shapes:
+//
+//   All waveforms generated by hexwave are constructed from six line segments
+//   characterized by 3 parameters.
+//
+//   See demonstration: https://www.youtube.com/watch?v=hsUCrAsDN-M
+//
+//                 reflect=0                          reflect=1
+//
+//           0-----P---1                        0-----P---1    peak_time = P
+//                 .     1                            .     1
+//                /\_    :                           /\_    :
+//               /   \_  :                          /   \_  :
+//              /      \.H                         /      \.H  half_height = H
+//             /       | :                        /       | :
+//       _____/        |_:___               _____/        | :       _____
+//           .           :   \        |         .         | :      /
+//           .           :    \       |         .         | :     /
+//           .           :     \     _/         .         \_:    /
+//           .           :      \  _/           .           :_  /
+//           .          -1       \/             .          -1 \/
+//       0 - Z - - - - 1                    0 - Z - - - - 1   zero_wait = Z
+//
+//    Classic waveforms:
+//                               peak    half    zero
+//                     reflect   time   height   wait
+//      Sawtooth          1       0       0       0
+//      Square            1       0       1       0
+//      Triangle          1       0.5     0       0
+//
+//    Some waveforms can be produced in multiple ways, which is useful when morphing
+//    into other waveforms, and there are a few more notable shapes:
+//
+//                               peak    half    zero
+//                     reflect   time   height   wait
+//      Sawtooth          1       1      any      0
+//      Sawtooth (8va)    1       0      -1       0
+//      Triangle          1       0.5     0       0
+//      Square            1       0       1       0
+//      Square            0       0       1       0
+//      Triangle          0       0.5     0       0
+//      Triangle          0       0      -1       0
+//      AlternatingSaw    0       0       0       0
+//      AlternatingSaw    0       1      any      0
+//      Stairs            0       0       1       0.5
+//
+//    The "Sawtooth (8va)" waveform is identical to a sawtooth wave with 2x the
+//    frequency, but when morphed with other values, it becomes an overtone of
+//    the base frequency.
+//
+//  Morphing waveforms:
+//
+//    Sweeping peak_time morphs the waveform while producing various spectra.
+//    Sweeping half_height effectively crossfades between two waveforms; useful, but less exciting.
+//    Sweeping zero_wait produces a similar effect no matter the reset of the waveform,
+//        a sort of high-pass/PWM effect where the wave becomes silent at zero_wait=1.
+//
+//    You can trivially morph between any two waveforms from the above table
+//    which only differ in one column.
+//
+//    Crossfade between classic waveforms:
+//                                            peak     half    zero
+//        Start         End         reflect   time    height   wait
+//        -----         ---         -------   ----    ------   ----
+//        Triangle      Square         0       0      -1..1    0
+//        Saw           Square         1       0       0..1    0
+//        Triangle      Saw            1       0.5     0..2    0
+//
+//    The last morph uses uses half-height values larger than 1, which means it will
+//    be louder and the output should be scaled down by half to compensate, or better
+//    by dynamically tracking the morph: volume_scale = 1 - half_height/4
+//
+//    Non-crossfade morph between classic waveforms, most require changing
+//    two parameters at the same time:
+//                                           peak     half    zero
+//      Start         End         reflect    time    height   wait
+//      -----         ---         -------    ----    ------   ----
+//      Square        Triangle      any      0..0.5   1..0     0
+//      Square        Saw            1       0..1     1..any   0
+//      Triangle      Saw            1     0.5..1     0..-1    0
+//
+//    Other noteworthy morphs between simple shapes:
+//                                                            peak     half    zero
+//      Start           Halfway       End          reflect    time    height   wait
+//      -----           ---------     ---          -------    ----    ------   ----
+//      Saw (8va,neg)                Saw (pos)        1       0..1      -1      0
+//      Saw (neg)                    Saw (pos)        1       0..1       0      0
+//      Triangle                     AlternatingSaw   0       0..1      -1      0
+//      AlternatingSaw  Triangle     AlternatingSaw   0       0..1       0      0
+//      Square                       AlternatingSaw   0       0..1       1      0
+//      Triangle        Triangle     AlternatingSaw   0       0..1    -1..1     0
+//      Square                       AlternatingSaw   0       0..1     1..0     0
+//      Saw (8va)       Triangle     Saw              1       0..1    -1..1     0
+//      Saw (neg)                    Saw (pos)        1       0..1     0..1     0
+//      AlternatingSaw               AlternatingSaw   0       0..1     0..any   0
+//
+//   The last entry is noteworthy because the morph from the halfway point to either
+//   endpoint sounds very different. For example, an LFO sweeping back and forth over
+//   the whole range will morph between the middle timbre and the AlternatingSaw
+//   timbre in two different ways, alternating.
+//
+//   Entries with "any" for half_height are whole families of morphs, as you can pick
+//   any value you want as the endpoint for half_height.
+//
+//   You can always morph between any two waveforms with the same value of 'reflect'
+//   by just sweeping the parameters simultaneously. There will never be artifacts
+//   and the result will always be useful, if not necessarily what you want.
+//
+//   You can vary the sound of two-parameter morphs by ramping them differently,
+//   e.g. if the morph goes from t=0..1, then square-to-triangle looks like:
+//        peak_time   = lerp(t, 0, 0.5)
+//        half_height = lerp(t, 1, 0  )
+//   but you can also do things like:
+//        peak_time   = lerp(smoothstep(t), 0, 0.5)
+//        half_height = cos(PI/2 * t)
+//
+// How it works:
+//
+//   hexwave use BLEP to bandlimit discontinuities and BLAMP
+//   to bandlimit C1 discontinuities. This is not polyBLEP
+//   (polynomial BLEP), it is table-driven BLEP. It is
+//   also not minBLEP (minimum-phase BLEP), as that complicates
+//   things for little benefit once BLAMP is involved.
+//
+//   The previous oscillator frequency is remembered, and when
+//   the frequency changes, a BLAMP is generated to remove the
+//   C1 discontinuity, which reduces artifacts for sweeps/LFO.
+//
+//   Changes to an oscillator timbre using hexwave_change() actually
+//   wait until the oscillator finishes its current cycle. All
+//   waveforms with non-zero "zero_wait" settings pass through 0
+//   and have 0-slope at the start of a cycle, which means changing
+//   the settings is artifact free at that time. (If zero_wait is 0,
+//   the code still treats it as passing through 0 with 0-slope; it'll
+//   apply the necessary fixups to make it artifact free as if it does
+//   transition to 0 with 0-slope vs. the waveform at the end of
+//   the cycle, then adds the fixups for a non-0 and non-0 slope
+//   at the start of the cycle, which cancels out if zero_wait is 0,
+//   and still does the right thing if zero_wait is 0 when the
+//   settings are updated.)
+//
+//   BLEP/BLAMP normally requires overlapping buffers, but this
+//   is hidden from the user by generating the waveform to a
+//   temporary buffer and saving the overlap regions internally
+//   between calls. (It is slightly more complicated; see code.)
+//
+//   By design all shapes have 0 DC offset; this is one reason
+//   hexwave uses zero_wait instead of standard PWM.
+//
+//   The internals of hexwave could support any arbitrary shape
+//   made of line segments, but I chose not to expose this
+//   generality in favor of a simple, easy-to-use API.
+
+#ifndef STB_INCLUDE_STB_HEXWAVE_H
+#define STB_INCLUDE_STB_HEXWAVE_H
+
+#ifndef STB_HEXWAVE_MAX_BLEP_LENGTH
+#define STB_HEXWAVE_MAX_BLEP_LENGTH   64 // good enough for anybody
+#endif
+
+#ifdef STB_HEXWAVE_STATIC
+#define STB_HEXWAVE_DEF static
+#else
+#define STB_HEXWAVE_DEF extern
+#endif
+
+typedef struct HexWave HexWave;
+
+STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer);
+//         width: size of BLEP, from 4..64, larger is slower & more memory but less aliasing
+//    oversample: 2+, number of subsample positions, larger uses more memory but less noise
+//   user_buffer: optional, if provided the library will perform no allocations.
+//                16*width*(oversample+1) bytes, must stay allocated as long as library is used
+//                technically it only needs:   8*( width * (oversample  + 1))
+//                                           + 8*((width *  oversample) + 1)  bytes
+//
+// width can be larger than 64 if you define STB_HEXWAVE_MAX_BLEP_LENGTH to a larger value
+
+STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer);
+//       user_buffer: pass in same parameter as passed to hexwave_init
+
+STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait);
+// see docs above for description
+//
+//   reflect is tested as 0 or non-zero
+//   peak_time is clamped to 0..1
+//   half_height is not clamped
+//   zero_wait is clamped to 0..1
+
+STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait);
+// see docs
+
+STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq);
+//            output: buffer where the library will store generated floating point audio samples
+// number_of_samples: the number of audio samples to generate
+//               osc: pointer to a Hexwave initialized with 'hexwave_create'
+//   oscillator_freq: frequency of the oscillator divided by the sample rate
+
+// private:
+typedef struct {
+	int reflect;
+	float peak_time;
+	float zero_wait;
+	float half_height;
+} HexWaveParameters;
+
+struct HexWave {
+	float t, prev_dt;
+	HexWaveParameters current, pending;
+	int have_pending;
+	float buffer[STB_HEXWAVE_MAX_BLEP_LENGTH];
+};
+#endif
+
+#ifdef STB_HEXWAVE_IMPLEMENTATION
+
+#ifndef STB_HEXWAVE_NO_ALLOCATION
+#include <stdlib.h> // malloc,free
+#endif
+
+#include <string.h> // memset,memcpy,memmove
+#include <math.h>   // sin,cos,fabs
+
+#define hexwave_clamp(v,a,b)   ((v) < (a) ? (a) : (v) > (b) ? (b) : (v))
+
+STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)
+{
+   hex->pending.reflect     = reflect;
+   hex->pending.peak_time   = hexwave_clamp(peak_time,0,1);
+   hex->pending.half_height = half_height;
+   hex->pending.zero_wait   = hexwave_clamp(zero_wait,0,1);
+   // put a barrier here to allow changing from a different thread than the generator
+   hex->have_pending        = 1;
+}
+
+STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)
+{
+   memset(hex, 0, sizeof(*hex));
+   hexwave_change(hex, reflect, peak_time, half_height, zero_wait);
+   hex->current = hex->pending;
+   hex->have_pending = 0;
+   hex->t = 0;
+   hex->prev_dt = 0;
+}
+
+static struct
+{
+   int width;       // width of fixup in samples
+   int oversample;  // number of oversampled versions (there's actually one more to allow lerpign)
+   float *blep;
+   float *blamp;
+} hexblep;
+
+static void hex_add_oversampled_bleplike(float *output, float time_since_transition, float scale, float *data)
+{
+   float *d1,*d2;
+   float lerpweight;
+   int i, bw = hexblep.width;
+
+   int slot = (int) (time_since_transition * hexblep.oversample);
+   if (slot >= hexblep.oversample)
+	  slot = hexblep.oversample-1; // clamp in case the floats overshoot
+
+   d1 = &data[ slot   *bw];
+   d2 = &data[(slot+1)*bw];
+
+   lerpweight = time_since_transition * hexblep.oversample - slot;
+   for (i=0; i < bw; ++i)
+	  output[i] += scale * (d1[i] + (d2[i]-d1[i])*lerpweight);
+}
+
+static void hex_blep (float *output, float time_since_transition, float scale)
+{
+   hex_add_oversampled_bleplike(output, time_since_transition, scale, hexblep.blep);
+}
+
+static void hex_blamp(float *output, float time_since_transition, float scale)
+{
+   hex_add_oversampled_bleplike(output, time_since_transition, scale, hexblep.blamp);
+}
+
+typedef struct
+{
+   float t,v,s; // time, value, slope
+} hexvert;
+
+// each half of the waveform needs 4 vertices to represent 3 line
+// segments, plus 1 more for wraparound
+static void hexwave_generate_linesegs(hexvert vert[9], HexWave *hex, float dt)
+{
+   int j;
+   float min_len = dt / 256.0f;
+
+   vert[0].t = 0;
+   vert[0].v = 0;
+   vert[1].t = hex->current.zero_wait*0.5f;
+   vert[1].v = 0;
+   vert[2].t = 0.5f*hex->current.peak_time + vert[1].t*(1-hex->current.peak_time);
+   vert[2].v = 1;
+   vert[3].t = 0.5f;
+   vert[3].v = hex->current.half_height;
+
+   if (hex->current.reflect) {
+	  for (j=4; j <= 7; ++j) {
+		 vert[j].t = 1 -  vert[7-j].t;
+		 vert[j].v =    - vert[7-j].v;
+	  }
+   } else {
+	  for (j=4; j <= 7; ++j) {
+		 vert[j].t =  0.5f +  vert[j-4].t;
+		 vert[j].v =        - vert[j-4].v;
+	  }
+   }
+   vert[8].t = 1;
+   vert[8].v = 0;
+
+   for (j=0; j < 8; ++j) {
+	  if (vert[j+1].t <= vert[j].t + min_len) {
+		  // if change takes place over less than a fraction of a sample treat as discontinuity
+		  //
+		  // otherwise the slope computation can blow up to arbitrarily large and we
+		  // try to generate a huge BLAMP and the result is wrong.
+		  //
+		  // why does this happen if the math is right? i believe if done perfectly,
+		  // the two BLAMPs on either side of the slope would cancel out, but our
+		  // BLAMPs have only limited sub-sample precision and limited integration
+		  // accuracy. or maybe it's just the math blowing up w/ floating point precision
+		  // limits as we try to make x * (1/x) cancel out
+		  //
+		  // min_len verified artifact-free even near nyquist with only oversample=4
+		 vert[j+1].t = vert[j].t;
+	  }
+   }
+
+   if (vert[8].t != 1.0f) {
+	  // if the above fixup moved the endpoint away from 1.0, move it back,
+	  // along with any other vertices that got moved to the same time
+	  float t = vert[8].t;
+	  for (j=5; j <= 8; ++j)
+		 if (vert[j].t == t)
+			vert[j].t = 1.0f;
+   }
+
+   // compute the exact slopes from the final fixed-up positions
+   for (j=0; j < 8; ++j)
+	  if (vert[j+1].t == vert[j].t)
+		 vert[j].s = 0;
+	  else
+		 vert[j].s = (vert[j+1].v - vert[j].v) / (vert[j+1].t - vert[j].t);
+
+   // wraparound at end
+   vert[8].t = 1;
+   vert[8].v = vert[0].v;
+   vert[8].s = vert[0].s;
+}
+
+STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq)
+{
+   hexvert vert[9];
+   int pass,i,j;
+   float t = hex->t;
+   float temp_output[2*STB_HEXWAVE_MAX_BLEP_LENGTH];
+   int buffered_length = sizeof(float)*hexblep.width;
+   float dt = (float) fabs(freq);
+   float recip_dt = (dt == 0.0f) ? 0.0f : 1.0f / dt;
+
+   int halfw = hexblep.width/2;
+   // all sample times are biased by halfw to leave room for BLEP/BLAMP to go back in time
+
+   if (num_samples <= 0)
+	  return;
+
+   // convert parameters to times and slopes
+   hexwave_generate_linesegs(vert, hex, dt);
+
+   if (hex->prev_dt != dt) {
+	  // if frequency changes, add a fixup at the derivative discontinuity starting at now
+	  float slope;
+	  for (j=1; j < 6; ++j)
+		 if (t < vert[j].t)
+			break;
+	  slope = vert[j].s;
+	  if (slope != 0)
+		 hex_blamp(output, 0, (dt - hex->prev_dt)*slope);
+	  hex->prev_dt = dt;
+   }
+
+   // copy the buffered data from last call and clear the rest of the output array
+   memset(output, 0, sizeof(float)*num_samples);
+   memset(temp_output, 0, 2*hexblep.width*sizeof(float));
+
+   if (num_samples >= hexblep.width) {
+	  memcpy(output, hex->buffer, buffered_length);
+   } else {
+	  // if the output is shorter than hexblep.width, we do all synthesis to temp_output
+	  memcpy(temp_output, hex->buffer, buffered_length);
+   }
+
+   for (pass=0; pass < 2; ++pass) {
+	  int i0,i1;
+	  float *out;
+
+	  // we want to simulate having one buffer that is num_output + hexblep.width
+	  // samples long, without putting that requirement on the user, and without
+	  // allocating a temp buffer that's as long as the whole thing. so we use two
+	  // overlapping buffers, one the user's buffer and one a fixed-length temp
+	  // buffer.
+
+	  if (pass == 0) {
+		 if (num_samples < hexblep.width)
+			continue;
+		 // run as far as we can without overwriting the end of the user's buffer
+		 out = output;
+		 i0 = 0;
+		 i1 = num_samples - hexblep.width;
+	  } else {
+		 // generate the rest into a temp buffer
+		 out = temp_output;
+		 i0 = 0;
+		 if (num_samples >= hexblep.width)
+			i1 = hexblep.width;
+		 else
+			i1 = num_samples;
+	  }
+
+	  // determine current segment
+	  for (j=0; j < 8; ++j)
+		 if (t < vert[j+1].t)
+			break;
+
+	  i = i0;
+	  for(;;) {
+		 while (t < vert[j+1].t) {
+			if (i == i1)
+			   goto done;
+			out[i+halfw] += vert[j].v + vert[j].s*(t - vert[j].t);
+			t += dt;
+			++i;
+		 }
+		 // transition from lineseg starting at j to lineseg starting at j+1
+
+		 if (vert[j].t == vert[j+1].t)
+			hex_blep(out+i, recip_dt*(t-vert[j+1].t), (vert[j+1].v - vert[j].v));
+		 hex_blamp(out+i, recip_dt*(t-vert[j+1].t), dt*(vert[j+1].s - vert[j].s));
+		 ++j;
+
+		 if (j == 8) {
+			// change to different waveform if there's a change pending
+			j = 0;
+			t -= 1.0; // t was >= 1.f if j==8
+			if (hex->have_pending) {
+			   float prev_s0 = vert[j].s;
+			   float prev_v0 = vert[j].v;
+			   hex->current = hex->pending;
+			   hex->have_pending = 0;
+			   hexwave_generate_linesegs(vert, hex, dt);
+			   // the following never occurs with this oscillator, but it makes
+			   // the code work in more general cases
+			   if (vert[j].v != prev_v0)
+				  hex_blep (out+i, recip_dt*t,    (vert[j].v - prev_v0));
+			   if (vert[j].s != prev_s0)
+				  hex_blamp(out+i, recip_dt*t, dt*(vert[j].s - prev_s0));
+			}
+		 }
+	  }
+	 done:
+	  ;
+   }
+
+   // at this point, we've written output[] and temp_output[]
+   if (num_samples >= hexblep.width) {
+	  // the first half of temp[] overlaps the end of output, the second half will be the new start overlap
+	  for (i=0; i < hexblep.width; ++i)
+		 output[num_samples-hexblep.width + i] += temp_output[i];
+	  memcpy(hex->buffer, temp_output+hexblep.width, buffered_length);
+   } else {
+	  for (i=0; i < num_samples; ++i)
+		 output[i] = temp_output[i];
+	  memcpy(hex->buffer, temp_output+num_samples, buffered_length);
+   }
+
+   hex->t = t;
+}
+
+STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer)
+{
+#ifndef STB_HEXWAVE_NO_ALLOCATION
+   if (user_buffer != 0) {
+	  free(hexblep.blep);
+	  free(hexblep.blamp);
+   }
+#endif
+}
+
+// buffer should be NULL or must be 4*(width*(oversample+1)*2 +
+STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer)
+{
+   int halfwidth = width/2;
+   int half = halfwidth*oversample;
+   int blep_buffer_count = width*(oversample+1);
+   int n = 2*half+1;
+#ifdef STB_HEXWAVE_NO_ALLOCATION
+   float *buffers = user_buffer;
+#else
+   float *buffers = user_buffer ? user_buffer : (float *) malloc(sizeof(float) * n * 2);
+#endif
+   float *step    = buffers+0*n;
+   float *ramp    = buffers+1*n;
+   float *blep_buffer, *blamp_buffer;
+   double integrate_impulse=0, integrate_step=0;
+   int i,j;
+
+   if (width > STB_HEXWAVE_MAX_BLEP_LENGTH)
+	  width = STB_HEXWAVE_MAX_BLEP_LENGTH;
+
+   if (user_buffer == 0) {
+#ifndef STB_HEXWAVE_NO_ALLOCATION
+	  blep_buffer  = (float *) malloc(sizeof(float)*blep_buffer_count);
+	  blamp_buffer = (float *) malloc(sizeof(float)*blep_buffer_count);
+#endif
+   } else {
+	  blep_buffer  = ramp+n;
+	  blamp_buffer = blep_buffer + blep_buffer_count;
+   }
+
+   // compute BLEP and BLAMP by integerating windowed sinc
+   for (i=0; i < n; ++i) {
+	  for (j=0; j < 16; ++j) {
+		 float sinc_t = 3.141592f* (i-half) / oversample;
+		 float sinc   = (i==half) ? 1.0f : (float) sin(sinc_t) / (sinc_t);
+		 float wt     = 2.0f*3.1415926f * i / (n-1);
+		 float window = (float) (0.355768 - 0.487396*cos(wt) + 0.144232*cos(2*wt) - 0.012604*cos(3*wt)); // Nuttall
+		 double value       =         window * sinc;
+		 integrate_impulse +=         value/16;
+		 integrate_step    +=         integrate_impulse/16;
+	  }
+	  step[i]            = (float) integrate_impulse;
+	  ramp[i]            = (float) integrate_step;
+   }
+
+   // renormalize
+   for (i=0; i < n; ++i) {
+	  step[i] = step[i] * (float) (1.0       / step[n-1]); // step needs to reach to 1.0
+	  ramp[i] = ramp[i] * (float) (halfwidth / ramp[n-1]); // ramp needs to become a slope of 1.0 after oversampling
+   }
+
+   // deinterleave to allow efficient interpolation e.g. w/SIMD
+   for (j=0; j <= oversample; ++j) {
+	  for (i=0; i < width; ++i) {
+		 blep_buffer [j*width+i] = step[j+i*oversample];
+		 blamp_buffer[j*width+i] = ramp[j+i*oversample];
+	  }
+   }
+
+   // subtract out the naive waveform; note we can't do this to the raw data
+   // above, because we want the discontinuity to be in a different locations
+   // for j=0 and j=oversample (which exists to provide something to interpolate against)
+   for (j=0; j <= oversample; ++j) {
+	  // subtract step
+	  for (i=halfwidth; i < width; ++i)
+		 blep_buffer [j*width+i] -= 1.0f;
+	  // subtract ramp
+	  for (i=halfwidth; i < width; ++i)
+		 blamp_buffer[j*width+i] -= (j+i*oversample-half)*(1.0f/oversample);
+   }
+
+   hexblep.blep  = blep_buffer;
+   hexblep.blamp = blamp_buffer;
+   hexblep.width = width;
+   hexblep.oversample = oversample;
+
+#ifndef STB_HEXWAVE_NO_ALLOCATION
+   if (user_buffer == 0)
+	  free(buffers);
+#endif
+}
+#endif // STB_HEXWAVE_IMPLEMENTATION
+
+/*
+------------------------------------------------------------------------------
+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.
+------------------------------------------------------------------------------
+*/

fggl/stb/stb_image_write.h

+/* 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 = { 0 };
+   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 = { 0 };
+   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 = { 0 };
+   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 = { 0 };
+   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 = { 0 };
+   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 = { 0 };
+   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 = { 0 };
+   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 = { 0 };
+   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.
+------------------------------------------------------------------------------
+*/

fggl/stb/stb_rect_pack.h

+// stb_rect_pack.h - v1.01 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Before #including,
+//
+//    #define STB_RECT_PACK_IMPLEMENTATION
+//
+// in the file that you want to have the implementation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+// Can override those by defining STBRP_SORT and STBRP_ASSERT.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Credits
+//
+//  Library
+//    Sean Barrett
+//  Minor features
+//    Martins Mozeiko
+//    github:IntellectualKitty
+//
+//  Bugfixes / warning fixes
+//    Jeremy Jaussaud
+//    Fabian Giesen
+//
+// Version history:
+//
+//     1.01  (2021-07-11)  always use large rect mode, expose STBRP__MAXVAL in public section
+//     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
+//     0.99  (2019-02-07)  warning fixes
+//     0.11  (2017-03-03)  return packing success/fail result
+//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
+//     0.09  (2016-08-27)  fix compiler warnings
+//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
+//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
+//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION  1
+
+#ifdef STBRP_STATIC
+#define STBRP_DEF static
+#else
+#define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct stbrp_context stbrp_context;
+typedef struct stbrp_node stbrp_node;
+typedef struct stbrp_rect stbrp_rect;
+
+typedef int stbrp_coord;
+
+#define STBRP__MAXVAL  0x7fffffff
+// Mostly for internal use, but this is the maximum supported coordinate value.
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects);
+// Assign packed locations to rectangles. The rectangles are of type
+// 'stbrp_rect' defined below, stored in the array 'rects', and there
+// are 'num_rects' many of them.
+//
+// Rectangles which are successfully packed have the 'was_packed' flag
+// set to a non-zero value and 'x' and 'y' store the minimum location
+// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+// if you imagine y increasing downwards). Rectangles which do not fit
+// have the 'was_packed' flag set to 0.
+//
+// You should not try to access the 'rects' array from another thread
+// while this function is running, as the function temporarily reorders
+// the array while it executes.
+//
+// To pack into another rectangle, you need to call stbrp_init_target
+// again. To continue packing into the same rectangle, you can call
+// this function again. Calling this multiple times with multiple rect
+// arrays will probably produce worse packing results than calling it
+// a single time with the full rectangle array, but the option is
+// available.
+//
+// The function returns 1 if all of the rectangles were successfully
+// packed and 0 otherwise.
+
+struct stbrp_rect {
+	// reserved for your use:
+	int id;
+
+	// input:
+	stbrp_coord w, h;
+
+	// output:
+	stbrp_coord x, y;
+	int was_packed;  // non-zero if valid packing
+
+}; // 16 bytes, nominally
+
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
+// Initialize a rectangle packer to:
+//    pack a rectangle that is 'width' by 'height' in dimensions
+//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+//
+// You must call this function every time you start packing into a new target.
+//
+// There is no "shutdown" function. The 'nodes' memory must stay valid for
+// the following stbrp_pack_rects() call (or calls), but can be freed after
+// the call (or calls) finish.
+//
+// Note: to guarantee best results, either:
+//       1. make sure 'num_nodes' >= 'width'
+//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+//
+// If you don't do either of the above things, widths will be quantized to multiples
+// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+//
+// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+// may run out of temporary storage and be unable to pack some rectangles.
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem);
+// Optionally call this function after init but before doing any packing to
+// change the handling of the out-of-temp-memory scenario, described above.
+// If you call init again, this will be reset to the default (false).
+
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic);
+// Optionally select which packing heuristic the library should use. Different
+// heuristics will produce better/worse results for different data sets.
+// If you call init again, this will be reset to the default.
+
+enum {
+	STBRP_HEURISTIC_Skyline_default = 0,
+	STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+	STBRP_HEURISTIC_Skyline_BF_sortHeight
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// the details of the following structures don't matter to you, but they must
+// be visible so you can handle the memory allocations for them
+
+struct stbrp_node {
+	stbrp_coord x, y;
+	stbrp_node *next;
+};
+
+struct stbrp_context {
+	int width;
+	int height;
+	int align;
+	int init_mode;
+	int heuristic;
+	int num_nodes;
+	stbrp_node *active_head;
+	stbrp_node *free_head;
+	stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#ifndef STBRP_SORT
+#include <stdlib.h>
+
+#define STBRP_SORT qsort
+#endif
+
+#ifndef STBRP_ASSERT
+#include <assert.h>
+
+#define STBRP_ASSERT assert
+#endif
+
+#ifdef _MSC_VER
+#define STBRP__NOTUSED(v)  (void)(v)
+#define STBRP__CDECL       __cdecl
+#else
+#define STBRP__NOTUSED(v)  (void)sizeof(v)
+#define STBRP__CDECL
+#endif
+
+enum {
+	STBRP__INIT_skyline = 1
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic) {
+	switch (context->init_mode) {
+	case STBRP__INIT_skyline:STBRP_ASSERT(
+			heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+		context->heuristic = heuristic;
+		break;
+	default:STBRP_ASSERT(0);
+	}
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem) {
+	if (allow_out_of_mem)
+		// if it's ok to run out of memory, then don't bother aligning them;
+		// this gives better packing, but may fail due to OOM (even though
+		// the rectangles easily fit). @TODO a smarter approach would be to only
+		// quantize once we've hit OOM, then we could get rid of this parameter.
+		context->align = 1;
+	else {
+		// if it's not ok to run out of memory, then quantize the widths
+		// so that num_nodes is always enough nodes.
+		//
+		// I.e. num_nodes * align >= width
+		//                  align >= width / num_nodes
+		//                  align = ceil(width/num_nodes)
+
+		context->align = (context->width + context->num_nodes - 1) / context->num_nodes;
+	}
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes) {
+	int i;
+
+	for (i = 0; i < num_nodes - 1; ++i)
+		nodes[i].next = &nodes[i + 1];
+	nodes[i].next = NULL;
+	context->init_mode = STBRP__INIT_skyline;
+	context->heuristic = STBRP_HEURISTIC_Skyline_default;
+	context->free_head = &nodes[0];
+	context->active_head = &context->extra[0];
+	context->width = width;
+	context->height = height;
+	context->num_nodes = num_nodes;
+	stbrp_setup_allow_out_of_mem(context, 0);
+
+	// node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+	context->extra[0].x = 0;
+	context->extra[0].y = 0;
+	context->extra[0].next = &context->extra[1];
+	context->extra[1].x = (stbrp_coord) width;
+	context->extra[1].y = (1 << 30);
+	context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste) {
+	stbrp_node *node = first;
+	int x1 = x0 + width;
+	int min_y, visited_width, waste_area;
+
+	STBRP__NOTUSED(c);
+
+		STBRP_ASSERT(first->x <= x0);
+
+	#if 0
+	// skip in case we're past the node
+	while (node->next->x <= x0)
+	   ++node;
+	#else
+		STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
+	#endif
+
+		STBRP_ASSERT(node->x <= x0);
+
+	min_y = 0;
+	waste_area = 0;
+	visited_width = 0;
+	while (node->x < x1) {
+		if (node->y > min_y) {
+			// raise min_y higher.
+			// we've accounted for all waste up to min_y,
+			// but we'll now add more waste for everything we've visted
+			waste_area += visited_width * (node->y - min_y);
+			min_y = node->y;
+			// the first time through, visited_width might be reduced
+			if (node->x < x0)
+				visited_width += node->next->x - x0;
+			else
+				visited_width += node->next->x - node->x;
+		} else {
+			// add waste area
+			int under_width = node->next->x - node->x;
+			if (under_width + visited_width > width)
+				under_width = width - visited_width;
+			waste_area += under_width * (min_y - node->y);
+			visited_width += under_width;
+		}
+		node = node->next;
+	}
+
+	*pwaste = waste_area;
+	return min_y;
+}
+
+typedef struct {
+	int x, y;
+	stbrp_node **prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height) {
+	int best_waste = (1 << 30), best_x, best_y = (1 << 30);
+	stbrp__findresult fr;
+	stbrp_node **prev, *node, *tail, **best = NULL;
+
+	// align to multiple of c->align
+	width = (width + c->align - 1);
+	width -= width % c->align;
+		STBRP_ASSERT(width % c->align == 0);
+
+	// if it can't possibly fit, bail immediately
+	if (width > c->width || height > c->height) {
+		fr.prev_link = NULL;
+		fr.x = fr.y = 0;
+		return fr;
+	}
+
+	node = c->active_head;
+	prev = &c->active_head;
+	while (node->x + width <= c->width) {
+		int y, waste;
+		y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+		if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
+			// bottom left
+			if (y < best_y) {
+				best_y = y;
+				best = prev;
+			}
+		} else {
+			// best-fit
+			if (y + height <= c->height) {
+				// can only use it if it first vertically
+				if (y < best_y || (y == best_y && waste < best_waste)) {
+					best_y = y;
+					best_waste = waste;
+					best = prev;
+				}
+			}
+		}
+		prev = &node->next;
+		node = node->next;
+	}
+
+	best_x = (best == NULL) ? 0 : (*best)->x;
+
+	// if doing best-fit (BF), we also have to try aligning right edge to each node position
+	//
+	// e.g, if fitting
+	//
+	//     ____________________
+	//    |____________________|
+	//
+	//            into
+	//
+	//   |                         |
+	//   |             ____________|
+	//   |____________|
+	//
+	// then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+	//
+	// This makes BF take about 2x the time
+
+	if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
+		tail = c->active_head;
+		node = c->active_head;
+		prev = &c->active_head;
+		// find first node that's admissible
+		while (tail->x < width)
+			tail = tail->next;
+		while (tail) {
+			int xpos = tail->x - width;
+			int y, waste;
+				STBRP_ASSERT(xpos >= 0);
+			// find the left position that matches this
+			while (node->next->x <= xpos) {
+				prev = &node->next;
+				node = node->next;
+			}
+				STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+			y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+			if (y + height <= c->height) {
+				if (y <= best_y) {
+					if (y < best_y || waste < best_waste || (waste == best_waste && xpos < best_x)) {
+						best_x = xpos;
+							STBRP_ASSERT(y <= best_y);
+						best_y = y;
+						best_waste = waste;
+						best = prev;
+					}
+				}
+			}
+			tail = tail->next;
+		}
+	}
+
+	fr.prev_link = best;
+	fr.x = best_x;
+	fr.y = best_y;
+	return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height) {
+	// find best position according to heuristic
+	stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+	stbrp_node *node, *cur;
+
+	// bail if:
+	//    1. it failed
+	//    2. the best node doesn't fit (we don't always check this)
+	//    3. we're out of memory
+	if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
+		res.prev_link = NULL;
+		return res;
+	}
+
+	// on success, create new node
+	node = context->free_head;
+	node->x = (stbrp_coord) res.x;
+	node->y = (stbrp_coord) (res.y + height);
+
+	context->free_head = node->next;
+
+	// insert the new node into the right starting point, and
+	// let 'cur' point to the remaining nodes needing to be
+	// stiched back in
+
+	cur = *res.prev_link;
+	if (cur->x < res.x) {
+		// preserve the existing one, so start testing with the next one
+		stbrp_node *next = cur->next;
+		cur->next = node;
+		cur = next;
+	} else {
+		*res.prev_link = node;
+	}
+
+	// from here, traverse cur and free the nodes, until we get to one
+	// that shouldn't be freed
+	while (cur->next && cur->next->x <= res.x + width) {
+		stbrp_node *next = cur->next;
+		// move the current node to the free list
+		cur->next = context->free_head;
+		context->free_head = cur;
+		cur = next;
+	}
+
+	// stitch the list back in
+	node->next = cur;
+
+	if (cur->x < res.x + width)
+		cur->x = (stbrp_coord) (res.x + width);
+
+#ifdef _DEBUG
+	cur = context->active_head;
+	while (cur->x < context->width) {
+	   STBRP_ASSERT(cur->x < cur->next->x);
+	   cur = cur->next;
+	}
+	STBRP_ASSERT(cur->next == NULL);
+
+	{
+	   int count=0;
+	   cur = context->active_head;
+	   while (cur) {
+		  cur = cur->next;
+		  ++count;
+	   }
+	   cur = context->free_head;
+	   while (cur) {
+		  cur = cur->next;
+		  ++count;
+	   }
+	   STBRP_ASSERT(count == context->num_nodes+2);
+	}
+#endif
+
+	return res;
+}
+
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b) {
+	const stbrp_rect *p = (const stbrp_rect *) a;
+	const stbrp_rect *q = (const stbrp_rect *) b;
+	if (p->h > q->h)
+		return -1;
+	if (p->h < q->h)
+		return 1;
+	return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+static int STBRP__CDECL rect_original_order(const void *a, const void *b) {
+	const stbrp_rect *p = (const stbrp_rect *) a;
+	const stbrp_rect *q = (const stbrp_rect *) b;
+	return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects) {
+	int i, all_rects_packed = 1;
+
+	// we use the 'was_packed' field internally to allow sorting/unsorting
+	for (i = 0; i < num_rects; ++i) {
+		rects[i].was_packed = i;
+	}
+
+	// sort according to heuristic
+	STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+	for (i = 0; i < num_rects; ++i) {
+		if (rects[i].w == 0 || rects[i].h == 0) {
+			rects[i].x = rects[i].y = 0;  // empty rect needs no space
+		} else {
+			stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+			if (fr.prev_link) {
+				rects[i].x = (stbrp_coord) fr.x;
+				rects[i].y = (stbrp_coord) fr.y;
+			} else {
+				rects[i].x = rects[i].y = STBRP__MAXVAL;
+			}
+		}
+	}
+
+	// unsort
+	STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+	// set was_packed flags and all_rects_packed status
+	for (i = 0; i < num_rects; ++i) {
+		rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+		if (!rects[i].was_packed)
+			all_rects_packed = 0;
+	}
+
+	// return the all_rects_packed status
+	return all_rects_packed;
+}
+
+#endif
+
+/*
+------------------------------------------------------------------------------
+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.
+------------------------------------------------------------------------------
+*/

fggl/stb/stb_textedit.h

+// stb_textedit.h - v1.14  - public domain - Sean Barrett
+// Development of this library was sponsored by RAD Game Tools
+//
+// This C header file implements the guts of a multi-line text-editing
+// widget; you implement display, word-wrapping, and low-level string
+// insertion/deletion, and stb_textedit will map user inputs into
+// insertions & deletions, plus updates to the cursor position,
+// selection state, and undo state.
+//
+// It is intended for use in games and other systems that need to build
+// their own custom widgets and which do not have heavy text-editing
+// requirements (this library is not recommended for use for editing large
+// texts, as its performance does not scale and it has limited undo).
+//
+// Non-trivial behaviors are modelled after Windows text controls.
+//
+//
+// LICENSE
+//
+// See end of file for license information.
+//
+//
+// DEPENDENCIES
+//
+// Uses the C runtime function 'memmove', which you can override
+// by defining STB_TEXTEDIT_memmove before the implementation.
+// Uses no other functions. Performs no runtime allocations.
+//
+//
+// VERSION HISTORY
+//
+//   1.14 (2021-07-11) page up/down, various fixes
+//   1.13 (2019-02-07) fix bug in undo size management
+//   1.12 (2018-01-29) user can change STB_TEXTEDIT_KEYTYPE, fix redo to avoid crash
+//   1.11 (2017-03-03) fix HOME on last line, dragging off single-line textfield
+//   1.10 (2016-10-25) supress warnings about casting away const with -Wcast-qual
+//   1.9  (2016-08-27) customizable move-by-word
+//   1.8  (2016-04-02) better keyboard handling when mouse button is down
+//   1.7  (2015-09-13) change y range handling in case baseline is non-0
+//   1.6  (2015-04-15) allow STB_TEXTEDIT_memmove
+//   1.5  (2014-09-10) add support for secondary keys for OS X
+//   1.4  (2014-08-17) fix signed/unsigned warnings
+//   1.3  (2014-06-19) fix mouse clicking to round to nearest char boundary
+//   1.2  (2014-05-27) fix some RAD types that had crept into the new code
+//   1.1  (2013-12-15) move-by-word (requires STB_TEXTEDIT_IS_SPACE )
+//   1.0  (2012-07-26) improve documentation, initial public release
+//   0.3  (2012-02-24) bugfixes, single-line mode; insert mode
+//   0.2  (2011-11-28) fixes to undo/redo
+//   0.1  (2010-07-08) initial version
+//
+// ADDITIONAL CONTRIBUTORS
+//
+//   Ulf Winklemann: move-by-word in 1.1
+//   Fabian Giesen: secondary key inputs in 1.5
+//   Martins Mozeiko: STB_TEXTEDIT_memmove in 1.6
+//   Louis Schnellbach: page up/down in 1.14
+//
+//   Bugfixes:
+//      Scott Graham
+//      Daniel Keller
+//      Omar Cornut
+//      Dan Thompson
+//
+// USAGE
+//
+// This file behaves differently depending on what symbols you define
+// before including it.
+//
+//
+// Header-file mode:
+//
+//   If you do not define STB_TEXTEDIT_IMPLEMENTATION before including this,
+//   it will operate in "header file" mode. In this mode, it declares a
+//   single public symbol, STB_TexteditState, which encapsulates the current
+//   state of a text widget (except for the string, which you will store
+//   separately).
+//
+//   To compile in this mode, you must define STB_TEXTEDIT_CHARTYPE to a
+//   primitive type that defines a single character (e.g. char, wchar_t, etc).
+//
+//   To save space or increase undo-ability, you can optionally define the
+//   following things that are used by the undo system:
+//
+//      STB_TEXTEDIT_POSITIONTYPE         small int type encoding a valid cursor position
+//      STB_TEXTEDIT_UNDOSTATECOUNT       the number of undo states to allow
+//      STB_TEXTEDIT_UNDOCHARCOUNT        the number of characters to store in the undo buffer
+//
+//   If you don't define these, they are set to permissive types and
+//   moderate sizes. The undo system does no memory allocations, so
+//   it grows STB_TexteditState by the worst-case storage which is (in bytes):
+//
+//        [4 + 3 * sizeof(STB_TEXTEDIT_POSITIONTYPE)] * STB_TEXTEDIT_UNDOSTATECOUNT
+//      +          sizeof(STB_TEXTEDIT_CHARTYPE)      * STB_TEXTEDIT_UNDOCHARCOUNT
+//
+//
+// Implementation mode:
+//
+//   If you define STB_TEXTEDIT_IMPLEMENTATION before including this, it
+//   will compile the implementation of the text edit widget, depending
+//   on a large number of symbols which must be defined before the include.
+//
+//   The implementation is defined only as static functions. You will then
+//   need to provide your own APIs in the same file which will access the
+//   static functions.
+//
+//   The basic concept is that you provide a "string" object which
+//   behaves like an array of characters. stb_textedit uses indices to
+//   refer to positions in the string, implicitly representing positions
+//   in the displayed textedit. This is true for both plain text and
+//   rich text; even with rich text stb_truetype interacts with your
+//   code as if there was an array of all the displayed characters.
+//
+// Symbols that must be the same in header-file and implementation mode:
+//
+//     STB_TEXTEDIT_CHARTYPE             the character type
+//     STB_TEXTEDIT_POSITIONTYPE         small type that is a valid cursor position
+//     STB_TEXTEDIT_UNDOSTATECOUNT       the number of undo states to allow
+//     STB_TEXTEDIT_UNDOCHARCOUNT        the number of characters to store in the undo buffer
+//
+// Symbols you must define for implementation mode:
+//
+//    STB_TEXTEDIT_STRING               the type of object representing a string being edited,
+//                                      typically this is a wrapper object with other data you need
+//
+//    STB_TEXTEDIT_STRINGLEN(obj)       the length of the string (ideally O(1))
+//    STB_TEXTEDIT_LAYOUTROW(&r,obj,n)  returns the results of laying out a line of characters
+//                                        starting from character #n (see discussion below)
+//    STB_TEXTEDIT_GETWIDTH(obj,n,i)    returns the pixel delta from the xpos of the i'th character
+//                                        to the xpos of the i+1'th char for a line of characters
+//                                        starting at character #n (i.e. accounts for kerning
+//                                        with previous char)
+//    STB_TEXTEDIT_KEYTOTEXT(k)         maps a keyboard input to an insertable character
+//                                        (return type is int, -1 means not valid to insert)
+//    STB_TEXTEDIT_GETCHAR(obj,i)       returns the i'th character of obj, 0-based
+//    STB_TEXTEDIT_NEWLINE              the character returned by _GETCHAR() we recognize
+//                                        as manually wordwrapping for end-of-line positioning
+//
+//    STB_TEXTEDIT_DELETECHARS(obj,i,n)      delete n characters starting at i
+//    STB_TEXTEDIT_INSERTCHARS(obj,i,c*,n)   insert n characters at i (pointed to by STB_TEXTEDIT_CHARTYPE*)
+//
+//    STB_TEXTEDIT_K_SHIFT       a power of two that is or'd in to a keyboard input to represent the shift key
+//
+//    STB_TEXTEDIT_K_LEFT        keyboard input to move cursor left
+//    STB_TEXTEDIT_K_RIGHT       keyboard input to move cursor right
+//    STB_TEXTEDIT_K_UP          keyboard input to move cursor up
+//    STB_TEXTEDIT_K_DOWN        keyboard input to move cursor down
+//    STB_TEXTEDIT_K_PGUP        keyboard input to move cursor up a page
+//    STB_TEXTEDIT_K_PGDOWN      keyboard input to move cursor down a page
+//    STB_TEXTEDIT_K_LINESTART   keyboard input to move cursor to start of line  // e.g. HOME
+//    STB_TEXTEDIT_K_LINEEND     keyboard input to move cursor to end of line    // e.g. END
+//    STB_TEXTEDIT_K_TEXTSTART   keyboard input to move cursor to start of text  // e.g. ctrl-HOME
+//    STB_TEXTEDIT_K_TEXTEND     keyboard input to move cursor to end of text    // e.g. ctrl-END
+//    STB_TEXTEDIT_K_DELETE      keyboard input to delete selection or character under cursor
+//    STB_TEXTEDIT_K_BACKSPACE   keyboard input to delete selection or character left of cursor
+//    STB_TEXTEDIT_K_UNDO        keyboard input to perform undo
+//    STB_TEXTEDIT_K_REDO        keyboard input to perform redo
+//
+// Optional:
+//    STB_TEXTEDIT_K_INSERT              keyboard input to toggle insert mode
+//    STB_TEXTEDIT_IS_SPACE(ch)          true if character is whitespace (e.g. 'isspace'),
+//                                          required for default WORDLEFT/WORDRIGHT handlers
+//    STB_TEXTEDIT_MOVEWORDLEFT(obj,i)   custom handler for WORDLEFT, returns index to move cursor to
+//    STB_TEXTEDIT_MOVEWORDRIGHT(obj,i)  custom handler for WORDRIGHT, returns index to move cursor to
+//    STB_TEXTEDIT_K_WORDLEFT            keyboard input to move cursor left one word // e.g. ctrl-LEFT
+//    STB_TEXTEDIT_K_WORDRIGHT           keyboard input to move cursor right one word // e.g. ctrl-RIGHT
+//    STB_TEXTEDIT_K_LINESTART2          secondary keyboard input to move cursor to start of line
+//    STB_TEXTEDIT_K_LINEEND2            secondary keyboard input to move cursor to end of line
+//    STB_TEXTEDIT_K_TEXTSTART2          secondary keyboard input to move cursor to start of text
+//    STB_TEXTEDIT_K_TEXTEND2            secondary keyboard input to move cursor to end of text
+//
+// Keyboard input must be encoded as a single integer value; e.g. a character code
+// and some bitflags that represent shift states. to simplify the interface, SHIFT must
+// be a bitflag, so we can test the shifted state of cursor movements to allow selection,
+// i.e. (STB_TEXTEDIT_K_RIGHT|STB_TEXTEDIT_K_SHIFT) should be shifted right-arrow.
+//
+// You can encode other things, such as CONTROL or ALT, in additional bits, and
+// then test for their presence in e.g. STB_TEXTEDIT_K_WORDLEFT. For example,
+// my Windows implementations add an additional CONTROL bit, and an additional KEYDOWN
+// bit. Then all of the STB_TEXTEDIT_K_ values bitwise-or in the KEYDOWN bit,
+// and I pass both WM_KEYDOWN and WM_CHAR events to the "key" function in the
+// API below. The control keys will only match WM_KEYDOWN events because of the
+// keydown bit I add, and STB_TEXTEDIT_KEYTOTEXT only tests for the KEYDOWN
+// bit so it only decodes WM_CHAR events.
+//
+// STB_TEXTEDIT_LAYOUTROW returns information about the shape of one displayed
+// row of characters assuming they start on the i'th character--the width and
+// the height and the number of characters consumed. This allows this library
+// to traverse the entire layout incrementally. You need to compute word-wrapping
+// here.
+//
+// Each textfield keeps its own insert mode state, which is not how normal
+// applications work. To keep an app-wide insert mode, update/copy the
+// "insert_mode" field of STB_TexteditState before/after calling API functions.
+//
+// API
+//
+//    void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)
+//
+//    void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+//    void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+//    int  stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+//    int  stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)
+//    void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXEDIT_KEYTYPE key)
+//
+//    Each of these functions potentially updates the string and updates the
+//    state.
+//
+//      initialize_state:
+//          set the textedit state to a known good default state when initially
+//          constructing the textedit.
+//
+//      click:
+//          call this with the mouse x,y on a mouse down; it will update the cursor
+//          and reset the selection start/end to the cursor point. the x,y must
+//          be relative to the text widget, with (0,0) being the top left.
+//
+//      drag:
+//          call this with the mouse x,y on a mouse drag/up; it will update the
+//          cursor and the selection end point
+//
+//      cut:
+//          call this to delete the current selection; returns true if there was
+//          one. you should FIRST copy the current selection to the system paste buffer.
+//          (To copy, just copy the current selection out of the string yourself.)
+//
+//      paste:
+//          call this to paste text at the current cursor point or over the current
+//          selection if there is one.
+//
+//      key:
+//          call this for keyboard inputs sent to the textfield. you can use it
+//          for "key down" events or for "translated" key events. if you need to
+//          do both (as in Win32), or distinguish Unicode characters from control
+//          inputs, set a high bit to distinguish the two; then you can define the
+//          various definitions like STB_TEXTEDIT_K_LEFT have the is-key-event bit
+//          set, and make STB_TEXTEDIT_KEYTOCHAR check that the is-key-event bit is
+//          clear. STB_TEXTEDIT_KEYTYPE defaults to int, but you can #define it to
+//          anything other type you wante before including.
+//
+//
+//   When rendering, you can read the cursor position and selection state from
+//   the STB_TexteditState.
+//
+//
+// Notes:
+//
+// This is designed to be usable in IMGUI, so it allows for the possibility of
+// running in an IMGUI that has NOT cached the multi-line layout. For this
+// reason, it provides an interface that is compatible with computing the
+// layout incrementally--we try to make sure we make as few passes through
+// as possible. (For example, to locate the mouse pointer in the text, we
+// could define functions that return the X and Y positions of characters
+// and binary search Y and then X, but if we're doing dynamic layout this
+// will run the layout algorithm many times, so instead we manually search
+// forward in one pass. Similar logic applies to e.g. up-arrow and
+// down-arrow movement.)
+//
+// If it's run in a widget that *has* cached the layout, then this is less
+// efficient, but it's not horrible on modern computers. But you wouldn't
+// want to edit million-line files with it.
+
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////
+////   Header-file mode
+////
+////
+
+#ifndef INCLUDE_STB_TEXTEDIT_H
+#define INCLUDE_STB_TEXTEDIT_H
+
+////////////////////////////////////////////////////////////////////////
+//
+//     STB_TexteditState
+//
+// Definition of STB_TexteditState which you should store
+// per-textfield; it includes cursor position, selection state,
+// and undo state.
+//
+
+#ifndef STB_TEXTEDIT_UNDOSTATECOUNT
+#define STB_TEXTEDIT_UNDOSTATECOUNT   99
+#endif
+#ifndef STB_TEXTEDIT_UNDOCHARCOUNT
+#define STB_TEXTEDIT_UNDOCHARCOUNT   999
+#endif
+#ifndef STB_TEXTEDIT_CHARTYPE
+#define STB_TEXTEDIT_CHARTYPE        int
+#endif
+#ifndef STB_TEXTEDIT_POSITIONTYPE
+#define STB_TEXTEDIT_POSITIONTYPE    int
+#endif
+
+typedef struct {
+	// private data
+	STB_TEXTEDIT_POSITIONTYPE where;
+	STB_TEXTEDIT_POSITIONTYPE insert_length;
+	STB_TEXTEDIT_POSITIONTYPE delete_length;
+	int char_storage;
+} StbUndoRecord;
+
+typedef struct {
+	// private data
+	StbUndoRecord undo_rec[STB_TEXTEDIT_UNDOSTATECOUNT];
+	STB_TEXTEDIT_CHARTYPE undo_char[STB_TEXTEDIT_UNDOCHARCOUNT];
+	short undo_point, redo_point;
+	int undo_char_point, redo_char_point;
+} StbUndoState;
+
+typedef struct {
+	/////////////////////
+	//
+	// public data
+	//
+
+	int cursor;
+	// position of the text cursor within the string
+
+	int select_start;          // selection start point
+	int select_end;
+	// selection start and end point in characters; if equal, no selection.
+	// note that start may be less than or greater than end (e.g. when
+	// dragging the mouse, start is where the initial click was, and you
+	// can drag in either direction)
+
+	unsigned char insert_mode;
+	// each textfield keeps its own insert mode state. to keep an app-wide
+	// insert mode, copy this value in/out of the app state
+
+	int row_count_per_page;
+	// page size in number of row.
+	// this value MUST be set to >0 for pageup or pagedown in multilines documents.
+
+	/////////////////////
+	//
+	// private data
+	//
+	unsigned char cursor_at_end_of_line; // not implemented yet
+	unsigned char initialized;
+	unsigned char has_preferred_x;
+	unsigned char single_line;
+	unsigned char padding1, padding2, padding3;
+	float preferred_x; // this determines where the cursor up/down tries to seek to along x
+	StbUndoState undostate;
+} STB_TexteditState;
+
+
+////////////////////////////////////////////////////////////////////////
+//
+//     StbTexteditRow
+//
+// Result of layout query, used by stb_textedit to determine where
+// the text in each row is.
+
+// result of layout query
+typedef struct {
+	float x0, x1;             // starting x location, end x location (allows for align=right, etc)
+	float baseline_y_delta;  // position of baseline relative to previous row's baseline
+	float ymin, ymax;         // height of row above and below baseline
+	int num_chars;
+} StbTexteditRow;
+#endif //INCLUDE_STB_TEXTEDIT_H
+
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////
+////   Implementation mode
+////
+////
+
+
+// implementation isn't include-guarded, since it might have indirectly
+// included just the "header" portion
+#ifdef STB_TEXTEDIT_IMPLEMENTATION
+
+#ifndef STB_TEXTEDIT_memmove
+#include <string.h>
+#define STB_TEXTEDIT_memmove memmove
+#endif
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Mouse input handling
+//
+
+// traverse the layout to locate the nearest character to a display position
+static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)
+{
+   StbTexteditRow r;
+   int n = STB_TEXTEDIT_STRINGLEN(str);
+   float base_y = 0, prev_x;
+   int i=0, k;
+
+   r.x0 = r.x1 = 0;
+   r.ymin = r.ymax = 0;
+   r.num_chars = 0;
+
+   // search rows to find one that straddles 'y'
+   while (i < n) {
+	  STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+	  if (r.num_chars <= 0)
+		 return n;
+
+	  if (i==0 && y < base_y + r.ymin)
+		 return 0;
+
+	  if (y < base_y + r.ymax)
+		 break;
+
+	  i += r.num_chars;
+	  base_y += r.baseline_y_delta;
+   }
+
+   // below all text, return 'after' last character
+   if (i >= n)
+	  return n;
+
+   // check if it's before the beginning of the line
+   if (x < r.x0)
+	  return i;
+
+   // check if it's before the end of the line
+   if (x < r.x1) {
+	  // search characters in row for one that straddles 'x'
+	  prev_x = r.x0;
+	  for (k=0; k < r.num_chars; ++k) {
+		 float w = STB_TEXTEDIT_GETWIDTH(str, i, k);
+		 if (x < prev_x+w) {
+			if (x < prev_x+w/2)
+			   return k+i;
+			else
+			   return k+i+1;
+		 }
+		 prev_x += w;
+	  }
+	  // shouldn't happen, but if it does, fall through to end-of-line case
+   }
+
+   // if the last character is a newline, return that. otherwise return 'after' the last character
+   if (STB_TEXTEDIT_GETCHAR(str, i+r.num_chars-1) == STB_TEXTEDIT_NEWLINE)
+	  return i+r.num_chars-1;
+   else
+	  return i+r.num_chars;
+}
+
+// API click: on mouse down, move the cursor to the clicked location, and reset the selection
+static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+{
+   // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
+   // goes off the top or bottom of the text
+   if( state->single_line )
+   {
+	  StbTexteditRow r;
+	  STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
+	  y = r.ymin;
+   }
+
+   state->cursor = stb_text_locate_coord(str, x, y);
+   state->select_start = state->cursor;
+   state->select_end = state->cursor;
+   state->has_preferred_x = 0;
+}
+
+// API drag: on mouse drag, move the cursor and selection endpoint to the clicked location
+static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+{
+   int p = 0;
+
+   // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
+   // goes off the top or bottom of the text
+   if( state->single_line )
+   {
+	  StbTexteditRow r;
+	  STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
+	  y = r.ymin;
+   }
+
+   if (state->select_start == state->select_end)
+	  state->select_start = state->cursor;
+
+   p = stb_text_locate_coord(str, x, y);
+   state->cursor = state->select_end = p;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Keyboard input handling
+//
+
+// forward declarations
+static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);
+static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);
+static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length);
+static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length);
+static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length);
+
+typedef struct
+{
+   float x,y;    // position of n'th character
+   float height; // height of line
+   int first_char, length; // first char of row, and length
+   int prev_first;  // first char of previous row
+} StbFindState;
+
+// find the x/y location of a character, and remember info about the previous row in
+// case we get a move-up event (for page up, we'll have to rescan)
+static void stb_textedit_find_charpos(StbFindState *find, STB_TEXTEDIT_STRING *str, int n, int single_line)
+{
+   StbTexteditRow r;
+   int prev_start = 0;
+   int z = STB_TEXTEDIT_STRINGLEN(str);
+   int i=0, first;
+
+   if (n == z) {
+	  // if it's at the end, then find the last line -- simpler than trying to
+	  // explicitly handle this case in the regular code
+	  if (single_line) {
+		 STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
+		 find->y = 0;
+		 find->first_char = 0;
+		 find->length = z;
+		 find->height = r.ymax - r.ymin;
+		 find->x = r.x1;
+	  } else {
+		 find->y = 0;
+		 find->x = 0;
+		 find->height = 1;
+		 while (i < z) {
+			STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+			prev_start = i;
+			i += r.num_chars;
+		 }
+		 find->first_char = i;
+		 find->length = 0;
+		 find->prev_first = prev_start;
+	  }
+	  return;
+   }
+
+   // search rows to find the one that straddles character n
+   find->y = 0;
+
+   for(;;) {
+	  STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+	  if (n < i + r.num_chars)
+		 break;
+	  prev_start = i;
+	  i += r.num_chars;
+	  find->y += r.baseline_y_delta;
+   }
+
+   find->first_char = first = i;
+   find->length = r.num_chars;
+   find->height = r.ymax - r.ymin;
+   find->prev_first = prev_start;
+
+   // now scan to find xpos
+   find->x = r.x0;
+   for (i=0; first+i < n; ++i)
+	  find->x += STB_TEXTEDIT_GETWIDTH(str, first, i);
+}
+
+#define STB_TEXT_HAS_SELECTION(s)   ((s)->select_start != (s)->select_end)
+
+// make the selection/cursor state valid if client altered the string
+static void stb_textedit_clamp(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   int n = STB_TEXTEDIT_STRINGLEN(str);
+   if (STB_TEXT_HAS_SELECTION(state)) {
+	  if (state->select_start > n) state->select_start = n;
+	  if (state->select_end   > n) state->select_end = n;
+	  // if clamping forced them to be equal, move the cursor to match
+	  if (state->select_start == state->select_end)
+		 state->cursor = state->select_start;
+   }
+   if (state->cursor > n) state->cursor = n;
+}
+
+// delete characters while updating undo
+static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)
+{
+   stb_text_makeundo_delete(str, state, where, len);
+   STB_TEXTEDIT_DELETECHARS(str, where, len);
+   state->has_preferred_x = 0;
+}
+
+// delete the section
+static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   stb_textedit_clamp(str, state);
+   if (STB_TEXT_HAS_SELECTION(state)) {
+	  if (state->select_start < state->select_end) {
+		 stb_textedit_delete(str, state, state->select_start, state->select_end - state->select_start);
+		 state->select_end = state->cursor = state->select_start;
+	  } else {
+		 stb_textedit_delete(str, state, state->select_end, state->select_start - state->select_end);
+		 state->select_start = state->cursor = state->select_end;
+	  }
+	  state->has_preferred_x = 0;
+   }
+}
+
+// canoncialize the selection so start <= end
+static void stb_textedit_sortselection(STB_TexteditState *state)
+{
+   if (state->select_end < state->select_start) {
+	  int temp = state->select_end;
+	  state->select_end = state->select_start;
+	  state->select_start = temp;
+   }
+}
+
+// move cursor to first character of selection
+static void stb_textedit_move_to_first(STB_TexteditState *state)
+{
+   if (STB_TEXT_HAS_SELECTION(state)) {
+	  stb_textedit_sortselection(state);
+	  state->cursor = state->select_start;
+	  state->select_end = state->select_start;
+	  state->has_preferred_x = 0;
+   }
+}
+
+// move cursor to last character of selection
+static void stb_textedit_move_to_last(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   if (STB_TEXT_HAS_SELECTION(state)) {
+	  stb_textedit_sortselection(state);
+	  stb_textedit_clamp(str, state);
+	  state->cursor = state->select_end;
+	  state->select_start = state->select_end;
+	  state->has_preferred_x = 0;
+   }
+}
+
+#ifdef STB_TEXTEDIT_IS_SPACE
+static int is_word_boundary( STB_TEXTEDIT_STRING *str, int idx )
+{
+   return idx > 0 ? (STB_TEXTEDIT_IS_SPACE( STB_TEXTEDIT_GETCHAR(str,idx-1) ) && !STB_TEXTEDIT_IS_SPACE( STB_TEXTEDIT_GETCHAR(str, idx) ) ) : 1;
+}
+
+#ifndef STB_TEXTEDIT_MOVEWORDLEFT
+static int stb_textedit_move_to_word_previous( STB_TEXTEDIT_STRING *str, int c )
+{
+   --c; // always move at least one character
+   while( c >= 0 && !is_word_boundary( str, c ) )
+	  --c;
+
+   if( c < 0 )
+	  c = 0;
+
+   return c;
+}
+#define STB_TEXTEDIT_MOVEWORDLEFT stb_textedit_move_to_word_previous
+#endif
+
+#ifndef STB_TEXTEDIT_MOVEWORDRIGHT
+static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *str, int c )
+{
+   const int len = STB_TEXTEDIT_STRINGLEN(str);
+   ++c; // always move at least one character
+   while( c < len && !is_word_boundary( str, c ) )
+	  ++c;
+
+   if( c > len )
+	  c = len;
+
+   return c;
+}
+#define STB_TEXTEDIT_MOVEWORDRIGHT stb_textedit_move_to_word_next
+#endif
+
+#endif
+
+// update selection and cursor to match each other
+static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state)
+{
+   if (!STB_TEXT_HAS_SELECTION(state))
+	  state->select_start = state->select_end = state->cursor;
+   else
+	  state->cursor = state->select_end;
+}
+
+// API cut: delete selection
+static int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   if (STB_TEXT_HAS_SELECTION(state)) {
+	  stb_textedit_delete_selection(str,state); // implicitly clamps
+	  state->has_preferred_x = 0;
+	  return 1;
+   }
+   return 0;
+}
+
+// API paste: replace existing selection with passed-in text
+static int stb_textedit_paste_internal(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)
+{
+   // if there's a selection, the paste should delete it
+   stb_textedit_clamp(str, state);
+   stb_textedit_delete_selection(str,state);
+   // try to insert the characters
+   if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, len)) {
+	  stb_text_makeundo_insert(state, state->cursor, len);
+	  state->cursor += len;
+	  state->has_preferred_x = 0;
+	  return 1;
+   }
+   // note: paste failure will leave deleted selection, may be restored with an undo (see https://github.com/nothings/stb/issues/734 for details)
+   return 0;
+}
+
+#ifndef STB_TEXTEDIT_KEYTYPE
+#define STB_TEXTEDIT_KEYTYPE int
+#endif
+
+// API key: process a keyboard input
+static void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_KEYTYPE key)
+{
+retry:
+   switch (key) {
+	  default: {
+		 int c = STB_TEXTEDIT_KEYTOTEXT(key);
+		 if (c > 0) {
+			STB_TEXTEDIT_CHARTYPE ch = (STB_TEXTEDIT_CHARTYPE) c;
+
+			// can't add newline in single-line mode
+			if (c == '\n' && state->single_line)
+			   break;
+
+			if (state->insert_mode && !STB_TEXT_HAS_SELECTION(state) && state->cursor < STB_TEXTEDIT_STRINGLEN(str)) {
+			   stb_text_makeundo_replace(str, state, state->cursor, 1, 1);
+			   STB_TEXTEDIT_DELETECHARS(str, state->cursor, 1);
+			   if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1)) {
+				  ++state->cursor;
+				  state->has_preferred_x = 0;
+			   }
+			} else {
+			   stb_textedit_delete_selection(str,state); // implicitly clamps
+			   if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1)) {
+				  stb_text_makeundo_insert(state, state->cursor, 1);
+				  ++state->cursor;
+				  state->has_preferred_x = 0;
+			   }
+			}
+		 }
+		 break;
+	  }
+
+#ifdef STB_TEXTEDIT_K_INSERT
+	  case STB_TEXTEDIT_K_INSERT:
+		 state->insert_mode = !state->insert_mode;
+		 break;
+#endif
+
+	  case STB_TEXTEDIT_K_UNDO:
+		 stb_text_undo(str, state);
+		 state->has_preferred_x = 0;
+		 break;
+
+	  case STB_TEXTEDIT_K_REDO:
+		 stb_text_redo(str, state);
+		 state->has_preferred_x = 0;
+		 break;
+
+	  case STB_TEXTEDIT_K_LEFT:
+		 // if currently there's a selection, move cursor to start of selection
+		 if (STB_TEXT_HAS_SELECTION(state))
+			stb_textedit_move_to_first(state);
+		 else
+			if (state->cursor > 0)
+			   --state->cursor;
+		 state->has_preferred_x = 0;
+		 break;
+
+	  case STB_TEXTEDIT_K_RIGHT:
+		 // if currently there's a selection, move cursor to end of selection
+		 if (STB_TEXT_HAS_SELECTION(state))
+			stb_textedit_move_to_last(str, state);
+		 else
+			++state->cursor;
+		 stb_textedit_clamp(str, state);
+		 state->has_preferred_x = 0;
+		 break;
+
+	  case STB_TEXTEDIT_K_LEFT | STB_TEXTEDIT_K_SHIFT:
+		 stb_textedit_clamp(str, state);
+		 stb_textedit_prep_selection_at_cursor(state);
+		 // move selection left
+		 if (state->select_end > 0)
+			--state->select_end;
+		 state->cursor = state->select_end;
+		 state->has_preferred_x = 0;
+		 break;
+
+#ifdef STB_TEXTEDIT_MOVEWORDLEFT
+	  case STB_TEXTEDIT_K_WORDLEFT:
+		 if (STB_TEXT_HAS_SELECTION(state))
+			stb_textedit_move_to_first(state);
+		 else {
+			state->cursor = STB_TEXTEDIT_MOVEWORDLEFT(str, state->cursor);
+			stb_textedit_clamp( str, state );
+		 }
+		 break;
+
+	  case STB_TEXTEDIT_K_WORDLEFT | STB_TEXTEDIT_K_SHIFT:
+		 if( !STB_TEXT_HAS_SELECTION( state ) )
+			stb_textedit_prep_selection_at_cursor(state);
+
+		 state->cursor = STB_TEXTEDIT_MOVEWORDLEFT(str, state->cursor);
+		 state->select_end = state->cursor;
+
+		 stb_textedit_clamp( str, state );
+		 break;
+#endif
+
+#ifdef STB_TEXTEDIT_MOVEWORDRIGHT
+	  case STB_TEXTEDIT_K_WORDRIGHT:
+		 if (STB_TEXT_HAS_SELECTION(state))
+			stb_textedit_move_to_last(str, state);
+		 else {
+			state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor);
+			stb_textedit_clamp( str, state );
+		 }
+		 break;
+
+	  case STB_TEXTEDIT_K_WORDRIGHT | STB_TEXTEDIT_K_SHIFT:
+		 if( !STB_TEXT_HAS_SELECTION( state ) )
+			stb_textedit_prep_selection_at_cursor(state);
+
+		 state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor);
+		 state->select_end = state->cursor;
+
+		 stb_textedit_clamp( str, state );
+		 break;
+#endif
+
+	  case STB_TEXTEDIT_K_RIGHT | STB_TEXTEDIT_K_SHIFT:
+		 stb_textedit_prep_selection_at_cursor(state);
+		 // move selection right
+		 ++state->select_end;
+		 stb_textedit_clamp(str, state);
+		 state->cursor = state->select_end;
+		 state->has_preferred_x = 0;
+		 break;
+
+	  case STB_TEXTEDIT_K_DOWN:
+	  case STB_TEXTEDIT_K_DOWN | STB_TEXTEDIT_K_SHIFT:
+	  case STB_TEXTEDIT_K_PGDOWN:
+	  case STB_TEXTEDIT_K_PGDOWN | STB_TEXTEDIT_K_SHIFT: {
+		 StbFindState find;
+		 StbTexteditRow row;
+		 int i, j, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0;
+		 int is_page = (key & ~STB_TEXTEDIT_K_SHIFT) == STB_TEXTEDIT_K_PGDOWN;
+		 int row_count = is_page ? state->row_count_per_page : 1;
+
+		 if (!is_page && state->single_line) {
+			// on windows, up&down in single-line behave like left&right
+			key = STB_TEXTEDIT_K_RIGHT | (key & STB_TEXTEDIT_K_SHIFT);
+			goto retry;
+		 }
+
+		 if (sel)
+			stb_textedit_prep_selection_at_cursor(state);
+		 else if (STB_TEXT_HAS_SELECTION(state))
+			stb_textedit_move_to_last(str, state);
+
+		 // compute current position of cursor point
+		 stb_textedit_clamp(str, state);
+		 stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+
+		 for (j = 0; j < row_count; ++j) {
+			float x, goal_x = state->has_preferred_x ? state->preferred_x : find.x;
+			int start = find.first_char + find.length;
+
+			if (find.length == 0)
+			   break;
+
+			// now find character position down a row
+			state->cursor = start;
+			STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
+			x = row.x0;
+			for (i=0; i < row.num_chars; ++i) {
+			   float dx = STB_TEXTEDIT_GETWIDTH(str, start, i);
+#ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE
+			   if (dx == STB_TEXTEDIT_GETWIDTH_NEWLINE)
+				  break;
+#endif
+			   x += dx;
+			   if (x > goal_x)
+				  break;
+			   ++state->cursor;
+			}
+			stb_textedit_clamp(str, state);
+
+			state->has_preferred_x = 1;
+			state->preferred_x = goal_x;
+
+			if (sel)
+			   state->select_end = state->cursor;
+
+			// go to next line
+			find.first_char = find.first_char + find.length;
+			find.length = row.num_chars;
+		 }
+		 break;
+	  }
+
+	  case STB_TEXTEDIT_K_UP:
+	  case STB_TEXTEDIT_K_UP | STB_TEXTEDIT_K_SHIFT:
+	  case STB_TEXTEDIT_K_PGUP:
+	  case STB_TEXTEDIT_K_PGUP | STB_TEXTEDIT_K_SHIFT: {
+		 StbFindState find;
+		 StbTexteditRow row;
+		 int i, j, prev_scan, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0;
+		 int is_page = (key & ~STB_TEXTEDIT_K_SHIFT) == STB_TEXTEDIT_K_PGUP;
+		 int row_count = is_page ? state->row_count_per_page : 1;
+
+		 if (!is_page && state->single_line) {
+			// on windows, up&down become left&right
+			key = STB_TEXTEDIT_K_LEFT | (key & STB_TEXTEDIT_K_SHIFT);
+			goto retry;
+		 }
+
+		 if (sel)
+			stb_textedit_prep_selection_at_cursor(state);
+		 else if (STB_TEXT_HAS_SELECTION(state))
+			stb_textedit_move_to_first(state);
+
+		 // compute current position of cursor point
+		 stb_textedit_clamp(str, state);
+		 stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+
+		 for (j = 0; j < row_count; ++j) {
+			float  x, goal_x = state->has_preferred_x ? state->preferred_x : find.x;
+
+			// can only go up if there's a previous row
+			if (find.prev_first == find.first_char)
+			   break;
+
+			// now find character position up a row
+			state->cursor = find.prev_first;
+			STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
+			x = row.x0;
+			for (i=0; i < row.num_chars; ++i) {
+			   float dx = STB_TEXTEDIT_GETWIDTH(str, find.prev_first, i);
+#ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE
+			   if (dx == STB_TEXTEDIT_GETWIDTH_NEWLINE)
+				  break;
+#endif
+			   x += dx;
+			   if (x > goal_x)
+				  break;
+			   ++state->cursor;
+			}
+			stb_textedit_clamp(str, state);
+
+			state->has_preferred_x = 1;
+			state->preferred_x = goal_x;
+
+			if (sel)
+			   state->select_end = state->cursor;
+
+			// go to previous line
+			// (we need to scan previous line the hard way. maybe we could expose this as a new API function?)
+			prev_scan = find.prev_first > 0 ? find.prev_first - 1 : 0;
+			while (prev_scan > 0 && STB_TEXTEDIT_GETCHAR(str, prev_scan - 1) != STB_TEXTEDIT_NEWLINE)
+			   --prev_scan;
+			find.first_char = find.prev_first;
+			find.prev_first = prev_scan;
+		 }
+		 break;
+	  }
+
+	  case STB_TEXTEDIT_K_DELETE:
+	  case STB_TEXTEDIT_K_DELETE | STB_TEXTEDIT_K_SHIFT:
+		 if (STB_TEXT_HAS_SELECTION(state))
+			stb_textedit_delete_selection(str, state);
+		 else {
+			int n = STB_TEXTEDIT_STRINGLEN(str);
+			if (state->cursor < n)
+			   stb_textedit_delete(str, state, state->cursor, 1);
+		 }
+		 state->has_preferred_x = 0;
+		 break;
+
+	  case STB_TEXTEDIT_K_BACKSPACE:
+	  case STB_TEXTEDIT_K_BACKSPACE | STB_TEXTEDIT_K_SHIFT:
+		 if (STB_TEXT_HAS_SELECTION(state))
+			stb_textedit_delete_selection(str, state);
+		 else {
+			stb_textedit_clamp(str, state);
+			if (state->cursor > 0) {
+			   stb_textedit_delete(str, state, state->cursor-1, 1);
+			   --state->cursor;
+			}
+		 }
+		 state->has_preferred_x = 0;
+		 break;
+
+#ifdef STB_TEXTEDIT_K_TEXTSTART2
+	  case STB_TEXTEDIT_K_TEXTSTART2:
+#endif
+	  case STB_TEXTEDIT_K_TEXTSTART:
+		 state->cursor = state->select_start = state->select_end = 0;
+		 state->has_preferred_x = 0;
+		 break;
+
+#ifdef STB_TEXTEDIT_K_TEXTEND2
+	  case STB_TEXTEDIT_K_TEXTEND2:
+#endif
+	  case STB_TEXTEDIT_K_TEXTEND:
+		 state->cursor = STB_TEXTEDIT_STRINGLEN(str);
+		 state->select_start = state->select_end = 0;
+		 state->has_preferred_x = 0;
+		 break;
+
+#ifdef STB_TEXTEDIT_K_TEXTSTART2
+	  case STB_TEXTEDIT_K_TEXTSTART2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+	  case STB_TEXTEDIT_K_TEXTSTART | STB_TEXTEDIT_K_SHIFT:
+		 stb_textedit_prep_selection_at_cursor(state);
+		 state->cursor = state->select_end = 0;
+		 state->has_preferred_x = 0;
+		 break;
+
+#ifdef STB_TEXTEDIT_K_TEXTEND2
+	  case STB_TEXTEDIT_K_TEXTEND2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+	  case STB_TEXTEDIT_K_TEXTEND | STB_TEXTEDIT_K_SHIFT:
+		 stb_textedit_prep_selection_at_cursor(state);
+		 state->cursor = state->select_end = STB_TEXTEDIT_STRINGLEN(str);
+		 state->has_preferred_x = 0;
+		 break;
+
+
+#ifdef STB_TEXTEDIT_K_LINESTART2
+	  case STB_TEXTEDIT_K_LINESTART2:
+#endif
+	  case STB_TEXTEDIT_K_LINESTART:
+		 stb_textedit_clamp(str, state);
+		 stb_textedit_move_to_first(state);
+		 if (state->single_line)
+			state->cursor = 0;
+		 else while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) != STB_TEXTEDIT_NEWLINE)
+			--state->cursor;
+		 state->has_preferred_x = 0;
+		 break;
+
+#ifdef STB_TEXTEDIT_K_LINEEND2
+	  case STB_TEXTEDIT_K_LINEEND2:
+#endif
+	  case STB_TEXTEDIT_K_LINEEND: {
+		 int n = STB_TEXTEDIT_STRINGLEN(str);
+		 stb_textedit_clamp(str, state);
+		 stb_textedit_move_to_first(state);
+		 if (state->single_line)
+			 state->cursor = n;
+		 else while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE)
+			 ++state->cursor;
+		 state->has_preferred_x = 0;
+		 break;
+	  }
+
+#ifdef STB_TEXTEDIT_K_LINESTART2
+	  case STB_TEXTEDIT_K_LINESTART2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+	  case STB_TEXTEDIT_K_LINESTART | STB_TEXTEDIT_K_SHIFT:
+		 stb_textedit_clamp(str, state);
+		 stb_textedit_prep_selection_at_cursor(state);
+		 if (state->single_line)
+			state->cursor = 0;
+		 else while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) != STB_TEXTEDIT_NEWLINE)
+			--state->cursor;
+		 state->select_end = state->cursor;
+		 state->has_preferred_x = 0;
+		 break;
+
+#ifdef STB_TEXTEDIT_K_LINEEND2
+	  case STB_TEXTEDIT_K_LINEEND2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+	  case STB_TEXTEDIT_K_LINEEND | STB_TEXTEDIT_K_SHIFT: {
+		 int n = STB_TEXTEDIT_STRINGLEN(str);
+		 stb_textedit_clamp(str, state);
+		 stb_textedit_prep_selection_at_cursor(state);
+		 if (state->single_line)
+			 state->cursor = n;
+		 else while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE)
+			++state->cursor;
+		 state->select_end = state->cursor;
+		 state->has_preferred_x = 0;
+		 break;
+	  }
+   }
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Undo processing
+//
+// @OPTIMIZE: the undo/redo buffer should be circular
+
+static void stb_textedit_flush_redo(StbUndoState *state)
+{
+   state->redo_point = STB_TEXTEDIT_UNDOSTATECOUNT;
+   state->redo_char_point = STB_TEXTEDIT_UNDOCHARCOUNT;
+}
+
+// discard the oldest entry in the undo list
+static void stb_textedit_discard_undo(StbUndoState *state)
+{
+   if (state->undo_point > 0) {
+	  // if the 0th undo state has characters, clean those up
+	  if (state->undo_rec[0].char_storage >= 0) {
+		 int n = state->undo_rec[0].insert_length, i;
+		 // delete n characters from all other records
+		 state->undo_char_point -= n;
+		 STB_TEXTEDIT_memmove(state->undo_char, state->undo_char + n, (size_t) (state->undo_char_point*sizeof(STB_TEXTEDIT_CHARTYPE)));
+		 for (i=0; i < state->undo_point; ++i)
+			if (state->undo_rec[i].char_storage >= 0)
+			   state->undo_rec[i].char_storage -= n; // @OPTIMIZE: get rid of char_storage and infer it
+	  }
+	  --state->undo_point;
+	  STB_TEXTEDIT_memmove(state->undo_rec, state->undo_rec+1, (size_t) (state->undo_point*sizeof(state->undo_rec[0])));
+   }
+}
+
+// discard the oldest entry in the redo list--it's bad if this
+// ever happens, but because undo & redo have to store the actual
+// characters in different cases, the redo character buffer can
+// fill up even though the undo buffer didn't
+static void stb_textedit_discard_redo(StbUndoState *state)
+{
+   int k = STB_TEXTEDIT_UNDOSTATECOUNT-1;
+
+   if (state->redo_point <= k) {
+	  // if the k'th undo state has characters, clean those up
+	  if (state->undo_rec[k].char_storage >= 0) {
+		 int n = state->undo_rec[k].insert_length, i;
+		 // move the remaining redo character data to the end of the buffer
+		 state->redo_char_point += n;
+		 STB_TEXTEDIT_memmove(state->undo_char + state->redo_char_point, state->undo_char + state->redo_char_point-n, (size_t) ((STB_TEXTEDIT_UNDOCHARCOUNT - state->redo_char_point)*sizeof(STB_TEXTEDIT_CHARTYPE)));
+		 // adjust the position of all the other records to account for above memmove
+		 for (i=state->redo_point; i < k; ++i)
+			if (state->undo_rec[i].char_storage >= 0)
+			   state->undo_rec[i].char_storage += n;
+	  }
+	  // now move all the redo records towards the end of the buffer; the first one is at 'redo_point'
+	  STB_TEXTEDIT_memmove(state->undo_rec + state->redo_point+1, state->undo_rec + state->redo_point, (size_t) ((STB_TEXTEDIT_UNDOSTATECOUNT - state->redo_point)*sizeof(state->undo_rec[0])));
+	  // now move redo_point to point to the new one
+	  ++state->redo_point;
+   }
+}
+
+static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, int numchars)
+{
+   // any time we create a new undo record, we discard redo
+   stb_textedit_flush_redo(state);
+
+   // if we have no free records, we have to make room, by sliding the
+   // existing records down
+   if (state->undo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+	  stb_textedit_discard_undo(state);
+
+   // if the characters to store won't possibly fit in the buffer, we can't undo
+   if (numchars > STB_TEXTEDIT_UNDOCHARCOUNT) {
+	  state->undo_point = 0;
+	  state->undo_char_point = 0;
+	  return NULL;
+   }
+
+   // if we don't have enough free characters in the buffer, we have to make room
+   while (state->undo_char_point + numchars > STB_TEXTEDIT_UNDOCHARCOUNT)
+	  stb_textedit_discard_undo(state);
+
+   return &state->undo_rec[state->undo_point++];
+}
+
+static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)
+{
+   StbUndoRecord *r = stb_text_create_undo_record(state, insert_len);
+   if (r == NULL)
+	  return NULL;
+
+   r->where = pos;
+   r->insert_length = (STB_TEXTEDIT_POSITIONTYPE) insert_len;
+   r->delete_length = (STB_TEXTEDIT_POSITIONTYPE) delete_len;
+
+   if (insert_len == 0) {
+	  r->char_storage = -1;
+	  return NULL;
+   } else {
+	  r->char_storage = state->undo_char_point;
+	  state->undo_char_point += insert_len;
+	  return &state->undo_char[r->char_storage];
+   }
+}
+
+static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   StbUndoState *s = &state->undostate;
+   StbUndoRecord u, *r;
+   if (s->undo_point == 0)
+	  return;
+
+   // we need to do two things: apply the undo record, and create a redo record
+   u = s->undo_rec[s->undo_point-1];
+   r = &s->undo_rec[s->redo_point-1];
+   r->char_storage = -1;
+
+   r->insert_length = u.delete_length;
+   r->delete_length = u.insert_length;
+   r->where = u.where;
+
+   if (u.delete_length) {
+	  // if the undo record says to delete characters, then the redo record will
+	  // need to re-insert the characters that get deleted, so we need to store
+	  // them.
+
+	  // there are three cases:
+	  //    there's enough room to store the characters
+	  //    characters stored for *redoing* don't leave room for redo
+	  //    characters stored for *undoing* don't leave room for redo
+	  // if the last is true, we have to bail
+
+	  if (s->undo_char_point + u.delete_length >= STB_TEXTEDIT_UNDOCHARCOUNT) {
+		 // the undo records take up too much character space; there's no space to store the redo characters
+		 r->insert_length = 0;
+	  } else {
+		 int i;
+
+		 // there's definitely room to store the characters eventually
+		 while (s->undo_char_point + u.delete_length > s->redo_char_point) {
+			// should never happen:
+			if (s->redo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+			   return;
+			// there's currently not enough room, so discard a redo record
+			stb_textedit_discard_redo(s);
+		 }
+		 r = &s->undo_rec[s->redo_point-1];
+
+		 r->char_storage = s->redo_char_point - u.delete_length;
+		 s->redo_char_point = s->redo_char_point - u.delete_length;
+
+		 // now save the characters
+		 for (i=0; i < u.delete_length; ++i)
+			s->undo_char[r->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u.where + i);
+	  }
+
+	  // now we can carry out the deletion
+	  STB_TEXTEDIT_DELETECHARS(str, u.where, u.delete_length);
+   }
+
+   // check type of recorded action:
+   if (u.insert_length) {
+	  // easy case: was a deletion, so we need to insert n characters
+	  STB_TEXTEDIT_INSERTCHARS(str, u.where, &s->undo_char[u.char_storage], u.insert_length);
+	  s->undo_char_point -= u.insert_length;
+   }
+
+   state->cursor = u.where + u.insert_length;
+
+   s->undo_point--;
+   s->redo_point--;
+}
+
+static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   StbUndoState *s = &state->undostate;
+   StbUndoRecord *u, r;
+   if (s->redo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+	  return;
+
+   // we need to do two things: apply the redo record, and create an undo record
+   u = &s->undo_rec[s->undo_point];
+   r = s->undo_rec[s->redo_point];
+
+   // we KNOW there must be room for the undo record, because the redo record
+   // was derived from an undo record
+
+   u->delete_length = r.insert_length;
+   u->insert_length = r.delete_length;
+   u->where = r.where;
+   u->char_storage = -1;
+
+   if (r.delete_length) {
+	  // the redo record requires us to delete characters, so the undo record
+	  // needs to store the characters
+
+	  if (s->undo_char_point + u->insert_length > s->redo_char_point) {
+		 u->insert_length = 0;
+		 u->delete_length = 0;
+	  } else {
+		 int i;
+		 u->char_storage = s->undo_char_point;
+		 s->undo_char_point = s->undo_char_point + u->insert_length;
+
+		 // now save the characters
+		 for (i=0; i < u->insert_length; ++i)
+			s->undo_char[u->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u->where + i);
+	  }
+
+	  STB_TEXTEDIT_DELETECHARS(str, r.where, r.delete_length);
+   }
+
+   if (r.insert_length) {
+	  // easy case: need to insert n characters
+	  STB_TEXTEDIT_INSERTCHARS(str, r.where, &s->undo_char[r.char_storage], r.insert_length);
+	  s->redo_char_point += r.insert_length;
+   }
+
+   state->cursor = r.where + r.insert_length;
+
+   s->undo_point++;
+   s->redo_point++;
+}
+
+static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length)
+{
+   stb_text_createundo(&state->undostate, where, 0, length);
+}
+
+static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length)
+{
+   int i;
+   STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, length, 0);
+   if (p) {
+	  for (i=0; i < length; ++i)
+		 p[i] = STB_TEXTEDIT_GETCHAR(str, where+i);
+   }
+}
+
+static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length)
+{
+   int i;
+   STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, old_length, new_length);
+   if (p) {
+	  for (i=0; i < old_length; ++i)
+		 p[i] = STB_TEXTEDIT_GETCHAR(str, where+i);
+   }
+}
+
+// reset the state to default
+static void stb_textedit_clear_state(STB_TexteditState *state, int is_single_line)
+{
+   state->undostate.undo_point = 0;
+   state->undostate.undo_char_point = 0;
+   state->undostate.redo_point = STB_TEXTEDIT_UNDOSTATECOUNT;
+   state->undostate.redo_char_point = STB_TEXTEDIT_UNDOCHARCOUNT;
+   state->select_end = state->select_start = 0;
+   state->cursor = 0;
+   state->has_preferred_x = 0;
+   state->preferred_x = 0;
+   state->cursor_at_end_of_line = 0;
+   state->initialized = 1;
+   state->single_line = (unsigned char) is_single_line;
+   state->insert_mode = 0;
+   state->row_count_per_page = 0;
+}
+
+// API initialize
+static void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)
+{
+   stb_textedit_clear_state(state, is_single_line);
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#endif
+
+static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)
+{
+   return stb_textedit_paste_internal(str, state, (STB_TEXTEDIT_CHARTYPE *) ctext, len);
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+#endif//STB_TEXTEDIT_IMPLEMENTATION
+
+/*
+------------------------------------------------------------------------------
+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.
+------------------------------------------------------------------------------
+*/