root/trunk/RBRapier/RBRapier/Renderer/View/Transformations.py

#!/usr/bin/env python
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
##~ License 
##~ 
##- The RuneBlade Foundation GL is intended to ease some 
##- aspects of writing intricate Jabber, XML, and User Interface (wxPython, etc.) 
##- applications, while providing the flexibility to modularly change the 
##- architecture. Enjoy.
##~ 
##~ Copyright (C) 2002  TechGame Networks, LLC.
##~ 
##~ This GL is free software; you can redistribute it and/or
##~ modify it under the terms of the BSD style License as found in the 
##~ LICENSE file included with this distribution.
##~ 
##~ TechGame Networks, LLC can be reached at:
##~ 3578 E. Hartsel Drive #211
##~ Colorado Springs, Colorado, USA, 80920
##~
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Imports 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

from RBRapier.Tools import Transformations
from RBRapier.Tools import Projections
from RBRapier.Tools import Quaternion
from RBRapier.Tools import ViewBox

from Numeric import transpose
from OpenGL import GL, GLU

try:
    GL.GL_COLOR_MATRIX
except AttributeError:
    GL.GL_COLOR_MATRIX = 0x80B1

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Definitions 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def GLExecuteAsMatrix(self, context):
    GL.glMultMatrixd(transpose(self.asArray4x4()).tolist())
def GLExecuteLoadMatrix(self, context):
    GL.glLoadMatrixd(transpose(self.asArray4x4()).tolist())

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class ManagedTransformationMixin(object):
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Constants / Variables / Etc. 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    _ModeNameTable = {None:"< None >", GL.GL_MODELVIEW:"Model View", GL.GL_PROJECTION:"Projection", GL.GL_TEXTURE:"Texture", GL.GL_COLOR:"Color"}
    _SaveMatrixLookup = {
        None: GL.GL_MODELVIEW_MATRIX,
        GL.GL_MODELVIEW: GL.GL_MODELVIEW_MATRIX,
        GL.GL_PROJECTION: GL.GL_PROJECTION_MATRIX,
        GL.GL_TEXTURE: GL.GL_TEXTURE_MATRIX,
        GL.GL_COLOR: GL.GL_COLOR_MATRIX,
        }
    Mode = None
    Save = 0
    _save_matrix = None

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Public Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def __init__(self, Mode=None, Save=0, *args, **kw):
        super(ManagedTransformationMixin, self).__init__(*args, **kw)
        if Mode is not None:
            self.Mode = Mode
        if Save is not 0:
            self.Save = Save

    def GLSelect(self, context):
        if self.Mode: 
            GL.glMatrixMode(self.Mode)
            if self.Save:
                self._SaveMatrix()
            self.GLExecute(context)
            GL.glMatrixMode(GL.GL_MODELVIEW)
        elif self.Save:
            self._SaveMatrix()
            self.GLExecute(context)
        else:
            self.GLExecute(context)

    def GLDeselect(self, context):
        if self.Save:
            if self.Mode:
                GL.glMatrixMode(self.Mode)
                self._RestoreMatrix()
                GL.glMatrixMode(GL.GL_MODELVIEW)
            else:
                self._RestoreMatrix()

    def _SaveMatrix(self):
        try:
            GL.glPushMatrix()
        except GL.GLerror, e:
            self._save_matrix = GL.glGetDouble(self._SaveMatrixLookup[self.Mode])
    #_SaveMatrix = staticmethod(GL.glPushMatrix)

    def _RestoreMatrix(self):
        oldmatrix = self._save_matrix
        if oldmatrix is None:
            GL.glPopMatrix()
        else:
            GL.glLoadMatrixd(oldmatrix)
            del self._save_matrix
    #_RestoreMatrix = staticmethod(GL.glPopMatrix)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Composite(Transformations.Composite):
    def GLExecute(self, context):
        for each in self.collection:
            each.GLExecute(context)

class CompositeMgd(ManagedTransformationMixin, Composite):
    pass
ManagedComposite = CompositeMgd

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Matrix(Transformations.Matrix):
    GLExecute = GLExecuteAsMatrix

