All Starling instances.

CAUTION: not a copy, but the actual object! Do not modify!

The anti-aliasing level. 0 - none, 16 - maximum.

The default value is 0.

The ratio between viewPort width and stage width. Useful for choosing a different set of textures depending on the display resolution.

The render context of this instance.

Indicates if the Context3D object is currently valid (i.e. it hasn't been lost or disposed).

The currently active Starling instance.

When enabled, all touches that start very close to the screen edges are discarded. On mobile, such touches often indicate swipes that are meant to use OS features. Per default, margins of 15 points at the top, bottom, and left side of the screen are checked. Call starling.touchProcessor.setSystemGestureMargins() to adapt the margins in each direction.

The default value is true on mobile, false on desktop.

Indicates if Stage3D render methods will report errors. It's recommended to activate this when writing custom rendering code (shaders, etc.), since you'll get more detailed error messages. However, it has a very negative impact on performance, and it prevents ATF textures from being restored on a context loss. Never activate for release builds!

The default value is false.

The number of frames that have been rendered since this instance was created.

Indicates if this Starling instance is started.

The default juggler of this instance. Will be advanced once per frame.

Indicates if multitouch input should be supported. You can enable or disable multitouch at any time; just beware that any current touches will be cancelled.

A Flash Sprite placed directly on top of the Starling content. Use it to display native Flash components.

If enabled, touches or mouse events on the native overlay won't be propagated to Starling.

The default value is true.

The Flash (2D) stage object Starling renders beneath.

The painter, which is used for all rendering. The same instance is passed to all rendermethods each frame.

The Context3D profile of the current render context, or null if the context has not been created yet.

The instance of the root class provided in the constructor. Available as soon as the event 'ROOT_CREATED' has been dispatched.

The class that will be instantiated by Starling as the 'root' display object. Must be a subclass of 'starling.display.DisplayObject'.

If you passed null as first parameter to the Starling constructor, you can use this property to set the root class at a later time. As soon as the class is instantiated, Starling will dispatch a ROOT_CREATED event.

Beware: you cannot change the root class once the root object has been instantiated.

Indicates if another Starling instance (or another Stage3D framework altogether) uses the same render context. If enabled, Starling will not execute any destructive context operations (e.g. not call 'configureBackBuffer', 'clear', 'present', etc. This has to be done manually, then.

The default value is false.

Indicates if a small statistics box (with FPS, memory usage and draw count) is displayed.

When the box turns dark green, more than 50% of the frames since the box' last update could skip rendering altogether. This will only happen if the property skipUnchangedFrames is enabled.

Beware that the memory usage should be taken with a grain of salt. The value is determined via System.totalMemory and does not take texture memory into account. It is recommended to use Adobe Scout for reliable and comprehensive memory analysis.

Indicates if multitouch simulation with "Shift" and "Ctrl"/"Cmd"-keys is enabled.

The default value is false.

When enabled, Starling will skip rendering the stage if it hasn't changed since the last frame. This is great for apps that remain static from time to time, since it will greatly reduce power consumption. You should activate this whenever possible!

The reason why it's disabled by default is just that it causes problems with Render- and VideoTextures. When you use those, you either have to disable this property temporarily, or call setRequiresRedraw() (ideally on the stage) whenever those textures are changing. Otherwise, the changes won't show up.

The default value is false.

The Starling stage object, which is the root of the display tree that is rendered.

The Flash Stage3D object Starling renders into.

If enabled, the Stage3D back buffer will change its size according to the browser zoom value - similar to what's done when "supportHighResolutions" is enabled. The resolution is updated on the fly when the zoom factor changes. Only relevant for the browser plugin.

The default value is false.

Indicates that if the device supports HiDPI screens Starling will attempt to allocate a larger back buffer than indicated via the viewPort size. Note that this is used on Desktop only; mobile AIR apps still use the "requestedDisplayResolution" parameter the application descriptor XML.

The default value is false.

The TouchProcessor is passed all mouse and touch input and is responsible for dispatching TouchEvents to the Starling display tree. If you want to handle these types of input manually, pass your own custom subclass to this property.

The viewport into which Starling contents will be rendered.

Creates a new Starling instance.

Dispatches ENTER_FRAME events on the display list, advances the Juggler and processes touches.

Parameters

Disposes all children of the stage and the render context; removes all registered event listeners.

Make this Starling instance the current one.

Calls advanceTime() (with the time that has passed since the last frame) and render().

Renders the complete display list. Before rendering, the context is cleared; afterwards, it is presented (to avoid this, enable shareContext).

This method also dispatches an Event.RENDER-event on the Starling instance. That's the last opportunity to make changes before the display list is rendered.

Makes sure that the next frame is actually rendered.

When skipUnchangedFrames is enabled, some situations require that you manually force a redraw, e.g. when a RenderTexture is changed. This method is the easiest way to do so; it's just a shortcut to stage.setRequiresRedraw().

Displays the statistics box at a certain position.

Parameters

As soon as Starling is started, it will queue input events (keyboard/mouse/touch); furthermore, the method nextFrame will be called once per Flash Player frame. (Except when shareContext is enabled: in that case, you have to call that method manually.)

Stops all logic and input processing, effectively freezing the app in its current state. Per default, rendering will continue: that's because the classic display list is only updated when stage3D is. (If Starling stopped rendering, conventional Flash contents would freeze, as well.)

However, if you don't need classic Flash contents, you can stop rendering, too. On some mobile systems (e.g. iOS), you are even required to do so if you have activated background code execution.

Parameters

Stops Starling right away and displays an error message on the native overlay. This method will also cause Starling to dispatch a FATAL_ERROR event.

Parameters

Dispatched when a new render context is created. The 'data' property references the context.

Dispatched when a fatal error is encountered. The 'data' property contains an error string.

Dispatched when the display list is about to be rendered. This event provides the last opportunity to make changes before the display list is rendered.

Dispatched when the root class has been created. The 'data' property references that object.

The version of the Starling framework.