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 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 __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 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 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 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 __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 __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 __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, locations): self.locations = locations self.VBOs = [] self.vptr_args = [] # VAO index or 'name' in OpenGL self._index = GLuint(0) glGenVertexArrays(1, self._index) # Plan: Store the arguments for a glVertex call, # then, when a buffer is added, activate the VBO # and call glVertexAttribPointer with stored arguments. offset = 0 count = 0 stride = 0 for loc, attribs in self.locations.items(): if 'vec' in attribs.type: size = int(attribs.type[3]) elif 'mat' in attribs.type: size = int(attribs.type[3])**2 elif 'float' in attribs.type: size = 1 else: raise TypeError("Unsupported type for VAO: " + attribs.type) self.vptr_args.append([ loc, size, GL_FLOAT, GL_FALSE, 0, # mulitply by stride later ctypes.c_void_p(offset) ]) offset += size * sizeof(ctypes.c_float) stride += size for arg in self.vptr_args: arg[4] = stride * sizeof(ctypes.c_float)
def __init__(self, width, height): global render_prog global render_vao self.width = width self.height = height fs_source = ''' #version 410 core layout (location = 0) out vec4 color; flat in int shape; void main(void) { color = vec4(1.0); vec2 p = gl_PointCoord * 2.0 - vec2(1.0); if (shape == 0) { if (dot(p, p) > 1.0) discard; } else if (shape == 1) { if (dot(p, p) > sin(atan(p.y, p.x) * 5.0)) discard; } else if (shape == 2) { if (abs(0.8 - dot(p, p)) > 0.2) discard; } else if (shape == 3) { if (abs(p.x) < abs(p.y)) discard; } } ''' vs_source = ''' #version 410 core flat out int shape; void main(void) { const vec4[4] position = vec4[4](vec4(-0.4, -0.4, 0.5, 1.0), vec4( 0.4, -0.4, 0.5, 1.0), vec4(-0.4, 0.4, 0.5, 1.0), vec4( 0.4, 0.4, 0.5, 1.0)); gl_Position = position[gl_VertexID]; shape = gl_VertexID; } ''' vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_source) glCompileShader(vs) fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_source) glCompileShader(fs) render_prog = glCreateProgram() glAttachShader(render_prog, vs) glAttachShader(render_prog, fs) glLinkProgram(render_prog) glDeleteShader(vs) glDeleteShader(fs) glGenVertexArrays(1, render_vao) glBindVertexArray(render_vao)
def __init__(self, width, height): global render_prog global render_vao global uniform global tex_wall, tex_ceiling, tex_floor self.width = width self.height = height vs = GLuint(0) fs = GLuint(0) vs_source = ''' #version 420 core out VS_OUT { vec2 tc; } vs_out; uniform mat4 mvp; uniform float offset; void main(void) { const vec2[4] position = vec2[4](vec2(-0.5, -0.5), vec2( 0.5, -0.5), vec2(-0.5, 0.5), vec2( 0.5, 0.5)); vs_out.tc = (position[gl_VertexID].xy + vec2(offset, 0.5)) * vec2(30.0, 1.0); gl_Position = mvp * vec4(position[gl_VertexID], 0.0, 1.0); } ''' fs_source = ''' #version 420 core layout (location = 0) out vec4 color; in VS_OUT { vec2 tc; } fs_in; layout (binding = 0) uniform sampler2D tex; void main(void) { color = texture(tex, fs_in.tc); } ''' vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_source) glCompileShader(vs) glGetShaderInfoLog(vs) fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_source) glCompileShader(fs) glGetShaderInfoLog(vs) render_prog = glCreateProgram() glAttachShader(render_prog, vs) glAttachShader(render_prog, fs) glLinkProgram(render_prog) glDeleteShader(vs) glDeleteShader(fs) glGetProgramInfoLog(render_prog) uniform.mvp = glGetUniformLocation(render_prog, "mvp") uniform.offset = glGetUniformLocation(render_prog, "offset") glGenVertexArrays(1, render_vao) glBindVertexArray(render_vao) ktxobj = KTXObject() tex_wall = ktxobj.ktx_load("brick.ktx") tex_ceiling = ktxobj.ktx_load("ceiling.ktx") tex_floor = ktxobj.ktx_load("floor.ktx") textures = [tex_floor, tex_wall, tex_ceiling] for i in range(0, 3): glBindTexture(GL_TEXTURE_2D, textures[i]) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glBindVertexArray(render_vao)
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 overlay vs_source = ''' #version 420 core void main(void) { const vec4 vertices[] = vec4[](vec4( 0.4, -0.4, 0.5, 1.0), vec4(-0.4, -0.4, 0.5, 1.0), vec4( 0.4, 0.4, 0.5, 1.0), vec4(-0.4, 0.4, 0.5, 1.0)); gl_Position = vertices[gl_VertexID]; } ''' tcs_source_triangles = ''' #version 420 core layout (vertices = 3) out; void main(void) { if (gl_InvocationID == 0) { gl_TessLevelInner[0] = 5.0; gl_TessLevelOuter[0] = 8.0; gl_TessLevelOuter[1] = 8.0; gl_TessLevelOuter[2] = 8.0; } gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; } ''' tes_source_triangles = ''' #version 420 core layout (triangles) in; void main(void) { gl_Position = (gl_TessCoord.x * gl_in[0].gl_Position) + (gl_TessCoord.y * gl_in[1].gl_Position) + (gl_TessCoord.z * gl_in[2].gl_Position); } ''' tes_source_triangles_as_points = ''' #version 420 core layout (triangles, point_mode) in; void main(void) { gl_Position = (gl_TessCoord.x * gl_in[0].gl_Position) + (gl_TessCoord.y * gl_in[1].gl_Position) + (gl_TessCoord.z * gl_in[2].gl_Position); } ''' tcs_source_quads = ''' #version 420 core layout (vertices = 4) out; void main(void) { if (gl_InvocationID == 0) { gl_TessLevelInner[0] = 9.0; gl_TessLevelInner[1] = 7.0; gl_TessLevelOuter[0] = 3.0; gl_TessLevelOuter[1] = 5.0; gl_TessLevelOuter[2] = 3.0; gl_TessLevelOuter[3] = 5.0; } gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; } ''' tes_source_quads = ''' #version 420 core layout (quads) in; void main(void) { vec4 p1 = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x); vec4 p2 = mix(gl_in[2].gl_Position, gl_in[3].gl_Position, gl_TessCoord.x); gl_Position = mix(p1, p2, gl_TessCoord.y); } ''' tcs_source_isolines = ''' #version 420 core layout (vertices = 4) out; void main(void) { if (gl_InvocationID == 0) { gl_TessLevelOuter[0] = 5.0; gl_TessLevelOuter[1] = 5.0; } gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; } ''' tes_source_isolines = ''' #version 420 core layout (isolines) in; void main(void) { float r = (gl_TessCoord.y + gl_TessCoord.x / gl_TessLevelOuter[0]); float t = gl_TessCoord.x * 2.0 * 3.14159; gl_Position = vec4(sin(t) * r, cos(t) * r, 0.5, 1.0); } ''' fs_source = ''' #version 420 core out vec4 color; void main(void) { color = vec4(1.0); } ''' i = 0 vs_sources = [vs_source, vs_source, vs_source, vs_source] tcs_sources = [ tcs_source_quads, tcs_source_triangles, tcs_source_triangles, tcs_source_isolines ] tes_sources = [ tes_source_quads, tes_source_triangles, tes_source_triangles_as_points, tes_source_isolines ] fs_sources = [fs_source, fs_source, fs_source, fs_source] overlay.init(80, 50) for i in range(0, 4): program[i] = glCreateProgram() vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_sources[i]) glCompileShader(vs) tcs = glCreateShader(GL_TESS_CONTROL_SHADER) glShaderSource(tcs, tcs_sources[i]) glCompileShader(tcs) tes = glCreateShader(GL_TESS_EVALUATION_SHADER) glShaderSource(tes, tes_sources[i]) glCompileShader(tes) fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_sources[i]) glCompileShader(fs) glAttachShader(program[i], vs) glAttachShader(program[i], tcs) glAttachShader(program[i], tes) glAttachShader(program[i], fs) glLinkProgram(program[i]) glDeleteShader(vs) glDeleteShader(tcs) glDeleteShader(tes) glDeleteShader(fs) glGenVertexArrays(1, vao) glBindVertexArray(vao) glPatchParameteri(GL_PATCH_VERTICES, 4) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
def __init__(self, width, height): global grass_buffer global grass_vao global grass_program global tex_grass_color global tex_grass_length global tex_grass_orientation global tex_grass_bend global uniform self.width = width self.height = height grass_vs = GLuint(0) grass_fs = GLuint(0) grass_vs_source = ''' #version 420 core // Incoming per vertex position in vec4 vVertex; // Output varyings out vec4 color; uniform mat4 mvpMatrix; layout (binding = 0) uniform sampler1D grasspalette_texture; layout (binding = 1) uniform sampler2D length_texture; layout (binding = 2) uniform sampler2D orientation_texture; layout (binding = 3) uniform sampler2D grasscolor_texture; layout (binding = 4) uniform sampler2D bend_texture; int random(int seed, int iterations) { int value = seed; int n; for (n = 0; n < iterations; n++) { value = ((value >> 7) ^ (value << 9)) * 15485863; } return value; } vec4 random_vector(int seed) { int r = random(gl_InstanceID, 4); int g = random(r, 2); int b = random(g, 2); int a = random(b, 2); return vec4(float(r & 0x3FF) / 1024.0, float(g & 0x3FF) / 1024.0, float(b & 0x3FF) / 1024.0, float(a & 0x3FF) / 1024.0); } mat4 construct_rotation_matrix(float angle) { float st = sin(angle); float ct = cos(angle); return mat4(vec4(ct, 0.0, st, 0.0), vec4(0.0, 1.0, 0.0, 0.0), vec4(-st, 0.0, ct, 0.0), vec4(0.0, 0.0, 0.0, 1.0)); } void main(void) { vec4 offset = vec4(float(gl_InstanceID >> 10) - 512.0, 0.0f, float(gl_InstanceID & 0x3FF) - 512.0, 0.0f); int number1 = random(gl_InstanceID, 3); int number2 = random(number1, 2); offset += vec4(float(number1 & 0xFF) / 256.0, 0.0f, float(number2 & 0xFF) / 256.0, 0.0f); // float angle = float(random(number2, 2) & 0x3FF) / 1024.0; vec2 texcoord = offset.xz / 1024.0 + vec2(0.5); // float bend_factor = float(random(number2, 7) & 0x3FF) / 1024.0; float bend_factor = texture(bend_texture, texcoord).r * 2.0; float bend_amount = cos(vVertex.y); float angle = texture(orientation_texture, texcoord).r * 2.0 * 3.141592; mat4 rot = construct_rotation_matrix(angle); vec4 position = (rot * (vVertex + vec4(0.0, 0.0, bend_amount * bend_factor, 0.0))) + offset; position *= vec4(1.0, texture(length_texture, texcoord).r * 0.9 + 0.3, 1.0, 1.0); gl_Position = mvpMatrix * position; // (rot * position); // color = vec4(random_vector(gl_InstanceID).xyz * vec3(0.1, 0.5, 0.1) + vec3(0.1, 0.4, 0.1), 1.0); // color = texture(orientation_texture, texcoord); color = texture(grasspalette_texture, texture(grasscolor_texture, texcoord).r) + vec4(random_vector(gl_InstanceID).xyz * vec3(0.1, 0.5, 0.1), 1.0); } ''' grass_fs_source = ''' #version 420 core in vec4 color; out vec4 output_color; void main(void) { output_color = color; } ''' grass_blade = [ -0.3, 0.0, 0.3, 0.0, -0.20, 1.0, 0.1, 1.3, -0.05, 2.3, 0.0, 3.3 ] glGenBuffers(1, grass_buffer) glBindBuffer(GL_ARRAY_BUFFER, grass_buffer) ar = array("f", grass_blade) glBufferData(GL_ARRAY_BUFFER, ar.tostring(), GL_STATIC_DRAW) glGenVertexArrays(1, grass_vao) glBindVertexArray(grass_vao) glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, None) glEnableVertexAttribArray(0) grass_program = glCreateProgram() grass_vs = glCreateShader(GL_VERTEX_SHADER) grass_fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(grass_vs, grass_vs_source) glShaderSource(grass_fs, grass_fs_source) glCompileShader(grass_vs) glCompileShader(grass_fs) glAttachShader(grass_program, grass_vs) glAttachShader(grass_program, grass_fs) glLinkProgram(grass_program) glDeleteShader(grass_fs) glDeleteShader(grass_vs) uniform.mvpMatrix = glGetUniformLocation(grass_program, "mvpMatrix") ktx = KTXObject() glActiveTexture(GL_TEXTURE1) tex_grass_length = ktx.ktx_load("grass_length.ktx") glActiveTexture(GL_TEXTURE2) tex_grass_orientation = ktx.ktx_load("grass_orientation.ktx") glActiveTexture(GL_TEXTURE3) tex_grass_color = ktx.ktx_load("grass_color.ktx") glActiveTexture(GL_TEXTURE4) tex_grass_bend = ktx.ktx_load("grass_bend.ktx")
def __init__(self, width, height): global m_vao global m_vbo i = 0 j = 0 load_shaders() initial_positions = [glm.vec4() for _ in range(POINTS_TOTAL)] initial_velocities = [glm.vec3() for _ in range(POINTS_TOTAL)] connection_vectors = [glm.ivec3() for _ in range(POINTS_TOTAL)] n = 0 for j in range(0, POINTS_Y): fj = float(j) / float(POINTS_Y) for i in range(0, POINTS_X): fi = float(i) / float(POINTS_X) initial_positions[n] = glm.vec4((fi - 0.5) * float(POINTS_X), (fj - 0.5) * float(POINTS_Y), 0.6 * sin(fi) * cos(fj), 1.0) initial_velocities[n] = glm.vec3(0.0) connection_vectors[n] = glm.ivec4(-1) if (j != (POINTS_Y - 1)): if (i != 0): connection_vectors[n][0] = n - 1 if (j != 0): connection_vectors[n][1] = n - POINTS_X if (i != (POINTS_X - 1)): connection_vectors[n][2] = n + 1 if (j != (POINTS_Y - 1)): connection_vectors[n][3] = n + POINTS_X n += 1 for i in range(0, 2): glGenVertexArrays(1, m_vao[i]) for i in range(0, 5): glGenBuffers(i + 1, m_vbo[i]) for i in range(0, 2): glBindVertexArray(m_vao[i]) glBindBuffer(GL_ARRAY_BUFFER, m_vbo[POSITION_A + i]) # POSITION_A glBindBuffer(GL_ARRAY_BUFFER, m_vbo[POSITION_A + i]) ar_position = np.empty([POINTS_TOTAL, 4], dtype='float32') for j, e in enumerate(initial_positions): ar_position[j] = e glBufferData(GL_ARRAY_BUFFER, POINTS_TOTAL * glm.sizeof(glm.vec4()), ar_position, GL_DYNAMIC_COPY) glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, None) glEnableVertexAttribArray(0) # VELOCITY_A glBindBuffer(GL_ARRAY_BUFFER, m_vbo[VELOCITY_A + i]) ar_velocities = np.empty([POINTS_TOTAL, 3], dtype='float32') for j, e in enumerate(initial_velocities): ar_velocities[j] = e glBufferData(GL_ARRAY_BUFFER, POINTS_TOTAL * glm.sizeof(glm.vec3()), ar_velocities, GL_DYNAMIC_COPY) glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, None) glEnableVertexAttribArray(1) # CONNECTION glBindBuffer(GL_ARRAY_BUFFER, m_vbo[CONNECTION]) ar_connection = np.empty([POINTS_TOTAL, 4], dtype='uint32') for j, e in enumerate(connection_vectors): ar_connection[j] = e glBufferData(GL_ARRAY_BUFFER, POINTS_TOTAL * glm.sizeof(glm.ivec4()), ar_connection, GL_STATIC_DRAW) glVertexAttribIPointer(2, 4, GL_INT, 0, None) glEnableVertexAttribArray(2) glGenTextures(2, m_pos_tbo) glBindTexture(GL_TEXTURE_BUFFER, m_pos_tbo[0]) glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_vbo[POSITION_A]) glBindTexture(GL_TEXTURE_BUFFER, m_pos_tbo[1]) glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_vbo[POSITION_B]) lines = (POINTS_X - 1) * POINTS_Y + (POINTS_Y - 1) * POINTS_X glGenBuffers(1, m_index_buffer) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_index_buffer) glBufferData(GL_ELEMENT_ARRAY_BUFFER, lines * 2 * ctypes.sizeof(ctypes.c_int), None, GL_STATIC_DRAW) e = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, lines * 2 * ctypes.sizeof(ctypes.c_int), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT) int_array = (ctypes.c_int * (4 * lines * 2)).from_address(e) n = 0 for j in range(0, POINTS_Y): for i in range(0, POINTS_X - 1): int_array[n] = i + j * POINTS_X n += 1 int_array[n] = 1 + i + j * POINTS_X n += 1 for i in range(0, POINTS_X): for j in range(0, POINTS_Y - 1): int_array[n] = i + j * POINTS_X n += 1 int_array[n] = POINTS_X + i + j * POINTS_X n += 1 glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER)
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 __init__(self, width, height): global render_prog global star_vao global star_buffer global uniforms global star_texture self.width = width self.height = height vs = GLuint(0) fs = GLuint(0) fs_source = ''' #version 410 core layout (location = 0) out vec4 color; uniform sampler2D tex_star; flat in vec4 starColor; void main(void) { color = starColor * texture(tex_star, gl_PointCoord); //color.r = 1.0; } ''' vs_source = ''' #version 410 core layout (location = 0) in vec4 position; layout (location = 1) in vec4 color; uniform float time; uniform mat4 proj_matrix; flat out vec4 starColor; void main(void) { vec4 newVertex = position; newVertex.z += time; newVertex.z = fract(newVertex.z); float size = (20.0 * newVertex.z * newVertex.z); starColor = smoothstep(1.0, 7.0, size) * color; newVertex.z = (999.9 * newVertex.z) - 1000.0; gl_Position = proj_matrix * newVertex; gl_PointSize = size; } ''' vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_source) glCompileShader(vs) if not glGetShaderiv(vs, GL_COMPILE_STATUS): print( 'compile error:' ) print( glGetShaderInfoLog(vs) ) fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_source) glCompileShader(fs) if not glGetShaderiv(fs, GL_COMPILE_STATUS): print( 'compile error:' ) print( glGetShaderInfoLog(fs) ) render_prog = glCreateProgram() glAttachShader(render_prog, vs) glAttachShader(render_prog, fs) glLinkProgram(render_prog) if not glGetProgramiv(render_prog, GL_LINK_STATUS): print( 'link error:' ) print( glGetProgramInfoLog(render_prog) ) glDeleteShader(vs) glDeleteShader(fs) uniforms.time = glGetUniformLocation(render_prog, "time") uniforms.proj_matrix = glGetUniformLocation(render_prog, "proj_matrix") star_texture = ktxobject.ktx_load("star.ktx") glGenVertexArrays(1, star_vao) glBindVertexArray(star_vao) class star_t: position = glm.vec3 color = glm.vec3 size_star_t = ctypes.sizeof(ctypes.c_float) * 6; # same as glm.sizeof(glm.vec3) * 2 glGenBuffers(1, star_buffer) glBindBuffer(GL_ARRAY_BUFFER, star_buffer) glBufferData(GL_ARRAY_BUFFER, NUM_STARS * size_star_t, None, GL_STATIC_DRAW) star = glMapBufferRange(GL_ARRAY_BUFFER, 0, NUM_STARS * size_star_t, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT) m = (GLfloat * 6 * NUM_STARS).from_address(star) for i in range(0, 1000): m[i][0] = (random_float() * 2.0 - 1.0) * 100.0 m[i][1] = (random_float() * 2.0 - 1.0) * 100.0 m[i][2] = random_float() m[i][3] = 0.8 + random_float() * 0.2 m[i][4] = 0.8 + random_float() * 0.2 m[i][5] = 0.8 + random_float() * 0.2 glUnmapBuffer(GL_ARRAY_BUFFER) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, size_star_t, None) glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, size_star_t, ctypes.c_void_p(glm.sizeof(glm.vec3) ) ) glEnableVertexAttribArray(0) glEnableVertexAttribArray(1)
def __init__(self, width, height): global program global vao global position_buffer global index_buffer global uniform_buffer vs_source = ''' #version 420 core in vec4 position; out VS_OUT { vec4 color; } vs_out; void main(void) { gl_Position = position; vs_out.color = position * 2.0 + vec4(0.5, 0.5, 0.5, 0.0); } ''' gs_source = ''' #version 420 core layout (triangles, invocations = 4) in; layout (triangle_strip, max_vertices = 3) out; layout (std140, binding = 0) uniform transform_block { mat4 mvp_matrix[4]; }; in VS_OUT { vec4 color; } gs_in[]; out GS_OUT { vec4 color; } gs_out; void main(void) { for (int i = 0; i < gl_in.length(); i++) { gs_out.color = gs_in[i].color; gl_Position = mvp_matrix[gl_InvocationID] * gl_in[i].gl_Position; gl_ViewportIndex = gl_InvocationID; EmitVertex(); } EndPrimitive(); } ''' fs_source = ''' #version 420 core out vec4 color; in GS_OUT { vec4 color; } fs_in; void main(void) { color = fs_in.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) 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) glGenBuffers(1, uniform_buffer) glBindBuffer(GL_UNIFORM_BUFFER, uniform_buffer) glBufferData(GL_UNIFORM_BUFFER, 4 * glm.sizeof(glm.mat4()), None, GL_DYNAMIC_DRAW) glEnable(GL_CULL_FACE) #// glFrontFace(GL_CW) glEnable(GL_DEPTH_TEST) glDepthFunc(GL_LEQUAL)
def __init__(self, width, height): global myobject global vao global render_fbo global tex_scene global tex_brightpass global tex_depth global filter_fbo global tex_filter global tex_lut global ubo_transform global ubo_material self.width = width self.height = height buffers = [GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1] 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 ] glGenFramebuffers(1, render_fbo) glBindFramebuffer(GL_FRAMEBUFFER, render_fbo) tex_scene = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, tex_scene) glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16F, MAX_SCENE_WIDTH, MAX_SCENE_HEIGHT) glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex_scene, 0) tex_brightpass = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, tex_brightpass) glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16F, MAX_SCENE_WIDTH, MAX_SCENE_HEIGHT) glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, tex_brightpass, 0) tex_depth = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, tex_depth) glTexStorage2D(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT32F, MAX_SCENE_WIDTH, MAX_SCENE_HEIGHT) glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, tex_depth, 0) glDrawBuffers(2, buffers) #glGenFramebuffers(2, filter_fbo[0]) filter_fbo = [glGenFramebuffers(1) for _ in range(2)] #glGenTextures(2, tex_filter[0]) tex_filter = [glGenTextures(1) for _ in range(2)] for i in range(0, 2): glBindFramebuffer(GL_FRAMEBUFFER, filter_fbo[i]) glBindTexture(GL_TEXTURE_2D, tex_filter[i]) glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16F, MAX_SCENE_WIDTH if i == 0 else MAX_SCENE_HEIGHT, MAX_SCENE_HEIGHT if i == 0 else MAX_SCENE_WIDTH) glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex_filter[i], 0) glDrawBuffers(1, buffers) glBindFramebuffer(GL_FRAMEBUFFER, 0) 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) myobject.load("torus.sbm") glGenBuffers(1, ubo_transform) glBindBuffer(GL_UNIFORM_BUFFER, ubo_transform) glBufferData(GL_UNIFORM_BUFFER, (2 + SPHERE_COUNT) * glm.sizeof(glm.mat4), None, GL_DYNAMIC_DRAW) class material: diffuse_color = glm.vec3 specular_color = glm.vec3 specular_power = GLfloat(0) ambient_color = glm.vec3 glGenBuffers(1, ubo_material) glBindBuffer(GL_UNIFORM_BUFFER, ubo_material) size_material = ctypes.sizeof(ctypes.c_float) * 12 glBufferData(GL_UNIFORM_BUFFER, SPHERE_COUNT * size_material, None, GL_STATIC_DRAW) mat = glMapBufferRange(GL_UNIFORM_BUFFER, 0, SPHERE_COUNT * size_material, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT) m = (GLfloat * 12 * SPHERE_COUNT).from_address(mat) ambient = 0.002 for i in range(SPHERE_COUNT): fi = 3.14159267 * i / 8.0 m[i][0:3] = (ctypes.c_float * 3)(sin(fi) * 0.5 + 0.5, sin(fi + 1.345) * 0.5 + 0.5, sin(fi + 2.567) * 0.5 + 0.5) m[i][4:7] = (ctypes.c_float * 3)(2.8, 2.8, 2.9) m[i][7] = 30 m[i][8:11] = (ctypes.c_float * 3)(ambient * 0.025, ambient * 0.025, ambient * 0.025) ambient *= 1.5 glUnmapBuffer(GL_UNIFORM_BUFFER)
def compile_program(vertex_source, fragment_source): global mv_location global proj_location vertex_shader = None fragment_shader = None if vertex_source: vertex_shader = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vertex_shader, vertex_source) glCompileShader(vertex_shader) if not glGetShaderiv(vertex_shader, GL_COMPILE_STATUS): raise Exception( 'failed to compile shader "%s":\n%s' % ('vertex_shader', glGetShaderInfoLog(vertex_shader))) if fragment_source: fragment_shader = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fragment_shader, fragment_source) glCompileShader(fragment_shader) if not glGetShaderiv(fragment_shader, GL_COMPILE_STATUS): raise Exception( 'failed to compile shader "%s":\n%s' % ('fragment_shader', glGetShaderInfoLog(fragment_shader))) program = glCreateProgram() glAttachShader(program, vertex_shader) glAttachShader(program, fragment_shader) glLinkProgram(program) mv_location = glGetUniformLocation(program, "mv_matrix") proj_location = glGetUniformLocation(program, "proj_matrix") vao = GLuint(0) glGenVertexArrays(1, vao) glBindVertexArray(vao) vertex_positions = [ -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, 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, -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, -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, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, -0.25, 0.25, 0.25, -0.25, 0.25, -0.25 ] buffer = GLuint(0) glGenBuffers(1, buffer) glBindBuffer(GL_ARRAY_BUFFER, buffer) #ar=numpy.array(vertex_positions, dtype='float32') ar = array("f", vertex_positions) glBufferData(GL_ARRAY_BUFFER, ar.tostring(), GL_STATIC_DRAW) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None) glEnableVertexAttribArray(0) glEnable(GL_CULL_FACE) glFrontFace(GL_CW) glEnable(GL_DEPTH_TEST) glDepthFunc(GL_LEQUAL) return program
def __init__(self, width, height): global quad_vao global temp_tex global color_tex global depth_tex global depth_fbo global objects self.width = width self.height = height load_shaders() object_names = [ "dragon.sbm", "sphere.sbm", "cube.sbm", "cube.sbm", "cube.sbm" ] object_colors = [ [1.0, 0.7, 0.8, 1.0], [0.7, 0.8, 1.0, 1.0], [0.3, 0.9, 0.4, 1.0], [0.6, 0.4, 0.9, 1.0], [0.8, 0.2, 0.1, 1.0], ] for i in range(0, OBJECT_COUNT): objects[i].obj.load(object_names[i]) objects[i].diffuse_albedo = object_colors[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, FBO_SIZE, FBO_SIZE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) color_tex = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, color_tex) glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, FBO_SIZE, FBO_SIZE) temp_tex = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, temp_tex) glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, FBO_SIZE, FBO_SIZE) glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_tex, 0) glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, color_tex, 0) glBindTexture(GL_TEXTURE_2D, 0) glBindFramebuffer(GL_FRAMEBUFFER, 0) glEnable(GL_DEPTH_TEST) glGenVertexArrays(1, quad_vao) glBindVertexArray(quad_vao) overlay.init(80, 50) overlay.clear() overlay.drawText("Q: Increase focal distance", 0, 0) overlay.drawText("A: Decrease focal distance", 0, 1) overlay.drawText("W: Increase focal depth", 0, 2) overlay.drawText("S: Decrease focal depth", 0, 3) overlay.drawText("P: Pause", 0, 4)
def __init__(self, width, height): global render_prog global render_vao global tex_alien_array global rain_buffer global droplet_x_offset, droplet_rot_speed, droplet_fall_speed self.width = width self.height = height vs = GLuint(0) fs = GLuint(0) vs_source = ''' #version 410 core layout (location = 0) in int alien_index; out VS_OUT { flat int alien; vec2 tc; } vs_out; struct droplet_t { float x_offset; float y_offset; float orientation; float unused; }; layout (std140) uniform droplets { droplet_t droplet[256]; }; void main(void) { const vec2[4] position = vec2[4](vec2(-0.5, -0.5), vec2( 0.5, -0.5), vec2(-0.5, 0.5), vec2( 0.5, 0.5)); vs_out.tc = position[gl_VertexID].xy + vec2(0.5); float co = cos(droplet[alien_index].orientation); float so = sin(droplet[alien_index].orientation); mat2 rot = mat2(vec2(co, so), vec2(-so, co)); vec2 pos = 0.25 * rot * position[gl_VertexID]; gl_Position = vec4(pos.x + droplet[alien_index].x_offset, pos.y + droplet[alien_index].y_offset, 0.5, 1.0); vs_out.alien = alien_index % 64; } ''' fs_source = ''' #version 410 core layout (location = 0) out vec4 color; in VS_OUT { flat int alien; vec2 tc; } fs_in; uniform sampler2DArray tex_aliens; void main(void) { color = texture(tex_aliens, vec3(fs_in.tc, float(fs_in.alien))); } ''' vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_source) glCompileShader(vs) glGetShaderInfoLog(vs) fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_source) glCompileShader(fs) glGetShaderInfoLog(vs) render_prog = glCreateProgram() glAttachShader(render_prog, vs) glAttachShader(render_prog, fs) glLinkProgram(render_prog) glDeleteShader(vs) glDeleteShader(fs) glGetProgramInfoLog(render_prog) glGenVertexArrays(1, render_vao) glBindVertexArray(render_vao) ktxobj = KTXObject() tex_alien_array = ktxobj.ktx_load("aliens.ktx") glBindTexture(GL_TEXTURE_2D_ARRAY, tex_alien_array) glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR) glGenBuffers(1, rain_buffer) glBindBuffer(GL_UNIFORM_BUFFER, rain_buffer) glBufferData(GL_UNIFORM_BUFFER, 256 * 4 * 4, None, GL_DYNAMIC_DRAW) for i in range(0, 256): droplet_x_offset.append(random_float() * 2.0 - 1.0) droplet_rot_speed.append( (random_float() + 0.5) * (-3.0 if (i & 1) else 3.0)) droplet_fall_speed.append(random_float() + 0.2) glBindVertexArray(render_vao) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def init(self, width, height, font=''): vs = GLuint(0) fs = GLuint(0) self.buffer_width = width self.buffer_height = height vs = glCreateShader(GL_VERTEX_SHADER) fs = glCreateShader(GL_FRAGMENT_SHADER) vs_source = ''' #version 440 core void main(void) { gl_Position = vec4(float((gl_VertexID >> 1) & 1) * 2.0 - 1.0, float((gl_VertexID & 1)) * 2.0 - 1.0, 0.0, 1.0); } ''' fs_source = ''' #version 440 core layout (origin_upper_left) in vec4 gl_FragCoord; layout (location = 0) out vec4 o_color; layout (binding = 0) uniform isampler2D text_buffer; layout (binding = 1) uniform isampler2DArray font_texture; void main(void) { ivec2 frag_coord = ivec2(gl_FragCoord.xy); ivec2 char_size = textureSize(font_texture, 0).xy; ivec2 char_location = frag_coord / char_size; ivec2 texel_coord = frag_coord % char_size; int character = texelFetch(text_buffer, char_location, 0).x; float val = texelFetch(font_texture, ivec3(texel_coord, character), 0).x; if (val == 0.0) discard; o_color = vec4(1.0); } ''' glShaderSource(vs, vs_source) glCompileShader(vs) glShaderSource(fs, fs_source) glCompileShader(fs) self.text_program = glCreateProgram() glAttachShader(self.text_program, vs) glAttachShader(self.text_program, fs) glLinkProgram(self.text_program) glDeleteShader(fs) glDeleteShader(vs) # glCreateVertexArrays(1, &vao); glGenVertexArrays(1, self.vao) glBindVertexArray(self.vao) # glCreateTextures(GL_TEXTURE_2D, 1, &text_buffer); self.text_buffer = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, self.text_buffer) glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8UI, width, height) if (font == ''): font = "cp437_9x16.ktx" self.font_texture = ktxobject.ktx_load(font) self.screen_buffer = ['\0' for _ in range(width * height)]
def __init__(self, width, height): global gbuffer_tex global gbuffer global fs_quad_vao global light_ubo global render_transform_ubo global myobject global tex_nm global tex_diffuse glGenFramebuffers(1, gbuffer) glBindFramebuffer(GL_FRAMEBUFFER, gbuffer) gbuffer_tex = [glGenTextures(1) for _ in range(3)] glBindTexture(GL_TEXTURE_2D, gbuffer_tex[0]) glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32UI, MAX_DISPLAY_WIDTH, MAX_DISPLAY_HEIGHT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) glBindTexture(GL_TEXTURE_2D, gbuffer_tex[1]) glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, MAX_DISPLAY_WIDTH, MAX_DISPLAY_HEIGHT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) glBindTexture(GL_TEXTURE_2D, gbuffer_tex[2]) glTexStorage2D(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT32F, MAX_DISPLAY_WIDTH, MAX_DISPLAY_HEIGHT) glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, gbuffer_tex[0], 0) glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, gbuffer_tex[1], 0) glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, gbuffer_tex[2], 0) glBindFramebuffer(GL_FRAMEBUFFER, 0) glGenVertexArrays(1, fs_quad_vao) glBindVertexArray(fs_quad_vao) myobject.load("ladybug.sbm") tex_nm = ktxobject.ktx_load("ladybug_nm.ktx") tex_diffuse = ktxobject.ktx_load("ladybug_co.ktx") load_shaders() light_ubo = glGenBuffers(1) glBindBuffer(GL_UNIFORM_BUFFER, light_ubo) size_light_t = ctypes.sizeof(ctypes.c_float) * 6 glBufferData(GL_UNIFORM_BUFFER, NUM_LIGHTS * size_light_t, None, GL_DYNAMIC_DRAW) render_transform_ubo = glGenBuffers(1) glBindBuffer(GL_UNIFORM_BUFFER, render_transform_ubo) glBufferData(GL_UNIFORM_BUFFER, (2 + NUM_INSTANCES) * glm.sizeof(glm.mat4), None, GL_DYNAMIC_DRAW)
def __init__(self, width, height): global program global vao global tex_checker global uniforms vs_source = ''' #version 410 core out VS_OUT { vec2 tc; noperspective vec2 tc_np; } vs_out; uniform mat4 mvp; void main(void) { const vec4 vertices[] = vec4[](vec4(-0.5, -0.5, 0.0, 1.0), vec4( 0.5, -0.5, 0.0, 1.0), vec4(-0.5, 0.5, 0.0, 1.0), vec4( 0.5, 0.5, 0.0, 1.0)); vec2 tc = (vertices[gl_VertexID].xy + vec2(0.5)); vs_out.tc = tc; vs_out.tc_np = tc; gl_Position = mvp * vertices[gl_VertexID]; } ''' fs_source = ''' #version 410 core out vec4 color; uniform sampler2D tex_checker; uniform bool use_perspective = true; in VS_OUT { vec2 tc; noperspective vec2 tc_np; } fs_in; void main(void) { vec2 tc = mix(fs_in.tc_np, fs_in.tc, bvec2(use_perspective)); color = texture(tex_checker, tc).rrrr; } ''' buffer = '' program = glCreateProgram() vs = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vs, vs_source) glCompileShader(vs) glGetShaderInfoLog(vs) fs = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fs, fs_source) glCompileShader(fs) glGetShaderInfoLog(fs) glAttachShader(program, vs) glAttachShader(program, fs) glLinkProgram(program) uniforms.mvp = glGetUniformLocation(program, "mvp") uniforms.use_perspective = glGetUniformLocation( program, "use_perspective") glGenVertexArrays(1, vao) glBindVertexArray(vao) checker_data = np.array([ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, ], dtype=np.ubyte) # unsigned char tex_checker = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, tex_checker) glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8, 8, 8) glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 8, 8, GL_RED, GL_UNSIGNED_BYTE, checker_data) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
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(): #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()