From ca2835943ca4327ad08b54af480e0c6333df201f Mon Sep 17 00:00:00 2001
From: talha <talha@talhaamir.xyz>
Date: Mon, 22 Apr 2024 03:38:29 +0500
Subject: Completed main levels to progress to text-rendering and 2d
development.
- Only lessons left are geometry shaders and anti-aliasing
- will get to those later on soon
- need to do text rendering now
---
.../basic quads/shaders/cubemap.fs.glsl | 9 +++
.../basic quads/shaders/cubemap.vs.glsl | 14 +++++
.../basic quads/shaders/depth_test.fs.glsl | 30 +++++++++
.../basic quads/shaders/depth_test.vs.glsl | 21 +++++++
.../basic quads/shaders/fbo.fs.glsl | 72 ++++++++++++++++++++++
.../basic quads/shaders/fbo.vs.glsl | 10 +++
.../basic quads/shaders/instancing.fs.glsl | 9 +++
.../basic quads/shaders/instancing.vs.glsl | 16 +++++
.../basic quads/shaders/refl.fs.glsl | 14 +++++
.../basic quads/shaders/refl.vs.glsl | 16 +++++
.../basic quads/shaders/refr.fs.glsl | 15 +++++
.../basic quads/shaders/refr.vs.glsl | 20 ++++++
12 files changed, 246 insertions(+)
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/cubemap.fs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/cubemap.vs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/depth_test.fs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/depth_test.vs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/fbo.fs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/fbo.vs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/instancing.fs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/instancing.vs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/refl.fs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/refl.vs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/refr.fs.glsl
create mode 100644 source/lessons/instanced_rendering/basic quads/shaders/refr.vs.glsl
(limited to 'source/lessons/instanced_rendering/basic quads/shaders')
diff --git a/source/lessons/instanced_rendering/basic quads/shaders/cubemap.fs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/cubemap.fs.glsl
new file mode 100644
index 0000000..72dfe4c
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/cubemap.vs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/cubemap.vs.glsl
new file mode 100644
index 0000000..956673a
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/depth_test.fs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/depth_test.fs.glsl
new file mode 100644
index 0000000..796d849
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/depth_test.vs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/depth_test.vs.glsl
new file mode 100644
index 0000000..827da20
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/fbo.fs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/fbo.fs.glsl
new file mode 100644
index 0000000..e12ad33
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/fbo.vs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/fbo.vs.glsl
new file mode 100644
index 0000000..82d7211
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/instancing.fs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/instancing.fs.glsl
new file mode 100644
index 0000000..1ec8011
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/instancing.vs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/instancing.vs.glsl
new file mode 100644
index 0000000..eff2fae
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/refl.fs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/refl.fs.glsl
new file mode 100644
index 0000000..6d28392
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/refl.vs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/refl.vs.glsl
new file mode 100644
index 0000000..b8f2b97
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/refr.fs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/refr.fs.glsl
new file mode 100644
index 0000000..6747ded
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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/basic quads/shaders/refr.vs.glsl b/source/lessons/instanced_rendering/basic quads/shaders/refr.vs.glsl
new file mode 100644
index 0000000..0554f0a
--- /dev/null
+++ b/source/lessons/instanced_rendering/basic quads/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);
+};
+
--
cgit v1.2.3