def setupLight(self, light, n, pos): l = light.techniqueCommon glEnable(GL_LIGHTING) glEnable(GL_LIGHT0 + n) glLightfv(GL_LIGHT0 + n, GL_POSITION, (pos[0], pos[1], pos[2], 0.0)) glLightfv(GL_LIGHT0 + n, GL_DIFFUSE, (l.color[0], l.color[1], l.color[2], 0.0)) glLightfv(GL_LIGHT0 + n, GL_AMBIENT, (0.0, 0.0, 0.0, 0.0))
def renderIncomingNeck(self, visibility, song, pos, time, neckTexture): #MFH - attempt to "scroll" an incoming guitar solo neck towards the player
if not song:
return
if not song.readyToGo:
return
def project(beat):
return 0.125 * beat / self.beatsPerUnit # glorandwarf: was 0.12
v = visibility
w = self.boardWidth
l = self.boardLength
#offset = (pos - self.lastBpmChange) / self.currentPeriod + self.baseBeat
offset = 0
z = ((time - pos) / self.currentPeriod) / self.beatsPerUnit
color = (1,1,1)
glEnable(GL_TEXTURE_2D)
if neckTexture:
neckTexture.texture.bind()
glBegin(GL_TRIANGLE_STRIP)
glColor4f(color[0],color[1],color[2], 0)
glTexCoord2f(0.0, project(offset - 2 * self.beatsPerUnit))
#glVertex3f(-w / 2, 0, -2)
glVertex3f(-w / 2, 0, z) #point A
glTexCoord2f(1.0, project(offset - 2 * self.beatsPerUnit))
#glVertex3f( w / 2, 0, -2)
glVertex3f( w / 2, 0, z) #point B
glColor4f(color[0],color[1],color[2], v)
glTexCoord2f(0.0, project(offset - 1 * self.beatsPerUnit))
#glVertex3f(-w / 2, 0, -1)
glVertex3f(-w / 2, 0, z+1) #point C
glTexCoord2f(1.0, project(offset - 1 * self.beatsPerUnit))
#glVertex3f( w / 2, 0, -1)
glVertex3f( w / 2, 0, z+1) #point D
glTexCoord2f(0.0, project(offset + l * self.beatsPerUnit * .7))
#glVertex3f(-w / 2, 0, l * .7)
glVertex3f(-w / 2, 0, z+2+l * .7) #point E
glTexCoord2f(1.0, project(offset + l * self.beatsPerUnit * .7))
#glVertex3f( w / 2, 0, l * .7)
glVertex3f( w / 2, 0, z+2+l * .7) #point F
glColor4f(color[0],color[1],color[2], 0)
glTexCoord2f(0.0, project(offset + l * self.beatsPerUnit))
#glVertex3f(-w / 2, 0, l)
glVertex3f(-w / 2, 0, z+2+l) #point G
glTexCoord2f(1.0, project(offset + l * self.beatsPerUnit))
#glVertex3f( w / 2, 0, l)
glVertex3f( w / 2, 0, z+2+l) #point H
glEnd()
glDisable(GL_TEXTURE_2D)
def drawBPM(self, visibility, song, pos):
if not song:
return
if not song.readyToGo:
return
v = visibility
w = self.boardWidth
track = song.track[self.player]
glEnable(GL_TEXTURE_2D)
for time, event in track.getEvents(pos - self.currentPeriod * 2, pos + self.currentPeriod * self.beatsPerBoard):
if not isinstance(event, Bars):
continue
glPushMatrix()
z = ((time - pos) / self.currentPeriod) / self.beatsPerUnit
z2 = ((time + event.length - pos) / self.currentPeriod) / self.beatsPerUnit
if z > self.boardLength:
f = (self.boardLength - z) / (self.boardLength * .2)
elif z < 0:
f = min(1, max(0, 1 + z2))
else:
f = 1.0
if event.barType == 0: #half-beat
sw = 0.1 #width
self.bpm_halfbeat.texture.bind()
elif event.barType == 1: #beat
sw = 0.1 #width
self.bpm_beat.texture.bind()
elif event.barType == 2: #measure
sw = 0.1 #width
self.bpm_measure.texture.bind()
bpm_vtx = array([[-(w / 2), 0, z + sw],
[-(w / 2), 0, z - sw],
[(w / 2), 0, z + sw],
[(w / 2), 0, z - sw]], dtype=float32)
bpm_tex = array([[0.0, 1.0],
[0.0, 0.0],
[1.0, 1.0],
[1.0, 0.0]], dtype=float32)
bpm_col = array([[1, 1, 1, v],
[1, 1, 1, v],
[1, 1, 1, v],
[1, 1, 1, v]], dtype=float32)
cmglDrawArrays(GL_TRIANGLE_STRIP, vertices=bpm_vtx, colors=bpm_col, texcoords=bpm_tex)
glPopMatrix()
glDisable(GL_TEXTURE_2D)
def __init_openGL(self):
glShadeModel(GL_SMOOTH)
glClearColor(0, 0, 0, 0)
glClearDepth(1)
glEnable(GL_DEPTH_TEST)
glEnable(GL_TEXTURE_2D)
glDepthFunc(GL_LEQUAL)
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
def drawSideBars(self, visibility, song, pos):
if not song:
return
if not song.readyToGo:
return
def project(beat):
return 0.125 * beat / self.beatsPerUnit # glorandwarf: was 0.12
v = visibility
w = self.boardWidth + 0.15
l = self.boardLength
offset = (pos - self.lastBpmChange) / self.currentPeriod + self.baseBeat
c = (1,1,1)
board_tex = array([[0.0, project(offset - 2 * self.beatsPerUnit)],
[1.0, project(offset - 2 * self.beatsPerUnit)],
[0.0, project(offset - 1 * self.beatsPerUnit)],
[1.0, project(offset - 1 * self.beatsPerUnit)],
[0.0, project(offset + l * self.beatsPerUnit * .7)],
[1.0, project(offset + l * self.beatsPerUnit * .7)],
[0.0, project(offset + l * self.beatsPerUnit)],
[1.0, project(offset + l * self.beatsPerUnit)]], dtype=float32)
glEnable(GL_TEXTURE_2D)
if self.theme == 2 and self.instrument.starPowerActive and self.oSideBars:
self.oSideBars.texture.bind()
else:
self.sideBars.texture.bind()
cmglDrawArrays(GL_TRIANGLE_STRIP, vertices=self.sidebars_vtx, colors=self.board_col, texcoords=board_tex)
glDisable(GL_TEXTURE_2D)
if self.theme == 1:
if shaders.enable("sololight"):
shaders.modVar("color",shaders.var["solocolor"])
shaders.setVar("offset",(-3.5,-w/2))
glBegin(GL_TRIANGLE_STRIP)
glVertex3f(w / 2-1.0, 0.4, -2)
glVertex3f(w / 2+1.0, 0.4, -2)
glVertex3f(w / 2-1.0, 0.4, l)
glVertex3f(w / 2+1.0, 0.4, l)
glEnd()
shaders.setVar("offset",(-3.5,w/2))
shaders.setVar("time",shaders.time()+0.5)
glBegin(GL_TRIANGLE_STRIP)
glVertex3f(-w / 2+1.0, 0.4, -2)
glVertex3f(-w / 2-1.0, 0.4, -2)
glVertex3f(-w / 2+1.0, 0.4, l)
glVertex3f(-w / 2-1.0, 0.4, l)
glEnd()
shaders.disable()
def renderNeckMethod(self, visibility, offset, neck, alpha = False): #blazingamer: New neck rendering method
def project(beat):
return 0.125 * beat / self.beatsPerUnit # glorandwarf: was 0.12
if self.instrument.starPowerActive and self.theme == 0:#8bit
color = self.engine.theme.spNoteColor #self.spColor #(.3,.7,.9)
elif self.instrument.starPowerActive and self.theme == 1:
color = self.engine.theme.spNoteColor #self.spColor #(.3,.7,.9)
else:
color = (1,1,1)
v = visibility
l = self.boardLength
glEnable(GL_TEXTURE_2D)
board_tex = array([[0.0, project(offset - 2 * self.beatsPerUnit)],
[1.0, project(offset - 2 * self.beatsPerUnit)],
[0.0, project(offset - 1 * self.beatsPerUnit)],
[1.0, project(offset - 1 * self.beatsPerUnit)],
[0.0, project(offset + l * self.beatsPerUnit * .7)],
[1.0, project(offset + l * self.beatsPerUnit * .7)],
[0.0, project(offset + l * self.beatsPerUnit)],
[1.0, project(offset + l * self.beatsPerUnit)]], dtype=float32)
#must be seperate for neck flashing.
board_col = array([[color[0],color[1],color[2], 0],
[color[0],color[1],color[2], 0],
[color[0],color[1],color[2], v],
[color[0],color[1],color[2], v],
[color[0],color[1],color[2], v],
[color[0],color[1],color[2], v],
[color[0],color[1],color[2], 0],
[color[0],color[1],color[2], 0]], dtype=float32)
if alpha == True:
glBlendFunc(GL_ONE, GL_ONE)
neck.texture.bind()
cmglDrawArrays(GL_TRIANGLE_STRIP, vertices=self.board_vtx, colors=board_col, texcoords=board_tex)
if alpha == True:
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glDisable(GL_TEXTURE_2D)
def draw(self, color = (1, 1, 1, 1), rect = (0,1,0,1), lOffset = 0.0, rOffset = 0.0):
with cmglPushedSpecificMatrix(GL_TEXTURE):
with cmglPushedSpecificMatrix(GL_PROJECTION):
with cmglMatrixMode(GL_PROJECTION):
self.context.setProjection()
with cmglPushedMatrix():
glLoadIdentity()
self._getEffectiveTransform().applyGL()
glScalef(self.texture.pixelSize[0], self.texture.pixelSize[1], 1)
glTranslatef(-.5, -.5, 0)
glColor4f(*color)
glEnable(GL_TEXTURE_2D)
self.texture.bind()
self.triangVtx[0,0] = 0.0-lOffset
self.triangVtx[0,1] = 1.0
self.triangVtx[1,0] = 1.0-rOffset
self.triangVtx[1,1] = 1.0
self.triangVtx[2,0] = 0.0+lOffset
self.triangVtx[2,1] = 0.0
self.triangVtx[3,0] = 1.0+rOffset
self.triangVtx[3,1] = 0.0
self.textriangVtx[0,0] = rect[0]
self.textriangVtx[0,1] = rect[3]
self.textriangVtx[1,0] = rect[1]
self.textriangVtx[1,1] = rect[3]
self.textriangVtx[2,0] = rect[0]
self.textriangVtx[2,1] = rect[2]
self.textriangVtx[3,0] = rect[1]
self.textriangVtx[3,1] = rect[2]
cmglDrawArrays(GL_TRIANGLE_STRIP, vertices=self.triangVtx, texcoords=self.textriangVtx)
glDisable(GL_TEXTURE_2D)
def render(self, visibility, topMost):
#MFH - display version in any menu:
if not visibility:
self.active = False
return
self.active = True
if self.graphicMenu and self.menuBackground:
self.engine.graphicMenuShown = True
else:
self.engine.graphicMenuShown = False
self.engine.view.setOrthogonalProjection(normalize = True)
try:
v = (1 - visibility) ** 2
# Default to this font if none was specified
font = self.font
tipFont = self.tipFont
if self.fadeScreen:
Dialogs.fadeScreen(v)
wS, hS = self.engine.view.geometry[2:4]
if self.graphicMenu and self.menuBackground:
#volshebnyi - better menu scaling
self.engine.drawImage(self.menuBackground, scale = (1.0,-1.0), coord = (wS/2,hS/2), stretched = 3)
else:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
n = len(self.choices)
x, y = self.pos
for i, choice in enumerate(self.choices[self.viewOffset:self.viewOffset + self.viewSize]):
if self.graphicMenu:
if self.currentIndex == i:
xpos = (.5,1)
else:
xpos = (0,.5)
ypos = float(i+self.viewOffset)
self.menuText.transform.reset()
self.menuText.transform.scale(.5*self.menuScale,(-1.0/n*self.menuScale))
self.menuText.transform.translate(wS*self.menux,(hS*self.menuy)-(hS*self.vSpace)*i)
self.menuText.draw(rect = (xpos[0],xpos[1],ypos/n,(ypos+1.0)/n))
#self.engine.drawImage(self.menuText, scale = (self.menuScale,-self.menuScale*2/n), coord = (wS*self.menux,hS*(self.menuy-self.vSpace*i)), rect = (xpos[0],xpos[1],ypos/n,(ypos+1.0)/n), stretched = 11)
else:
text = choice.getText(i + self.viewOffset == self.currentIndex)
glPushMatrix()
glRotate(v * 45, 0, 0, 1)
scale = 0.002
if self.mainMenu and self.theme < 2 and i % 2 == 1:#8bit
scale = 0.0016
w, h = font.getStringSize(" ", scale = scale)
# Draw arrows if scrolling is needed to see all items
if i == 0 and self.viewOffset > 0:
self.engine.theme.setBaseColor((1 - v) * max(.1, 1 - (1.0 / self.viewOffset) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up = (0, -1), s = .015)
glPopMatrix()
elif i == self.viewSize - 1 and self.viewOffset + self.viewSize < n:
self.engine.theme.setBaseColor((1 - v) * max(.1, 1 - (1.0 / (n - self.viewOffset - self.viewSize)) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up = (0, 1), s = .015)
glPopMatrix()
if i + self.viewOffset == self.currentIndex:
if choice.tipText and self.showTips:
if self.tipColor:
c1, c2, c3 = self.tipColor
glColor3f(c1,c2,c3)
elif self.textColor:
c1, c2, c3 = self.textColor
glColor3f(c1,c2,c3)
else:
self.engine.theme.setBaseColor(1-v)
tipScale = self.tipScale
if self.tipScroll > -(self.tipSize) and self.tipScroll < 1:
tipFont.render(choice.tipText, (self.tipScroll, self.tipY), scale = tipScale)
if self.tipScrollMode == 0:
if self.tipScrollB > -(self.tipSize) and self.tipScrollB < 1:
tipFont.render(choice.tipText, (self.tipScrollB, self.tipY), scale = tipScale)
a = (math.sin(self.time) * .15 + .75) * (1 - v * 2)
self.engine.theme.setSelectedColor(a)
a *= -.005
glTranslatef(a, a, a)
else:
self.engine.theme.setBaseColor(1 - v)
#MFH - settable color through Menu constructor
if i + self.viewOffset == self.currentIndex and self.selectedColor:
c1,c2,c3 = self.selectedColor
glColor3f(c1,c2,c3)
elif self.textColor:
c1,c2,c3 = self.textColor
glColor3f(c1,c2,c3)
#MFH - now to catch " >" main menu options and blank them:
if text == " >":
text = ""
if self.engine.data.submenuSelectFound and len(text) > 0 and not self.mainMenu and self.useSelectedBox:
Tw, Th = font.getStringSize(text,scale)
lineSpacing = font.getLineSpacing(scale)
frameWidth = Tw*1.10
#frameHeight = (Th+Th2)*1.10
frameHeight = Th + lineSpacing
boxXOffset = (x + (Tw/2))*wS
boxYOffset = (1.0 - (y*4.0/3.0) - (Th*1.2/2))*hS
subSelectHYFactor = 640.000/self.engine.view.aspectRatio
subSelectHFactor = subSelectHYFactor/self.engine.data.subSelectImgH
self.engine.data.submenuSelect.transform.reset()
tempWScale = frameWidth*self.engine.data.subSelectWFactor
tempHScale = -(frameHeight)*subSelectHFactor
self.engine.data.submenuSelect.transform.scale(tempWScale,tempHScale)
self.engine.data.submenuSelect.transform.translate(boxXOffset,boxYOffset)
self.engine.data.submenuSelect.draw()
font.render(text, (x - v / 4, y), scale = scale)
v *= 2
if self.theme == 1 and self.font == self.engine.data.pauseFont: # evilynux - Ugly workaround for Gh3
y += h*.70 #Worldrave - Changed Pause menu spacing back to .70 from .65 for now.
else:
y += h
glPopMatrix()
finally:
self.engine.view.resetProjection()
def clear(self, r = 0, g = 0, b = 0, a = 0): glDepthMask(1) glEnable(GL_COLOR_MATERIAL) glClearColor(r, g, b, a) glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
def drawTrack(self, visibility, song, pos):
if not song:
return
if not song.readyToGo:
return
def project(beat):
return 0.125 * beat / self.beatsPerUnit # glorandwarf: was 0.12
if self.theme == 0 or self.theme == 1:
size = 2
else:
size = 0
v = visibility
w = self.boardWidth
l = self.boardLength
if self.staticStrings:
offset = 0
else:
offset = (pos - self.lastBpmChange) / self.currentPeriod + self.baseBeat
track_tex = array([[0.0, project(offset - 2 * self.beatsPerUnit)],
[1.0, project(offset - 2 * self.beatsPerUnit)],
[0.0, project(offset - 1 * self.beatsPerUnit)],
[1.0, project(offset - 1 * self.beatsPerUnit)],
[0.0, project(offset + l * self.beatsPerUnit * .7)],
[1.0, project(offset + l * self.beatsPerUnit * .7)],
[0.0, project(offset + l * self.beatsPerUnit)],
[1.0, project(offset + l * self.beatsPerUnit)]], dtype=float32)
glEnable(GL_TEXTURE_2D)
#MFH - logic to briefly display oFlash
if self.theme == 2 and self.overdriveFlashCount < self.overdriveFlashCounts and self.oFlash:
self.oFlash.texture.bind()
elif self.theme == 2 and self.instrument.starPowerActive and self.oCenterLines:
self.oCenterLines.texture.bind()
else:
self.centerLines.texture.bind()
track_vtx = array([[-w / 2, 0, -2+size],
[w / 2, 0, -2+size],
[-w / 2, 0, -1+size],
[w / 2, 0, -1+size],
[-w / 2, 0, l * .7],
[w / 2, 0, l * .7],
[-w / 2, 0, l],
[w / 2, 0, l]], dtype=float32)
if self.staticStrings: #MFH
color = (1,1,1)
track_col = array([[color[0],color[1],color[2], v],
[color[0],color[1],color[2], v],
[color[0],color[1],color[2], v],
[color[0],color[1],color[2], v],
[color[0],color[1],color[2], v],
[color[0],color[1],color[2], v],
[color[0],color[1],color[2], 0],
[color[0],color[1],color[2], 0]], dtype=float32)
cmglDrawArrays(GL_TRIANGLE_STRIP, vertices=track_vtx, colors=track_col, texcoords=track_tex)
else: #MFH: original moving strings
cmglDrawArrays(GL_TRIANGLE_STRIP, vertices=track_vtx, colors=self.board_col, texcoords=track_tex)
glDisable(GL_TEXTURE_2D)
def render(self, text, pos = (0, 0), rotate = 0, scale = DEFAULT_SCALE, shadowoffset = (.0022, .0005), align = LEFT, new = False):
"""
Draw some text.
@param text: Text to draw
@param pos: Text coordinate tuple (x, y)
@param rotate: Angle to rotate text, in degrees
@param scale: Scale factor
"""
# deufeufeu : new drawing relaying only on pygame.font.render
# : I know me miss special unicodes characters, but the gain
# : is really important.
# evilynux : Use arrays to increase performance
def drawSquare(w,h,tw,th):
self.square_prim[1,0] = self.square_prim[3,0] = w
self.square_prim[2,1] = self.square_prim[3,1] = h
self.square_tex[0,1] = self.square_tex[1,1] = th
self.square_tex[1,0] = self.square_tex[3,0] = tw
cmglDrawArrays(GL_TRIANGLE_STRIP, vertices=self.square_prim, texcoords=self.square_tex)
if not text:
return
try:
t,w,h = self.stringsCache.get(text)
except KeyError:
s = self.font.render(text, True, (255,255,255))
t = Texture()
t.setFilter(GL_LINEAR, GL_LINEAR)
t.setRepeat(GL_CLAMP, GL_CLAMP)
t.loadSurface(s, alphaChannel = True)
del s
w, h = self.font.size(text)
self.stringsCache.add(text,(t,w,h))
x, y = pos
scale *= self.scale
w, h = w*scale*self.aspectRatioFactor, h*scale
if align == CENTER: #we have already done all the calculating. Why not add this? - akedrou
x -= (w/2)
elif align == RIGHT:
x -= w
y -= (h/2)
tw,th = t.size
glEnable(GL_TEXTURE_2D)
with cmglPushedMatrix():
if rotate:
if not isinstance(rotate, tuple):
glRotatef(rotate, 0, 0, 1.0)
else:
glRotatef(0, *rotate)
glTranslatef(x,y,0)
t.bind()
if self.outline:
with cmglPushedAttrib(GL_CURRENT_BIT):
glColor4f(0, 0, 0, .25 * glGetDoublev(GL_CURRENT_COLOR)[3])
blur = 2 * DEFAULT_SCALE
for offset in [(-.7, -.7), (0, -1), (.7, -.7), (-1, 0),
(1, 0), (-.7, .7), (0, 1), (.7, .7)]:
with cmglPushedMatrix():
glTranslatef(blur * offset[0], blur * offset[1], 0)
drawSquare(w,h,tw,th)
if self.shadow:
with cmglPushedAttrib(GL_CURRENT_BIT):
glColor4f(0, 0, 0, 1)
with cmglPushedMatrix():
glTranslatef(shadowoffset[0], shadowoffset[1], 0)
drawSquare(w,h,tw,th)
drawSquare(w,h,tw,th)
glDisable(GL_TEXTURE_2D)
def textureSetup(self):
# Free memory if we already allocated space for textures.
if len(self.animTexs) > 0:
glDeleteTextures(self.animTexs)
self.animTexs = glGenTextures(len(self.animImgs))
for texIdx, img in enumerate(self.animImgs):
animSize = img.get_size()
if img.get_alpha is None:
color = "RGB"
colorGL = GL_RGB
else:
color = "RGBA"
colorGL = GL_RGBA
# Log.debug("AnimationPlayer: Image %d format: %s (%dx%d)" % (texIdx, color, animSize[0], animSize[1]))
glBindTexture(GL_TEXTURE_2D, self.animTexs[texIdx])
surfaceData = pygame.image.tostring(img, color, True)
# Linear filtering
glTexImage2D(GL_TEXTURE_2D, 0, 3, animSize[0], animSize[1], 0, colorGL,
GL_UNSIGNED_BYTE, surfaceData)
# MipMapping
# gluBuild2DMipmaps(GL_TEXTURE_2D, colorGL,
# animSize[0], animSize[1], colorGL,
# GL_UNSIGNED_BYTE, surfaceData)
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MIN_FILTER, GL_LINEAR)
Log.debug("AnimationPlayer progress: %d%%" % \
( 100*(texIdx+1+len(self.animImgs)) / \
(2*len(self.animImgs)) ))
# Resize animation (polygon) to respect resolution ratio
# (The math is actually simple, take the time to draw it down if required)
winRes = float(self.winWidth)/float(self.winHeight)
animWidth = float(self.animImgs[0].get_size()[0])
animHeight = float(self.animImgs[0].get_size()[1])
animRes = animWidth/animHeight
vtxX = 1.0
vtxY = 1.0
if winRes > animRes:
r = float(self.winHeight)/animHeight
vtxX = 1.0 - abs(self.winWidth-r*animWidth) / (float(self.winWidth))
elif winRes < animRes:
r = float(self.winWidth)/animWidth
vtxY = 1.0 - abs(self.winHeight-r*animHeight) / (float(self.winHeight))
# Vertices
animVtx = array([[-vtxX, vtxY],
[ vtxX, -vtxY],
[ vtxX, vtxY],
[-vtxX, vtxY],
[-vtxX, -vtxY],
[ vtxX, -vtxY]], dtype=float32)
# Texture coordinates
texCoord = array([[0.0, 1.0],
[1.0, 0.0],
[1.0, 1.0],
[0.0, 1.0],
[0.0, 0.0],
[1.0, 0.0]], dtype=float32)
# Create a compiled OpenGL call list and do array-based drawing
# Could have used GL_QUADS but IIRC triangles are recommended
self.animList = cmglList()
with self.animList:
glEnable(GL_TEXTURE_2D)
glColor3f(1., 1., 1.)
cmglDrawArrays(GL_TRIANGLE_STRIP, vertices=animVtx, texcoords=texCoord)
glDisable(GL_TEXTURE_2D)
