refactor(gfx): refactored material attributes

tomezpl · tomezpl · commit e60ee39a3244 · 2024-10-26T16:16:39.000+01:00
diff --git a/Content/GLSL/Unlit/SolidColour.frag b/Content/GLSL/Unlit/SolidColour.frag
@@ -0,0 +1,9 @@
+#version 330
+
+out vec4 color;
+
+uniform vec3 colour;
+
+void main() {
+    color = vec4(colour, 1.0);
+}
diff --git a/Content/GLSL/Unlit/SolidColour.vert b/Content/GLSL/Unlit/SolidColour.vert
@@ -0,0 +1,11 @@
+#version 330
+
+uniform mat4 VIEW;
+uniform mat4 MODEL;
+uniform mat4 PROJ;
+
+layout(location = 0) in vec3 position;
+
+void main() {
+    gl_Position = PROJ * VIEW * MODEL * vec4(position, 1.0);
+}
diff --git a/src/examples/demo/DemoApp.h b/src/examples/demo/DemoApp.h
@@ -135,19 +135,30 @@ class DemoApp : public system::BaseApp
 	engine::ConsoleLogger::Global().LogInfo("", "main", "Demo starting!");
 
 	// Load & compile shaders.
-	std::string vertShaderSrc = system::FileSystem::Read("../../Content/GLSL/Unlit/RGBVertex.vert"), fragShaderSrc = system::FileSystem::Read("../../Content/GLSL/Unlit/RGBVertex.frag");
+	std::string
+	    vertShaderSrc = system::FileSystem::Read("../../Content/GLSL/Unlit/RGBVertex.vert"),
+	    fragShaderSrc = system::FileSystem::Read("../../Content/GLSL/Unlit/RGBVertex.frag"),
+	    vertShaderSrc2 = system::FileSystem::Read("../../Content/GLSL/Unlit/SolidColour.vert"),
+	    fragShaderSrc2 = system::FileSystem::Read("../../Content/GLSL/Unlit/SolidColour.frag");
 	gfx::ShaderCompiledResult
 	    vertShader = gfx::ShaderCompilerGLSL::Singleton().CompileShader(vertShaderSrc.c_str(), vertShaderSrc.length(), gfx::VertexShader),
-	    fragShader = gfx::ShaderCompilerGLSL::Singleton().CompileShader(fragShaderSrc.c_str(), fragShaderSrc.length(), gfx::FragmentShader);
+	    fragShader = gfx::ShaderCompilerGLSL::Singleton().CompileShader(fragShaderSrc.c_str(), fragShaderSrc.length(), gfx::FragmentShader),
+	    vertShader2 = gfx::ShaderCompilerGLSL::Singleton().CompileShader(vertShaderSrc2.c_str(), vertShaderSrc2.length(), gfx::VertexShader),
+	    fragShader2 = gfx::ShaderCompilerGLSL::Singleton().CompileShader(fragShaderSrc2.c_str(), fragShaderSrc2.length(), gfx::FragmentShader);
 
 	// Register shader with the API.
 	auto& api = engine.GetApi<gfx::GraphicsApiGL>();
 	api.GetSceneGraph().SetCamera(&m_Camera);
 
-	lepus::gfx::Material baseMaterial;
-	lepus::gfx::GLShader baseShader(lepus::gfx::ShaderInfo("RGBVertex"));
+	lepus::gfx::Material baseMaterial, otherMaterial;
+	lepus::gfx::GLShader baseShader(lepus::gfx::ShaderInfo("RGBVertex")), redShader(lepus::gfx::ShaderInfo("SolidColour"));
 	baseShader.SetGLProgram(gfx::ShaderCompilerGLSL::Singleton().BuildProgram(vertShader, fragShader));
+	redShader.SetGLProgram(gfx::ShaderCompilerGLSL::Singleton().BuildProgram(vertShader2, fragShader2));
 	baseMaterial.SetShader(&baseShader);
+	otherMaterial.SetShader(&redShader);
+
+	types::Vector3 baseColour(1.f, 1.f, 1.f);
+	auto baseColourIndex = otherMaterial.Attributes().Add<const types::Vector3&>("colour", baseColour);
 
 	// Set up engine for drawing.
 	engine.Setup();
