Reworked material

CMakeLists.txt

@@ -4,7 +4,7 @@ project(OpenGLUtility)
 
 set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-# set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 17)
 
 set(BUILD_EXAMPLES ON CACHE BOOL "Build examples")
 set(BUILD_DOCUMENTATION ON CACHE BOOL "Generate documentation")
@@ -33,13 +33,11 @@ file(GLOB_RECURSE source_files
 	"vendor/src/*.c"
 )
 
-message(STATUS ${source_files})
-
 add_library(openglu SHARED 
 	${include_files}
 	${source_files}
 	"cpp.hint"
-)
+ "src/core.cpp")
 
 target_compile_definitions(openglu PRIVATE OGLU_BUILD_DLL)
 

examples/movement/main.cpp

@@ -184,6 +184,12 @@ int main(int argc, char** argv)
 	// Make a square
 	oglu::VertexArray cubeDefault = oglu::MakeVertexArray(vertices, sizeof(vertices), nullptr, 0, topology, sizeof(topology));
 	oglu::SharedMaterial cubeMaterial(new oglu::Material);
+
+	//cubeMaterial->AddProperty("ambient", oglu::Color::White);
+	cubeMaterial->AddProperty("diffuse", oglu::Color::White);
+	cubeMaterial->AddProperty("specular", oglu::Color::White);
+	cubeMaterial->AddProperty("shininess", 32.f);
+
 	oglu::Object cubes[10] = { 
 		oglu::Object(cubeDefault),
 		oglu::Object(cubeDefault),
@@ -287,10 +293,10 @@ int main(int argc, char** argv)
 			shader->SetUniform("model", cube);
 			shader->SetUniformMatrix3fv("normal", 1, GL_FALSE, glm::value_ptr(cube.GetNormalMatrix()));
 
-			shader->SetUniform("material.ambient", cube.material->ambient, true);
+			shader->SetUniform("material.ambient", cube.material->GetPropertyValue<oglu::Color>("ambient"), true);
-			shader->SetUniform("material.diffuse", cube.material->diffuse, true);
+			shader->SetUniform("material.diffuse", cube.material->GetPropertyValue<oglu::Color>("diffuse"), true);
-			shader->SetUniform("material.specular", cube.material->specular, true);
+			shader->SetUniform("material.specular", cube.material->GetPropertyValue<oglu::Color>("specular"), true);
-			shader->SetUniform("material.shininess", cube.material->shininess);
+			shader->SetUniform("material.shininess", cube.material->GetPropertyValue<float>("shininess"));
 			cube.Render();
 		}
 
@@ -339,10 +345,10 @@ int main(int argc, char** argv)
 		ImGui::SetNextItemOpen(true, ImGuiCond_Once);
 		if (ImGui::CollapsingHeader("Cube Material"))
 		{
-			ImGui::ColorEdit3("Ambient", &(cubeMaterial->ambient.r));
+			ImGui::ColorEdit3("Ambient", &(cubeMaterial->GetProperty<oglu::Color>("ambient")->r));
-			ImGui::ColorEdit3("Diffuse", &(cubeMaterial->diffuse.r));
+			ImGui::ColorEdit3("Diffuse", &(cubeMaterial->GetProperty<oglu::Color>("diffuse")->r));
-			ImGui::ColorEdit3("Specular", &(cubeMaterial->specular.r));
+			ImGui::ColorEdit3("Specular", &(cubeMaterial->GetProperty<oglu::Color>("specular")->r));
-			ImGui::SliderFloat("Shininess", &(cubeMaterial->shininess), 1.0f, 256.0f);
+			ImGui::SliderFloat("Shininess", cubeMaterial->GetProperty<float>("shininess"), 1.0f, 256.0f);
 		}
 
 		ImGui::End();

include/core.hpp

@@ -12,12 +12,12 @@
 #pragma warning(disable : 4251)
 
 #include <memory>
+#include <iostream>
 #include <stdexcept>
 #include <string>
 
 #include <glad/glad.h>
 
-
 #ifdef OGLU_WIN32
 	#ifdef OGLU_BUILD_DLL
 		#define OGLU_API __declspec(dllexport)
@@ -28,4 +28,30 @@
 	#define OGLU_API
 #endif //OGLU_WIN32
 
+namespace oglu
+{
+	class NullBuffer : public std::streambuf
+	{
+	public:
+		int overflow(int c) { return c; }
+	};
+
+	class NullStream : public std::ostream
+	{
+	public:
+		NullStream() : std::ostream(&buf) {}
+
+	private:
+		NullBuffer buf;
+	};
+
+	extern OGLU_API NullStream cnull;
+}
+
+#ifndef NDEBUG
+	#define OGLU_ERROR_STREAM std::cerr
+#else
+	#define OGLU_ERROR_STREAM oglu::cnull
+#endif
+
 #endif

