La til kurskoden, samt foiler

kurs1.py

@@ -0,0 +1,37 @@
+import numpy as np
+from vispy import app
+from vispy import gloo
+
+vertex = """
+attribute vec2 a_position;
+void main (void)
+{
+    gl_Position = vec4(a_position, 0.0, 1.0);
+}
+"""
+
+fragment = """
+void main()
+{
+    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+}
+"""
+
+c = app.Canvas(keys='interactive')
+program = gloo.Program(vertex, fragment)
+
+program['a_position'] = np.float32(np.c_[
+np.linspace(-1.0, +1.0, 1000),
+np.random.uniform(-0.5, +0.5, 1000)])
+
+@c.connect
+def on_resize(event):
+    gloo.set_viewport(0, 0, *event.size)
+
+@c.connect
+def on_draw(event):
+    gloo.clear((1,1,1,1))
+    program.draw('line_strip')
+
+c.show()
+app.run()

kurs2.py

@@ -0,0 +1,55 @@
+from vispy import gloo
+from vispy import app
+import numpy as np
+
+# Create vertices
+vPosition = np.array([[-0.8, -0.8, 0.0], [+0.7, -0.7, 0.0],
+                      [-0.7, +0.7, 0.0]], np.float32)
+
+
+VERT_SHADER = """ // simple vertex shader
+attribute vec3 a_position;
+void main (void) {
+    gl_Position = vec4(a_position, 1.0);
+}
+"""
+
+FRAG_SHADER = """ // simple fragment shader
+uniform vec4 u_color;
+varying float time;
+void main()
+{
+    gl_FragColor = vec4(gl_FragCoord.x,0.5+0.5*sin(gl_FragCoord.y) ,gl_FragCoord.y, 1.0);
+    // gl_FragColor = vec4(gl_FragCoord.x, gl_FragCoord.y, 0.5+0.5*sin(gl_FragCoord.y ),1.0);
+}
+"""
+
+
+class Canvas(app.Canvas):
+
+    def __init__(self):
+        app.Canvas.__init__(self, keys='interactive')
+
+        # Create program
+        self._program = gloo.Program(VERT_SHADER, FRAG_SHADER)
+
+        # Set uniform and attribute
+        self._program['u_color'] = 0.2, 1.0, 0.4, 1
+        self._program['a_position'] = gloo.VertexBuffer(vPosition)
+
+        gloo.set_clear_color('white')
+
+        self.show()
+
+    def on_resize(self, event):
+        width, height = event.physical_size
+        gloo.set_viewport(0, 0, width, height)
+
+    def on_draw(self, event):
+        gloo.clear()
+        self._program.draw('triangle_strip')
+
+
+if __name__ == '__main__':
+    c = Canvas()
+    app.run()

kurs3.py