@@ -156,8 +167,8 @@ class DemoApp : public system::BaseApp
 	// Instantiate two Renderables in the scene graph, each with its own transform, using the same cube mesh data.
 	auto cubeMesh = lepus::gfx::GLMesh(lepus::utility::Primitives::Cube());
 	auto cube = lepus::gfx::Renderable<lepus::gfx::GLMesh>(&cubeMesh, lepus::math::Transform(), baseMaterial);
-	auto cube2 = lepus::gfx::Renderable<lepus::gfx::GLMesh>(&cubeMesh, lepus::math::Transform(), baseMaterial);
-	auto cube3 = lepus::gfx::Renderable<lepus::gfx::GLMesh>(&cubeMesh, lepus::math::Transform(), baseMaterial);
+	auto cube2 = lepus::gfx::Renderable<lepus::gfx::GLMesh>(&cubeMesh, lepus::math::Transform(), otherMaterial);
+	auto cube3 = lepus::gfx::Renderable<lepus::gfx::GLMesh>(&cubeMesh, lepus::math::Transform(), otherMaterial);
 	auto cube4 = lepus::gfx::Renderable<lepus::gfx::GLMesh>(&cubeMesh, lepus::math::Transform(), baseMaterial);
 
 	cube.GetTransform()->Origin(lepus::types::Vector3(0.f, 0.f, -2.f));
@@ -176,14 +187,14 @@ class DemoApp : public system::BaseApp
 
 	auto cubeNode = api.GetSceneGraph().AddChild(&cube);
 
+	auto window = static_cast<GLFWwindow*>(windowing->GetWindowPtr());
+
 	// Initialise the FOV variable and set up a callback so we can let the user adjust it with the mouse scroll wheel.
 	m_FOV = m_Camera.FOV();
-	glfwSetScrollCallback(reinterpret_cast<GLFWwindow*>(windowing->GetWindowPtr()), DemoAppGLFWCallbacks::scroll);
+	glfwSetScrollCallback(window, DemoAppGLFWCallbacks::scroll);
 
 	float runningTime = glfwGetTime();
 
-	GLFWwindow* window = reinterpret_cast<GLFWwindow*>(windowing->GetWindowPtr());
-
 	// Set up mouse input for camera freelook.
 	glfwGetCursorPos(window, &m_MouseState.lastX, &m_MouseState.lastY);
 	glfwSetCursorPosCallback(reinterpret_cast<GLFWwindow*>(windowing->GetWindowPtr()), DemoAppGLFWCallbacks::cursorPos);
@@ -220,6 +231,12 @@ class DemoApp : public system::BaseApp
 	    Tick(deltaTime, keys);
 	    UpdateUniforms(&api);
 
+	    baseColour.x(sinf(runningTime));
+	    baseColour.y(cosf(runningTime));
+	    baseColour.z(baseColour.x() * baseColour.y());
+
+	    otherMaterial.Attributes().Set<const types::Vector3&>(baseColourIndex, baseColour);
+
 	    engine.Render<unsigned char, gfx::GraphicsEngine::PixelFormat::RGBA32>(100, 149, 237);
 
 	    float newRunningTime = glfwGetTime();
diff --git a/src/lepus/gfx/GraphicsEngine/Apis/ApiGL.h b/src/lepus/gfx/GraphicsEngine/Apis/ApiGL.h
@@ -137,7 +137,7 @@ namespace lepus
 
 	    void UpdateUniforms() override;
 
-	    void UpdateUniforms(const GLRenderable* renderable, const MaterialAttributes& materialAttribs, GLuint program, const lepus::math::Matrix4x4& worldMatrix);
+	    void UpdateUniforms(const GLRenderable* renderable, MaterialAttributes& materialAttribs, GLuint program, const lepus::math::Matrix4x4& worldMatrix);
 
 	    inline GLSceneGraph& GetSceneGraph()
 	    {
diff --git a/src/lepus/gfx/GraphicsEngine/Apis/ApiGL/ApiGL.cpp b/src/lepus/gfx/GraphicsEngine/Apis/ApiGL/ApiGL.cpp
@@ -55,7 +55,7 @@ void GraphicsApiGL::UpdateUniforms()
     // TODO: this method should only update "global" uniforms that aren't specific to any renderable in particular.
 }
 
