From 0963c011d211b6e4debb2264b36255544fb20bba Mon Sep 17 00:00:00 2001 From: Terri00 Date: Mon, 25 Feb 2019 11:54:17 +0000 Subject: [PATCH] Console Update --- MCDV/Camera.hpp | 10 +- MCDV/Console.hpp | 146 +++ MCDV/FrameBuffer.hpp | 77 ++ MCDV/GLFWUtil.hpp | 15 + MCDV/MCDV.vcxproj | 9 + MCDV/MCDV.vcxproj.filters | 26 + MCDV/TextFont.hpp | 246 +++++ MCDV/Texture.hpp | 1 + MCDV/dina-r-background.png | Bin 0 -> 26334 bytes MCDV/dina-r.png | Bin 0 -> 15993 bytes MCDV/fonts/dina-r-background.png | Bin 0 -> 26334 bytes MCDV/fonts/dina-r.png | Bin 0 -> 15993 bytes MCDV/main.cpp | 326 ++++-- MCDV/render.png | Bin 0 -> 63366 bytes MCDV/shaders/textfont.fs | 14 + MCDV/shaders/textfont.vs | 11 + MCDV/stb_image_write.h | 1642 ++++++++++++++++++++++++++++++ MCDV/test.png | Bin 0 -> 31792 bytes MCDV/textfont.fs | 14 + MCDV/textfont.vs | 11 + MCDV/util.h | 16 + 21 files changed, 2466 insertions(+), 98 deletions(-) create mode 100644 MCDV/Console.hpp create mode 100644 MCDV/FrameBuffer.hpp create mode 100644 MCDV/TextFont.hpp create mode 100644 MCDV/dina-r-background.png create mode 100644 MCDV/dina-r.png create mode 100644 MCDV/fonts/dina-r-background.png create mode 100644 MCDV/fonts/dina-r.png create mode 100644 MCDV/render.png create mode 100644 MCDV/shaders/textfont.fs create mode 100644 MCDV/shaders/textfont.vs create mode 100644 MCDV/stb_image_write.h create mode 100644 MCDV/test.png create mode 100644 MCDV/textfont.fs create mode 100644 MCDV/textfont.vs diff --git a/MCDV/Camera.hpp b/MCDV/Camera.hpp index 340f4f7..eb98205 100644 --- a/MCDV/Camera.hpp +++ b/MCDV/Camera.hpp @@ -116,21 +116,21 @@ void Camera::handleInput(float deltaTime) if (!isNoclip) travelDir = this->travelFront; - if (keyHandler->getKeyDown(GLFW_KEY_LEFT_SHIFT)) + if (keyHandler->getKey(GLFW_KEY_LEFT_SHIFT)) this->speed = 20.0f; else this->speed = 2.5f; - if (keyHandler->getKeyDown(GLFW_KEY_W)) + if (keyHandler->getKey(GLFW_KEY_W)) cameraPos += speed * travelDir * deltaTime; - if (keyHandler->getKeyDown(GLFW_KEY_S)) + if (keyHandler->getKey(GLFW_KEY_S)) cameraPos -= speed * travelDir * deltaTime; - if (keyHandler->getKeyDown(GLFW_KEY_A)) + if (keyHandler->getKey(GLFW_KEY_A)) cameraPos -= glm::normalize(glm::cross(travelDir, cameraUp)) * speed * deltaTime; - if (keyHandler->getKeyDown(GLFW_KEY_D)) + if (keyHandler->getKey(GLFW_KEY_D)) cameraPos += glm::normalize(glm::cross(travelDir, cameraUp)) * speed * deltaTime; } diff --git a/MCDV/Console.hpp b/MCDV/Console.hpp new file mode 100644 index 0000000..12becfe --- /dev/null +++ b/MCDV/Console.hpp @@ -0,0 +1,146 @@ +#include "GLFWUtil.hpp" +#include +#include +#include + +#include "util.h" + +#include "TextFont.hpp" + +enum MSG_STATUS { + INFO = 0, + SUCCESS, + ERR +}; + +std::map MSG_STATUS_COLOR { + { MSG_STATUS::INFO, glm::vec3(0.75f, 0.75f, 0.75f) }, + { MSG_STATUS::SUCCESS, glm::vec3(0.2f, 1.0f, 0.2f) }, + { MSG_STATUS::ERR, glm::vec3(1.0f, 0.2f, 0.2f) } +}; + +class Console{ +private: + std::map cVarBook = {}; + std::map cCmdBook = {}; + std::string current_input_buffer = ""; + + TextFont* ui_input_buffer; + TextFont* ui_last_result; + + util_keyHandler* keyHandler; +public: + bool isEnabled = false; + + Console(util_keyHandler* keyhandler, int* window_width, int* window_height) { //Todo; set private references to width/height + this->keyHandler = keyhandler; + + //Setup + this->ui_input_buffer = new TextFont(">> "); + this->ui_input_buffer->size = glm::vec2(1.0f / *window_width, 1.0f / *window_height) * 2.0f; + this->ui_input_buffer->alpha = 1.0f; + this->ui_input_buffer->color = glm::vec3(1.0f, 1.0f, 1.0f); + this->ui_input_buffer->screenPosition = glm::vec2(0, (1.0f / *window_height) * 30.0f); + + //Console reply + this->ui_last_result = new TextFont("..."); + this->ui_last_result->size = glm::vec2(1.0f / *window_width, 1.0f / *window_height) * 2.0f; + this->ui_last_result->alpha = 1.0f; + this->ui_last_result->color = glm::vec3(0.75f, 0.75f, 0.75f); + this->ui_last_result->screenPosition = glm::vec2(0, (1.0f / *window_height) * 15.0f); + } + + Console() { + + } + + void RegisterCVar(std::string name, int* variableAddr) { + this->cVarBook.insert({ name, variableAddr }); + + std::cout << "Registered CVAR: " << name << " at address: 0x" <cCmdBook.insert({ name, addr }); + std::cout << "Registered CCMD: " << name << " at address: 0x" << std::hex << addr << std::endl; + } + + void CallCmd(std::string name) { + ((void(*)(void)) this->cCmdBook[name])(); //Call assigned CMD->function + } + + void FeedBack(std::string s, MSG_STATUS status = MSG_STATUS::INFO) { + std::cout << "Con :: " << s << std::endl; + this->ui_last_result->color = MSG_STATUS_COLOR[status]; // Assign correct color to output text + this->ui_last_result->SetText(s); + } + + void parseRead() { + std::vector parts = split(this->current_input_buffer); + + if (parts.size() > 0) { + if (this->cVarBook.count(parts[0]) > 0) { + //Fond in CVARs + + if (parts.size() > 1) { //edit cvar + *this->cVarBook[parts[0]] = std::stoi(parts[1]); + this->FeedBack("Var set: " + std::string(parts[0])); + } + else { + this->FeedBack((std::string(parts[0]) + " = " + std::to_string(*this->cVarBook[parts[0]]))); + } + } + + else if (this->cCmdBook.count(parts[0]) > 0) { + this->CallCmd(parts[0]); + if(parts[0] != "HELP") + this->FeedBack(std::string("Called: *") + parts[0] + std::string( " @ 0x") + to_string((unsigned int)this->cCmdBook[parts[0]], std::hex)); + } + + else { + this->FeedBack("No registered command registered for '" + parts[0] + "'", MSG_STATUS::ERR); + } + } + } + + void handleKeysTick() { + if (!this->isEnabled) return; + + bool modified = false; + for (int i = 44; i < 94; i++) { //Check every key starting from space + if (this->keyHandler->getKeyDown(i)) { + this->current_input_buffer += (char)i; + modified = true; + } + } + + //And space bar... + if (this->keyHandler->getKeyDown(32)) { + this->current_input_buffer += (char)32; + modified = true; + } + + if (this->keyHandler->getKeyDown(GLFW_KEY_BACKSPACE)) { + if (this->current_input_buffer.size() > 0) { + this->current_input_buffer.pop_back(); + modified = true; + } + } + + if (this->keyHandler->getKeyDown(GLFW_KEY_ENTER)) { + this->parseRead(); + this->current_input_buffer = ""; + modified = true; + } + + if (modified) { + this->ui_input_buffer->SetText(">> " + this->current_input_buffer); + } + } + + void draw() { + if (!this->isEnabled) return; + this->ui_last_result->DrawWithBackground(); + this->ui_input_buffer->DrawWithBackground(); + } +}; \ No newline at end of file diff --git a/MCDV/FrameBuffer.hpp b/MCDV/FrameBuffer.hpp new file mode 100644 index 0000000..555685b --- /dev/null +++ b/MCDV/FrameBuffer.hpp @@ -0,0 +1,77 @@ +#pragma once +#include +#include +#include +#include +#include +#include + +#include "GLFWUtil.hpp" + +#define STBI_MSC_SECURE_CRT +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include "stb_image_write.h" + + +class FrameBuffer { +public: + unsigned int fbo; + unsigned int rbo; + unsigned int texture; + + FrameBuffer(bool depthtest = true) { + glGenFramebuffers(1, &this->fbo); //Generate frame buffer + glBindFramebuffer(GL_FRAMEBUFFER, this->fbo); + + if (glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) { + + glGenTextures(1, &this->texture); + glBindTexture(GL_TEXTURE_2D, this->texture); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1024, 1024, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glBindTexture(GL_TEXTURE_2D, 0); + + //attach + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, this->texture, 0); + + if (depthtest) + { + glGenRenderbuffers(1, &this->rbo); + glBindRenderbuffer(GL_RENDERBUFFER, this->rbo); + glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 1024, 1024); + glBindRenderbuffer(GL_RENDERBUFFER, 0); + + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, this->rbo); + } + + if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) + std::cout << "Framebuffer failed to generate" << std::endl; + } + + FrameBuffer::Unbind(); + } + + void Bind() { + glBindFramebuffer(GL_FRAMEBUFFER, this->fbo); + } + + void Save() { + void* data = malloc(3 * 1024 * 1024); + glReadPixels(0, 0, 1024, 1024, GL_RGB, GL_UNSIGNED_BYTE, data); + + if (data != 0) + stbi_write_png("test.png", 1024, 1024, 3, data, 1024 * 3); + else + std::cout << "Something went wrong making render" << std::endl; + } + + static void Unbind() { + glBindFramebuffer(GL_FRAMEBUFFER, 0); //Revert to default framebuffer + } + + ~FrameBuffer() { + glDeleteFramebuffers(1, &this->fbo); + } +}; \ No newline at end of file diff --git a/MCDV/GLFWUtil.hpp b/MCDV/GLFWUtil.hpp index 65b83c6..5e4c10c 100644 --- a/MCDV/GLFWUtil.hpp +++ b/MCDV/GLFWUtil.hpp @@ -4,8 +4,23 @@ class util_keyHandler { private: GLFWwindow* windowHandle; + int* states_previous_frame = new int[GLFW_KEY_LAST]; // About a kb + public: + bool getKeyDown(int key) { + + if ((states_previous_frame[key] != GLFW_PRESS) && (glfwGetKey(this->windowHandle, key) == GLFW_PRESS)) { + states_previous_frame[key] = glfwGetKey(this->windowHandle, key); + return true; + } + + states_previous_frame[key] = glfwGetKey(this->windowHandle, key); + + return false; + } + + bool getKey(int key) { if (glfwGetKey(this->windowHandle, key) == GLFW_PRESS) return true; diff --git a/MCDV/MCDV.vcxproj b/MCDV/MCDV.vcxproj index a846f0b..d9fb208 100644 --- a/MCDV/MCDV.vcxproj +++ b/MCDV/MCDV.vcxproj @@ -124,6 +124,8 @@ + + @@ -135,7 +137,9 @@ + + @@ -154,9 +158,14 @@ + + + + + diff --git a/MCDV/MCDV.vcxproj.filters b/MCDV/MCDV.vcxproj.filters index fee4f54..0b8ef5a 100644 --- a/MCDV/MCDV.vcxproj.filters +++ b/MCDV/MCDV.vcxproj.filters @@ -30,6 +30,9 @@ {ba697338-0a0c-4917-a742-5e182f96f7be} + + {1d19365b-710e-41b8-862f-283759638b5c} + @@ -92,6 +95,18 @@ Header Files\valve + + OpenGL\engine + + + OpenGL\engine + + + OpenGL\engine + + + OpenGL\stb + @@ -123,5 +138,16 @@ OpenGL\Shader Files + + OpenGL\Shader Files + + + OpenGL\Shader Files + + + + + Font Files + \ No newline at end of file diff --git a/MCDV/TextFont.hpp b/MCDV/TextFont.hpp new file mode 100644 index 0000000..dc79dba --- /dev/null +++ b/MCDV/TextFont.hpp @@ -0,0 +1,246 @@ +#pragma once +#include +#include +#include +#include +#include +#include + +#include "GLFWUtil.hpp" + +#include +#include +#include + +#include "Shader.hpp" +//#define STB_IMAGE_IMPLEMENTATION +//#include "stb_image.h" + +//Class for rendering fonts +class TextFont +{ +private: + static Shader* shader; //Font shader + static unsigned int textureID; //Font image + static unsigned int textureBackgroundID; //Font background image + + std::string text; + + unsigned int VAO; + unsigned int VBO; + int elementCount; + +public: + static void init() { //Setup shader and texture loading etc. + std::cout << "Initializing fonts" << std::endl; + + + //Load shader + TextFont::shader = new Shader("shaders/textfont.vs", "shaders/textfont.fs"); + + //Load font texture + glGenTextures(1, &TextFont::textureID); + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); //1 byte per pixel + + //Load texture using stb_image + int width, height, nrChannels; + unsigned char* data = stbi_load("fonts/dina-r.png", &width, &height, &nrChannels, 1); + if (data){ + glBindTexture(GL_TEXTURE_2D, TextFont::textureID); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, width, height, 0, GL_RED, GL_UNSIGNED_BYTE, data); + //glGenerateMipmap(GL_TEXTURE_2D); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + + stbi_image_free(data); + } + else{ + std::cout << "ERROR::FONT::LOAD_FAILED" << std::endl; + } + + glGenTextures(1, &TextFont::textureBackgroundID); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); //1 byte per pixel + + unsigned char* data_background = stbi_load("fonts/dina-r-background.png", &width, &height, &nrChannels, 1); + if (data) { + glBindTexture(GL_TEXTURE_2D, TextFont::textureBackgroundID); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, width, height, 0, GL_RED, GL_UNSIGNED_BYTE, data); + //glGenerateMipmap(GL_TEXTURE_2D); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + + stbi_image_free(data); + } + else { + std::cout << "ERROR::FONT::LOAD_FAILED" << std::endl; + } + } + + glm::vec2 screenPosition; + glm::vec3 color; + float alpha; + glm::vec2 size; + + void SetText(std::string text, glm::vec2 screenPos, glm::vec2 size) { + this->text = text; + this->screenPosition = screenPos; + this->size = size; + + //Do generation + + //Clear old mesh + if (this->VAO != NULL) { + glDeleteVertexArrays(1, &this->VAO); + glDeleteBuffers(1, &this->VBO); + } + + std::vector verts; + + float current_x = 0; + float current_y = 0; + + //Create vertex arrays + float charwidth = 1.0f / 94.0f; + + for (int i = 0; i < text.length(); i++) { + char c = text[i]; + + float toffset = (float)(c - 0x21) * charwidth; + + if (!(c < 0x21 || c > 0x7E)) { //Check if out of bounds + std::vector character = { + + current_x, current_y, toffset, 1.0f, + current_x + 7.0f, current_y + 12.0f, toffset + charwidth, 0.0f, + current_x, current_y + 12.0f, toffset, 0.0f, + + current_x, current_y, toffset, 1.0f, + current_x + 7.0f, current_y, toffset + charwidth, 1.0f, + current_x + 7.0f, current_y + 12.0f, toffset + charwidth, 0.0f + + }; + + //Append character vert data + verts.insert(verts.end(), character.begin(), character.end()); + } + + if (c == 0x0A) { + current_x = 0.0f; + current_y -= 15.0f; + } + else current_x += 7; //Font character width + } + + this->elementCount = verts.size() / 4; //XYUV + + glGenVertexArrays(1, &this->VAO); + glGenBuffers(1, &this->VBO); + + glBindBuffer(GL_ARRAY_BUFFER, this->VBO); + glBufferData(GL_ARRAY_BUFFER, verts.size() * sizeof(float), &verts[0], GL_STATIC_DRAW); + + glBindVertexArray(this->VAO); + + //position attribute + glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + } + + void SetText(std::string s) { + this->SetText(s, this->screenPosition, this->size); + } + + void Draw() { + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + glDisable(GL_CULL_FACE); + + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glBlendEquation(GL_FUNC_ADD); + + //glDepthMask(0); + + glm::mat4 model = glm::mat4(); + model = glm::translate(model, glm::vec3((screenPosition.x - 0.5f) * 2.0f, -(screenPosition.y - 0.5f)*2.0f, 0)); + model = glm::scale(model, glm::vec3(this->size.x, this->size.y, 0.0f)); + + this->shader->use(); + this->shader->setVec3("color", this->color); + this->shader->setFloat("alpha", this->alpha); + this->shader->setMatrix("model", model); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, TextFont::textureID); //bind texture + this->shader->setInt("text", 0); + + glBindVertexArray(this->VAO); + glDrawArrays(GL_TRIANGLES, 0, this->elementCount); + } + + void DrawWithBackground() { + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + glDisable(GL_CULL_FACE); + + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glBlendEquation(GL_FUNC_ADD); + + //glDepthMask(0); + glDisable(GL_DEPTH_TEST); + + glm::mat4 model = glm::mat4(); + model = glm::translate(model, glm::vec3((screenPosition.x - 0.5f) * 2.0f, -(screenPosition.y - 0.5f)*2.0f, 0)); + model = glm::scale(model, glm::vec3(this->size.x, this->size.y, 0.0f)); + + //bind textures + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, TextFont::textureBackgroundID); + + this->shader->use(); + + this->shader->setVec3("color", glm::vec3(0, 0, 0)); + this->shader->setFloat("alpha", this->alpha); + this->shader->setMatrix("model", model); + + this->shader->setInt("text", 0); + + glBindVertexArray(this->VAO); + glDrawArrays(GL_TRIANGLES, 0, this->elementCount); + + //Draw foreground + this->shader->setVec3("color", this->color); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, TextFont::textureID); + + glBindVertexArray(this->VAO); + glDrawArrays(GL_TRIANGLES, 0, this->elementCount); + } + + std::string GetText() { + return this->text; + } + + TextFont(std::string text) { + this->SetText(text, glm::vec2(0, 0), glm::vec2(1.0f, 1.0f)); + } + + ~TextFont() { + //Clear old mesh + if (this->VAO != NULL) { + glDeleteVertexArrays(1, &this->VAO); + glDeleteBuffers(1, &this->VBO); + } + } +}; + +unsigned int TextFont::textureID; +unsigned int TextFont::textureBackgroundID; +Shader* TextFont::shader; \ No newline at end of file diff --git a/MCDV/Texture.hpp b/MCDV/Texture.hpp index 2ae4155..c237ca6 100644 --- a/MCDV/Texture.hpp +++ b/MCDV/Texture.hpp @@ -9,6 +9,7 @@ #define STB_IMAGE_IMPLEMENTATION #include "stb_image.h" + class Texture { public: diff --git a/MCDV/dina-r-background.png b/MCDV/dina-r-background.png new file mode 100644 index 0000000000000000000000000000000000000000..ba56ade5b049ce893879101cabfdc09ce763c0de GIT binary patch literal 26334 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 literal 0 HcmV?d00001 diff --git a/MCDV/dina-r.png b/MCDV/dina-r.png new file mode 100644 index 0000000000000000000000000000000000000000..3efffa6858fc0a8916c6d22aaef4de0e2d95bcc2 GIT binary patch literal 15993 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 literal 0 HcmV?d00001 diff --git a/MCDV/fonts/dina-r.png b/MCDV/fonts/dina-r.png new file mode 100644 index 0000000000000000000000000000000000000000..3efffa6858fc0a8916c6d22aaef4de0e2d95bcc2 GIT binary patch literal 15993 zcmeI3dsGuw9>+(Did4@o+Eu8pG|H;gFnK@55K*E+HCBa|h>Oc)G6^Fglg)z!6cxd` zY7y5J1RqcZk551awZ64Q>+9&M_`+S^VnL{`;*(Z(k^q4VOg(42f9yFk=Omfm{oU{H zckk!^?#=u&OQuel*vt20UkHMFg@-ApLy*@>>b|E>H|qQ1oS3=PPY+Yr3=0H(*vI+l z0#2utLjuN+EX2N78NF&P`7uAq9YcQMbOw@8U%`3swlE`RjVnu?CBIMPa5;>b?s-QwKI3JU)jj zi{wfWz8DdRqFd?RodCItDtj$zMSmqgn{HqTQcLKPel38fQ(L)8g@hX|R@8{$;YtNH z*&u?@A`(8Ai*q#+j#Q!(b7Vpx&XJ*92?rHoLXm(kLs72OHMO?#cA=FdW^+~!723Vi zwIoJ`Z>a|a#kCq4ACqu&8mWN8cs^RK5TCR>O(g}qUF(zzI)GAoJM4y`p>L5Z5 zt@=3UqNS2a1*kwLM5P>!h>vq{Y6={bClYaRtw6xj;nZ{_lI9d0glU&5jIdDUlhmrL zsN!-RH4*q<+O{@3420{*Frj7(?%avN?B=c5a>leAAx@2JMxLeHaEQAqPdr{?S5+BqwV*fT#F$( z(wu-=6+{B6$6=FEFNZyio}6;e$rDN%NVAI6;tGKr?x?wy%K0CJP-g>Gtf*^G^5k&4 zHn6|ixyKDQSAXa7bGb0j`Q0RK?FOYY=%uaQpwy%M!bn&Z{HAO`b1Rkej}mdgh@hV7 zaD`YT5{Tq5*bFMB5)Ry;Rua_dZgHMcViEO+;1YqJ4wW-JN**;vkFb@aN$9SHR*zq< z{q1h09`2~;O1S00vfb8iIUIk>8_$e>%cwvsCJ6w9-ehpm^8vgJE&vF<$>5^r19%x+ z01$eU!9~vp@G`gnAoM1Ki=GeQWpDvN=uHL}Js-f!-~xcqn+z^`K7g0O1puKp8C>*y z055|J077pvxaj!+UIrHcgx+Lu(enYk3@!i&y~*IB=L2{dTmTSylfgyL2k?d;l+l3jjiIGPvmZ0A2NKE?g6-#=azJ#$;~+(rIRc|HI5$`>s`%J9RcI;_?soMqPTI_`5U1UmF8@_uhFV%#%qM zWeuKm&yc$M*=S8+^h#`b`JQ9!z`mR%MQ4(U`#LCXqSxTVH!rJa!!d<1(#pl&#$-JXwt3AUpUbDb z%5qubu~@%3W6y~FSJaANKiu1IY;Af$>D9Rtt{?j7@1mO(XOhdsbBj@Y=c+bjiIU@qFT9bEa<_feHQ5qlYxR9aP8hZMK{^|qPdA>$7`_$1Yb+%XJ z<7rO~rlrzcVc&|oocY^jqO(=%0E4zjeRW+ImEZC2(za%c*UW-;4(rR^+{bUht?Ba* ze7e0K`eggUUwrZ_lhVo>-tN^@1ohuPYh3!ksJex=cthsm=QA>uUvA4()||SoxiVaA zj%4i|upzT&w>;J&bm*L_aR+wpjkxm?8I+e0koCqL$(X)h6`WUx?i)GEyP*5_(U;HP^e+>=okyHIGyG2M z{@MK #include @@ -42,96 +45,114 @@ double mousex = 0.0; double mousey = 0.0; Camera camera; +Console console; int SV_WIREFRAME = 0; //0: off 1: overlay 2: only int SV_RENDERMODE = 0; int SV_PERSPECTIVE = 0; -float M_HEIGHT_MIN = 0.0f; -float M_HEIGHT_MAX = 10.0f; +int M_HEIGHT_MIN = 0.0f; +int M_HEIGHT_MAX = 10.0f * 100.0f; -float M_CLIP_NEAR = 0.1f; -float M_CLIP_FAR = 100.0f; +int M_CLIP_NEAR = 0.1f * 100.0f; +int M_CLIP_FAR = 100.0f * 100.0f; + +int T_RENDER_RESOLUTION_X = 1024; +int T_RENDER_RESOLUTION_Y = 1024; +bool T_ARM_FOR_FB_RENDER = false; bool SV_DRAW_BSP = true; bool SV_DRAW_NAV = false; +bool V_DO_QUIT = false; + +std::string _filesrc_bsp; +std::string _filesrc_nav; + Radar* _radar; -float M_ORTHO_SIZE = 20.0f; +int M_ORTHO_SIZE = 20; + +// Runtime UI stuffz +void update_globals_ui_text(TextFont* target); //Auto update the ui text +TextFont* ui_text_info; +TextFont* ui_text_loaded; + +//CCMDS +void _ccmd_renderbsp() { SV_RENDERMODE = 0; } +void _ccmd_rendernav() { SV_RENDERMODE = 1; } +void _ccmd_exit() { V_DO_QUIT = true; } +void _ccmd_perspective() { SV_PERSPECTIVE = 0; } +void _ccmd_orthographic() { SV_PERSPECTIVE = 1; } +void _ccmd_render_image() { T_ARM_FOR_FB_RENDER = true; } +void _ccmd_reset_ang() { camera.pitch = -90; camera.yaw = 0; camera.mouseUpdate(0, 0, true); } +void _ccmd_help() { + console.FeedBack(R"TERRI00( + +Controls: + WASD Fly + Click and drag Look around + ` or ~ key Open console + +Commands: + General: + QUIT / EXIT Closes (wow!) + NAV View nav mesh + BSP View bsp file + HELP Helps you out + + Camera: + PERSPECTIVE / PERSP Switches to perspective view + ORTHOGRAPHIC / ORTHO Switches to orthographic view + OSIZE / SIZE Changes the orthographic scale + LOOKDOWN Sets yaw to 0, pitch to -90 + + RENDER Renders the view to render.png + + Variables: + RENDERMODE Same as nav/bsp switch + PROJMATRIX Same as persp/ortho + + Variables (the actual height stuff): + MIN Minimum levels of height (units) + MAX Maximum levels of height (units) + + FARZ Far clip plane of the camera + NEARZ Near clip plane of the camera +)TERRI00", MSG_STATUS::SUCCESS); +} int main(int argc, char* argv[]) { - std::string _FILE_BSP = "D:\\Users\\Harry\\Source\\Repos\\MCDV\\Release\\killhouse.bsp"; - std::string _FILE_NAV = "D:\\Users\\Harry\\Source\\Repos\\MCDV\\Release\\killhouse.nav"; + _filesrc_bsp = "D:\\Users\\Harry\\Source\\Repos\\MCDV\\Debug\\killhouse.bsp"; + _filesrc_nav = "D:\\Users\\Harry\\Source\\Repos\\MCDV\\Debug\\killhouse.nav"; for (int i = 1; i < argc; ++i) { char* _arg = argv[i]; std::string arg = _arg; if (split(arg, '.').back() == "bsp") { - _FILE_BSP = arg; + _filesrc_bsp = arg; } if (split(arg, '.').back() == "nav") { - _FILE_NAV = arg; + _filesrc_nav = arg; } } - /* - std::vector data = { - glm::vec3(0,0,-5), - glm::vec3(0,0,-4.5), - glm::vec3(10,-2,0), - glm::vec3(-3,5,0), - glm::vec3(0,2,-9), - glm::vec3(3,-5,0), - glm::vec3(-2,0,4), - glm::vec3(1,4,5), - glm::vec3(1,4.5f, 5), - glm::vec3(4,-5,0), - glm::vec3(0,4,-4), - glm::vec3(0,6,4), - glm::vec3(0,10,0), - glm::vec3(-2,-16,0), - glm::vec3(0,-4,-8), - glm::vec3(1,1,0), - glm::vec3(3,3,-4), - glm::vec3(0,4,0), - glm::vec3(0,-1,0) - }; - - octree::Tree test(data, 3); - - octree::Node* tNode = test.head.getNodeByVec(glm::vec3(0, 0, -5)); - std::vector points = tNode->getContainedValues(); - - for (int i = 0; i < points.size(); i++) { - glm::vec3 p = points[i]; - - std::cout << p.x << " : " << p.y << " : " << p.z << std::endl; - } - - std::cout << "Total entries: " << test.head.getEntryCount() << std::endl; - - system("PAUSE"); - return 0; - */ - - - #pragma region Initialisation - std::cout << "Bigman Engine" << std::endl; + std::cout << "CS:GO Heightmap generator" << std::endl; //Initialize OpenGL glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); //We are using version 3.3 of openGL glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); //Creating the window - GLFWwindow* window = glfwCreateWindow(window_width, window_height, "bigman engine", NULL, NULL); + GLFWwindow* window = glfwCreateWindow(window_width, window_height, "CS:GO Heightmap generator", NULL, NULL); //Check if window open if (window == NULL) @@ -171,22 +192,19 @@ int main(int argc, char* argv[]) { Mesh* t200 = NULL; Mesh* t201 = NULL; - if (_FILE_BSP != ""){ - vbsp_level bsp_map(_FILE_BSP, true); + if (_filesrc_bsp != ""){ + vbsp_level bsp_map(_filesrc_bsp, true); t200 = new Mesh(bsp_map.generate_bigmesh()); } - if (_FILE_NAV != "") { - Nav::Mesh bob(_FILE_NAV); + if (_filesrc_nav != "") { + Nav::Mesh bob(_filesrc_nav); t201 = new Mesh(bob.generateGLMesh()); } //Radar rtest("de_overpass.txt"); //_radar = &rtest; - - - //VertAlphaMesh t300(vbsp_level::genVertAlpha(t200.vertices, t201.vertices)); util_keyHandler keys(window); @@ -196,6 +214,60 @@ int main(int argc, char* argv[]) { glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); + TextFont::init(); //Setup textfonts before we use it + + ui_text_info = new TextFont("Hello World!"); + ui_text_info->size = glm::vec2(1.0f / window_width, 1.0f / window_height) * 2.0f; + ui_text_info->alpha = 1.0f; + ui_text_info->color = glm::vec3(0.75f, 0.75f, 0.75f); + ui_text_info->screenPosition = glm::vec2(0, (1.0f / window_height) * 15.0f); + + ui_text_loaded = new TextFont("Currently Loaded:\n " + std::string(_filesrc_bsp) + "\n " + std::string(_filesrc_nav)); + ui_text_loaded->size = glm::vec2(1.0f / window_width, 1.0f / window_height) * 2.0f; + ui_text_loaded->alpha = 1.0f; + ui_text_loaded->color = glm::vec3(0.75f, 0.75f, 0.75f); + ui_text_loaded->screenPosition = glm::vec2(0, 1.0f - ((1.0f / window_height) * 45.0f)); + + update_globals_ui_text(ui_text_info); //Update globals + + //Generate console + console = Console(&keys, &window_width, &window_height); + console.RegisterCVar("RENDERMODE", &SV_RENDERMODE); + + //Help + console.RegisterCmd("HELP", &_ccmd_help); + + //Quit ccmds + console.RegisterCmd("QUIT", &_ccmd_exit); + console.RegisterCmd("EXIT", &_ccmd_exit); + + //Render modes + console.RegisterCmd("NAV", &_ccmd_rendernav); + console.RegisterCmd("BSP", &_ccmd_renderbsp); + + console.RegisterCmd("PERSPECTIVE", &_ccmd_perspective); + console.RegisterCmd("PERSP", &_ccmd_perspective); + console.RegisterCmd("ORTHOGRAPHIC", &_ccmd_orthographic); + console.RegisterCmd("ORTHO", &_ccmd_orthographic); + console.RegisterCmd("LOOKDOWN", &_ccmd_reset_ang); + + //console.RegisterCVar("SX", &T_RENDER_RESOLUTION_X); + //console.RegisterCVar("SY", &T_RENDER_RESOLUTION_Y); + console.RegisterCmd("RENDER", &_ccmd_render_image); + + //Register CVARS + console.RegisterCVar("RENDERMODE", &SV_RENDERMODE); + console.RegisterCVar("PROJMATRIX", &SV_PERSPECTIVE); + console.RegisterCVar("MIN", &M_HEIGHT_MIN); + console.RegisterCVar("MAX", &M_HEIGHT_MAX); + console.RegisterCVar("OSIZE", &M_ORTHO_SIZE); + console.RegisterCVar("SIZE", &M_ORTHO_SIZE); + + //Far/near + console.RegisterCVar("FARZ", &M_CLIP_FAR); + console.RegisterCVar("NEARZ", &M_CLIP_NEAR); + + //FrameBuffer t_frame_buffer = FrameBuffer(); //The main loop while (!glfwWindowShouldClose(window)) @@ -206,20 +278,35 @@ int main(int argc, char* argv[]) { //Input processInput(window, keys); - camera.handleInput(deltaTime); + if(!console.isEnabled) + camera.handleInput(deltaTime); + + console.handleKeysTick(); + + if (T_ARM_FOR_FB_RENDER) { + //t_frame_buffer.Bind(); + glViewport(0, 0, T_RENDER_RESOLUTION_X, T_RENDER_RESOLUTION_Y); + } //Rendering commands glClearColor(0.05f, 0.05f, 0.05f, 1.0f); + + + if(T_ARM_FOR_FB_RENDER) glClearColor(0.0f, 1.0f, 0.00f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPolygonMode(GL_FRONT, GL_FILL); + glDisable(GL_BLEND); + glEnable(GL_DEPTH_TEST); + glDepthMask(1); shader_lit.use(); if(SV_PERSPECTIVE == 0) - shader_lit.setMatrix("projection", glm::perspective(glm::radians(90.0f / 2), (float)window_width / (float)window_height, M_CLIP_NEAR, M_CLIP_FAR)); + shader_lit.setMatrix("projection", glm::perspective(glm::radians(90.0f / 2), (float)window_width / (float)window_height, (float)M_CLIP_NEAR * 0.01f, (float)M_CLIP_FAR * 0.01f)); else - shader_lit.setMatrix("projection", glm::ortho(-M_ORTHO_SIZE, M_ORTHO_SIZE, -M_ORTHO_SIZE, M_ORTHO_SIZE, M_CLIP_NEAR, M_CLIP_FAR)); + shader_lit.setMatrix("projection", glm::ortho(-(float)M_ORTHO_SIZE, (float)M_ORTHO_SIZE, -(float)M_ORTHO_SIZE, (float)M_ORTHO_SIZE, (float)M_CLIP_NEAR * 0.01f, (float)M_CLIP_FAR * 0.01f)); shader_lit.setMatrix("view", camera.getViewMatrix()); @@ -227,37 +314,59 @@ int main(int argc, char* argv[]) { shader_lit.setMatrix("model", model); shader_lit.setVec3("color", 0.0f, 0.0f, 1.0f); - shader_lit.setFloat("HEIGHT_MIN", M_HEIGHT_MIN); - shader_lit.setFloat("HEIGHT_MAX", M_HEIGHT_MAX); + shader_lit.setFloat("HEIGHT_MIN", (float)M_HEIGHT_MIN * 0.01f); + shader_lit.setFloat("HEIGHT_MAX", (float)M_HEIGHT_MAX * 0.01f); - if (SV_RENDERMODE == 0) - if(t200 != NULL) + if (SV_RENDERMODE == 0) { + glEnable(GL_CULL_FACE); + if (t200 != NULL) t200->Draw(); + } - if(SV_RENDERMODE == 1) + if (SV_RENDERMODE == 1) { + glDisable(GL_CULL_FACE); if (t201 != NULL) t201->Draw(); + } - - - //t300.Draw(); - //glPolygonMode(GL_FRONT, GL_LINE); - // - //shader_unlit.use(); - //shader_unlit.setMatrix("projection", camera.getProjectionMatrix()); - //shader_unlit.setMatrix("view", camera.getViewMatrix()); - //shader_unlit.setMatrix("model", model); - //shader_unlit.setVec3("color", 0.0f, 0.0f, 1.0f); - // - //t201.Draw(); + + if (!T_ARM_FOR_FB_RENDER) { // UI + console.draw(); + + //ui_text_info->DrawWithBackground(); + //ui_text_loaded->DrawWithBackground(); + } + + //Sort out render buffer stuff + if (T_ARM_FOR_FB_RENDER) { + std::cout << "Done" << std::endl; + + void* data = malloc(3 * T_RENDER_RESOLUTION_X * T_RENDER_RESOLUTION_Y); + glReadPixels(0, 0, T_RENDER_RESOLUTION_X, T_RENDER_RESOLUTION_Y, GL_RGB, GL_UNSIGNED_BYTE, data); + + if (data != 0) { + stbi_flip_vertically_on_write(true); + stbi_write_png("render.png", T_RENDER_RESOLUTION_X, T_RENDER_RESOLUTION_Y, 3, data, T_RENDER_RESOLUTION_X * 3); + console.FeedBack("Done! Saved to: render.png", MSG_STATUS::SUCCESS); + } + else + console.FeedBack("Something went wrong making render", MSG_STATUS::ERR); + + //t_frame_buffer.Unbind(); + glViewport(0, 0, window_width, window_height); + T_ARM_FOR_FB_RENDER = false; + } //Check and call events, swap buffers glfwSwapBuffers(window); glfwPollEvents(); + + if (V_DO_QUIT) + break; } //Exit safely @@ -287,38 +396,48 @@ void processInput(GLFWwindow* window, util_keyHandler keys) if (keys.getKeyDown(GLFW_KEY_ESCAPE)) glfwSetWindowShouldClose(window, true); + if (keys.getKeyDown(GLFW_KEY_GRAVE_ACCENT)) + console.isEnabled = !console.isEnabled; + + + return; if (keys.getKeyDown(GLFW_KEY_1)) { - SV_EDITMODE = 0; glfwSetWindowTitle(window, "Bigman Engine :: EDITING MIN"); + SV_EDITMODE = 0; + update_globals_ui_text(ui_text_info); //Update globals } if (keys.getKeyDown(GLFW_KEY_2)) { - SV_EDITMODE = 1; glfwSetWindowTitle(window, "Bigman Engine :: EDITING MAX"); + SV_EDITMODE = 1; + update_globals_ui_text(ui_text_info); //Update globals } if (keys.getKeyDown(GLFW_KEY_3)) { - //SV_EDITMODE = 2; glfwSetWindowTitle(window, "Bigman Engine :: de_overpass.bsp - EDITING NEAR"); + SV_EDITMODE = 2; //glfwSetWindowTitle(window, "Bigman Engine :: de_overpass.bsp - EDITING NEAR"); + update_globals_ui_text(ui_text_info); //Update globals } if (keys.getKeyDown(GLFW_KEY_4)) { - //SV_EDITMODE = 3; glfwSetWindowTitle(window, "Bigman Engine :: de_overpass.bsp - EDITING FAR"); + SV_EDITMODE = 3; //glfwSetWindowTitle(window, "Bigman Engine :: de_overpass.bsp - EDITING FAR"); + update_globals_ui_text(ui_text_info); //Update globals } if (keys.getKeyDown(GLFW_KEY_5)) { - SV_PERSPECTIVE = 0; glfwSetWindowTitle(window, "Bigman Engine :: perspective"); + SV_PERSPECTIVE = 0; + update_globals_ui_text(ui_text_info); //Update globals } if (keys.getKeyDown(GLFW_KEY_6)) { - SV_PERSPECTIVE = 1; glfwSetWindowTitle(window, "Bigman Engine :: ortho"); + SV_PERSPECTIVE = 1; + update_globals_ui_text(ui_text_info); //Update globals } if (keys.getKeyDown(GLFW_KEY_7)) { - SV_RENDERMODE = 0; glfwSetWindowTitle(window, "Bigman Engine :: .bsp"); - - glEnable(GL_CULL_FACE); + SV_RENDERMODE = 0; + update_globals_ui_text(ui_text_info); //Update globals + } if (keys.getKeyDown(GLFW_KEY_8)) { - SV_RENDERMODE = 1; glfwSetWindowTitle(window, "Bigman Engine :: .nav"); - - glDisable(GL_CULL_FACE); + SV_RENDERMODE = 1; + update_globals_ui_text(ui_text_info); //Update globals } if (keys.getKeyDown(GLFW_KEY_9)) { @@ -326,7 +445,7 @@ void processInput(GLFWwindow* window, util_keyHandler keys) //M_ORTHO_SIZE = (_radar->scale / 0.1f) / 2.0f; //camera.cameraPos.x = (-_radar->pos_x ) * 0.01f; //camera.cameraPos.z = (_radar->pos_y - 1024) * 0.01f; - glfwSetWindowTitle(window, "Bigman Engine :: EDITING ORTHO SCALE"); + update_globals_ui_text(ui_text_info); //Update globals } @@ -339,6 +458,27 @@ void processInput(GLFWwindow* window, util_keyHandler keys) } } +std::string _globals_editmode_lookups[] = { + "Minimum Z", + "Maximum Z", + "Far Clip plane", + "Near Clip plane", + "Orthographic Size" +}; + +void update_globals_ui_text(TextFont* target) { + + std::ostringstream ss; + + ss << "Perspective: " << (SV_PERSPECTIVE == 0 ? "Perspective" : "Orthographic") << "\n"; + if (SV_PERSPECTIVE == 1) ss << "Ortho scale: " << M_ORTHO_SIZE << "\n"; + ss << "Viewing: " << (SV_RENDERMODE == 0 ? "BSP" : "NAV") << "\n"; + ss << "Editing: " << _globals_editmode_lookups[SV_EDITMODE] << "\n"; + + + target->SetText(ss.str()); +} + void mouse_callback(GLFWwindow* window, double xpos, double ypos) { camera.mouseUpdate(xpos, ypos, isClicking); diff --git a/MCDV/render.png b/MCDV/render.png new file mode 100644 index 0000000000000000000000000000000000000000..21498a5ffec0ba8b2fbc50ed5970e2f6d27c0f75 GIT binary patch literal 63366 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 AhyVZp literal 0 HcmV?d00001 diff --git a/MCDV/shaders/textfont.fs b/MCDV/shaders/textfont.fs new file mode 100644 index 0000000..59616cf --- /dev/null +++ b/MCDV/shaders/textfont.fs @@ -0,0 +1,14 @@ +#version 330 core +in vec2 TexCoords; +out vec4 FragColor; + +uniform vec3 color; +uniform float alpha; +uniform sampler2D text; + +void main() +{ + vec4 sample = vec4(1.0, 1.0, 1.0, texture(text, TexCoords).r); + FragColor = vec4(color, alpha) * sample; + //FragColor = vec4(texture(text, TexCoords).r, 0.0, 0.0, 1.0); +} \ No newline at end of file diff --git a/MCDV/shaders/textfont.vs b/MCDV/shaders/textfont.vs new file mode 100644 index 0000000..f167dd8 --- /dev/null +++ b/MCDV/shaders/textfont.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec4 vert; +out vec2 TexCoords; + +uniform mat4 model; + +void main() +{ + gl_Position = model * vec4(vert.xy, 0.0, 1.0); + TexCoords = vert.zw; +} \ No newline at end of file diff --git a/MCDV/stb_image_write.h b/MCDV/stb_image_write.h new file mode 100644 index 0000000..525a226 --- /dev/null +++ b/MCDV/stb_image_write.h @@ -0,0 +1,1642 @@ +/* stb_image_write - v1.10 - public domain - http://nothings.org/stb/stb_image_write.h +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. + +If using a modern Microsoft Compiler, non-safe versions of CRT calls may cause +compilation warnings or even errors. To avoid this, also before #including, + +#define STBI_MSC_SECURE_CRT + +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 + +LICENSE + +See end of file for license information. + +*/ + +#ifndef INCLUDE_STB_IMAGE_WRITE_H +#define INCLUDE_STB_IMAGE_WRITE_H + +#include + +// 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 +extern int stbi_write_tga_with_rle; +extern int stbi_write_png_compression_level; +extern 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 STBI_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 +#endif // STBI_WRITE_NO_STDIO + +#include +#include +#include +#include + +#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 +#define STBIW_ASSERT(x) assert(x) +#endif + +#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff) + +#ifdef STB_IMAGE_WRITE_STATIC +static int stbi__flip_vertically_on_write = 0; +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__flip_vertically_on_write = 0; +int stbi_write_tga_with_rle = 1; +int stbi_write_force_png_filter = -1; +#endif + +STBIWDEF void stbi_flip_vertically_on_write(int flag) +{ + stbi__flip_vertically_on_write = flag; +} + +typedef struct +{ + stbi_write_func *func; + void *context; +} 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(_MSC_VER) && defined(STBI_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, bufferlen, NULL, NULL); +} +#endif + +static FILE *stbiw__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode))) + return 0; + +#if _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__putc(stbi__write_context *s, unsigned char c) +{ + s->func(s->context, &c, 1); +} + +static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c) +{ + unsigned char arr[3]; + arr[0] = a, arr[1] = b, arr[2] = c; + s->func(s->context, arr, 3); +} + +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) + s->func(s->context, &d[comp - 1], 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 + s->func(s->context, d, 1); // 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) + s->func(s->context, &d[comp - 1], 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); + } + 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) +{ + 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 +} + +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_bmp_core(&s, x, y, comp, data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s; + if (stbi__start_write_file(&s, filename)) { + int r = stbi_write_bmp_core(&s, x, y, comp, data); + stbi__end_write_file(&s); + return r; + } + else + return 0; +} +#endif //!STBI_WRITE_NO_STDIO + +static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data) +{ + int has_alpha = (comp == 2 || comp == 4); + int colorbytes = has_alpha ? comp - 1 : comp; + int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3 + + if (y < 0 || x < 0) + return 0; + + if (!stbi_write_tga_with_rle) { + return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *)data, has_alpha, 0, + "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8); + } + else { + int i, j, k; + int jend, jdir; + + stbiw__writef(s, "111 221 2222 11", 0, 0, format + 8, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8); + + if (stbi__flip_vertically_on_write) { + j = 0; + jend = y; + jdir = 1; + } + else { + j = y - 1; + jend = -1; + jdir = -1; + } + for (; j != jend; j += jdir) { + unsigned char *row = (unsigned char *)data + j * x * comp; + int len; + + for (i = 0; i < x; i += len) { + unsigned char *begin = row + i * comp; + int diff = 1; + len = 1; + + if (i < x - 1) { + ++len; + diff = memcmp(begin, row + (i + 1) * comp, comp); + if (diff) { + const unsigned char *prev = begin; + for (k = i + 2; k < x && len < 128; ++k) { + if (memcmp(prev, row + k * comp, comp)) { + prev += comp; + ++len; + } + else { + --len; + break; + } + } + } + else { + for (k = i + 2; k < x && len < 128; ++k) { + if (!memcmp(begin, row + k * comp, comp)) { + ++len; + } + else { + break; + } + } + } + } + + if (diff) { + unsigned char header = STBIW_UCHAR(len - 1); + s->func(s->context, &header, 1); + 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); + s->func(s->context, &header, 1); + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin); + } + } + } + } + return 1; +} + +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_tga_core(&s, x, y, comp, (void *)data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s; + if (stbi__start_write_file(&s, filename)) { + int r = stbi_write_tga_core(&s, x, y, comp, (void *)data); + stbi__end_write_file(&s); + return r; + } + else + return 0; +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR writer +// by Baldur Karlsson + +#define stbiw__max(a, b) ((a) > (b) ? (a) : (b)) + +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 STBI_MSC_SECURE_CRT + len = sprintf_s(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#else + len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#endif + s->func(s->context, buffer, len); + + for (i = 0; i < y; i++) + stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp * x*(stbi__flip_vertically_on_write ? y - 1 - i : i)); + STBIW_FREE(scratch); + return 1; + } +} + +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data) +{ + stbi__write_context s; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_hdr_core(&s, x, y, comp, (float *)data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data) +{ + stbi__write_context s; + if (stbi__start_write_file(&s, filename)) { + int r = stbi_write_hdr_core(&s, x, y, comp, (float *)data); + stbi__end_write_file(&s); + return r; + } + else + return 0; +} +#endif // STBI_WRITE_NO_STDIO + + +////////////////////////////////////////////////////////////////////////////// +// +// PNG writer +// + +#ifndef STBIW_ZLIB_COMPRESS +// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size() +#define stbiw__sbraw(a) ((int *) (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(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); + + { + // 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, 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, diff, end0pos; + int DU[64]; + + // DCT rows + for (dataOff = 0; dataOff<64; dataOff += 8) { + 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 + 8], &CDU[dataOff + 16], &CDU[dataOff + 24], &CDU[dataOff + 32], &CDU[dataOff + 40], &CDU[dataOff + 48], &CDU[dataOff + 56]); + } + // Quantize/descale/zigzag the coefficients + for (i = 0; i<64; ++i) { + float v = CDU[i] * fdtbl[i]; + // DU[stbiw__jpg_ZigZag[i]] = (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[i]] = (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; + 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; + 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,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 }; + const unsigned char *imageData = (const unsigned char *)data; + 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; + int x, y, pos; + for (y = 0; y < height; y += 8) { + for (x = 0; x < width; x += 8) { + float YDU[64], UDU[64], VDU[64]; + for (row = y, pos = 0; row < y + 8; ++row) { + int p; + if (row < height) { + p = (stbi__flip_vertically_on_write ? (height - 1 - row) : row)*width*comp; + } + else { + // row >= height => use last input row (=> first if flipping) + p = stbi__flip_vertically_on_write ? 0 : ((height - 1)*width*comp); + } + for (col = x; col < x + 8; ++col, ++pos) { + float r, g, b; + // if col >= width => use pixel from last input column + p += ((col < width) ? col : (width - 1))*comp; + + r = imageData[p + 0]; + g = imageData[p + ofsG]; + b = imageData[p + ofsB]; + YDU[pos] = +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + UDU[pos] = -0.16874f*r - 0.33126f*g + 0.50000f*b; + VDU[pos] = +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + + // Do the bit alignment of the EOI marker + stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits); + } + + // EOI + stbiw__putc(s, 0xFF); + stbiw__putc(s, 0xD9); + + return 1; +} + +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_jpg_core(&s, x, y, comp, (void *)data, quality); +} + + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s; + if (stbi__start_write_file(&s, filename)) { + int r = stbi_write_jpg_core(&s, x, y, comp, data, quality); + stbi__end_write_file(&s); + return r; + } + else + return 0; +} +#endif + +#endif // STB_IMAGE_WRITE_IMPLEMENTATION + +/* Revision history +1.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. +------------------------------------------------------------------------------ +*/ \ No newline at end of file diff --git a/MCDV/test.png b/MCDV/test.png new file mode 100644 index 0000000000000000000000000000000000000000..96b3902da10476fdddcf535c63d85b2d884e1ba7 GIT binary patch literal 31792 zcmeI5O=uHA6vxMOsUaj1L1Y{JAQZF*4-o^3U(hzD=3pt}RSERacoQii7O^Q9Ct^vs_lOG9p^-p*PN z19`8QYq#=+T*7u3JnWQDsn*lmMW;Mk?K-%@#rf{@>z{QS-siMedv?GcfA^k5YyWKf z(^-4);94=HV}57%jaH}otHsOr8(uBh>^dY<_4Y2WcKx6|c5p3cO-bkT_wt34eT9dM zW0q0-qjTo72?4V!$ z>vvYyt=O1MHs7k|!ncqceK=oO@yGomWZc2EzL0CV#L`ixJf+IZzil^~f9`SC{jQpa zR<~emzh4VsU;a$}qnl_QQ>`zzy7IY}=!sB2_HTS+Pcx64uzPNF_=MYiw4Wvto@X zC9JVokxG;j*4Ugl2U4wtlE7Lo)j5!AeeQumw#oNRDr8oyNkytyg$&cdYUdD2ktikc z#W|}=?Iq4xRjOEp%&AhvA{C|skZNRrC?zl*tTO{*kt$Uo!*qb@U}S(5YhsZqRw2W5 zusJz|QWUF@VLBN4P)`RFScB;hMJb9!s#t{#)4{g3g_xcqN(rkvXT>?Imns&iL@8la z=d2zwd|ca-KuRgXbO2Iy28dD;U!1dIO)OHyDrA@rFdd8xV0(qO8gz@mnplO*s#3)w z6{dp$l#Tss#KSkG&N&Sa)(3xL+^n(Vt5U@xl_({w>YNqlFdbkz7#ZN)1S}S*Fdd?7 zaS)4Cu?iWc0~E560hkWjYS1kLYho2Lt4bA%RG1D1P+&SpeMJveIzS;C8Gz|vJaTWm z4UF9S&KesE+4?@YUSh46u{o#4s8Yfi zJHAt6L@B|vT$HUHKx&k&9Z<+o6f!5)#3EI!LS|K|Vtrh(3K>X^f>fyrnN_8VMXFeZ z%&JnwB310P99BADTF%G-RyyeQ4Z1~OO{_wOj~m6u#YzVQC|K!$l@1!Dy0u-AN{pLT zowMQ`rUOg|BLmo8Vf*PTLMg&@urA>s9=^pQl^Az?aSqb~3fag2Ob4xtb&J3nQA${+ z1mmkx#Ud4^g8>wn4lo@wNOfzwB9$07iF2i%98XPs{k3<+|0Qr$IX7Nf9I4Lz100o^ A-v9sr literal 0 HcmV?d00001 diff --git a/MCDV/textfont.fs b/MCDV/textfont.fs new file mode 100644 index 0000000..59616cf --- /dev/null +++ b/MCDV/textfont.fs @@ -0,0 +1,14 @@ +#version 330 core +in vec2 TexCoords; +out vec4 FragColor; + +uniform vec3 color; +uniform float alpha; +uniform sampler2D text; + +void main() +{ + vec4 sample = vec4(1.0, 1.0, 1.0, texture(text, TexCoords).r); + FragColor = vec4(color, alpha) * sample; + //FragColor = vec4(texture(text, TexCoords).r, 0.0, 0.0, 1.0); +} \ No newline at end of file diff --git a/MCDV/textfont.vs b/MCDV/textfont.vs new file mode 100644 index 0000000..f167dd8 --- /dev/null +++ b/MCDV/textfont.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec4 vert; +out vec2 TexCoords; + +uniform mat4 model; + +void main() +{ + gl_Position = model * vec4(vert.xy, 0.0, 1.0); + TexCoords = vert.zw; +} \ No newline at end of file diff --git a/MCDV/util.h b/MCDV/util.h index 8441b08..c750915 100644 --- a/MCDV/util.h +++ b/MCDV/util.h @@ -27,6 +27,22 @@ namespace util { }; } +template +std::string to_string(T t, std::ios_base & (*f)(std::ios_base&)) +{ + std::ostringstream oss; + oss << f << t; + return oss.str(); +} + +//Split only on whitespace +std::vector split(std::string const &input) { + std::istringstream buffer(input); + std::vector ret((std::istream_iterator(buffer)), + std::istream_iterator()); + return ret; +} + std::vector split(std::string string, char delim) { std::stringstream cStream(string); -- 2.25.1