import { RENDERER_TYPE, SystemManager } from '@pixi/core'; import type { BackgroundSystem, BLEND_MODES, ColorSource, ExtensionMetadata, GenerateTextureSystem, ICanvas, ICanvasRenderingContext2D, IGenerateTextureOptions, IRenderableObject, IRenderer, IRendererOptions, IRendererPlugins, IRendererRenderOptions, Matrix, PluginSystem, Rectangle, RenderTexture, StartupSystem, ViewSystem } from '@pixi/core'; import type { DisplayObject } from '@pixi/display'; import type { CanvasContextSystem, SmoothingEnabledProperties } from './CanvasContextSystem'; import type { CanvasMaskSystem } from './CanvasMaskSystem'; import type { CanvasObjectRendererSystem } from './CanvasObjectRendererSystem'; export interface CanvasRenderer extends GlobalMixins.CanvasRenderer { } /** * The CanvasRenderer draws the scene and all its content onto a 2d canvas. * * This renderer should be used for browsers that support WebGL. * * This renderer should be used for browsers that do not support WebGL. * Don't forget to add the view to your DOM or you will not see anything! * * Renderer is composed of systems that manage specific tasks. The following systems are added by default * whenever you create a renderer: * * | System | Description | * | ------------------------------------ | ----------------------------------------------------------------------------- | * * | Generic Systems | Systems that manage functionality that all renderer types share | * | ------------------------------------ | ----------------------------------------------------------------------------- | * | {@link PIXI.ViewSystem} | This manages the main view of the renderer usually a Canvas | * | {@link PIXI.PluginSystem} | This manages plugins for the renderer | * | {@link PIXI.BackgroundSystem} | This manages the main views background color and alpha | * | {@link PIXI.StartupSystem} | Boots up a renderer and initiatives all the systems | * | {@link PIXI.EventSystem} | This manages UI events. | * | {@link PIXI.GenerateTextureSystem} | This adds the ability to generate textures from any PIXI.DisplayObject | * * | PixiJS High-Level Systems | Set of specific systems designed to work with PixiJS objects | * | ------------------------------------ | ----------------------------------------------------------------------------- | * | {@link PIXI.CanvasContextSystem} | This manages the canvas `2d` contexts and their state | * | {@link PIXI.CanvasMaskSystem} | This manages masking operations. | * | {@link PIXI.CanvasExtract} | This extracts image data from a PIXI.DisplayObject | * | {@link PIXI.CanvasPrepare} | This prepares a PIXI.DisplayObject async for rendering | * * The breadth of the API surface provided by the renderer is contained within these systems. * @class * @memberof PIXI */ export declare class CanvasRenderer extends SystemManager implements IRenderer { /** @ignore */ static extension: ExtensionMetadata; /** * Options passed to the constructor. * @member {PIXI.IRendererOptions} */ readonly options: IRendererOptions; /** * Used with autoDetectRenderer, this is always supported for any environment, so return true. * @ignore */ static test(): boolean; /** * Fired after rendering finishes. * @event PIXI.CanvasRenderer#postrender */ /** * Fired before rendering starts. * @event PIXI.CanvasRenderer#prerender */ /** * The type of the renderer. will be PIXI.RENDERER_TYPE.CANVAS * @member {number} * @see PIXI.RENDERER_TYPE */ readonly type = RENDERER_TYPE.CANVAS; /** When logging Pixi to the console, this is the name we will show */ readonly rendererLogId = "Canvas"; /** * textureGenerator system instance * @readonly */ textureGenerator: GenerateTextureSystem; /** * background system instance * @readonly */ background: BackgroundSystem; /** * canvas mask system instance * @readonly */ mask: CanvasMaskSystem; /** * plugin system instance * @readonly */ _plugin: PluginSystem; /** * Canvas context system instance * @readonly */ canvasContext: CanvasContextSystem; /** * Startup system instance * @readonly */ startup: StartupSystem; /** * View system instance * @readonly */ _view: ViewSystem; /** * renderer system instance * @readonly */ objectRenderer: CanvasObjectRendererSystem; /** * @param {PIXI.IRendererOptions} [options] - See {@link PIXI.settings.RENDER_OPTIONS} for defaults. */ constructor(options?: Partial); /** * Useful function that returns a texture of the display object that can then be used to create sprites * This can be quite useful if your displayObject is complicated and needs to be reused multiple times. * @param displayObject - The displayObject the object will be generated from. * @param {IGenerateTextureOptions} options - Generate texture options. * @param {PIXI.Rectangle} options.region - The region of the displayObject, that shall be rendered, * if no region is specified, defaults to the local bounds of the displayObject. * @param {number} [options.resolution] - If not given, the renderer's resolution is used. * @param {PIXI.MSAA_QUALITY} [options.multisample] - If not given, the renderer's multisample is used. * @returns A texture of the graphics object. */ generateTexture(displayObject: IRenderableObject, options?: IGenerateTextureOptions): RenderTexture; reset(): void; /** * Renders the object to its WebGL view. * @param displayObject - The object to be rendered. * @param options - Object to use for render options. * @param {PIXI.RenderTexture} [options.renderTexture] - The render texture to render to. * @param {boolean} [options.clear=true] - Should the canvas be cleared before the new render. * @param {PIXI.Matrix} [options.transform] - A transform to apply to the render texture before rendering. * @param {boolean} [options.skipUpdateTransform=false] - Should we skip the update transform pass? */ render(displayObject: DisplayObject, options?: IRendererRenderOptions): void; /** Clear the canvas of renderer. */ clear(): void; /** * Removes everything from the renderer and optionally removes the Canvas DOM element. * @param {boolean} [removeView=false] - Removes the Canvas element from the DOM. */ destroy(removeView?: boolean): void; /** Collection of plugins */ get plugins(): IRendererPlugins; /** * Resizes the canvas view to the specified width and height. * @param desiredScreenWidth - the desired width of the screen * @param desiredScreenHeight - the desired height of the screen */ resize(desiredScreenWidth: number, desiredScreenHeight: number): void; /** * Same as view.width, actual number of pixels in the canvas by horizontal. * @member {number} * @readonly * @default 800 */ get width(): number; /** * Same as view.height, actual number of pixels in the canvas by vertical. * @member {number} * @readonly * @default 600 */ get height(): number; /** The resolution / device pixel ratio of the renderer. */ get resolution(): number; set resolution(value: number); /** Whether CSS dimensions of canvas view should be resized to screen dimensions automatically. */ get autoDensity(): boolean; /** The canvas element that everything is drawn to.*/ get view(): ICanvas; /** * Measurements of the screen. (0, 0, screenWidth, screenHeight). * Its safe to use as filterArea or hitArea for the whole stage. */ get screen(): Rectangle; /** the last object rendered by the renderer. Useful for other plugins like interaction managers */ get lastObjectRendered(): IRenderableObject; /** Flag if we are rendering to the screen vs renderTexture */ get renderingToScreen(): boolean; /** * This sets if the CanvasRenderer will clear the canvas or not before the new render pass. * If the scene is NOT transparent PixiJS will use a canvas sized fillRect operation every * frame to set the canvas background color. If the scene is transparent PixiJS will use clearRect * to clear the canvas every frame. Disable this by setting this to false. For example, if * your game has a canvas filling background image you often don't need this set. */ get clearBeforeRender(): boolean; /** * Tracks the blend modes useful for this renderer. * @deprecated since 7.0.0 use `renderer.canvasContext.blendModes` instead */ get blendModes(): string[]; /** * system that manages canvas masks * @deprecated since 7.0.0 use `renderer.canvasContext.mask` */ get maskManager(): CanvasMaskSystem; /** * Boolean flag controlling canvas refresh. * @deprecated since 7.0.0 */ get refresh(): boolean; /** * The root canvas 2d context that everything is drawn with. * @deprecated since 7.0.0 Use `renderer.canvasContext.rootContext instead */ get rootContext(): ICanvasRenderingContext2D; /** * The currently active canvas 2d context (could change with renderTextures) * @deprecated since 7.0.0 Use `renderer.canvasContext.activeContext instead */ get context(): ICanvasRenderingContext2D; /** * The canvas property used to set the canvas smoothing property. * @deprecated since 7.0.0 Use `renderer.canvasContext.smoothProperty` instead. */ get smoothProperty(): SmoothingEnabledProperties; /** * Sets the blend mode of the renderer. * @param {number} blendMode - See {@link PIXI.BLEND_MODES} for valid values. * @param {boolean} [readyForOuterBlend=false] - Some blendModes are dangerous, they affect outer space of sprite. * Pass `true` only if you are ready to use them. * @deprecated since 7.0.0 Use `renderer.canvasContext.setBlendMode` instead. */ setBlendMode(blendMode: BLEND_MODES, readyForOuterBlend?: boolean): void; /** * Checks if blend mode has changed. * @deprecated since 7.0.0 Use `renderer.canvasContext.invalidateBlendMode` instead. */ invalidateBlendMode(): void; /** * Sets matrix of context. * called only from render() methods * takes care about resolution * @param transform - world matrix of current element * @param roundPixels - whether to round (tx,ty) coords * @param localResolution - If specified, used instead of `renderer.resolution` for local scaling * @deprecated since 7.0.0 - Use `renderer.canvasContext.setContextTransform` instead. */ setContextTransform(transform: Matrix, roundPixels?: boolean, localResolution?: number): void; /** * The background color to fill if not transparent * @deprecated since 7.0.0 */ get backgroundColor(): ColorSource; /** * @deprecated since 7.0.0 * @ignore */ set backgroundColor(value: ColorSource); /** * The background color alpha. Setting this to 0 will make the canvas transparent. * @member {number} * @deprecated since 7.0.0 */ get backgroundAlpha(): number; /** * @deprecated since 7.0.0 * @ignore */ set backgroundAlpha(value: number); /** * old abstract function not used by canvas renderer * @deprecated since 7.0.0 */ get preserveDrawingBuffer(): boolean; /** * old abstract function not used by canvas renderer * @deprecated since 7.0.0 */ get useContextAlpha(): boolean; /** @private */ static readonly __plugins: IRendererPlugins; /** @private */ static readonly __systems: Record; }