From d8cb09f097b6ef6c46260fe296b68140edae7d47 Mon Sep 17 00:00:00 2001 From: devZoGok Date: Wed, 1 Dec 2021 19:58:44 +0200 Subject: [PATCH] refactored shaders --- brdfIntegration.frag | 127 ++++++++++++++++---------------------- brdfIntegration.vert | 4 +- environmentPreFilter.frag | 97 ++++++++++++----------------- environmentPreFilter.vert | 4 +- irradiance.frag | 26 ++++---- irradiance.vert | 4 +- mesh.cpp | 4 ++ mesh.h | 4 +- pbrSample.cpp | 77 ++++++++++++++++------- shader.cpp | 5 ++ shader.h | 1 + 11 files changed, 179 insertions(+), 174 deletions(-) diff --git a/brdfIntegration.frag b/brdfIntegration.frag index d8cc26f..a540866 100644 --- a/brdfIntegration.frag +++ b/brdfIntegration.frag @@ -1,14 +1,15 @@ #version 330 core out vec4 FragColor; -in vec2 TexCoords; +in vec2 texCoords; + +uniform uint numSamples; const float PI = 3.14159265359; -// ---------------------------------------------------------------------------- + // http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html // efficient VanDerCorpus calculation. -float RadicalInverse_VdC(uint bits) -{ +float radicalInverseVdC(uint bits) { bits = (bits << 16u) | (bits >> 16u); bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u); bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u); @@ -16,99 +17,77 @@ float RadicalInverse_VdC(uint bits) bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u); return float(bits) * 2.3283064365386963e-10; // / 0x100000000 } -// ---------------------------------------------------------------------------- -vec2 Hammersley(uint i, uint N) -{ - return vec2(float(i)/float(N), RadicalInverse_VdC(i)); + +vec2 hammersley(uint i, uint normal) { + return vec2(float(i) / float(normal), radicalInverseVdC(i)); } -// ---------------------------------------------------------------------------- -vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness) -{ - float a = roughness*roughness; - + +vec3 importanceSampleGGX(vec2 Xi, vec3 normal, float a) { float phi = 2.0 * PI * Xi.x; - float cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a*a - 1.0) * Xi.y)); - float sinTheta = sqrt(1.0 - cosTheta*cosTheta); + float cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a * a - 1.0) * Xi.y)); + float sinTheta = sqrt(1.0 - cosTheta * cosTheta); // from spherical coordinates to cartesian coordinates - halfway vector - vec3 H; - H.x = cos(phi) * sinTheta; - H.y = sin(phi) * sinTheta; - H.z = cosTheta; + vec3 halfVec = vec3(cos(phi) * sinTheta, sin(phi) * sinTheta, cosTheta); // from tangent-space H vector to world-space sample vector - vec3 up = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0); - vec3 tangent = normalize(cross(up, N)); - vec3 bitangent = cross(N, tangent); + vec3 up = (abs(normal.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0)); + vec3 tan = normalize(cross(up, normal)); + vec3 biTan = cross(normal, tan); - vec3 sampleVec = tangent * H.x + bitangent * H.y + N * H.z; + vec3 sampleVec = tan * halfVec.x + biTan * halfVec.y + normal * halfVec.z; return normalize(sampleVec); } -// ---------------------------------------------------------------------------- -float GeometrySchlickGGX(float NdotV, float roughness) -{ - // note that we use a different k for IBL - float a = roughness; - float k = (a * a) / 2.0; - float nom = NdotV; - float denom = NdotV * (1.0 - k) + k; - - return nom / denom; +float schlickGGX(float nDotV, float k) { + return nDotV / (nDotV * (1.0 - k) + k); } -// ---------------------------------------------------------------------------- -float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) -{ - float NdotV = max(dot(N, V), 0.0); - float NdotL = max(dot(N, L), 0.0); - float ggx2 = GeometrySchlickGGX(NdotV, roughness); - float ggx1 = GeometrySchlickGGX(NdotL, roughness); + +float geoSmith(vec3 normal, vec3 viewDir, vec3 lightDir, float roughness) { + float nDotV = max(dot(normal, viewDir), 0.0); + float nDotL = max(dot(normal, lightDir), 0.0); + float k = pow(roughness, 4) / 2.0; + float ggx2 = schlickGGX(nDotV, k); + float ggx1 = schlickGGX(nDotL, k); return ggx1 * ggx2; } -// ---------------------------------------------------------------------------- -vec2 IntegrateBRDF(float NdotV, float roughness) -{ - vec3 V; - V.x = sqrt(1.0 - NdotV*NdotV); - V.y = 0.0; - V.z = NdotV; - float A = 0.0; - float B = 0.0; +vec2 integrateBRDF(float nDotV, float roughness) { + vec3 viewDir = vec3(sqrt(1.0 - nDotV * nDotV), 0.0, nDotV); - vec3 N = vec3(0.0, 0.0, 1.0); - - const uint SAMPLE_COUNT = 1024u; - for(uint i = 0u; i < SAMPLE_COUNT; ++i) - { + float a = 0.0; + float b = 0.0; + + vec3 normal = vec3(0.0, 0.0, 1.0); + + for(uint i = 0u; i < numSamples; ++i) { // generates a sample vector that's biased towards the // preferred alignment direction (importance sampling). - vec2 Xi = Hammersley(i, SAMPLE_COUNT); - vec3 H = ImportanceSampleGGX(Xi, N, roughness); - vec3 L = normalize(2.0 * dot(V, H) * H - V); + vec2 Xi = hammersley(i, numSamples); + vec3 halfVec = importanceSampleGGX(Xi, normal, roughness); + vec3 lightDir = normalize(2.0 * dot(viewDir, halfVec) * halfVec - viewDir); - float NdotL = max(L.z, 0.0); - float NdotH = max(H.z, 0.0); - float VdotH = max(dot(V, H), 0.0); + float nDotL = max(lightDir.z, 0.0); + float nDotH = max(halfVec.z, 0.0); + float vDotH = max(dot(viewDir, halfVec), 0.0); - if(NdotL > 0.0) - { - float G = GeometrySmith(N, V, L, roughness); - float G_Vis = (G * VdotH) / (NdotH * NdotV); - float Fc = pow(1.0 - VdotH, 5.0); + if(nDotL > 0.0) { + float G = geoSmith(normal, viewDir, lightDir, roughness); + float gVis = (G * vDotH) / (nDotH * nDotV); + float fc = pow(1.0 - vDotH, 5.0); - A += (1.0 - Fc) * G_Vis; - B += Fc * G_Vis; + a += (1.0 - fc) * gVis; + b += fc * gVis; } } - A /= float(SAMPLE_COUNT); - B /= float(SAMPLE_COUNT); - return vec2(A, B); + + a /= float(numSamples); + b /= float(numSamples); + return vec2(a, b); } -// ---------------------------------------------------------------------------- -void main() -{ - vec2 integratedBRDF = IntegrateBRDF(TexCoords.x, TexCoords.y); + +void main() { + vec2 integratedBRDF = integrateBRDF(texCoords.x, texCoords.y); FragColor = vec4(integratedBRDF, 0, 1); } diff --git a/brdfIntegration.vert b/brdfIntegration.vert index 157f634..9e745fa 100644 --- a/brdfIntegration.vert +++ b/brdfIntegration.vert @@ -4,9 +4,9 @@ layout (location = 0) in vec3 aPos; layout (location = 1) in vec3 aNormal; layout (location = 2) in vec2 aTexCoords; -out vec2 TexCoords; +out vec2 texCoords; void main(){ - TexCoords = aTexCoords; + texCoords = aTexCoords; gl_Position = vec4(aPos, 1); } diff --git a/environmentPreFilter.frag b/environmentPreFilter.frag index ed37ef3..16125dd 100644 --- a/environmentPreFilter.frag +++ b/environmentPreFilter.frag @@ -1,30 +1,23 @@ #version 330 core +# out vec4 FragColor; -in vec3 WorldPos; +in vec3 fragPos; uniform samplerCube environmentMap; uniform float roughness; +uniform float resolution; +uniform uint numSamples; const float PI = 3.14159265359; -// ---------------------------------------------------------------------------- -float DistributionGGX(vec3 N, vec3 H, float roughness) -{ - float a = roughness*roughness; - float a2 = a*a; - float NdotH = max(dot(N, H), 0.0); - float NdotH2 = NdotH*NdotH; - float nom = a2; - float denom = (NdotH2 * (a2 - 1.0) + 1.0); - denom = PI * denom * denom; - - return nom / denom; +float trowbridgeReitz(vec3 normal, vec3 halfVec, float alpha) { + float nDotH = max(dot(normal, halfVec), 0.0); + return (alpha * alpha) / (PI * pow(nDotH * nDotH * (alpha * alpha - 1) + 1, 2)); } -// ---------------------------------------------------------------------------- + // http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html // efficient VanDerCorpus calculation. -float RadicalInverse_VdC(uint bits) -{ +float radicalInverseVdC(uint bits) { bits = (bits << 16u) | (bits >> 16u); bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u); bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u); @@ -32,75 +25,63 @@ float RadicalInverse_VdC(uint bits) bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u); return float(bits) * 2.3283064365386963e-10; // / 0x100000000 } -// ---------------------------------------------------------------------------- -vec2 Hammersley(uint i, uint N) -{ - return vec2(float(i)/float(N), RadicalInverse_VdC(i)); + +vec2 hammersley(uint i, uint normal) { + return vec2(float(i) / float(normal), radicalInverseVdC(i)); } -// ---------------------------------------------------------------------------- -vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness) -{ - float a = roughness*roughness; - + +vec3 importanceSampleGGX(vec2 Xi, vec3 normal, float a) { float phi = 2.0 * PI * Xi.x; float cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a*a - 1.0) * Xi.y)); float sinTheta = sqrt(1.0 - cosTheta*cosTheta); // from spherical coordinates to cartesian coordinates - halfway vector - vec3 H; - H.x = cos(phi) * sinTheta; - H.y = sin(phi) * sinTheta; - H.z = cosTheta; + vec3 halfVec = vec3(cos(phi) * sinTheta, sin(phi) * sinTheta, cosTheta); // from tangent-space H vector to world-space sample vector - vec3 up = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0); - vec3 tangent = normalize(cross(up, N)); - vec3 bitangent = cross(N, tangent); + vec3 up = (abs(normal.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0)); + vec3 tan = normalize(cross(up, normal)); + vec3 bitan = cross(normal, tan); - vec3 sampleVec = tangent * H.x + bitangent * H.y + N * H.z; + vec3 sampleVec = tan * halfVec.x + bitan * halfVec.y + normal * halfVec.z; return normalize(sampleVec); } -// ---------------------------------------------------------------------------- -void main() -{ - vec3 N = normalize(WorldPos); + +void main() { + vec3 normal = normalize(fragPos); // make the simplyfying assumption that V equals R equals the normal - vec3 R = N; - vec3 V = R; + vec3 reflVec = normal; + vec3 viewVec = reflVec; - const uint SAMPLE_COUNT = 1024u; vec3 prefilteredColor = vec3(0.0); float totalWeight = 0.0; - for(uint i = 0u; i < SAMPLE_COUNT; ++i) - { + for(uint i = 0u; i < numSamples; ++i) { // generates a sample vector that's biased towards the preferred alignment direction (importance sampling). - vec2 Xi = Hammersley(i, SAMPLE_COUNT); - vec3 H = ImportanceSampleGGX(Xi, N, roughness); - vec3 L = normalize(2.0 * dot(V, H) * H - V); + vec2 Xi = hammersley(i, numSamples); + vec3 halfVec = importanceSampleGGX(Xi, normal, roughness * roughness); + vec3 lightVec = normalize(2.0 * dot(viewVec, halfVec) * halfVec - viewVec); + float nDotL = max(dot(normal, lightVec), 0.0); - float NdotL = max(dot(N, L), 0.0); - if(NdotL > 0.0) - { + if(nDotL > 0.0) { // sample from the environment's mip level based on roughness/pdf - float D = DistributionGGX(N, H, roughness); - float NdotH = max(dot(N, H), 0.0); - float HdotV = max(dot(H, V), 0.0); - float pdf = D * NdotH / (4.0 * HdotV) + 0.0001; + float D = trowbridgeReitz(normal, halfVec, roughness * roughness); + float nDotH = max(dot(normal, halfVec), 0.0); + float hDotV = max(dot(halfVec, viewVec), 0.0); + float pdf = max(D * nDotH / (4.0 * hDotV), 0.0001); - float resolution = 512.0; // resolution of source cubemap (per face) float saTexel = 4.0 * PI / (6.0 * resolution * resolution); - float saSample = 1.0 / (float(SAMPLE_COUNT) * pdf + 0.0001); + float saSample = 1.0 / max(float(numSamples) * pdf, 0.0001); - float mipLevel = roughness == 0.0 ? 0.0 : 0.5 * log2(saSample / saTexel); + float mipLevel = (roughness == 0.0 ? 0.0 : 0.5 * log2(saSample / saTexel)); - prefilteredColor += textureLod(environmentMap, L, mipLevel).rgb * NdotL; - totalWeight += NdotL; + prefilteredColor += textureLod(environmentMap, lightVec, mipLevel).rgb * nDotL; + totalWeight += nDotL; } } - prefilteredColor = prefilteredColor / totalWeight; + prefilteredColor /= totalWeight; FragColor = vec4(prefilteredColor, 1.0); } diff --git a/environmentPreFilter.vert b/environmentPreFilter.vert index 83c6ea0..c3f1bf0 100644 --- a/environmentPreFilter.vert +++ b/environmentPreFilter.vert @@ -2,12 +2,12 @@ layout (location = 0) in vec3 aPos; -out vec3 WorldPos; +out vec3 fragPos; uniform mat4 proj; uniform mat4 view; void main(){ - WorldPos = aPos; + fragPos = aPos; gl_Position = proj * view * vec4(aPos, 1); } diff --git a/irradiance.frag b/irradiance.frag index f8075ca..ec043f5 100644 --- a/irradiance.frag +++ b/irradiance.frag @@ -1,37 +1,37 @@ #version 330 core + out vec4 FragColor; -in vec3 WorldPos; +in vec3 fragPos; uniform samplerCube environmentMap; +uniform float sampleDelta; const float PI = 3.14159265359; -void main() -{ - vec3 N = normalize(WorldPos); +void main() { + vec3 normal = normalize(fragPos); vec3 irradiance = vec3(0.0); // tangent space calculation from origin point - vec3 up = vec3(0.0, 1.0, 0.0); - vec3 right = cross(up, N); - up = cross(N, right); + vec3 up = vec3(0.0, 1.0, 0.0); + vec3 right = cross(up, normal); + up = cross(normal, right); - float sampleDelta = 0.5; float nrSamples = 0.0f; - for(float phi = 0.0; phi < 2.0 * PI; phi += sampleDelta) - { - for(float theta = 0.0; theta < 0.5 * PI; theta += sampleDelta) - { + + for(float phi = 0.0; phi < 2.0 * PI; phi += sampleDelta) { + for(float theta = 0.0; theta < 0.5 * PI; theta += sampleDelta) { // spherical to cartesian (in tangent space) vec3 tangentSample = vec3(sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta)); // tangent space to world - vec3 sampleVec = tangentSample.x * right + tangentSample.y * up + tangentSample.z * N; + vec3 sampleVec = tangentSample.x * right + tangentSample.y * up + tangentSample.z * normal; irradiance += texture(environmentMap, sampleVec).rgb * cos(theta) * sin(theta); nrSamples++; } } + irradiance = PI * irradiance * (1.0 / float(nrSamples)); FragColor = vec4(irradiance, 1.0); diff --git a/irradiance.vert b/irradiance.vert index 83c6ea0..c3f1bf0 100644 --- a/irradiance.vert +++ b/irradiance.vert @@ -2,12 +2,12 @@ layout (location = 0) in vec3 aPos; -out vec3 WorldPos; +out vec3 fragPos; uniform mat4 proj; uniform mat4 view; void main(){ - WorldPos = aPos; + fragPos = aPos; gl_Position = proj * view * vec4(aPos, 1); } diff --git a/mesh.cpp b/mesh.cpp index 46ee880..c172726 100755 --- a/mesh.cpp +++ b/mesh.cpp @@ -320,6 +320,7 @@ namespace vb01{ irradianceShader->use(); irradianceShader->setMat4(proj, "proj"); irradianceShader->setInt(0, "environmentMap"); + irradianceShader->setFloat(irradianceSampleDelta, "sampleDelta"); prefilterMap->select(); Root *root = Root::getSingleton(); @@ -349,6 +350,8 @@ namespace vb01{ environmentShader->use(); environmentShader->setMat4(proj, "proj"); environmentShader->setInt(0, "environmentMap"); + environmentShader->setFloat(preFilterMapSize, "resolution"); + environmentShader->setUnsignedInt(numSamples, "numSamples"); prefilterMap->select(); @@ -392,6 +395,7 @@ namespace vb01{ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, *brdfIntegrationMap->getTexture(), 0); brdfIntegrationShader->use(); + brdfIntegrationShader->setUnsignedInt(numSamples, "numSamples"); Root *root = Root::getSingleton(); root->getBrdfLutPlane()->render(); diff --git a/mesh.h b/mesh.h index 832d116..61dcb6f 100755 --- a/mesh.h +++ b/mesh.h @@ -73,7 +73,9 @@ namespace vb01{ void updateShapeKeys(Shader*); inline glm::vec3 getUpVec(glm::vec3 dir){return (fabs(dir.y) == 1 ? glm::vec3(0, 0, -1) : glm::vec3(0, 1, 0));} - int irradianceMapSize = 32, preFilterMapSize = 512, environmentMapSize = 128, brdfMapSize = 512; + int irradianceMapSize = 32, preFilterMapSize = 512, environmentMapSize = 128, brdfMapSize = 512; + u32 numSamples = 1024; + float irradianceSampleDelta = 0.5; Texture *prefilterMap = nullptr, *irradianceMap = nullptr, *postfilterMap = nullptr, *brdfIntegrationMap = nullptr; Shader *environmentShader = nullptr, *irradianceShader = nullptr, *brdfIntegrationShader = nullptr; u32 preFilterFramebuffer, preFilterRenderbuffer, irrandianceFramebuffer, irradianceRenderbuffer, postFilterFramebuffer, postFilterRenderbuffer, brdfFramebuffer, brdfRenderbuffer; diff --git a/pbrSample.cpp b/pbrSample.cpp index d006482..69bfc99 100644 --- a/pbrSample.cpp +++ b/pbrSample.cpp @@ -4,6 +4,7 @@ #include "texture.h" #include "light.h" #include "box.h" +#include "quad.h" #include @@ -13,12 +14,12 @@ using namespace std; int main() { const string PATH = "../", TEX_PATH = PATH + "samples/textures/", MODEL_PATH = PATH + "samples/models/"; string skyboxTextures[] = { - TEX_PATH + "top.jpg", - TEX_PATH + "bottom.jpg", - TEX_PATH + "left.jpg", - TEX_PATH + "right.jpg", - TEX_PATH + "front.jpg", - TEX_PATH + "back.jpg" + TEX_PATH + "bricks.jpg", + TEX_PATH + "bricks.jpg", + TEX_PATH + "bricks.jpg", + TEX_PATH + "bricks.jpg", + TEX_PATH + "bricks.jpg", + TEX_PATH + "bricks.jpg" }; /* @@ -30,36 +31,68 @@ int main() { root->createSkybox(skyboxTextures); Camera *cam = root->getCamera(); - cam->setPosition(Vector3(0, 1, 1) * 7); - cam->lookAt(Vector3(0, -1, -1).norm(), Vector3(0, 1, -1).norm()); + cam->setPosition(Vector3(1, 1, 1) * 2); + cam->lookAt(Vector3(-1, -1, -1).norm(), Vector3(-1, 1, -1).norm()); Node *rootNode = root->getRootNode(); - Model *model = new Model(MODEL_PATH + "teapot.vb"); + Model *model = new Model(MODEL_PATH + "sphere.vb"); model->setReflect(true); Material *mat = new Material(PATH + "pbr"); - mat->addBoolUniform("albedoMapEnabled", true); - mat->addBoolUniform("normalMapEnabled", true); - mat->addBoolUniform("roughnessMapEnabled", true); - mat->addBoolUniform("metallnessMapEnabled", true); - mat->addBoolUniform("ambientOcclusionMapEnabled", true); - mat->addBoolUniform("environmentMapEnabled", false); - string fr0[]{TEX_PATH + "geyser-rock1_albedo.jpg"}; - string fr1[]{TEX_PATH + "geyser-rock1_normal.jpg"}; - string fr2[]{TEX_PATH + "geyser-rock1_roughness.jpg"}; - string fr3[]{TEX_PATH + "geyser-rock1_metallic.jpg"}; - string fr4[]{TEX_PATH + "geyser-rock1_ao.jpg"}; + mat->addBoolUniform("albedoMapEnabled", false); + mat->addBoolUniform("normalMapEnabled", false); + mat->addBoolUniform("roughnessMapEnabled", false); + mat->addBoolUniform("metalnessMapEnabled", false); + mat->addBoolUniform("ambientOcclusionMapEnabled", false); + mat->addBoolUniform("environmentMapEnabled", true); + mat->addVec4Uniform("albedoColor", Vector4(1, .764, .03, 1)); + mat->addFloatUniform("metalnessVal", .9); + mat->addFloatUniform("roughnessVal", .1); + mat->addFloatUniform("ambientOcclusion", .1); + /* + string fr0[]{TEX_PATH + "rustediron2_albedo.jpg"}; + string fr1[]{TEX_PATH + "rustediron2_normal.jpg"}; + string fr2[]{TEX_PATH + "rustediron2_roughness.jpg"}; + string fr3[]{TEX_PATH + "rustediron2_metallic.jpg"}; + string fr4[]{TEX_PATH + "rustediron2_ao.jpg"}; mat->addTexUniform("textures[0]", new Texture(fr0, 1, false), true); mat->addTexUniform("textures[1]", new Texture(fr1, 1, false), true); mat->addTexUniform("textures[2]", new Texture(fr2, 1, false), true); mat->addTexUniform("textures[3]", new Texture(fr3, 1, false), true); mat->addTexUniform("textures[4]", new Texture(fr4, 1, false), true); + */ model->setMaterial(mat); rootNode->attachChild(model); + model->setPosition(Vector3(0, 0, 0)); + { + Node *lightNode = new Node(); + Box *b = new Box(Vector3(1, 1, 1) * 1); + Material *m = new Material(PATH + "skybox"); + m->addTexUniform("tex", model->getChild(0)->getMesh(0)->getPostfilterMap(), true); + b->setMaterial(m); + lightNode->attachMesh(b); + rootNode->attachChild(lightNode); + lightNode->setPosition(Vector3(0, 0, 0)); + lightNode->setOrientation(Quaternion(1.57, Vector3::VEC_I)); + } + { + Node *lightNode = new Node(); + Quad *b = new Quad(Vector3(2, 2, 1), false); + Material *m = new Material(PATH + "texture"); + m->addBoolUniform("texturingEnabled", true); + m->addBoolUniform("lightingEnabled", false); + //m->addVec4Uniform("diffuseColor", Vector4(0, 0, 1, 1)); + m->addTexUniform("textures[0]", model->getChild(0)->getMesh(0)->getBrdfIntegrationMap(), true); + b->setMaterial(m); + lightNode->attachMesh(b); + rootNode->attachChild(lightNode); + lightNode->setPosition(Vector3(-4, 1, 0)); + lightNode->setOrientation(Quaternion(1.57, Vector3::VEC_I)); + } { Light *light = new Light(Light::POINT); - light->setColor(Vector3(10, 10, 10)); + light->setColor(Vector3(1, 1, 1) * 10); Node *lightNode = new Node(); Box *b = new Box(Vector3(1, 1, 1) * .1); Material *m = new Material(PATH + "texture"); @@ -70,7 +103,7 @@ int main() { lightNode->attachMesh(b); lightNode->addLight(light); rootNode->attachChild(lightNode); - lightNode->setPosition(Vector3(2, 3, 2)); + lightNode->setPosition(Vector3(0, 4, 3)); lightNode->setOrientation(Quaternion(1.57, Vector3::VEC_I)); } { diff --git a/shader.cpp b/shader.cpp index c004564..79e6035 100755 --- a/shader.cpp +++ b/shader.cpp @@ -224,4 +224,9 @@ namespace vb01{ int uniformLoc = glGetUniformLocation(id, var.c_str()); glUniform1i(uniformLoc, i); } + + void Shader::setUnsignedInt(u32 i, string var){ + int uniformLoc = glGetUniformLocation(id, var.c_str()); + glUniform1ui(uniformLoc, i); + } } diff --git a/shader.h b/shader.h index 7c9bc57..7092516 100755 --- a/shader.h +++ b/shader.h @@ -28,6 +28,7 @@ namespace vb01{ void setFloat(float, std::string); void setBool(bool, std::string); void setInt(int, std::string); + void setUnsignedInt(u32, std::string); void editShader(ShaderType, int, std::string); inline bool isGeometry(){return geometry;} private: