Added asset-less HW3D demo

Added tinting to objects

Author: OneLoneCoder

examples/TEST_Hardware3D.cpp

@@ -0,0 +1,211 @@
+/*
+	Example file for olcUTIL_Hardware3D.h
+
+	License (OLC-3)
+	~~~~~~~~~~~~~~~
+
+	Copyright 2018 - 2025 OneLoneCoder.com
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions
+	are met:
+
+	1. Redistributions or derivations of source code must retain the above
+	copyright notice, this list of conditions and the following disclaimer.
+
+	2. Redistributions or derivative works in binary form must reproduce
+	the above copyright notice. This list of conditions and the following
+	disclaimer must be reproduced in the documentation and/or other
+	materials provided with the distribution.
+
+	3. Neither the name of the copyright holder nor the names of its
+	contributors may be used to endorse or promote products derived
+	from this software without specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+	Links
+	~~~~~
+	YouTube:	https://www.youtube.com/javidx9
+	Discord:	https://discord.gg/WhwHUMV
+	Twitter:	https://www.twitter.com/javidx9
+	Twitch:		https://www.twitch.tv/javidx9
+	GitHub:		https://www.github.com/onelonecoder
+	Homepage:	https://www.onelonecoder.com
+
+	Author
+	~~~~~~
+	David Barr, aka javidx9, ©OneLoneCoder 2019, 2020, 2021, 2022, 2023, 2024, 2025
+
+*/
+
+
+#define OLC_PGE_APPLICATION
+//#define OLC_GFX_OPENGL33
+#include <utilities/olcUTIL_Hardware3D.h>
+#include <olcPixelGameEngine.h>
+
+
+
+class Quad3D : public olc::PixelGameEngine
+{
+public:
+	Quad3D()
+	{
+		sAppName = "Hardware3D Assetless Demo";
+	}
+
+	olc::mf4d matWorld;
+	olc::mf4d matView;
+	olc::mf4d matProject;
+	
+	olc::Renderable texCube;
+	olc::utils::hw3d::mesh meshCube;
+	olc::utils::hw3d::mesh meshLightCube;
+
+	std::array<olc::vf3d, 64> cubes;
+	std::array<olc::vf3d, 3> lights;
+
+public:
+	bool OnUserCreate() override
+	{
+		float fAspect = float(GetScreenSize().y) / float(GetScreenSize().x);
+		float S = 1.0f / (tan(3.14159f * 0.25f));
+		float f = 1000.0f;
+		float n = 0.1f;
+
+		matProject(0, 0) = fAspect;	 matProject(0, 1) = 0.0f; matProject(0, 2) = 0.0f;	               matProject(0, 3) = 0.0f;
+		matProject(1, 0) = 0.0f; matProject(1, 1) = 1;    matProject(1, 2) = 0.0f;                 matProject(1, 3) = 0.0f;
+		matProject(2, 0) = 0.0f; matProject(2, 1) = 0.0f; matProject(2, 2) = -(f / (f - n));       matProject(2, 3) = -1.0f;
+		matProject(3, 0) = 0.0f; matProject(3, 1) = 0.0f; matProject(3, 2) = -((f * n) / (f - n)); matProject(3, 3) = 0.0f;
+
+		matWorld.identity();
+		matView.identity();
+
+		// Create a unit cube, centered on origin
+		meshCube = olc::utils::hw3d::CreateCube({ 1,1,1 }, {-0.5, -0.5, -0.5});
+
+		// Creat another cube, smaller
+		meshLightCube = olc::utils::hw3d::CreateCube({ 0.5,0.5,0.5 }, { -0.25, -0.25, -0.25 });
+
+		// Why 2 cubes? the regular ones will have their vertex information recoloured
+
+		// Create texture (so we dont need to load anything)
+		texCube.Create(128, 128);
+		SetDrawTarget(texCube.Sprite());
+		Clear(olc::WHITE);
+		FillCircle(64, 64, 32, olc::BLACK);
+		FillCircle(64, 64, 24, olc::BLUE);
+		FillCircle(64, 64, 16, olc::RED);
+		FillCircle(64, 64, 8, olc::YELLOW);
+		SetDrawTarget(nullptr);
+		texCube.Decal()->Update();
+
+		// Position cubes nicely
+		for(int x=0; x<8; x++)
+			for (int y = 0; y < 8; y++)
+			{
+				float z = sin(float(x)) + cos(float(y));
+				cubes[y * 8 + x] = { float(x) - 4.0f, float(z), float(y) - 4.0f };
+			}
+
+
+		Clear(olc::VERY_DARK_BLUE);
+		HW3D_Projection(matProject.m);
+		HW3D_SetCullMode(olc::CullMode::CCW);
+		return true;
+	}
+
+	float fThetaX = 1;
+	float fThetaY = 2;
+
+	float fLightTime = 0.0f;
+
+
+	bool OnUserUpdate(float fElapsedTime) override
+	{
+		// spin stuff
+		fThetaX += fElapsedTime * 0.1f;
+		fThetaY += fElapsedTime * 0.05f;
+		
+		olc::mf4d m1, m2, m3, m4;
+
+		// fake a pseudo-view matrix by transforming in an identity view
+		m1.rotateY(fThetaY);
+		m2.rotateX(fThetaX);
+		m3.translate(0.0, 0.0, -10.0);
+		matView = m3 * m2 * m1;
+
+		// Clear background
+		ClearBuffer(olc::CYAN, true);
+		
+		// Update light positions
+		fLightTime += fElapsedTime;
+		lights[0] = { 6.0f * sin(fLightTime * 2.5f), 6.0f * cos(fLightTime * 2.5f), 0.0f };
+		lights[1] = { 0.0f, 6.0f * sin(fLightTime), 6.0f * cos(fLightTime) };
+		lights[2] = { 6.0f * cos(fLightTime * 1.7f), 0.0f, 6.0f * sin(fLightTime * 1.7f) };
+		
+		// World Space lighting! The 3 lights are used as directional light sources
+		// so i dont need to pre-compute all the geometry on the CPU. This is a 
+		// limitation of the hw3d approach but like I said, its for basic 3D usage.
+		for (size_t i = 0; i < meshCube.pos.size(); i += 3)
+		{
+			const auto& p0 = meshCube.pos[i + 0];
+			const auto& p1 = meshCube.pos[i + 1];
+			const auto& p2 = meshCube.pos[i + 2];
+
+			// Hand calculate surface normal (i know i know the norms are already there...)
+			olc::vf3d vCross = olc::vf3d(p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2]).cross(olc::vf3d(p2[0] - p0[0], p2[1] - p0[1], p2[2] - p0[2])).norm();
+
+			// Additive colouring
+			meshCube.col[i + 0] = olc::BLACK;
+			meshCube.col[i + 1] = olc::BLACK;
+			meshCube.col[i + 2] = olc::BLACK;
+
+			olc::Pixel c[] = { olc::RED, olc::GREEN, olc::BLUE };
+			for (int j = 0; j < 3; j++)
+			{
+				olc::vf3d vLight = -lights[j].norm();
+				float illum = std::max(-vCross.dot(vLight), 0.0f) * 0.8f + 0.2f;
+				meshCube.col[i + 0] += olc::PixelF(illum, illum, illum, 1.0f) * c[j];
+				meshCube.col[i + 1] += olc::PixelF(illum, illum, illum, 1.0f) * c[j];
+				meshCube.col[i + 2] += olc::PixelF(illum, illum, illum, 1.0f) * c[j];
+			}
+		}
+
+
+		// Draw all cubes
+		for (const auto& cube : cubes)
+		{
+			matWorld.translate(cube);
+			HW3D_DrawObject((matView * matWorld).m, texCube.Decal(), meshCube.layout, meshCube.pos, meshCube.uv, meshCube.col);
+		}
+
+		// Draw light cubes
+		matWorld.translate(lights[0]);
+		HW3D_DrawObject((matView * matWorld).m, nullptr, meshLightCube.layout, meshLightCube.pos, meshLightCube.uv, meshLightCube.col, olc::RED);
+		matWorld.translate(lights[1]);
+		HW3D_DrawObject((matView * matWorld).m, nullptr, meshLightCube.layout, meshLightCube.pos, meshLightCube.uv, meshLightCube.col, olc::GREEN);
+		matWorld.translate(lights[2]);
+		HW3D_DrawObject((matView * matWorld).m, nullptr, meshLightCube.layout, meshLightCube.pos, meshLightCube.uv, meshLightCube.col, olc::BLUE);
+		return true;
+	}
+};
+
+int main()
+{
+	Quad3D demo;
+	if (demo.Construct(1280, 720, 1, 1, false, false))
+		demo.Start();
+	return 0;
+}

