Example: Geo cubes

Author: einarf

examples/README.md

@@ -32,3 +32,16 @@ python manage.py runeffect examples.feedback
 ```
 
 ![screenshot](https://github.com/Contraz/demosys-py/blob/master/examples/images/feedback.png)
+
+Geo Cubes
+---------
+
+Geometry shader example. We're drawing points were the geometry shader emits
+a cube on each point and slightly modifying the position of each cube.
+The texture on these cube is an fbo texture of a spinning cube just for fun.
+
+```bash
+python manage.py runeffect examples.geocubes
+```
+
+![screenshot](https://raw.githubusercontent.com/Contraz/demosys-py/master/examples/images/geocubes.png)

examples/geocubes/effect.py

@@ -0,0 +1,62 @@
+import moderngl as mgl
+# import math
+from demosys.effects import effect
+from demosys import geometry
+from demosys.opengl import FBO
+
+
+class GeoCubesEffect(effect.Effect):
+    """Simple effect drawing a textured cube"""
+    def __init__(self):
+        self.cube_shader1 = self.get_shader('geocubes/cube_multi_fade.glsl')
+        self.cube_shader2 = self.get_shader('geocubes/cube_texture_light.glsl')
+        self.quad_shader = self.get_shader('geocubes/quad_fs_uvscale.glsl')
+
+        self.texture1 = self.get_texture('geocubes/texture.png')
+        self.texture2 = self.get_texture('geocubes/GreenFabric.png')
+
+        self.cube = geometry.cube(4.0, 4.0, 4.0)
+
+        v = 100.0
+        r = (-v, v)
+
+        self.points = geometry.points_random_3d(50_000, range_x=r, range_y=r, range_z=r, seed=7656456)
+        self.quad = geometry.quad_fs()
+        self.fbo = FBO.create((512, 512), depth=True)
+
+    @effect.bind_target
+    def draw(self, time, frametime, target):
+        self.ctx.enable(mgl.DEPTH_TEST)
+        self.ctx.enable(mgl.CULL_FACE)
+
+        mv_m = self.create_transformation(rotation=(time * 1.2, time * 2.1, time * 0.25),
+                                          translation=(0.0, 0.0, -8.0))
+        normal_m = self.create_normal_matrix(mv_m)
+        proj_m = self.create_projection(fov=60.0, ratio=1.0)
+
+        with self.fbo:
+            self.cube_shader1.uniform("m_proj", proj_m.astype('f4').tobytes())
+            self.cube_shader1.uniform("m_mv", mv_m.astype('f4').tobytes())
+            self.cube_shader1.uniform("m_normal", normal_m.astype('f4').tobytes())
+            self.texture1.use(location=0)
+            self.texture2.use(location=1)
+            self.cube_shader1.uniform("texture0", 0)
+            self.cube_shader1.uniform("texture1", 1)
+            self.cube_shader1.uniform("time", time)
+            self.cube.draw(self.cube_shader1)
+
+        self.sys_camera.projection.update(fov=75, near=0.1, far=1000)
+
+        view_m = self.sys_camera.view_matrix
+        normal_m = self.create_normal_matrix(view_m)
+
+        self.cube_shader2.uniform("m_proj", self.sys_camera.projection.tobytes())
+        self.cube_shader2.uniform("m_mv", view_m.astype('f4').tobytes())
+        self.cube_shader2.uniform("m_normal", normal_m.astype('f4').tobytes())
+        self.fbo.color_buffers[0].use(location=0)
+        self.cube_shader2.uniform("texture0", 0)
+        self.cube_shader2.uniform("time", time)
+        self.cube_shader2.uniform("lightpos", (0.0, 0.0, 0.0))
+        self.points.draw(self.cube_shader2)
+
+        self.fbo.clear(red=0.5, green=0.5, blue=0.5, alpha=1.0, depth=1.0)

examples/geocubes/shaders/geocubes/cube_multi_fade.glsl

@@ -0,0 +1,45 @@
+#version 330
+
+#if defined VERTEX_SHADER
+
+in vec3 in_position;
+in vec3 in_normal;
+in vec2 in_uv;
+
+uniform mat4 m_proj;
+uniform mat4 m_mv;
+uniform mat3 m_normal;
+
+out vec3 normal;
+out vec2 uv;
+
+void main() {
+	gl_Position = m_proj * m_mv * vec4(in_position, 1.0);
+    normal = m_normal * in_normal;
+    uv = in_uv;
+}
+
+#elif defined FRAGMENT_SHADER
+
+out vec4 fragColor;
+uniform sampler2D texture0;
+uniform sampler2D texture1;
+uniform float time;
+
+in vec3 normal;
+in vec2 uv;
+
+void main()
+{
+    vec4 c1 = texture(texture0, uv);
+    vec4 c2 = texture(texture1, uv);
+    float m1 = sin(time * 1.0) / 2.0 + 0.5;
+    float m2 = 1.0 - m1;
+
+    vec3 dir = vec3(0.0, 0.0, 1.0);
+    float d = dot(dir, normal);
+
+    fragColor = (c1 * m1 + c2 * m2) * d;
+}
+
+#endif

examples/geocubes/shaders/geocubes/cube_texture_light.glsl

@@ -0,0 +1,119 @@
+#version 330
+
+#if defined VERTEX_SHADER
+
+in vec3 in_position;
+
+uniform mat4 m_proj;
+uniform mat4 m_mv;
+uniform mat3 m_normal;
+
+void main() {
+	gl_Position = vec4(in_position, 1.0);
+}
+
+#elif defined FRAGMENT_SHADER
+
+out vec4 fragColor;
+uniform sampler2D texture0;
+uniform float time;
+
+in vec3 normal;
+in vec2 uv;
+in vec3 lightdir;
+in vec3 eyepos;
+
+void main()
+{
+    vec4 diffuse = vec4(0.5, 0.5, 0.5, 1.0);
+    vec4 ambient = vec4(0.2, 0.2, 0.2, 1.0);
+    vec4 specular = vec4(1.0, 1.0, 1.0, 1.0);
+    float shininess = 0.5;
+
+    vec4 c = texture(texture0, uv);
+    vec4 spec = vec4(0.0);
+
+    vec3 n = normalize(normal);
+    vec3 l = normalize(lightdir);
+    vec3 e = normalize(eyepos);
+
+    float intensity = max(dot(n,l), 0.0);
+    if (intensity > 0.0) {
+        vec3 h = normalize(l + e);
+        float intSpec = max(dot(h, n), 0.0);
+        spec = specular * pow(intSpec, shininess);
+    }
+    float att = clamp(1.0 - length(eyepos)/200.0, 0.0, 1.0);
+    att *= att;
+    fragColor = c * max(intensity * diffuse + spec, ambient) * att;
+}
+
+
+#elif defined GEOMETRY_SHADER
+
+layout (points) in;
+layout (triangle_strip, max_vertices = 24) out; // 4 vertices per side of the cube
+
+uniform mat4 m_proj;
+uniform mat4 m_mv;
+uniform mat3 m_normal;
+uniform vec3 lightpos;
+uniform float time;
+
+out vec2 uv;
+out vec3 normal;
+out vec3 lightdir;
+out vec3 eyepos;
+
+// Define the 8 corners of a cube (back plane, front plane (counter clockwise))
+vec3 cube_corners[8] = vec3[]  (
+	vec3( 1.0,  1.0, -1.0), // right top far
+	vec3(-1.0,  1.0, -1.0), // left top far
+	vec3(-1.0, -1.0, -1.0), // left bottom far
+	vec3( 1.0, -1.0, -1.0), // right bottom far
+	vec3( 1.0,  1.0,  1.0), // right top near
+	vec3(-1.0,  1.0,  1.0), // left top near
+	vec3(-1.0, -1.0,  1.0), // left bottom near
+	vec3( 1.0, -1.0,  1.0)  // right bottom near
+);
+
+#define EMIT_V(POS, UV, NORMAL) \
+	uv = UV; \
+	normal = normalize(m_normal * NORMAL); \
+	lightdir = lightpos - POS.xyz; \
+	eyepos = -POS.xyz; \
+	gl_Position = m_proj * vec4(POS, 1.0); \
+	EmitVertex()
+
+#define EMIT_QUAD(P1, P2, P3, P4, NORMAL) \
+	EMIT_V(corners[P1], vec2(0.0, 0.0), NORMAL); \
+	EMIT_V(corners[P2], vec2(1.0, 0.0), NORMAL); \
+	EMIT_V(corners[P3], vec2(0.0, 1.0), NORMAL); \
+	EMIT_V(corners[P4], vec2(1.0, 1.0), NORMAL); \
+	EndPrimitive()
+
+void main()
+{
+	// Calculate the 8 cube corners
+	vec3 point = gl_in[0].gl_Position.xyz;
+	vec3 corners[8];
+	int i;
+	for(i = 0; i < 8; i++)
+	{
+		vec3 pos = point.xyz + cube_corners[i] * 0.5;
+		pos.y += sin(time + length(gl_in[0].gl_Position.xyz));
+		pos.x += cos(time + gl_in[0].gl_Position.x);
+		pos.z += cos(time + gl_in[0].gl_Position.z);
+
+		corners[i] = (m_mv * vec4(pos, 1.0)).xyz;
+	}
+	EMIT_QUAD(3, 2, 0, 1, vec3( 0.0,  0.0, -1.0)); // back
+	EMIT_QUAD(6, 7, 5, 4, vec3( 0.0,  0.0,  1.0)); // front
+	EMIT_QUAD(7, 3, 4, 0, vec3( 1.0,  0.0,  0.0)); // right
+	EMIT_QUAD(2, 6, 1, 5, vec3(-1.0,  0.0,  0.0)); // left
+	EMIT_QUAD(5, 4, 1, 0, vec3( 0.0,  1.0,  0.0)); // top
+	EMIT_QUAD(2, 3, 6, 7, vec3( 0.0, -1.0,  0.0)); // bottom
+    EndPrimitive();
+}
+
+#endif

examples/geocubes/shaders/geocubes/quad_fs_uvscale.glsl

@@ -0,0 +1,28 @@
+#version 410
+
+#if defined VERTEX_SHADER
+
+uniform vec2 uv_scale;
+in vec3 in_Position;
+in vec2 in_UV0;
+
+out vec2 uv0;
+
+void main() {
+	gl_Position = vec4(in_Position, 1.0);
+    uv0 = (in_UV0 - vec2(0.5)) * uv_scale;
+}
+
+#elif defined FRAGMENT_SHADER
+
+out vec4 fragColor;
+uniform sampler2D texture0;
+
+in vec2 uv0;
+
+void main()
+{
+    fragColor = texture(texture0, uv0);
+}
+
+#endif