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()