createeffect command now sets up an effect class with a shader

Author: einarf

README.rst

@@ -76,7 +76,9 @@ Manual setup (OS X / Linux):
 Controls
 ========
 
-- Currently you can control the camera with ``A``, ``W``, ``S`` and ``D``
+- Currently you can control the camera with ``A``, ``W``, ``S`` and ``D``.
+  ``Q`` and ``E`` for y axis movements
+- Standard yaw/pitch camera rotation with mouse
 - ``ESC`` for exit
 - ``SPACE`` for pause
 - ``X`` for taking ``png`` screenshot

demosys/core/management/commands/createeffect.py

@@ -21,3 +21,30 @@ def handle(self, *args, **options):
         if os.path.exists(name):
             print(f"Directory {name} already exist. Aborting.")
             return
+
+        os.mkdir(name)
+        os.mkdir(os.path.join(name, 'textures'))
+        os.mkdir(os.path.join(name, 'shaders'))
+
+        # Create effect.py
+        with open(os.path.join(name, 'effect.py'), 'w') as fd:
+            fd.write(default_effect())
+
+        # Create default.glsl
+        with open(os.path.join(name, 'shaders', 'default.glsl'), 'w') as fd:
+            fd.write(default_shader())
+
+
+def default_effect():
+    file_path = os.path.join(root_path(), 'effects/default/effect.py')
+    return open(file_path, 'r').read()
+
+
+def default_shader():
+    file_path = os.path.join(root_path(), 'effects/default/shaders/default.glsl')
+    return open(file_path, 'r').read()
+
+
+def root_path():
+    module_dir = os.path.dirname(globals()['__file__'])
+    return os.path.dirname(os.path.dirname(os.path.dirname(module_dir)))

demosys/effects/default/effect.py

@@ -0,0 +1,31 @@
+from demosys.effects import Effect
+from demosys.opengl import geometry
+from OpenGL import GL
+from pyrr import matrix44
+
+
+class DefaultEffect(Effect):
+    """Generated default efffect"""
+    def init(self):
+        self.shader = self.get_shader("default.glsl")
+        self.cube = geometry.cube(4.0, 4.0, 4.0)
+
+    def draw(self, time, target):
+        GL.glEnable(GL.GL_DEPTH_TEST)
+
+        # Rotate and translate
+        m_mv = self.create_transformation(rotation=(time * 1.2, time * 2.1, time * 0.25),
+                                          translation=(0.0, 0.0, -4.0))
+
+        # Apply the rotation and translation from the system camera
+        m_mv = matrix44.multiply(m_mv, self.sys_camera.view_matrix)
+
+        # Create normal matrix from model-view
+        m_normal = self.create_normal_matrix(m_mv)
+
+        # Draw the cube
+        self.cube.bind(self.shader)
+        self.shader.uniform_mat4("m_proj", self.sys_camera.projection)
+        self.shader.uniform_mat4("m_mv", m_mv)
+        self.shader.uniform_mat3("m_normal", m_normal)
+        self.cube.draw()

demosys/effects/default/shaders/default.glsl

@@ -0,0 +1,34 @@
+#version 410
+
+#if defined VERTEX_SHADER
+
+in vec3 in_position;
+in vec3 in_normal;
+
+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;
+}
+
+#elif defined FRAGMENT_SHADER
+
+out vec4 fragColor;
+uniform float time;
+
+in vec3 normal;
+
+void main()
+{
+    vec3 dir = vec3(0.0, 0.0, 1.0);
+    float l = dot(dir, normal);
+    fragColor = vec4(l);
+}
+
+#endif

demosys/opengl/geometry.py

@@ -45,9 +45,9 @@ def quad_2d(width, height, xpos, ypos):
     vao.add_array_buffer(GL.GL_FLOAT, pos)
     vao.add_array_buffer(GL.GL_FLOAT, normals)
     vao.add_array_buffer(GL.GL_FLOAT, uvs)