-void GraphicsApiGL::UpdateUniforms(const GLRenderable* const renderable, const MaterialAttributes& materialAttribs, const GLuint program, const lepus::math::Matrix4x4& worldMatrix)
+void GraphicsApiGL::UpdateUniforms(const GLRenderable* const renderable, MaterialAttributes& materialAttribs, const GLuint program, const lepus::math::Matrix4x4& worldMatrix)
 {
     auto cam = m_Scene.Camera();
     auto proj = cam->BuildPerspectiveMatrix();
@@ -111,6 +111,9 @@ void GraphicsApiGL::UpdateUniforms(const GLRenderable* const renderable, const M
 	case lepus::gfx::UniformType::FLOAT:
 	    glUniform1f(location, materialAttribs.Get<GLfloat>(i));
 	    break;
+	case lepus::gfx::UniformType::VEC3:
+	    glUniform3fv(location, 1, materialAttribs.Get<GLfloat*>(i));
+	    break;
 	case lepus::gfx::UniformType::INVALID:
 	default:
 	    break;
@@ -130,7 +133,7 @@ void GraphicsApiGL::Draw()
     {
 	if (!branchComplete && !currentNode->IsRoot())
 	{
-	    auto renderable = (const GLRenderable*)(currentNode->GetTransformable());
+	    auto renderable = (GLRenderable*)(currentNode->GetTransformable());
 	    auto material = renderable->GetMaterial();
 	    if (renderable)
 	    {
diff --git a/src/lepus/gfx/GraphicsEngine/GraphicsApi/Uniforms.h b/src/lepus/gfx/GraphicsEngine/GraphicsApi/Uniforms.h
@@ -10,6 +10,7 @@ namespace lepus
 	    INVALID = 0,
 	    MATRIX4,
 	    FLOAT,
+	    VEC3
 	};
 
 #pragma region Engine global uniform names
diff --git a/src/lepus/gfx/Material.h b/src/lepus/gfx/Material.h
@@ -37,7 +37,7 @@ namespace lepus
 		m_Shader = shader;
 	    }
 
-	    [[nodiscard]] const lepus::gfx::MaterialAttributes& Attributes() const
+	    [[nodiscard]] lepus::gfx::MaterialAttributes& Attributes()
 	    {
 		return m_Attributes;
 	    }
diff --git a/src/lepus/gfx/Material/MaterialAttributes.h b/src/lepus/gfx/Material/MaterialAttributes.h
@@ -71,6 +71,7 @@ namespace lepus
 		m_AttribCount = 0;
 		m_AttribNames = nullptr;
 		m_AttribValues = nullptr;
+		m_AttribTypes = nullptr;
 	    }
 
 	    /// @brief Adds an attribute and returns its index.
@@ -80,9 +81,11 @@ namespace lepus
 		this->_EnsureCapacity(1);
 
 		size_t numChars = strlen(name);
-		m_AttribNames[m_AttribCount] = new char[numChars];
+		m_AttribNames[m_AttribCount] = new char[numChars + 1];
+		memset((void*)m_AttribNames[m_AttribCount], 0, sizeof(char) * (numChars + 1));
 		memcpy((void*)m_AttribNames[m_AttribCount], name, numChars);
-		m_AttribValues[m_AttribValues] = value;
+
+		Set<TValue>(m_AttribCount, value);
 
 		return m_AttribCount++;
 	    }
@@ -105,31 +108,53 @@ namespace lepus
 	    template <>
 	    inline void Set<const lepus::math::Matrix4x4&>(uint8_t index, const lepus::math::Matrix4x4& value)
 	    {
+		// Clear existing data
+		if (m_AttribTypes[index] == UniformType::MATRIX4)
+		{
+		    delete[] static_cast<float*>(m_AttribValues[index]);
+		}
+
+		m_AttribValues[index] = new float[4 * 4];
+
 		m_AttribTypes[index] = UniformType::MATRIX4;
 		memcpy((void*)m_AttribValues[index], value.data(), sizeof(float) * 4 * 4);
 	    }
 
+	    template <>
+	    inline void Set<const lepus::types::Vector3&>(uint8_t index, const lepus::types::Vector3& value)
+	    {
+		if (m_AttribTypes[index] == UniformType::VEC3)
+		{
+		    delete[] static_cast<float*>(m_AttribValues[index]);
+		}
+
+		m_AttribValues[index] = new float[3];
+
+		m_AttribTypes[index] = UniformType::VEC3;
+		memcpy((void*)m_AttribValues[index], value.GetData(), sizeof(float) * 3);
+	    }
+
 	    template <typename TValue = void*>
 	    inline TValue Get(uint8_t index) const
 	    {
 		assert(index < m_AttribCount);
 
-		return m_AttribValues[index];
+		return (TValue)(m_AttribValues[index]);
 	    }
 
-	    inline const char* GetName(uint8_t index) const
+	    [[nodiscard]] inline const char* GetName(uint8_t index) const
 	    {
 		assert(index < m_AttribCount);
 
 		return m_AttribNames[index];
 	    }
 
-	    inline const uint8_t Count() const
+	    [[nodiscard]] inline const uint8_t Count() const
 	    {
 		return m_AttribCount;
 	    }
 
-	    inline const UniformType GetType(uint8_t index) const
+	    [[nodiscard]] inline const UniformType GetType(uint8_t index) const
 	    {
 		return m_AttribTypes[index];
 	    }
@@ -164,6 +189,12 @@ namespace lepus
 
 	    return mat;
 	}
