Esempio n. 1
0
    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()
Esempio n. 2
0
    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))
Esempio n. 3
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)
Esempio n. 4
0
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