include/lighting/ambient.hpp

@@ -1,3 +1,10 @@
+/*****************************************************************//**
+ * @file   ambient.hpp
+ * @brief  Anything related to ambient/environmental lighting
+ * 
+ * @author Lauchmelder
+ * @date   January 2021
+ *********************************************************************/
 #ifndef AMBIENT_HPP
 #define AMBIENT_HPP
 
@@ -6,16 +13,46 @@
 
 namespace oglu
 {
+	/**
+	 * @brief A class holding information needed for ambient lighting.
+	 */
 	class OGLU_API AmbientLight
 	{
 	public:
+		/**
+		 * @brief Create default ambient light.
+		 * 
+		 * By default, this creates a white light at full intensity
+		 */
 		AmbientLight();
+
+		/**
+		 * @brief Create a custom ambient light.
+		 * 
+		 * @param r Red component
+		 * @param r Green component
+		 * @param r Blue component
+		 * @param intensity Intensity of the lighting
+		 */
 		AmbientLight(GLfloat r, GLfloat g, GLfloat b, GLfloat intensity);
+
+		/**
+		 * @brief Create a custom ambient light.
+		 *
+		 * @param color Color of the lighting
+		 * @param intensity Intensity of the lighting
+		 */
 		AmbientLight(const Color& color, GLfloat intensity);
+
+		/**
+		 * @brief Copy another ambient light.
+		 * 
+		 * @param other The light to copy from
+		 */
 		AmbientLight(const AmbientLight& other);
 
-		GLfloat intensity;
+		GLfloat intensity;	///< Intensity of the ambient light
-		Color color;
+		Color color;		///< Color of the ambient light
 	};
 }
 

include/lighting/point.hpp

@@ -1,3 +1,10 @@
+/*****************************************************************//**
+ * @file   point.hpp
+ * @brief  Anything related to point light sources
+ *
+ * @author Lauchmelder
+ * @date   January 2021
+ *********************************************************************/
 #ifndef POINT_HPP
 #define POINT_HPP
 
@@ -9,27 +16,74 @@ namespace oglu
 {
 	class Transformable;
 
+	/**
+	 * @brief A class containing things related to point lighting.
+	 */
 	class OGLU_API PointLight
 	{
 	public:
+		/**
+		 * @brief Create a default point light.
+		 * 
+		 * By default the diffusion and specular components are white and
+		 * the light is positioned at the world origin
+		 */
 		PointLight();
+
+		/**
+		 * @brief Create a new point light.
+		 * 
+		 * @param position Position of the light
+		 * @param diffusionColor Color of the diffusion component
+		 * @param specularColor Color of the specular component
+		 */
 		PointLight(const glm::vec3& position, const Color& diffusionColor = Color::White, const Color& specularColor = Color::White);
+		
+		/**
+		 * @brief Copy from another point light.
+		 * 
+		 * @param other The point light to copy from
+		 */
 		PointLight(const PointLight& other);
 
 		~PointLight();
 
+		/**
+		 * @brief Link the lights position to a Transformable.
+		 * 
+		 * It is possible to link the positions of a Transformable and
+		 * a PointLight. This means that these two objects will always
+		 * have the same position, until they are unlinked. Deleting a
+		 * Transformable before unlinking any linked PointLight causes
+		 * undefined behaviour.
+		 * 
+		 * @param link The Transformable to link to
+		 */
 		void LinkPositionToTransformable(Transformable& link);
+
+		/**
+		 * @brief Unlink a Transformable.
+		 * 
+		 * This breaks the link between the two objects.
+		 */
 		void UnlinkPositionFromTransformable();
+
+		/**
+		 * Get the lights position.
+		 * 
+		 * @returns A pointer to the lights position
+		 */
 		float* GetPositionPointer();
 
 	public:
-		Color diffusionColor;
+		// TODO: Does this split make sense? I'll keep it for now
-		Color specularColor;
+		Color diffusionColor;	///< Diffusion color of the light
+		Color specularColor;	///< Specular color of the light
 
 
 	private:
-		glm::vec3* position;
+		glm::vec3* position;	///< Position of the light
-		bool isLinked;
+		bool isLinked;			///< Wether the position is linked to an object or not
 	};
 }
 

include/material.hpp

