starling-framework

import Texture from "../textures/Texture"; import Vector3D from "openfl/geom/Vector3D"; import Rectangle from "openfl/geom/Rectangle"; import Matrix3D from "openfl/geom/Matrix3D"; import Matrix from "openfl/geom/Matrix"; declare namespace starling.rendering { /** * The RenderState stores a combination of settings that are currently used for rendering. * * This includes modelview and transformation matrices as well as context3D related settings. * * * * 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 <code>painter.prepareToDraw()</code>. * * However, the Painter recognizes changes to those settings and will finish the current * * batch right away if necessary. * * * * Matrix Magic * * * * 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 <code>modelviewMatrix</code>, 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 * * <code>Sprite3D</code> containers.) * * * * By feeding the result of the previous transformation into the * * <code>projectionMatrix</code>, you'll end up with so-called "clipping coordinates", * * which are in the range <code>[-1, 1]</code> (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 <code>mvpMatrix</code>, which is short for * * "modelviewProjectionMatrix". This is simply a combination of <code>modelview-</code> and * * <code>projectionMatrix</code>, combining the effects of both. Pass this matrix * * to the vertex shader and all your vertices will automatically end up at the right * * position. * * * * @see Painter * * @see starling.display.Sprite3D * */ export class RenderState { /** * Creates a new render state with the default settings. */ constructor(); /** * Duplicates all properties of another instance on the current instance. */ copyFrom(renderState: RenderState): void; /** * Resets the RenderState to the default settings. * * (Check each property documentation for its default value.) */ reset(): void; /** * Prepends the given matrix to the 2D modelview matrix. */ transformModelviewMatrix(matrix: Matrix): void; /** * Prepends the given matrix to the 3D modelview matrix. * * The current contents of the 2D modelview matrix is stored in the 3D modelview matrix * * before doing so; the 2D modelview matrix is then reset to the identity matrix. * */ transformModelviewMatrix3D(matrix: Matrix3D): void; /** * Creates a perspective projection matrix suitable for 2D and 3D rendering. * * * * 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. * */ setProjectionMatrix(x: number, y: number, width: number, height: number, stageWidth?: number, stageHeight?: number, cameraPos?: Vector3D): void; /** * This method needs to be called whenever <code>projectionMatrix3D</code> was changed * * other than via <code>setProjectionMatrix</code>. * */ setProjectionMatrixChanged(): void; /** * Changes the modelview matrices (2D and, if available, 3D) to identity matrices. * * An object transformed an identity matrix performs no transformation. * */ setModelviewMatricesToIdentity(): void; /** * Returns the current 2D modelview matrix. * * CAUTION: Use with care! Each call returns the same instance. * * @default identity matrix */ get modelviewMatrix(): Matrix; set modelviewMatrix(value: 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 */ get modelviewMatrix3D(): Matrix3D; set modelviewMatrix3D(value: 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 <code>setProjectionMatrixChanged</code>. * * @default identity matrix */ get projectionMatrix3D(): Matrix3D; set projectionMatrix3D(value: 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. */ get mvpMatrix3D(): Matrix3D; /** * Changes the the current render target. * * * * @param target Either a texture or <code>null</code> 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: <code>0 - 4</code>). * * This parameter affects only texture targets. Note that at the time * * of this writing, AIR supports anti-aliasing only on Desktop. * */ setRenderTarget(target: Texture, enableDepthAndStencil?: boolean, antiAlias?: number): void; /** * 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 * */ get alpha(): number; set alpha(value: 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 * */ get blendMode(): string; set blendMode(value: string) /** * The texture that is currently being rendered into, or <code>null</code> * * to render into the back buffer. On assignment, calls <code>setRenderTarget</code> * * with its default parameters. */ get renderTarget(): Texture; set renderTarget(value: Texture) /** * Sets the triangle culling mode. Allows to exclude triangles from rendering based on * * their orientation relative to the view plane. * * @default Context3DTriangleFace.NONE * */ get culling(): string; set culling(value: string) /** * Enables or disables depth buffer writes. * * @default false * */ get depthMask(): boolean; set depthMask(value: boolean) /** * Sets type of comparison used for depth testing. * * @default Context3DCompareMode.ALWAYS * */ get depthTest(): string; set depthTest(value: 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 <code>null</code>. * * * * @default null * */ get clipRect(): Rectangle; set clipRect(value: Rectangle) /** * The anti-alias setting used when setting the current render target * * via <code>setRenderTarget</code>. */ get renderTargetAntiAlias(): number; /** * Indicates if the render target (set via <code>setRenderTarget</code>) * * has its depth and stencil buffers enabled. */ get renderTargetSupportsDepthAndStencil(): boolean; /** * Indicates if there have been any 3D transformations. * * Returns <code>true</code> if the 3D modelview matrix contains a value. */ get is3D(): boolean; } } export default starling.rendering.RenderState;