olcPixelGameEngine.h

@@ -1204,6 +1204,7 @@ namespace olc
 				0, 0, 0, 1
 			} };
 		olc::CullMode cull = olc::CullMode::NONE;
+		olc::Pixel tint = olc::WHITE;
 	};
 
 	struct LayerDesc
@@ -1764,6 +1765,7 @@ namespace olc
 	typedef void CALLSTYLE locUniform1f_t(GLint location, GLfloat v0);
 	typedef void CALLSTYLE locUniform1i_t(GLint location, GLint v0);
 	typedef void CALLSTYLE locUniform2fv_t(GLint location, GLsizei count, const GLfloat* value);
+	typedef void CALLSTYLE locUniform4fv_t(GLint location, GLsizei count, const GLfloat* value);
 	typedef void CALLSTYLE locUniformMatrix4fv_t(GLint location, GLsizei count, GLboolean trasnpose, const GLfloat* value);
 	typedef void CALLSTYLE locActiveTexture_t(GLenum texture);
 	typedef void CALLSTYLE locGenFrameBuffers_t(GLsizei n, GLuint* ids);
@@ -3535,6 +3537,7 @@ namespace olc
 		task.depth = bHW3DDepthTest;
 		task.cull = nHW3DCullMode;
 		task.mvp = matModelView;