@@ -0,0 +1,156 @@
+import numpy as np
+from vispy import app, gloo
+from vispy.util.transforms import perspective, translate, rotate
+
+vert = """
+// Uniforms
+// ------------------------------------
+uniform   mat4 u_model;
+uniform   mat4 u_view;
+uniform   mat4 u_projection;
+uniform   vec4 u_color;
+// Attributes
+// ------------------------------------
+attribute vec3 a_position;
+attribute vec4 a_color;
+attribute vec3 a_normal;
+// Varying
+// ------------------------------------
+varying vec4 v_color;
+void main()
+{
+    v_color = a_color * u_color;
+    gl_Position = u_projection * u_view * u_model * vec4(a_position,1.0);
+}
+"""
+
+
+frag = """
+// Varying
+// ------------------------------------
+varying vec4 v_color;
+void main()
+{
+    gl_FragColor = v_color;
+}
+"""
+
+
+# -----------------------------------------------------------------------------
+def cube():
+    """
+    Build vertices for a colored cube.
+    V  is the vertices
+    I1 is the indices for a filled cube (use with GL_TRIANGLES)
+    I2 is the indices for an outline cube (use with GL_LINES)
+    """
+    vtype = [('a_position', np.float32, 3),
+             ('a_normal', np.float32, 3),
+             ('a_color', np.float32, 4)]
+    # Vertices positions
+    v = [[1, 1, 1], [-1, 1, 1], [-1, -1, 1], [1, -1, 1],
+         [1, -1, -1], [1, 1, -1], [-1, 1, -1], [-1, -1, -1]]
+    # Face Normals
+    n = [[0, 0, 1], [1, 0, 0], [0, 1, 0],
+         [-1, 0, 0], [0, -1, 0], [0, 0, -1]]
+    # Vertice colors
+    c = [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1], [0, 1, 0, 1],
+         [1, 1, 0, 1], [1, 1, 1, 1], [1, 0, 1, 1], [1, 0, 0, 1]]
+
+    V = np.array([(v[0], n[0], c[0]), (v[1], n[0], c[1]),
+                  (v[2], n[0], c[2]), (v[3], n[0], c[3]),
+                  (v[0], n[1], c[0]), (v[3], n[1], c[3]),
+                  (v[4], n[1], c[4]), (v[5], n[1], c[5]),
+                  (v[0], n[2], c[0]), (v[5], n[2], c[5]),
+                  (v[6], n[2], c[6]), (v[1], n[2], c[1]),
+                  (v[1], n[3], c[1]), (v[6], n[3], c[6]),
+                  (v[7], n[3], c[7]), (v[2], n[3], c[2]),
+                  (v[7], n[4], c[7]), (v[4], n[4], c[4]),
+                  (v[3], n[4], c[3]), (v[2], n[4], c[2]),
+                  (v[4], n[5], c[4]), (v[7], n[5], c[7]),
+                  (v[6], n[5], c[6]), (v[5], n[5], c[5])],
+                 dtype=vtype)
+    I1 = np.resize(np.array([0, 1, 2, 0, 2, 3], dtype=np.uint32), 6 * (2 * 3))
+    I1 += np.repeat(4 * np.arange(2 * 3, dtype=np.uint32), 6)
+
+    I2 = np.resize(
+        np.array([0, 1, 1, 2, 2, 3, 3, 0], dtype=np.uint32), 6 * (2 * 4))
+    I2 += np.repeat(4 * np.arange(6, dtype=np.uint32), 8)
+
+    return V, I1, I2
+
+
+# -----------------------------------------------------------------------------
+class Canvas(app.Canvas):
+
+    def __init__(self):
+        app.Canvas.__init__(self, keys='interactive', size=(800, 600))
+
+        self.vertices, self.filled, self.outline = cube()
+        self.filled_buf = gloo.IndexBuffer(self.filled)
+        self.outline_buf = gloo.IndexBuffer(self.outline)
+
+        self.program = gloo.Program(vert, frag)
+        self.program.bind(gloo.VertexBuffer(self.vertices))
+
+        self.view = translate((0, 0, -5))
+        self.model = np.eye(4, dtype=np.float32)
+
+        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
+        self.projection = perspective(45.0, self.size[0] /
+                                      float(self.size[1]), 2.0, 10.0)
+
+        self.program['u_projection'] = self.projection
+
+        self.program['u_model'] = self.model
+        self.program['u_view'] = self.view
+
+        self.theta = 0
+        self.phi = 0
+
+        gloo.set_clear_color('white')
+        gloo.set_state('opaque')
+        gloo.set_polygon_offset(1, 1)
+
+        self._timer = app.Timer('auto', connect=self.on_timer, start=True)
+
+        self.show()
+
+    # ---------------------------------
+    def on_timer(self, event):
+        self.theta += .3
+        self.phi += .0
+        self.model = np.dot(rotate(self.theta, (0, 1, 0)),
+                            rotate(self.phi, (0, 0, 1)))
+        self.program['u_model'] = self.model
+        self.update()
+
+    # ---------------------------------
+    def on_resize(self, event):
+        gloo.set_viewport(0, 0, event.physical_size[0], event.physical_size[1])
+        self.projection = perspective(45.0, event.size[0] /
+                                      float(event.size[1]), 2.0, 10.0)
+        self.program['u_projection'] = self.projection
+
+    # ---------------------------------
+    def on_draw(self, event):
+        gloo.clear()
+
+        # Filled cube
+
+        gloo.set_state(blend=False, depth_test=True, polygon_offset_fill=True)
+        self.program['u_color'] = 1, 1, 1, 1
+        self.program.draw('triangles', self.filled_buf)
+
+        # Outline
+        gloo.set_state(blend=True, depth_test=True, polygon_offset_fill=False)
+        gloo.set_depth_mask(False)
+        self.program['u_color'] = 0, 0, 0, 1
+        self.program.draw('lines', self.outline_buf)
+        gloo.set_depth_mask(True)
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    c = Canvas()
+    app.run()