root/trunk/RBRapier/demo/Cube/cubescene.py

#!/usr/bin/env python
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
##~ License 
##~ 
##- The RuneBlade Foundation library 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 library 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 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

import time
import math

from wxPython import wx
from OpenGL import GL, GLU, GLUT
import Numeric

from RBSkinning import SkinXML
from RBSkinning.wxTools.GLViewSetup import GLViewSetup

from RBRapier.Renderer import SequenceMgr
from RBRapier.Renderer.Appearance import Blending
from RBRapier.Renderer.Environment import Buffers
from RBRapier.Renderer.Environment import Selection
from RBRapier.Renderer.View import Viewport
from RBRapier.Renderer.View import Transformations

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Constants / Variables / Etc. 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

skinxml = """<?xml version='1.0'?> 
<skin:skin xmlns:skin='http://namespaces.runeblade.com/skin' xmlns:py='http://namespaces.runeblade.com/xmlPython' xmlns='http://namespaces.runeblade.com/wxPythonSkin'>
    <frame ctxvar='scene.frame' title='Cube Scene' show='1' pos='0,0' size='800,600'>
        <layout fit='0'>
            <panel>
                <layout>
                    <glcanvas ctxvar='scene.glcanvas' sizercfg='1, wxEXPAND' attribList='[WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_MIN_ALPHA, 8, WX_GL_DEPTH_SIZE, 8]'>
                        <event type='EVT_LEFT_DOWN' call='ctx.scene.OnMouse'/>
                        <event type='EVT_MOTION' call='ctx.scene.OnMouse'/>
                    </glcanvas>
                </layout>
            </panel>
        </layout> 
    </frame>

    <!--
    <frame title='Demo PyCrust' show='1' pos='850,0' size='400,800'>
        <layout fit='0'>
            <pycrust_shell sizercfg='1, wxEXPAND' locals='{"scene":context.scene}'/>
        </layout> 
    </frame>
    -->
</skin:skin>
"""

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

class Cube(object):
    size = 0.5
    color = (1., 1., 1., 1.)
    tx, ty, tz = 0, 0, 0
    sx, sy, sz = 120, 180, 90
    usecolor = None

    def __init__(self, size=size, (tx,ty,tz)=(tx,ty,tz), (sx,sy,sz)=(sx,sy,sz), color=color):
        self.size = size
        self.sx, self.sy, self.sz = sx,sy,sz
        self.tx, self.ty, self.tz = tx,ty,tz
        self.color = color

    def _time(self):
        return time.clock()

    def GLExecute(self, context):
        GL.glLoadIdentity()
        GL.glRotated((self.tx + self.sx*self._time())%360., 1, 0, 0)
        GL.glRotated((self.ty + self.sy*self._time())%360., 0, 1, 0)
        GL.glRotated((self.tz + self.sz*self._time())%360., 0, 0, 1)

        GL.glPushName(id(self))
        GL.glColor4fv(self.usecolor or self.color)
        GLUT.glutWireCube(self.size)
        GL.glPopName()

    def SetSelected(self, selected):
        if selected:
            self.usecolor = (1., 0., 0., 1.)
        else:
            self.usecolor = None

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

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

    _fps_score = 0
    fps = 0.
    frametitle = 'Cube Scene'
    Initialized = False

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

    def OnSkinInitialize(self):
        pass

    def OnSkinFinalize(self):
        self.viewsetup = GLViewSetup(self.glcanvas)
        self.viewsetup.OnRender.Add(self.Initialize)
        self.viewsetup.OnRender.Add(self.Render)
        self.viewsetup.StartRendering()

    def IsPickingEnabled(self):
        return self.Initialized and self.pickmatrix.PickEnabled

    def Initialize(self, glviewsetup, canvas):
        self.viewsetup.OnRender.Remove(self.Initialize)
        self.root = SequenceMgr.RootSequence()

        self.clearcolor = Buffers.ClearColor((0.5,0.5,1.0,0.0))
        self.root.AddElement(self.clearcolor, -2)

        self.viewport = Viewport.Viewport()
        self.root.AddElement(self.viewport, -2)

        self.root.AddElement(Blending.Blend(), -1)

        self.subseq = SequenceMgr.SequenceBase()
        self.root.AddElement(self.subseq)
        
        self.projection = Transformations.OrthographicMgd(GL.GL_PROJECTION, True, -1, 1, -1, 1, -1, 1)
        self.subseq.AddElement(self.projection.GLSelect)
        self.subseq.AddPostElement(self.projection.GLDeselect)

        viewportrect = self.glcanvas.GetClientRect().asTuple()

        self.pickbuffer = Selection.SelectionBuffer()
        self.pickmatrix = Transformations.ViewBoxMappingMatrixMgd(GL.GL_PROJECTION, True)
        self.pickmatrix.PickEnabled = False

        self.pickseq = SequenceMgr.RootSequence()
        self.pickseq.AddElement(self.pickbuffer.GLSelect)
        self.pickseq.AddElement(self.pickmatrix.GLSelect)
        self.pickseq.AddElement(self.subseq.GLExecute)
        self.pickseq.AddElement(self.pickmatrix.GLDeselect)
        self.pickseq.AddElement(self.pickbuffer.GLDeselect)

        color0 = Numeric.asarray((0., 0., 0., 0.), Numeric.Float)
        color1 = Numeric.asarray((1., 1., 1., 1.), Numeric.Float)
        count = 10.
        self.selectables = {}
        for i in range(1, int(1+count)):
            f = i/count
            cube = Cube(f, (3*i, +2*i, -5*i), color=(color0*(1-f)+color1*f))
            self.subseq.AddElement(cube.GLExecute)
            self.selectables[id(cube)] = cube

        self.Initialized = True

    def Render(self, glviewsetup, canvas):
        viewportrect = canvas.GetClientRect().asTuple()
        self.viewport.SetRectangle(viewportrect)
        self.projection.SetDimensionsAspectRatio(2., 2., self.viewport.GetAspectRatio())
        self.root.GLExecute(None)

        if self.IsPickingEnabled():
            self.pickseq.GLExecute(None)

            for each in self.selectables.itervalues():
                each.SetSelected(False)
            for selection in self.pickbuffer.Selection:
                each = selection.Resolve(self.selectables)
                each.SetSelected(True)

        if time.clock() - self._fps_score >= .2:
            self.frame.SetTitle(self.frametitle + ' [FPS: %1.1f, |Picked|=%d]' % (self.fps, len(self.pickbuffer.Selection)))
            self.fps = self.root.Statistics['persecond']
            self._fps_score = time.clock()

    def OnMouse(self, evt):
        evt.Skip()
        if not self.Initialized: 
            return
        self.pickmatrix.PickEnabled = True
        if self.IsPickingEnabled():
            x, y = evt.GetPosition()
            pw, ph = (2,2)
            pos0, pos1 = (x-pw, y-ph), (x+pw, y+ph)
            pos0, pos1 = self.viewport.MapPointsTo([pos0, pos1], flipy=True)
            self.pickmatrix.MapFrom.SetPts(pos0, pos1)
        
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Main
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def Run():
    application = wx.wxPySimpleApp()
    scene = CubeScene()
    scene.OnSkinInitialize()
    skin = SkinXML(skinxml, application=application, scene=scene)
    scene.OnSkinFinalize()
    skin.context.application.MainLoop()

if __name__ == '__main__':
    Run()