+		task.tint = tint;
 		task.vb.resize(pos.size());
 
 		for (size_t i = 0; i < pos.size(); i++)
@@ -3552,6 +3555,7 @@ namespace olc
 		task.depth = bHW3DDepthTest;
 		task.cull = nHW3DCullMode;
 		task.mvp = matModelView;
+		task.tint = olc::WHITE;
 		task.vb =
 		{
 			{ pos1[0], pos1[1], pos1[2], 1.0f, 0.0f, 0.0f, col.n},
@@ -3570,6 +3574,7 @@ namespace olc
 		task.depth = bHW3DDepthTest;
 		task.cull = nHW3DCullMode;
 		task.mvp = matModelView;
+		task.tint = olc::WHITE;
 
 		const float ox = pos[0];
 		const float oy = pos[1];
@@ -5453,42 +5458,24 @@ namespace olc
 			//                           x      y      z      w      u      v       rgb
 			//std::vector<std::tuple<float, float, float, float, float, float, uint32_t>> vb;
 
+			float f[4] = { float(task.tint.r) / 255.0f, float(task.tint.g) / 255.0f, float(task.tint.b) / 255.0f, float(task.tint.a) / 255.0f };
+
 			if (task.depth)
 			{
-
-				//// Render as 3D Spatial Entity
-				//for (uint32_t n = 0; n < decal.points; n++)
-				//{
-				//	glColor4ub(decal.tint[n].r, decal.tint[n].g, decal.tint[n].b, decal.tint[n].a);
-				//	glTexCoord4f(decal.uv[n].x, decal.uv[n].y, 0.0f, decal.w[n]);
-				//	glVertex3f(decal.pos[n].x, decal.pos[n].y, decal.z[n]);
-				//}
-
 				for (uint32_t n = 0; n < task.vb.size(); n++)
 				{
 					olc::Pixel p = task.vb[n].c;
-					glColor4ub(p.r, p.g, p.b, p.a);
+					glColor4ub(GLubyte(p.r * f[0]), GLubyte(p.g * f[1]), GLubyte(p.b * f[2]), GLubyte(p.a * f[3]));
 					glTexCoord2f(task.vb[n].p[4], task.vb[n].p[5]);
 					glVertex4f(task.vb[n].p[0], task.vb[n].p[1], task.vb[n].p[2], task.vb[n].p[3]);
 				}
 			}
 			else
 			{
-
-
-				//// Render as 2D Spatial entity
-				//for (uint32_t n = 0; n < task.vb.size(); n++)
-				//{
-				//	olc::Pixel p = std::get<6>(task.vb[n]);
-				//	glColor4ub(p.r, p.g, p.b, p.a);
-				//	glTexCoord4f(std::get<4>(task.vb[n]), std::get<5>(task.vb[n]), 0.0f, std::get<3>(task.vb[n]));
-				//	glVertex2f(std::get<0>(task.vb[n]), std::get<1>(task.vb[n]));
-				//}
-
 				for (uint32_t n = 0; n < task.vb.size(); n++)
 				{
 					olc::Pixel p = task.vb[n].c;
-					glColor4ub(p.r, p.g, p.b, p.a);
+					glColor4ub(GLubyte(p.r * f[0]), GLubyte(p.g * f[1]), GLubyte(p.b * f[2]), GLubyte(p.a * f[3]));
 					glVertex4f(task.vb[n].p[4], task.vb[n].p[5], 0.0f, task.vb[n].p[3]);
 					glTexCoord2f(task.vb[n].p[0], task.vb[n].p[1]);
 				}
@@ -5724,6 +5711,7 @@ namespace olc
 		locGetUniformLocation_t* locGetUniformLocation = nullptr;
 		locUniformMatrix4fv_t* locUniformMatrix4fv = nullptr;
 		locUniform1i_t* locUniform1i = nullptr;
+		locUniform4fv_t* locUniform4fv = nullptr;
 
 		uint32_t m_nFS = 0;
 		uint32_t m_nVS = 0;
@@ -5733,6 +5721,7 @@ namespace olc
 
 		uint32_t m_uniMVP = 0;
 		uint32_t m_uniIs3D = 0;
+		uint32_t m_uniTint = 0;
 
 		struct locVertex
 		{
@@ -5871,6 +5860,7 @@ namespace olc
 			locUseProgram = OGL_LOAD(locUseProgram_t, glUseProgram);
 			locGetShaderInfoLog = OGL_LOAD(locGetShaderInfoLog_t, glGetShaderInfoLog);
 			locUniform1i = OGL_LOAD(locUniform1i_t, glUniform1i);
+			locUniform4fv = OGL_LOAD(locUniform4fv_t, glUniform4fv);
 			locUniformMatrix4fv = OGL_LOAD(locUniformMatrix4fv_t, glUniformMatrix4fv);
 			locGetUniformLocation = OGL_LOAD(locGetUniformLocation_t, glGetUniformLocation);
 #if !defined(OLC_PLATFORM_EMSCRIPTEN)
@@ -5911,9 +5901,10 @@ namespace olc
 				"layout(location = 2) in vec4 aCol;\n"
 				"uniform mat4 mvp;\n"
 				"uniform int is3d;\n"
+				"uniform vec4 tint;\n"
 				"out vec2 oTex;\n"
 				"out vec4 oCol;\n"
-				"void main(){ if(is3d!=0) {gl_Position = mvp * vec4(aPos.x, aPos.y, aPos.z, 1.0); oTex = aTex;} else {float p = 1.0 / aPos.z; gl_Position = p * vec4(aPos.x, aPos.y, 0.0, 1.0); oTex = p * aTex;} oCol = aCol;}";
+				"void main(){ if(is3d!=0) {gl_Position = mvp * vec4(aPos.x, aPos.y, aPos.z, 1.0); oTex = aTex;} else {float p = 1.0 / aPos.z; gl_Position = p * vec4(aPos.x, aPos.y, 0.0, 1.0); oTex = p * aTex;} oCol = aCol * tint;}";
 			locShaderSource(m_nVS, 1, &strVS, NULL);
 			locCompileShader(m_nVS);
 
@@ -5924,8 +5915,11 @@ namespace olc
 
 			m_uniMVP = locGetUniformLocation(m_nQuadShader, "mvp");
 			m_uniIs3D = locGetUniformLocation(m_nQuadShader, "is3d");
+			m_uniTint = locGetUniformLocation(m_nQuadShader, "tint");
 			locUniform1i(m_uniIs3D, 0);
-			locUniformMatrix4fv(m_uniMVP, 1, false, matProjection.data());
+			locUniformMatrix4fv(m_uniMVP, 16, false, matProjection.data());
+			float f[4] = { 100.0f, 100.0f, 100.0f, 100.0f };
+			locUniform4fv(m_uniTint, 4, f);
 
 			// Create Quad
 			locGenBuffers(1, &m_vbQuad);
@@ -6002,6 +5996,8 @@ namespace olc
 			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 			locUseProgram(m_nQuadShader);
 			locBindVertexArray(m_vaQuad);
+			float f[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+			locUniform4fv(m_uniTint, 1, f);
 
 #if defined(OLC_PLATFORM_EMSCRIPTEN)
 			locVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(locVertex), 0); locEnableVertexAttribArray(0);
@@ -6047,6 +6043,8 @@ namespace olc
 			locBufferData(0x8892, sizeof(locVertex) * 4, verts, 0x88E0);
 
 			locUniform1i(m_uniIs3D, 0);
+			float f[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+			locUniform4fv(m_uniTint, 1, f);
 			glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 		}
 
@@ -6066,6 +6064,10 @@ namespace olc
 
 			locBufferData(0x8892, sizeof(locVertex) * decal.points, pVertexMem, 0x88E0);
 			locUniform1i(m_uniIs3D, 0);
+
+			float f[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+			locUniform4fv(m_uniTint, 1, f);
+
 			if (nDecalMode == DecalMode::WIREFRAME)
 				glDrawArrays(GL_LINE_LOOP, 0, decal.points);
 			else
@@ -6186,6 +6188,9 @@ namespace olc
 					+ matProjection[3 * 4 + r] * task.mvp[c * 4 + 3];
 			locUniformMatrix4fv(m_uniMVP, 1, false, matMVP.data());
 
+			float f[4] = { float(task.tint.r) / 255.0f, float(task.tint.g) / 255.0f, float(task.tint.b) / 255.0f, float(task.tint.a) / 255.0f };
+			locUniform4fv(m_uniTint, 1, f);
+
 
 			if (task.cull == olc::CullMode::NONE)
 			{