First pass at Phong shader.

include/shader.h

@@ -68,31 +68,38 @@ struct GouraudShader : public IShader {
 
 };
 //Even more complex shader that interpolates normals and calculates intensities per fragment instead
-//of per normals. Uses half angle optimization.
+//of per normals. Uses half angle optimization.BlinnPhongShader
 struct BlinnPhongShader : public IShader {
-    Matrix4 MVP, MV;
-    float ambientStrength = 0.05, diffStrength = 0, specularStrength = 0.5, spec = 0;
-    Vector3f ambient, diffuse, specular;
-    Vector3f lightColor1{1,0,0}, lightColor2{0,0,1}, lightColor3{1,1,1};
-    Vector3f varying_diffuse, varying_specular, reflectDir, viewDir;
+    Matrix4 MVP, MV, V, N;
+    float ambientStrength = 0.05, diffStrength = 0, specularStrength = 0.9, spec = 0;
+    Vector3f normals[3], viewDir[3];
+    Vector3f ambient, diffuse, specular, interpNormal, interpViewDir;
+    Vector3f lightColor{0,0.1,1},lightColorSpec{1,1,1};
+    Vector3f varying_diffuse, varying_specular, reflectDir, light2;
     Vector3f rgb{255,255,255};
 
     Vector3f vertex(Vector3f &vertex, Vector3f &normal, Vector3f &light, int index) override{
-        reflectDir = Vector3f::reflect(-light, normal);
-        viewDir = MV.matMultVec(vertex);
-        varying_specular.data[index] = std::pow( std::max(viewDir.dotProduct(reflectDir), 0.0f), 32.0f);
-        varying_diffuse.data[index] = std::max(0.0f, normal.dotProduct(light));
+        normals[index] = N.matMultDir(normal).normalized();
+        viewDir[index] = MV.matMultVec(vertex).normalized();
+        light2 = V.matMultDir(light).normalized();
         return MVP.matMultVec(vertex);
     }
 
     bool fragment(const Vector3f &bari, Vector3f &color, float &depth, Vector3f &zVerts) override{
-        ambient = lightColor1 * ambientStrength;
+        //Interpolated stuff
+        interpNormal  = (normals[0] * bari.x) + (normals[1] * bari.y)  + (normals[2] * bari.z);
+        interpViewDir = (viewDir[0] * bari.x) + (viewDir[1] * bari.y)  + (viewDir[2] * bari.z);
+        //Ambient 
+        ambient = lightColor * ambientStrength;
+
+        //Diffuse
+        diffStrength = std::max(0.0f, (interpNormal).dotProduct(light2));
+        diffuse = lightColor * diffStrength;
         
-        diffStrength = bari.dotProduct(varying_diffuse);
-        diffuse = lightColor2 * diffStrength;
-
-        spec = bari.dotProduct(varying_specular);
-        specular = lightColor3 * (specularStrength * spec);
+        //Specular
+        reflectDir = Vector3f::reflect(-light2, interpNormal);
+        spec = std::pow( std::max( (-interpViewDir).dotProduct(reflectDir), 0.0f), 50.0f);
+        specular = lightColorSpec * (specularStrength * spec);
 
         color = (ambient + diffuse + specular) * rgb;
 

src/rasterizer.cpp

@@ -80,21 +80,28 @@ void Rasterizer::drawWireFrame(Vector3f *vertices, IShader &shader, Buffer<Uint3
 
 //Draws triangles using baricentric coordinates,
 void Rasterizer::drawTriangles(Vector3f *vertices, IShader &shader, Buffer<Uint32> *pixelBuffer, Buffer<float> *zBuffer){
+    //Per fragment variables            
+    float depth, area;
+    Vector3f e, e_row, rgbVals{255,255,255};
 
     //Transform into viewport coordinates 
     Rasterizer::viewportTransform(pixelBuffer, vertices);
 
+    area = edge(vertices[0],vertices[1],vertices[2]);
+    if(area < 0 ) return;
+    area = 1/area;
+
     //Finding triangle bounding box limits & clips it to the screen width and height
     int xMax, xMin, yMax, yMin;
     Rasterizer::triBoundBox(xMax, xMin, yMax, yMin, vertices, pixelBuffer);
 
-    //Per fragment variables            
-    float depth, area;
-    Vector3f e, e_row, rgbVals{255,255,255};
+    
 
     //Per triangle variables
     Vector3f zVals{vertices[0].z,vertices[1].z,vertices[2].z};
-    area = 1/edge(vertices[0],vertices[1],vertices[2]);
+
+    
+
     float A01 = vertices[0].y - vertices[1].y, B01= vertices[1].x - vertices[0].x;
     float A12 = vertices[1].y - vertices[2].y, B12= vertices[2].x - vertices[1].x;
     float A20 = vertices[2].y - vertices[0].y, B20= vertices[0].x - vertices[2].x;

src/scene.cpp

@@ -34,7 +34,7 @@ bool Scene::loadSceneModels(std::string &path){
     }
     else{
         TransformParameters initParameters;
-        //initParameters.rotation = Vector3f(90*M_PI/180.0f, 0 , 0);
+        initParameters.rotation = Vector3f(90*M_PI/180.0f, 0 , 0);
         initParameters.translation = Vector3f(0, 0, 0);
         modelsInScene.push_back(new Model(fullPath, initParameters));
         return false;

src/sceneManager.cpp

@@ -23,7 +23,7 @@ bool SceneManager::switchScene(){
 
 //for now just loads a single .obj based on the  given string
 bool SceneManager::loadScene(){
-    currentScene = new Scene("cow.obj");
+    currentScene = new Scene("teapot.obj");
     return  !currentScene->checkIfEmpty(); //True if empty, so it's negated for startup
 }
 

src/softwareRenderer.cpp

@@ -35,10 +35,10 @@ void SoftwareRenderer::drawTriangularMesh(Model * currentModel){
     Vector3f normalPrim[3];
 
     //Initializing shader 
-    GouraudShader shader;
+    BlinnPhongShader shader;
 
     //Basic light direction
-    Vector3f lightDir{1, 1, 1};
+    Vector3f lightDir{1, 0, 0};
     Vector3f viewDir;
 
     //Building ModelViewProjection matrix
@@ -58,7 +58,6 @@ void SoftwareRenderer::drawTriangularMesh(Model * currentModel){
         buildTri(n,normalPrim, *normals);
 
         //Skip faces that are pointing away from us
-       //if (backFaceCulling(trianglePrimitive, viewDir)) continue;
 
         //Apply vertex shader
         for(int i = 0; i < 3; ++i){