✨(engine): add shader program map, load default & phong shaders

assets/shaders/lighting_blinn-phong.frag

@@ -1,39 +0,0 @@
-//-----------------------------------------------------------------------------
-// Fragment shader for Blinn-Phong lighting
-//-----------------------------------------------------------------------------
-#version 330 core
-
-in vec2 TexCoord;
-in vec3 FragPos;
-in vec3 Normal;
-
-uniform sampler2D texture_map;
-uniform vec3 lightPos;			// for diffuse
-uniform vec3 lightColor;		// for diffuse
-uniform vec3 viewPos;			// for specular
-
-out vec4 frag_color;
-
-void main()
-{
-    // Ambient ---------------------------------------------------------
-    float ambientFactor = 0.1f;
-    vec3 ambient = lightColor * ambientFactor;
-  	
-    // Diffuse ------------------------------------
-    vec3 normal = normalize(Normal);
-    vec3 lightDir = normalize(lightPos - FragPos);
-    float NDotL = max(dot(normal, lightDir), 0.0);
-    vec3 diffuse = lightColor * NDotL;
-    
-    // Specular (Blinn-Phong)-------------------------------------------
-	float specularFactor = 0.8f;
-	float shininess = 32.0f;
-	vec3 viewDir = normalize(viewPos - FragPos);
-	vec3 halfDir = normalize(lightDir + viewDir);
-	float NDotH = max(dot(normal, halfDir), 0.0);
-	vec3 specular = lightColor * specularFactor * pow(NDotH, shininess);
-	
-	vec4 texel = texture(texture_map, TexCoord);
-    frag_color = vec4(ambient + diffuse + specular, 1.0f) * texel;
-}

assets/shaders/lighting_blinn-phong.vert

@@ -1,26 +0,0 @@
-//-----------------------------------------------------------------------------
-// Vertex shader for phong lighting
-//-----------------------------------------------------------------------------
-#version 330 core
-
-layout (location = 0) in vec3 pos;			
-layout (location = 1) in vec3 normal;	
-layout (location = 2) in vec2 texCoord;
-
-uniform mat4 model;			// model matrix
-uniform mat4 view;			// view matrix
-uniform mat4 projection;	// projection matrix
-
-out vec3 FragPos;
-out vec3 Normal;
-out vec2 TexCoord;
-
-void main()
-{
-    FragPos = vec3(model * vec4(pos, 1.0f));			// vertex position in world space
-	Normal = normal;
-	
-	TexCoord = texCoord;
-
-	gl_Position = projection * view *  model * vec4(pos, 1.0f);
-}

include/engine.h

@@ -46,7 +46,7 @@ namespace djalim {
       double previousSeconds = 0.0;
       double elapsedSeconds;
       int frameCount = 0;
-      ShaderProgram shaderProgram;
+      std::map<std::string, ShaderProgram> shaderPrograms;
       FPSCamera Camera = FPSCamera(glm::vec3(0.0f, 2.0f, 10.0f));
 
       Objects3D objects;

src/core/engine.cpp

@@ -44,9 +44,15 @@ djalim::OpenGlEngine::OpenGlEngine(const char* title, int width, int height) {
 
   loadCallbacks();
 
-  bool loaded = shaderProgram.loadShaders("../assets/shaders/vertex.glsl", "../assets/shaders/fragment.glsl");
+  bool loaded = shaderPrograms["default"].loadShaders("assets/shaders/vertex.glsl", "assets/shaders/fragment.glsl");
   if (!loaded) {
-    std::cerr << "Failed to load shaders correctly" << std::endl;
+    std::cerr << "Failed to load default shaders correctly" << std::endl;
+    exit(1);
+  }
+
+  loaded = shaderPrograms["phong"].loadShaders("assets/shaders/lighting_blinn-phong.vert", "assets/shaders/lighting_blinn-phong.frag");
+  if (!loaded) {
+    std::cerr << "Failed to load phong shaders correctly" << std::endl;
     exit(1);
   }
 
@@ -92,11 +98,14 @@ void djalim::OpenGlEngine::createObject(std::string name, std::string textures,
   glBufferData(GL_ARRAY_BUFFER, sizeof(float)*(objects[name])->meshVertices.size(), (objects[name])->meshVertices.data(), GL_STATIC_DRAW);
 
   // Attribut de position
-  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
   glEnableVertexAttribArray(0);
-  // Attribut de coordonnée de texture
-  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
+  // Attribut de normale
+  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
   glEnableVertexAttribArray(1);
+  // Attribut de coordonnée de texture
+  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
+  glEnableVertexAttribArray(2);
 }
 
 djalim::OpenGlEngine::~OpenGlEngine() {
@@ -138,7 +147,7 @@ void djalim::OpenGlEngine::draw(djalim::Mesh3D* object){
   model = glm::translate(model, object->position);
   model = glm::scale(model, object->scale);
 
-  shaderProgram.setUniform("model", model);
+  shaderPrograms["phong"].setUniform("model", model);
 
   glBindVertexArray(object->VAO);
   glDrawArrays(GL_TRIANGLES, 0, object->numFaces * 3);

src/onCreate.cpp

@@ -7,15 +7,15 @@ void djalim::OpenGlEngine::onCreate(){
   stbi_set_flip_vertically_on_load(true);
 
   createObject("mimikyu",
-      "../assets/textures/crate.jpg",
-      "../assets/models/destiny island.obj",
+      "assets/textures/crate.jpg",
+      "assets/models/destiny island.obj",
       glm::vec3(0.0,0.0,0.0),
       glm::vec3(0.0,0.0,0.0),
       glm::vec3(.1,.1,.1)
   );
   createObject("cube",
-      "../assets/textures/crate.jpg",
-      "../assets/models/crate.obj",
+      "assets/textures/crate.jpg",
+      "assets/models/crate.obj",
       glm::vec3(1.0,1.0,1.0),
       glm::vec3(0.0,1.0,0.0),
       glm::vec3(1.0,1.0,1.0)

src/onUpdate.cpp

@@ -6,8 +6,8 @@
 void djalim::OpenGlEngine::onUpdate(){
     showFps();
 
-    shaderProgram.use();
-    shaderProgram.setUniform("ourTexture", 0);
+    shaderPrograms["phong"].use();
+    shaderPrograms["phong"].setUniform("ourTexture", 0);
 
     glm::mat4 model(1.0), view(1.0), projection(1.0);
 
@@ -18,8 +18,11 @@ void djalim::OpenGlEngine::onUpdate(){
     projection = glm::perspective(glm::radians(Camera.getFOV()), (float)windowWidth / (float)windowHeight, 0.1f, 200.0f);
 
     // Matrice de Projection
-    shaderProgram.setUniform("projection", projection);
-    shaderProgram.setUniform("view", view);
+    shaderPrograms["phong"].setUniform("projection", projection);
+    shaderPrograms["phong"].setUniform("view", view);
+    shaderPrograms["phong"].setUniform("viewPos", Camera.getPosition());
+    shaderPrograms["phong"].setUniform("lightPos", glm::vec3(0.0f, 10.0f, 0.0f));
+    shaderPrograms["phong"].setUniform("lightColor", glm::vec3(1.0f, 1.0f, 1.0f));
 
     draw((objects["cube"]).get());
     draw((objects["mimikyu"]).get());