# This doesn't work anymore
node = Node()
node.body = Body()
node.position = Vector(1, 2, 3)

# This is the way to do it from now on
node = Node()
node.body = Body()
node.body.position = Vector(1, 2, 3)

geom = Sphere(1) # 1 is radius of the sphere
geomNode = Node()
# 20 and 20 are the amount of horizontal and vertical slices
geomNode.render = geom.createPrimitive(20, 20).render
geomNode.collisionGeometry = geom.createCollisionGeometry()

geom = Sphere(1)
vertices = geom.generateMesh(20, 20)
normals = generateNormals(vertices, smooth=False)
texCoords = generateTexCoords(vertices, type="spherical")
primitive = RenderPrimitive(vertices, normals, texCoords)

geomNode = Node()
geomNode.render = primitive.render
geomNode.collisionGeometry = physics.createCollisionGeometry(geom)

# Alternative 1
vertices, normals, texCoords = graphics.geometry.createSphere(1, normals=True, texCoords=True)

# Alternative 2
vertices = graphics.geometry.createSphere(1)
normals = graphics.geometry.generateNormals(vertices, smooth=True)
texCoords = graphics.geometry.generateTexCoords(vertices, "spherical")

primitive = RenderPrimitive(vertices, normals, texCoords)

geomNode = Node()
geomNode.render = primitive
geomNode.collisionGeometry = physics.geometry.Sphere(1)

myWorld = World()
myWorld.rootNode.logic = coolUpdateFunction
-> myNode.dirtyAttributeSignal(myNode, "logic", coolUpdateFunction)
-> myWorld._dirtyAttribute(myNode, "logic", coolUpdateFunction)
-> myWorld.space._dirtyAttribute(...)
-> myWorld.logic._dirtyAttribute(...)
-> attribute name was "logic", so if we're not already storing this node, store it so we can update it when myWorld.update() is called
-> myWorld.physics._dirtyAttribute(...)
-> for view in myWorld.views: view._dirtyAttribute(...)
->     view.renderer._dirtyAttribute(...)
->     view.audio._dirtyAttribute(...)

myNode = Node()
myNode.render = myGeometry.createPrimitive().render
myNode.collisionGeometry = myGeometry.createCollisionGeometry()
myWorld.rootNode.addChild(myNode)
myWorld.rootNode.newChildSignal(myNode)
myWorld._newNode(myNode)
myWorld.space._newNode(myNode)
...etc

myNode.position = Vector(1, 2, 3)
# World transform cache is invalidated, so the following call will calculate it
print transform.getWorldPosition(myNode)
# World transform is now cached, so the following call will use the one from cache
print transform.getWorldRotation(myNode)

class Signal(object):
    def __init__(self):
        self.slots = []
        
    def connect(self, slot):
        self.slots.append(slot)

    def disconnect(self, slot):
        self.slots.remove(slot)

    def __call__(self, *args, **keyargs):
        for slot in self.slots:
            slot(*args, **keyargs)

foo = Signal()
foo.connect(bar)
foo.connect(baz)
foo("hi there", 2)

def __setattr__(self, name, value):
    object.__setattr__(self, name, value)

    if not name.startswith("_"):
        self.dirtyAttributeSignal(self, name, value)

def __delattr__(self, name):
    object.__delattr__(self, name)

    if not name.startswith("_"):
        self.removedAttributeSignal(self, name)

def _newNode(self, node):
    self.nodes.add(node)
        
    if hasattr(node, "collisionGeometry"):
        self._updateODEGeometry(node)

def _removedNode(self, node):
    self.nodes.remove(node)

    if hasattr(node, "collisionGeometry"):
        self._removeODEGeometry(node)

def _dirtyAttribute(self, node, name, value):
    if name == "collisionGeometry":
        self._updateODEGeometry(node)
        return

def _removedAttribute(self, node, name):
    if name == "collisionGeometry":
        self._removeODEGeometry(node)

def _updateODEGeometry(self, node):
    odeGeom = node.collisionGeometry
    self._ode.SpaceAdd(self._odeSpace, odeGeom)

def _removeODEGeometry(self, node):
    odeGeom = node.collisionGeometry
    self._ode.SpaceRemove(self._odeSpace, odeGeom)