+
+	template <>
+	inline void MaterialAttributes::Set<const float* const>(uint8_t index, const float* const value)
+	{
+	    memcpy(m_AttribValues[index], value, sizeof(value));
+	}
     } // namespace gfx
 } // namespace lepus
 
diff --git a/src/lepus/gfx/SceneGraph/Renderable.h b/src/lepus/gfx/SceneGraph/Renderable.h
@@ -17,7 +17,7 @@ namespace lepus
 	{
 	    private:
 	    const MeshType* m_Mesh;
-	    const Material* m_Material;
+	    Material* m_Material;
 	    bool m_OwnsMaterial;
 
 	    public:
@@ -36,7 +36,7 @@ namespace lepus
 		}
 	    }
 
-	    Renderable(const MeshType* mesh, lepus::math::Transform& transform, const Material& material)
+	    Renderable(const MeshType* mesh, lepus::math::Transform& transform, Material& material)
 	        : Renderable(mesh, transform, false)
 	    {
 		m_Material = &material;
@@ -56,7 +56,7 @@ namespace lepus
 		}
 	    }
 
-	    Renderable(const MeshType* mesh, lepus::math::Transform&& transform, const Material& material)
+	    Renderable(const MeshType* mesh, lepus::math::Transform&& transform, Material& material)
 	        : Renderable(mesh, transform, false)
 	    {
 		m_Material = &material;
@@ -85,7 +85,7 @@ namespace lepus
 		return m_Mesh;
 	    }
 
