added color corection into mcdungeons

Pika/gameplay/containers/minecraftDungeons/mcDungeonsEditor.h

@@ -342,7 +342,8 @@ struct McDungeonsEditor: public Container
 			addBack(pos, blockType);
 		};
 
-		auto isSolid = [](unsigned char b) { return b != 0 && b != BlockTypes::glass; };
+		auto isSolid = [](unsigned char b) { return b != 0 && b != BlockTypes::glass && b != BlockTypes::glowStone
+			&& b != BlockTypes::furnace_on; };
 
 		for (int x = 0; x < worldSize.x; x++)
 			for (int y = 0; y < worldSize.y; y++)
@@ -385,7 +386,11 @@ struct McDungeonsEditor: public Container
 
 						if (b == BlockTypes::glowStone)
 						{
-							renderer.createPointLight({x,y,z}, glm::vec3(0.845f, 0.812f, 0.381f)*1.5f, 16.f, 1.5f);
+							renderer.createPointLight({x,y,z}, glm::vec3(0.845f, 0.812f, 0.381f)*1.5f, 16.f, 2.f);
+						}else 
+						if (b == BlockTypes::furnace_on)
+						{
+							renderer.createSpotLight({x,y,z}, glm::radians(90.f), glm::vec3(0,0,1), 16, 1.5, glm::vec3(1, 0.5f, 0.211f) * 2.f);
 						}
 
 					}
@@ -415,11 +420,17 @@ struct McDungeonsEditor: public Container
 		renderer.fileOpener.fileExistsCallback = defaultFileExistsCustom;
 		
 		renderer.init(1, 1, PIKA_RESOURCES_PATH "BRDFintegrationMap.png", requestedInfo.requestedFBO.fbo);
-		
+		renderer.colorCorrectionTexture() = renderer.loadColorLookupTextureFromFile(PIKA_RESOURCES_PATH "/mcDungeons/lut.png");
+
 		//renderer.skyBox = renderer.loadSkyBox(names);
 		//renderer.skyBox.color = {0.2,0.3,0.8};
-		renderer.skyBox = renderer.atmosfericScattering({0,1,0}, {0.2,0.2,0.5}, {0.6,0.2,0.1}, {},
+		renderer.skyBox = renderer.atmosfericScattering({0,0.7,0.3}, {0.2,0.2,0.5}, {0.6,0.2,0.1}, {},
 			false, 10);
+		renderer.frustumCulling = false;
+		renderer.skyBox.color = glm::vec3(0.659f, 0.698f, 0.723f);
+
+		renderer.createDirectionalLight(glm::vec3(0.575, -0.686, 0.445), glm::vec3(0.155f, 0.893f, 1.000f), 2);
+
 
 		//helmetModel = renderer.loadModel(PIKA_RESOURCES_PATH "helmet/helmet.obj");
 		//model = renderer.loadModel(PIKA_RESOURCES_PATH "rave.glb", 0.5);

Pika/resources/logs.txt

@@ -1,8 +1,7 @@
-#2023-02-27 13:11:25: Created container: Gameplay
-#2023-02-27 13:11:30: Created container: McDungeonsEditor
-#2023-02-27 13:11:32: Destroyed continer: Gameplay #1
-#2023-02-27 13:16:07: Reloaded dll
-#2023-02-27 13:23:25: Reloaded dll
-#2023-02-27 13:27:28: Created container: McDungeonsEditor
-#2023-02-27 13:27:33: Destroyed continer: McDungeonsEditor #3
-#2023-02-27 13:27:42: Destroyed continer: McDungeonsEditor #2
+#2023-02-28 14:33:39: Created container: Gameplay
+#2023-02-28 14:33:41: Destroyed continer: Gameplay #1
+#2023-02-28 14:33:45: Created container: ImmageViewer
+#2023-02-28 14:33:47: Terminated container because it returned 0: ImmageViewer #2
+#2023-02-28 14:33:47: Destroyed continer: ImmageViewer #2
+#2023-02-28 14:33:48: Created container: McDungeonsEditor
+#2023-02-28 14:36:19: Destroyed continer: McDungeonsEditor #3

Pika/thirdparty/gl3d/gl3d.cpp

@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////
 //gl32 --Vlad Luta -- 
-//built on 2023-02-18
+//built on 2023-02-28
 ////////////////////////////////////////////////
 
 #include "gl3d.h"
@@ -31473,7 +31473,9 @@ namespace gl3d
 			return;
 	
 		setTextureQuality(quality);
-		glGenerateMipmap(GL_TEXTURE_2D);
+
+		if(quality > linearNoMipmap)
+			glGenerateMipmap(GL_TEXTURE_2D);
 	
 	}
 
@@ -31615,6 +31617,13 @@ namespace gl3d
 				glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY, 1.f);
 			}
 			break;
