diff --git a/VisPy.pdf b/VisPy.pdf
new file mode 100644
index 0000000..380a019
Binary files /dev/null and b/VisPy.pdf differ
diff --git a/kurs1.py b/kurs1.py
new file mode 100644
index 0000000..508355f
--- /dev/null
+++ b/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()
diff --git a/kurs2.py b/kurs2.py
new file mode 100644
index 0000000..47ae949
--- /dev/null
+++ b/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()
diff --git a/kurs3.py b/kurs3.py
new file mode 100644
index 0000000..4a5efb3
--- /dev/null
+++ b/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()