-	    [[nodiscard]] const Material* GetMaterial() const
+	    [[nodiscard]] Material* const GetMaterial()
 	    {
 		return m_Material;
 	    }

Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ namespace lepus`
`137`	`137`
`138`	`138`	`void UpdateUniforms() override;`
`139`	`139`
`140`		`- void UpdateUniforms(const GLRenderable* renderable, const MaterialAttributes& materialAttribs, GLuint program, const lepus::math::Matrix4x4& worldMatrix);`
	`140`	`+ void UpdateUniforms(const GLRenderable* renderable, MaterialAttributes& materialAttribs, GLuint program, const lepus::math::Matrix4x4& worldMatrix);`
`141`	`141`
`142`	`142`	`inline GLSceneGraph& GetSceneGraph()`
`143`	`143`	`{`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ void GraphicsApiGL::UpdateUniforms()`
`55`	`55`	`// TODO: this method should only update "global" uniforms that aren't specific to any renderable in particular.`
`56`	`56`	`}`
`57`	`57`
`58`		`-void GraphicsApiGL::UpdateUniforms(const GLRenderable* const renderable, const MaterialAttributes& materialAttribs, const GLuint program, const lepus::math::Matrix4x4& worldMatrix)`
	`58`	`+void GraphicsApiGL::UpdateUniforms(const GLRenderable* const renderable, MaterialAttributes& materialAttribs, const GLuint program, const lepus::math::Matrix4x4& worldMatrix)`
`59`	`59`	`{`
`60`	`60`	`auto cam = m_Scene.Camera();`
`61`	`61`	`auto proj = cam->BuildPerspectiveMatrix();`
`@@ -111,6 +111,9 @@ void GraphicsApiGL::UpdateUniforms(const GLRenderable* const renderable, const M`
`111`	`111`	`case lepus::gfx::UniformType::FLOAT:`
`112`	`112`	`glUniform1f(location, materialAttribs.Get<GLfloat>(i));`
`113`	`113`	`break;`
	`114`	`+ case lepus::gfx::UniformType::VEC3:`
	`115`	`+ glUniform3fv(location, 1, materialAttribs.Get<GLfloat*>(i));`
	`116`	`+ break;`
`114`	`117`	`case lepus::gfx::UniformType::INVALID:`
`115`	`118`	`default:`
`116`	`119`	`break;`
`@@ -130,7 +133,7 @@ void GraphicsApiGL::Draw()`
`130`	`133`	`{`
`131`	`134`	`if (!branchComplete && !currentNode->IsRoot())`
`132`	`135`	`{`
`133`		`- auto renderable = (const GLRenderable*)(currentNode->GetTransformable());`
	`136`	`+ auto renderable = (GLRenderable*)(currentNode->GetTransformable());`
`134`	`137`	`auto material = renderable->GetMaterial();`
`135`	`138`	`if (renderable)`
`136`	`139`	`{`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ namespace lepus`
`37`	`37`	`m_Shader = shader;`
`38`	`38`	`}`
`39`	`39`
`40`		`- [[nodiscard]] const lepus::gfx::MaterialAttributes& Attributes() const`
	`40`	`+ [[nodiscard]] lepus::gfx::MaterialAttributes& Attributes()`
`41`	`41`	`{`
`42`	`42`	`return m_Attributes;`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ namespace lepus`
`17`	`17`	`{`
`18`	`18`	`private:`
`19`	`19`	`const MeshType* m_Mesh;`
`20`		`- const Material* m_Material;`
	`20`	`+ Material* m_Material;`
`21`	`21`	`bool m_OwnsMaterial;`
`22`	`22`
`23`	`23`	`public:`
`@@ -36,7 +36,7 @@ namespace lepus`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`39`		`- Renderable(const MeshType* mesh, lepus::math::Transform& transform, const Material& material)`
	`39`	`+ Renderable(const MeshType* mesh, lepus::math::Transform& transform, Material& material)`
`40`	`40`	`: Renderable(mesh, transform, false)`
`41`	`41`	`{`
`42`	`42`	`m_Material = &material;`
`@@ -56,7 +56,7 @@ namespace lepus`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`- Renderable(const MeshType* mesh, lepus::math::Transform&& transform, const Material& material)`
	`59`	`+ Renderable(const MeshType* mesh, lepus::math::Transform&& transform, Material& material)`
`60`	`60`	`: Renderable(mesh, transform, false)`
`61`	`61`	`{`
`62`	`62`	`m_Material = &material;`
`@@ -85,7 +85,7 @@ namespace lepus`
`85`	`85`	`return m_Mesh;`
`86`	`86`	`}`
`87`	`87`
`88`		`- [[nodiscard]] const Material* GetMaterial() const`
	`88`	`+ [[nodiscard]] Material* const GetMaterial()`
`89`	`89`	`{`
`90`	`90`	`return m_Material;`
`91`	`91`	`}`