diff options
Diffstat (limited to 'source/lessons/instanced_rendering/planetary models/shaders')
15 files changed, 453 insertions, 0 deletions
diff --git a/source/lessons/instanced_rendering/planetary models/shaders/cubemap.fs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/cubemap.fs.glsl new file mode 100644 index 0000000..72dfe4c --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/cubemap.fs.glsl @@ -0,0 +1,9 @@ +#version 330 core + +in vec3 TexCoords; +uniform samplerCube skybox; +out vec4 FragColor; + +void main() { + FragColor = texture(skybox, TexCoords); +}; diff --git a/source/lessons/instanced_rendering/planetary models/shaders/cubemap.vs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/cubemap.vs.glsl new file mode 100644 index 0000000..956673a --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/cubemap.vs.glsl @@ -0,0 +1,14 @@ +#version 330 core +layout(location=0) in vec3 aPos; + +uniform mat4 Model; +uniform mat4 View; +uniform mat4 Projection; + +out vec3 TexCoords; + +void main() { + vec4 pos = Projection*View*vec4(aPos, 1.0); + gl_Position = vec4(pos.xyww); + TexCoords = aPos; +}; diff --git a/source/lessons/instanced_rendering/planetary models/shaders/depth_test.fs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/depth_test.fs.glsl new file mode 100644 index 0000000..796d849 --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/depth_test.fs.glsl @@ -0,0 +1,30 @@ +#version 330 core + + +in vec2 TexCoords; +in vec3 VertexWorldPos; +uniform sampler2D TexId; +out vec4 FragColor; + +uniform float near = 0.1f; +uniform float far = 100.0f; + +/* @note +float linear_fragment_depth = MakeDepthLinear(non_linear_fragment_depth); +float scaled_lfd = linear_fragment_depth/far; + +gives us the z value in eye space. +This is purely for learning purposes. +The equation used in MakeDepthLinear is derived from the PerspectiveProjectionMatrix. +Take a look at the equation for that in the codebase +or here: https://www.songho.ca/opengl/gl_projectionmatrix.html +*/ +float MakeDepthLinear(float depth) { + float ndc = 2.0f*depth - 1; + float linear_depth = (2.0 * far * near)/(far + near - ndc*(far - near)); + return linear_depth; +} + +void main() { + FragColor = texture(TexId, TexCoords); +} diff --git a/source/lessons/instanced_rendering/planetary models/shaders/depth_test.vs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/depth_test.vs.glsl new file mode 100644 index 0000000..827da20 --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/depth_test.vs.glsl @@ -0,0 +1,21 @@ +#version 330 core +layout(location=0) in vec3 aPos; +layout(location=1) in vec2 aTex; + +uniform mat4 Model; +layout (std140) uniform Matrices { + mat4 View; // start: 0 // end: 16 * 4 = 64 + mat4 Projection; // start: 64 // end: 64 + 64 = 128 +}; + +out vec2 TexCoords; +out vec3 VertexWorldPos; + +// @note: I still do not fully understand how the FragNormal calculation works. Need to make sure I intuitively +// get that + +void main() { + gl_Position = Projection*View*Model*vec4(aPos, 1.0); + VertexWorldPos = vec3(Model * vec4(aPos, 1.0)); + TexCoords = aTex; +}; diff --git a/source/lessons/instanced_rendering/planetary models/shaders/fbo.fs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/fbo.fs.glsl new file mode 100644 index 0000000..e12ad33 --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/fbo.fs.glsl @@ -0,0 +1,72 @@ +#version 330 core + +in vec2 TexCoords; +uniform sampler2D TexId; +out vec4 FragColor; + +vec4 filter_color_invert(vec4 color) +{ + vec4 res = vec4(vec3(1.0) - vec3(color), 1.0); + return res; +} + +vec4 filter_color_grayscale(vec4 color) +{ + // we will need to average the colors + // float average = (color.x + color.y + color.z) / 3.0f; + // in reality, human our most sensitive towards green and least to blue, so will need to weight those + float average = 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b; + vec4 res = vec4(vec3(average), 1.0); + + return res; +} + +// @note: different kernels for experimentation +const float kernel_sharpen[9] = float[]( + -1, -1, -1, + -1, 9, -1, + -1, -1, -1 +); + +const float kernel_blur[9] = float[]( + 1.0/16.0, 2.0/16.0, 1.0/16.0, + 2.0/16.0, 4.0/16.0, 2.0/16.0, + 1.0/16.0, 2.0/16.0, 1.0/16.0 +); + +const float kernel_edge_detection[9] = float[]( + 1, 1, 1, + 1, -8, 1, + 1, 1, 1 +); + +vec4 filter_kernal_effects() +{ + const float offset = 1.0/300.0; + vec2 offsets[9] = vec2[]( + vec2(-offset, offset), // top left + vec2( 0, offset), // top center + vec2( offset, offset), // top right + vec2(-offset, 0), // center left + vec2( 0, 0), // center center + vec2( offset, 0), // center right + vec2(-offset, -offset), // bot left + vec2( 0, -offset), // bot center + vec2( offset, -offset) // bot right + ); + + float kernal[9] = kernel_edge_detection; + vec3 kernalValue = vec3(0.0); + vec3 sampleTex[9]; + for (int i=0; i<9; i++) { + sampleTex[i] = vec3(texture(TexId, TexCoords + offsets[i])); + kernalValue += (kernal[i] * sampleTex[i]); + } + + vec4 res = vec4(kernalValue, 1.0); + return res; +} + +void main() { + FragColor = texture(TexId, TexCoords); +} diff --git a/source/lessons/instanced_rendering/planetary models/shaders/fbo.vs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/fbo.vs.glsl new file mode 100644 index 0000000..82d7211 --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/fbo.vs.glsl @@ -0,0 +1,10 @@ +#version 330 core +layout(location=0) in vec3 aPos; +layout(location=1) in vec2 aTex; + +out vec2 TexCoords; + +void main() { + gl_Position = vec4(aPos.x, aPos.y, 0.0f, 1.0f); + TexCoords = aTex; +}; diff --git a/source/lessons/instanced_rendering/planetary models/shaders/instanced_model.vs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/instanced_model.vs.glsl new file mode 100644 index 0000000..2456a3c --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/instanced_model.vs.glsl @@ -0,0 +1,29 @@ +#version 330 core +layout(location=0) in vec3 aPos; +layout(location=1) in vec3 aNormal; +layout(location=2) in vec2 aTex; +layout(location=3) in mat4 aTransform; + +// uniform mat4 Model; +layout (std140) uniform Matrices { + mat4 View; // start: 0 // end: 16 * 4 = 64 + mat4 Projection; // start: 64 // end: 64 + 64 = 128 +}; + +uniform mat4 Model; + +out vec2 TexCoords; +out vec3 VertexWorldPos; +out vec3 FragNormal; + +// @note: I still do not fully understand how the FragNormal calculation works. Need to make sure I intuitively +// get that + +void main() { + gl_Position = Projection*View*aTransform*vec4(aPos, 1.0); + + VertexWorldPos = vec3(aTransform * vec4(aPos, 1.0)); + FragNormal = mat3(transpose(inverse(aTransform))) * aNormal; + FragNormal = normalize(FragNormal); + TexCoords = aTex; +}; diff --git a/source/lessons/instanced_rendering/planetary models/shaders/instancing.fs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/instancing.fs.glsl new file mode 100644 index 0000000..1ec8011 --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/instancing.fs.glsl @@ -0,0 +1,9 @@ +#version 330 core + + +// uniform sampler2D TexId; +out vec4 FragColor; + +void main() { + FragColor = vec4(gl_FragCoord.x/1024.0, gl_FragCoord.y/768.0, 0.0, 1.0f); +} diff --git a/source/lessons/instanced_rendering/planetary models/shaders/instancing.vs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/instancing.vs.glsl new file mode 100644 index 0000000..eff2fae --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/instancing.vs.glsl @@ -0,0 +1,16 @@ +#version 330 core +layout(location=0) in vec3 aPos; +layout(location=1) in mat4 aOffset; + +// uniform mat4 Model; +layout (std140) uniform Matrices { + mat4 View; // start: 0 // end: 16 * 4 = 64 + mat4 Projection; // start: 64 // end: 64 + 64 = 128 +}; + +// @note: I still do not fully understand how the FragNormal calculation works. Need to make sure I intuitively +// get that + +void main() { + gl_Position = Projection*View*aOffset*vec4(aPos, 1.0); +} diff --git a/source/lessons/instanced_rendering/planetary models/shaders/model.fs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/model.fs.glsl new file mode 100644 index 0000000..dbe5cf4 --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/model.fs.glsl @@ -0,0 +1,150 @@ +#version 330 core + +#define MAX_TEXTURES 32 +struct Material { + sampler2D diffuse[MAX_TEXTURES]; + sampler2D specular[MAX_TEXTURES]; + float shininess; +}; + +struct DirectionalLight { + vec3 direction; + + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +struct PointLight { + vec3 position; + + vec3 ambient; + vec3 diffuse; + vec3 specular; + + // attentuation factors + float kC; + float kL; + float kQ; +}; + +struct SpotLight { + vec3 position; + + vec3 ambient; + vec3 diffuse; + vec3 specular; + + // attenuation factors + float kC; + float kL; + float kQ; + + // vector for the direction directly in front of the spotlight + vec3 front; + + // spot radius + float radius_inner; + float radius_outer; // to smooth out the light + +}; + +// this is the result of a light creation. This contains the multipliers for each kind of a light we want +// to have. +struct LightFactor { + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +in vec2 TexCoords; +in vec3 FragNormal; +in vec3 VertexWorldPos; +uniform Material material; +uniform PointLight pointLight; +uniform DirectionalLight dirLight; +uniform vec3 cameraPosition; + +out vec4 FragColor; + +LightFactor make_directional_light(DirectionalLight light, vec3 CONST_viewDir) { + LightFactor res; + + vec3 DL_lightDir = normalize(-light.direction); + res.ambient = light.ambient; + + float DL_diffuseStrength = max(dot(DL_lightDir, FragNormal), 0.0); + res.diffuse = light.diffuse * DL_diffuseStrength; + + vec3 DL_reflectDir = reflect(-DL_lightDir, FragNormal); + float DL_specularity = max(dot(CONST_viewDir, DL_reflectDir), 0.0); + float DL_shinePower = pow(DL_specularity, material.shininess); + res.specular = light.specular * DL_shinePower; + + return res; +}; + +LightFactor make_point_light(PointLight light, vec3 CONST_viewDir) { + LightFactor res; + + float PL_lightDistance = length(light.position - VertexWorldPos); + float PL_attenuationFactor = 1.0 / + (light.kC + (light.kL * PL_lightDistance) + (light.kQ * PL_lightDistance * PL_lightDistance)); + res.ambient = PL_attenuationFactor * light.ambient; + + vec3 PL_lightDir = normalize(light.position - VertexWorldPos); + float PL_diffuseStrength = max(dot(PL_lightDir, FragNormal), 0.0); + res.diffuse = PL_attenuationFactor * light.diffuse * PL_diffuseStrength; + + vec3 PL_reflectDir = reflect(-PL_lightDir, FragNormal); + float PL_specularity = max(dot(CONST_viewDir, PL_reflectDir), 0.0); + float PL_shinePower = pow(PL_specularity, material.shininess); + res.specular = PL_attenuationFactor * PL_shinePower * light.specular; + + return res; +} + +LightFactor make_spot_light(SpotLight light, vec3 CONST_viewDir) { + LightFactor res; + + float SL_lightDistance = length(light.position - VertexWorldPos); + float SL_attenuationFactor = 1.0 / + (light.kC + (light.kL * SL_lightDistance) + (light.kQ * SL_lightDistance * SL_lightDistance)); + vec3 SL_lightDir = normalize(light.position - VertexWorldPos); + + res.ambient = SL_attenuationFactor * light.ambient; + + float SL_diffAmount = dot(SL_lightDir, normalize(-light.front)); + float SL_spotLightFadeFactor = clamp((SL_diffAmount - light.radius_outer)/(light.radius_inner - light.radius_outer), 0.0f, 1.0f); + float SL_diffuseStrength = max(dot(SL_lightDir, FragNormal), 0.0); + res.diffuse = SL_spotLightFadeFactor * SL_attenuationFactor * light.diffuse * SL_diffuseStrength; + + vec3 SL_reflectDir = reflect(-SL_lightDir, FragNormal); + float SL_specularity = max(dot(CONST_viewDir, SL_reflectDir), 0.0); + float SL_shinePower = pow(SL_specularity, material.shininess); + res.specular = SL_spotLightFadeFactor * SL_attenuationFactor * SL_shinePower * light.specular; + + return res; +} + +void main() { + //vec3 CONST_viewDir = normalize(cameraPosition - VertexWorldPos); + //vec3 combinedAmbience = vec3(0.0); + //vec3 combinedDiffuse = vec3(0.0); + //vec3 combinedSpecular = vec3(0.0); + + //LightFactor DL_factors = make_directional_light(dirLight, CONST_viewDir); + //combinedAmbience += DL_factors.ambient; + //combinedDiffuse += DL_factors.diffuse; + //combinedSpecular += DL_factors.specular; + + //LightFactor PL_factors = make_point_light(pointLight, CONST_viewDir); + //combinedAmbience += PL_factors.ambient; + //combinedDiffuse += PL_factors.diffuse; + //combinedSpecular += PL_factors.specular; + + vec3 diffuseLight = vec3(texture(material.diffuse[0], TexCoords)); + + vec3 color = diffuseLight; + FragColor = vec4(color, 1.0); +}; diff --git a/source/lessons/instanced_rendering/planetary models/shaders/model.vs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/model.vs.glsl new file mode 100644 index 0000000..e4896c9 --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/model.vs.glsl @@ -0,0 +1,28 @@ +#version 330 core +layout(location=0) in vec3 aPos; +layout(location=1) in vec3 aNormal; +layout(location=2) in vec2 aTex; + +// uniform mat4 Model; +layout (std140) uniform Matrices { + mat4 View; // start: 0 // end: 16 * 4 = 64 + mat4 Projection; // start: 64 // end: 64 + 64 = 128 +}; + +uniform mat4 Model; + +out vec2 TexCoords; +out vec3 VertexWorldPos; +out vec3 FragNormal; + +// @note: I still do not fully understand how the FragNormal calculation works. Need to make sure I intuitively +// get that + +void main() { + gl_Position = Projection*View*Model*vec4(aPos, 1.0); + + VertexWorldPos = vec3(Model * vec4(aPos, 1.0)); + FragNormal = mat3(transpose(inverse(Model))) * aNormal; + FragNormal = normalize(FragNormal); + TexCoords = aTex; +}; diff --git a/source/lessons/instanced_rendering/planetary models/shaders/refl.fs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/refl.fs.glsl new file mode 100644 index 0000000..6d28392 --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/refl.fs.glsl @@ -0,0 +1,14 @@ +#version 330 core + +in vec3 Normal; +in vec3 Position; + +uniform samplerCube skybox; +uniform vec3 cameraPos; +out vec4 FragColor; + +void main() { + vec3 I = normalize(Position - cameraPos); + vec3 R = reflect(I, normalize(Normal)); + FragColor = vec4(texture(skybox, R).rgb, 1.0); +}; diff --git a/source/lessons/instanced_rendering/planetary models/shaders/refl.vs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/refl.vs.glsl new file mode 100644 index 0000000..b8f2b97 --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/refl.vs.glsl @@ -0,0 +1,16 @@ +#version 330 core +layout(location=0) in vec3 aPos; +layout(location=1) in vec3 aNormal; + +uniform mat4 View; +uniform mat4 Model; +uniform mat4 Projection; + +out vec3 Normal; +out vec3 Position; + +void main() { + Normal = mat3(transpose(inverse(Model))) * aNormal; + Position = vec3(Model * vec4(aPos, 1.0)); + gl_Position = Projection * View * Model * vec4(aPos, 1.0); +}; diff --git a/source/lessons/instanced_rendering/planetary models/shaders/refr.fs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/refr.fs.glsl new file mode 100644 index 0000000..6747ded --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/refr.fs.glsl @@ -0,0 +1,15 @@ +#version 330 core + +in vec3 Normal; +in vec3 Position; + +uniform samplerCube skybox; +uniform vec3 cameraPos; +out vec4 FragColor; + +void main() { + float refr_ratio = 1.0/1.52; + vec3 I = normalize(Position - cameraPos); + vec3 R = refract(I, normalize(Normal), refr_ratio); + FragColor = vec4(texture(skybox, R).rgb, 1.0); +}; diff --git a/source/lessons/instanced_rendering/planetary models/shaders/refr.vs.glsl b/source/lessons/instanced_rendering/planetary models/shaders/refr.vs.glsl new file mode 100644 index 0000000..0554f0a --- /dev/null +++ b/source/lessons/instanced_rendering/planetary models/shaders/refr.vs.glsl @@ -0,0 +1,20 @@ +#version 330 core +layout(location=0) in vec3 aPos; +layout(location=1) in vec3 aNormal; + +uniform mat4 View; +uniform mat4 Model; +uniform mat4 Projection; + +out vec3 Normal; +out vec3 Position; + +void main() { + // @note: This is the calculation for getting the normal vector + // one that is unaffected by non-uniform scaling that is. + // look at the lighting chapter in learnopengl.com to understand this more + Normal = mat3(transpose(inverse(Model))) * aNormal; + Position = vec3(Model * vec4(aPos, 1.0)); + gl_Position = Projection * View * Model * vec4(aPos, 1.0); +}; + |