pixi.js
    Preparing search index...

    Class AbstractRenderer<PIPES, OPTIONS, CANVAS>Abstract Advanced

    The base class for a PixiJS Renderer. It contains the shared logic for all renderers.

    You should not use this class directly, but instead use WebGLRenderer or WebGPURenderer. Alternatively, you can also use autoDetectRenderer if you want us to determine the best renderer for you.

    The renderer is composed of systems that manage specific tasks. The following systems are added by default whenever you create a renderer:

    Generic Systems Systems that manage functionality that all renderer types share
    ViewSystem This manages the main view of the renderer usually a Canvas
    BackgroundSystem This manages the main views background color and alpha
    EventSystem This manages UI events.
    AccessibilitySystem This manages accessibility features. Requires import 'pixi.js/accessibility'
    Core Systems Provide an optimised, easy to use API to work with WebGL/WebGPU
    GlobalUniformSystem This manages shaders, programs that run on the GPU to calculate 'em pixels.
    TextureGCSystem This will automatically remove textures from the GPU if they are not used.
    PixiJS High-Level Systems Set of specific systems designed to work with PixiJS objects
    HelloSystem Says hello, buy printing out the pixi version into the console log (along with the renderer type)
    GenerateTextureSystem This adds the ability to generate textures from any Container
    FilterSystem This manages the filtering pipeline for post-processing effects.
    PrepareSystem This manages uploading assets to the GPU. Requires import 'pixi.js/prepare'
    ExtractSystem This extracts image data from display objects.

    The breadth of the API surface provided by the renderer is contained within these systems.

    Type Parameters

    Hierarchy (View Summary)

    • EventEmitter<
          {
              resize: [screenWidth: number, screenHeight: number, resolution: number];
          },
      >
    Index

    Constructors

    Properties

    background: BackgroundSystem

    The background system manages the background color and alpha of the main view.

    name: string

    The name of the renderer.

    textureGenerator: GenerateTextureSystem

    System that manages the generation of textures from the renderer

    The view system manages the main canvas that is attached to the DOM

    defaultOptions: {
        failIfMajorPerformanceCaveat: boolean;
        resolution: number;
        roundPixels: boolean;
    } = ...

    The default options for the renderer.

    Type declaration

    • failIfMajorPerformanceCaveat: boolean

      Should the failIfMajorPerformanceCaveat flag be enabled as a context option used in the isWebGLSupported function. If set to true, a WebGL renderer can fail to be created if the browser thinks there could be performance issues when using WebGL.

      In PixiJS v6 this has changed from true to false by default, to allow WebGL to work in as many scenarios as possible. However, some users may have a poor experience, for example, if a user has a gpu or driver version blacklisted by the browser.

      If your application requires high performance rendering, you may wish to set this to false. We recommend one of two options if you decide to set this flag to false:

      1: Use the Canvas renderer as a fallback in case high performance WebGL is not supported.

      2: Call isWebGLSupported (which if found in the utils package) in your code before attempting to create a PixiJS renderer, and show an error message to the user if the function returns false, explaining that their device & browser combination does not support high performance WebGL. This is a much better strategy than trying to create a PixiJS renderer and finding it then fails.

      false
      
    • resolution: number

      Default resolution / device pixel ratio of the renderer.

      1
      
    • roundPixels: boolean

      Should round pixels be forced when rendering?

      false
      

    Accessors

    • get canvas(): CANVAS

      The canvas element that everything is drawn to.

      Returns CANVAS

    • get height(): number

      Same as view.height, actual number of pixels in the canvas by vertical.

      Returns number

      600
      
    • get lastObjectRendered(): Container

      the last object rendered by the renderer. Useful for other plugins like interaction managers

      Returns Container

    • get renderingToScreen(): boolean

      Flag if we are rendering to the screen vs renderTexture

      Returns boolean

      true
      
    • get resolution(): number

      The resolution / device pixel ratio of the renderer.

      Returns number

    • set resolution(value: number): void

      Parameters

      • value: number

      Returns void

    • get roundPixels(): boolean

      Whether the renderer will round coordinates to whole pixels when rendering. Can be overridden on a per scene item basis.

      Returns boolean

    • get screen(): Rectangle

      Measurements of the screen. (0, 0, screenWidth, screenHeight).

      Its safe to use as filterArea or hitArea for the whole stage.

      Returns Rectangle

    • get width(): number

      Same as view.width, actual number of pixels in the canvas by horizontal.

      Returns number

      800
      

    Methods

    • Advanced

      Clears the render target.

      Parameters

      • options: ClearOptions = {}

        The options to use when clearing the render target.

        The options for clearing the render target.

        • Optionalclear?: CLEAR_OR_BOOL

          The clear mode to use.

        • OptionalclearColor?: ColorSource

          The color to clear with.

        • Optionaltarget?: RenderSurface

          The render target to render. if this target is a canvas and you are using the WebGL renderer, please ensure you have set multiView to true on renderer.

      Returns void

    • Advanced

      Resets the rendering state of the renderer. This is useful when you want to use the WebGL context directly and need to ensure PixiJS's internal state stays synchronized. When modifying the WebGL context state externally, calling this method before the next Pixi render will reset all internal caches and ensure it executes correctly.

      This is particularly useful when combining PixiJS with other rendering engines like Three.js:

      // Reset Three.js state
      threeRenderer.resetState();

      // Render a Three.js scene
      threeRenderer.render(threeScene, threeCamera);

      // Reset PixiJS state since Three.js modified the WebGL context
      pixiRenderer.resetState();

      // Now render Pixi content
      pixiRenderer.render(pixiScene);

      Returns void

    • Resizes the WebGL view to the specified width and height.

      Parameters

      • desiredScreenWidth: number

        The desired width of the screen.

      • desiredScreenHeight: number

        The desired height of the screen.

      • Optionalresolution: number

        The resolution / device pixel ratio of the renderer.

      Returns void