metallic & roughness map support

Author: HummaWhite

img/metal_rough.png

@@ -14,7 +14,6 @@ Image::Image(int width, int height) :
 Image::Image(const std::string& filename) {
     int channels;
     // The textures should be in the linear space
-    stbi_ldr_to_hdr_gamma(1.f);
     float* data = stbi_loadf(filename.c_str(), &mWidth, &mHeight, &channels, 3);
 
     if (!data) {

src/image.cpp

@@ -230,19 +230,14 @@ void runCuda() {
 	if (State::camChanged) {
 		iteration = 0;
 		Camera& cam = scene->camera;
-		cameraPosition.x = zoom * sin(phi) * sin(theta);
-		cameraPosition.y = zoom * cos(theta);
-		cameraPosition.z = zoom * cos(phi) * sin(theta);
+		cam.view = glm::vec3(sin(phi) * sin(theta), cos(theta), cos(phi) * sin(theta));
 
-		cam.view = -glm::normalize(cameraPosition);
 		glm::vec3 v = cam.view;
 		glm::vec3 u = glm::vec3(0, 1, 0);//glm::normalize(cam.up);
 		glm::vec3 r = glm::cross(v, u);
 		cam.up = glm::cross(r, v);
 		cam.right = r;
 
-		cameraPosition += cam.lookAt;
-		cam.position = cameraPosition;
 		State::camChanged = false;
 	}
 
@@ -305,8 +300,8 @@ void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods
 }
 
 void mouseScrollCallback(GLFWwindow* window, double offsetX, double offsetY) {
-	zoom -= offsetY;
-	zoom = std::fmax(0.1f, zoom);
+	scene->camera.fov.y -= offsetY;
+	scene->camera.fov.y = std::min(scene->camera.fov.y, 45.f);
 	State::camChanged = true;
 }
 
@@ -348,8 +343,8 @@ void mousePositionCallback(GLFWwindow* window, double xpos, double ypos) {
 		right.y = 0.0f;
 		right = glm::normalize(right);
 
-		cam.lookAt -= (float)(xpos - lastX) * right * 0.01f;
-		cam.lookAt += (float)(ypos - lastY) * forward * 0.01f;
+		cam.position -= (float)(xpos - lastX) * right * 0.01f;
+		cam.position += (float)(ypos - lastY) * forward * 0.01f;
 		State::camChanged = true;
 	}
 	lastX = xpos;

src/main.cpp

@@ -259,5 +259,7 @@ struct Material {
     float ior = 1.5f;
 
     int baseColorMapId = NullTextureId;
+    int metallicMapId = NullTextureId;
+    int roughnessMapId = NullTextureId;
     int normalMapId = NullTextureId;
 };

src/material.h

@@ -217,6 +217,7 @@ void RenderImGui() {
 		ImGuiWindowFlags_NoFocusOnAppearing |
 		ImGuiWindowFlags_NoNav); {
 		ImGui::Text("Traced Depth %d", imguiData->TracedDepth);
+		ImGui::Text("BVH Size %d", scene->BVHSize);
 		ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
 
 		ImGui::End();
@@ -259,6 +260,10 @@ void RenderImGui() {
 			State::camChanged = true;
 		}
 
+		if (ImGui::DragFloat3("Up", glm::value_ptr(cam.up), .1f)) {
+			State::camChanged = true;
+		}
+
 		if (ImGui::SliderFloat("FOV", &cam.fov.y, .1f, 45.f, "%.1f deg")) {
 			State::camChanged = true;
 		}

src/preview.cpp

@@ -1,5 +1,6 @@
 #include "scene.h"
 #include "common.h"
+#include "stb_image.h"
 #include <iostream>
 #include <cstring>
 #include <stack>
@@ -113,6 +114,9 @@ void Resource::clear() {
 }
 
 Scene::Scene(const std::string& filename) {
+    stbi_ldr_to_hdr_gamma(1.f);
+    stbi_set_flip_vertically_on_load(true);
+
     std::cout << "[Scene loading " << filename << " ...]" << std::endl;
     std::cout << " " << std::endl;
     char* fname = (char*)filename.c_str();
@@ -335,20 +339,22 @@ void Scene::loadCamera() {
     camera.fov = glm::vec2(fovx, fovy);
     camera.tanFovY = glm::tan(glm::radians(fovy * 0.5f));
 
+    camera.view = glm::normalize(camera.lookAt - camera.position);
     camera.right = glm::normalize(glm::cross(camera.view, camera.up));
     camera.pixelLength = glm::vec2(2 * xscaled / (float)camera.resolution.x,
         2 * yscaled / (float)camera.resolution.y);
 
-    camera.view = glm::normalize(camera.lookAt - camera.position);
-
     //set up render camera stuff
     int arraylen = camera.resolution.x * camera.resolution.y;
     state.image.resize(arraylen);
     std::fill(state.image.begin(), state.image.end(), glm::vec3());
 }
 
 void Scene::loadEnvMap(const std::string& filename) {
+    stbi_set_flip_vertically_on_load(false);
     envMapTexId = addTexture(filename);
+    stbi_set_flip_vertically_on_load(true);
+
     auto envMap = textures[envMapTexId];
     std::vector<float> pdf(envMap->width() * envMap->height());
 
@@ -406,10 +412,22 @@ void Scene::loadMaterial(const std::string& matId) {
             }
         }
         else if (tokens[0] == "Metallic") {
-            material.metallic = std::stof(tokens[1]);
+            if (std::isdigit(tokens[1][tokens[1].length() - 1])) {
+                material.metallic = std::stof(tokens[1]);
+            }
+            else {
+                material.metallicMapId = addTexture(tokens[1]);
+                std::cout << "\t\t[Metallic use texture " << tokens[1] << "]" << std::endl;
+            }
         }
         else if (tokens[0] == "Roughness") {
-            material.roughness = std::stof(tokens[1]);
+            if (std::isdigit(tokens[1][tokens[1].length() - 1])) {
+                material.roughness = std::stof(tokens[1]);
+            }
+            else {
+                material.roughnessMapId = addTexture(tokens[1]);
+                std::cout << "\t\t[Roughness use texture " << tokens[1] << "]" << std::endl;
+            }
         }
         else if (tokens[0] == "Ior") {
             material.ior = std::stof(tokens[1]);

src/scene.cpp

@@ -70,11 +70,18 @@ struct DevScene {
             mat.baseColor = textures[mat.baseColorMapId].linearSample(intersec.uv);
         }
 
+        if (mat.metallicMapId > NullTextureId) {
+            mat.metallic = textures[mat.metallicMapId].linearSample(intersec.uv).r;
+        }
+
+        if (mat.roughnessMapId > NullTextureId) {
+            mat.roughness = textures[mat.roughnessMapId].linearSample(intersec.uv).r;
+        }
+
         if (mat.normalMapId > NullTextureId) {
             glm::vec3 mapped = textures[mat.normalMapId].linearSample(intersec.uv);
             glm::vec3 localNorm = glm::normalize(glm::vec3(mapped.x, mapped.y, mapped.z) * 1.f - 0.5f);
             intersec.norm = Math::localToWorld(intersec.norm, localNorm);
-            //intersec.norm = getPrimitivePlainNormal
         }
         return mat;
     }