// // BumpMapping.cpp // BumpMapping // // Created by John Ryland on 2/10/17. // Copyright © 2017 John Ryland. All rights reserved. // #include "../Framework/Framework.h" #include "../Platform/Paths.h" DECLARE_PROGRAM_UNIFORMS(BumpProgram) DECLARE_UNIFORM(mat4, modelViewMatrix) DECLARE_UNIFORM(mat3, normalMatrix) DECLARE_UNIFORM(mat4, modelViewProjectionMatrix) DECLARE_UNIFORM(sampler2D, texture__ao__Id) DECLARE_UNIFORM(sampler2D, texture_col1_Id) DECLARE_UNIFORM(sampler2D, texture_col2_Id) DECLARE_UNIFORM(sampler2D, texture_disp_Id) DECLARE_UNIFORM(sampler2D, texture_glos_Id) DECLARE_UNIFORM(sampler2D, texture_norm_Id) DECLARE_UNIFORM(sampler2D, texture_refl_Id) DECLARE_PROGRAM_UNIFORMS_END // pos 3, tangent-space quat 4, uv 2 -> possible to fit in 9 float values - is 8 possible? DECLARE_VERTEX(BumpVertex) DECLARE_ATTRIB(vec3, pos, GL_FALSE) DECLARE_ATTRIB(vec3, normal, GL_FALSE) DECLARE_ATTRIB(vec3, tangent, GL_FALSE) //DECLARE_ATTRIB(vec3, binormal, GL_FALSE) DECLARE_ATTRIB(vec2, uv, GL_FALSE) DECLARE_VERTEX_END class BumpMapping : public DemoContext { public: ~BumpMapping() override; void prepare() override; void update(float a_seconds) override; void draw() override; void onResize(const vec2f& a_shape) override; private: ProgramContext2 m_demoModelContext; float m_projectionMatrix[16]; }; #define SHADER_VARS R"( varying vec2 texCoord; varying vec3 lightVec1; varying vec3 lightVec2; //varying vec3 halfVec; //varying vec3 eyeVec; varying vec3 camVec; //varying vec3 col; varying float lightDistSqr1; varying float lightDistSqr2; )" const char* s_bumpedVertexShader = SHADER_VARS R"( mat3 calculateTagentSpace() { // TBN -> 'tangent space' -> basically it is 3 ortho normal vectors which define the basis vectors or 3 axis -> eg: a rotation matrix // This 3x3 rotation matrix (or 3 vec3 vectors) can also be represented more simply using a quaternion apparently -> TODO: figure out as quots // Also apparently the tangent is best calculated by an exporter and is part of the model data vec3 n = normalize(normalMatrix * normal).xyz; // normal vec3 t = normalize(normalMatrix * tangent).xyz; // tangent vec3 b = cross(n, t); // bi-normal //col = binormal; return mat3(t,b,n); } void calculateTagentSpaceLighting(mat3 tbn) { vec3 t = tbn[0]; vec3 b = tbn[1]; vec3 n = tbn[2]; vec3 vertexPos = vec3(modelViewMatrix * vec4(pos, 1.0)); // vertex position vec3 cameraPos = vec3(0.0, 0.0, 0.0); // camera position vec3 lightPos1 = vec3(4.0, 8.0, -7.0); // light position vec3 lightPos2 = vec3(-8.0, -4.0, 5.0); // light position vec3 camDir = normalize(cameraPos - vertexPos); //vec3 halfVector = normalize(vertexPos + lightDir); // transform light and half angle vectors by tangent basis //eyeVec = normalize( vec3( dot(vertexPos, t), dot(vertexPos, b), dot(vertexPos, n) ) ); //halfVec = normalize( vec3( dot(halfVector, t), dot(halfVector, b), dot(halfVector, n) ) ); camVec = vec3( dot(camDir, t), dot(camDir, b), dot(camDir, n) ); vec3 lightDir1 = normalize(lightPos1 - vertexPos); // light direction vec3 lightDir2 = normalize(lightPos2 - vertexPos); // light direction lightVec1 = vec3( dot(lightDir1, t), dot(lightDir1, b), dot(lightDir1, n) ); lightVec2 = vec3( dot(lightDir2, t), dot(lightDir2, b), dot(lightDir2, n) ); lightDistSqr1 = length(lightPos1 - vertexPos); lightDistSqr1 = lightDistSqr1 * lightDistSqr1; lightDistSqr2 = length(lightPos2 - vertexPos); lightDistSqr2 = lightDistSqr2 * lightDistSqr2; } void main() { texCoord = uv; gl_Position = modelViewProjectionMatrix * vec4(pos, 1.0); mat3 tbn = calculateTagentSpace(); calculateTagentSpaceLighting(tbn); } )"; const char* s_bumpedFragmentShader = SHADER_VARS R"( /* vec3 Gsub(vec3 v) // Sub Function of G { float k = ((roughness + 1) * (roughness + 1)) / 8; float fdotv = dot(fNormal, v); return vec3((fdotv) / ((fdotv) * (1.0 - k) + k)); } vec3 G(vec3 l, vec3 v, vec3 h) // Geometric Attenuation Term - Schlick Modified (k = a/2) { return Gsub(l) * Gsub(v); } */ #if 1 const float parallaxScale = 0.03; // ~0.1 vec2 parallaxMapping(in vec3 V, in vec2 T, out float parallaxHeight) { // determine number of layers from angle between V and N const float minLayers = 2.0; const float maxLayers = 30.0; float numLayers = mix(maxLayers, minLayers, abs(dot(vec3(0.0, 0.0, 1.0), V))); // height of each layer float layerHeight = 1.0 / numLayers; // depth of current layer float currentLayerHeight = 0.0; // shift of texture coordinates for each iteration vec2 dtex = parallaxScale * V.xy /* / V.z */ / numLayers; // current texture coordinates vec2 currentTextureCoords = T; // get first depth from heightmap float heightFromTexture = texture2D(texture_disp_Id, currentTextureCoords).x;// texture(u_heightTexture, currentTextureCoords).r; // while point is above surface while (heightFromTexture > currentLayerHeight) { // to the next layer currentLayerHeight += layerHeight; // shift texture coordinates along vector V currentTextureCoords -= dtex; // get new depth from heightmap heightFromTexture = texture2D(texture_disp_Id, currentTextureCoords).r; } /////////////////////////////////////////////////////////// // previous texture coordinates vec2 prevTCoords = currentTextureCoords + dtex; // heights for linear interpolation float nextH = heightFromTexture - currentLayerHeight; float prevH = texture2D(texture_disp_Id, prevTCoords).r - currentLayerHeight + layerHeight; // proportions for linear interpolation float weight = nextH / (nextH - prevH); // interpolation of texture coordinates vec2 finalTexCoords = prevTCoords * weight + currentTextureCoords * (1.0-weight); // interpolation of depth values parallaxHeight = currentLayerHeight + prevH * weight + nextH * (1.0 - weight); return finalTexCoords; // return results //parallaxHeight = currentLayerHeight; //return currentTextureCoords; } float parallaxSoftShadowMultiplier(in vec3 L, in vec2 initialTexCoord, in float initialHeight) { float shadowMultiplier = 1.0; const float minLayers = 15.0; const float maxLayers = 30.0; // calculate lighting only for surface oriented to the light source if(dot(vec3(0.0, 0.0, 1.0), L) > 0.0) { // calculate initial parameters float numSamplesUnderSurface = 0.0; shadowMultiplier = 0.0; float numLayers = mix(maxLayers, minLayers, abs(dot(vec3(0.0, 0.0, 1.0), L))); float layerHeight = initialHeight / numLayers; vec2 texStep = parallaxScale * L.xy / L.z / numLayers; // current parameters float currentLayerHeight = initialHeight - layerHeight; vec2 currentTextureCoords = initialTexCoord + texStep; float heightFromTexture = texture2D(texture_disp_Id, currentTextureCoords).r; float stepIndex = 1.0; // while point is below depth 0.0 ) while(currentLayerHeight > 0.0) { // if point is under the surface if(heightFromTexture < currentLayerHeight) { // calculate partial shadowing factor numSamplesUnderSurface += 1.0; float newShadowMultiplier = (currentLayerHeight - heightFromTexture) * (1.0 - stepIndex / numLayers); shadowMultiplier = max(shadowMultiplier, newShadowMultiplier); } // offset to the next layer stepIndex += 1.0; currentLayerHeight -= layerHeight; currentTextureCoords += texStep; heightFromTexture = texture2D(texture_disp_Id, currentTextureCoords).r; } // Shadowing factor should be 1 if there were no points under the surface if(numSamplesUnderSurface < 1.0) { shadowMultiplier = 1.0; } else { shadowMultiplier = 1.0 - shadowMultiplier; } } return shadowMultiplier; } #endif void main() { vec3 V = normalize(camVec); vec3 L1 = normalize(lightVec1); vec3 L2 = normalize(lightVec2); float parallaxHeight; vec2 T = texCoord; float shadowMultiplier = 1.0; //T -= 0.1 * V.xy * texture2D(texture_disp_Id, T).x; T = parallaxMapping(V, T, parallaxHeight); shadowMultiplier = parallaxSoftShadowMultiplier(L1, texCoord, parallaxHeight - 0.01); float _ao_ = texture2D(texture__ao__Id, T).x; vec4 col1 = texture2D(texture_col1_Id, T); // ambient vec4 col2 = texture2D(texture_col2_Id, T); // albedo float glos = texture2D(texture_glos_Id, T).x; vec3 norm = texture2D(texture_norm_Id, T).xyz; float refl = texture2D(texture_refl_Id, T).x; //norm = (2.0 * normalize(norm)) - vec3(1.0); norm = normalize((2.0 * norm) - vec3(1.0)); float NdotL1 = dot(norm, L1);// * 50.0 / lightDistSqr1; float NdotL2 = dot(norm, L2);// * 50.0 / lightDistSqr2; float ambientFactor = 0.2; float diffuseFactor = clamp(NdotL1 + NdotL2, 0.0, 1.0); float specularFactor = 0.0; /* if (NdotL1 > 0.2) { //specularFactor = glos * pow(1.5 * dot(reflect(-L, norm), V), refl * 50.0); // specularFactor = glos * clamp(pow(1.8 * dot(normalize(halfVec), norm), refl * 30.0), 0.0, 1.0); //col += vec4(1.0 - glos) * col2 * diffuseFactor * 100.0 / lightDistSqr; } */ gl_FragColor = vec4(col2.xyz * /* _ao_ * */ (ambientFactor + (diffuseFactor + specularFactor) * pow(shadowMultiplier, 4.0)), 1.0); } )"; BumpMapping::~BumpMapping() { m_demoModelContext.shutdown(); } void BumpMapping::prepare() { // TODO: perhaps the texture list can be parameter to the setup const int textureCount = 7; const char* files[textureCount] = { "-diffuse.png", "-diffuse_var1.png", "-diffuse_var2.png", "-displacement.png", "-gloss.png", "-normals.png", "-reflection.png" /* "__ao_.png", "_col1.png", "_col2.png", "_disp.png", "_glos.png", "_norm.png", "_refl.png" */ }; OptionsType options; m_demoModelContext.setup(s_bumpedVertexShader, s_bumpedFragmentShader, Medium, options, textureCount); std::vector vertexes; CreateBumpCube(vertexes); m_demoModelContext.m_vertexArray.m_vertexData.clear(); m_demoModelContext.m_vertexArray.m_vertexData.reserve(vertexes.size() / 2); for (int i = 0; i < vertexes.size(); i += 4) { vec3f v = vertexes[i+0]; vec3f n = vertexes[i+1]; vec3f t = vertexes[i+2]; //vec3f b = vertexes[i+3]; vec3f uv = vertexes[i+3]; //vec3attrib v3{ 1.0, 2.0, 3.0, 4.0 }; //BumpVertex vert{ v3 }; m_demoModelContext.m_vertexArray.m_vertexData.push_back(BumpVertex{ {v.x,v.y,v.z}, {n.x,n.y,n.z}, {t.x,t.y,t.z}, /* b.x,b.y,b.z, */ {uv.x*0.5f,uv.y*0.5f} }); } m_demoModelContext.update(); m_demoModelContext.setFlag(clearColor | clearDepth | enableCullFace | enableDepthTest); m_demoModelContext.setBackgroundColor(0.0f, 0.0f, 0.0f); std::string basename = "brick01"; basename = "48";//2287";//48";//2287";//"48";//; for (int i = 0; i < textureCount; i++) { std::vector rawImageData; std::vector decodedImageData; uint32_t imageW, imageH; std::string fileName = basename + files[i]; loadFile(fileName.c_str(), rawImageData); decodePNG(decodedImageData, imageW, imageH, rawImageData.data(), rawImageData.size()); m_demoModelContext.setTextureData(i, imageW, imageH, decodedImageData.data()); } //m_demoModelContext.m_uniforms.m_textureId = 0; m_demoModelContext.m_uniforms.m_texture__ao__Id = 0; m_demoModelContext.m_uniforms.m_texture_col1_Id = 1; m_demoModelContext.m_uniforms.m_texture_col2_Id = 2; m_demoModelContext.m_uniforms.m_texture_disp_Id = 3; m_demoModelContext.m_uniforms.m_texture_glos_Id = 4; m_demoModelContext.m_uniforms.m_texture_norm_Id = 5; m_demoModelContext.m_uniforms.m_texture_refl_Id = 6; } void BumpMapping::onResize(const vec2f& a_shape) { Math::makePerspectiveMatrix4x4(m_projectionMatrix, Math::degreesToRadians(45.0f), a_shape.x / a_shape.y, 0.1f, 100.0f); } void BumpMapping::update(float a_seconds) { float baseModelViewMatrix[16]; float modelViewProjectionMatrix[16]; float trans[3] = { 0.0f, 0.0f, -20.0f }; float rotate[3] = { fmod(a_seconds*23.f, 360.0f), fmod(a_seconds*37.f, 360.0f), fmod(a_seconds*46.0f, 360.0f)}; Math::translationRotationScaleToMatrix4x4(baseModelViewMatrix, trans, rotate, 5.0f); Math::multiplyMatrix4x4(modelViewProjectionMatrix, m_projectionMatrix, baseModelViewMatrix); //memcpy(m_demoModelContext.m_uniforms.m_normalMatrix.m, baseModelViewMatrix, sizeof(float)*12); float normalMatrix[16]; float normalMatrix2[16]; Math::makeIdentityMatrix4x4(normalMatrix); //Math::translateMatrix4x4(normalMatrix, trans); Math::rotateMatrix4x4(normalMatrix, rotate); //Math::transposeMatrix4x4(normalMatrix2, normalMatrix); memcpy(m_demoModelContext.m_uniforms.m_normalMatrix.m, normalMatrix, sizeof(float)*12); /* float normalMatrix2[16]; Math::inverseMatrix4x4(normalMatrix2, normalMatrix); Math::transposeMatrix4x4(normalMatrix, normalMatrix2); //Math::inverseMatrix4x4(normalMatrix, baseModelViewMatrix); //Math::transposeMatrix4x4(m_demoModelContext.m_uniforms.m_normalMatrix.m, normalMatrix); //Math::transposeMatrix4x4(m_demoModelContext.m_uniforms.m_normalMatrix.m, normalMatrix); */ /* float normalMatrix[9]; Math::matrix4x4ToNormalMatrix3x3(normalMatrix, baseModelViewMatrix); for (int i = 0; i < 9; i++) m_demoModelContext.m_uniforms.m_normalMatrix.m[(i/3)*4 + (i%3)] = normalMatrix[i]; */ memcpy(m_demoModelContext.m_uniforms.m_modelViewMatrix.m, baseModelViewMatrix, sizeof(float)*16); memcpy(m_demoModelContext.m_uniforms.m_modelViewProjectionMatrix.m, modelViewProjectionMatrix, sizeof(float)*16); } void BumpMapping::draw() { m_demoModelContext.draw(); } REGISTER_DEMO_CONTEXT("Bump Mapping", BumpMapping)