import EventDispatcher from "../events/EventDispatcher";
import Context3DRenderMode from "../display3D/Context3DRenderMode";
import Context3DProfile from "../display3D/Context3DProfile";
import Context3D from "../display3D/Context3D";
import Stage from "./Stage";
import Vector from "../Vector";
declare namespace openfl.display {
	/**
	 * 	The Stage3D class provides a display area and a programmable rendering
	 * 	context for drawing 2D and 3D graphics.
	 * 
	 * 	Stage3D provides a high-performance rendering surface for content rendered
	 * 	using the `Context3D` class. This surface uses the graphics processing unit
	 * 	(GPU) when possible. The runtime stage provides a fixed number of `Stage3D`
	 * 	objects. The number of instances varies by the type of device. Desktop
	 * 	computers typically provide four Stage3D instances.
	 * 
	 * 	Content drawn to the `Stage3D` viewport is composited with other visible
	 * 	graphics objects in a predefined order. The most distant are all
	 * 	`StageVideo` surfaces. `Stage3D` comes next, with traditional Flash display
	 * 	object content being rendered last, on top of all others. StageVideo and
	 * 	Stage3D layers are rendered with no transparency; thus a viewport completely
	 * 	obscures any other Stage3D or StageVideo viewports positioned underneath it.
	 * 	Display list content is rendered with transparency.
	 * 
	 * 	**Note:** You can use the `visible` property of a Stage3D object to remove
	 * 	it from the display temporarily, such as when playing a video using the
	 * 	StageVideo class.
	 * 
	 * 	A `Stage3D` object is retrieved from the Player stage using its `stage3Ds`
	 * 	member. Use the Stage3D instance to request an associated rendering context
	 * 	and to position the display on the runtime stage.
	 * 
	 * 	@event context3DCreate      Dispatched when a rendering context is created.
	 * 	@event error             	Dispatched when a request for a rendering
	 * 								context fails.
	 * 
	 * 	@see `openfl.display.Stage`
	 * 	@see `openfl.display3D.Context3D`
	 * 
	 */
	export class Stage3D extends EventDispatcher {
		protected constructor(stage: Stage);
		/**
		 * 		The Context3D object associated with this Stage3D instance.
		 * 
		 * 		This property is initially `null`. To create the Context3D instance for this
		 * 		Stage3D object, add an event listener for the `context3DCreate` event and then call
		 * 		the `requestContext3D` method. The listener is called once the Context3D object has
		 * 		been created.
		 * 	
		 */
		context3D: Context3D;
		/**
		 * 		Specifies whether this Stage3D object is visible.
		 * 
		 * 		Use this property to temporarily hide a Stage3D object on the Stage. This property
		 * 		defaults to `true`.
		 * 	
		 */
		visible: boolean;
		/**
		 * 		The horizontal coordinate of the Stage3D display on the stage, in pixels.
		 * 
		 * 		This property defaults to zero.
		 * 	
		 */
		get x(): number;
		set x(value: number)
		/**
		 * 		The vertical coordinate of the Stage3D display on the stage, in pixels.
		 * 
		 * 		This property defaults to zero.
		 * 	
		 */
		get y(): number;
		set y(value: number)
		/**
		 * 		Request the creation of a Context3D object for this Stage3D instance.
		 * 
		 * 		Before calling this function, add an event listener for the `context3DCreate`
		 * 		event. If you do not, the runtime throws an exception.
		 * 
		 * 		**Important note on device loss:**
		 * 		GPU device loss occurs when the GPU hardware becomes unavailable to the application.
		 * 		The Context3D object is disposed when the GPU device is lost. GPU device loss can
		 * 		happen for various reasons, such as, when a mobile device runs out of battery power
		 * 		or a Windows device goes to a "lock screen." When the GPU becomes available again,
		 * 		the runtime creates a new Context3D instance and dispatches another
		 * 		`context3DCreate` event. Your application must reload all assets and reset the
		 * 		rendering context state whenever device loss occurs.
		 * 
		 * 		Design your application logic to handle the possibility of device loss and context
		 * 		regeneration. Do not remove the `context3DCreate` event listener. Do not perform
		 * 		actions in response to the event that should not be repeated in the application.
		 * 		For example, do not add anonymous functions to handle timer events because they
		 * 		would be duplicated after device loss. To test your application's handling of
		 * 		device loss, you can simulate device loss by calling the `dispose()` method of the
		 * 		Context3D object.
		 * 
		 * 		The following example illustrates how to request a Context3d rendering context:
		 * 
		 * 		```haxe
		 * 		if( stage.stage3Ds.length > 0 )
		 * 		{
		 * 			var stage3D:Stage3D = stage.stage3Ds[0];
		 * 			stage3D.addEventListener( Event.CONTEXT3D_CREATE, myContext3DHandler );
		 * 			stage3D.requestContext3D( );
		 * 		}
		 * 
		 * 		function myContext3DHandler ( event : Event ) : void
		 * 		{
		 * 			var targetStage3D : Stage3D = cast event.target;
		 * 			InitAll3DResources( targetStage3D.context3D );
		 * 			StartRendering( targetStage3D.context3D );
		 * 		}
		 * 		```
		 * 
		 * 		@param	context3DRenderMode	The type of rendering context to request. The default
		 * 		is `Context3DRenderMode.AUTO` for which the runtime will create a
		 * 		hardware-accelerated context if possible and fall back to software otherwise. Use
		 * 		`Context3DRenderMode.SOFTWARE` to request a software rendering context. Software
		 * 		rendering is not available on mobile devices. Software rendering is available only
		 * 		for `Context3DProfile.BASELINE` and `Context3DProfile.BASELINE_CONSTRAINED`.
		 * 		@param	profile	(AIR 3.4 and higher) Specifies the extent to which Flash Player
		 * 		supports lower-level GPUs. The default is `Context3DProfile.BASELINE`, which
		 * 		returns a Context3D instance similar to that used in previous releases. To get
		 * 		details of all available profiles, see openfl.display3D.Context3DProfile.
		 * 		@event	context3DCreate	Dispatched when the requested rendering context is
		 * 		successfully completed.
		 * 		@event	error	Dispatched when the requested rendering context cannot be created.
		 * 		@throws	Error	if no listeners for the `context3DCreate` event have been added to
		 * 		this Stage3D object.
		 * 		@throws	ArgumentError	if this method is called again with a different
		 * 		`context3DRenderMode` before the previous call has completed.
		 * 	
		 */
		requestContext3D(context3DRenderMode?: Context3DRenderMode, profile?: Context3DProfile): void;
		/**
		 * 		Request the creation of a Context3D object for this Stage3D instance.
		 * 
		 * 		Before calling this function, add an event listener for the `context3DCreate`
		 * 		event. If you do not, the runtime throws an exception.
		 * 
		 * 		**Important note on device loss:**
		 * 		GPU device loss occurs when the GPU hardware becomes unavailable to the
		 * 		application. The Context3D object is disposed when the GPU device is lost. GPU
		 * 		device loss can happen for various reasons, such as, when a mobile device runs out
		 * 		of battery power or a Windows device goes to a "lock screen." When the GPU becomes
		 * 		available again, the runtime creates a new Context3D instance and dispatches
		 * 		another `context3DCreate` event. Your application must reload all assets and reset
		 * 		the rendering context state whenever device loss occurs.
		 * 
		 * 		Design your application logic to handle the possibility of device loss and context
		 * 		regeneration. Do not remove the `context3DCreate` event listener. Do not perform
		 * 		actions in response to the event that should not be repeated in the application.
		 * 		For example, do not add anonymous functions to handle timer events because they
		 * 		would be duplicated after device loss. To test your application's handling of
		 * 		device loss, you can simulate device loss by calling the `dispose()` method of the
		 * 		Context3D object.
		 * 
		 * 		The following example illustrates how to request a Context3d rendering context:
		 * 
		 * 		```haxe
		 * 		if( stage.stage3Ds.length > 0 )
		 * 		{
		 * 			var stage3D:Stage3D = stage.stage3Ds[0];
		 * 			stage3D.addEventListener( Event.CONTEXT3D_CREATE, myContext3DHandler );
		 * 			stage3D.requestContext3DMatchingProfiles(Vector.ofValues(Context3DProfile.BASELINE, Context3DProfile.BASELINE_EXTENDED));
		 * 		}
		 * 
		 * 		function myContext3DHandler ( event : Event ) : Void
		 * 		{
		 * 			var targetStage3D : Stage3D = cast event.target;
		 * 			if(targetStage3D.context3D.profile.localeCompare(Context3DProfile.BASELINE) == 0)
		 * 			{
		 * 				InitAll3DResources( targetStage3D.context3D );
		 * 			}
		 * 			StartRendering( targetStage3D.context3D );
		 * 		}
		 * 		```
		 * 
		 * 		@param	profiles	(AIR 3.4 and higher) a profile arrays that developer want to
		 * 		use in their flash program. When developer pass profile array to
		 * 		`Stage3D.requestContext3DMatchingProfiles`, he will get a Context3D based on the
		 * 		high level profile in that array according to their hardware capability. The
		 * 		`rendermode` is set to AUTO, so the parameter is omitted.
		 * 		@event	context3DCreate	Dispatched when the requested rendering context is
		 * 		successfully completed.
		 * 		@event	error	Dispatched when the requested rendering context cannot be created.
		 * 		If the hardware is not available, it will not create a software context3d.
		 * 		@throws	Error	if no listeners for the context3DCreate event have been added to
		 * 		this Stage3D object.
		 * 		@throws	ArgumentError	if this method is called before the previous call has
		 * 		completed.
		 * 		@throws	ArgumentError	if the item in array is not openfl.display3D.Context3DProfile.
		 * 	
		 */
		requestContext3DMatchingProfiles(profiles: Vector<Context3DProfile>): void;
	}
}
export default openfl.display.Stage3D;