home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / lib / site-packages / cgkit / scene.py < prev    next >
Encoding:
Python Source  |  2007-01-11  |  7.8 KB  |  279 lines
  1. # ***** BEGIN LICENSE BLOCK *****
  2. # Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3. #
  4. # The contents of this file are subject to the Mozilla Public License Version
  5. # 1.1 (the "License"); you may not use this file except in compliance with
  6. # the License. You may obtain a copy of the License at
  7. # http://www.mozilla.org/MPL/
  8. #
  9. # Software distributed under the License is distributed on an "AS IS" basis,
  10. # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11. # for the specific language governing rights and limitations under the
  12. # License.
  13. #
  14. # The Original Code is the Python Computer Graphics Kit.
  15. #
  16. # The Initial Developer of the Original Code is Matthias Baas.
  17. # Portions created by the Initial Developer are Copyright (C) 2004
  18. # the Initial Developer. All Rights Reserved.
  19. #
  20. # Contributor(s):
  21. #
  22. # Alternatively, the contents of this file may be used under the terms of
  23. # either the GNU General Public License Version 2 or later (the "GPL"), or
  24. # the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  25. # in which case the provisions of the GPL or the LGPL are applicable instead
  26. # of those above. If you wish to allow use of your version of this file only
  27. # under the terms of either the GPL or the LGPL, and not to allow others to
  28. # use your version of this file under the terms of the MPL, indicate your
  29. # decision by deleting the provisions above and replace them with the notice
  30. # and other provisions required by the GPL or the LGPL. If you do not delete
  31. # the provisions above, a recipient may use your version of this file under
  32. # the terms of any one of the MPL, the GPL or the LGPL.
  33. #
  34. # ***** END LICENSE BLOCK *****
  35. # $Id: scene.py,v 1.2 2005/04/14 07:58:55 mbaas Exp $
  36.  
  37. ## \file scene.py
  38. ## Contains the Scene class.
  39.  
  40. from cgtypes import vec3
  41. from Interfaces import ISceneItem
  42. import worldobject, timer
  43. import protocols
  44. from boundingbox import BoundingBox
  45. import joystick
  46. import _core
  47.  
  48. # Scene
  49. class Scene(object):
  50.     """%Scene class."""
  51.     
  52.     def __init__(self):
  53.         # Handedness ('r' or 'l')
  54.         self._handedness = "r"
  55.         # Normalized up direction
  56.         self._up = vec3(0,0,1)
  57.         # Unit   (1 unit = unitscale [Unit])
  58.         self._unit = "m"
  59.         # Unit scale
  60.         self._unitscale = 1.0
  61.  
  62.         # Global options
  63.         self._globals = {}
  64.         
  65.         self.items = []
  66. #        self.items_by_name = {}
  67.  
  68.         self._worldroot = worldobject.WorldObject("WorldRoot", auto_insert=False)
  69.         self._timer = timer.Timer(auto_insert=False)
  70.  
  71.         # Key: ID  Value:Joystick object
  72.         self._joysticks = {}
  73.         
  74.         self.clear()
  75.  
  76.     def __len__(self):
  77.         return len(self.items)
  78.  
  79.     def __iter__(self):
  80.         return iter(self.items)
  81.  
  82.     def hasGlobal(self, name):
  83.         return self._globals.has_key(name)
  84.             
  85.     def getGlobal(self, name, default=None):
  86.         return self._globals.get(name, default)
  87.  
  88.     def setGlobal(self, name, value):
  89.         self._globals[name] = value
  90.  
  91.     # createDefaultItems
  92. #    def createDefaultItems(self):
  93. #        self._worldroot = WorldObject("root", auto_insert=False)
  94.  
  95.     # worldRoot
  96.     def worldRoot(self):
  97.         """Return the root object of the world.
  98.         """
  99.         return self._worldroot
  100.  
  101.     # walkWorld
  102.     def walkWorld(self, root=None):
  103.         """Walk the world tree and yield each object.
  104.  
  105.         This method can be used to iterator over the entire world tree or
  106.         a subtree thereof. The argument root specifies the root of the
  107.         tree which is to traverse (the root itself will not be returned).
  108.         """
  109.         if root==None:
  110.             root = self._worldroot
  111.         return self._walkWorld(root)
  112.  
  113.     # timer
  114.     def timer(self):
  115.         """Return the global timer object."""
  116.         return self._timer
  117.  
  118.     # clear
  119.     def clear(self):
  120.         """Clear the entire scene."""
  121.  
  122.         # Remove all children of the world root...
  123.         for obj in list(self._worldroot.iterChilds()):
  124.             self._worldroot.removeChild(obj)
  125.             
  126.         self.items = [self._timer, self._worldroot]
  127. #        self.items_by_name = {}
  128.  
  129.     # insert
  130.     def insert(self, item):
  131.         """Insert an item into the scene."""
  132.         protocols.adapt(item, ISceneItem)
  133. #        if isinstance(item, worldobject.WorldObject):
  134.         if isinstance(item, _core.WorldObject):
  135.             self._worldroot.addChild(item)
  136.         else:
  137.             self.items.append(item)
  138.  
  139.     # item
  140.     def item(self, name):
  141.         """Return the item with the specified name.
  142.  
  143.         \param name (\c str) Item name
  144.         \return Item or None if no item was found
  145.         """
  146.         for item in self.items:
  147.             if name==item.name:
  148.                 return item
  149.         return None
  150.  
  151.     # worldObject
  152.     def worldObject(self, name):
  153.         """Return the world object with the specified name.
  154.  
  155.         You can use '|' as a path separator.
  156.  
  157.         \param name (\c str) Object name
  158.         \return WorldObject
  159.         """
  160.         obj = self._worldroot
  161.         if len(name)>0:
  162.             names = name.split("|")
  163.         else:
  164.             names = []
  165.         for n in names:
  166.             obj = obj.child(n)
  167.         return obj
  168.  
  169.     # boundingBox
  170.     def boundingBox(self):
  171.         """Return the bounding box of the entire scene.
  172.  
  173.         \todo Use the world transform instead of the local transform
  174.         """
  175.         return self._worldroot.boundingBox()
  176. #        return self._boundingBox(self._worldroot)
  177.             
  178. #    def _boundingBox(self, node):
  179. #        res = BoundingBox()
  180. #        for obj in node.iterChilds():
  181. #            L = obj.localTransform()
  182. #            g = obj.geom
  183. #            if g!=None:
  184. #                bb = g.boundingBox()
  185. #                if not bb.isEmpty():
  186. #                    res.addBoundingBox(bb.transform(L))
  187.  
  188. #            res.addBoundingBox(self._boundingBox(obj).transform(L))
  189.  
  190. #        return res
  191.  
  192.     # setJoystick
  193.     def setJoystick(self, joystick):
  194.         """Set a joystick object.
  195.         """
  196.         self._joysticks[joystick.id] = joystick
  197.  
  198.     # getJoystick
  199.     def getJoystick(self, id):
  200.         """Get a joystick object.
  201.  
  202.         A dummy joystick object is returned if there is no joystick
  203.         with the specified id.
  204.         """
  205.         if id in self._joysticks:
  206.             return self._joysticks[id]
  207.         else:
  208.             return joystick.Joystick(id=id, name="Dummy-Joystick")
  209.  
  210.     ## protected:
  211.  
  212.  
  213.     def _walkWorld(self, obj):
  214.         """Helper method for the walkWorld() method."""
  215.         for child in obj.iterChilds():
  216.             yield child
  217.             for c in self._walkWorld(child):
  218.                 yield c
  219.  
  220.     
  221.     # "handedness" property...
  222.     
  223.     def _getHandedness(self):
  224.         """Return the handedness.
  225.  
  226.         This method is used for retrieving the \a handedness property.
  227.  
  228.         \return Handedness (\c str) which is either 'l' or 'r'.
  229.         """
  230.         return self._handedness
  231.  
  232.     def _setHandedness(self, h):
  233.         """Set the handedness.
  234.  
  235.         This method is used for setting the \a handedness property.
  236.  
  237.         \param h (\c str) Handedness ('l' or 'r')
  238.         """
  239.         h = h.lower()
  240.         if h!="l" and h!="r":
  241.             raise ValueError, "Handedness must be either 'l' or 'r'."
  242.         self._handedness = h
  243.  
  244.     handedness = property(_getHandedness, _setHandedness, None, "Handedness")
  245.  
  246.     # "up" property...
  247.     
  248.     def _getUp(self):
  249.         """Return the up vector.
  250.  
  251.         This method is used for retrieving the \a up property.
  252.  
  253.         \return Up vector (\c vec3)
  254.         """
  255.         return self._up
  256.  
  257.     def _setUp(self, up):
  258.         """Set the up vector.
  259.  
  260.         This method is used for setting the \a up property.
  261.  
  262.         \param up (\c vec3) Up vector
  263.         """
  264.         self._up = vec3(up).normalize()
  265.  
  266.     up = property(_getUp, _setUp, None, "Up vector")
  267.     
  268.  
  269. ######################################################################
  270.  
  271. _scene = Scene()
  272.  
  273. # getScene
  274. def getScene():
  275.     """Return the global %scene instance."""
  276.     global _scene
  277.     return _scene
  278.  
  279.