def draw_grid(self,):
gl.glUseProgram(self.simple_object_shader)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LESS)
gl.glBindVertexArray(self.grid_vao)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.grid_vbo)
vProjection = gl.glGetUniformLocation(self.simple_object_shader, 'vProjection')
vPosisition = gl.glGetAttribLocation(self.simple_object_shader, "vPosisition")
vColor = gl.glGetAttribLocation(self.simple_object_shader, "vColor")
vCamera = gl.glGetUniformLocation(self.simple_object_shader, 'vCamera')
gl.glUniformMatrix4fv(vProjection, 1, gl.GL_FALSE, self.projection_matrix_function())
gl.glUniformMatrix4fv(vCamera, 1, gl.GL_FALSE, self.camera_matrix_function())
gl.glEnableVertexAttribArray(vPosisition)
gl.glEnableVertexAttribArray(vColor)
gl.glVertexAttribPointer(vPosisition, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
gl.glVertexAttribPointer(vColor, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, ctypes.c_void_p(self.grid_size * 4))
gl.glDrawArrays(gl.GL_TRIANGLES, 0, self.grid_size // 4)
def display(self):
"""Draw surface to a quad. Call as part of OpenGL rendering code."""
ogl.glEnable(ogl.GL_BLEND)
ogl.glBlendFunc(ogl.GL_SRC_ALPHA, ogl.GL_ONE_MINUS_SRC_ALPHA)
ogl.glEnable(ogl.GL_TEXTURE_2D)
ogl.glBindTexture(ogl.GL_TEXTURE_2D, self._txtr)
ogl.glTexEnvf(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_MODE, ogl.GL_REPLACE)
#ogl.glColor4d( 1.0, 1.0, 1.0, alpha )
#ogl.glTexEnvf(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_MODE, ogl.GL_MODULATE)
#glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
#ogl.glTexEnvfv(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_COLOR, (0, 0, 0, alpha))
#ogl.glNormal3f(0.0, 0.0, -1.0)
ogl.glBegin(ogl.GL_QUADS)
ogl.glTexCoord2f(0.0, 1-self._usable[1])
# bottom left corner
ogl.glVertex3f(*self.dims[0])
ogl.glTexCoord2f(self._usable[0], 1-self._usable[1])
# bottom right corner
ogl.glVertex3f(self.dims[1][0],self.dims[1][1],0.0)
ogl.glTexCoord2f(self._usable[0], 1.0)
# top right corner
ogl.glVertex3f(*self.dims[2])
ogl.glTexCoord2f(0.0, 1.0)
# top left corner
ogl.glVertex3f(*self.dims[3])
ogl.glEnd()
ogl.glDisable(ogl.GL_BLEND)
ogl.glDisable(ogl.GL_TEXTURE_2D)
def gl_draw_all(self, root, offset):
if not self.visible:
return
from OpenGL import GL, GLU
rect = self.rect.move(offset)
if self.is_gl_container:
self.gl_draw_self(root, offset)
suboffset = rect.topleft
for subwidget in self.subwidgets:
subwidget.gl_draw_all(root, suboffset)
else:
try:
surface = Surface(self.size, SRCALPHA)
except Exception:
#size error?
return
self.draw_all(surface)
data = image.tostring(surface, 'RGBA', 1)
w, h = root.size
GL.glViewport(0, 0, w, h)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GLU.gluOrtho2D(0, w, 0, h)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
GL.glRasterPos2i(max(rect.left, 0), max(h - rect.bottom, 0))
GL.glPushAttrib(GL.GL_COLOR_BUFFER_BIT)
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glDrawPixels(self.width, self.height, GL.GL_RGBA,
GL.GL_UNSIGNED_BYTE, fromstring(data,
dtype='uint8'))
GL.glPopAttrib()
GL.glFlush()
def paintGL(self):
"""Handle paint event by drawing the items returned by the creator
function."""
if not check_opengl_context(self.context(), (3, 0)):
return
program = self.shader_program
projection = self.camera.projection(self.width(), self.height())
set_uniform_matrix(program, "view", self.camera.view_matrix)
set_uniform_matrix(program, "projection", projection)
set_uniform_vector(program, "ambient_color", self.ambient_color)
set_uniform_vector(program, "diffuse_color", self.diffuse_color)
set_uniform_vector(program, "diffuse_position", self.camera.position)
GL.glClearColor(*self.background_color, 0)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_MULTISAMPLE)
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
# Draw transparent items after opaque ones, and sorted by distance to
# the observer (far to near). Note that this is only an approximation
# that is correct only for point-like items; a 100% correct blending
# order would have to be decided on the level of fragments (based on
# the interpolated depth value).
items = sorted(
self.items,
key=lambda item: (
item.opaque(),
np.linalg.norm(self.camera.position - item.position()),
),
reverse=True)
for item in items:
item.draw()
def display_one_track(self,track_index,color4=np.array([1,1,0,1],dtype=np.float32)):
gl.glPushMatrix()
gl.glDisable(gl.GL_LIGHTING)
gl.glEnable(gl.GL_LINE_SMOOTH)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA,gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glHint(gl.GL_LINE_SMOOTH_HINT,gl.GL_DONT_CARE)
gl.glLineWidth(7.)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glColor4fv(color4)
d=self.data[track_index].astype(np.float32)
gl.glVertexPointerf(d)
gl.glDrawArrays(gl.GL_LINE_STRIP, 0, len(d))
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnable(gl.GL_LIGHTING)
gl.glPopMatrix()
def initializeGL(self):
self.cell_width = (2 * self.screen_width / len(self.game.field[0]) /
self.screen_width)
self.cell_height = (2 * self.screen_height / len(self.game.field) /
self.screen_height)
self.shader = Shader('shader.vs', 'shader.fs')
self.shader.save_attr_locations(['aVertexPosition', 'aVertexTexCoord'])
self.shader.save_uniform_locations(['uTexture'])
self.shader.bind()
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glClearColor(255, 255, 255, 1)
GL.glViewport(0, 0, self.screen_width, self.screen_height)
self.setGeometry(0, 0, self.screen_width, self.screen_height)
self.set_field()
self.start_spawn()
self.draw_timer = Timer(self.update, consts.REDRAW_TIME)
self.draw_timer.start_timer()
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
def initializeGL(self):
"""Init"""
self.qglClearColor(self.gl_bg_color.darker())
#GL.glShadeModel(GL.GL_FLAT)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glClearDepth(1.0)
#Fix up the lines to be cleaner...
GL.glEnable(GL.GL_LINE_SMOOTH)
GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)
GL.glLineWidth(0.1)
GL.glEnable(GL.GL_BLEND)
GL.glEnable(GL.GL_MULTISAMPLE)
GL.glEnable(GL.GL_LIGHTING)
GL.glEnable(GL.GL_LIGHT0)
GL.glEnable(GL.GL_NORMALIZE)
GL.glEnable(GL.GL_LIGHT1)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glEnable(GL.GL_COLOR_MATERIAL)
GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_DIFFUSE, [0.6, 0.6, 0.6, 1.0])
GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT, [0.3, 0.3, 0.3, 1.0])
GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, [0.5, 0.5, 0.5, 1.0])
GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, 10.0)
GL.glColorMaterial(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE)
GL.glLightModeli(
GL.GL_LIGHT_MODEL_COLOR_CONTROL,
GL.GL_SINGLE_COLOR
)
GL.glLightModeli(GL.GL_LIGHT_MODEL_TWO_SIDE, 1)
def initGL():
gl.glShadeModel(gl.GL_SMOOTH)
gl.glClearColor(1.0, 1.0, 1.0, 0.0)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LESS)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glLightfv(gl.GL_LIGHT1, gl.GL_AMBIENT, [.1, .1, .1, .1])
gl.glLightfv(gl.GL_LIGHT1, gl.GL_DIFFUSE, [1., 1., 1., 0.])
gl.glLightfv(gl.GL_LIGHT1, gl.GL_SPECULAR, [1., 1., 1., 0.])
gl.glLightfv(gl.GL_LIGHT1, gl.GL_POSITION, [10., 5., 100., 1.])
gl.glEnable(gl.GL_LIGHT1)
gl.glEnable(gl.GL_LIGHTING)
gl.glCullFace(gl.GL_BACK)
gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST)
#gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST)
gl.glEnable(gl.GL_DITHER)
gl.glEnable(gl.GL_CULL_FACE)
def initializeGL(self): # , width=1, height=1
""" Initialization of the GL frame. """
# TODO: glOrtho should set to size of the frame which would allow using
# TODO: absolute coordinates in range/domain of original frame
GL.glClearColor(0.0, 0.0, 0.0, 1.0)
GL.glClearDepth(1.0)
GL.glOrtho(0, 1, 1, 0, -1, 1)
#glOrtho(0, width, height, 0, -1, 1) # DOESN'T WORK!!
GL.glMatrixMode(GL.GL_PROJECTION)
# Enable rational alpha blending
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
if self.anti_aliasing:
# Points
GL.glEnable(GL.GL_POINT_SMOOTH)
GL.glHint(GL.GL_POINT_SMOOTH_HINT, GL.GL_NICEST)
# Lines
GL.glEnable(GL.GL_LINE_SMOOTH)
GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)
# Polygons, but NOT GL_TRIANGLE_FAN
GL.glEnable(GL.GL_POLYGON_SMOOTH)
GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)
# Not sure...
GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST)
def draw(self):
self.execute()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
#handle mouse transformations
gl.glTranslatef(self.initrans[0], self.initrans[1], self.initrans[2])
gl.glRotatef(self.rotate[0], 1, 0, 0)
gl.glRotatef(self.rotate[1], 0, 1, 0) #we switched around the axis so make this rotate_z
gl.glTranslatef(self.translate[0], self.translate[1], self.translate[2])
gl.glEnable(gl.GL_POINT_SMOOTH)
gl.glPointSize(5)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
self.arrvbo.bind()
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glVertexPointer(4, gl.GL_FLOAT, 0, self.arrvbo)
self.colvbo.bind()
gl.glColorPointer(4, gl.GL_FLOAT, 0, self.colvbo)
gl.glDrawArrays(gl.GL_POINTS, 0, self.size**3)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
self.arrvbo.unbind()
self.colvbo.unbind()
glut.glutSwapBuffers()
if self.makeMovie:
gl.glReadPixels(0,0,800,600,gl.GL_RGB, gl.GL_UNSIGNED_BYTE, array=self.curimage)
fname = '_tmp%05d.png'%self.curindex
scipy.misc.imsave(fname, self.curimage)
self.curindex += 1
def setDefaultParamsPoint(self, **params):
params = super(PlotGL, self).setDefaultParamsPoint(**params)
gl.glEnable(gl.GL_POINT_SMOOTH)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glPointSize(params.get('point_size'))
return params
def paintGL(self):
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
GLU.gluLookAt(0, 0, 2, 0, 0, 0, 0, 1, 0)
GL.glDisable(GL.GL_DEPTH_TEST)
self.qglClearColor(self.clearColor)
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glPushMatrix()
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
offset = self.offset
if offset <= 0:
offset = 0
if offset > len(self.res_list) - 1:
offset = len(self.res_list) - 1
mid = int(math.floor(offset + 0.5))
start_pos = mid - TileflowWidget.VISIBLE_TILES
if start_pos < 0:
start_pos = 0
end_pos = mid + TileflowWidget.VISIBLE_TILES
if end_pos > len(self.res_list):
end_pos = len(self.res_list)
for i in range(start_pos, mid)[::TileflowWidget.DIRECTION]:
self.drawTile(i, i - offset, self.tiles[i])
for i in range(mid, end_pos)[::-TileflowWidget.DIRECTION]:
self.drawTile(i, i - offset, self.tiles[i])
GL.glPopMatrix()
def draw(self, P=None, V=None, M=None):
atlas = self.font_manager.atlas
if self._dirty:
self.upload()
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
_,_,width,height = gl.glGetIntegerv( gl.GL_VIEWPORT )
P = orthographic( 0, width, 0, height, -1, +1 )
V = np.eye(4).astype( np.float32 )
M = np.eye(4).astype( np.float32 )
shader = self.shader
shader.bind()
gl.glActiveTexture( gl.GL_TEXTURE0 )
shader.uniformi( 'u_uniforms', 0 )
gl.glBindTexture( gl.GL_TEXTURE_2D, self._ubuffer_id )
shape = self._ubuffer_shape
shader.uniformf( 'u_uniforms_shape', shape[1]//4, shape[0])
gl.glActiveTexture( gl.GL_TEXTURE1 )
shader.uniformi( 'u_font_atlas', 1 )
shader.uniformf( 'u_font_atlas_shape',
atlas.width, atlas.height, atlas.depth)
gl.glBindTexture( gl.GL_TEXTURE_2D, self.font_manager.atlas.texid)
shader.uniform_matrixf( 'u_M', M )
shader.uniform_matrixf( 'u_V', V )
shader.uniform_matrixf( 'u_P', P )
gl.glDisable( gl.GL_DEPTH_TEST )
self._vbuffer.draw( )
shader.unbind()
def on_display():
gl.glClearColor(1,1,1,1);
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
shader.bind()
shader.uniformi( 'uniforms', 0 )
shape = collection.uniforms_shape or (1,1)
shader.uniformf( 'uniforms_shape', shape[0], shape[1])
gl.glActiveTexture( gl.GL_TEXTURE0 )
gl.glBindTexture( gl.GL_TEXTURE_2D, collection.uniforms_id )
_,_,width,height = gl.glGetIntegerv( gl.GL_VIEWPORT )
P = orthographic( 0, width, 0, height, -1, +1 )
V = np.eye(4).astype( np.float32 )
M = np.eye(4).astype( np.float32 )
shader.uniform_matrixf( 'M', M )
shader.uniform_matrixf( 'V', V )
shader.uniform_matrixf( 'P', P )
collection.draw( )
shader.unbind()
glut.glutSwapBuffers()
def _on_paint(self, event): """ Respond to paint events. Initialize GL if this is the first paint event. Resize the view port if the width or height changed. Redraw the screen, calling the draw functions. """ if not self.IsShownOnScreen(): # Cannot realise a GL context on OS X if window is not yet shown return # create device context (needed on Windows, noop on X) dc = None if event.GetEventObject(): # Only create DC if paint triggered by WM message (for OS X) dc = wx.PaintDC(self) self.lock() self.SetCurrent(self._gl_ctx) # Real the explicit GL context # check if gl was initialized if not self._gl_init_flag: GL.glClearColor(*BACKGROUND_COLOR_SPEC) for fcn in self._init_fcns: fcn() self._gl_init_flag = True # check for a change in window size if self._resized_flag: self.width, self.height = self.GetSize() GL.glMatrixMode(GL.GL_PROJECTION) GL.glLoadIdentity() GL.glOrtho(0, self.width, self.height, 0, 1, 0) GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity() GL.glViewport(0, 0, self.width, self.height) for cache in self._gl_caches: cache.changed(True) self._resized_flag = False # clear buffer if needed if self.clear_accum or not self.use_persistence: GL.glClear(GL.GL_COLOR_BUFFER_BIT) self.clear_accum=False # apply fading if self.use_persistence: GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glBegin(GL.GL_QUADS) GL.glColor4f(1,1,1,self.persist_alpha) GL.glVertex2f(0, self.height) GL.glVertex2f(self.width, self.height) GL.glVertex2f(self.width, 0) GL.glVertex2f(0, 0) GL.glEnd() GL.glDisable(GL.GL_BLEND) # draw functions for fcn in self._draw_fcns: fcn[1]() # show result self.SwapBuffers() self.unlock()
def draw_line(self,
start_x,
start_y,
end_x,
end_y,
color=(1.0, 1.0, 1.0, 1.0),
width=None):
"""Draw a line on canvas."""
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glColor4f(*color)
prev_width = None
if width is not None:
prev_width = gl.glGetFloat(gl.GL_LINE_WIDTH)
gl.glLineWidth(width)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_DONT_CARE)
gl.glBegin(gl.GL_LINES)
gl.glVertex2f(start_x, start_y)
gl.glVertex2f(end_x, end_y)
gl.glEnd()
gl.glDisable(gl.GL_BLEND)
if prev_width is not None:
gl.glLineWidth(prev_width)
def enable_smoothing():
gl.glEnable(gl.GL_LINE_SMOOTH)
gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST)
gl.glEnable(gl.GL_POINT_SMOOTH)
gl.glHint(gl.GL_POINT_SMOOTH_HINT, gl.GL_NICEST)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def init(self):
""" For initialisation once OpenGL context is created. """
self.setAnimationPeriod(33)
ogl.glDisable(ogl.GL_LIGHTING)
ogl.glEnableClientState(ogl.GL_VERTEX_ARRAY)
ogl.glEnable(ogl.GL_BLEND)
ogl.glBlendFunc(ogl.GL_SRC_ALPHA, ogl.GL_ONE_MINUS_SRC_ALPHA)
ogl.glEnable(ogl.GL_CULL_FACE)
ogl.glPointSize(2.0)
self.setStateFileName('keyboard_anywhere.xml')
if not self.restoreStateFromFile():
self.camera().setSceneRadius(500)
# Make key commands appear in the help
self.kbt = ['lower left', 'lower right', 'upper left']
self.setKeyDescription(QtCore.Qt.Key_1,
'set the {0} point of the keyboard'.format(self.kbt[0]))
self.setKeyDescription(QtCore.Qt.Key_2,
'set the {0} point of the keyboard'.format(self.kbt[1]))
self.setKeyDescription(QtCore.Qt.Key_3,
'set the {0} point of the keyboard'.format(self.kbt[2]))
self.setKeyDescription(QtCore.Qt.Key_Z,
'shift the keyboard slightly in the local +Z direction')
self.setKeyDescription(QtCore.Qt.ShiftModifier + QtCore.Qt.Key_Z,
'shift the keyboard slightly in the local -Z direction')
self.setKeyDescription(QtCore.Qt.Key_Plus,
'rotate the keyboard slightly about the local +Y axis')
self.setKeyDescription(QtCore.Qt.Key_Minus,
'rotate the keyboard slightly about the local -Y axis')
self.kb_corners = np.zeros((3,3))
self.kb_corner_index = 0
self.keyboard = Keyboard()
def gl_draw_all(self, root, offset):
if not self.visible:
return
from OpenGL import GL, GLU
rect = self.rect.move(offset)
if self.is_gl_container:
self.gl_draw_self(root, offset)
suboffset = rect.topleft
for subwidget in self.subwidgets:
subwidget.gl_draw_all(root, suboffset)
else:
try:
surface = Surface(self.size, SRCALPHA)
except Exception, e:
#size error?
return
self.draw_all(surface)
data = image.tostring(surface, 'RGBA', 1)
w, h = root.size
GL.glViewport(0, 0, w, h)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GLU.gluOrtho2D(0, w, 0, h)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
GL.glRasterPos2i(max(rect.left, 0), max(h - rect.bottom, 0))
GL.glPushAttrib(GL.GL_COLOR_BUFFER_BIT)
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glDrawPixels(self.width, self.height,
GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, fromstring(data, dtype='uint8'))
GL.glPopAttrib()
GL.glFlush()
def initializeGL(self):
print('initializeGL')
print(self.getOpenglInfo())
self.setClearColor(self.trolltechBlack)
#self.object = self.makeObject()
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_DEPTH_TEST) # z - буфер
gl.glEnable(gl.GL_LIGHTING) # включаем освещение
gl.glEnable(gl.GL_LIGHT0) # включаем нулевую лампу
gl.glEnable(gl.GL_COLOR_MATERIAL
) # управление свойством материала (отражение материала)
#gl.glColorMaterial(gl.GL_FRONT, gl.GL_SPECULAR)
gl.glEnable(gl.GL_NORMALIZE) # нормаль единичной длины
gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION,
[100, 100, 100, 1]) # позиция нулевой лампы
gl.glLightf(gl.GL_LIGHT0, gl.GL_CONSTANT_ATTENUATION,
0.1) # постоянная составляющая и расстояние
gl.glLightf(gl.GL_LIGHT0, gl.GL_LINEAR_ATTENUATION,
0.05) # линейная составляющая
gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPOT_DIRECTION,
[0, 1, 1]) # положение источника света (ось конуса)
gl.glLighti(gl.GL_LIGHT0, gl.GL_SPOT_EXPONENT, 0)
gl.glLighti(gl.GL_LIGHT0, gl.GL_SPOT_CUTOFF, 5) # угол рассеяния луча
gl.glShadeModel(gl.GL_SMOOTH)
gl.glEnable(gl.GL_DEPTH_TEST) # включаем буфер глубины
gl.glEnable(gl.GL_CULL_FACE)
def createShaders(self, parent):
self._shaders.link()
GL.glEnable(GL.GL_PROGRAM_POINT_SIZE)
GL.glEnable(GL.GL_POINT_SPRITE)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glEnable(GL.GL_BLEND)
def __init__(self):
super().__init__()
self.initShaders()
# location of model matrix in shader program
self.modelview_loc = GL.glGetUniformLocation(self.shaderProgram,
b"modelview")
self.model_loc = GL.glGetUniformLocation(self.shaderProgram, b"model")
self.projection_loc = GL.glGetUniformLocation(self.shaderProgram,
b"projection")
self.sampler_loc = GL.glGetUniformLocation(self.shaderProgram,
b"sampler")
# set background color to black
GL.glClearColor(0.0, 0.0, 0.0, 1.0)
# enable face culling (backface by default)
GL.glEnable(GL.GL_CULL_FACE)
GL.glEnable(GL.GL_DEPTH_TEST)
# (Rs Sr + Rd Dr, Gs Sg + Gd Dg, Bs Sb + Bd Db, As Sa + Ad Da)
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
self.window = GLWindow.getInstance()
GL.glViewport(0, 0, window.size[0], window.size[1])
self.scene = Scene()
self.scene.camera.setAspect(window.size[0], window.size[1])
def initializeGL(self):
"""Initialize OpenGL, VBOs, upload data on the GPU, etc."""
# First check for supported GL version
gl_version = float(gl.glGetString(gl.GL_VERSION)[:3])
if gl_version < 3.3:
return
# background color
gl.glClearColor(0, 0, 0, 0)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# self.mcp_data = mcpUBO()
self.globaldata = ndUBO()
self.mcp_col_shader = BlueSkyProgram('mcp.vert', 'color.frag')
self.mcp_tex_shader = BlueSkyProgram('mcp.vert', 'texture.frag')
self.mcp_txt_shader = BlueSkyProgram('mcp_text.vert', 'mcp_text.frag')
self.color_shader = BlueSkyProgram('normal.vert', 'color.frag')
self.text_shader = BlueSkyProgram('text.vert', 'text.frag')
self.text_shader.bind_uniform_buffer('global_data', self.globaldata)
self.create_objects()
self.update_lcd()
def on_display():
gl.glClearColor(1, 1, 1, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
shader.bind()
shader.uniformi('uniforms', 0)
shape = collection.uniforms_shape or (1, 1)
shader.uniformf('uniforms_shape', shape[0], shape[1])
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, collection.uniforms_id)
_, _, width, height = gl.glGetIntegerv(gl.GL_VIEWPORT)
P = orthographic(0, width, 0, height, -1, +1)
V = np.eye(4).astype(np.float32)
M = np.eye(4).astype(np.float32)
shader.uniform_matrixf('M', M)
shader.uniform_matrixf('V', V)
shader.uniform_matrixf('P', P)
collection.draw()
shader.unbind()
glut.glutSwapBuffers()
def paintLayer(self, layerName, width, height): self.width, self.height = width, height GL.glViewport(0, 0, self.width, self.height) self.qglClearColor(QtGui.QColor(0, 0, 200, 0)) GL.glHint(GL.GL_POINT_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) GL.glEnable(GL.GL_POINT_SMOOTH) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glMatrixMode(GL.GL_PROJECTION) # 2d operations GL.glLoadMatrixf(np.array([[self.camera.cameraZoom,0,0,0],[0,self.camera.cameraZoom,0,0],[0,0,1.0,0],[(2.0*self.camera.cameraOx)/self.width,(2.0*self.camera.cameraOy)/self.height,0,1.0]],dtype=np.float32)) # set the near and far clipping planes and aspect ratio # try to control the near and far based on the interest distance GL.glMultMatrixf(np.array([[1,0,0,0],[0,self.aspect,0,0],[0,0,-1.00002,-1],[0,0,self.camera.cameraInterest*-0.0200002,0]],dtype=np.float32)) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glShadeModel(GL.GL_SMOOTH) # draw 3D geometry # apply the camera matrix GL.glMatrixMode(GL.GL_PROJECTION) GL.glMultMatrixd(self.camera.P().T) GL.glMatrixMode(GL.GL_MODELVIEW) p = self.getLayer(layerName) if p is None: return p.paintGL(drawOpts=self.drawOpts)
def renderNeckMethod(self,
visibility,
offset,
neck,
alpha=False): #blazingamer: New neck rendering method
v = visibility
gl.glEnable(gl.GL_TEXTURE_2D)
if offset == 0:
board_tex = self.board_tex_static
else:
board_tex = self.board_tex
if self.failcount == v:
board_col = self.board_col_flash
else:
board_col = self.board_col
if alpha == True:
gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE)
if neck:
neck.texture.bind()
cmgl.drawArrays(gl.GL_TRIANGLE_STRIP,
vertices=self.board_vtx,
colors=board_col,
texcoords=board_tex)
if alpha == True:
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glDisable(gl.GL_TEXTURE_2D)
def render(self):
if not self.isExposed():
return
self.context.makeCurrent(self)
bits = 0
bits |= gl.GL_COLOR_BUFFER_BIT
bits |= gl.GL_DEPTH_BUFFER_BIT
bits |= gl.GL_STENCIL_BUFFER_BIT
gl.glClear(bits)
gl.glEnable(gl.GL_PROGRAM_POINT_SIZE)
for program in self.layer_manager.programs():
if program.do_blending:
if self.bg_white:
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_SRC_ALPHA)
else:
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_ONE, gl.GL_SRC_ALPHA)
else:
gl.glDisable(gl.GL_BLEND)
self.layer_manager.draw()
if self.hud_program.is_visible:
self.hud_program.draw()
self.context.swapBuffers(self)
def _execute_vbos(self):
gl.glDisable(gl.GL_LIGHTING)
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glLineWidth(self.line_width)
self.vbo.bind()
#try:
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
#gl.glVertexPointerf(cdata)
gl.glVertexPointer(3, gl.GL_FLOAT, 28, self.vbo)
gl.glColorPointer(4, gl.GL_FLOAT, 28, self.vbo + 12)
gl.glMultiDrawArrays(gl.GL_LINE_STRIP,\
self.first,self.counts,self.len_counts)
#finally:
self.vbo.unbind()
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_LIGHTING)
gl.glEnable(gl.GL_DEPTH_TEST)
def draw_text(self,
text,
color=(1.0, 1.0, 0.0, 0.0),
screen_position=(0.0, 0.0)):
import OpenGL.GL as gl
gl.glUseProgram(self._program_id)
gl.glActiveTexture(gl.GL_TEXTURE0 + self._texture_unit)
gl.glBindTexture(gl.GL_TEXTURE_2D, self._texture_id)
#gl.glBindSampler(tex_unit, self._sampler_id)
gl.glUniform1i(self._uniform_locations['u_fonttex'],
self._texture_unit)
gl.glUniform4f(self._uniform_locations['u_color'], *color)
gl.glUniform2f(self._uniform_locations['u_screen_size'],
*self._screen_size)
gl.glUniform2f(self._uniform_locations['u_char_size'], self._width,
self._height)
gl.glUniform2f(self._uniform_locations['u_screen_position'],
*screen_position)
gl.glUniform2f(self._uniform_locations['u_fonttex_size'],
self._image_width, self._image_height)
nchars = len(text)
gl.glUniform1ui(self._uniform_locations['u_nchars'], nchars)
self._texcoords[:nchars] = [self._char_to_texcoords[c] for c in text]
gl.glUniform2fv(self._uniform_locations['u_texcoords'], nchars,
self._texcoords)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
gl.glDisable(gl.GL_BLEND)
def GL_drawPath(self, x, y, mode=GL.GL_LINE_STRIP):
points = np.empty((len(x), 2))
points[:, 0] = x
points[:, 1] = y
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
try:
GL.glVertexPointerf(points)
if mode in (GL.GL_LINES, GL.GL_LINE_STRIP, GL.GL_LINE_LOOP):
GL.glEnable(GL.GL_LINE_SMOOTH)
GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
color = self.pen.color()
GL.glLineWidth(self.pen.width())
elif mode == GL.GL_TRIANGLE_FAN:
color = self.brush.color()
GL.glColor3f(color.red() / 255,
color.green() / 255,
color.blue() / 255)
GL.glDrawArrays(mode, 0, points.shape[0])
finally:
GL.glDisableClientState(GL.GL_VERTEX_ARRAY)
def on_display( ):
global shader
gl.glClearColor(1,1,1,1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
gl.glColor(0,0,0,1)
shader.bind()
radius = 255.0
theta, dtheta = 0, 5.5/180.0*math.pi
support = 0.75
thickness = 1.0
for i in range(500):
x = 256+radius*math.cos(theta);
y = 32+256+radius*math.sin(theta);
r = 10.1-i*0.02
circle( (x,y,r), thickness=thickness, support=support )
radius -= 0.45
theta += dtheta
for i in range(0,39):
r = 4
thickness = (i+1)/10.0
x = 20+i*12.5 - r
y = 16
circle( (x,y,r), thickness=thickness, support=support )
glut.glutSwapBuffers( )
def billboardLabel(self, objPos, character, offset, scale):
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glColor4f(self.textColour[0], self.textColour[1],
self.textColour[2], 1.0)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glPushMatrix()
GL.glTranslate(objPos[0], objPos[1], objPos[2])
modelview = (GL.GLfloat * 16)()
mvm = GL.glGetFloatv(GL.GL_MODELVIEW_MATRIX, modelview)
for i in (0, 1, 2):
for j in (0, 1, 2):
if i is j:
modelview[i * 4 + j] = 1
else:
modelview[i * 4 + j] = 0
GL.glLoadMatrixf(mvm)
GL.glScalef(scale, scale, scale)
GL.glTranslate(offset, 0, 0)
GL.glCallList(self.fonts[character])
GL.glPopMatrix()
GL.glDisable(GL.GL_TEXTURE_2D)
GL.glDisable(GL.GL_BLEND)
def initialize_scene():
return
gl.glClearColor(0, 1, 1, 1)
gl.glColor3f(1, 1, 1)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
def paintGL(self):
"""Paint the scene.
"""
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glEnable(gl.GL_POINT_SMOOTH)
gl.glPointSize(10)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
#bind the color buffer
self.glcolbuf.bind()
gl.glColorPointer(4, gl.GL_FLOAT, 0, None)
# bind the VBO
self.glbuf.bind()
# these vertices contain 2 simple precision coordinates
gl.glVertexPointer(2, gl.GL_FLOAT, 0, None)
# tell OpenGL that the VBO contains an array of vertices
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
# draw "count" points from the VBO
gl.glDrawArrays(gl.GL_POINTS, 0, self.color_count)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glDisable(gl.GL_BLEND)
def drawGrid(self):
#draw grid
# line smooth and alpha blending of the lines
if self.bsmooth:
GL.glEnable(GL.GL_LINE_SMOOTH)
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)
GL.glBegin(GL.GL_LINES)
xr = 200.0
zr = 200.0
dx = 10.0
dz = 10.0
xval = np.arange(-0.5 * xr, +0.5 * xr + dx * 0.001, dx)
zval = np.arange(
self.center_mass[self.lasti0 % self.nbframes] - 0.5 * zr,
self.center_mass[self.lasti0 % self.nbframes] + 0.5 * zr +
dz * 0.001, dz)
GL.glColor4f(1.0, 1.0, 1.0, 0.3)
for x in xval:
GL.glVertex3f(zval[0], 0.0, x)
GL.glVertex3f(zval[-1], 0.0, x)
for z in zval:
GL.glVertex3f(z, 0.0, xval[0])
GL.glVertex3f(z, 0.0, xval[-1])
GL.glEnd()
def _draw_selection_box(self):
""" The drawing method for the selection box. Initially we will draw the
box boundaries with lines, and then fill the interior with two
triangles.
IMPORTANT!!!
THIS FUNCTION MUST BE CALLED ONLY WHEN AN OPENGL CONTEXT WINDOW HAS
BEEN CREATED AND INITIALIZED, OTHERWISE WILL RAISE AN ERROR IN THE
OPENGL WRAPPER!!!
YOU HAVE BEEN WARNED
"""
GL.glUseProgram(self.selection_box_program)
GL.glLineWidth(1)
GL.glBindVertexArray(self.vao)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.buffers[1])
GL.glBufferData(GL.GL_ARRAY_BUFFER, self.points.itemsize*int(len(self.points)), self.points, GL.GL_DYNAMIC_DRAW)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.buffers[0])
GL.glBufferData(GL.GL_ARRAY_BUFFER, self.indexes.itemsize*int(len(self.indexes)), self.indexes, GL.GL_DYNAMIC_DRAW)
GL.glDrawElements(GL.GL_LINE_STRIP, int(len(self.indexes)), GL.GL_UNSIGNED_INT, None)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_SRC_ALPHA)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.buffers[0])
GL.glBufferData(GL.GL_ARRAY_BUFFER, self.triangles.itemsize*int(len(self.triangles)), self.triangles, GL.GL_DYNAMIC_DRAW)
GL.glDrawElements(GL.GL_TRIANGLE_STRIP, int(len(self.triangles)), GL.GL_UNSIGNED_INT, None)
GL.glDisable(GL.GL_BLEND)
GL.glDisable(GL.GL_DEPTH_TEST)
GL.glBindVertexArray(0)
GL.glUseProgram(0)
return True
def initializeGL(self):
"""Initialize OpenGL, VBOs, upload data on the GPU, etc."""
# First check for supported GL version
gl_version = float(gl.glGetString(gl.GL_VERSION)[:3])
if gl_version < 3.3:
return
# background color
gl.glClearColor(0, 0, 0, 0)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# self.mcp_data = mcpUBO()
self.globaldata = ndUBO()
self.mcp_col_shader = BlueSkyProgram('mcp.vert', 'color.frag')
self.mcp_tex_shader = BlueSkyProgram('mcp.vert', 'texture.frag')
self.mcp_txt_shader = BlueSkyProgram('mcp_text.vert', 'mcp_text.frag')
self.color_shader = BlueSkyProgram('normal.vert', 'color.frag')
self.text_shader = BlueSkyProgram('text.vert', 'text.frag')
self.text_shader.bind_uniform_buffer('global_data', self.globaldata)
self.create_objects()
self.update_lcd()
def quad(self, g, quad):
# Enable alpha blending/transparency
self.vbuffer.sync()
gl.glUseProgram(self.program.id)
gl.glEnable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# Bind texture
gl.glUniform1i(self.program.tex, 0)
gl.glBindTexture(gl.GL_TEXTURE_2D, quad.texture.id)
# Set up geometry transforms
worldMatrix = Matrix.scale(quad.width, quad.height, 1)
worldMatrix = Matrix.translate(quad.x, quad.y, 0) * worldMatrix
worldViewProjectionMatrix = g.viewProjectionMatrix * worldMatrix
#worldViewProjectionMatrix = g.viewProjectionMatrix
gl.glUniformMatrix4fv(self.program.worldViewProjectionMatrix, 1, 0,
worldViewProjectionMatrix.data)
# Draw geometry
gl.glBindVertexArray(self.vao)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
gl.glBindVertexArray(0)
def __init__(self, joints_3d, skeleton):
super().__init__('Pose viewer', 1600, 900, msaa=4)
# Enable alpha blending.
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# Enable back-face culling.
gl.glEnable(gl.GL_CULL_FACE)
gl.glCullFace(gl.GL_BACK)
# Enable depth test.
gl.glEnable(gl.GL_DEPTH_TEST)
self.shader = create_simple_shader()
self.trans_mats_binding = UniformBinding('transformMatrices', [
('viewMatrix', np.float32, (4, 4)),
('projMatrix', np.float32, (4, 4)),
])
self.trans_mats_binding.bind_program(self.shader)
self.trans_mats_ubo = self.trans_mats_binding.create_ubo(bind=True)
self.trans_mats_ubo['viewMatrix'] = np.eye(4)
self.trans_mats_ubo['projMatrix'] = np.eye(4)
self.reset_free_camera()
self.skeleton = skeleton
self.bones = self.pose_to_bones(joints_3d)
self.origin = joints_3d[skeleton.root_joint_id]
def draw(self):
gl.glEnable( gl.GL_TEXTURE_2D )
gl.glDisable( gl.GL_DEPTH_TEST )
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(3, gl.GL_FLOAT, 0, self.vertices)
gl.glColorPointer(4, gl.GL_FLOAT, 0, self.colors)
gl.glTexCoordPointer(2, gl.GL_FLOAT, 0, self.texcoords)
r,g,b = 0,0,0
gl.glColor( 1, 1, 1, 1 )
gl.glEnable( gl.GL_BLEND )
#gl.glBlendFunc( gl.GL_CONSTANT_COLOR_EXT, gl.GL_ONE_MINUS_SRC_COLOR )
#gl.glBlendColor(r,g,b,1)
gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA )
gl.glBlendColor( 1, 1, 1, 1 )
gl.glEnableVertexAttribArray( 1 );
gl.glVertexAttribPointer( 1, 1, gl.GL_FLOAT, gl.GL_FALSE, 0, self.attrib)
shader.bind()
shader.uniformi('texture', 0)
shader.uniformf('pixel', 1.0/512, 1.0/512)
gl.glDrawElements(gl.GL_TRIANGLES, len(self.indices),
gl.GL_UNSIGNED_INT, self.indices)
shader.unbind()
gl.glDisableVertexAttribArray( 1 );
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glDisable( gl.GL_TEXTURE_2D )
gl.glDisable( gl.GL_BLEND )
def display(self):
"""(Re)display all the actors in the scene.
This should e.g. be used when actors are added to the scene,
or after changing camera position/orientation or lens.
"""
#GD.debugt("UPDATING CURRENT OPENGL CANVAS")
self.makeCurrent()
self.clear()
self.glLight(self.lighting)
# draw the highlighted actors
self.camera.loadProjection()
self.camera.loadMatrix()
if self.highlights:
for actor in self.highlights:
actor.draw(mode=self.rendermode)
# draw the scene actors
if self.alphablend:
opaque = [ a for a in self.actors if not a.trans ]
transp = [ a for a in self.actors if a.trans ]
for actor in opaque:
actor.draw(mode=self.rendermode)
GL.glEnable (GL.GL_BLEND)
GL.glDepthMask (GL.GL_FALSE)
GL.glBlendFunc (GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
for actor in transp:
actor.draw(mode=self.rendermode)
GL.glDepthMask (GL.GL_TRUE)
GL.glDisable (GL.GL_BLEND)
else:
for actor in self.actors:
self.setDefaults()
actor.draw(mode=self.rendermode)
# annotations are drawn in 3D space
for actor in self.annotations:
self.setDefaults()
actor.draw(mode=self.rendermode)
# decorations are drawn in 2D mode
self.begin_2D_drawing()
if len(self.decorations) > 0:
for actor in self.decorations:
self.setDefaults()
actor.draw(mode=self.rendermode)
# draw the focus rectangle if more than one viewport
if len(GD.GUI.viewports.all) > 1:
if self.hasFocus():
self.draw_focus_rectangle(2)
elif self.focus:
self.draw_focus_rectangle(1)
self.end_2D_drawing()
# make sure canvas is updated
GL.glFlush()
def renderNeckMethod(self, visibility, offset, neck, alpha = False): #blazingamer: New neck rendering method
v = visibility
gl.glEnable(gl.GL_TEXTURE_2D)
if offset == 0:
board_tex = self.board_tex_static
else:
board_tex = self.board_tex
if self.failcount == v:
board_col = self.board_col_flash
else:
board_col = self.board_col
if alpha == True:
gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE)
if neck:
neck.texture.bind()
cmgl.drawArrays(gl.GL_TRIANGLE_STRIP, vertices=self.board_vtx, colors=board_col, texcoords=board_tex)
if alpha == True:
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glDisable(gl.GL_TEXTURE_2D)
def draw_line(self, start_x, start_y, end_x, end_y,
color=(1.0, 1.0, 1.0, 1.0),
width=None):
"""Draw a line on canvas."""
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glColor4f(*color)
prev_width = None
if width is not None:
prev_width = gl.glGetFloat(gl.GL_LINE_WIDTH)
gl.glLineWidth(width)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_DONT_CARE)
gl.glBegin(gl.GL_LINES)
gl.glVertex2f(start_x, start_y)
gl.glVertex2f(end_x, end_y)
gl.glEnd()
gl.glDisable(gl.GL_BLEND)
if prev_width is not None:
gl.glLineWidth(prev_width)
def display(self):
"""Draw surface to a quad. Call as part of OpenGL rendering code."""
ogl.glEnable(ogl.GL_BLEND)
ogl.glBlendFunc(ogl.GL_SRC_ALPHA, ogl.GL_ONE_MINUS_SRC_ALPHA)
ogl.glEnable(ogl.GL_TEXTURE_2D)
ogl.glBindTexture(ogl.GL_TEXTURE_2D, self._txtr)
ogl.glTexEnvf(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_MODE,
ogl.GL_REPLACE)
#ogl.glColor4d( 1.0, 1.0, 1.0, alpha )
#ogl.glTexEnvf(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_MODE, ogl.GL_MODULATE)
#glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
#ogl.glTexEnvfv(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_COLOR, (0, 0, 0, alpha))
#ogl.glNormal3f(0.0, 0.0, -1.0)
ogl.glBegin(ogl.GL_QUADS)
ogl.glTexCoord2f(0.0, 1 - self._usable[1])
# bottom left corner
ogl.glVertex3f(*self.dims[0])
ogl.glTexCoord2f(self._usable[0], 1 - self._usable[1])
# bottom right corner
ogl.glVertex3f(self.dims[1][0], self.dims[1][1], 0.0)
ogl.glTexCoord2f(self._usable[0], 1.0)
# top right corner
ogl.glVertex3f(*self.dims[2])
ogl.glTexCoord2f(0.0, 1.0)
# top left corner
ogl.glVertex3f(*self.dims[3])
ogl.glEnd()
ogl.glDisable(ogl.GL_BLEND)
ogl.glDisable(ogl.GL_TEXTURE_2D)
def render(self, visibility):
"""
Render the layer.
@param visibility: Floating point visibility factor (1 = opaque, 0 = invisibile)
"""
w, h = self.stage.engine.view.geometry[2:4]
v = 1.0 - visibility ** 2
color = self.color
#coordinates are positioned with (0,0) being in the middle of the screen
coord = [w/2 + self.position[0] * w/2, h/2 - self.position[1] * h/2]
if v > .01:
color = [self.color[0], self.color[1], self.color[2], visibility]
scale = [self.scale[0], -self.scale[1]]
rot = self.angle
self.transforms = [scale, coord, rot, color]
# Blend in all the effects
for effect in self.effects:
effect.apply()
gl.glBlendFunc(self.srcBlending, self.dstBlending)
drawImage(self.drawing, self.transforms[0], self.transforms[1],
self.transforms[2], self.transforms[3])
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def on_display():
global shader
gl.glClearColor(1, 1, 1, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
radius = 255.0
theta, dtheta = 0, 5.5 / 180.0 * math.pi
thickness = 1.0
support = .75
for i in range(500):
xc, yc = 256, 256 + 32
r = 10.1 - i * 0.02
thickness = 1.0 #0.1 + (1.0-i/500.0)*4
x0 = xc + np.cos(theta) * radius * .925
y0 = yc + np.sin(theta) * radius * .925
x1 = xc + np.cos(theta) * radius * 1.00
y1 = yc + np.sin(theta) * radius * 1.00
line((x0, y0), (x1, y1), thickness, support)
radius -= 0.45
theta += dtheta
for i in range(0, 49):
thickness = (i + 1) / 10.0
x = 20 + i * 10 + .315
y = 16 + .315
line((x, y + 6), (x, y - 6), thickness, support)
glut.glutSwapBuffers()
def InitialiseOpenGL( self, width, height ) : # Initialise the trackball self.trackball = mtk.Trackball() self.trackball.Initialise( width, height ) # Default background color gl.glClearColor( 1, 1, 1, 1 ) # Enable depth test gl.glEnable( gl.GL_DEPTH_TEST ) # Enable face culling gl.glEnable( gl.GL_CULL_FACE ) # Enable blending function gl.glEnable( gl.GL_BLEND ) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) # Enable multisampling (antialiasing) gl.glEnable( gl.GL_MULTISAMPLE ) # Initialise the projection transformation matrix self.SetProjectionMatrix( width, height ) # Initialise Model-View transformation matrix self.modelview_matrix = np.identity( 4, dtype=np.float32 ) # Position the scene (camera) self.modelview_matrix[3,2] = -30.0 # Load the shaders self.flat_shader = mtk.FlatShader() self.smooth_shader = mtk.SmoothShader() self.shader = self.smooth_shader # Initialise viewing parameters self.wireframe_mode = 0 self.element_number = 0 self.color_enabled = False self.antialiasing = True
def drawSphere(self) : if self._indexes is None : return GL.glDisable(GL.GL_CULL_FACE) # GL.glEnable(GL.GL_LIGHTING) # GL.glScale(1,1,1) # GL.glDisable(GL.GL_LIGHTING) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnableClientState( GL.GL_VERTEX_ARRAY ) GL.glEnableClientState( GL.GL_COLOR_ARRAY ) GL.glEnableClientState( GL.GL_NORMAL_ARRAY ) GL.glColorPointer( 4, GL.GL_FLOAT, 0, self._meshColors) GL.glVertexPointer( 3, GL.GL_FLOAT, 0, self._vertices ) GL.glNormalPointer( GL.GL_FLOAT, 0, self._normals ) GL.glDrawElements( GL.GL_TRIANGLE_STRIP, len(self._indexes), GL.GL_UNSIGNED_INT, self._indexes ) GL.glDisableClientState( GL.GL_COLOR_ARRAY ) GL.glColor(0.6,.3,.6) GL.glDrawElements( GL.GL_POINTS, len(self._indexes), GL.GL_UNSIGNED_INT, self._indexes ) GL.glDisableClientState( GL.GL_COLOR_ARRAY ) GL.glDisableClientState( GL.GL_VERTEX_ARRAY ) GL.glDisableClientState( GL.GL_NORMAL_ARRAY )
def initializeGL(self):
"""Initialize OpenGL, VBOs, upload data on the GPU, etc."""
# First check for supported GL version
gl_version = float(gl.glGetString(gl.GL_VERSION)[:3])
if gl_version < 3.3:
return
# background color
gl.glClearColor(0, 0, 0, 0)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
self.globaldata = ndUBO()
try:
# Compile shaders and link color shader program
self.color_shader = BlueSkyProgram('data/graphics/shaders/nd-normal.vert', 'data/graphics/shaders/nd-color.frag')
self.color_shader.bind_uniform_buffer('global_data', self.globaldata)
# Compile shaders and link text shader program
self.text_shader = BlueSkyProgram('data/graphics/shaders/nd-text.vert', 'data/graphics/shaders/nd-text.frag')
self.text_shader.bind_uniform_buffer('global_data', self.globaldata)
except RuntimeError as e:
qCritical('Error compiling shaders in radarwidget: ' + e.args[0])
return
# Set initial zoom
self.globaldata.set_zoom(4.0)
self.create_objects()
def _draw_point_label(self): """ Draw the point label for the last mouse motion coordinate. The mouse coordinate must be an X, Y tuple. The label will be drawn at the X, Y coordinate. The values of the X, Y coordinate will be scaled to the current X, Y bounds. """ if not self.enable_point_label(): return if not self._point_label_coordinate: return x, y = self._point_label_coordinate if x < self.padding_left or x > self.width-self.padding_right: return if y < self.padding_top or y > self.height-self.padding_bottom: return #scale to window bounds x_win_scalar = float(x - self.padding_left)/(self.width-self.padding_left-self.padding_right) y_win_scalar = float((self.height - y) - self.padding_bottom)/(self.height-self.padding_top-self.padding_bottom) #scale to grid bounds x_val = x_win_scalar*(self.x_max-self.x_min) + self.x_min y_val = y_win_scalar*(self.y_max-self.y_min) + self.y_min #create text label_str = self._populate_point_label(x_val, y_val) if not label_str: return txt = gltext.Text(label_str, font_size=POINT_LABEL_FONT_SIZE) w, h = txt.get_size() #enable transparency GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) #draw rect + text GL.glColor4f(*POINT_LABEL_COLOR_SPEC) if x > self.width/2: x -= w+2*POINT_LABEL_PADDING + POINT_LABEL_OFFSET else: x += POINT_LABEL_OFFSET self._draw_rect(x, y-h-2*POINT_LABEL_PADDING, w+2*POINT_LABEL_PADDING, h+2*POINT_LABEL_PADDING) txt.draw_text(wx.Point(x+POINT_LABEL_PADDING, y-h-POINT_LABEL_PADDING))
def display(self):
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glClearColor(*self.BACKGROUND)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
glu.gluLookAt(-0.75 * self.size, -0.75 * self.size, 1.75 * self.size,
0.5 * self.size, 0.5 * self.size, 0.5 * self.size, 0, 0,
1)
# We want to rotate about the centre of the cube, so
# shift, rotate, shift back
gl.glTranslate(self.size / 2.0, self.size / 2.0, self.size / 2.0)
gl.glRotatef(self.rx, 1, 0, 0)
gl.glRotatef(self.ry, 0, 1, 0)
gl.glRotatef(self.rz, 0, 0, 1)
gl.glTranslate(-self.size / 2.0, -self.size / 2.0, -self.size / 2.0)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glVertexPointerf(self.verts)
gl.glColorPointerf(self.colours)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, len(self.verts))
self._render_floor()
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
def drawCharacterHead(self, x, y, z, realCoords=None, dim=0):
GL.glEnable(GL.GL_CULL_FACE)
origin = (x - 0.25, y - 0.25, z - 0.25)
size = (0.5, 0.5, 0.5)
box = FloatBox(origin, size)
hat_origin = (x - 0.275, y - 0.275, z - 0.275)
hat_size = (0.55, 0.55, 0.55)
hat_box = FloatBox(hat_origin, hat_size)
if realCoords is not None and self.playerPos[dim][
realCoords] != "Player" and config.settings.downloadPlayerSkins.get(
):
drawCube(
box,
texture=self.playerTexture[self.playerPos[dim][realCoords]],
textureVertices=self.texVerts[0])
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
drawCube(
hat_box,
texture=self.playerTexture[self.playerPos[dim][realCoords]],
textureVertices=self.texVerts[1])
GL.glDisable(GL.GL_BLEND)
else:
drawCube(box,
texture=self.charTex,
textureVertices=self.texVerts[0])
GL.glDisable(GL.GL_CULL_FACE)
def initializeGL(self): # , width=1, height=1
""" Initialization of the GL frame. """
# TODO: glOrtho should set to size of the frame which would allow using
# TODO: absolute coordinates in range/domain of original frame
GL.glClearColor(0.0, 0.0, 0.0, 1.0)
GL.glClearDepth(1.0)
GL.glOrtho(0, 1, 1, 0, -1, 1)
#glOrtho(0, width, height, 0, -1, 1) # DOESN'T WORK!!
GL.glMatrixMode(GL.GL_PROJECTION)
# Enable rational alpha blending
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
if self.anti_aliasing:
# Points
GL.glEnable(GL.GL_POINT_SMOOTH)
GL.glHint(GL.GL_POINT_SMOOTH_HINT, GL.GL_NICEST)
# Lines
GL.glEnable(GL.GL_LINE_SMOOTH)
GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)
# Polygons, but NOT GL_TRIANGLE_FAN
GL.glEnable(GL.GL_POLYGON_SMOOTH)
GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)
# Not sure...
GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST)
def draw_grid(self,):
gl.glUseProgram(self.simple_object_shader)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LESS)
gl.glBindVertexArray(self.grid_vao)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.grid_vbo)
vProjection = gl.glGetUniformLocation(self.simple_object_shader, 'vProjection')
vPosisition = gl.glGetAttribLocation(self.simple_object_shader, "vPosisition")
vColor = gl.glGetAttribLocation(self.simple_object_shader, "vColor")
vCamera = gl.glGetUniformLocation(self.simple_object_shader, 'vCamera')
gl.glUniformMatrix4fv(vProjection, 1, gl.GL_FALSE, self.projection_matrix_function())
gl.glUniformMatrix4fv(vCamera, 1, gl.GL_FALSE, self.camera_matrix_function())
gl.glEnableVertexAttribArray(vPosisition)
gl.glEnableVertexAttribArray(vColor)
gl.glVertexAttribPointer(vPosisition, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
gl.glVertexAttribPointer(vColor, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, ctypes.c_void_p(self.grid_size * 4))
gl.glDrawArrays(gl.GL_TRIANGLES, 0, self.grid_size / 4)
