setattr(self, "transform_"+attr,value)

return inner

def get_attr():

if getattr(self,"children_"+attr) != getattr(self, "transform_"+attr):

raise Exception("no consistent value for "+attr)

return getattr(self,"children_"+attr)

self.scheduled_interval_calls = [

c for c in self.scheduled_interval_calls if c[0] != callback

]

if self.is_running:

pyglet.clock.unschedule( callback )

_best_grabber = FBOGrabber

return _best_grabber()

except:

# Fallback: GL generic grabber

raise Exception("ERROR: GPU doesn't support Frame Buffers Objects. Can't continue")

def grab (self, texture):

pass

def before_render (self, texture):

director.window.clear()

def after_render (self, texture):

buffer = image.get_buffer_manager().get_color_buffer()

texture.blit_into(buffer, 0, 0, 0)

class PbufferGrabber(object):

"""A render-to texture mechanism using pbuffers.

def grab (self, texture):

GLX_DEPTH_SIZE, 24,

GLX_DOUBLEBUFFER, 1,

])

def before_render (self, texture):

self.pbuf.switch_to()

gl.glViewport(0, 0, self.pbuf.width, self.pbuf.height)

gl.glOrtho(0, self.pbuf.width, 0, self.pbuf.height, -1, 1)

gl.glMatrixMode(gl.GL_MODELVIEW)

gl.glEnable (gl.GL_TEXTURE_2D)

def after_render (self, texture):

buffer = image.get_buffer_manager().get_color_buffer()

texture.blit_into (buffer, 0, 0, 0)

self.fbuf.texture2d (texture)

self.fbuf.check_status()

self.fbuf.unbind()

def before_render (self, texture):

self.fbuf.bind()

glClear(GL_COLOR_BUFFER_BIT)

def after_render (self, texture):

self.fbuf.unbind()

class FramebufferObject (object):

"""

def __init__ (self):

"""Create a new framebuffer object"""

glGenFramebuffersEXT (1, byref(id))

self._id = id.value

unicode=unicode,

int=int,

float=float,

)

_python_to_xml = {

str: unicode,

To display the text, we'll create a `Label`. Keyword arguments are used

to set the font, position and alignment of the label::

The label position will be the center of the screen::

label.position = 320,240

Since `Label` is a subclass of `CocosNode` it can be added

as a child. All `CocosNode` objects know how to render itself, perform actions

and transformations.

To add it as a layer's child, use the `CocosNode.add` method::

self.add( label )

After defining the ``HelloWorld`` class, we need to initialize and create a window.

This example is very similar to example #1, with the difference that it introduces

us to the world of actions.

action.

You can find the entire program in the `samples/hello_world_actions.py` file.

import cocos

the available actions into the namespace with this import::

from cocos.actions import *

we call super() with a blueish color::

class HelloWorld(cocos.layer.ColorLayer):

In this example we also create and add an sprite as a child. In cocos2d

sprites are `Sprite` objects::

sprite = cocos.sprite.Sprite('grossini.png')

We place the sprite in the center of the screen. Default position is (0,0)::

sprite.position = 320,240

We set the scale attribute to 3. This means that our sprite will be 3 times bigger.

The default scale attribute is 1::

sprite.scale = 3

We add the sprite as a child but on top of the label by setting the z-value to 1, since

3. and we repeat these 2 actions forever

Notice that the '+' operator is the `Sequence` action::

label.do( Repeat( scale + Reverse( scale) ) )

And we tell the sprite to do the same actions but starting with the 'scale back' action::

sprite.do( Repeat( Reverse(scale) + scale ) )

Then we initialize the director, like in the previous example::

cocos.director.director.init()

hello_layer = HelloWorld ()

We start defining the KeyDisplay layer class. As always, we put some initialization on ``__init__`` and the code for displaying it in step::

class KeyDisplay(cocos.layer.Layer):

# If you want that your layer receives events

# you must set this variable to 'True',

# otherwise it won't receive any event.

is_event_handler = True

def __init__(self):

super( KeyDisplay, self ).__init__()

self.text = cocos.text.Label("", x=100, y=280 )

# To keep track of which keys are pressed:

self.keys_pressed = set()

self.update_text()

'modifiers' is a bitwise or of several constants indicating which

modifiers are active at the time of the press (ctrl, shift, capslock, etc.)

"""

self.keys_pressed.add (key)

self.update_text()

def on_key_release (self, key, modifiers):

"""This function is called when a key is released.

'key' is a constant indicating which key was pressed.

'modifiers' is a bitwise or of several constants indicating which

modifiers are active at the time of the press (ctrl, shift, capslock, etc.)

Constants are the ones from pyglet.window.key

"""

self.keys_pressed.remove (key)

self.update_text()

def update_text(self):

key_names = [pyglet.window.key.symbol_string (k) for k in self.keys_pressed]

text = 'Keys: '+','.join (key_names)

Handling mouse input is similar. You have three events of interest: on_mouse_press, on_mouse_release and on_mouse_motion. With that, we can define our layer::

class MouseDisplay(cocos.layer.Layer):

is_event_handler = True #: enable pyglet's events

def __init__(self):

super( MouseDisplay, self ).__init__()

self.posx = 100

self.posy = 240

self.text = cocos.text.Label('No mouse events yet', font_size=18, x=self.posx, y=self.posy )

def on_mouse_motion (self, x, y, dx, dy):

"""This function is called when the mouse is moved over the app.

(x, y) are the physical coordinates of the mouse

(dx, dy) is the distance vector covered by the mouse pointer since the

last call.

"""

self.update_text (x, y)

def on_mouse_press (self, x, y, buttons, modifiers):

"""This function is called when any mouse button is pressed

(x, y) are the physical coordinates of the mouse

'buttons' is a bitwise or of pyglet.window.mouse constants LEFT, MIDDLE, RIGHT

'modifiers' is a bitwise or of pyglet.window.key modifier constants

* Change the on_mouse_press handler and remove the mapping to virtual coordinates; note how it behaves strangely after resizing the window

* Note that the mouse coordinates on screen are physical coordinates, so their range changes when resizing the window; modify the demo to show virtual coordinates.

* Change the code to be able to move the mouse coordinates label when you drag the mouse (hint: a mouse drag is a sequence of button_press, several motions, and a button_release event)

Where to next?

--------------

To achieve optimal performance in your 2D

applications you'll need to work with OpenGL directly. The canonical

`The OpenGL Shading Language`_.

There are numerous examples of cocos2d applications in the ``samples/``

directory of the documentation and source distributions. Keep checking

tag_date = 0

tag_svn_revision = 0

__author__ = "cocos2d team"

__date__ = "2008-06-27"

try:

setup(

packages = find_packages(),

dependency_links=['http://code.google.com/p/pyglet/downloads/list',],

include_package_data = True,

class TestLayer(cocos.layer.Layer):

def __init__(self):

super( TestLayer, self ).__init__()

x,y = director.get_window_size()

self.sprite = Sprite('grossini.png')

self.sprite.position = x/2, y/2

self.add( self.sprite )

if __name__ == "__main__":

director.init()