def on_initialize(self, event): gl.glClearColor(0,0,0,1) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE) #_MINUS_SRC_ALPHA) # Start the timer upon initialization. self.timer.start()
def draw_points(self): gl.glDisable(gl.GL_BLEND) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthMask(gl.GL_TRUE) self.program_points.draw('points')
def __init__(self): app.Canvas.__init__(self, size=(1024, 1024), title='Skybox example', keys='interactive') self.cubeSize = 10 self.pressed = False self.azimuth = pi / 2.0 self.elevation = pi / 2.0 self.distanceMin = 1 self.distanceMax = 50 self.distance = 30 self.sensitivity = 5.0 self.view = getView(self.azimuth, self.elevation, self.distance) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) self.program = gloo.Program(vertex_shader, fragment_shader, count=24) self.program['a_position'] = faces * self.cubeSize self.program['a_texcoord'] = faces self.program['a_texture'] = gloo.TextureCube(texture, interpolation='linear') self.program['u_model'] = self.model self.program['u_view'] = self.view gloo.set_viewport(0, 0, *self.physical_size) self.projection = perspective(60.0, self.size[0] / float(self.size[1]), 1.0, 100.0) self.program['u_projection'] = self.projection gl.glEnable(gl.GL_DEPTH_TEST) gloo.set_clear_color('black') self.show()
def __init__(self): app.Canvas.__init__(self, size=(1024, 1024), title='Skybox example', keys='interactive') self.cubeSize = 10 self.pressed = False self.azimuth = pi / 2.0 self.elevation = pi / 2.0 self.distanceMin = 1 self.distanceMax = 50 self.distance = 30 self.sensitivity = 5.0 self.view = getView(self.azimuth, self.elevation, self.distance) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) self.program = gloo.Program(vertex_shader, fragment_shader, count=24) self.program['a_position'] = faces*self.cubeSize self.program['a_texcoord'] = faces self.program['a_texture'] = gloo.TextureCube(texture, interpolation='linear') self.program['u_model'] = self.model self.program['u_view'] = self.view gloo.set_viewport(0, 0, *self.physical_size) self.projection = perspective(60.0, self.size[0] / float(self.size[1]), 1.0, 100.0) self.program['u_projection'] = self.projection gl.glEnable(gl.GL_DEPTH_TEST) gloo.set_clear_color('black') self.show()
def on_initialize(self, event): gl.glClearColor(1,1,1,1) gl.glEnable(gl.GL_DEPTH_TEST) # Create shader program self._prog_handle = gl.glCreateProgram() # Create vertex shader shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource(shader, VERT_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Vertex shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Create fragment shader shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(shader, FRAG_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Fragment shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Link gl.glLinkProgram(self._prog_handle) status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Program did not link.') # Create texture im = dataio.crate() self._tex_handle = gl.glGenTextures(1) gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1) gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, im.shape[1], im.shape[0], 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, im) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) if use_buffers: # Create vertex buffer self._positions_handle = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._positions_handle) gl.glBufferData(gl.GL_ARRAY_BUFFER, positions.nbytes, positions, gl.GL_DYNAMIC_DRAW) # self._texcoords_handle = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._texcoords_handle) gl.glBufferData(gl.GL_ARRAY_BUFFER, texcoords.nbytes, texcoords, gl.GL_DYNAMIC_DRAW) # Create buffer for faces self._faces_handle = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._faces_handle) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, faces.nbytes, faces, gl.GL_DYNAMIC_DRAW)
def on_initialize(self, event): self.program = gl.glCreateProgram() vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(vertex, vertex_code) gl.glShaderSource(fragment, fragment_code) gl.glCompileShader(vertex) gl.glCompileShader(fragment) gl.glAttachShader(self.program, vertex) gl.glAttachShader(self.program, fragment) gl.glLinkProgram(self.program) gl.glDetachShader(self.program, vertex) gl.glDetachShader(self.program, fragment) gl.glUseProgram(self.program) n = 10000000 self.data = np.zeros((n, 4), dtype=np.float32) self.data[:, :2] = .15 * prng.randn(n, 2) self.data[:, 3] = 1. vbuffer = gl.glCreateBuffer() gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbuffer) gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data, gl.GL_DYNAMIC_DRAW) stride = self.data.strides[0] offset = 0 loc = gl.glGetAttribLocation(self.program, "a_position") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset) gl.glClearColor(0, 0, 0, 1) gl.glEnable(34370) gl.glEnable(34913) # Auto-close after 10 seconds self.timer = app.Timer(10, self.on_timer, start=True)
def on_initialize(self, event): gl.glClearColor(0, 0, 0, 1) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) # _MINUS_SRC_ALPHA) # Start the timer upon initialization. self.timer.start()
def _draw_context(self): if self._rect_clip is None: yield else: gl.glEnable(gl.GL_SCISSOR_TEST); gloo.set_scissor(*self._rect_clip) yield gl.glDisable(gl.GL_SCISSOR_TEST);
def on_initialize(self, event): gl.glClearColor(0, 0, 0, 1) # Enable blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) # Create shader program self._prog_handle = gl.glCreateProgram() # Create vertex shader shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource_compat(shader, VERT_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Vertex shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Create fragment shader shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) need_enabled = gl.glShaderSource_compat(shader, FRAG_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Fragment shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Enable point sprites for enum in need_enabled: gl.glEnable(enum) # Link gl.glLinkProgram(self._prog_handle) status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Program did not link.') # Create texture self._tex_handle = gl.glGenTextures(1) gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1) gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, im1.shape[1], im1.shape[0], 0, gl.GL_LUMINANCE, gl.GL_FLOAT, im1.astype(np.float32)) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) # Create vertex buffer self._vbo_handle = gl.glGenBuffers(1)
def on_initialize(self, event): gl.glClearColor(0,0,0,1); # Enable blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) # Create shader program self._prog_handle = gl.glCreateProgram() # Create vertex shader shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource_compat(shader, VERT_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Vertex shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Create fragment shader shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) need_enabled = gl.glShaderSource_compat(shader, FRAG_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Fragment shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Enable point sprites for enum in need_enabled: gl.glEnable(enum) # Link gl.glLinkProgram(self._prog_handle) status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Program did not link.') # Create texture self._tex_handle = gl.glGenTextures(1) gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1) gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, im1.shape[1], im1.shape[0], 0, gl.GL_LUMINANCE, gl.GL_FLOAT, im1.astype(np.float32)) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) # Create vertex buffer self._vbo_handle = gl.glGenBuffers(1)
def on_initialize(self, event): gl.glClearColor(1, 1, 1, 1) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) n = 10000 self.discs = DiscCollection() self.discs.line_width = 2. self.discs.position = 0.25 * np.random.randn(n, 2).astype(np.float32) self.discs.color = np.random.uniform(0, 1, (n, 3)).astype(np.float32) self.discs.size = np.random.uniform(2, 12, (n, 1)).astype(np.float32)
def on_initialize(self, event): gl.glClearColor(1,1,1,1) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) n = 10000 self.discs = DiscCollection() self.discs.line_width = 2. self.discs.position = 0.25 * np.random.randn(n, 2).astype(np.float32) self.discs.color = np.random.uniform(0,1,(n,3)).astype(np.float32) self.discs.size = np.random.uniform(2,12,(n,1)).astype(np.float32)
def on_draw(self, event): # Render in the FBO. with self._fbo: gl.glEnable(gl.GL_DEPTH_TEST) gloo.clear('black') gloo.set_viewport(0, 0, *self.size) self.program.draw(gl.GL_POINTS) # Retrieve the contents of the FBO texture. self.im = _screenshot((0, 0, self.size[0], self.size[1])) self._time = time() - self._t0 # Immediately exit the application. app.quit()
def on_initialize(self, event): gl.glClearColor(1, 1, 1, 1) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(GL_VERTEX_PROGRAM_POINT_SIZE) gl.glEnable(GL_POINT_SPRITE)
def draw_model(self): gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthMask(gl.GL_TRUE) gl.glFrontFace(gl.GL_CCW) gl.glDisable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_ZERO, gl.GL_ZERO) if self.render_params['transparent']: gl.glEnable(gl.GL_BLEND) gl.glDepthMask(gl.GL_FALSE) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) self.program_solids.draw('triangles')
def _test_enabling_disabling(): # Enabling/disabling gl.glEnable(gl.GL_DEPTH_TEST) assert_equal(gl.glIsEnabled(gl.GL_DEPTH_TEST), True) assert_equal(gl.glGetParameter(gl.GL_DEPTH_TEST), 1) gl.glDisable(gl.GL_DEPTH_TEST) assert_equal(gl.glIsEnabled(gl.GL_DEPTH_TEST), False) assert_equal(gl.glGetParameter(gl.GL_DEPTH_TEST), 0) # gl.glEnable(gl.GL_BLEND) assert_equal(gl.glIsEnabled(gl.GL_BLEND), True) assert_equal(gl.glGetParameter(gl.GL_BLEND), 1) gl.glDisable(gl.GL_BLEND) assert_equal(gl.glIsEnabled(gl.GL_BLEND), False) assert_equal(gl.glGetParameter(gl.GL_BLEND), 0) gl.check_error()
def draw_depth(camera, renderables, rend_target): rendfb, rendtex, _ = rend_target material = DepthMaterial() program = DepthMaterial().compile() with rendfb: gloo.clear(color=camera.clear_color) gloo.set_state(depth_test=True) gl.glEnable(gl.GL_CULL_FACE) gl.glCullFace(gl.GL_FRONT) for renderable in renderables: material.upload_camera(program, camera) material.upload_attributes(program, renderable._attributes) program['u_model'] = renderable.model_mat.T program.draw(gl.GL_TRIANGLES) gl.glCullFace(gl.GL_BACK) gl.glDisable(gl.GL_CULL_FACE)
def on_initialize(self, event): gl.glClearColor(0, 0, 0, 1) # Enable blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) gl.glEnable(GL_VERTEX_PROGRAM_POINT_SIZE) gl.glEnable(GL_POINT_SPRITE)
def on_initialize(self, event): # Build & activate program self.program = gl.glCreateProgram() vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(vertex, vertex_code) gl.glShaderSource(fragment, fragment_code) gl.glCompileShader(vertex) gl.glCompileShader(fragment) gl.glAttachShader(self.program, vertex) gl.glAttachShader(self.program, fragment) gl.glLinkProgram(self.program) gl.glDetachShader(self.program, vertex) gl.glDetachShader(self.program, fragment) gl.glUseProgram(self.program) # Build vertex buffer n = 10000 self.data = np.zeros(n, dtype=[('lifetime', np.float32), ('start', np.float32, 3), ('end', np.float32, 3)]) vbuffer = gl.glCreateBuffer() gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbuffer) gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data, gl.GL_DYNAMIC_DRAW) # Bind buffer attributes stride = self.data.strides[0] offset = 0 loc = gl.glGetAttribLocation(self.program, "lifetime") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 1, gl.GL_FLOAT, False, stride, offset) offset = self.data.dtype["lifetime"].itemsize loc = gl.glGetAttribLocation(self.program, "start") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset) offset = self.data.dtype["start"].itemsize loc = gl.glGetAttribLocation(self.program, "end") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset) # OpenGL initalization self.elapsed_time = 0 gl.glClearColor(0, 0, 0, 1) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) gl.glEnable(34370) # gl.GL_VERTEX_PROGRAM_POINT_SIZE gl.glEnable(34913) # gl.GL_POINT_SPRITE gl.glViewport(0, 0, *self.physical_size) self.new_explosion() self.timer = app.Timer('auto', self.on_timer, start=True)
def on_initialize(self, event): # Build & activate program self.program = gl.glCreateProgram() vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(vertex, vertex_code) gl.glShaderSource(fragment, fragment_code) gl.glCompileShader(vertex) gl.glCompileShader(fragment) gl.glAttachShader(self.program, vertex) gl.glAttachShader(self.program, fragment) gl.glLinkProgram(self.program) gl.glDetachShader(self.program, vertex) gl.glDetachShader(self.program, fragment) gl.glUseProgram(self.program) # Build vertex buffer n = 10000 self.data = np.zeros(n, dtype=[('lifetime', np.float32, 1), ('start', np.float32, 3), ('end', np.float32, 3)]) vbuffer = gl.glCreateBuffer() gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbuffer) gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data, gl.GL_DYNAMIC_DRAW) # Bind buffer attributes stride = self.data.strides[0] offset = 0 loc = gl.glGetAttribLocation(self.program, "lifetime") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 1, gl.GL_FLOAT, False, stride, offset) offset = self.data.dtype["lifetime"].itemsize loc = gl.glGetAttribLocation(self.program, "start") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset) offset = self.data.dtype["start"].itemsize loc = gl.glGetAttribLocation(self.program, "end") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset) # OpenGL initalization self.elapsed_time = 0 gl.glClearColor(0, 0, 0, 1) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) gl.glEnable(34370) # gl.GL_VERTEX_PROGRAM_POINT_SIZE gl.glEnable(34913) # gl.GL_POINT_SPRITE gl.glViewport(0, 0, *self.physical_size) self.new_explosion() self.timer = app.Timer('auto', self.on_timer, start=True)
def on_paint(self, event): gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) with self.program as prog: # Filled cube gl.glDisable(gl.GL_BLEND) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_POLYGON_OFFSET_FILL) prog['u_color'] = 1, 1, 1, 1 prog.draw(gl.GL_TRIANGLES, self.filled_buf) # Outline gl.glDisable(gl.GL_POLYGON_OFFSET_FILL) gl.glEnable(gl.GL_BLEND) gl.glDepthMask(gl.GL_FALSE) prog['u_color'] = 0, 0, 0, 1 prog.draw(gl.GL_LINES, self.outline_buf) gl.glDepthMask(gl.GL_TRUE)
def on_initialize(self, event): gl.glClearColor(0,0,0,1) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def on_initialize(self, event): gl.glClearColor(1, 1, 1, 1) gl.glEnable(gl.GL_DEPTH_TEST) # Create shader program self._prog_handle = gl.glCreateProgram() # Create vertex shader shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource(shader, VERT_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Vertex shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Create fragment shader shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(shader, FRAG_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Fragment shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Link gl.glLinkProgram(self._prog_handle) status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Program did not link.') # Create texture im = dataio.crate() self._tex_handle = gl.glGenTextures(1) gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1) gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, im.shape[1], im.shape[0], 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, im) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) if use_buffers: # Create vertex buffer self._positions_handle = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._positions_handle) gl.glBufferData(gl.GL_ARRAY_BUFFER, positions.nbytes, positions, gl.GL_DYNAMIC_DRAW) # self._texcoords_handle = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._texcoords_handle) gl.glBufferData(gl.GL_ARRAY_BUFFER, texcoords.nbytes, texcoords, gl.GL_DYNAMIC_DRAW) # Create buffer for faces self._faces_handle = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._faces_handle) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, faces.nbytes, faces, gl.GL_DYNAMIC_DRAW)
def on_draw(self, event): # Read about depth testing and changing stated in vispy here http://vispy.org/gloo.html?highlight=set_state gloo.clear(color=[0, 0, 0, 1.0], depth=True) gl.glEnable(gl.GL_DEPTH_TEST) gl.glStencilOp(gl.GL_KEEP, gl.GL_KEEP, gl.GL_REPLACE) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT | gl.GL_STENCIL_BUFFER_BIT) gl.glStencilFunc(gl.GL_ALWAYS, 1, 0xFF) gl.glStencilMask(0xFF) # delta_time self.current_frame = time() self.delta_time = self.current_frame - self.last_frame self.last_frame = self.current_frame if self.camera.bool_a: self.camera.ProcessKeyboard(Camera_Movement.LEFT, self.delta_time) if self.camera.bool_w: self.camera.ProcessKeyboard(Camera_Movement.FORWARD, self.delta_time) if self.camera.bool_s: self.camera.ProcessKeyboard(Camera_Movement.BACKWARD, self.delta_time) if self.camera.bool_d: self.camera.ProcessKeyboard(Camera_Movement.RIGHT, self.delta_time) self.view = self.camera.GetViewMatrix() self.projection = glm.perspective(glm.radians(self.camera.Zoom), builtins.width / builtins.height, 0.1, 100.0) # vispy takes numpy array in m * n matrix form self.view = (np.array(self.view.to_list()).astype(np.float32)) self.projection = (np.array(self.projection.to_list()).astype( np.float32)) # reshaping to (m, n) to (1, m*n) to support data input in vispy self.view = self.view.reshape( (1, self.view.shape[0] * self.view.shape[1])) self.projection = self.projection.reshape( (1, self.projection.shape[0] * self.projection.shape[1])) # drawing normal cube self.program['view'] = self.view self.program['projection'] = self.projection self.program['a_position'] = self.vertices self.program['aNormal'] = self.aNormal self.program['viewPos'] = self.camera.Position self.program['texCoords'] = self.texCoord self.program['l_ambient[0]'] = [0.2, 0.2, 0.2] self.program['l_diffuse[0]'] = [1, 1, 0.5] self.program['l_specular[0]'] = [1.0, 1.0, 1.0] self.program['l_direction[0]'] = [-0.3, -1, -1] self.program['m_diffuse[0]'] = self.diffuse_map self.program['m_shininess[0]'] = 32 self.program['m_specular[0]'] = self.specular_map self.model = glm.mat4(1.0) # rotate the cube if you want # self.model = glm.rotate(self.model, glm.radians((time() - self.startTime) * 10), glm.vec3(0,1.5,1)) self.model = glm.translate(self.model, glm.vec3(0, 0.5, 0)) self.model = (np.array(self.model.to_list()).astype(np.float32)) self.model = self.model.reshape( (1, self.model.shape[0] * self.model.shape[1])) self.program['model'] = self.model self.program.draw('triangles') self.model = glm.mat4(1.0) self.model = glm.translate(self.model, glm.vec3(0.5, 0.5, 2)) self.model = (np.array(self.model.to_list()).astype(np.float32)) self.model = self.model.reshape( (1, self.model.shape[0] * self.model.shape[1])) self.program['model'] = self.model self.program.draw('triangles') self.program['a_position'] = self.vertices * 10 self.model = glm.mat4(1.0) self.model = glm.translate(self.model, glm.vec3(0, -5, 0)) self.model = (np.array(self.model.to_list()).astype(np.float32)) self.model = self.model.reshape( (1, self.model.shape[0] * self.model.shape[1])) self.program['model'] = self.model self.program.draw('triangles') gl.glStencilFunc(gl.GL_NOTEQUAL, 1, 0xFF) gl.glStencilMask(0x00) gl.glDisable(gl.GL_DEPTH_TEST) self.model = glm.mat4(1.0) self.model = glm.translate(self.model, [0, 0.5, 0]) self.model = (np.array(self.model.to_list()).astype(np.float32)) self.model = self.model.reshape( (1, self.model.shape[0] * self.model.shape[1])) # drawing light source self.programLightSource['model'] = self.model self.programLightSource['view'] = self.view self.programLightSource['projection'] = self.projection self.programLightSource['a_position'] = self.vertices * 1.2 self.programLightSource.draw('triangles') gl.glStencilMask(0xFF) gl.glStencilFunc(gl.GL_ALWAYS, 1, 0xFF) gl.glEnable(gl.GL_DEPTH_TEST) self.update()
def on_initialize(self, event): # Build & activate cube program self.cube = gl.glCreateProgram() vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(vertex, cube_vertex) gl.glShaderSource(fragment, cube_fragment) gl.glCompileShader(vertex) gl.glCompileShader(fragment) gl.glAttachShader(self.cube, vertex) gl.glAttachShader(self.cube, fragment) gl.glLinkProgram(self.cube) gl.glDetachShader(self.cube, vertex) gl.glDetachShader(self.cube, fragment) gl.glUseProgram(self.cube) # Get data & build cube buffers vcube_data, self.icube_data = makecube() vcube = gl.glCreateBuffer() gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vcube) gl.glBufferData(gl.GL_ARRAY_BUFFER, vcube_data, gl.GL_STATIC_DRAW) icube = gl.glCreateBuffer() gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, icube) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, self.icube_data, gl.GL_STATIC_DRAW) # Bind cube attributes stride = vcube_data.strides[0] offset = 0 loc = gl.glGetAttribLocation(self.cube, "a_position") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset) offset = vcube_data.dtype["a_position"].itemsize loc = gl.glGetAttribLocation(self.cube, "a_texcoord") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset) # Create & bind cube texture crate = checkerboard() texture = gl.glCreateTexture() gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, gl.GL_LUMINANCE, gl.GL_UNSIGNED_BYTE, crate.shape[:2]) gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, gl.GL_LUMINANCE, gl.GL_UNSIGNED_BYTE, crate) loc = gl.glGetUniformLocation(self.cube, "u_texture") gl.glUniform1i(loc, texture) gl.glBindTexture(gl.GL_TEXTURE_2D, 0) # Create & bind cube matrices view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) projection = np.eye(4, dtype=np.float32) translate(view, 0, 0, -7) self.phi, self.theta = 60, 20 rotate(model, self.theta, 0, 0, 1) rotate(model, self.phi, 0, 1, 0) loc = gl.glGetUniformLocation(self.cube, "u_model") gl.glUniformMatrix4fv(loc, 1, False, model) loc = gl.glGetUniformLocation(self.cube, "u_view") gl.glUniformMatrix4fv(loc, 1, False, view) loc = gl.glGetUniformLocation(self.cube, "u_projection") gl.glUniformMatrix4fv(loc, 1, False, projection) # OpenGL initalization gl.glClearColor(0.30, 0.30, 0.35, 1.00) gl.glEnable(gl.GL_DEPTH_TEST) self._resize(*(self.size + self.physical_size)) self.timer = app.Timer('auto', self.on_timer, start=True)
def on_initialize(self, event): gl.glClearColor(0, 0, 0, 1) # Enable blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
def on_initialize(self, event): gl.glClearColor(1, 1, 1, 1) gl.glEnable(gl.GL_DEPTH_TEST)
def on_initialize(self, event): # Build & activate cube program self.cube = gl.glCreateProgram() vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(vertex, cube_vertex) gl.glShaderSource(fragment, cube_fragment) gl.glCompileShader(vertex) gl.glCompileShader(fragment) gl.glAttachShader(self.cube, vertex) gl.glAttachShader(self.cube, fragment) gl.glLinkProgram(self.cube) gl.glDetachShader(self.cube, vertex) gl.glDetachShader(self.cube, fragment) gl.glUseProgram(self.cube) # Get data & build cube buffers vcube_data, self.icube_data = makecube() vcube = gl.glCreateBuffer() gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vcube) gl.glBufferData(gl.GL_ARRAY_BUFFER, vcube_data, gl.GL_STATIC_DRAW) icube = gl.glCreateBuffer() gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, icube) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, self.icube_data, gl.GL_STATIC_DRAW) # Bind cube attributes stride = vcube_data.strides[0] offset = 0 loc = gl.glGetAttribLocation(self.cube, "a_position") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset) offset = vcube_data.dtype["a_position"].itemsize loc = gl.glGetAttribLocation(self.cube, "a_texcoord") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset) # Create & bind cube texture crate = checkerboard() texture = gl.glCreateTexture() gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, gl.GL_LUMINANCE, gl.GL_UNSIGNED_BYTE, crate.shape[:2]) gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, gl.GL_LUMINANCE, gl.GL_UNSIGNED_BYTE, crate) loc = gl.glGetUniformLocation(self.cube, "u_texture") gl.glUniform1i(loc, texture) gl.glBindTexture(gl.GL_TEXTURE_2D, 0) # Create & bind cube matrices view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) projection = np.eye(4, dtype=np.float32) translate(view, 0, 0, -7) self.phi, self.theta = 60, 20 rotate(model, self.theta, 0, 0, 1) rotate(model, self.phi, 0, 1, 0) loc = gl.glGetUniformLocation(self.cube, "u_model") gl.glUniformMatrix4fv(loc, 1, False, model) loc = gl.glGetUniformLocation(self.cube, "u_view") gl.glUniformMatrix4fv(loc, 1, False, view) loc = gl.glGetUniformLocation(self.cube, "u_projection") gl.glUniformMatrix4fv(loc, 1, False, projection) # OpenGL initalization gl.glClearColor(0.30, 0.30, 0.35, 1.00) gl.glEnable(gl.GL_DEPTH_TEST) self.timer.start()
def on_initialize(self, event): gl.glClearColor(1, 1, 1, 1) gl.glEnable(gl.GL_DEPTH_TEST) gl.glPolygonOffset(1, 1)
def _draw(self, dt): self.frame_time = dt win_width = calib.CALIB_DISP_WIN_SIZE_WIDTH win_height = calib.CALIB_DISP_WIN_SIZE_HEIGHT # Set 2D scaling for aspect 1 if win_height > win_width: u_mapcalib_aspectscale = np.eye(2) * np.array( [1, win_width / win_height]) else: u_mapcalib_aspectscale = np.eye(2) * np.array( [win_height / win_width, 1]) self.transform_uniforms[ 'u_mapcalib_aspectscale'] = u_mapcalib_aspectscale self.transform_uniforms[ 'u_mapcalib_lateral_luminance_offset'] = calib.CALIB_DISP_SPH_LAT_LUM_OFFSET self.transform_uniforms[ 'u_mapcalib_lateral_luminance_gradient'] = calib.CALIB_DISP_SPH_LAT_LUM_GRADIENT # Make sure stencil testing is disabled and depth testing is enabled #gl.glDisable(gl.GL_STENCIL_TEST) gl.glEnable(gl.GL_DEPTH_TEST) # Clear raw stimulus buffer with self._raw_fb: gloo.clear() # Clear mask buffer with self._mask_fb: gloo.clear() with self._out_fb: gloo.clear() with self._display_fb: gloo.clear() azim_orientation = calib.CALIB_DISP_SPH_VIEW_AZIM_ORIENT for i in range(4): # Set 3D transform distance = calib.CALIB_DISP_SPH_VIEW_DISTANCE[i] fov = calib.CALIB_DISP_SPH_VIEW_FOV[i] view_scale = calib.CALIB_DISP_SPH_VIEW_SCALE[i] azim_angle = calib.CALIB_DISP_SPH_VIEW_AZIM_ANGLE[i] elev_angle = calib.CALIB_DISP_SPH_VIEW_ELEV_ANGLE[i] radial_offset_scalar = calib.CALIB_DISP_SPH_POS_RADIAL_OFFSET[i] lateral_offset_scalar = calib.CALIB_DISP_SPH_POS_LATERAL_OFFSET[i] # Set angles self.transform_uniforms[ 'u_mapcalib_azimuth_angle'] = azim_angle + 45. self.transform_uniforms['u_mapcalib_elevation_angle'] = elev_angle # Set relative size self.transform_uniforms[ 'u_mapcalib_scale'] = view_scale * np.array([1, 1]) # 3D translation self.transform_uniforms[ 'u_mapcalib_translation'] = transforms.translate( (0, 0, -distance)) # 3D projection self.transform_uniforms[ 'u_mapcalib_projection'] = transforms.perspective( fov, 1., 0.1, 400.0) xy_offset = np.array([ calib.CALIB_DISP_GLOB_POS_X * win_width / win_height, calib.CALIB_DISP_GLOB_POS_Y ]) self.transform_uniforms['u_mapcalib_rotate_x'] = transforms.rotate( 90, (1, 0, 0)) # 3D elevation rotation self.transform_uniforms[ 'u_mapcalib_rotate_elev'] = transforms.rotate( -elev_angle, (1, 0, 0)) # 2D rotation around center of screen self.transform_uniforms[ 'u_mapcalib_rotate2d'] = geometry.rotation2D(np.pi / 4 - np.pi / 2 * i) # 2D translation radially radial_offset = np.array([ -np.real(1.j**(.5 + i)), -np.imag(1.j**(.5 + i)) ]) * radial_offset_scalar sign = -1 if i % 2 == 0 else +1 lateral_offset = np.array([ sign * np.real(1.j**(.5 + i)), sign * -1 * np.imag(1.j**(.5 + i)) ]) * lateral_offset_scalar self.transform_uniforms[ 'u_mapcalib_translate2d'] = radial_offset + xy_offset + lateral_offset # Render 90 degree mask to mask buffer # (BEFORE further 90deg rotation) self.transform_uniforms['u_mapcalib_rotate_z'] = transforms.rotate( 45 + azim_angle, (0, 0, 1)) self.apply_transform(self._mask_program) self._mask_program['u_part'] = i with self._mask_fb: self._mask_program.draw('triangles', self._mask_index_buffer) # Apply 90*i degree rotation to actual spherical stimulus self.transform_uniforms['u_mapcalib_rotate_z'] = transforms.rotate( azim_orientation + 90 * i + azim_angle, (0, 0, 1)) # And render actual stimulus sphere with self._raw_fb: # Important: only provide dt on first iteration. # Otherwise the final cumulative time is going to be ~4*dt (too high!) self.render(dt if i == 0 else 0.0) # Combine mask and raw texture into out_texture # (To optionally be saved to disk and rendered to screen) self._out_prog['u_part'] = i with self._out_fb: self._out_prog.draw('triangle_strip') with self._mask_fb: gloo.clear() with self._raw_fb: gloo.clear()
def on_initialize(self, event): gl.glClearColor(1, 1, 1, 1) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def on_initialize(self, event): gl.glClearColor(0, 0, 0, 1) gl.glEnable(gl.GL_DEPTH_TEST)
def __enter__(self): if self.enabled: gl.glEnable(GL_CONSERVATIVE_RASTERIZATION_NV)
def on_initialize(self, event): gl.glClearColor(1,1,1,1) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def on_initialize(self, event): gl.glClearColor(0, 0, 0, 1) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def __init__(self, size): app.Canvas.__init__(self, title='Hello OpenGL', keys='interactive', size=size) # vispy wrapper of glfw dont have the wrapper of this function yet, I am opening a PR for this # by the time we can use this self._app.native.glfwSetInputMode( self.native._id, self._app.native.GLFW_CURSOR, self._app.native.GLFW_CURSOR_DISABLED) builtins.width, builtins.height = size # camera instance self.camera = Camera(position=glm.vec3(0, 0, 3), sensitivity=0.2) self.startTime = time() self.first_mouse = True self.lightPos = [0, 0, 0] self.lightColor = glm.vec3(1) self.program = gloo.Program(vertex, fragment) self.programLightSource = gloo.Program(lightSourceVertex, lightSourceFragment) self.vertices = np.array([[-0.5, -0.5, -0.5], [0.5, -0.5, -0.5], [0.5, 0.5, -0.5], [0.5, 0.5, -0.5], [-0.5, 0.5, -0.5], [-0.5, -0.5, -0.5], [-0.5, -0.5, 0.5], [0.5, -0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [-0.5, 0.5, 0.5], [-0.5, -0.5, 0.5], [-0.5, 0.5, 0.5], [-0.5, 0.5, -0.5], [-0.5, -0.5, -0.5], [-0.5, -0.5, -0.5], [-0.5, -0.5, 0.5], [-0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, -0.5], [0.5, -0.5, -0.5], [0.5, -0.5, -0.5], [0.5, -0.5, 0.5], [0.5, 0.5, 0.5], [-0.5, -0.5, -0.5], [0.5, -0.5, -0.5], [0.5, -0.5, 0.5], [0.5, -0.5, 0.5], [-0.5, -0.5, 0.5], [-0.5, -0.5, -0.5], [-0.5, 0.5, -0.5], [0.5, 0.5, -0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [-0.5, 0.5, 0.5], [-0.5, 0.5, -0.5]]).astype(np.float32) self.aNormal = np.array([ [0, 0, -1], [0, 0, -1], [0, 0, -1], [0, 0, -1], [0, 0, -1], [0, 0, -1], [0, 0, 1], [0, 0, 1], [0, 0, 1], [0, 0, 1], [0, 0, 1], [0, 0, 1], [-1, 0, 0], [-1, 0, 0], [-1, 0, 0], [-1, 0, 0], [-1, 0, 0], [-1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0], [0, -1, 0], [0, -1, 0], [0, -1, 0], [0, -1, 0], [0, -1, 0], [0, -1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], ]).astype(np.float32) self.texCoord = np.array( [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [1.0, 1.0], [0.0, 1.0], [0.0, 0.0], [0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [1.0, 1.0], [0.0, 1.0], [0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 0.0], [1.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0], [1.0, 0.0], [0.0, 0.0], [0.0, 1.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0], [1.0, 0.0], [0.0, 0.0], [0.0, 1.0]]).astype(np.float32) self.diffuse_map = gloo.Texture2D( data=np.flip(io.imread('Assets/container2.png'), 0)) self.specular_map = gloo.Texture2D( data=np.flip(io.imread('Assets/container2_specular.png'), 0)) self.model = None self.projection = None self.view = None # delta time self.delta_time = 0 self.last_frame = 0 # mouse variables self.last_x = None self.last_y = None self.timer = app.Timer('auto', self.on_timer, start=True) gloo.set_state(depth_test=True) gl.glDepthFunc(gl.GL_LESS) gl.glEnable(gl.GL_STENCIL_TEST) self.show()