Optimizations and change of compiler.

CMakeLists.txt

@@ -10,7 +10,7 @@ include_directories(${SDL2_INCLUDE_DIR} include libs)
 
 file(GLOB source_files "*.h" "*.cpp" "src/*.cpp" "include/*.h" "libs/*.h")
 add_executable(softwareRenderer ${source_files})
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}  -g -ffast-math")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS} -g -fno-exceptions  -ffast-math")
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -g ")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -g ")
 target_link_libraries(softwareRenderer ${SDL2_LIBRARY})

include/camera.h

@@ -27,7 +27,7 @@ struct Camera{
 
     //Values related to orbiting mode
     float radius  = 2;
-    bool orbiting = false;
+    bool orbiting = true;
 
     //Momentary fixed camera speed (FPS dependent)
     float camSpeed = 0.1f;

include/rasterizer.h

@@ -38,7 +38,7 @@ class Rasterizer{
 
         static float clamp(float n, float lower, float upper);
 
-        static float gammaAdjust(float n);
+        static int gammaAdjust(float n);
 
     private:
         Rasterizer(){}; //Ensuring an object can never be instanced accidentally
@@ -52,8 +52,10 @@ class Rasterizer{
         static const Uint32 red;
         static const Uint32 green;
         static const Uint32 blue; 
-};
 
+        //Gamma correction look-up table for gamma = 2.2
+        static const int gammaTable[256];
 
+};
 
 #endif

include/shader.h

@@ -322,15 +322,22 @@ struct PBRShader : public IShader {
         interpNormal  = interpNormal.normalized();
         interpViewDir = interpViewDir.normalized();
 
+        //Varying f0 based on metallicness of surface
+        float invMetal = (1.0f-interpMetal);
+        F0corrected = (F0 * invMetal) + (interpCol * interpMetal);
+        
+        nDotV = std::max(interpNormal.dotProduct(interpViewDir), 0.0f);
+
         //Setting up Direct Lighting variables
         radianceOut.zero();
-        for(int light = 0; light < numLights; ++light ){
+        const int maxLights = numLights;
+        Vector3f radiaceLights[maxLights];
+        //#pragma omp simd 
+        for(int light = 0; light < maxLights; ++light ){
             int val = light*3;
             interpLightDir = lightDirVal[val] +  (lightDirVal[val + 1] - lightDirVal[val])* u +  (lightDirVal[val + 2] - lightDirVal[val]) * v;
             halfwayDir = (interpLightDir.normalized() + interpViewDir).normalized();
-            nDotV = std::max(interpNormal.dotProduct(interpViewDir), 0.0f);
             nDotL = std::max(interpNormal.dotProduct(interpLightDir), 0.0f);
-            F0corrected = (F0 * (1.0f-interpMetal)) + (interpCol * interpMetal);//Varying f0 based on metallicness of surface
 
             //We assume the only lights in the scene are far away so there is no attenuation
             
@@ -345,12 +352,16 @@ struct PBRShader : public IShader {
             specular  = numerator * invDenominator;
 
             //Calculating the full rendering equation for a single light
-            kS = F;
-            kD = (Vector3f(1.0) - kS);
-            kD = kD * (1.0f - interpMetal); 
-            radianceOut +=  ( (kD * (interpCol * (1/M_PI)) + specular ) * nDotL * lightCol[light]);
+            //kS = F;
+            kD = (Vector3f(1.0) - F);
+            kD = kD *invMetal; 
+            radiaceLights[light] = ( (kD * (interpCol * (1/M_PI)) + specular ) * nDotL * lightCol[light]);
         }
         
+        for(int i = 0; i < maxLights; ++i) {
+            radianceOut += radiaceLights[i];
+        }
+
         //Simplistic ambient term
         ambient =  interpCol * (ambientInt * interpAO);
 

include/texture.h

@@ -4,8 +4,6 @@
 #include <string>
 #include "vector3D.h"
 
-
-
 class Texture{
     public:
         Texture(std::string path, std::string type); 
@@ -17,8 +15,9 @@ class Texture{
 
     private:
         int bilinearFiltering(float u, float v);
+        void tileData();
         float *pixelData;
-        int width, height, channels;
+        int width, height, channels, tileW = 2, tileH = 2;
 };
 
 #endif

src/engine.cpp

@@ -83,7 +83,7 @@ void Engine::run(){
         deltaT = SDL_GetTicks() - start;
         printf("%2.1d: Loop elapsed time (ms):%d\n",count, deltaT);
         total += deltaT;
-        //if(count == 500) break;
+        if(count == 500) break;
     }
 
     printf("Closing down engine.\n");

src/inputManager.cpp

@@ -174,7 +174,7 @@ void InputManager::handleEvent(SDL_Event * event, bool &done, unsigned int delta
             fov += zoom;
         }
 
-        if(fov < 30){
+        if(fov < 20){
             fov = 20;
         }
         else if (fov > 120){

src/rasterizer.cpp

@@ -1,9 +1,30 @@
 #include "rasterizer.h"
 #include "vector"
 #include "array"
-
 #include <algorithm>
 
+//Gamma correction lookup table
+const int Rasterizer::gammaTable[256] = {0, 21, 28, 34, 39, 43, 46,
+        50, 53, 56, 59, 61, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84,
+        85, 87, 89, 90, 92, 93, 95, 96, 98, 99, 101, 102, 103, 105, 106,
+        107, 109, 110, 111, 112, 114, 115, 116, 117, 118, 119, 120, 122,
+        123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
+        136, 137, 138, 139, 140, 141, 142, 143, 144, 144, 145, 146, 147,
+        148, 149, 150, 151, 151, 152, 153, 154, 155, 156, 156, 157, 158,
+        159, 160, 160, 161, 162, 163, 164, 164, 165, 166, 167, 167, 168,
+        169, 170, 170, 171, 172, 173, 173, 174, 175, 175, 176, 177, 178,
+        178, 179, 180, 180, 181, 182, 182, 183, 184, 184, 185, 186, 186,
+        187, 188, 188, 189, 190, 190, 191, 192, 192, 193, 194, 194, 195,
+        195, 196, 197, 197, 198, 199, 199, 200, 200, 201, 202, 202, 203,
+        203, 204, 205, 205, 206, 206, 207, 207, 208, 209, 209, 210, 210,
+        211, 212, 212, 213, 213, 214, 214, 215, 215, 216, 217, 217, 218,
+        218, 219, 219, 220, 220, 221, 221, 222, 223, 223, 224, 224, 225,
+        225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231,
+        232, 232, 233, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238,
+        238, 239, 239, 240, 240, 241, 241, 242, 242, 243, 243, 244, 244,
+        245, 245, 246, 246, 247, 247, 248, 248, 249, 249, 249, 250, 250,
+        251, 251, 252, 252, 253, 253, 254, 254, 255, 255};
+
 //Initializing all the basic colors 
 const SDL_PixelFormat* Rasterizer::mappingFormat( SDL_AllocFormat(PIXEL_FORMAT));
 const Uint32 Rasterizer::white(SDL_MapRGBA(mappingFormat, 0xFF,0xFF,0xFF,0xFF));
@@ -140,9 +161,9 @@ void Rasterizer::drawTriangles(Vector3f *vertices, IShader &shader, Buffer<Uint3
                     rgbVals = shader.fragment(uPers , vPers);
                     //Update pixel buffer with clamped values 
                     (*pixelBuffer)(x,y) = SDL_MapRGB(mappingFormat,
-                    clamp(gammaAdjust(rgbVals.data[0]), 0, 255.0f), //
-                    clamp(gammaAdjust(rgbVals.data[1]), 0, 255.0f),//
-                    clamp(gammaAdjust(rgbVals.data[2]), 0, 255.0f));//
+                    gammaAdjust(rgbVals.data[0]), //
+                    gammaAdjust(rgbVals.data[1]),//
+                    gammaAdjust(rgbVals.data[2]));//
                     //(*pixelBuffer)(x,y) = SDL_MapRGB(mappingFormat,0xFF, 0xFF, 0xFF);
                 }   
             }
@@ -167,7 +188,6 @@ void Rasterizer::viewportTransform(Buffer<Uint32> *pixelBuffer, Vector3f *vertic
     }
 }
 
-
 void Rasterizer::triBoundBox(int &xMax, int &xMin, int &yMax, int &yMin,Vector3f *vertices, Buffer<Uint32> *pixelBuffer){
     // xMax = std::ceil(std::max({vertices[0].x, vertices[1].x, vertices[2].x}));
     //xMin = std::ceil(std::min({vertices[0].x, vertices[1].x, vertices[2].x}));
@@ -187,7 +207,6 @@ void Rasterizer::triBoundBox(int &xMax, int &xMin, int &yMax, int &yMin,Vector3f
     yMin = std::max(yMin, 0);
 }
 
-
 float Rasterizer::edge(Vector3f &a, Vector3f &b, Vector3f &c){
     return (b.x - a.x)*(c.y - a.y) - (b.y - a.y)*(c.x - a.x);
 }
@@ -201,12 +220,11 @@ bool Rasterizer::inside(float e, float a, float b){
     return false;
 }
 
-
 float Rasterizer::clamp(float n, float lower, float upper) {
   return std::max(lower, std::min(n, upper));
 }
 
-
-float Rasterizer::gammaAdjust(float n) {
-  return std::pow(n, 1.0/2.2)*255.0f;
+int Rasterizer::gammaAdjust(float n) {
+    int val = round(clamp(n*255, 0, 255));
+    return gammaTable[val];
 }

src/softwareRenderer.cpp

@@ -50,7 +50,6 @@ void SoftwareRenderer::drawTriangularMesh(Model * currentModel){
     shader.metalT    = currentModel->getMetallic();
 
     //Setting up lighting
-    Vector3f lightDir[mNumLights * 3 ];
     Vector3f lightPositions[mNumLights];
     Vector3f lColor[mNumLights];
     for(int x = 0; x < mNumLights; ++x){
@@ -67,8 +66,7 @@ void SoftwareRenderer::drawTriangularMesh(Model * currentModel){
     shader.cameraPos = mCamera->position;
 
     shader.numLights  = mNumLights;
-    shader.lightCol = lColor;
-    
+    shader.lightCol   = lColor;
     shader.lightPos = lightPositions;
 
     //Building worldToObject matrix
@@ -78,8 +76,9 @@ void SoftwareRenderer::drawTriangularMesh(Model * currentModel){
     int count = 0;
     Vector3f dummyDir; //TO DO FIX THIS
 
-    #pragma omp parallel for private(trianglePrimitive, normalPrim, uvPrim, tangentPrim, lightDir) firstprivate(shader)
+    #pragma omp parallel for private(trianglePrimitive, normalPrim, uvPrim, tangentPrim) firstprivate(shader) schedule(dynamic)
     for (int j= 0; j < numFaces; ++j){
+        Vector3f lightDir[mNumLights * 3 ];
         shader.lightDirVal = lightDir;
         //Current vertex and normal indices
         Vector3i f = (*vIndices)[j];
@@ -114,7 +113,7 @@ void SoftwareRenderer::drawTriangularMesh(Model * currentModel){
         Rasterizer::drawTriangles(trianglePrimitive, shader, pixelBuffer, zBuffer);
         
     }
-    printf("%d faces drawn.\n", count);
+    //printf("%d faces drawn.\n", count);
 }
 
 void SoftwareRenderer::clearBuffers(){

src/texture.cpp

@@ -5,25 +5,29 @@
 
 Texture::Texture(std::string path, std::string type){
     stbi_set_flip_vertically_on_load(true);  
+
     unsigned char * data = stbi_load(path.c_str(), &width, &height, &channels, 0);
+
+    pixelData = new float[width*height*channels];
+
     if (data){
         if(type == "RGB"){
-            pixelData = new float[width*height*channels];
             for(int i = 0; i < width*height*channels; ++i){
                 pixelData[i] = std::pow((float)data[i] * (1/255.0f), 2.2f);
             }
+            //tileData(tileSize);
         }
         else if (type == "XYZ"){
-            pixelData = new float[width*height*channels];
             for(int i = 0; i < width*height*channels; ++i){
                 pixelData[i] = (float)data[i] * (2/255.0f) - 1.0f;
             }
+            //tileData(tileSize);
         }
         else if (type == "BW"){
-            pixelData = new float[width*height*channels];
             for(int i = 0; i < width*height*channels; ++i){
                 pixelData[i] = (float)data[i] * (1/255.0f);
             }
+            //tileData(tileSize);
         }
         else{
             printf("Error unrecognized texture format type.\n");
@@ -35,6 +39,53 @@ Texture::Texture(std::string path, std::string type){
     stbi_image_free(data);
 }
 
+void Texture::tileData(){
+    float *tiledPixelData = new float[width*height*channels];
+
+    int tileNumW = width / tileW;
+    int tileNumH = height / tileH;
+
+    for(int i = 0; i < tileH; ++i){
+        
+        for(int j = 0; j < tileW; ++j){
+
+            for(int pH = 0; pH < tileH; ++pH){
+
+                for(int pW = 0; pW < tileW; ++pW){
+
+                    
+
+                }
+
+            }
+
+        }
+
+    }
+
+    // //Channel by channel every i 3 = 1 pixel
+    // int currentPixel = 0;
+    // for(int i = 0; i < width*height*channels; ++i){
+    //     int currentChannel = i % channels;
+
+    //     if(currentChannel == 0){
+    //         ++currentPixel;
+    //     }
+
+
+    //     if(currentPixel %)
+
+
+    //     tiledPixelData[i] = pixelData[i];
+
+
+    // }
+
+
+    delete [] pixelData;
+    pixelData = tiledPixelData;
+}
+
 Texture::~Texture(){
     delete [] pixelData;
 }