-    vao.map_buffer(pos, "in_Position", 3)
+    vao.map_buffer(pos, "in_position", 3)
     vao.map_buffer(normals, "in_normal", 3)
-    vao.map_buffer(uvs, "in_UV0", 2)
+    vao.map_buffer(uvs, "in_uv", 2)
     vao.build()
     return vao
 
@@ -186,11 +186,11 @@ def cube(width, height, depth, normals=True, uvs=True):
         vao.add_array_buffer(GL.GL_FLOAT, normals)
     if uvs:
         vao.add_array_buffer(GL.GL_FLOAT, uvs)
-    vao.map_buffer(pos, "in_Position", 3)
+    vao.map_buffer(pos, "in_position", 3)
     if normals:
-        vao.map_buffer(normals, "in_Normal", 3)
+        vao.map_buffer(normals, "in_normal", 3)
     if uvs:
-        vao.map_buffer(uvs, "in_UV0", 2)
+        vao.map_buffer(uvs, "in_uv", 2)
     vao.build()
     return vao
 
@@ -217,6 +217,6 @@ def gen():
     pos = VBO(numpy.array(list(gen()), dtype=numpy.float32))
     vao = VAO("geometry:points_random")
     vao.add_array_buffer(GL.GL_FLOAT, pos)
-    vao.map_buffer(pos, "in_Position", 3)
+    vao.map_buffer(pos, "in_position", 3)
     vao.build()
     return vao

demosys_test/cube/effect.py

@@ -7,8 +7,6 @@
 
 class CubeEffect(effect.Effect):
     """Simple effect drawing a textured cube"""
-    depth_testing = True
-
     def init(self):
         self.cube_shader1 = self.get_shader('cube/cube_multi_fade.glsl')
         self.cube_shader2 = self.get_shader('cube/cube_texture_light.glsl')
@@ -35,9 +33,9 @@ def draw(self, time, target):
         proj_m = self.create_projection(fov=60.0, ratio=1.0)
 
         self.cube.bind(self.cube_shader1)
-        self.cube_shader1.uniform_mat4("ProjM", proj_m)
-        self.cube_shader1.uniform_mat4("ModelViewM", mv_m)
-        self.cube_shader1.uniform_mat3("NormalM", normal_m)
+        self.cube_shader1.uniform_mat4("m_proj", proj_m)
+        self.cube_shader1.uniform_mat4("m_mv", mv_m)
+        self.cube_shader1.uniform_mat3("m_normal", normal_m)
         self.cube_shader1.uniform_sampler_2d(0, "texture0", self.texture1)
         self.cube_shader1.uniform_sampler_2d(1, "texture1", self.texture2)
         self.cube_shader1.uniform_1f("time", time)
@@ -56,9 +54,9 @@ def draw(self, time, target):
         normal_m = self.create_normal_matrix(view_m)
 
         self.points.bind(self.cube_shader2)
-        self.cube_shader2.uniform_mat4("ProjM", self.sys_camera.projection)
-        self.cube_shader2.uniform_mat4("ModelViewM", view_m)
-        self.cube_shader2.uniform_mat3("NormalM", normal_m)
+        self.cube_shader2.uniform_mat4("m_proj", self.sys_camera.projection)
+        self.cube_shader2.uniform_mat4("m_mv", view_m)
+        self.cube_shader2.uniform_mat3("m_normal", normal_m)
         self.cube_shader2.uniform_sampler_2d(0, "texture0", self.fbo.color_buffers[0])
         self.cube_shader2.uniform_1f("time", time)
         self.cube_shader2.uniform_3f("lightpos", 0.0, 0.0, 0.0)

demosys_test/cube/shaders/cube/cube_multi_fade.glsl

@@ -2,21 +2,21 @@
 
 #if defined VERTEX_SHADER
 
-in vec3 in_Position;
-in vec3 in_Normal;
-in vec2 in_UV0;
+in vec3 in_position;
+in vec3 in_normal;
+in vec2 in_uv;
 