class MatrixMgd(ManagedTransformationMixin, Matrix):
    pass

class LoadMatrix(Transformations.Matrix):
    GLExecute = GLExecuteLoadMatrix

class LoadMatrixMgd(ManagedTransformationMixin, LoadMatrix):
    pass

class Identity(Transformations.Identity):
    def GLExecute(self, context):
        pass # Uh.... don't use this?

class IdentityMgd(ManagedTransformationMixin, Identity):
    pass

class LoadIdentity(Transformations.Identity):
    def GLExecute(self, context):
        GL.glLoadIdentity()

class LoadIdentityMgd(ManagedTransformationMixin, LoadIdentity):
    pass

class Translate(Transformations.Translate):
    def GLExecute(self, context):
        GL.glTranslated(*self.Direction[:3])

class TranslateMgd(ManagedTransformationMixin, Translate):
    pass

class Scale(Transformations.Scale):
    def GLExecute(self, context):
        GL.glScaled(*self.Scale[:3])

class ScaleMgd(ManagedTransformationMixin, Scale):
    pass

class Rotate(Transformations.Rotate):
    def GLExecute(self, context):
        GL.glRotated(self.Angle, *self.Axis[:3])

class RotateMgd(ManagedTransformationMixin, Rotate):
    pass

class Quaternion(Quaternion.Quaternion):
    GLExecute = GLExecuteAsMatrix

class QuaternionMgd(ManagedTransformationMixin, Quaternion):
    pass

class LinearMappingMatrix(Transformations.LinearMappingMatrix):
    GLExecute = GLExecuteAsMatrix

class LinearMappingMatrixMgd(ManagedTransformationMixin, LinearMappingMatrix):
    pass

class ViewBoxMappingMatrix(ViewBox.ViewBoxMappingMatrix3dh):
    GLExecute = GLExecuteAsMatrix

class ViewBoxMappingMatrixMgd(ManagedTransformationMixin, ViewBoxMappingMatrix):
    pass

class LookAt(Transformations.LookAt):
    def GLExecute(self, context):
        args= self.Eye.tolist() + self.Center.tolist() + self.Up.tolist()
        GLU.gluLookAt(*args)

class LookAtMgd(ManagedTransformationMixin, LookAt):
    pass

class SphericalLookAt(Transformations.SphericalLookAt):
    def GLExecute(self, context):
        args= self.Eye.tolist() + self.Center.tolist() + self.Up.tolist()
        GLU.gluLookAt(*args)

class SphericalLookAtMgd(ManagedTransformationMixin, SphericalLookAt):
    pass

class Shear(Transformations.Shear):
    GLExecute = GLExecuteAsMatrix

class ShearMgd(ManagedTransformationMixin, Shear):
    pass

class Skew(Transformations.Skew):
    GLExecute = GLExecuteAsMatrix

class SkewMgd(ManagedTransformationMixin, Skew):
    pass

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Projections
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class ProjectionModelMixin(object):
    ProjectionModel = None

    def ApplyProjectionModel(self):
        projmodel = self.ProjectionModel
        if projmodel is not None: 
            projmodel.UpdateProjection(self)

class Orthographic(Projections.Orthographic, ProjectionModelMixin):
    def GLExecute(self, context):
        self.ApplyProjectionModel()
        GL.glOrtho(self.Left, self.Right, self.Bottom, self.Top, self.Near, self.Far)

class OrthographicMgd(ManagedTransformationMixin, Orthographic):
    pass

class Frustum(Projections.Frustum, ProjectionModelMixin):
    def GLExecute(self, context):
        self.ApplyProjectionModel()
        GL.glFrustum(self.Left, self.Right, self.Bottom, self.Top, self.Near, self.Far)

class FrustumMgd(ManagedTransformationMixin, Frustum):
    pass

class Perspective(Projections.Perspective, ProjectionModelMixin):
    def GLExecute(self, context):
        self.ApplyProjectionModel()
        GL.glFrustum(self.Left, self.Right, self.Bottom, self.Top, self.Near, self.Far)

class PerspectiveMgd(ManagedTransformationMixin, Perspective):
    pass