Starling's Painter instance stores a reference to the current RenderState. * Via a stack mechanism, you can always save a specific state and restore it later. * That makes it easy to write rendering code that doesn't have any side effects.
* *Beware that any context-related settings are not applied on the context
* right away, but only after calling painter.prepareToDraw().
* However, the Painter recognizes changes to those settings and will finish the current
* batch right away if necessary.
On rendering, Starling traverses the display tree, constantly moving from one * coordinate system to the next. Each display object stores its vertex coordinates * in its local coordinate system; on rendering, they must be moved to a global, * 2D coordinate space (the so-called "clip-space"). To handle these calculations, * the RenderState contains a set of matrices.
* *By multiplying vertex coordinates with the modelviewMatrix, you'll get the
* coordinates in "screen-space", or in other words: in stage coordinates. (Optionally,
* there's also a 3D version of this matrix. It comes into play when you're working with
* Sprite3D containers.)
By feeding the result of the previous transformation into the
* projectionMatrix, you'll end up with so-called "clipping coordinates",
* which are in the range [-1, 1] (just as needed by the graphics pipeline).
* If you've got vertices in the 3D space, this matrix will also execute a perspective
* projection.
Finally, there's the mvpMatrix, which is short for
* "modelviewProjectionMatrix". This is simply a combination of modelview- and
* projectionMatrix, combining the effects of both. Pass this matrix
* to the vertex shader and all your vertices will automatically end up at the right
* position.
The first 4 parameters define which area of the stage you want to view (the camera * will 'zoom' to exactly this region). The final 3 parameters determine the perspective * in which you're looking at the stage.
* *The stage is always on the rectangle that is spawned up between x- and y-axis (with * the given size). All objects that are exactly on that rectangle (z equals zero) will be * rendered in their true size, without any distortion.
* *If you pass only the first 4 parameters, the camera will be set up above the center * of the stage, with a field of view of 1.0 rad.
*/ public setProjectionMatrix(x:number, y:number, width:number, height:number, stageWidth?:number, stageHeight?:number, cameraPos?:Vector3D):void; /** This method needs to be called wheneverprojectionMatrix3D was changed
* other than via setProjectionMatrix.
*/
public setProjectionMatrixChanged():void;
/** Changes the modelview matrices (2D and, if available, 3D) to identity matrices.
* An object transformed an identity matrix performs no transformation.
*/
public setModelviewMatricesToIdentity():void;
/** Returns the current 2D modelview matrix.
* CAUTION: Use with care! Each call returns the same instance.
* @default identity matrix */
public modelviewMatrix:Matrix;
protected get_modelviewMatrix():Matrix;
protected set_modelviewMatrix(value:Matrix):Matrix;
/** Returns the current 3D modelview matrix, if there have been 3D transformations.
* CAUTION: Use with care! Each call returns the same instance.
* @default null */
public modelviewMatrix3D:Matrix3D;
protected get_modelviewMatrix3D():Matrix3D;
protected set_modelviewMatrix3D(value:Matrix3D):Matrix3D;
/** Returns the current projection matrix. You can use the method 'setProjectionMatrix3D'
* to set it up in an intuitive way.
* CAUTION: Use with care! Each call returns the same instance. If you modify the matrix
* in place, you have to call setProjectionMatrixChanged.
* @default identity matrix */
public projectionMatrix3D:Matrix3D;
protected get_projectionMatrix3D():Matrix3D;
protected set_projectionMatrix3D(value:Matrix3D):Matrix3D;
/** Calculates the product of modelview and projection matrix and stores it in a 3D matrix.
* CAUTION: Use with care! Each call returns the same instance. */
public readonly mvpMatrix3D:Matrix3D;
protected get_mvpMatrix3D():Matrix3D;
// other methods
/** Changes the the current render target.
*
* @param target Either a texture or null to render into the back buffer.
* @param enableDepthAndStencil Indicates if depth and stencil testing will be available.
* This parameter affects only texture targets.
* @param antiAlias The anti-aliasing quality (range: 0 - 4).
* This parameter affects only texture targets. Note that at the time
* of this writing, AIR supports anti-aliasing only on Desktop.
*/
public setRenderTarget(target:Texture, enableDepthAndStencil?:boolean,
antiAlias?:number):void;
// other properties
/** The current, cumulated alpha value. Beware that, in a standard 'render' method,
* this already includes the current object! The value is the product of current object's
* alpha value and all its parents. @default 1.0
*/
public alpha:number;
protected get_alpha():number;
protected set_alpha(value:number):number;
/** The blend mode to be used on rendering. A value of "auto" is ignored, since it
* means that the mode should remain unchanged.
*
* @default BlendMode.NORMAL
* @see starling.display.BlendMode
*/
public blendMode:string;
protected get_blendMode():string;
protected set_blendMode(value:string):string;
/** The texture that is currently being rendered into, or null
* to render into the back buffer. On assignment, calls setRenderTarget
* with its default parameters. */
public renderTarget:Texture;
protected get_renderTarget():Texture;
protected set_renderTarget(value:Texture):Texture;
/** @protected */
/*@:allow(starling)*/ protected readonly renderTargetBase:TextureBase;
protected get_renderTargetBase():TextureBase;
/** @protected */
/*@:allow(starling)*/ readonly protected renderTargetOptions:number;
protected get_renderTargetOptions():number;
/** Sets the triangle culling mode. Allows to exclude triangles from rendering based on
* their orientation relative to the view plane.
* @default Context3DTriangleFace.NONE
*/
public culling:string;
protected get_culling():string;
protected set_culling(value:string):string;
/** Enables or disables depth buffer writes.
* @default false
*/
public depthMask:boolean;
protected get_depthMask():boolean;
protected set_depthMask(value:boolean):boolean;
/** Sets type of comparison used for depth testing.
* @default Context3DCompareMode.ALWAYS
*/
public depthTest:string;
protected get_depthTest():string;
protected set_depthTest(value:string):string;
/** The clipping rectangle can be used to limit rendering in the current render target to
* a certain area. This method expects the rectangle in stage coordinates. To prevent
* any clipping, assign null.
*
* @default null
*/
public clipRect:Rectangle;
protected get_clipRect():Rectangle;
protected set_clipRect(value:Rectangle):Rectangle;
/** The anti-alias setting used when setting the current render target
* via setRenderTarget. */
public readonly renderTargetAntiAlias:number;
protected get_renderTargetAntiAlias():number;
/** Indicates if the render target (set via setRenderTarget)
* has its depth and stencil buffers enabled. */
public readonly renderTargetSupportsDepthAndStencil:boolean;
protected get_renderTargetSupportsDepthAndStencil():boolean;
/** Indicates if there have been any 3D transformations.
* Returns true if the 3D modelview matrix contains a value. */
public readonly is3D:boolean;
protected get_is3D():boolean;
/** @private
*
* This callback is executed whenever a state change requires a draw operation.
* This is the case if blend mode, render target, culling or clipping rectangle
* are changing. */
/*@:allow(starling)*/ protected onDrawRequired:()=>void;
protected get_onDrawRequired():()=>void;
protected set_onDrawRequired(value:()=>void):()=>void;
}
}
export default starling.rendering.RenderState;