+			case linearNoMipmap:
+			{
+				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+				glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY, 1.f);
+			}
+			break;
 			case nearestMipmap:
 			{
 				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
@@ -31894,7 +31903,7 @@ namespace gl3d
 
 		//std::pair< std::string, const char*>{"name", "value"}
 		//#pragma shaderSources
-      std::pair<std::string, const char*>{"ssao.frag", "#version 330 core\n"
+      std::pair<std::string, const char*>{"ssao.frag", "#version 330 core\n"
 "out float fragColor;\n"
 "noperspective in highp vec2 v_texCoords;\n"
 "uniform sampler2D u_gPosition; \n"
@@ -32691,6 +32700,45 @@ namespace gl3d
 "a_outBloom = vec4(0.0, 0.0, 0.0, 1.0);\n"
 "};\n"
 "a_outBloom = clamp (a_outBloom, 0.0, 1000.0);\n"
+"}\n"},
+
+      std::pair<std::string, const char*>{"colorCorrection.frag", "#version 150\n"
+"out vec4 a_color;\n"
+"noperspective in vec2 v_texCoords;\n"
+"uniform sampler2D u_texture;\n"
+"uniform sampler2D u_lookup;\n"
+"void main ()\n"
+"{\n"
+"vec4 tmpvar_1;\n"
+"tmpvar_1 = texture (u_texture, v_texCoords);\n"
+"int tmpvar_2;\n"
+"tmpvar_2 = int(floor((64.0 * tmpvar_1.z)));\n"
+"int tmpvar_3;\n"
+"tmpvar_3 = min (int(ceil(\n"
+"(64.0 * tmpvar_1.z)\n"
+")), 63);\n"
+"vec2 finalCellPos_4;\n"
+"ivec2 index2_5;\n"
+"index2_5.x = (int(mod (tmpvar_2, 8)));\n"
+"index2_5.y = (tmpvar_2 / 8);\n"
+"vec2 tmpvar_6;\n"
+"tmpvar_6 = (((vec2(0.125, 0.125) * tmpvar_1.xy) + (vec2(0.125, 0.125) * \n"
+"vec2(index2_5)\n"
+")) + vec2(0.001, 0.001));\n"
+"finalCellPos_4.x = tmpvar_6.x;\n"
+"finalCellPos_4.y = (1.0 - tmpvar_6.y);\n"
+"vec2 finalCellPos_7;\n"
+"ivec2 index2_8;\n"
+"index2_8.x = (int(mod (tmpvar_3, 8)));\n"
+"index2_8.y = (tmpvar_3 / 8);\n"
+"vec2 tmpvar_9;\n"
+"tmpvar_9 = (((vec2(0.125, 0.125) * tmpvar_1.xy) + (vec2(0.125, 0.125) * \n"
+"vec2(index2_8)\n"
+")) + vec2(0.001, 0.001));\n"
+"finalCellPos_7.x = tmpvar_9.x;\n"
+"finalCellPos_7.y = (1.0 - tmpvar_9.y);\n"
+"a_color.xyz = mix (texture (u_lookup, finalCellPos_4).xyz, texture (u_lookup, finalCellPos_7).xyz, vec3(((64.0 * tmpvar_1.z) - float(tmpvar_2))));\n"
+"a_color.w = 1.0;\n"
 "}\n"},
 
       std::pair<std::string, const char*>{"chromaticAberation.frag", "#version 150\n"
@@ -36322,9 +36370,10 @@ namespace gl3d
 		directionalShadows.create(frameBuffer);
 		spotShadows.create(frameBuffer);
 		pointShadows.create(frameBuffer);
-		antiAlias.create(x, y, errorReporter, fileOpener);
+		antiAlias.create(errorReporter, fileOpener);
 		adaptiveResolution.create(x, y);
 		copyDepth.create(errorReporter, fileOpener);
+		internal.colorCorrection.create(x, y, errorReporter, fileOpener);
 
 		internal.pBRtextureMaker.init(errorReporter, fileOpener);
 	}
@@ -38654,6 +38703,16 @@ namespace gl3d
 		internal.ssao.ssao_finalColor_exponent = std::min(std::max(1.f, exponent), 64.f);
 	}
 
+	bool &Renderer3D::colorCorrection()
+	{
+		return internal.colorCorrection.colorCorrection;
+	}
+
+	ColorLookupTexture &Renderer3D::colorCorrectionTexture()
+	{
+		return internal.colorCorrection.currentTexture;
+	}
+
 	bool &Renderer3D::bloom()
 	{
 		return this->internal.lightShader.bloom;
@@ -38821,6 +38880,7 @@ namespace gl3d
 			j["exposure"] = getExposure();
 			j["normal mapping"] = isNormalMappingEnabeled();
 			j["light subscatter"] = isLightSubScatteringEnabeled();
+			j["colorCorrection"] = colorCorrection();
 
 			//fxaa
 			{
@@ -38906,6 +38966,12 @@ namespace gl3d
 				setExposure(exposure);
 			}
 
+			auto colorCorrection = rez["colorCorrection"];
+			if (colorCorrection.is_number())
+			{
+				this->colorCorrection() = colorCorrection;
+			}
+
 			auto normalMapping = rez["normal mapping"];
 			if (normalMapping.is_boolean())
 			{
@@ -39592,6 +39658,19 @@ namespace gl3d
 	};
 
 
+	ColorLookupTexture Renderer3D::loadColorLookupTextureFromFile(const char *path)
+	{
+		GpuTexture gpuTexture;
+		gpuTexture.loadTextureFromFile(path, fileOpener, -1, 3);
+		glBindTexture(GL_TEXTURE_2D, gpuTexture.id);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+		return {gpuTexture.id};
+	}
+
 	void Renderer3D::render(float deltaTime)
 	{
 		glEnable(GL_DEPTH_TEST);
@@ -40010,7 +40089,7 @@ namespace gl3d
 					{
 						if (!(potentialAnimations && j.hasBones))
 						{
-							if (shouldCullObject(j.minBoundary, j.maxBoundary, modelViewProjMat))
+							if (frustumCulling && shouldCullObject(j.minBoundary, j.maxBoundary, modelViewProjMat))
 							{
 								continue;
 							}
@@ -40525,18 +40604,14 @@ namespace gl3d
 							internal.directionalLights[lightIndex].changedThisFrame = false;
 
 							glm::vec3 lightDir = internal.directionalLights[lightIndex].direction;
-							//glm::mat4 lightView = lookAtSafe(-lightDir, {}, { 0.f,1.f,0.f });
 
 							glm::vec3 direction = lightDir;
 							glm::vec3 eye = camera.position - (direction);
 							glm::vec3 center = eye + direction;
 
-							glm::mat4 lightView = lookAtSafe(eye, center, { 0.f,1.f,0.f });
-							//glm::mat4 lightView = lookAtSafe(camera.position, camera.position + lightDir, { 0.f,1.f,0.f });
+							glm::mat4 lightView = lookAtSafe(eye, center, {0.f,1.f,0.f});//todo option to add a custom vector direction
 
 							//zoffset is used to move the light further
-
-
 							float zOffsets[] = { 15 / 200.f,0,0 };
 
 							glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
@@ -41702,7 +41777,16 @@ namespace gl3d
 	#pragma region draw to screen and fxaa 
 
 		glViewport(0, 0, internal.w, internal.h);
-		glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
+		
+
+		if (colorCorrection())
+		{
+			glBindFramebuffer(GL_FRAMEBUFFER, internal.colorCorrection.fbo);
+		}
+		else
+		{
+			glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
+		}
 
 		if (antiAlias.usingFXAA || adaptiveResolution.useAdaptiveResolution)
 		{
@@ -41737,8 +41821,28 @@ namespace gl3d
 
 	#pragma endregion
 
+	#pragma region color corection
+
+		if (colorCorrection())
+		{
+			glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
 
+			internal.colorCorrection.shader.bind();
+			glUniform1i(internal.colorCorrection.u_texture, 0);
+			glActiveTexture(GL_TEXTURE0);
+			glBindTexture(GL_TEXTURE_2D, internal.colorCorrection.texture);
 
+			glUniform1i(internal.colorCorrection.u_lookup, 1);
+			glActiveTexture(GL_TEXTURE1);
+			glBindTexture(GL_TEXTURE_2D, internal.colorCorrection.currentTexture.t.id);
+
+			glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+		}
+
+	#pragma endregion
+
+
+	//todo implement
 	#pragma region copy depth buffer for later forward rendering
 
 		glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
@@ -41804,7 +41908,8 @@ namespace gl3d
 		postProcess.resize(internal.adaptiveW, internal.adaptiveH);
 
 		adaptiveResolution.resize(internal.adaptiveW, internal.adaptiveH);
-
+		
+		internal.colorCorrection.resize(x, y);
 	}
 
 	void Renderer3D::clearAllLoadedResource()
@@ -41899,6 +42004,7 @@ namespace gl3d
 		adaptiveResolution.clear();
 		internal.pBRtextureMaker.clear();
 		copyDepth.clear();
+		internal.colorCorrection.clear();
 	}
 
 	SkyBox Renderer3D::loadSkyBox(const char *names[6])
@@ -42512,7 +42618,7 @@ namespace gl3d
 	}
 
 
-	void Renderer3D::AntiAlias::create(int w, int h, ErrorReporter &errorReporter, FileOpener &fileOpener)
+	void Renderer3D::AntiAlias::create(ErrorReporter &errorReporter, FileOpener &fileOpener)
 	{
 
 		shader.loadShaderProgramFromFile("shaders/drawQuads.vert",
@@ -42839,6 +42945,54 @@ namespace gl3d
 		shader.clear();
 	}
 
+	void Renderer3D::ColorCorrection::create(int w, int h, ErrorReporter &errorReporter, FileOpener &fileOpener)
+	{
+
+
+		shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/colorCorrection.frag", errorReporter, fileOpener);
+
+		u_texture = getUniform(shader.id, "u_texture", errorReporter);
+		u_lookup = getUniform(shader.id, "u_lookup", errorReporter);
+
+		glGenFramebuffers(1, &fbo);
+		glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+		glGenTextures(1, &texture);
+
+		glBindTexture(GL_TEXTURE_2D, texture);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_FLOAT, NULL);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
+
+
+		resize(w, h);
+
+		glBindFramebuffer(GL_FRAMEBUFFER, this->fbo);
+
+	}
+
+	void Renderer3D::ColorCorrection::resize(int w, int h)
+	{
+		if (currentDimensions.x != w || currentDimensions.y != h)
+		{
+			glBindTexture(GL_TEXTURE_2D, texture);
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h,
+				0, GL_RGBA, GL_FLOAT, NULL);
+
+			currentDimensions = glm::ivec2(w, h);
+		}
+
+	}
+
+	void Renderer3D::ColorCorrection::clear()
+	{
+		glDeleteFramebuffers(1, &fbo);
+		glDeleteTextures(1, &texture);
+		shader.clear();
+	}
+
 };
 #pragma endregion
 

Pika/thirdparty/gl3d/gl3d.h

@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////
 //gl32 --Vlad Luta -- 
-//built on 2023-02-18
+//built on 2023-02-28
 ////////////////////////////////////////////////
 
 
@@ -33838,6 +33838,7 @@ namespace gl3d
 	{
 		dontSet = -1, //won't create mipmap
 		leastPossible = 0,
+		linearNoMipmap,
 		nearestMipmap,
 		linearMipmap,
 		maxQuality
@@ -34564,6 +34565,14 @@ namespace gl3d
 		bool useGroundColor = 0;
 	};
 
+	//load using renderer.loadColorLookupTextureFromFile
+	//the memory of the lookup texture is not managed by the engine and not cleared by the engine on clearAll.
+	struct ColorLookupTexture
+	{
+		GpuTexture t;
+		void clear() { t.clear(); }
+	};
+
 	struct Renderer3D
 
 	{
@@ -34827,6 +34836,11 @@ namespace gl3d
 		void setSSAOSampleCount(int samples);
 		float &getSSAOExponent();
 		void setSSAOExponent(float exponent);
+		
+		bool &colorCorrection();
+		//the memory of the lookup texture is not managed by the engine and not cleared by the engine on clearAll.
+		ColorLookupTexture &colorCorrectionTexture();
+
 
 		//bloom
 		//more or less expensive
@@ -34899,6 +34913,31 @@ namespace gl3d
 		void renderSubModelBorder(Model o, int index, glm::vec3 position, glm::vec3 rotation = {},
 			glm::vec3 scale = { 1,1,1 }, float borderSize = 0.5, glm::vec3 borderColor = { 0.7, 0.7, 0.1 });
 
+		struct ColorCorrection
+		{
+			GLuint u_texture;
+			GLuint u_lookup;
+
+			Shader shader;
+
+			GLuint fbo;
+			//fbo texture
+			GLuint texture;
+
+			glm::ivec2 currentDimensions = {};
+
+			bool colorCorrection = 0;
+
+			void create(int w, int h, ErrorReporter &errorReporter, FileOpener &fileOpener);
+
+			void resize(int w, int h);
+
+			void clear();
+
+			//the memory of the lookup texture is not managed by the engine and not cleared by the engine on clearAll.
+			ColorLookupTexture currentTexture; //the texture supplied by user
+
+		};
 
 		struct InternalStruct
 		{
@@ -35089,6 +35128,8 @@ namespace gl3d
 
 			bool hasLastFrameTexture = 1;
 
+			ColorCorrection colorCorrection;
+
 		}internal;
 		
 
@@ -35209,7 +35250,7 @@ namespace gl3d
 		{
 			Shader shader;
 			Shader noAAshader;
-			void create(int w, int h, ErrorReporter &errorReporter, FileOpener &fileOpener);
+			void create(ErrorReporter &errorReporter, FileOpener &fileOpener);
 			void clear();
 
 			GLuint u_texture;
@@ -35222,6 +35263,8 @@ namespace gl3d
 			bool usingFXAA = true;
 		}antiAlias;
 
+		ColorLookupTexture loadColorLookupTextureFromFile(const char *path);
+
 		struct CopyDepth
 		{
 			gl3d::Shader shader;