def __init__(self, width, height): global tex_src global tex_lut self.width = width self.height = height # // Load texture from file tex_src = ktxobject.ktx_load("treelights_2k.ktx") # // Now bind it to the context using the GL_TEXTURE_2D binding point glBindTexture(GL_TEXTURE_2D, tex_src) glGenVertexArrays(1, vao) glBindVertexArray(vao) load_shaders() exposureLUT = [ 11.0, 6.0, 3.2, 2.8, 2.2, 1.90, 1.80, 1.80, 1.70, 1.70, 1.60, 1.60, 1.50, 1.50, 1.40, 1.40, 1.30, 1.20, 1.10, 1.00 ] tex_lut = glGenTextures(1) glBindTexture(GL_TEXTURE_1D, tex_lut) glTexStorage1D(GL_TEXTURE_1D, 1, GL_R32F, 20) glTexSubImage1D(GL_TEXTURE_1D, 0, 0, 20, GL_RED, GL_FLOAT, exposureLUT) glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
def plot(self): # Specify shader to be used glUseProgram(self.gls_pgr.program_id) # Bind VAO - this will automatically # bind all the vbo's saving us a bunch # of calls #glBindVertexArray(self.vao_id) glUniform4fv(self.gls_id_xy_color,1, self.plot_color) # Modern GL makes the draw call really simple # All the complexity has been pushed elsewhere glEnableVertexAttribArray(self.vertIndex) # set buffers glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer) glVertexAttribPointer(self.vertIndex,2, GL_FLOAT, GL_FALSE, 0, None) glDrawArrays(GL_LINE_STRIP, 0, self.data_points-1) # Lets unbind the shader and vertex array state glUseProgram(0) # disable arrays glDisableVertexAttribArray(self.vertIndex) glBindVertexArray(0)
def compile_program(): program = glCreateProgram() vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_source) glCompileShader(vs) tcs = glCreateShader(GL_TESS_CONTROL_SHADER) glShaderSource(tcs, tcs_source) glCompileShader(tcs) tes = glCreateShader(GL_TESS_EVALUATION_SHADER) glShaderSource(tes, tes_source) glCompileShader(tes) fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_source) glCompileShader(fs) glAttachShader(program, vs) glAttachShader(program, tcs) glAttachShader(program, tes) glAttachShader(program, fs) glLinkProgram(program) vao = GLuint(0) glGenVertexArrays(1, vao) glBindVertexArray(vao) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) return program
def display(self): currentTime = time.time() t = currentTime * 0.02 r = 550.0 black = [0.0, 0.0, 0.0, 1.0] one = 1.0 glClearBufferfv(GL_COLOR, 0, black) glClearBufferfv(GL_DEPTH, 0, one) mv_matrix = (GLfloat * 16)(*identityMatrix) mv_matrix = m3dLookAt([sin(t) * r, 25.0, cos(t) * r], [0.0, -50.0, 0.0], [0.0, 1.0, 0.0]) prj_matrix = (GLfloat * 16)(*identityMatrix) prj_matrix = m3dPerspective(m3dDegToRad(45.0), float(self.width) / float(self.height), 0.1, 1000.0) glUseProgram(grass_program) glUniformMatrix4fv(uniform.mvpMatrix, 1, GL_FALSE, m3dMultiply(prj_matrix, mv_matrix)) glEnable(GL_DEPTH_TEST) glDepthFunc(GL_LEQUAL) glViewport(0, 0, self.width, self.height) glBindVertexArray(grass_vao) glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 6, 1024 * 1024) glutSwapBuffers()
def reset(self, attr_idx=0): glUseProgram(0) #--TODO enable/destroy all buffers glDisableVertexAttribArray(attr_idx) glBindVertexArray(0) self.vbo_isinit = False
def plot(self): # Specify shader to be used glUseProgram(self.gls_pgr.program_id) # Bind VAO - this will automatically # bind all the vbo's saving us a bunch # of calls #glBindVertexArray(self.vao_id) glUniform4fv(self.gls_id_xy_color, 1, self.plot_color) # Modern GL makes the draw call really simple # All the complexity has been pushed elsewhere glEnableVertexAttribArray(self.vertIndex) # set buffers glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer) glVertexAttribPointer(self.vertIndex, 2, GL_FLOAT, GL_FALSE, 0, None) glDrawArrays(GL_LINE_STRIP, 0, self.data_points - 1) # Lets unbind the shader and vertex array state glUseProgram(0) # disable arrays glDisableVertexAttribArray(self.vertIndex) glBindVertexArray(0)
def init(): global VAOs glGenVertexArrays(1, VAOs) glBindVertexArray(VAOs) vertices = [ [-0.90, -0.90], [0.85, -0.90], [-0.90, 0.85], [0.90, -0.85], [0.90, 0.90], [-0.85, 0.90], ] vertices = np.array(vertices, dtype="f") buffers = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, buffers) glBufferData(GL_ARRAY_BUFFER, vertices, GL_STATIC_DRAW) shaders = [ (GL_VERTEX_SHADER, "triangles.vert"), (GL_FRAGMENT_SHADER, "triangles.frag"), ] program = LoadShaders(shaders) glUseProgram(program) glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, None) glEnableVertexAttribArray(0)
def vbo_reset(self,attr_idx=0): glUseProgram(0) #--TODO enable/destroy all buffers glDisableVertexAttribArray(attr_idx) glBindVertexArray(0) self.vbo_isinit = False
def display(): glClear(GL_COLOR_BUFFER_BIT) glBindVertexArray(VAOs); glDrawArrays(GL_TRIANGLES, 0, NumVertices) glFlush()
def display(self): currentTime = time.time() glUseProgram(prefix_sum_prog) glBindImageTexture(0, images[0], 0, GL_FALSE, 0, GL_READ_ONLY, GL_R32F) glBindImageTexture(1, images[1], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32F) glDispatchCompute(NUM_ELEMENTS, 1, 1) glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT) glBindImageTexture(0, images[1], 0, GL_FALSE, 0, GL_READ_ONLY, GL_R32F) glBindImageTexture(1, images[2], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32F) glDispatchCompute(NUM_ELEMENTS, 1, 1) glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT) glBindTexture(GL_TEXTURE_2D, images[2]) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, images[2]) glUseProgram(show_image_prog) glViewport(0, 0, self.width, self.height) glBindVertexArray(dummy_vao) glDrawArrays(GL_TRIANGLE_STRIP, 0, 4) glutSwapBuffers()
def display(self): global myobject currentTime = time.time() j = 0 one = 1.0 black = [0.0, 0.0, 0.0, 0.0] last_time = 0.0 total_time = 0.0 if (paused == False): total_time += (currentTime - last_time) last_time = currentTime t = float(total_time) i = int(total_time * 3.0) glViewport(0, 0, self.width, self.height) glClearBufferfv(GL_COLOR, 0, black) glClearBufferfv(GL_DEPTH, 0, one) view_matrix = (GLfloat * 16)(*identityMatrix) view_matrix = m3dLookAt([ 100.0 * cos(t * 0.023), 100.0 * cos(t * 0.023), 300.0 * sin(t * 0.037) - 600.0 ], [0.0, 0.0, 260.0], normalize([0.1 - cos(t * 0.1) * 0.3, 1.0, 0.0])) proj_matrix = (GLfloat * 16)(*identityMatrix) proj_matrix = m3dPerspective(m3dDegToRad(50.0), float(self.width) / float(self.height), 1.0, 2000.0) glUseProgram(render_program) glUniform1f(uniform.time, t) glUniformMatrix4fv(uniform.view_matrix, 1, GL_FALSE, view_matrix) glUniformMatrix4fv(uniform.proj_matrix, 1, GL_FALSE, proj_matrix) glUniformMatrix4fv(uniform.viewproj_matrix, 1, GL_FALSE, m3dMultiply(proj_matrix, view_matrix)) glBindVertexArray(myobject.get_vao()) if (mode == MODE_MULTIDRAW): glMultiDrawArraysIndirect(GL_TRIANGLES, None, NUM_DRAWS, 0) elif (mode == MODE_SEPARATE_DRAWS): for j in range(0, NUM_DRAWS): first, count = myobject.get_sub_object_info( j % myobject.get_sub_object_count()) glDrawArraysInstancedBaseInstance(GL_TRIANGLES, first, count, 1, j) glutSwapBuffers()
def compile_program(vertex_source, fragment_source): texture = glGenTextures(1) #// Generate a name for the texture glGenTextures(1, texture); #// Now bind it to the context using the GL_TEXTURE_2D binding point glBindTexture(GL_TEXTURE_2D, texture); #// Specify the amount of storage we want to use for the texture glTexStorage2D(GL_TEXTURE_2D, #// 2D texture 8, #// 8 mipmap levels GL_RGBA32F, #// 32-bit floating-point RGBA data 256, 256); #// 256 x 256 texels #// Define some data to upload into the texture data = np.zeros(256 * 256 * 4); #// generate_texture() is a function that fills memory with image data generate_texture(data, 256, 256); #// Assume the texture is already bound to the GL_TEXTURE_2D target glTexSubImage2D(GL_TEXTURE_2D, #// 2D texture 0, #// Level 0 0, 0, #// Offset 0, 0 256, 256, #// 256 x 256 texels, replace entire image GL_RGBA, #// Four channel data GL_FLOAT, #// Floating point data data); #// Pointer to data #// Free the memory we allocated before - \GL now has our data #delete data; program = glCreateProgram(); fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs, fragment_source); glCompileShader(fs); #print_shader_log(fs); vs = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vs, vertex_source); glCompileShader(vs); #print_shader_log(vs); glAttachShader(program, vs); glAttachShader(program, fs); glLinkProgram(program); vao = GLuint(0) glGenVertexArrays(1, vao); glBindVertexArray(vao); return program
def display(self): black = [0.0, 0.0, 0.0, 0.0] glClearBufferfv(GL_COLOR, 0, black) glUseProgram(square_program) glBindVertexArray(square_vao) glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, 4) glutSwapBuffers()
def display(self): currentTime = time.time() gray = [ 0.2, 0.2, 0.2, 1.0 ] ones = [ 1.0 ] t = currentTime * 0.1 proj_matrix = (GLfloat * 16)(*identityMatrix) proj_matrix = m3dPerspective(m3dDegToRad(60.0), float(self.width) / float(self.height), 0.1, 1000.0); view_matrix = (GLfloat * 16)(*identityMatrix) view_matrix = m3dLookAt([15.0 * sin(t), 0.0, 15.0 * cos(t)], (0.0, 0.0, 0.0), (0.0, 1.0, 0.0)) RX = (GLfloat * 16)(*identityMatrix) m3dRotationMatrix44(RX, t * m3dDegToRad(0.0), 1.0, 0.0, 0.0) RY = (GLfloat * 16)(*identityMatrix) m3dRotationMatrix44(RY, t * m3dDegToRad(130.1), 0.0, 1.0, 0.0) T = (GLfloat * 16)(*identityMatrix) m3dTranslateMatrix44(T, 0.0, -4.0, 0.0) mv_matrix = (GLfloat * 16)(*identityMatrix) mv_matrix = m3dMultiply(RX, m3dMultiply(RY, T)) mv_matrix = m3dMultiply(view_matrix , mv_matrix) glClearBufferfv(GL_COLOR, 0, gray) glClearBufferfv(GL_DEPTH, 0, ones) glBindTexture(GL_TEXTURE_CUBE_MAP, tex_envmap) glViewport(0, 0, self.width, self.height) glUseProgram(skybox_prog) glBindVertexArray(skybox_vao) glUniformMatrix4fv(uniforms.skybox.view_matrix, 1, GL_FALSE, view_matrix) glDisable(GL_DEPTH_TEST) glDrawArrays(GL_TRIANGLE_STRIP, 0, 4) glUseProgram(render_prog) glUniformMatrix4fv(uniforms.render.mv_matrix, 1, GL_FALSE, mv_matrix) glUniformMatrix4fv(uniforms.render.proj_matrix, 1, GL_FALSE, proj_matrix) glEnable(GL_DEPTH_TEST) myobject.render() glutSwapBuffers()
def init_vao_vbo(self,data=None): if data.size: self.vao_data=data # Lets create a VAO and bind it # Think of VAO's as object that encapsulate buffer state # Using a VAO enables you to cut down on calls in your draw # loop which generally makes things run faster self.vertexBuffer = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer) glBufferData(GL_ARRAY_BUFFER, 4*len(self.vao_data), self.vao_data,GL_DYNAMIC_DRAW) #self.vbo_id = glGenBuffers(1) #glBindBuffer(GL_ARRAY_BUFFER, self.vbo_id) #vertexData = numpy.array(quadV, numpy.float32) #glBufferData(GL_ARRAY_BUFFER, 4*len(self.vao_data), self.vao_data,GL_DYNAMIC_DRAW) # self.vao_id = \ #vao_id=glGenVertexArrays(1,None) #self.vao_id=vao_id #print vao_id #glBindVertexArray(self.vao_id[0]) # Lets create our Vertex Buffer objects - these are the buffers # that will contain our per vertex data #self.vbo_id = glGenBuffers(1) # Bind a buffer before we can use it #glBindBuffer(GL_ARRAY_BUFFER, self.vbo_id[0]) # Now go ahead and fill this bound buffer with some data #glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(self.data), self.data, GL_DYNAMIC_DRAW) # Now specify how the shader program will be receiving this data # In this case the data from this buffer will be available in the shader as the vin_position vertex attribute # Now do the same for the other vertex buffer #glBindBuffer(GL_ARRAY_BUFFER, vbo_id[1]) #glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(color_data), color_data, GL_STATIC_DRAW) #glVertexAttribPointer(program.attribute_location('vin_color'), 3, GL_FLOAT, GL_FALSE, 0, None) #glEnableVertexAttribArray(1) # Lets unbind our vbo and vao state # We will bind these again in the draw loop glBindBuffer(GL_ARRAY_BUFFER, 0) glBindVertexArray(0)
def init_vao_vbo(self, data=None): if data.size: self.vao_data = data # Lets create a VAO and bind it # Think of VAO's as object that encapsulate buffer state # Using a VAO enables you to cut down on calls in your draw # loop which generally makes things run faster self.vertexBuffer = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer) glBufferData(GL_ARRAY_BUFFER, 4 * len(self.vao_data), self.vao_data, GL_DYNAMIC_DRAW) #self.vbo_id = glGenBuffers(1) #glBindBuffer(GL_ARRAY_BUFFER, self.vbo_id) #vertexData = numpy.array(quadV, numpy.float32) #glBufferData(GL_ARRAY_BUFFER, 4*len(self.vao_data), self.vao_data,GL_DYNAMIC_DRAW) # self.vao_id = \ #vao_id=glGenVertexArrays(1,None) #self.vao_id=vao_id #print vao_id #glBindVertexArray(self.vao_id[0]) # Lets create our Vertex Buffer objects - these are the buffers # that will contain our per vertex data #self.vbo_id = glGenBuffers(1) # Bind a buffer before we can use it #glBindBuffer(GL_ARRAY_BUFFER, self.vbo_id[0]) # Now go ahead and fill this bound buffer with some data #glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(self.data), self.data, GL_DYNAMIC_DRAW) # Now specify how the shader program will be receiving this data # In this case the data from this buffer will be available in the shader as the vin_position vertex attribute # Now do the same for the other vertex buffer #glBindBuffer(GL_ARRAY_BUFFER, vbo_id[1]) #glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(color_data), color_data, GL_STATIC_DRAW) #glVertexAttribPointer(program.attribute_location('vin_color'), 3, GL_FLOAT, GL_FALSE, 0, None) #glEnableVertexAttribArray(1) # Lets unbind our vbo and vao state # We will bind these again in the draw loop glBindBuffer(GL_ARRAY_BUFFER, 0) glBindVertexArray(0)
def constructCylinderMesh(self, slices, radius, length, direction): self.slices = slices self.radius = radius self.vertex_array_type = GL_TRIANGLES vertex_list, tris = construct_triangle_cylinder(slices, radius, length) self.numVertices = len(vertex_list) self.numIndices = len(tris) * 3 # Create the Vertex Array Object self.vertexArrayObject = GLuint(0) glGenVertexArrays(1, self.vertexArrayObject) glBindVertexArray(self.vertexArrayObject) indices = np.array( tris, dtype='uint32') # np.array(tris).reshape(1,numIndices)[0] self.indices = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER) self.vertices = vbo.VBO(np.array(vertex_list, 'f'))
def __init__(self, width, height): global overlay global texture global program global vao self.width = width self.height = height overlay.init(80, 50) #// Generate a name for the texture glGenTextures(1, texture) #// Load texture from file texture = ktxobject.ktx_load("treelights_2k.ktx") #// Now bind it to the context using the GL_TEXTURE_2D binding point glBindTexture(GL_TEXTURE_2D, texture) program = glCreateProgram() fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_source) glCompileShader(fs) if not glGetShaderiv(fs, GL_COMPILE_STATUS): print('compile error:') print(glGetShaderInfoLog(fs)) vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_source) glCompileShader(vs) if not glGetShaderiv(vs, GL_COMPILE_STATUS): print('compile error:') print(glGetShaderInfoLog(vs)) glAttachShader(program, vs) glAttachShader(program, fs) glLinkProgram(program) if not glGetProgramiv(program, GL_LINK_STATUS): print('link error:') print(glGetProgramInfoLog(program)) glGenVertexArrays(1, vao) glBindVertexArray(vao)
def __init__(self, width, height): global depth_fbo global objects global depth_tex global depth_debug_tex global quad_vao load_shaders() object_names = ["dragon.sbm", "sphere.sbm", "cube.sbm", "torus.sbm"] for i in range(0, OBJECT_COUNT): objects[i].obj.load(object_names[i]) glGenFramebuffers(1, depth_fbo) glBindFramebuffer(GL_FRAMEBUFFER, depth_fbo) depth_tex = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, depth_tex) glTexStorage2D(GL_TEXTURE_2D, 11, GL_DEPTH_COMPONENT32F, DEPTH_TEXTURE_SIZE, DEPTH_TEXTURE_SIZE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL) glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_tex, 0) depth_debug_tex = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, depth_debug_tex) glTexStorage2D(GL_TEXTURE_2D, 1, GL_R32F, DEPTH_TEXTURE_SIZE, DEPTH_TEXTURE_SIZE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, depth_debug_tex, 0) glBindTexture(GL_TEXTURE_2D, 0) glBindFramebuffer(GL_FRAMEBUFFER, 0) glEnable(GL_DEPTH_TEST) glGenVertexArrays(1, quad_vao) glBindVertexArray(quad_vao)
def constructSphereMesh(self, slices, stacks, radius): self.slices = slices self.stacks = stacks self.radius = radius self.vertex_array_type = GL_TRIANGLES vertexList, tris = construct_triangle_sphere(slices, stacks, radius * 2) self.numVertices = (slices + 1) * (stacks + 1) self.numIndices = len(tris) * 3 #Create the Vertex Array Object self.vertexArrayObject = GLuint(0) glGenVertexArrays(1, self.vertexArrayObject) glBindVertexArray(self.vertexArrayObject) indices = np.array( tris, dtype='uint32') #np.array(tris).reshape(1,numIndices)[0] self.indices = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER) self.vertices = vbo.VBO(np.array(vertexList, 'f'))
def draw(self): glUseProgram(self.text_program) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, self.text_buffer) if (self.dirty): glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, self.buffer_width, self.buffer_height, GL_RED_INTEGER, GL_UNSIGNED_BYTE, str(''.join(self.screen_buffer))) dirty = False glActiveTexture(GL_TEXTURE1) glBindTexture(GL_TEXTURE_2D_ARRAY, self.font_texture) glBindVertexArray(self.vao) glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)
def compile_program(): program = glCreateProgram() vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_source) glCompileShader(vs) tcs = glCreateShader(GL_TESS_CONTROL_SHADER) glShaderSource(tcs, tcs_source) glCompileShader(tcs) tes = glCreateShader(GL_TESS_EVALUATION_SHADER) glShaderSource(tes, tes_source) glCompileShader(tes) gs = glCreateShader(GL_GEOMETRY_SHADER) glShaderSource(gs, gs_source) glCompileShader(gs) fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_source) glCompileShader(fs) glAttachShader(program, vs) glAttachShader(program, tcs) glAttachShader(program, tes) glAttachShader(program, gs) glAttachShader(program, fs) glLinkProgram(program) glDeleteShader(vs) glDeleteShader(tcs) glDeleteShader(tes) glDeleteShader(gs) glDeleteShader(fs) vao = GLuint(0) glGenVertexArrays(1, vao) glBindVertexArray(vao) return program
def display(self): currentTime = time.time() black = [0.0, 0.0, 0.0, 0.0] one = [1.0] t = currentTime glViewport(0, 0, self.width, self.height) glClearBufferfv(GL_COLOR, 0, black) glClearBufferfv(GL_DEPTH, 0, one) glUseProgram(render_prog) glPointSize(200.0) glBindVertexArray(render_vao) glDrawArrays(GL_POINTS, 0, 4) glutSwapBuffers()
def display(self): currentTime = time.time() black = [0.0, 0.0, 0.0, 1.0] one = 1.0 f = currentTime glViewport(0, 0, self.width, self.height) glClearBufferfv(GL_COLOR, 0, black) glClearBufferfv(GL_DEPTH, 0, one) glUseProgram(program) proj_matrix = (GLfloat * 16)(*identityMatrix) proj_matrix = m3dPerspective(m3dDegToRad(50.0), float(self.width) / float(self.height), .1, 1000.0) T = (GLfloat * 16)(*identityMatrix) m3dTranslateMatrix44(T, 0.0, 0.0, -8.0) RY = (GLfloat * 16)(*identityMatrix) m3dRotationMatrix44(RY, currentTime * m3dDegToRad(17.0), 0.0, 1.0, 0.0) RX = (GLfloat * 16)(*identityMatrix) m3dRotationMatrix44(RX, currentTime * m3dDegToRad(10.0), 1.0, 0.0, 0.0) mv_matrix = (GLfloat * 16)(*identityMatrix) mv_matrix = m3dMultiply(T, m3dMultiply(RY, RX)) glUniformMatrix4fv(mvp_location, 1, GL_FALSE, m3dMultiply(proj_matrix, mv_matrix)) glUniformMatrix4fv(mv_location, 1, GL_FALSE, mv_matrix) glUniform1f(stretch_location, sin(f * 4.0) * 0.75 + 1.0) glBindVertexArray(vao) glDrawElements(GL_TRIANGLES, 12, GL_UNSIGNED_SHORT, None) glutSwapBuffers()
def __init__(self, width, height): global objects global quad_vao self.width = width self.height = height self.flags.fullscreen = 0 self.flags.stereo = 1 load_shaders() object_names = ["cube.sbm", "sphere.sbm", "dragon.sbm", "torus.sbm"] for i in range(0, OBJECT_COUNT): objects[i].obj.load(object_names[i]) glEnable(GL_DEPTH_TEST) glGenVertexArrays(1, quad_vao) glBindVertexArray(quad_vao)
def __init__(self, width, height): global patch_vao global patch_buffer global cage_indices load_shaders() glGenVertexArrays(1, patch_vao) glBindVertexArray(patch_vao) glGenBuffers(1, patch_buffer) glBindBuffer(GL_ARRAY_BUFFER, patch_buffer) glBufferData(GL_ARRAY_BUFFER, ctypes.sizeof(ctypes.c_float)*3*16, None, GL_DYNAMIC_DRAW) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None) glEnableVertexAttribArray(0) indices = [ 0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 6, 7, 8, 9, 9, 10, 10, 11, 12, 13, 13, 14, 14, 15, 0, 4, 4, 8, 8, 12, 1, 5, 5, 9, 9, 13, 2, 6, 6, 10, 10, 14, 3, 7, 7, 11, 11, 15 ] ar = np.array(indices, dtype=np.uint16) glGenBuffers(1, cage_indices) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cage_indices) glBufferData(GL_ELEMENT_ARRAY_BUFFER, ctypes.sizeof(ctypes.c_ushort)*len(indices), ar, GL_STATIC_DRAW) overlay.init(80, 50) overlay.clear() overlay.drawText("W: Toggle wireframe", 0, 0) overlay.drawText("C: Toggle control cage", 0, 1) overlay.drawText("X: Toggle control points", 0, 2) overlay.drawText("P: Pause", 0, 3)
def __init__(self, width, height): global myobject global tex_envmap global skybox_vao envmaps[0] = ktxobject.ktx_load("mountaincube.ktx") tex_envmap = envmaps[envmap_index] glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS) myobject.load("dragon.sbm") load_shaders() glGenVertexArrays(1, skybox_vao) glBindVertexArray(skybox_vao) glDepthFunc(GL_LEQUAL)
def display(self): global m_iteration_index glUseProgram(m_update_program) glEnable(GL_RASTERIZER_DISCARD) for i in range(iterations_per_frame, 0, -1): glBindVertexArray(m_vao[m_iteration_index & 1]) glBindTexture(GL_TEXTURE_BUFFER, m_pos_tbo[m_iteration_index & 1]) m_iteration_index += 1 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_vbo[POSITION_A + (m_iteration_index & 1)]) glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1, m_vbo[VELOCITY_A + (m_iteration_index & 1)]) glBeginTransformFeedback(GL_POINTS) glDrawArrays(GL_POINTS, 0, POINTS_TOTAL) glEndTransformFeedback() glDisable(GL_RASTERIZER_DISCARD) black = [0.0, 0.0, 0.0, 0.0] glViewport(0, 0, self.width, self.height) glClearBufferfv(GL_COLOR, 0, black) glUseProgram(m_render_program) if (draw_points): glPointSize(4.0) glDrawArrays(GL_POINTS, 0, POINTS_TOTAL) if (draw_lines): glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_index_buffer) glDrawElements(GL_LINES, CONNECTIONS_TOTAL * 2, GL_UNSIGNED_INT, None) glutSwapBuffers()
def display(self): global render_prog global star_vao global uniforms currentTime = time.time() black = [ 0.0, 0.0, 0.0, 0.0 ] one = [ 1.0 ] t = currentTime proj_matrix = (GLfloat * 16)(*identityMatrix) proj_matrix = m3dPerspective(m3dDegToRad(50.0), float(self.width) / float(self.height), 0.1, 1000.0) t *= 0.1 t -= floor(t) glViewport(0, 0, self.width, self.height) glClearBufferfv(GL_COLOR, 0, black) glClearBufferfv(GL_DEPTH, 0, one) glUseProgram(render_prog) glUniform1f(uniforms.time, t) glUniformMatrix4fv(uniforms.proj_matrix, 1, GL_FALSE, proj_matrix) glEnable(GL_BLEND) glBlendFunc(GL_ONE, GL_ONE) glBindVertexArray(star_vao) glEnable(GL_PROGRAM_POINT_SIZE) glDrawArrays(GL_POINTS, 0, NUM_STARS) glutSwapBuffers()
def __init__(self, width, height): global ktxobject global dummy_vao global images self.width = width self.height = height #glGenTextures(3, images) images = [glGenTextures(1) for _ in range(3)] images[0] = ktxobject.ktx_load("salad-gray.ktx") for i in range(1, 3): glBindTexture(GL_TEXTURE_2D, images[i]) glTexStorage2D(GL_TEXTURE_2D, 1, GL_R32F, NUM_ELEMENTS, NUM_ELEMENTS) glGenVertexArrays(1, dummy_vao) glBindVertexArray(dummy_vao) load_shaders()
def draw_point_cloud(event): global vertex_indices, vertex_positions glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glPushMatrix() glMultMatrixf( np.array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], dtype='f')) vertex_indices.bind() vertex_positions.bind() glEnableVertexAttribArray(0) # from 'location = 0' in shader glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, None) glDrawElements(GL_POINTS, len(pointcloud), GL_UNSIGNED_INT, None) glBindVertexArray(0) vertex_positions.unbind() normal_indices.bind() normal_positions.bind() glEnableVertexAttribArray(0) glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, None) glDrawElements(GL_LINES, len(normals), GL_UNSIGNED_INT, None) glPopMatrix()
def __init__(self, width, height): global uniforms_buffer global fragment_buffer global atomic_counter_buffer global head_pointer_image global dummy_vao global myobject self.width = width self.height = height load_shaders() glGenBuffers(1, uniforms_buffer) glBindBuffer(GL_UNIFORM_BUFFER, uniforms_buffer) glBufferData(GL_UNIFORM_BUFFER, sizeof(GLfloat * 16 * 3), None, GL_DYNAMIC_DRAW) myobject.load("dragon.sbm") glGenBuffers(1, fragment_buffer) glBindBuffer(GL_SHADER_STORAGE_BUFFER, fragment_buffer) glBufferData(GL_SHADER_STORAGE_BUFFER, 1024 * 1024 * 16, None, GL_DYNAMIC_COPY) glGenBuffers(1, atomic_counter_buffer) glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomic_counter_buffer) glBufferData(GL_ATOMIC_COUNTER_BUFFER, 4, None, GL_DYNAMIC_COPY) head_pointer_image = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, head_pointer_image) glTexStorage2D(GL_TEXTURE_2D, 1, GL_R32UI, 1024, 1024) glGenVertexArrays(1, dummy_vao) glBindVertexArray(dummy_vao)
def __init__(self, width, height): global program global mv_location global mvp_location global stretch_location global vao global buffer vs_source = ''' // Vertex Shader // OpenGL SuperBible #version 410 core // Incoming per vertex... position and normal in vec4 vVertex; void main(void) { gl_Position = vVertex; } ''' gs_source = ''' // Geometry Shader // Graham Sellers // OpenGL SuperBible #version 410 core layout (triangles) in; layout (triangle_strip, max_vertices = 12) out; uniform float stretch = 0.7; flat out vec4 color; uniform mat4 mvpMatrix; uniform mat4 mvMatrix; void make_face(vec3 a, vec3 b, vec3 c) { vec3 face_normal = normalize(cross(c - a, c - b)); vec4 face_color = vec4(1.0, 0.4, 0.7, 1.0) * (mat3(mvMatrix) * face_normal).z; gl_Position = mvpMatrix * vec4(a, 1.0); color = face_color; EmitVertex(); gl_Position = mvpMatrix * vec4(b, 1.0); color = face_color; EmitVertex(); gl_Position = mvpMatrix * vec4(c, 1.0); color = face_color; EmitVertex(); EndPrimitive(); } void main(void) { int n; vec3 a = gl_in[0].gl_Position.xyz; vec3 b = gl_in[1].gl_Position.xyz; vec3 c = gl_in[2].gl_Position.xyz; vec3 d = (a + b) * stretch; vec3 e = (b + c) * stretch; vec3 f = (c + a) * stretch; a *= (2.0 - stretch); b *= (2.0 - stretch); c *= (2.0 - stretch); make_face(a, d, f); make_face(d, b, e); make_face(e, c, f); make_face(d, e, f); EndPrimitive(); } ''' fs_source = ''' // Fragment Shader // Graham Sellers // OpenGL SuperBible #version 410 core flat in vec4 color; out vec4 output_color; void main(void) { output_color = color; } ''' program = glCreateProgram() vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_source) glCompileShader(vs) gs = glCreateShader(GL_GEOMETRY_SHADER) glShaderSource(gs, gs_source) glCompileShader(gs) fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_source) glCompileShader(fs) glAttachShader(program, vs) glAttachShader(program, gs) glAttachShader(program, fs) glLinkProgram(program) mv_location = glGetUniformLocation(program, "mvMatrix") mvp_location = glGetUniformLocation(program, "mvpMatrix") stretch_location = glGetUniformLocation(program, "stretch") tetrahedron_verts = np.array([ 0.000, 0.000, 1.000, 0.943, 0.000, -0.333, -0.471, 0.816, -0.333, -0.471, -0.816, -0.333 ], dtype=np.float32) tetrahedron_indices = np.array([0, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 1], dtype=np.uint16) size_t_verts = ctypes.sizeof(ctypes.c_float) * len(tetrahedron_verts) size_t_indices = ctypes.sizeof( ctypes.c_ushort) * len(tetrahedron_indices) glGenVertexArrays(1, vao) glBindVertexArray(vao) glGenBuffers(1, buffer) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer) glBufferData(GL_ELEMENT_ARRAY_BUFFER, size_t_verts + size_t_indices, None, GL_STATIC_DRAW) glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, size_t_indices, tetrahedron_indices) glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, size_t_indices, size_t_verts, tetrahedron_verts) glBindBuffer(GL_ARRAY_BUFFER, buffer) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(size_t_indices)) glEnableVertexAttribArray(0) glEnable(GL_CULL_FACE) #// glDisable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) glDepthFunc(GL_LEQUAL)
def run(): pygame.init() screen = pygame.display.set_mode((800,600), pygame.OPENGL) #Create the Vertex Array Object vertexArrayObject = GLuint(0) glGenVertexArrays(1, vertexArrayObject) glBindVertexArray(vertexArrayObject) #Create the VBO vertices = np.array([[0,1,0],[-1,-1,0],[1,-1,0]], dtype='f') vertexPositions = vbo.VBO(vertices) #Create the index buffer object indices = np.array([0,1,2], dtype='uint16') indexPositions = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER) indexPositions.bind() vertexPositions.bind() glEnableVertexAttribArray(0) # from 'location = 0' in shader glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, None) glBindVertexArray(0) vertexPositions.unbind() indexPositions.unbind() #Now create the shaders VERTEX_SHADER = shaders.compileShader(""" #version 330 layout(location = 0) in vec4 position; void main() { gl_Position = position; } """, GL_VERTEX_SHADER) FRAGMENT_SHADER = shaders.compileShader(""" #version 330 out vec4 outputColor; void main() { outputColor = vec4(0.0f, 1.0f, 0.0f, 1.0f); } """, GL_FRAGMENT_SHADER) shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER) #The draw loop while True: glUseProgram(shader) glBindVertexArray(vertexArrayObject) #glDrawArrays(GL_TRIANGLES, 0, 3) #This line works glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0) #This line does not glBindVertexArray(0) glUseProgram(0) # Show the screen pygame.display.flip()
def __init__(self, width, height): global program global vao global position_buffer global index_buffer global mv_location global proj_location vs_source = ''' #version 410 core in vec4 position; out VS_OUT { vec4 color0; vec4 color1; } vs_out; uniform mat4 mv_matrix; uniform mat4 proj_matrix; void main(void) { gl_Position = proj_matrix * mv_matrix * position; vs_out.color0 = position * 2.0 + vec4(0.5, 0.5, 0.5, 0.0); vs_out.color1 = vec4(0.5, 0.5, 0.5, 0.0) - position * 2.0; } ''' fs_source = ''' #version 410 core layout (location = 0, index = 0) out vec4 color0; layout (location = 0, index = 1) out vec4 color1; in VS_OUT { vec4 color0; vec4 color1; } fs_in; void main(void) { color0 = vec4(fs_in.color0.xyz, 1.0); color1 = vec4(fs_in.color0.xyz, 1.0); } ''' program = glCreateProgram() fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_source) glCompileShader(fs) vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_source) glCompileShader(vs) glAttachShader(program, vs) glAttachShader(program, fs) glLinkProgram(program) mv_location = glGetUniformLocation(program, "mv_matrix") proj_location = glGetUniformLocation(program, "proj_matrix") glGenVertexArrays(1, vao) glBindVertexArray(vao) vertex_indices = np.array([ 0, 1, 2, 2, 1, 3, 2, 3, 4, 4, 3, 5, 4, 5, 6, 6, 5, 7, 6, 7, 0, 0, 7, 1, 6, 0, 2, 2, 4, 6, 7, 5, 3, 7, 3, 1 ], dtype=np.uint16) # GLushort vertex_positions = np.array([ -0.25, -0.25, -0.25, -0.25, 0.25, -0.25, 0.25, -0.25, -0.25, 0.25, 0.25, -0.25, 0.25, -0.25, 0.25, 0.25, 0.25, 0.25, -0.25, -0.25, 0.25, -0.25, 0.25, 0.25, ], dtype=np.float32) # GLfloat size_vertex_indices = ctypes.sizeof( ctypes.c_ushort) * len(vertex_indices) size_vertex_positions = ctypes.sizeof( ctypes.c_float) * len(vertex_positions) glGenBuffers(1, position_buffer) glBindBuffer(GL_ARRAY_BUFFER, position_buffer) glBufferData(GL_ARRAY_BUFFER, size_vertex_positions, vertex_positions, GL_STATIC_DRAW) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None) glEnableVertexAttribArray(0) glGenBuffers(1, index_buffer) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer) glBufferData(GL_ELEMENT_ARRAY_BUFFER, size_vertex_indices, vertex_indices, GL_STATIC_DRAW) glEnable(GL_CULL_FACE)
def reset(self): glUseProgram(0) glDisableVertexAttribArray(self.vertIndex) glBindVertexArray(0)
def __init__(self, width, height): global myobject global indirect_draw_buffer global draw_index_buffer i = 0 load_shaders() myobject.load("asteroids.sbm") sizeOfDrawIndCmd = ctypes.sizeof(GLuint * 4) glGenBuffers(1, indirect_draw_buffer) glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirect_draw_buffer) glBufferData(GL_DRAW_INDIRECT_BUFFER, NUM_DRAWS * sizeOfDrawIndCmd, None, GL_STATIC_DRAW) cmd_memory = glMapBufferRange( GL_DRAW_INDIRECT_BUFFER, 0, NUM_DRAWS * sizeOfDrawIndCmd, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT) cmd_buffer = ((GLuint * 4) * NUM_DRAWS).from_address(cmd_memory) for i in range(0, NUM_DRAWS): first, count = myobject.get_sub_object_info( i % myobject.get_sub_object_count()) cmd_buffer[i][0] = count cmd_buffer[i][1] = 1 cmd_buffer[i][2] = first cmd_buffer[i][3] = i glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) glBindVertexArray(myobject.get_vao()) glGenBuffers(1, draw_index_buffer) glBindBuffer(GL_ARRAY_BUFFER, draw_index_buffer) glBufferData(GL_ARRAY_BUFFER, NUM_DRAWS * ctypes.sizeof(GLuint), None, GL_STATIC_DRAW) draw_index = glMapBufferRange( GL_ARRAY_BUFFER, 0, NUM_DRAWS * ctypes.sizeof(GLuint), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT) int_array = (GLuint * NUM_DRAWS).from_address(draw_index) for i in range(0, NUM_DRAWS): int_array[i] = i glUnmapBuffer(GL_ARRAY_BUFFER) glVertexAttribIPointer(10, 1, GL_UNSIGNED_INT, 0, None) glVertexAttribDivisor(10, 1) glEnableVertexAttribArray(10) glEnable(GL_DEPTH_TEST) glDepthFunc(GL_LEQUAL) glEnable(GL_CULL_FACE)
def run(): #Start OpenGL and ask it for an OpenGL context pygame.init() clock = pygame.time.Clock() screen = pygame.display.set_mode(SCREEN_SIZE, pygame.HWSURFACE|pygame.OPENGL|pygame.DOUBLEBUF) #The first thing we do is print some OpenGL details and check that we have a good enough version print("OpenGL Implementation Details:") if glGetString(GL_VENDOR): print("\tGL_VENDOR: {}".format(glGetString(GL_VENDOR).decode())) if glGetString(GL_RENDERER): print("\tGL_RENDERER: {}".format(glGetString(GL_RENDERER).decode())) if glGetString(GL_VERSION): print("\tGL_VERSION: {}".format(glGetString(GL_VERSION).decode())) if glGetString(GL_SHADING_LANGUAGE_VERSION): print("\tGL_SHADING_LANGUAGE_VERSION: {}".format(glGetString(GL_SHADING_LANGUAGE_VERSION).decode())) major_version = int(glGetString(GL_VERSION).decode().split()[0].split('.')[0]) minor_version = int(glGetString(GL_VERSION).decode().split()[0].split('.')[1]) if major_version < 3 or (major_version < 3 and minor_version < 0): print("OpenGL version must be at least 3.0 (found {0})".format(glGetString(GL_VERSION).decode().split()[0])) #Now onto the OpenGL initialisation #Set up depth culling glEnable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) glDepthMask(GL_TRUE) glDepthFunc(GL_LEQUAL) glDepthRange(0.0, 1.0) #We create out shaders which do little more than set a flat colour for each face VERTEX_SHADER = shaders.compileShader(b""" #version 130 in vec4 position; in vec4 normal; uniform mat4 projectionMatrix; uniform mat4 viewMatrix; uniform mat4 modelMatrix; flat out float theColor; void main() { vec4 temp = modelMatrix * position; temp = viewMatrix * temp; gl_Position = projectionMatrix * temp; theColor = clamp(abs(dot(normalize(normal.xyz), normalize(vec3(0.9,0.1,0.5)))), 0, 1); } """, GL_VERTEX_SHADER) FRAGMENT_SHADER = shaders.compileShader(b""" #version 130 flat in float theColor; out vec4 outputColor; void main() { outputColor = vec4(1.0, 0.5, theColor, 1.0); } """, GL_FRAGMENT_SHADER) shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER) #And then grab our attribute locations from it glBindAttribLocation(shader, 0, b"position") glBindAttribLocation(shader, 1, b"normal") #Create the Vertex Array Object to hold our volume mesh vertexArrayObject = GLuint(0) glGenVertexArrays(1, vertexArrayObject) glBindVertexArray(vertexArrayObject) #Create the index buffer object indexPositions = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER, usage=GL_STATIC_DRAW) #Create the VBO vertexPositions = vbo.VBO(vertices, usage=GL_STATIC_DRAW) #Bind our VBOs and set up our data layout specifications with indexPositions, vertexPositions: glEnableVertexAttribArray(0) glVertexAttribPointer(0, 3, GL_FLOAT, False, 6*vertices.dtype.itemsize, vertexPositions+(0*vertices.dtype.itemsize)) glEnableVertexAttribArray(1) glVertexAttribPointer(1, 3, GL_FLOAT, False, 6*vertices.dtype.itemsize, vertexPositions+(3*vertices.dtype.itemsize)) glBindVertexArray(0) glDisableVertexAttribArray(0) #Now grab out transformation martix locations modelMatrixUnif = glGetUniformLocation(shader, b"modelMatrix") viewMatrixUnif = glGetUniformLocation(shader, b"viewMatrix") projectionMatrixUnif = glGetUniformLocation(shader, b"projectionMatrix") modelMatrix = np.array([[1.0,0.0,0.0,-32.0],[0.0,1.0,0.0,-32.0],[0.0,0.0,1.0,-32.0],[0.0,0.0,0.0,1.0]], dtype='f') viewMatrix = np.array([[1.0,0.0,0.0,0.0],[0.0,1.0,0.0,0.0],[0.0,0.0,1.0,-50.0],[0.0,0.0,0.0,1.0]], dtype='f') projectionMatrix = np.array([[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], dtype='f') #These next few lines just set up our camera frustum fovDeg = 45.0 frustumScale = 1.0 / tan(radians(fovDeg) / 2.0) zNear = 1.0 zFar = 1000.0 projectionMatrix[0][0] = frustumScale projectionMatrix[1][1] = frustumScale projectionMatrix[2][2] = (zFar + zNear) / (zNear - zFar) projectionMatrix[2][3] = -1.0 projectionMatrix[3][2] = (2 * zFar * zNear) / (zNear - zFar) #viewMatrix and projectionMatrix don't change ever so just set them once here with shader: glUniformMatrix4fv(projectionMatrixUnif, 1, GL_TRUE, projectionMatrix) glUniformMatrix4fv(viewMatrixUnif, 1, GL_TRUE, viewMatrix) #These are used to track the rotation of the volume LastFrameMousePos = (0,0) CurrentMousePos = (0,0) xRotation = 0 yRotation = 0 while True: clock.tick() for event in pygame.event.get(): if event.type == pygame.QUIT: return if event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE: return if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: CurrentMousePos = event.pos LastFrameMousePos = CurrentMousePos if event.type == pygame.MOUSEMOTION and 1 in event.buttons: CurrentMousePos = event.pos diff = (CurrentMousePos[0] - LastFrameMousePos[0], CurrentMousePos[1] - LastFrameMousePos[1]) xRotation += event.rel[0] yRotation += event.rel[1] LastFrameMousePos = CurrentMousePos glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) #Perform the rotation of the mesh moveToOrigin = np.array([[1.0,0.0,0.0,-32.0],[0.0,1.0,0.0,-32.0],[0.0,0.0,1.0,-32.0],[0.0,0.0,0.0,1.0]], dtype='f') rotateAroundX = np.array([[1.0,0.0,0.0,0.0],[0.0,cos(radians(yRotation)),-sin(radians(yRotation)),0.0],[0.0,sin(radians(yRotation)),cos(radians(yRotation)),0.0],[0.0,0.0,0.0,1.0]], dtype='f') rotateAroundY = np.array([[cos(radians(xRotation)),0.0,sin(radians(xRotation)),0.0],[0.0,1.0,0.0,0.0],[-sin(radians(xRotation)),0.0,cos(radians(xRotation)),0.0],[0.0,0.0,0.0,1.0]], dtype='f') modelMatrix = rotateAroundY.dot(rotateAroundX.dot(moveToOrigin)) with shader: glUniformMatrix4fv(modelMatrixUnif, 1, GL_TRUE, modelMatrix) glBindVertexArray(vertexArrayObject) glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None) glBindVertexArray(0) # Show the screen pygame.display.flip()