-uniform mat4 ProjM;
-uniform mat4 ModelViewM;
-uniform mat3 NormalM;
+uniform mat4 m_proj;
+uniform mat4 m_mv;
+uniform mat3 m_normal;
 
 out vec3 normal;
-out vec2 uv0;
+out vec2 uv;
 
 void main() {
-	gl_Position = ProjM * ModelViewM * vec4(in_Position, 1.0);
-    normal = NormalM * in_Normal;
-    uv0 = in_UV0;
+	gl_Position = m_proj * m_mv * vec4(in_position, 1.0);
+    normal = m_normal * in_normal;
+    uv = in_uv;
 }
 
 #elif defined FRAGMENT_SHADER
@@ -27,12 +27,12 @@ uniform sampler2D texture1;
 uniform float time;
 
 in vec3 normal;
-in vec2 uv0;
+in vec2 uv;
 
 void main()
 {
-    vec4 c1 = texture(texture0, uv0);
-    vec4 c2 = texture(texture1, uv0);
+    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;
 

demosys_test/cube/shaders/cube/cube_texture_light.glsl

@@ -2,17 +2,14 @@
 
 #if defined VERTEX_SHADER
 
-in vec3 in_Position;
+in vec3 in_position;
 
-uniform mat4 ProjM;
-uniform mat4 ModelViewM;
-uniform mat3 NormalM;
-
-out vec3 normal;
-out vec2 uv0;
+uniform mat4 m_proj;
+uniform mat4 m_mv;
+uniform mat3 m_normal;
 
 void main() {
-	gl_Position = vec4(in_Position, 1.0);
+	gl_Position = vec4(in_position, 1.0);
 }
 
 #elif defined FRAGMENT_SHADER
@@ -22,7 +19,7 @@ uniform sampler2D texture0;
 uniform float time;
 
 in vec3 normal;
-in vec2 uv0;
+in vec2 uv;
 in vec3 lightdir;
 in vec3 eyepos;
 
@@ -34,7 +31,7 @@ void main()
     vec4 specular = vec4(1.0, 1.0, 1.0, 1.0);
     float shininess = 0.5;
 
-    vec4 c = texture(texture0, uv0);
+    vec4 c = texture(texture0, uv);
     vec4 spec = vec4(0.0);
 
     vec3 n = normalize(normal);
@@ -58,13 +55,13 @@ void main()
 layout (points) in;
 layout (triangle_strip, max_vertices = 24) out; // 4 vertices per side of the cube
 
-uniform mat4 ProjM;
-uniform mat4 ModelViewM;
-uniform mat3 NormalM;
+uniform mat4 m_proj;
+uniform mat4 m_mv;
+uniform mat3 m_normal;
 uniform vec3 lightpos;
 uniform float time;
 
-out vec2 uv0;
+out vec2 uv;
 out vec3 normal;
 out vec3 lightdir;
 out vec3 eyepos;
@@ -82,11 +79,11 @@ vec3 cube_corners[8] = vec3[]  (
 );
 
 #define EMIT_V(POS, UV, NORMAL) \
-	uv0 = UV; \
-	normal = normalize(NormalM * NORMAL); \
+	uv = UV; \
+	normal = normalize(m_normal * NORMAL); \
 	lightdir = lightpos - POS.xyz; \
 	eyepos = -POS.xyz; \
-	gl_Position = ProjM * vec4(POS, 1.0); \
+	gl_Position = m_proj * vec4(POS, 1.0); \
 	EmitVertex()
 
 #define EMIT_QUAD(P1, P2, P3, P4, NORMAL) \
@@ -109,7 +106,7 @@ void main()
 		pos.x += cos(time + gl_in[0].gl_Position.x);
 		pos.z += cos(time + gl_in[0].gl_Position.z);
 
-		corners[i] = (ModelViewM * vec4(pos, 1.0)).xyz;
+		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