def runningSession(self):
try:
GL_shaders.glUseProgram(self.shader)
self.myTexture2D.bind(0) # Passed an id which is also passed to shader via uniforms
self.whatevs.bind(1)
self.myModel.bind()
GL.glUniformMatrix4fv(
self.UNIFORMS['my_ModelMatrix'],1, GL.GL_TRUE,
self.ModelMatrix.get())
GL.glUniformMatrix4fv(
self.UNIFORMS['my_ViewMatrix'],1, GL.GL_TRUE,
self.ViewMatrix.get())
GL.glUniformMatrix4fv(
self.UNIFORMS['my_ProjectionMatrix'],1, GL.GL_TRUE,
self.ProjectionMatrix.get())
GL.glUniform1i(self.UNIFORMS['tex0'], 0) # same id as passed to texture2D.bind()
GL.glUniform1i(self.UNIFORMS['tex1'], 1)
finally:
self.myModel.unbind()
self.whatevs.unbind()
self.myTexture2D.unbind()
GL_shaders.glUseProgram(0)
def drawScene(self):
#This is where we change graphics. Things in here won't actually be applied right away
#to the canvas. So when this function is done, drawing will be applied right after.
vbo = GLvbo.VBO(self.myTriangle)
#The vertex-buffer-object has to stay in here since
#it cannot be "selfed" or we get errors
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GLshaders.glUseProgram(self.GLEngineShader)
try:
vbo.bind()
try:
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
GL.glEnableClientState(GL.GL_COLOR_ARRAY)
#GL.glVertexPointerf(vbo)
GL.glVertexPointer(3, GL.GL_FLOAT, 24, vbo)
GL.glColorPointer(3, GL.GL_FLOAT, 24, vbo+12)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 9)
finally:
vbo.unbind()
GL.glDisableClientState(GL.GL_VERTEX_ARRAY)
GL.glDisableClientState(GL.GL_COLOR_ARRAY)
finally:
GLshaders.glUseProgram(0)
def DrawBlock(self):
global _lightVector
shaders.glUseProgram(self.shader)
invT = np.linalg.inv(glGetDouble(GL_MODELVIEW_MATRIX)).transpose()
glUniformMatrix4fv(self.uniformInvT, 1, False, invT)
try:
self.vbo.bind()
try:
glEnableVertexAttribArray(self.position)
glEnableVertexAttribArray(self.color)
glEnableVertexAttribArray(self.vertex_normal)
stride = 44
glVertexAttribPointer(self.position, 3, GL_FLOAT, False,
stride, self.vbo)
glVertexAttribPointer(self.color, 3, GL_FLOAT, False, stride,
self.vbo + 12)
glVertexAttribPointer(self.vertex_normal, 3, GL_FLOAT, True,
stride, self.vbo + 24)
glDrawArrays(GL_QUADS, 0, 24)
finally:
self.vbo.unbind()
glDisableVertexAttribArray(self.position)
glDisableVertexAttribArray(self.color)
glDisableVertexAttribArray(self.vertex_normal)
finally:
shaders.glUseProgram(0)
def __init__(self, screen):
self.rot_x = 0
self.rot_y = 0
self.lines = False
self.pause = False
# glEnable(GL_LIGHTING)
# glEnable(GL_LIGHT0)
vs_source = open('shaders/' + vert_name, "r")
vs_source = vs_source.read()
VERTEX_SHADER = shaders.compileShader(vs_source, GL_VERTEX_SHADER)
fs_source = open('shaders/' + frag_name, "r")
fs_source = fs_source.read()
FRAGMENT_SHADER = shaders.compileShader(fs_source, GL_FRAGMENT_SHADER)
self.shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER)
# glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)
shaders.glUseProgram(self.shader)
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LEQUAL)
light_position = [0.0, -1.0, 1.0, 1.0]
glLightfv(GL_LIGHT0, GL_POSITION, light_position)
glShadeModel(GL_SMOOTH)
self.screen = screen
self.aspect = screen.get_width() / screen.get_height()
gluPerspective(45.0, self.aspect, 0.1, 200.0)
glClearColor(0.0, 0.0, 0.0, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
return
def paintGL_UnProjector(self):
if not self.shader_UnProjector: self.__init__UnProjector()
glUseProgram(self.shader_UnProjector)
v= glGetFloatv(GL_VIEWPORT)
glUniform2f(self.res, v[2],v[3])
c1,c2=self.centroids
glUniform3f(self.c1, *c1)
glUniform3f(self.c2, *c2)
v= glGetIntegerv( GL_VIEWPORT )
m= glGetDoublev( GL_MODELVIEW_MATRIX )
p= glGetDoublev( GL_PROJECTION_MATRIX )
w,h=v[2:] ; kwa={'modelMatrix':m, 'projMatrix':p, 'viewport':v}
#nearz,farz=0,-1
nearz,farz=-1,0 # because 0,1 dont work. So far will be origin plane
glUniform3f(self.near11, *UnProject(0,0,nearz, **kwa))
glUniform3f(self.near12, *UnProject(0,h,nearz, **kwa))
glUniform3f(self.near21, *UnProject(w,0,nearz, **kwa))
glUniform3f(self.near22, *UnProject(w,h,nearz, **kwa))
glUniform3f(self.far11, *UnProject(0,0,farz, **kwa))
glUniform3f(self.far12, *UnProject(0,h,farz, **kwa))
glUniform3f(self.far21, *UnProject(w,0,farz, **kwa))
glUniform3f(self.far22, *UnProject(w,h,farz, **kwa))
#glRectf(-.75,-.75,.75,.75)
glRectf(-1,-1,1,1)
def _render_in_mode(self, mvp, points_vbo, colors_vbo, count, mode):
shaders.glUseProgram(self._program)
GL.glUniformMatrix4fv(GL.glGetUniformLocation(self._program, 'mvp'), 1,
True, mvp)
points_vbo.bind()
arg_position = GL.glGetAttribLocation(self._program, 'position')
GL.glEnableVertexAttribArray(arg_position)
GL.glVertexAttribPointer(arg_position, 3, GL.GL_FLOAT, False, 0,
points_vbo)
colors_vbo.bind()
arg_in_color = GL.glGetAttribLocation(self._program, 'in_color')
GL.glEnableVertexAttribArray(arg_in_color)
GL.glVertexAttribPointer(arg_in_color, 3, GL.GL_FLOAT, False, 0,
colors_vbo)
GL.glDrawArrays(mode, 0, count)
points_vbo.unbind()
colors_vbo.unbind()
GL.glDisableVertexAttribArray(arg_position)
GL.glDisableVertexAttribArray(arg_in_color)
shaders.glUseProgram(0)
def Render(self, mode):
"""Render the geometry for the scene."""
shaders.glUseProgram(self.shader)
try:
self.vbo.bind()
try:
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(self.vbo)
glDrawArrays(GL_TRIANGLES, 0, 9)
finally:
self.vbo.unbind()
glDisableClientState(GL_VERTEX_ARRAY)
# self.vbo = vbo.VBO(
# array( [
# [ 2,-1, 0 ],
# [ 4,-1, 0 ],
# [ 4, 1, 0 ],
# [ 2,-1, 0 ],
# [ 4, 1, 0 ],
# [ 2, 1, 0 ],
# # [ 2,-2, 0 ],
# # [ 4,-2, 0 ],
# # [ 4, 0, 0 ],
# # [ 2,-2, 0 ],
# # [ 4, 0, 0 ],
# # [ 2, 0, 0 ],
# ],'f')
# )
finally:
shaders.glUseProgram(0)
def unprep(state): (glEnable if state["blend"] else glDisable)(GL_BLEND) shaders.glUseProgram(state["program"]) glBlendFunc(state["srcfunc"], state["dstfunc"]) (glEnableVertexAttribArray if state["penable"] else glDisableVertexAttribArray)(_locations["p"]) # glVertexAttribPointer(_locations["p"], state["psize"], state["ptype"], state["pnorm"], state["pstride"], state["ppointer"]) pass
def cubeModel(shader):
glTranslate(3.0,0.,0.)
shaders.glUseProgram(shader)
myUniformLocation = glGetUniformLocation(shader, "myUniform");
glUniform4f(myUniformLocation, 0.9,0.3,0.3,1.0);
glutSolidCube(1.)
glDeleteProgram(shader)
def on_display():
for i in range(0, updates_per_frame):
lattice.evolve()
lattice.update_moments()
moments_texture.collect()
for i in range(0, updates_per_frame):
particles.update(aging=False)
lattice.sync()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
shaders.glUseProgram(shader_program)
glUniformMatrix4fv(projection_id, 1, False,
numpy.asfortranarray(projection))
moments_texture.bind()
glBegin(GL_POLYGON)
glVertex(0, 0, 0)
glVertex(lattice.geometry.size_x, 0, 0)
glVertex(lattice.geometry.size_x, lattice.geometry.size_y, 0)
glVertex(0, lattice.geometry.size_y, 0)
glEnd()
shaders.glUseProgram(particle_program)
glUniformMatrix4fv(particle_projection_id, 1, False,
numpy.asfortranarray(projection))
particles.bind()
glPointSize(point_size)
glDrawArrays(GL_POINTS, 0, particles.count)
glutSwapBuffers()
def main():
glutInit(sys.argv)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
glutInitWindowSize(800, 800)
glutCreateWindow('fluid')
FRAGMENT_SHADER = shaders.compileShader(
"""#version 120
void main() {
gl_FragColor = vec4( 0, 1, 0, 1 );
}""", GL_FRAGMENT_SHADER
)
shader = shaders.compileProgram(FRAGMENT_SHADER)
shaders.glUseProgram(shader)
glutDisplayFunc(display)
glutIdleFunc(display)
glMatrixMode(GL_PROJECTION)
gluPerspective(40.0, 1.0, 1.0, 200.0)
glMatrixMode(GL_MODELVIEW)
gluLookAt(0, 0, 180,
0, 0, 0,
0, 1, 0)
glPushMatrix()
glutMainLoop()
return
def draw(self):
for polIdx, pol in zip(range(len(self.verts)), self.verts):
GL.glActiveTexture(GL.GL_TEXTURE0+polIdx)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.texIdx[polIdx])
shaders.glUseProgram(self.shader)
loc = GL.glGetUniformLocation(self.shader, "u_translate")
GL.glUniformMatrix4fv(loc, 1, GL.GL_FALSE, self.translationMatrix.matrix)
loc = GL.glGetUniformLocation(self.shader, "u_rotate")
GL.glUniformMatrix4fv(loc, 1, GL.GL_FALSE, self.rotationMatrix.matrix)
loc = GL.glGetUniformLocation(self.shader, "u_scale")
GL.glUniformMatrix4fv(loc, 1, GL.GL_FALSE, self.scalingMatrix.matrix)
loc = GL.glGetUniformLocation(self.shader, "u_texture")
GL.glUniform1i(loc, polIdx)
loc = GL.glGetUniformLocation(self.shader, "u_rotationCenter")
GL.glUniform4fv(loc, 1, self.rotationCenter)
GL.glBegin(GL.GL_POLYGON)
GL.glTexCoord2f(1.0-self.uvs[polIdx][0][0], 1.0-self.uvs[polIdx][0][1])
GL.glVertex3f(pol[0][0], pol[0][1], pol[0][2])
GL.glTexCoord2f(1.0-self.uvs[polIdx][0][0], 1.0-self.uvs[polIdx][1][1])
GL.glVertex3f(pol[1][0], pol[1][1], pol[1][2])
GL.glTexCoord2f(1.0-self.uvs[polIdx][1][0], 1.0-self.uvs[polIdx][1][1])
GL.glVertex3f(pol[2][0], pol[2][1], pol[2][2])
GL.glTexCoord2f(1.0-self.uvs[polIdx][1][0], 1.0-self.uvs[polIdx][0][1])
GL.glVertex3f(pol[3][0], pol[3][1], pol[3][2])
GL.glEnd()
shaders.glUseProgram(0)
def paint(self, mvp_matrix):
if not self._is_initialized:
self.initialize()
self._is_initialized = True
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_INDEX_ARRAY)
shaders.glUseProgram(self._shader)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._vertex_vbo)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._index_vbo)
gl.glPolygonMode(gl.GL_FRONT, gl.GL_LINE)
gl.glPolygonMode(gl.GL_BACK, gl.GL_LINE)
gl.glUniformMatrix4fv(self._mvp_handle, 1, gl.GL_FALSE, mvp_matrix);
gl.glEnableVertexAttribArray(self._position_handle)
for mesh in self._model._meshes:
if self._model._vertex_type == b'\x02':
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, False, mesh._vertex_size, ctypes.c_void_p(mesh._vertex_buffer_offset))
elif self._model._vertex_type == b'\x0E':
gl.glVertexAttribPointer(0, 3, half_float_vertex.GL_HALF_FLOAT, False, mesh._vertex_size, ctypes.c_void_p(mesh._vertex_buffer_offset))
else:
raise Exception('Unknown vertex_type: %s' % self._model._vertex_type)
gl.glDrawElements(gl.GL_TRIANGLES, mesh._index_count, gl.GL_UNSIGNED_SHORT, ctypes.c_void_p(mesh._index_buffer_offset * 2))
gl.glDisableVertexAttribArray(self._position_handle)
shaders.glUseProgram(0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, 0)
gl.glDisableClientState(gl.GL_INDEX_ARRAY)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
def Render(self, mode=0): """Render the geometry for the scene.""" super(TestContext, self).Render(mode) glUseProgram(self.shader) glUniform1f(self.tween_location, self.tween_fraction) try: self.vbo.bind() try: glEnableVertexAttribArray(self.position_location) glEnableVertexAttribArray(self.tweened_location) glEnableVertexAttribArray(self.color_location) stride = 4 * 9 glVertexAttribPointer( self.position_location, 3, GL_FLOAT, False, stride, self.vbo) glVertexAttribPointer( self.tweened_location, 3, GL_FLOAT, False, stride, self.vbo + 12) glVertexAttribPointer( self.color_location, 3, GL_FLOAT, False, stride, self.vbo + 24) glDrawArrays(GL_TRIANGLES, 0, 9) finally: self.vbo.unbind() glDisableVertexAttribArray(self.position_location) glDisableVertexAttribArray(self.tweened_location) glDisableVertexAttribArray(self.color_location) finally: shaders.glUseProgram(0)
def render(self):
try:
GL_shaders.glUseProgram(self.shader)
try:
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbo)
GL.glVertexAttribPointer( # Vertex data
0, # Attribute 0 in this attribute array
3, # This attribute uses 3 elements
GL.GL_FLOAT, # These values are of type "GL_FLOAT"
False, # Normalize values? No!
self.vertex_data.shape[1]*c.sizeof(c.c_float), # bits per row, 4 bits for floats, 6 elements in one row (doubles are 8)
c.c_void_p(0)) # Where in each row does attribute start?
GL.glEnableVertexAttribArray(0)
GL.glVertexAttribPointer( # Extra vertex data
1,
3,
GL.GL_FLOAT,
False,
self.vertex_data.shape[1]*c.sizeof(c.c_float),
c.c_void_p(3*4))
GL.glEnableVertexAttribArray(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, self.ibo)
GL.glDrawElements(
GL.GL_TRIANGLES,
self.index_data.size,
GL.GL_UNSIGNED_INT, c.c_void_p(0))
finally:
GL.glDisableVertexAttribArray(0)
GL.glDisableVertexAttribArray(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
finally:
GL_shaders.glUseProgram(0)
def _render(self, mvp, v_buffer, shader, c_buffer=None, points=True):
ctn = len(v_buffer) // 3
shaders.glUseProgram(shader)
v_buffer.bind()
GL.glUniformMatrix4fv(GL.glGetUniformLocation(shader, 'mvp'), 1, True,
mvp)
position_loc = GL.glGetAttribLocation(shader, 'position_in')
GL.glEnableVertexAttribArray(position_loc)
GL.glVertexAttribPointer(position_loc, 3, GL.GL_FLOAT, False, 0,
v_buffer)
if c_buffer is None:
color_loc = GL.glGetAttribLocation(shader, 'color_in')
GL.glVertexAttrib3fv(color_loc,
np.array([1, 1, 0], dtype=np.float32))
v_buffer.unbind()
if c_buffer is not None:
c_buffer.bind()
color_loc = GL.glGetAttribLocation(shader, 'color_in')
GL.glEnableVertexAttribArray(color_loc)
GL.glVertexAttribPointer(color_loc, 3, GL.GL_FLOAT, False, 0,
c_buffer)
c_buffer.unbind()
GL.glDrawArrays(GL.GL_POINTS if points else GL.GL_LINES, 0, ctn)
GL.glDisableVertexAttribArray(position_loc)
if c_buffer is not None:
GL.glDisableVertexAttribArray(color_loc)
shaders.glUseProgram(0)
def renderTranslucent(self): try: GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.translucentFBO) GL.glClearBufferfv(GL.GL_DEPTH, 0, 1) GL_shaders.glUseProgram(self.shaderTranslucent) self.tex1.bind(0) self.model2.bind() GL.glUniformMatrix4fv( self.UNIFORMSTranslucent['my_ModelMatrix'],1, GL.GL_TRUE, self.ModelMatrix.get()) GL.glUniformMatrix4fv( self.UNIFORMSTranslucent['my_ViewMatrix'],1, GL.GL_TRUE, self.ViewMatrix.get()) GL.glUniformMatrix4fv( self.UNIFORMSTranslucent['my_ProjectionMatrix'],1, GL.GL_TRUE, self.ProjectionMatrix.get()) GL.glUniform1i(self.UNIFORMSTranslucent['tex0'], 0) finally: self.model2.unbind() self.tex1.unbind() GL_shaders.glUseProgram(0) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
def _render_object(mvp, position, color, program, n_points, uniform_color=False, drawing_object=GL.GL_POINTS):
shaders.glUseProgram(program)
GL.glUniformMatrix4fv(
GL.glGetUniformLocation(program, 'mvp'),
1, True, mvp)
# If color is fragment-level then use uniform, pass an array otherwise
if uniform_color:
GL.glUniform3fv(
GL.glGetUniformLocation(program, 'color'),
1, color)
else:
color.bind()
color_loc = GL.glGetAttribLocation(program, 'color')
GL.glEnableVertexAttribArray(color_loc)
GL.glVertexAttribPointer(color_loc, 3, GL.GL_FLOAT,
False, 0,
color)
position.bind()
position_loc = GL.glGetAttribLocation(program, 'position')
GL.glEnableVertexAttribArray(position_loc)
GL.glVertexAttribPointer(position_loc, 3, GL.GL_FLOAT,
False, 0,
position)
GL.glDrawArrays(drawing_object, 0, n_points)
GL.glDisableVertexAttribArray(position_loc)
position.unbind()
if not uniform_color:
GL.glDisableVertexAttribArray(color_loc)
color.unbind()
shaders.glUseProgram(0)
def render( self, mode, shader=None ):
"""Render this shader in the current mode"""
renderer = mode.cache.getData(self)
if renderer is None:
renderer = self.compile( mode, shader )
if renderer is False:
log.warn("""%s""",
self.compileLog,
)
if renderer not in (None,False):
try:
GL_shaders.glUseProgram( renderer )
except error.GLError, err:
log.error( '''Failure compiling: %s''', '\n'.join([
'%s: %s'%(shader.url or shader.source,shader.compileLog)
for shader in self.shaders
]))
raise
else:
for uniform in mode.uniforms:
uniform.render( self, mode )
for uniform in self.uniforms:
uniform.render( self, mode )
# TODO: retrieve maximum texture count and restrict to that...
i = 0
for texture in self.textures:
if texture.render( self, mode, i ):
i += 1
def scenemodel(shader):
# glRotate(90,0.,0.,1.)
shaders.glUseProgram(shader)
myUniformLocation = glGetUniformLocation(shader, "myUniform");
glUniform4f(myUniformLocation, 0.2,0.5,1.0,1.0);
glutSolidTeapot(1.)
glDeleteProgram(shader)
def Render( self, mode):
"""Render the geometry for the scene."""
BaseContext.Render( self, mode )
if not mode.visible:
return
self.ViewPort( self.width, self.height )
shaders.glUseProgram(self.shader)
glUniform2f( self.UNIFORM_LOCATIONS['viewport'], self.width, self.height )
glUniform1f( self.UNIFORM_LOCATIONS['pointSizeThreshold'], 0.0 )
glUniform1f( self.UNIFORM_LOCATIONS['MaxPixelSize'], 50.0 )
glUniform1f( self.UNIFORM_LOCATIONS['ConstantRadius'], 1.0 )
glRotate( 45, 0,1,0 )
glScale( 3,3,3 )
# Clear The Screen And The Depth Buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
try:
self.vbo.bind()
try:
glEnableClientState( GL_VERTEX_ARRAY );
glEnable( GL_PROGRAM_POINT_SIZE );
glVertexPointerf( self.vbo )
# glDrawArrays( GL_TRIANGLES, 0, 9 )
glDrawArrays( GL_POINTS, 0, 9 )
finally:
self.vbo.unbind()
glDisableClientState( GL_VERTEX_ARRAY );
finally:
shaders.glUseProgram( 0 )
def draw(self):
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, self.pfmtexobj)
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_2D, self.media.texobj)
glActiveTexture(GL_TEXTURE2)
glBindTexture(GL_TEXTURE_2D, self.blend.texobj)
shaders.glUseProgram(self.shader)
glUniform1i(self.texture0Loc, 0)
glUniform1i(self.texture1Loc, 1)
glUniform1i(self.texture2Loc, 2)
glUniform1f(self.blendGammaLoc, self.blendGamma)
glUniform1f(self.targetGammaLoc, self.targetGamma)
glUniform1f(self.mediaGammaLoc, self.mediaGamma)
glUniformMatrix4fv(self.warpMatLoc, 1, GL_FALSE, self.warpMat)
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
glBindBuffer(GL_ARRAY_BUFFER, self.vertdata)
glVertexPointer(2, GL_FLOAT, 0, None)
glTexCoordPointer(2, GL_FLOAT, 0, None)
glDrawArrays(GL_TRIANGLES, 0, 6)
glUseProgram(0)
glPopClientAttrib()
self.saveOutputImage()
def Render(self, mode=0): """Render the geometry for the scene.""" super(TestContext, self).Render(mode) glUseProgram(self.shader) try: self.vbo.bind() try: glUniform4f(self.light_ambient_location, 0.2, 0.2, 0.2, 1.0) glUniform4f(self.light_diffuse_location, 1, 0.8, 0.8, 1) glUniform3f(self.light_location_location, 2, 2, 10) glUniform4f(self.material_ambient_location, 0.2, 0.2, 0.8, 1.0) glUniform4f(self.material_diffuse_location, 1, 1, 1, 1) glEnableVertexAttribArray(self.vertex_position_location) glEnableVertexAttribArray(self.vertex_normal_location) stride = 6 * 4 glVertexAttribPointer( self.vertex_position_location, 3, GL_FLOAT, False, stride, self.vbo) glVertexAttribPointer( self.vertex_normal_location, 3, GL_FLOAT, False, stride, self.vbo + 12) glDrawArrays(GL_TRIANGLES, 0, 18) finally: self.vbo.unbind() glDisableVertexAttribArray(self.vertex_position_location) glDisableVertexAttribArray(self.vertex_normal_location) finally: shaders.glUseProgram(0)
def _render_tracked_cam_track(self, view_proj):
shaders.glUseProgram(self._shaders.line)
try:
self._buffer_objects.track.bind()
position_loc = None
try:
GL.glUniformMatrix4fv(
GL.glGetUniformLocation(self._shaders.line, 'mvp'), 1,
True, view_proj)
GL.glUniform3fv(
GL.glGetUniformLocation(self._shaders.line, 'color'), 1,
np.array([1, 1, 1], dtype=np.float32))
position_loc = GL.glGetAttribLocation(self._shaders.line,
'position')
GL.glEnableVertexAttribArray(position_loc)
GL.glVertexAttribPointer(position_loc, 3, GL.GL_FLOAT, False,
0, self._buffer_objects.track)
GL.glDrawArrays(GL.GL_LINE_STRIP, 0,
self._buffer_objects.track.data.shape[0])
finally:
if position_loc is not None:
GL.glDisableVertexAttribArray(position_loc)
self._buffer_objects.track.unbind()
finally:
shaders.glUseProgram(0)
def Render(self, mode):
'''render the geometry of the scene'''
# tell opengl to use our shader
shaders.glUseProgram(self.shader)
try:
# bind data into gpu
self.vbo.bind()
try:
# tells opengl to access vertex once
# we call a draw function
glEnableClientState(GL_VERTEX_ARRAY)
# point at our vbo data
glVertexPointerf(self.vbo)
# actually tell opengl to draw
# the stuff in the VBO as a series
# of triangles
glDrawArrays(GL_TRIANGLES, 0, 9)
finally:
# cleanup, unbind the our data from gpu ram
# and tell opengl that it should not
# expect vertex arrays anymore
self.vbo.unbind()
glDisableClientState(GL_VERTEX_ARRAY)
finally:
# stop using our shader
shaders.glUseProgram(0)
def draw_scroll(self, offset, scale):
glPushMatrix()
shaders.glUseProgram(self.shader)
glUniform1f(glGetUniformLocation(self.shader, "offset"), offset)
glUniform1f(glGetUniformLocation(self.shader, "scale"), scale)
self.vbo.bind()
glColor4f(1.0, 0.0, 0.0, 1.0)
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(None)
vbo_edge = self.nrows % self.history
strip_nvertices = (self.points - 1) * 4
glPushMatrix()
glTranslatef(0.0, -float(vbo_edge) / self.history, 0.0)
glDrawArrays(GL_QUADS, strip_nvertices * (self.history - vbo_edge), strip_nvertices * vbo_edge)
glPopMatrix()
glPushMatrix()
glTranslatef(0.0, -1.0 - float(vbo_edge) / self.history, 0.0)
glDrawArrays(GL_QUADS, 0, strip_nvertices * (self.history - vbo_edge))
glPopMatrix()
glDisableClientState(GL_VERTEX_ARRAY)
self.vbo.unbind()
shaders.glUseProgram(0)
glPopMatrix()
def cleanup(self): ''' Cleans up after the shader has been used ''' glDisableVertexAttribArray(self.attrib_position) # Unbind the shader shaders.glUseProgram(0)
def paintGL_Spheres(self): if not self.shader_Spheres: self.__init__Spheres() shaders.glUseProgram(self.shader_Spheres) c1,c2=self.centroids self.drawSphere( c1 , (1,0,0,1) ) self.drawSphere( c2 , (0,0,1,1) )
def paintGL(self):
if GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) == 33305:
return
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
if not self.texture:
return
if not self.shader:
self.compileShaders()
if not self.vbo:
self.vbo = GL.glGenBuffers(1)
shaders.glUseProgram(self.shader)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbo)
vertices = numpy.array(
[-self.scale + self.cx, -self.scale + self.cy ,
self.scale + self.cx, -self.scale + self.cy,
self.scale + self.cx, self.scale + self.cy,
-self.scale + self.cx, self.scale + self.cy,
0,0,1,0,1,1,0,1], dtype = numpy.float32)
GL.glBufferData(GL.GL_ARRAY_BUFFER, 64, vertices, GL.GL_STATIC_DRAW)
loc = GL.glGetAttribLocation(self.shader, "positionIn")
GL.glEnableVertexAttribArray(loc)
GL.glVertexAttribPointer(loc, 2, GL.GL_FLOAT, 0, 8, c_void_p(0))
loc = GL.glGetAttribLocation(self.shader, "texIn")
GL.glEnableVertexAttribArray(loc)
GL.glVertexAttribPointer(loc, 2, GL.GL_FLOAT, 0, 8, c_void_p(32))
def _uniformLoc(name):
return GL.glGetUniformLocation(self.shader,name)
GL.glUniform1f(_uniformLoc("g"), self.gamma);
GL.glUniform1f(_uniformLoc("m"), math.pow(2, self.exposure + 2.47393))
GL.glUniform1f(_uniformLoc("s"), math.pow(2, -3.5 * self.gamma))
GL.glUniform1i(_uniformLoc("hdr_mode"), self.hdr_mode);
GL.glUniform1i(_uniformLoc("texture"), 0);
GL.glActiveTexture(GL.GL_TEXTURE0);
GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture)
GL.glDrawArrays(GL.GL_QUADS, 0, 4);
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
loc = GL.glGetAttribLocation(self.shader, "positionIn")
GL.glDisableVertexAttribArray(loc)
loc = GL.glGetAttribLocation(self.shader, "texIn")
GL.glDisableVertexAttribArray(loc)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
shaders.glUseProgram(0)
if self.rightBtnDown:
self.renderPixelInfo()
def draw_content(self):
glPushMatrix()
glTranslated(-1.0, 0.0, 0.0)
glScalef(2.0, 1.0, 1.0)
self.shader.setup(self.mag_range)
self.multitexture.draw_scroll(self.texture_edge)
shaders.glUseProgram(0)
glPopMatrix()
def runningSession(self):
try:
GL_shaders.glUseProgram(self.shader) ##TODO: revise handling of shaders - objects?
GL.glUniformMatrix4fv(
self.UNIFORMS['my_ModelMatrix'],1, GL.GL_TRUE,
self.ModelMatrix.get())
GL.glUniformMatrix4fv(
self.UNIFORMS['my_ViewMatrix'],1, GL.GL_TRUE,
self.ViewMatrix.get())
GL.glUniformMatrix4fv(
self.UNIFORMS['my_ProjectionMatrix'],1, GL.GL_TRUE,
self.ProjectionMatrix.get())
try:
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbo)
GL.glVertexAttribPointer( # Vertex data
0, # Attribute 0 in this attribute array
3, # This attribute uses 3 elements
GL.GL_FLOAT, # These values are of type "GL_FLOAT"
False, # Normalize values? No!
self.vertex_data.shape[1]*c.sizeof(c.c_float), # bits per row, 4 bits for floats, 6 elements in one row (doubles are 8)
c.c_void_p(0)) # Where in each row does attribute start?
GL.glEnableVertexAttribArray(0)
GL.glVertexAttribPointer( # Vertex data
1, # Attribute 0 in this attribute array
3, # This attribute uses 3 elements
GL.GL_FLOAT, # These values are of type "GL_FLOAT"
False, # Normalize values? No!
self.vertex_data.shape[1]*c.sizeof(c.c_float), # bits per row, 4 bits for floats, 6 elements in one row (doubles are 8)
c.c_void_p(3*4)) # Where in each row does attribute start?
GL.glEnableVertexAttribArray(0)
GL.glVertexAttribPointer( # Vertex data
2, # Attribute 0 in this attribute array
2, # This attribute uses 3 elements
GL.GL_FLOAT, # These values are of type "GL_FLOAT"
False, # Normalize values? No!
self.vertex_data.shape[1]*c.sizeof(c.c_float), # bits per row, 4 bits for floats, 6 elements in one row (doubles are 8)
c.c_void_p(6*4)) # Where in each row does attribute start?
GL.glEnableVertexAttribArray(0)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, self.ibo)
GL.glDrawElements(
GL.GL_TRIANGLES,
self.vertex_index.size,
GL.GL_UNSIGNED_INT, c.c_void_p(0))
finally:
GL.glDisableVertexAttribArray(0)
GL.glDisableVertexAttribArray(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
finally:
GL_shaders.glUseProgram(0)
def setup(self, mag_range):
scale = (self.TEX_RANGE[1] - self.TEX_RANGE[0]) / (mag_range[1] - mag_range[0]) * (self.M2C_RANGE[1] - self.M2C_RANGE[0])
shift = (self.TEX_RANGE[0] - mag_range[0]) / (self.TEX_RANGE[1] - self.TEX_RANGE[0]) + self.M2C_RANGE[0] / scale
shaders.glUseProgram(self.program)
glUniform1i(glGetUniformLocation(self.program, "sampler"), 0)
glUniform1f(glGetUniformLocation(self.program, "scale"), scale)
glUniform1f(glGetUniformLocation(self.program, "shift"), shift)
glActiveTexture(GL_TEXTURE0)
def __exit__(self, exc_type, exc_value, traceback):
try:
while self._attr_enabled:
loc = self._attr_enabled.pop()
G.glDisableVertexAttribArray(loc)
finally:
try:
if self._indices_vbo is not None:
self._indices_vbo.unbind()
self._vbo.unbind()
finally:
shaders.glUseProgram(0)
def compileProgram(self):
'''
Compiles the vertex shader and the fragment shader and
runs glUseProgram on the resulting program object
'''
# Compile each shader
vertex_shader = shaders.compileShader(vs_src, GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader(fs_src, GL_FRAGMENT_SHADER)
# Compile and link the program
self.shader = shaders.compileProgram(vertex_shader, fragment_shader)
# Tells the GL Context that this is the pipeline to use.
shaders.glUseProgram(self.shader)
def render(self):
GL_shaders.glUseProgram(self.shader)
GL.glUniform1f(self.UNIFORMS['a'], 0.5)
GL.glUniform4f(self.UNIFORMS['b'], 1.0, 1.0, 0.0, 1.0)
GL.glUniform1i(self.UNIFORMS['s'], 0)
GL.glUniform1i(self.UNIFORMS['t'], 1)
try:
self.vbo.bind() # Select "self.vbo"
self.ibo.bind() # Select "self.ibo"
# It won't deselect "self.vbo" since they target different buffers
try:
GL.glEnableVertexAttribArray(0)
GL.glEnableVertexAttribArray(1)
GL.glEnableVertexAttribArray(2)
GL.glVertexAttribPointer( # Vertex data, maybe...
0, # Attribute 0 in this attribute array
3, # This attribute uses 3 elements
GL.GL_FLOAT, # These values are of type "GL_FLOAT"
False, # Normalize values? No!
8*4, # bits per row, 4 bits for floats, 6 elements in one row (doubles are 8)
self.vbo) # Where in each row does attribute start? A little unintuitive...
GL.glVertexAttribPointer( # Normal data, maybe...
1,
3,
GL.GL_FLOAT,
False,
8*4,
self.vbo + 3*4)
GL.glVertexAttribPointer( # UV-mapping data, maybe...
2,
2,
GL.GL_FLOAT,
False,
8*4,
self.vbo + 6*4)
GL.glDrawElements(
GL.GL_TRIANGLES,
6, ##TODO: create method that gets number of indices in IBO!
GL.GL_UNSIGNED_INT, self.ibo)
finally:
self.vbo.unbind()
self.ibo.unbind()
GL.glDisableVertexAttribArray(0)
GL.glDisableVertexAttribArray(1)
GL.glDisableVertexAttribArray(2)
finally:
GL_shaders.glUseProgram(0)
def Render(self, mode):
GLshaders.glUseProgram(self.myShader)
try:
self.vbo.bind()
try:
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
GL.glVertexPointerf(self.vbo)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)
finally:
self.vbo.unbind()
GL.glDisableClientState(GL.GL_VERTEX_ARRAY)
finally:
GLshaders.glUseProgram(0)
def render():
# blue bg
blue = (0.0, 0.0, 1.0, 0.0)
glClearColor(*blue)
glClear(GL_COLOR_BUFFER_BIT)
# this should go in an init function really
# http://pyopengl.sourceforge.net/context/tutorials/shader_1.html
VERTEX_SHADER = shaders.compileShader("""
#version 120
void main() {
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}
""", GL_VERTEX_SHADER)
FRAGMENT_SHADER = shaders.compileShader("""
#version 120
void main() {
gl_FragColor = vec4( 0, 1, 0, 1 );
}
""", GL_FRAGMENT_SHADER)
shader = shaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER)
myvbo = vbo.VBO(
array( [
[ 0, 1, 0 ],
[ -1,-1, 0 ],
[ 1,-1, 0 ],
[ 2,-1, 0 ],
[ 4,-1, 0 ],
[ 4, 1, 0 ],
[ 2,-1, 0 ],
[ 4, 1, 0 ],
[ 2, 1, 0 ],
],'f')
)
shaders.glUseProgram(shader)
try:
myvbo.bind()
try:
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointerf(myvbo)
glDrawArrays(GL_TRIANGLES, 0, 9)
finally:
myvbo.unbind()
glDisableClientState(GL_VERTEX_ARRAY);
finally:
shaders.glUseProgram(0)
def Render(self, mode): """Render the geometry for the scene.""" shaders.glUseProgram(self.shader) try: self.vbo.bind() try: glEnableClientState(GL_VERTEX_ARRAY) glVertexPointerf(self.vbo) glDrawArrays(GL_TRIANGLES, 0, 9) finally: self.vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY) finally: shaders.glUseProgram(0)
def render(self):
GL_shaders.glUseProgram(self.shader)
try:
self.vbo.bind()
try:
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
GL.glVertexPointerf(self.vbo)
# Draw triangles, start at 0 in vbo and continue for 3 entries (one triangle!)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)
finally:
self.vbo.unbind()
GL.glDisableClientState(GL.GL_VERTEX_ARRAY)
finally:
GL_shaders.glUseProgram(0)
def renderComposition(self): try: GL_shaders.glUseProgram(self.shaderComposition) GL.glActiveTexture(GL.GL_TEXTURE0 + 0) GL.glBindTexture(GL.GL_TEXTURE_2D, self.opaqueDEPTHtex) GL.glActiveTexture(GL.GL_TEXTURE0 + 1) GL.glBindTexture(GL.GL_TEXTURE_2D, self.translucentDEPTHtex) self.canvas.bind() GL.glUniform1i(self.UNIFORMSComposition['tex0'], 0) GL.glUniform1i(self.UNIFORMSComposition['tex1'], 1) finally: self.canvas.unbind() GL.glBindTexture(GL.GL_TEXTURE_2D, 0) GL_shaders.glUseProgram(0)
def paint():
#print("DRAW")
if not initialized:
init()
shaders.glUseProgram(shader_program)
old_warnings = warnings[:]
warnings.clear()
#re-bind the textures every draw, to be safe
for texnr, tex in enumerate(texture_locations):
gl.glActiveTexture(gl.GL_TEXTURE0+texnr)
loc = texture_locations[tex]
gl.glUniform1i(loc, texnr)
store = texdict[tex]
store.bind()
for uniform in list(uniform_dirty):
if uniform not in uniform_locations:
continue
if uniform not in uniform_types:
continue
utype = uniform_types[uniform]
value = uniform_values.get(uniform, None)
if value is None:
warnings.append("WARNING: unset uniform '%s'" % uniform)
continue
loc = uniform_locations[uniform]
set_uniform(value, utype, loc)
uniform_dirty.remove(uniform)
glstate_module.set_state(**glstate)
if glclear not in (None, False):
if glclear == True:
glstate_module.clear()
else:
glstate_module.clear(*glclear)
renderer.draw()
# Heisenbug!!! see below. Seems to be solved now
try:
warnings
except NameError:
return
if warnings != old_warnings:
for warning in warnings:
print(warning)
def draw(self):
if self.is_empty: return
if self.vbo is None: self.vbo = vbo.VBO(self.vbo_data)
shaders.glUseProgram(Chunk.shader)
self.vbo.bind()
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_COLOR_ARRAY)
glVertexPointer(3, GL_FLOAT, 24, self.vbo)
glColorPointer(3, GL_FLOAT, 24, self.vbo + 12)
glDrawArrays(GL_QUADS, 0, self.vbo_data.size / 6)
self.vbo.unbind()
glDisableClientState(GL_VERTEX_ARRAY)
glDisableClientState(GL_COLOR_ARRAY)
shaders.glUseProgram(0)
