def render__(self):
"""
Grafikus objektum pozicionálása textúra kötése és leképezés
"""
glPushMatrix()
glTranslate(*self._coord )
glRotate(self._angle.x,1.0, 0.0, 0.0)
glRotate(self._angle.y,0.0, 1.0, 0.0)
glRotate(self._angle.z,0.0, 0.0, 1.0)
glScale(*self._scale)
if self.visible and self._geometry != None:
glLoadName(self._id)
if self._material != None:
self._material.bindMaterial()
else:
Texture.unbindTexture()
self._geometry.renderMesh()
if self._showNormals:
self._geometry.renderNormalVectors()
if self.hasEventListener(Event.RENDERED):
self.dispatchEvent(Event(Event.RENDERED))
glPopMatrix()
def render__(self):
"""
A konténer poziciónálása méretezése és forgatása
A tárolt elemek leképezése
végül a saját geometria leképezése
"""
glPushMatrix()
glTranslate(*self._coord)
glRotate(self._angle[0],1.0, 0.0, 0.0)
glRotate(self._angle[1],0.0, 1.0, 0.0)
glRotate(self._angle[2],0.0, 0.0, 1.0)
glScale(*self._scale)
for element in self.elementList:
element.render__()
if self.visible and self._geometry != None:
# glLoadName(self._id)
if self._material != None:
self._material.bindMaterial()
else:
Texture.unbindTexture()
self._geometry.renderMesh()
glPopMatrix()
if self.hasEventListener(Event.RENDERED):
self.dispatchEvent(Event(Event.RENDERED))
def __buildFont(self):
"""
Font map betöltése és glList generálása a betűknek
Felhasznált forrás:
- U{Nehe: lesson 17 <http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=17>}
"""
glEnable(GL_TEXTURE_2D)
if Config.hasValue("resource.fontmap"):
self.__fontList = []
self.__fontTexture = Texture(Config.getValue("resource.fontmap"))
self.__fontTexture.bindTexture()
self.__fontList = glGenLists(256)
for i in xrange(256):
cx = ( i % 16 ) / 16.0
cy = ( i / 16 ) / 16.0
glNewList(self.__fontList + i, GL_COMPILE)
glBegin(GL_QUADS)
glTexCoord2f(cx, 1-cy)
glVertex2i(0, 0)
glTexCoord2f(cx + 0.0625, 1-cy)
glVertex2i(16, 0)
glTexCoord2f(cx + 0.0625, 1-cy-0.0625)
glVertex2i(16, 16)
glTexCoord2f(cx, 1-cy-0.0625)
glVertex2i(0, 16)
glEnd()
glTranslate(12,0,0)
glEndList()
glDisable(GL_TEXTURE_2D)
class GLContext(GfxContext):
"""
Az OpenGL becsomagolása
"""
def __init__(self, IOContext=None):
GfxContext.__init__(self)
self.__view = Viewport()
self.__matrix = GLContext.GfxMatrix()
self.__currTextureUnit = Gfx.TEXTURE_UNIT_0
self.__curTextures = dict(zip(xrange(Gfx.TEXTURE_UNIT_0, Gfx.TEXTURE_UNIT_9), (None,)*Gfx.NUM_TEXTURE_UNITS))
self.__fontList = None
self.__fontTexture = None
# set shader pointers to NULL
self.normalmap_shader = None
self.normalmap_vshader = None
Text()
@property
def matrix(self):
return self.__matrix
@property
def viewport(self):
return self.__view
def glInit(self):
self.__checkEXT()
self.__setupGL()
print ("GfxDriverGL initialized")
def __checkEXT(self):
"""
A felhasznált OpenGL függvények elérhetőségének ellenőrzése
"""
try:
self.begin = glBegin
self.end = glEnd
self.clear = glClear
self.color = glColor3f
self.color4 = glColor4f
self.vertex = glVertex
self.pointSize = glPointSize
self.lineWidth = glLineWidth
except Exception as e:
raise IloExtensionError(e)
def __setupGL(self):
"""
OpenGL alapbeállítások elvégzése
"""
try:
glClearColor(0.0, 0.0, 0.0, 0.0)
glClearDepth(1.0)
glClearStencil(0)
glShadeModel(GL_SMOOTH)
glEnable(GL_CULL_FACE)
glEnable(GL_NORMALIZE)
glEnable(GL_COLOR_MATERIAL)
glEnable(GL_TEXTURE_2D)
glEnable(GL_DEPTH_TEST)
# glEnable(GL_BLEND)
# glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glDepthFunc(GL_LEQUAL) # so that multi-pass lightmapping works
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
glCullFace(GL_BACK)
glDisable(GL_CULL_FACE)
glPolygonMode(GL_BACK, GL_FILL)
glPolygonMode(GL_FRONT, GL_FILL)
# set default projection matrix
self.__buildFont()
self.__view.setPerspectiveView()
self.matrix.setMatrixMode(Gfx.MODELVIEW)
except Exception as e:
raise IloInitError(e)
def beginRendering(self):
"""
Leképezés előkészítése
"""
self.matrix.setMatrixMode(Gfx.MODELVIEW)
glClear(GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT |
GL_STENCIL_BUFFER_BIT)
glEnable(GL_DEPTH_TEST)
glClearStencil(0)
glStencilMask(1)
glClearDepth(1.0)
glClearColor(0.0, 0.0, 0.0, 1.0)
self.matrix.loadIdentity()
#self.matrix.rotate(-90.0, 1.0, 0.0, 0.0)
def endRendering(self):
"""
Leképezés lezárása
"""
glFlush()
def beginMeshRenderPass(self):
"""
Model leképezési fázis előkészítése
"""
self.enableMaterials()
glEnable(GL_VERTEX_ARRAY)
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_NORMAL_ARRAY)
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
def endMeshRenderPass(self):
"""
Model leképezési fázis lezárása
"""
glDisableClientState(GL_TEXTURE_COORD_ARRAY)
glDisableClientState(GL_NORMAL_ARRAY)
glDisableClientState(GL_VERTEX_ARRAY)
glDisable(GL_VERTEX_ARRAY)
self.disableMaterials()
def enableMaterials(self):
"""
Anyagminták használatának bekapcsolása
"""
glEnable(GL_TEXTURE_2D)
def disableMaterials(self):
"""
Anyagminta használatának kikapcsolása
"""
glDisable(GL_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D, 0)
glUseProgram(0)
def __buildFont(self):
"""
Font map betöltése és glList generálása a betűknek
Felhasznált forrás:
- U{Nehe: lesson 17 <http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=17>}
"""
glEnable(GL_TEXTURE_2D)
if Config.hasValue("resource.fontmap"):
self.__fontList = []
self.__fontTexture = Texture(Config.getValue("resource.fontmap"))
self.__fontTexture.bindTexture()
self.__fontList = glGenLists(256)
for i in xrange(256):
cx = ( i % 16 ) / 16.0
cy = ( i / 16 ) / 16.0
glNewList(self.__fontList + i, GL_COMPILE)
glBegin(GL_QUADS)
glTexCoord2f(cx, 1-cy)
glVertex2i(0, 0)
glTexCoord2f(cx + 0.0625, 1-cy)
glVertex2i(16, 0)
glTexCoord2f(cx + 0.0625, 1-cy-0.0625)
glVertex2i(16, 16)
glTexCoord2f(cx, 1-cy-0.0625)
glVertex2i(0, 16)
glEnd()
glTranslate(12,0,0)
glEndList()
glDisable(GL_TEXTURE_2D)
def textRenderPass(self):
"""
A beállított szövegobjektumok megjelenítése egymenetben
a leképezés utólsó sakaszában (a takarás elkerüése érdekében)
Felhasznált forrás:
- U{Nehe: lesson 17 <http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=17>}
"""
if self.__fontTexture != None:
self.enable2D(self.viewport.width, self.viewport.height)
self.matrix.setMatrixMode(Gfx.MODELVIEW)
glPushAttrib(GL_ALL_ATTRIB_BITS)
glEnable(GL_TEXTURE_2D)
glDisable(GL_LIGHTING)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA,GL_ONE)
self.__fontTexture.bindTexture()
for item in Text.getInstance().textList:
self.matrix.loadIdentity()
glColor(*(item.color))
#glScale(*(item.scale))
glTranslate(item.x, item.y,0)
glListBase(self.__fontList + (-32+(128*item.fontSet)))
glCallLists(item.text)
glPopAttrib()
self.disable2D()
def enable2D(self, width, height):
"""
2D-s leképezés kezdete
Ortgonális vetítés beállítása
@param width: A 2D-s vetítési keret szélessége pixelben
@type width: C{int}
@param height: A 2D-s vetítési keret magassága pixelben
@type width: C{int}
"""
self.matrix.setMatrixMode(Gfx.MODELVIEW)
self.matrix.pushMatrix()
self.matrix.loadIdentity()
self.matrix.setMatrixMode(Gfx.PROJECTION)
self.matrix.pushMatrix()
self.matrix.loadIdentity()
glOrtho(0, width, height, 0, 0, 1)
glDisable(GL_DEPTH_TEST)
#glDepthMask(GL_FALSE)
def disable2D(self):
"""
2D-s leképezés vége,
Perspektívikus vetítés visszaállítása
"""
self.matrix.setMatrixMode(Gfx.PROJECTION)
self.matrix.popMatrix()
self.matrix.setMatrixMode(Gfx.MODELVIEW)
self.matrix.popMatrix()
glEnable(GL_DEPTH_TEST)
#glDepthMask(GL_FALSE)
def activeTextureUnit(self, texture_unit):
"""
Adott Textúra egység aktiválása, több szintű textúrázás esetén
@param texture_unit: A beállítantandó textúrázási szint
@type texture_unit: C{GLuint}
"""
if self.__currTextureUnit == unit:
return
if (unit != GL_TEXTURE0 and not self.multitexture) or (unit >= NUM_TEXTURE_UNITS):
return
glActiveTextureARB(unit)
glClientActiveTextureARB(unit)
self.__currTextureUnit = unit
class GfxMatrix(object):
"""
OpenGL mátrixok kezelése
Mátrixok beállítása, utoljára használt visszaállítása
Mozgatás, forgatás, skálázás,
"""
_instance = None
__curMatrix = None
__prevMatrix = None
def __new__(cls, *args, **kwargs):
if not cls._instance:
cls._instance = super(GLContext.GfxMatrix, cls).__new__( cls, *args, **kwargs)
return cls._instance
else:
raise SingletonClassError("Csak egyszer példányosítható!")
def __init__(self):
"""
GfxMatrix inicializálása
"""
self.pushMatrix = glPushMatrix
self.popMatrix = glPopMatrix
self.setMatrixMode = glMatrixMode
self.translate = glTranslate
self.scale = glTranslate
self.rotate = glRotate
def __log(self, newType):
"""
Utoljára használt mátrixtípus mentése
@param newType: Az új használandó mátrix típus
"""
GfxMatrix.__prevMatrix = GfxMatrix.__curMatrix
GfxMatrix.__curMatrix = newType
def prevMatrix(self):
"""
Az utóljára használt mátrixtípus visszaállítása
"""
glMatrixMode( GfxMatrix.___prevMatrix )
GfxMatrix.__log(GfxMatrix.___prevMatrix)
def getMatrix(self, type):
"""
Megadott típusú mátrix lekérdezése
@param type: A kért mátrix típusa
"""
if type == GL_PROJECTION:
return Matrix4x4(glGetDoublev(GL_PROJECTION_MATRIX))
if type == GL_MODELVIEW:
return Matrix4x4(glGetDoublev(GL_MODELVIEW_MATRIX))
if type == GL_TEXTURE:
return Matrix4x4(glGetDoublev(GL_TEXTURE_MATRIX))
def setMatrix(self, matrix, type = None ):
"""
Adott típusú mátrix beállítása
@param matrix: A beállítandó mátrix
@param type: A beállítandó mátrix típusa
"""
if type :
glMatrixMode( type )
if isinstance(matrix, Matrix4x4):
glLoadMatrixd( matrix.T )
else:
glLoadMatrixd( matrix )
def multiplyMatrix(self, matrix, type = None):
"""
A megadott típusú openGL mátrixra jobbról rászorzunk az adott
mátrixxal
@param matrix: A szorzó mátrix
@param type: A szorzandó openGL mátrix típusa
"""
if type :
glMatrixMode( type )
glMultMatrixd( matrix )
def loadIdentity(self, type = None):
"""
Egységmátrix beállítása a megadott típusú openGL mátrixra
@param type: OpenGL mátrix típus
"""
if type :
glMatrixMode( type )
glLoadIdentity()
#-----------------------------------------GETTER/SETTER-------------------------
@property
def currentMatrix(self):
return GfxMatrix.__curMatrix
@property
def previewMatrix(self):
GfxMatrix.__prevMatrix