@@ -0,0 +1,86 @@
+/*****************************************************************//**
+ * @file   material.hpp
+ * @brief  Anything related to materials
+ * 
+ * @author Lauchmelder
+ * @date   January 2021
+ *********************************************************************/
+#ifndef MATERIAL_HPP
+#define MATERIAL_HPP
+
+#include <map>
+#include <any>
+#include <iostream>
+#include <core.hpp>
+
+namespace oglu
+{
+	/**
+	 * @brief A structure representing an object's material.
+	 * 
+	 * This object is dynamic and can contain any data that you want
+	 */
+	class OGLU_API Material
+	{
+	public:
+		/**
+		 * @brief Adds a new material property.
+		 * 
+		 * @param name The name of the property
+		 * @param value The value of the property
+		 */
+		void AddProperty(const std::string& name, const std::any& value);
+
+		/**
+		 * @brief Remove the given property from the material.
+		 */
+		void RemoveProperty(const std::string& name);
+
+		/**
+		 * @brief Get a property from the material.
+		 * 
+		 * Should the material property not be present in the material this function
+		 * will attempt to add it, using the default constructor of the supplied class.
+		 * You should not rely on this failsafe working properly all the time.
+		 * 
+		 * @tparam T The type of the stores property
+		 * @param name The name of the property
+		 * @returns A pointer to the stored property
+		 */
+		template<typename T> T* GetProperty(const std::string& name, std::ostream& errorStream = OGLU_ERROR_STREAM)
+		{
+			std::map<std::string, std::any>::iterator it = properties.find(name);
+			if (it == properties.end())
+			{
+				errorStream << "Failed to locate material property \"" << name << "\" in " << static_cast<const void*>(this) << ". Trying to construct default property of type \"" << typeid(T).name() << "\" and add it to the material.\n";
+
+				it = properties.insert(std::make_pair(name, T())).first;
+			}
+
+			return std::any_cast<T>(&(it->second));
+		}
+
+		/**
+		 * @brief Get a property from the material.
+		 *
+		 * Should the material property not be present in the material this function
+		 * will attempt to add it, using the default constructor of the supplied class.
+		 * You should not rely on this failsafe working properly all the time.
+		 * 
+		 * @tparam T The type of the stores property
+		 * @param name The name of the property
+		 * @returns The value of the stored property
+		 */
+		template<typename T> inline T GetPropertyValue(const std::string& name, std::ostream& errorStream = OGLU_ERROR_STREAM)
+		{
+			return *(GetProperty<T>(name, errorStream));
+		}
+
+	private:
+		std::map<std::string, std::any> properties;
+	};
+
+	typedef std::shared_ptr<Material> SharedMaterial;	///< A material that can safely be shared between objects
+}
+
+#endif

include/object.hpp

@@ -15,18 +15,7 @@
 
 namespace oglu
 {
-	/**
+	class Material;
-	 * @brief A structure representing an object's material.
-	 */
-	class OGLU_API Material
-	{
-	public:
-		Color ambient = Color::White;
-		Color diffuse = Color::White;
-		Color specular = Color::White;
-		float shininess = 32.0f;
-	};
-
 	typedef std::shared_ptr<Material> SharedMaterial;
 
 	/**

include/openglu.hpp

@@ -13,6 +13,7 @@
 #include <shader.hpp>
 #include <texture.hpp>
 #include <object.hpp>
+#include <material.hpp>
 #include <camera.hpp>
 
 #include <lighting/ambient.hpp>

src/core.cpp

@@ -0,0 +1,6 @@
+#include "core.hpp"
+
+namespace oglu
+{
+	NullStream cnull;
+}

src/lighting/ambient.cpp

@@ -3,7 +3,7 @@
 namespace oglu
 {
 	AmbientLight::AmbientLight() :
-		color(1.f, 1.f, 1.f), intensity(1.0f)
+		color(Color::White), intensity(1.0f)
 	{
 	}
 

src/material.cpp

@@ -0,0 +1,14 @@
+#include "material.hpp"
+
+namespace oglu
+{
+	void Material::AddProperty(const std::string& name, const std::any& value)
+	{
+		properties.insert(std::make_pair(name, value));
+	}
+
+	void Material::RemoveProperty(const std::string& name)
+	{
+		properties.erase(name);
+	}
+}

src/object.cpp

@@ -1,5 +1,7 @@
 #include "object.hpp"
 
+#include <material.hpp>
+
 namespace oglu
 {
 	Object::Object(const GLfloat* vertices, size_t verticesSize, const GLuint* indices, size_t indicesSize, const VertexAttribute* topology, size_t topologySize) :