Merge pull request 'hot_new_model' (#16) from hot_new_model into master

Reviewed-on: #16

cw 9/models/side_table.mtl

@@ -0,0 +1,16 @@
+# Blender MTL File: 'side_table_01_4k.blend'
+# Material Count: 1
+
+newmtl side_table_01
+Ns 250.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.450000
+d 1.000000
+illum 2
+map_Bump C:\\Users\\korze\\AppData\\Local\\Temp\\Temp1_side_table_01_4k.blend.zip\\textures\\side_table_01_nor_gl_4k.exr
+map_Kd C:\\Users\\korze\\AppData\\Local\\Temp\\Temp1_side_table_01_4k.blend.zip\\textures\\side_table_01_diff_4k.jpg
+map_Ns C:\\Users\\korze\\AppData\\Local\\Temp\\Temp1_side_table_01_4k.blend.zip\\textures\\side_table_01_rough_4k.jpg
+refl C:\\Users\\korze\\AppData\\Local\\Temp\\Temp1_side_table_01_4k.blend.zip\\textures\\side_table_01_metal_4k.exr

cw 9/shaders/shader_no_pbr.frag

@@ -0,0 +1,171 @@
+#version 430 core
+
+layout (location = 0) out vec4 FragColor;
+layout (location = 1) out vec4 BloomColor;
+
+float AMBIENT = 0.03;
+float PI = 3.14;
+
+uniform sampler2D depthMap;
+uniform sampler2D depthMapShip;
+
+uniform sampler2D colorTexture;
+uniform sampler2D normalSampler;
+
+uniform vec3 cameraPos;
+
+uniform vec3 color;
+
+uniform vec3 sunDir;
+uniform vec3 sunColor;
+
+uniform vec3 lightPos;
+uniform vec3 lightColor;
+
+uniform vec3 spotlightPos;
+uniform vec3 spotlightColor;
+uniform vec3 spotlightConeDir;
+uniform vec3 spotlightPhi;
+
+uniform float metallic;
+uniform float roughness;
+
+uniform float exposition;
+
+in vec3 vecNormal;
+in vec3 worldPos;
+
+out vec4 outColor;
+
+
+in vec3 viewDirTS;
+in vec3 lightDirTS;
+in vec3 spotlightDirTS;
+in vec3 sunDirTS;
+
+in vec3 test;
+
+in vec4 sunSpacePos;
+in vec4 shipPos;
+
+in vec2 vecTex;
+
+float calculateShadow(vec3 normal, vec3 light, vec4 pos, sampler2D depth) {
+    vec4 posNormalized = (pos / pos.w) * 0.5 + 0.5;
+    float closestDepth = texture2D(depth, posNormalized.xy).r;
+
+    //float bias = max(0.03 * (1.0 - dot(normal, light)), 0.003); 
+
+    if (closestDepth + 0.003 > posNormalized.z) return 1.0;
+
+    return 0.0;
+}
+
+float DistributionGGX(vec3 normal, vec3 H, float roughness){
+    float a      = roughness*roughness;
+    float a2     = a*a;
+    float NdotH  = max(dot(normal, H), 0.0);
+    float NdotH2 = NdotH*NdotH;
+	
+    float num   = a2;
+    float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+    denom = PI * denom * denom;
+	
+    return num / denom;
+}
+float GeometrySchlickGGX(float NdotV, float roughness){
+    float r = (roughness + 1.0);
+    float k = (r*r) / 8.0;
+
+    float num   = NdotV;
+    float denom = NdotV * (1.0 - k) + k;
+	
+    return num / denom;
+}
+float GeometrySmith(vec3 normal, vec3 V, vec3 lightDir, float roughness){
+    float NdotV = max(dot(normal, V), 0.0);
+    float NdotL = max(dot(normal, lightDir), 0.0);
+    float ggx2  = GeometrySchlickGGX(NdotV, roughness);
+    float ggx1  = GeometrySchlickGGX(NdotL, roughness);
+	
+    return ggx1 * ggx2;
+}
+vec3 fresnelSchlick(float cosTheta, vec3 F0){
+    return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
+} 
+
+vec3 PBRLight(vec3 lightDir, vec3 radiance, vec3 normal, vec3 V){
+	float diffuse=max(0,dot(normal,lightDir));
+
+	//vec3 V = normalize(cameraPos-worldPos);
+	vec3 F0 = vec3(0.04); 
+    F0 = mix(F0, color, metallic);
+
+    vec3 H = normalize(V + lightDir);    
+        
+    // cook-torrance brdf
+    float NDF = DistributionGGX(normal, H, roughness);        
+    float G   = GeometrySmith(normal, V, lightDir, roughness);      
+    vec3 F    = fresnelSchlick(max(dot(H, V), 0.0), F0);       
+        
+    vec3 kS = F;
+    vec3 kD = vec3(1.0) - kS;
+    kD *= 1.0 - metallic;	  
+        
+    vec3 numerator    = NDF * G * F;
+    float denominator = 4.0 * max(dot(normal, V), 0.0) * max(dot(normal, lightDir), 0.0) + 0.0001;
+    vec3 specular     = numerator / denominator;  
+            
+    // add to outgoing radiance Lo
+    float NdotL = max(dot(normal, lightDir), 0.0);   
+	return (kD * color / PI + specular) * radiance * NdotL;
+}
+
+
+void main()
+{
+	//vec3 normal = vec3(0,0,1);
+    vec3 normal = normalize(vecNormal);
+
+    //color = texture2D(colorTexture, vecTex).xyz;
+    //vec3 normal = normalize((texture2D(normalSampler, vecTex).xyz) * 2 - 1);
+
+    //vec3 viewDir = normalize(viewDirTS);
+    vec3 viewDir = normalize(cameraPos-worldPos);
+
+	//vec3 lightDir = normalize(lightDirTS);
+	vec3 lightDir = normalize(lightPos-worldPos);
+
+
+	vec3 ambient = AMBIENT*color;
+	vec3 attenuatedlightColor = lightColor/pow(length(lightPos-worldPos),2);
+	vec3 ilumination;
+	ilumination = ambient+PBRLight(lightDir,attenuatedlightColor,normal,viewDir);
+	
+	//flashlight
+	//vec3 spotlightDir= normalize(spotlightDirTS);
+	vec3 spotlightDir= normalize(spotlightPos-worldPos);
+	
+
+    float angle_atenuation = clamp((dot(-normalize(spotlightPos-worldPos),spotlightConeDir)-0.5)*3,0,1);
+	attenuatedlightColor = angle_atenuation*spotlightColor/pow(length(spotlightPos-worldPos),2)*calculateShadow(normal, spotlightDir, shipPos, depthMapShip);
+	ilumination=ilumination+PBRLight(spotlightDir,attenuatedlightColor,normal,viewDir);
+
+
+	//sun
+	ilumination=ilumination+PBRLight(sunDir,sunColor*calculateShadow(normal, spotlightDir, sunSpacePos, depthMap),normal,viewDir);
+   
+
+    
+	outColor = vec4(vec3(1.01) - exp(-ilumination*exposition),1);
+
+     FragColor = outColor;
+    // check whether fragment output is higher than threshold, if so output as brightness color
+    float brightness = dot(FragColor.rgb, vec3(0.2126, 0.7152, 0.0722));
+    if(brightness > 1.0)
+        BloomColor = vec4(FragColor.rgb, 1.0);
+    else
+        BloomColor = vec4(0.0, 0.0, 0.0, 1.0); 
+	//outColor = vec4(roughness,metallic,0,1);
+    //outColor = vec4(test;
+}

cw 9/shaders/shader_no_pbr.vert

@@ -0,0 +1,53 @@
+#version 430 core
+
+layout(location = 0) in vec3 vertexPosition;
+layout(location = 1) in vec3 vertexNormal;
+layout(location = 2) in vec2 vertexTexCoord;
+layout(location = 3) in vec3 vertexTangent;
+layout(location = 4) in vec3 vertexBitangent;
+
+uniform mat4 lightVP;
+uniform mat4 lightShipVP;
+uniform mat4 transformation;
+uniform mat4 modelMatrix;
+
+out vec3 vecNormal;
+out vec3 worldPos;
+
+uniform vec3 lightPos;
+uniform vec3 spotlightPos;
+uniform vec3 cameraPos;
+uniform vec3 sunDir;
+
+out vec3 viewDirTS;
+out vec3 lightDirTS;
+out vec3 spotlightDirTS;
+out vec3 sunDirTS;
+
+out vec4 sunSpacePos;
+out vec4 shipPos;
+out vec2 vecTex;
+
+void main()
+{
+	sunSpacePos = lightVP * modelMatrix * vec4(vertexPosition, 1);
+	shipPos = lightShipVP * modelMatrix * vec4(vertexPosition, 1);
+
+	worldPos = (modelMatrix* vec4(vertexPosition,1)).xyz;
+	vecNormal = (modelMatrix* vec4(vertexNormal,0)).xyz;
+	gl_Position = transformation * vec4(vertexPosition, 1.0);
+	
+	vec3 w_tangent = normalize(mat3(modelMatrix)*vertexTangent);
+	vec3 w_bitangent = normalize(mat3(modelMatrix)*vertexBitangent);
+	mat3 TBN = transpose(mat3(w_tangent, w_bitangent, vecNormal));
+
+	vecTex = vertexTexCoord;
+	
+	vec3 V = normalize(cameraPos-worldPos);
+	viewDirTS = TBN*V;
+	vec3 L = normalize(lightPos-worldPos);
+	lightDirTS = TBN*L;
+	vec3 SL = normalize(spotlightPos-worldPos);
+	spotlightDirTS = TBN*SL;
+	sunDirTS = TBN*sunDir;
+}

cw 9/src/room.hpp

@@ -50,6 +50,7 @@ namespace models {
 	Core::RenderContext easelContext;
 	Core::RenderContext carContext;
 	Core::RenderContext vaseContext;
+	Core::RenderContext sideTableContext;
 }
 
 namespace texture {
@@ -123,6 +124,9 @@ namespace texture {
 	GLuint metalNormal;
 	GLuint metalARM;
 
+	GLuint rust;
+	GLuint rustNormal;
+	GLuint rustARM;
 }
 
 Core::RenderContext cubeContext;
@@ -147,6 +151,7 @@ GLuint bloomTextureFBO;
 GLuint program;
 GLuint programSun;
 GLuint programTest;
+GLuint programNoTex;
 GLuint programTex;
 GLuint programDepth;
 GLuint programSkybox;
@@ -348,6 +353,53 @@ void drawObjectPBR(Core::RenderContext& context, glm::mat4 modelMatrix, GLuint t
 	Core::DrawContext(context);
 }
 
+void drawObjectNoPBR(Core::RenderContext& context, glm::mat4 modelMatrix, glm::vec3 color, float roughness, float metallic) {
+	glUseProgram(programNoTex);
+
+	glActiveTexture(GL_TEXTURE0);
+	glUniform1i(glGetUniformLocation(programNoTex, "depthMap"), 0);
+	glBindTexture(GL_TEXTURE_2D, depthMap);
+	glUniformMatrix4fv(glGetUniformLocation(programNoTex, "lightVP"), 1, GL_FALSE, (float*)&lightVP);
+
+	glActiveTexture(GL_TEXTURE1);
+	glUniform1i(glGetUniformLocation(programNoTex, "depthMapShip"), 1);
+	glBindTexture(GL_TEXTURE_2D, depthMapShip);
+	glUniformMatrix4fv(glGetUniformLocation(programNoTex, "lightShipVP"), 1, GL_FALSE, (float*)&lightShipVP);
+
+	glm::mat4 viewProjectionMatrix = createPerspectiveMatrix() * createCameraMatrix();
+	glm::mat4 transformation = viewProjectionMatrix * modelMatrix;
+	glUniformMatrix4fv(glGetUniformLocation(programNoTex, "transformation"), 1, GL_FALSE, (float*)&transformation);
+	glUniformMatrix4fv(glGetUniformLocation(programNoTex, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
+
+	glUniform1f(glGetUniformLocation(programNoTex, "exposition"), exposition);
+
+	glUniform1f(glGetUniformLocation(programNoTex, "roughness"), roughness);
+	glUniform1f(glGetUniformLocation(programNoTex, "metallic"), metallic);
+
+	glUniform3f(glGetUniformLocation(programNoTex, "color"), color.x, color.y, color.z);
+
+	glUniform3f(glGetUniformLocation(programNoTex, "cameraPos"), cameraPos.x, cameraPos.y, cameraPos.z);
+
+	glUniform3f(glGetUniformLocation(programNoTex, "sunDir"), sunDir.x, sunDir.y, sunDir.z);
+	glUniform3f(glGetUniformLocation(programNoTex, "sunColor"), sunColor.x, sunColor.y, sunColor.z);
+
+	if (lightOn)
+		glUniform3f(glGetUniformLocation(programNoTex, "lightPos"), pointlightPos.x, pointlightPos.y, pointlightPos.z);
+	else
+		glUniform3f(glGetUniformLocation(programNoTex, "lightPos"), 1000.f, 1000.f, 1000.f);
+	glUniform3f(glGetUniformLocation(programNoTex, "lightColor"), pointlightColor.x, pointlightColor.y, pointlightColor.z);
+
+
+	glUniform3f(glGetUniformLocation(programNoTex, "spotlightConeDir"), spotlightConeDir.x, spotlightConeDir.y, spotlightConeDir.z);
+	glUniform3f(glGetUniformLocation(programNoTex, "spotlightPos"), spotlightPos.x, spotlightPos.y, spotlightPos.z);
+	glUniform3f(glGetUniformLocation(programNoTex, "spotlightColor"), spotlightColor.x, spotlightColor.y, spotlightColor.z);
+	glUniform1f(glGetUniformLocation(programNoTex, "spotlightPhi"), spotlightPhi);
+
+
+	Core::DrawContext(context);
+	glUseProgram(program);
+}
+
 void renderShadowapSun(GLuint depthFBO, glm::mat4 light) {
 	float time = glfwGetTime();
 	glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
@@ -379,12 +431,13 @@ void renderShadowapSun(GLuint depthFBO, glm::mat4 light) {
 	drawObjectDepth(models::tvStandContext, light, glm::mat4());
 	drawObjectDepth(models::carpetContext, light, glm::mat4());
 	drawObjectDepth(models::cabinet1Context, light, glm::mat4());
-	drawObjectDepth(models::cabinet2Context, light, glm::mat4());
+	//drawObjectDepth(models::cabinet2Context, light, glm::mat4());
 	drawObjectDepth(models::lampContext, light, glm::mat4());
 	drawObjectDepth(models::bookshelfContext, light, glm::mat4());
 	drawObjectDepth(models::easelContext, light, glm::mat4());
 	drawObjectDepth(models::carContext, light, glm::translate(carPosTranform));
 	drawObjectDepth(models::vaseContext, light, glm::translate(glm::vec3(1.1f, 1.41f, -2.2f)));
+	drawObjectDepth(models::sideTableContext, light, glm::translate(glm::vec3(0.0f, 0.0f, 1.9f)));
 
 	glm::vec3 spaceshipSide = glm::normalize(glm::cross(spaceshipDir, glm::vec3(0.f, 1.f, 0.f)));
 	glm::vec3 spaceshipUp = glm::normalize(glm::cross(spaceshipSide, spaceshipDir));
@@ -570,15 +623,18 @@ void renderScene(GLFWwindow* window)
 	drawObjectPBR(models::tvStandContext, glm::mat4(), texture::wood, texture::woodNormal, texture::woodARM);
 	drawObjectPBR(models::carpetContext, glm::mat4(), texture::carpet, texture::carpetNormal, texture::carpetARM);
 	drawObjectPBR(models::cabinet1Context, glm::mat4(), texture::wood, texture::woodNormal, texture::woodARM);
-	drawObjectPBR(models::cabinet2Context, glm::mat4(), texture::wood, texture::woodNormal, texture::woodARM);
+	//drawObjectPBR(models::cabinet2Context, glm::mat4(), texture::wood, texture::woodNormal, texture::woodARM);
 	drawObjectPBR(models::lampContext, glm::translate(glm::vec3(0.022f, 0.15f, 0.04f)), texture::metal, texture::metalNormal, texture::metalARM);
 	drawObjectPBR(models::bookshelfContext, glm::mat4(), texture::wood, texture::woodNormal, texture::woodARM);
-	drawObjectPBR(models::lightSwitchContext, glm::mat4(), texture::white, texture::whiteNormal, texture::whiteARM);
+	drawObjectPBR(models::lightSwitchContext, glm::mat4(), texture::door, texture::doorNorm, texture::doorArm);
 	drawObjectPBR(models::easelContext, glm::mat4(), texture::wood, texture::woodNormal, texture::woodARM);
-	drawObjectPBR(models::carContext, glm::translate(carPosTranform), texture::red, texture::redNormal, texture::redARM);
+	//drawObjectPBR(models::carContext, glm::translate(carPosTranform), texture::brick, texture::brickNormal, texture::brickARM);
+	drawObjectNoPBR(models::carContext, glm::translate(carPosTranform), glm::vec3(1.0f, 0.0f, 0.0f), 0.0f, 0.2f);
+
 	drawObjectPBR(models::vaseContext, glm::translate(glm::vec3(1.1f, 1.41f, -2.2f)), texture::vase, texture::vaseNormal, texture::vaseARM);
 	//drawObjectPBR(models::couchContext, glm::eulerAngleY(3.14f), texture::redLeather, texture::redLeatherNormal, texture::redLeatherARM);
 	drawObjectPBR(models::couchContext, glm::translate(glm::vec3(2.9f, 0.0f, 1.9f)) * glm::eulerAngleY(3.14f), texture::redLeather, texture::redLeatherNormal, texture::redLeatherARM);
+	drawObjectPBR(models::sideTableContext, glm::translate(glm::vec3(0.0f, 0.0f, 1.9f)), texture::wood, texture::woodNormal, texture::woodARM);
 	
 	// draw windows
 	drawObjectPBR(models::windowContext, glm::scale(glm::vec3(1.0f, 1.0f, 2.3f)) * glm::translate(glm::vec3(-2.9f, 0, -0.2f)), texture::wood, texture::woodNormal, texture::woodARM);
@@ -654,6 +710,10 @@ void init(GLFWwindow* window)
 
 	programSkybox = shaderLoader.CreateProgram("shaders/shader_skybox.vert", "shaders/shader_skybox.frag");
 	programBlur = shaderLoader.CreateProgram("shaders/shader_blur.vert", "shaders/shader_blur.frag");
+
+	programNoTex = shaderLoader.CreateProgram("shaders/shader_no_pbr.vert", "shaders/shader_no_pbr.frag");
+
+
 	loadCubemap(faces);
 	initDepthMap();
 
@@ -722,7 +782,9 @@ void init(GLFWwindow* window)
 	texture::metalNormal = Core::LoadTexture("textures/lamp/metal_norm.jpg");
 	texture::metalARM = Core::LoadTexture("textures/lamp/metal_arm.jpg");
 
-
+	texture::rust = Core::LoadTexture("textures/rust/rust.jpg");
+	texture::rustNormal = Core::LoadTexture("textures/rust/rust_norm.jpg");
+	texture::rustARM = Core::LoadTexture("textures/rust/rust_arm.jpg");
 
 	loadModelToContext("./models/sphere.obj", sphereContext);
 	loadModelToContext("./models/cube.obj", cubeContext);
@@ -752,6 +814,7 @@ void init(GLFWwindow* window)
 	loadModelToContext("./models/easel/easel3.obj", models::easelContext);
 	loadModelToContext("./models/car/car.obj", models::carContext);
 	loadModelToContext("./models/ceramic_vase_02_4k.obj", models::vaseContext);
+	loadModelToContext("./models/side_table.obj", models::sideTableContext);
 
 	initDepthMap();
 	initDepthMapShip();