import SubTexture from "./../../starling/textures/SubTexture"; import Starling from "./../../starling/core/Starling"; import Rectangle from "openfl/geom/Rectangle"; import IllegalOperationError from "openfl/errors/IllegalOperationError"; import Texture from "./../../starling/textures/Texture"; import Image from "./../../starling/display/Image"; import DisplayObject from "./../display/DisplayObject"; import Vector3D from "openfl/geom/Vector3D"; import Matrix from "openfl/geom/Matrix"; declare namespace starling.textures { /** A RenderTexture is a any texture onto which you can draw any display object. * *

After creating a render texture, just call the draw method to render * an object directly onto the texture. The object will be drawn onto the texture at its current * position, adhering its current rotation, scale and alpha properties.

* *

Drawing is done very efficiently, as it is happening directly in graphics memory. After * you have drawn objects onto the texture, the performance will be just like that of a normal * texture — no matter how many objects you have drawn.

* *

If you draw lots of objects at once, it is recommended to bundle the drawing calls in * a block via the drawBundled method, like shown below. That will speed it up * immensely, allowing you to draw hundreds of objects very quickly.

* * 
	 *  renderTexture.drawBundled(function():void
	 *  {
	 *     for (i?:number; i<numDrawings; ++i)
	 *     {
	 *         image.rotation = (2 * Math.PI / numDrawings) * i;
	 *         renderTexture.draw(image);
	 *     }   
	 *  });
	 *
* *

To erase parts of a render texture, you can use any display object like a "rubber" by * setting its blending mode to BlendMode.ERASE. To wipe it completely clean, * use the clear method.

* * Persistence * *

Older devices may require double buffering to support persistent render textures. Thus, * you should disable the persistent parameter in the constructor if you only * need to make one draw operation on the texture. The static useDoubleBuffering * property allows you to customize if new textures will be created with or without double * buffering.

* * Context Loss * *

Unfortunately, render textures are wiped clean when the render context is lost. * This means that you need to manually recreate all their contents in such a case. * One way to do that is by using the root.onRestore callback, like here:

* * * renderTexture.root.onRestore = function():void * { * quad:Quad = new Quad(100, 100, 0xff00ff); * renderTexture.clear(); // required on texture restoration * renderTexture.draw(quad); * }); * *

For example, a drawing app would need to store information about all draw operations * when they occur, and then recreate them inside onRestore on a context loss * (preferably using drawBundled instead).

* *

However, there is one problem: when that callback is executed, it's very likely that * not all of your textures are already available, since they need to be restored, too (and * that might take a while). You probably loaded your textures with the "AssetManager". * In that case, you can listen to its TEXTURES_RESTORED event instead:

* * * assetManager.addEventListener(Event.TEXTURES_RESTORED, function():void * { * brush:Image = new Image(assetManager.getTexture("brush")); * renderTexture.draw(brush); * }); * *

[Note that this time, there is no need to call clear, because that's the * default behavior of onRestore, anyway — and we didn't modify that.]

* */ export class RenderTexture extends SubTexture { /** Creates a new RenderTexture with a certain size (in points). If the texture is * persistent, its contents remains intact after each draw call, allowing you to use the * texture just like a canvas. If it is not, it will be cleared before each draw call. * *

Non-persistent textures can be used more efficiently on older devices; on modern * hardware, it does not make a difference. For more information, have a look at the * documentation of the useDoubleBuffering property.

*/ public constructor(width:number, height:number, persistent?:boolean, scale?:number, format?:string); /** @inheritDoc */ public /*override*/ dispose():void; /** Draws an object into the texture. * * @param object The object to draw. * @param matrix If 'matrix' is null, the object will be drawn adhering its * properties for position, scale, and rotation. If it is not null, * the object will be drawn in the orientation depicted by the matrix. * @param alpha The object's alpha value will be multiplied with this value. * @param antiAliasing Values range from 0 (no antialiasing) to 4 (best quality). * Beginning with AIR 22, this feature is supported on all platforms * (except for software rendering mode). * @param cameraPos When drawing a 3D object, you can optionally pass in a custom * camera position. If left empty, the camera will be placed with * its default settings (centered over the texture, fov = 1.0). */ public draw(object:DisplayObject, matrix?:Matrix, alpha?:number, antiAliasing?:number, cameraPos?:Vector3D):void; /** Bundles several calls to draw together in a block. This avoids buffer * switches and allows you to draw multiple objects into a non-persistent texture. * Note that the 'antiAliasing' setting provided here overrides those provided in * individual 'draw' calls. * * @param drawingBlock a callback with the form: 
function():void;
* @param antiAliasing Values range from 0 (no antialiasing) to 4 (best quality). * Beginning with AIR 22, this feature is supported on all platforms * (except for software rendering mode). * @param cameraPos When drawing a 3D object, you can optionally pass in a custom * camera position. If left empty, the camera will be placed with * its default settings (centered over the texture, fov = 1.0). */ public drawBundled(drawingBlock:()=>void, antiAliasing?:number, cameraPos?:Vector3D):void; /** Clears the render texture with a certain color and alpha value. Call without any * arguments to restore full transparency. */ public clear(color?:number, alpha?:number):void; // properties /** Indicates if the texture is persistent over multiple draw calls. */ public readonly isPersistent:boolean; protected get_isPersistent():boolean; /** Indicates if new persistent textures should use double buffering. Single buffering * is faster and requires less memory, but is not supported on all hardware. * *

By default, applications running with the profile "baseline" or "baselineConstrained" * will use double buffering; all others use just a single buffer. You can override this * behavior, though, by assigning a different value at runtime.

* * @default true for "baseline" and "baselineConstrained", false otherwise */ public static useDoubleBuffering:boolean; protected static get_useDoubleBuffering():boolean; protected static set_useDoubleBuffering(value:boolean):boolean; } } export default starling.textures.RenderTexture;