cocos.layer.scrolling module

This module defines the ScrollableLayer and ScrollingManager classes.

This module helps to handle what will be visible on screen when the game world does not fit in the window area.

It models this concept: the game world is a big volume. We have a camera that follows the actor moving parallel to one of the volume faces, without rotations. What the camera sees is what will be seen on the app window. Also, the camera’s movements can be restricted in order not to show parts outside of the world. This technique is usually named ‘scrolling’.

It has support for parallax rendering, that is, faking perspective by using layers that slide slower the farther they are.

The important concepts are:
  • The coordinator, implemented as ScrollingManager which enforces the view limits imposed by the managed layers, accounts for layer’s parallax.
  • The managed layers, implemented each by a ScrollableLayer, which as a group holds all the entities in the world and each one can define what area of the x-y plane should be shown on camera.
-The focus, tied to ScrollingManager fx and fy attributes, which
indicates that point (fx, fy) in world coordinates is the point of interest, and should show at the center of the screen view if no restriction is violated.
class ScrollableLayer(parallax=1)

Bases: cocos.layer.base_layers.Layer

Layer that supports scrolling.

If px_width is defined, then px_height must also be defined; scrolling will be limited to only show areas with origin_x <= x < = px_width and origin_y <= y <= px_height).

If px_width is not defined, then the layer will not limit the scrolling.

A layer may have a parallax value which is used to scale the position (and not the dimensions) of the view for the layer - the layer’s view (x, y) coordinates are calculated as:

my_view_x = parallax * passed_view_x
my_view_y = parallax * passed_view_y

The scrolling is managed by the parent node of ScrollingManager class.

Warning

Don’t change scale_x , scale_y from the default 1.0 or scrolling and coordinate changes will fail.

Parameters:parallax (float) – the parallax for this layer. Defaults to 1.
draw()

Draws itself

on_cocos_resize(usable_width, usable_height)

Event handler for window resizing.

on_enter()

Called every time just before the node enters the stage.

on_exit()

Called every time just before the node exits the stage.

set_dirty()

The viewport has changed in some way.

set_view(x, y, w, h, viewport_ox=0, viewport_oy=0)

Sets the position of the viewport for this layer.

Parameters:
  • x (float) – The view x position
  • y (float) – The view y position
  • w (float) – The width of the view
  • h (float) – The height of the view
  • viewport_ox (float) – The viewport x origin
  • viewport_oy (float) – The viewport y origin
class ScrollingManager(viewport=None, do_not_scale=None)

Bases: cocos.layer.base_layers.Layer

Handles scrolling for his children, which should be ScrollableLayer instances.

Restricts the scrolling so that all the visibility restriction imposed by the children are honored; at least one child should define a constraint for the scrolling to be limited.

The drawing can be limited to a specific window’s rectangle by passing the viewport parameter.

The scrolling manager also provides coordinate changes between screen coords and world coords.

Parameters:
  • viewport (Rect) – A rectangle defining the viewport. [Optional]
  • do_not_scale (bool) – Whether the ScrollingManager should scale the view during Window resizes. (Defaults to None, meaning it takes the same value as director.autoscale)
add(child, z=0, name=None)

Add the child and then update the manager’s focus / viewport.

Parameters:
  • child (CocosNode) – The node to add. Normally it’s a ScrollableLayer.
  • z (int) – z-order for this child.
  • name (str) – The name of this child. [Optional]
force_focus(fx, fy)

Force the manager to focus on a point, regardless of any managed layer visible boundaries.

Parameters:
  • fx (int) – the focus point x coordinate
  • fy (int) – the focus point y coordinate
on_cocos_resize(usable_width, usable_height)

Event handler for Window resize.

on_enter()

“Called every time just before the node enters the stage.

on_exit()

Called every time just before the node exits the stage.

pixel_from_screen(x, y)

deprecated, was renamed as screen_to_world

pixel_to_screen(x, y)

deprecated, was renamed as world_to_screen

refresh_focus()

Resets the focus at the focus point.

screen_to_world(x, y)

Translates screen coordinates to world coordinates.

Account for viewport, layer and screen transformations.

Parameters:
  • x (int) – x coordinate in screen space
  • y (int) – y coordinate in screen space
Returns:

tuple[int, int] – coordinates in world-space

set_focus(fx, fy, force=False)

Makes the point (fx, fy) show as near the view’s center as possible.

Changes his children so that the point (fx, fy) in world coordinates will be seen as near the view center as possible, while at the same time not displaying out-of-bounds areas in the children.

Parameters:
  • fx (int) – the focus point x coordinate
  • fy (int) – the focus point y coordinate
  • force (bool) – If True, forces the update of the focus, eventhough the focus point or the scale did not change. Defaults to False.
set_state()

Sets OpenGL state for using scissor test.

unset_state()

Unsets OpenGL state for using scissor test.

update_view_size()

Updates the view size based on the director usable width and height, and on the optional viewport.

visit()

Draws itself and its children into the viewport area.

Same as in CocosNode.visit(), but will restrict drawing to the rect viewport.

world_to_screen(x, y)

Translates world coordinates to screen coordinates.

Account for viewport, layer and screen transformations.

Parameters:
  • x (int) – x coordinate in world space
  • y (int) – y coordinate in world space
Returns:

tuple[int, int] – coordinates in screen space

scale

The scaling factor of the object.

Type:float