root/trunk/RBRapier/RBRapier/Renderer/Geometry/ArrayTraversal.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 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

from OpenGL import GL
import Numeric
import NumericVertexArray
from RBFoundation.Aspects import Aspect

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

_PrimitveMap = {
    'pointlist': GL.GL_POINTS,

    'linelist': GL.GL_LINES,
    'lineloop': GL.GL_LINE_LOOP,
    'linestrip': GL.GL_LINE_STRIP,

    'trilist': GL.GL_TRIANGLES,
    'trifan': GL.GL_TRIANGLE_FAN,
    'tristrip': GL.GL_TRIANGLE_STRIP,

    'quadlist': GL.GL_QUADS,
    'quadstrip': GL.GL_QUAD_STRIP,
    }

_ReversePrimitveMap = dict([(y,x) for x,y in _PrimitveMap.iteritems()])
_PrimitveStatsMap = {
    GL.GL_POINTS: ('points', lambda count: count),

    GL.GL_LINES: ('lines', lambda count: count//2),
    GL.GL_LINE_STRIP: ('lines', lambda count: count-1),
    GL.GL_LINE_LOOP: ('lines', lambda count: count),

    GL.GL_TRIANGLES: ('triangles', lambda count: count//3),
    GL.GL_TRIANGLE_FAN: ('triangles', lambda count: count-2), 
    GL.GL_TRIANGLE_STRIP: ('triangles', lambda count: count-2), 

    GL.GL_QUADS: ('triangles', lambda count: count//2),
    GL.GL_QUAD_STRIP: ('triangles', lambda count: count-2),
    }
    
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Definitions 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def GetPrimitiveCollection(primitive, count):
    if isinstance(primitive, (list, tuple)):
        assert len(primitive) == count
        return [_PrimitveMap.get(p, p) for p in primitive]
    else:
        return [_PrimitveMap.get(primitive, primitive)]*count

def GenerateStatistics(self, context):
    if context.Statistics:
        for StatName, StatResults in self._StatsData.iteritems():
            try: context.Statistics[StatName] += StatResults
            except KeyError: context.Statistics[StatName] = StatResults

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Ranged Traversals
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class RangedTraversalRaw(object):
    """Draws a collection of ranges using multiple primitives"""

    def __init__(self, primitives, starts, lengths):
        assert len(primitives) == len(starts) == len(lengths)
        self.primitives = primitives
        self.starts = starts
        self.lengths = lengths

        self._StatsData = {}
        for primitive, count in zip(primitives, lengths):
            StatName, StatCalc = _PrimitveStatsMap[primitive]
            self._StatsData[StatName] = self._StatsData.get(StatName, 0) + StatCalc(count)
            ReverseName = _ReversePrimitveMap[primitive]
            self._StatsData[ReverseName] = self._StatsData.get(ReverseName, 0) + 1

    GenerateStatistics = GenerateStatistics

    def GLExecute(self, context):
        map(GL.glDrawArrays, self.primitives, self.starts, self.lengths)
        self.GenerateStatistics(context)

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

class RangedTraversal(RangedTraversalRaw):
    """Draws a collection of ranges using multiple primitives"""

    def __init__(self, primitive, rangecollection):
        primitives = GetPrimitiveCollection(primitive, len(rangecollection))
        starts, lengths = zip(*rangecollection)
        RangedTraversalRaw.__init__(self, primitives, starts, lengths)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Indexed Collection Traversals
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class IndexedCollectionTraversalRaw(object):
    """Draws a collection of index arrays using multiple primitives"""

    def __init__(self, primitives, data):
        assert len(primitives) == len(data)
        self.primitives = primitives
        self.data = data

        self._StatsData = {}
        for primitive, datacoll in zip(primitives, data): 
            StatName, StatCalc = _PrimitveStatsMap[primitive]
            self._StatsData[StatName] = self._StatsData.get(StatName, 0) + StatCalc(len(datacoll))
            ReverseName = _ReversePrimitveMap[primitive]
            self._StatsData[ReverseName] = self._StatsData.get(ReverseName, 0) + 1

    GenerateStatistics = GenerateStatistics

    def GLExecute(self, context):
        map(NumericVertexArray.DrawElementsArray, self.primitives, self.data)
        self.GenerateStatistics(context)

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

class IndexedCollectionTraversal(IndexedCollectionTraversalRaw):
    """Draws a collection of index arrays using multiple primitives"""

    _DefaultFormat = Numeric.UInt16

    def __init__(self, primitive, data, format=None):
        if format is None: format = self._DefaultFormat
        primitives = GetPrimitiveCollection(primitive, len(data))
        data = [Numeric.asarray(item, format) for item in data]
        IndexedCollectionTraversalRaw.__init__(self, primitives, data)

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

class ColoredIndexedCollectionTraversal(IndexedCollectionTraversal):
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Constants / Variables / Etc. 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    colors = []

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

    def __init__(self, primitive, data, format=None):
        IndexedCollectionTraversal.__init__(self, primitive, data, format)
        self.GenerateColors()

    def GenerateColors(self):
        import random
        self.colors = [(.3 + .7*random.random(), .3 + .7*random.random(), .3 + .7*random.random()) for x in self.data]

    def GLExecute(self, context):
        _glDrawElements = NumericVertexArray.DrawElementsArray
        for color, primitive, indexes in zip(self.colors, self.primitives, self.data):
            GL.glColor3fv(color)
            _glDrawElements(primitive, indexes)

        self.GenerateStatistics(context)

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

class ColoredIndexedCollectionAspect(Aspect, ColoredIndexedCollectionTraversal):
    pass