About to have to look at shader code again.

src/dawnopengl/display/shader/Shader.cpp

@@ -10,8 +10,8 @@ using namespace Dawn;
 
 void Shader::compileShader(
   std::map<std::string, int32_t> attributeLocations,
-  std::string vertexShader,
-  std::string fragmentShader
+  const std::string vertexShader,
+  const std::string fragmentShader
 ) {
   GLint isSuccess;
   int32_t maxLength;
@@ -79,54 +79,75 @@ void Shader::compileShader(
   assertNoGLError();
 }
 
-void Shader::bindAttributeLocation(std::string name, int32_t location) {
+void Shader::bindAttributeLocation(
+  const std::string name,
+  const int32_t location
+) {
   if(this->shaderProgram == -1) throw "Shader has not yet been compiled";
   glBindAttribLocation(this->shaderProgram, location, name.c_str());
   assertNoGLError();
 }
 
-void Shader::setTexture(shaderparameter_t param, textureslot_t slot) {
+void Shader::setTexture(
+  const shaderparameter_t param,
+  const textureslot_t slot
+) {
   glUniform1i(param, slot);
   assertNoGLError();
 }
 
-shaderparameter_t Shader::getParameterByName(std::string name) {
+shaderparameter_t Shader::getParameterByName(const std::string name) {
   return glGetUniformLocation(this->shaderProgram, name.c_str());
 }
 
-shaderbufferlocation_t Shader::getBufferLocationByName(std::string name) {
+shaderbufferlocation_t Shader::getBufferLocationByName(const std::string name) {
   return glGetUniformBlockIndex(this->shaderProgram, name.c_str());
 }
 
 void Shader::setParameterBuffer(
-  shaderbufferlocation_t location,
-  shaderbufferslot_t slot
+  const shaderbufferlocation_t location,
+  const shaderbufferslot_t slot
 ) {
   glUniformBlockBinding(this->shaderProgram, location, slot);
   assertNoGLError();
 }
 
-void Shader::setMatrix(shaderparameter_t uniform, glm::mat4 matrix) {
+void Shader::setMatrix(
+  const shaderparameter_t uniform,
+  const glm::mat4 matrix
+) {
   glUniformMatrix4fv(uniform, 1, GL_FALSE, glm::value_ptr(matrix));
   assertNoGLError();
 }
 
-void Shader::setBoolean(shaderparameter_t uni, bool value) {
+void Shader::setBoolean(
+  const shaderparameter_t uni, 
+  const bool value
+) {
   glUniform1i(uni, value);
   assertNoGLError();
 }
 
-void Shader::setColor(shaderparameter_t uniform, struct Color color) {
+void Shader::setColor(
+  const shaderparameter_t uniform,
+  const struct Color color
+) {
   glUniform4f(uniform, color.r, color.g, color.b, color.a);
   assertNoGLError();
 }
 
-void Shader::setVector3(shaderparameter_t uniform, glm::vec3 vector) {
+void Shader::setVector3(
+  const shaderparameter_t uniform,
+  const glm::vec3 vector
+) {
   glUniform3f(uniform, vector.x, vector.y, vector.z);
   assertNoGLError();
 }
 
-void Shader::setFloat(shaderparameter_t param, float_t value) {
+void Shader::setFloat(
+  const shaderparameter_t param,
+  const float_t value
+) {
   glUniform1f(param, value);
   assertNoGLError();
 }

src/dawnopengl/display/shader/Shader.hpp

@@ -31,8 +31,8 @@ namespace Dawn {
        */
       void compileShader(
         std::map<std::string, int32_t> attributeLocations,
-        std::string vertexShader,
-        std::string fragmentShader
+        const std::string vertexShader,
+        const std::string fragmentShader
       );
 
       /**
@@ -43,7 +43,10 @@ namespace Dawn {
        * @param name Attribute name in the HLSL shader.
        * @param location Index pointing to which location it is to be bound to.
        */
-      void bindAttributeLocation(std::string name, int32_t location);
+      void bindAttributeLocation(
+        const std::string name,
+        const int32_t location
+      );
 
     public:
       /**
@@ -52,7 +55,7 @@ namespace Dawn {
        * @param name Name of the parameter to get.
        * @return The shader parameter.
        */
-      shaderparameter_t getParameterByName(std::string name);
+      shaderparameter_t getParameterByName(const std::string name);
 
       /**
        * Locate a shader buffer parameter set by its name.
@@ -60,27 +63,49 @@ namespace Dawn {
        * @param name Name of the buffer to get.
        * @return The shader buffer.
        */
-      shaderbufferlocation_t getBufferLocationByName(std::string name);
+      shaderbufferlocation_t getBufferLocationByName(const std::string name);
 
       virtual void compile() override = 0;
       void bind() override;
+
       void setParameterBuffer(
-        shaderbufferlocation_t location,
-        shaderbufferslot_t slot
+        const shaderbufferlocation_t location,
+        const shaderbufferslot_t slot
       );
-      void setMatrix(shaderparameter_t parameter, glm::mat4 matrix) override;
-      void setBoolean(shaderparameter_t parameter, bool_t value) override;
-      void setColor(shaderparameter_t parameter, struct Color color) override;
-      void setVector3(shaderparameter_t parameter, glm::vec3 vector) override;
-      void setTexture(
-        shaderparameter_t parameter,
-        textureslot_t texture
+
+      void setMatrix(
+        const shaderparameter_t parameter,
+        const glm::mat4 matrix
+      ) override;
+
+      void setBoolean(
+        const shaderparameter_t parameter,
+        const bool_t value
+      ) override;
+
+      void setColor(
+        const shaderparameter_t parameter,
+        const struct Color color
+      ) override;
+
+      void setVector3(
+        const shaderparameter_t parameter,
+        const glm::vec3 vector
+      ) override;
+
+      void setTexture(
+        const shaderparameter_t parameter,
+        const textureslot_t texture
+      ) override;
+
+      void setFloat(
+        const shaderparameter_t parameter,
+        const float_t value
       ) override;
-      void setFloat(shaderparameter_t parameter, float_t value) override;
 
       /**
        * Destroys and deletes the shader from the GPU.
        */
-      virtual ~Shader();
+      ~Shader();
   };
 }