root/trunk/RBRapier/RBRapier/Renderer/SequenceMgr.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 types
import time
import bisect
import weakref
from RBFoundation.SubObs.Basic import SubjectList
    
import AttributeMgr
import BufferMgr
import StateMgr

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

class _MatchAll(object):
    def __cmp__(self, other): return 0 # -1: less, 0: equal, 1: greater
_MatchAll = _MatchAll()

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

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

    SetupPhase = -2
    ManagerPhase = -1
    GeneralPhase = 0
    PostPhase = 1

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

    def __init__(self):
        self.Elements = []
        self.OnAddElement = SubjectList()
        self.OnRemoveElement = SubjectList()
        self.OnBeginExecute = SubjectList()
        self.OnEndExecute = SubjectList()

    def __len__(self):
        return len(self.Elements)

    def AddSetupElement(self, Element, PriorityDelta=0):
        self._AddElement(Element, self.SetupPhase + PriorityDelta)

    def AddManagerElement(self, Element, PriorityDelta=0):
        self._AddElement(Element, self.ManagerPhase + PriorityDelta)

    def AddPostElement(self, Element, PriorityDelta=0):
        self._AddElement(Element, self.PostPhase + PriorityDelta)

    def AddElement(self, Element, priority=None):
        if priority is None: 
            priority = self.GeneralPhase
        self._AddElement(Element, priority)

    def AddElements(self, elements):
        for each in elements:
            if isinstance(each, (tuple, list)):
                self.AddElement(*each)
            else: self.AddElement(each)

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

    def RemoveElement(self, Element):
        self.Elements[:] = [x for x in self.Elements if x[-1] != Element]
        self.OnRemoveElement.Update(Element)

    def GLExecute(self, context):
        self.OnBeginExecute.Update(context)
        for priority, elementfn, element in self.Elements:
            if getattr(element, 'Active', 1):
                elementfn(context)
        self.OnEndExecute.Update(context)

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Protected Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def _AddElement(self, Element, priority=0):
        if priority <= 0:
            idx = bisect.bisect_right(self.Elements, (priority, _MatchAll, _MatchAll))
        else: 
            idx = bisect.bisect_left(self.Elements, (priority, _MatchAll, _MatchAll))

        if isinstance(Element, types.MethodType):
            ElementFn, Element = Element, Element.im_self
        elif callable(getattr(Element, 'GLExecute', None)):
            ElementFn = Element.GLExecute
        elif callable(getattr(Element, 'GLSelect', None)):
            ElementFn = Element.GLSelect
        else:
            raise ValueError, "Unsuppored element type %r: %r" % (type(Element), Element)

        self.Elements.insert(idx, (priority, ElementFn, Element))

        try: ElementSequenceAdd = Element.SequenceAdd
        except AttributeError: pass
        else: ElementSequenceAdd(weakref.proxy(self))

        self.OnAddElement.Update(Element)

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

class Sequence(SequenceBase):
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Public Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def __init__(self, ManagerAttribute=0, ManageBuffer=0):
        SequenceBase.__init__(self)

        if ManagerAttribute:
            self.AttributeMgr = AttributeMgr.AttributeEffector()
        else: self.AttributeMgr = AttributeMgr.AttributeTracker()
        self.AddManagerElement(self.AttributeMgr)

        if ManageBuffer:
            self.BufferMgr = BufferMgr.BufferEffector()
        else: self.BufferMgr = BufferMgr.BufferTracker()
        self.AddManagerElement(self.BufferMgr)

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

class RootSequence(Sequence):
    def __init__(self):
        Sequence.__init__(self, 1, 1)
        self.StateMgr = StateMgr.StateManager()
        self.ClientStateMgr = StateMgr.ClientStateManager()

    def GLExecute(self, context=None):
        self.Statistics = {}
        start = time.clock()
        self.Statistics['start'] = start
        self.StateMgr.Reset()
        self.ClientStateMgr.Reset()
        Sequence.GLExecute(self, self)
        stop = time.clock()
        self.Statistics['stop'] = stop
        self.Statistics['duration'] = stop - start
        self.Statistics['persecond'] = 1./max(1e-9, stop-start)