OpenGLContext.atlas

class _Strip( object ):

Strip within the atlas which takes particular set of images

__init__( self , atlas , height , yoffset )

Sets up the strip to receive images

_remover( self , offset )

add( self , image , start = None )

Add the given PIL image to our atlas' image

onRemove( self , * args , ** named )

Remove map by offset (normally a weakref-release callback)

start_coord( self , x )

Do we have an empty space sufficient to fit image of width x?

return starting coordinate or -1 if not enough space...

class Atlas( object ):

Collection of textures packed into a single texture

Texture atlases allow the rendering engine to reduce the number of state-changes which occur during the rendering process. They pack a large number of small textures into a single large texture, producing offset/scale matrices to use for modifying texture coordinates to map from the original to the packed coordinates.

__init__( self , components = 4 , dataType = 'B' , max_size = 4096 )

add( self , image )

Insert a PIL image of values as a sub-texture

Has to find a place within the atlas to insert the sub-texture and then return the offset/scale factors...

cached( self , mode )

Get cached version of this texture

Note: currently we do *not* properly use mode-level caching for the texture object

choose_strip( self , max_x , max_y , x , y )

Find the strip to which we should be added

debugImageTexture( self , mode )

Create a debugging image texture for this texture atlas

render( self )

Render this texture to the context

size( self )

class AtlasError( Exception ):

Raised when we can't/shouldn't append to this atlas

class AtlasManager( object ):

Collection of atlases within the renderer

__init__( self , max_size = 4096 , max_child_size = 128 )

add( self , image )

Add the given image to the texture atlas

calculate_max_size( self )

Calculate the maximum size of a texture

Note that this might, for instance, assume a single-component texture or some similarly inappropriate value...

formatToComponents( self , format )

Convert PIL format to component count

class Map( object ):

Object representing a sub-texture within a texture atlas

A Map object is a dependent version of an OpenGLContext.texture.Texture object, i.e. it tries to offer the same API, but with support for Atlas-based maps instead of stand-alone ones.

texture

Retrieve our texture

__call__( self )

Enable/call our texture

__init__( self , atlas , offset , size , image )

coords( self )

Return our bottom-left and top-right coordinate pairs

matrix( self )

Calculate a 4x4 transform matrix for texcoords

To manipulate texture coordinates with this matrix they need to be in homogenous coordinates, i.e. a "regular" 2d coordinate of (x,y) becomes (x,y,0.0,1.0) so that it can pick up the translations.

dot( coord, matrix ) produces the transformed coordinate for processing.

returns 4x4 translation matrix

replace( self , image )

Replace our current image with given (PIL) image

update( self , texture )

Update texture with (new) data in self.image

This just calls texture.update with our metadata in order to do the actual copy of the data-pointer.

Classes