• Public
  • Public/Protected
  • All

Class Renderer

Base class for hardware-accelerated processing and/or image-synthesis. It provides information such as the current canvas, the canvas's size (native resolution), and the multi-frame number (for progressive rendering). A renderer's properties are expected to be managed by its owning object or the canvas and should not be set directly/manually. Alterations to these properties can be tracked with the _altered property. This allows an inheritor to implement partial asset reallocation and, e.g., speed up dynamic multi-frame reconfiguration. The alterable object can be extended using Object.assign(this._alterable, ... some structure of booleans).

This base class further provides the invalidate method that invokes an invalidation callback also provided by the owning/controlling canvas.

Since Initializable is extended, the initialization workflow applies to all specialized renderers (requires super calls in constructor as well as in initialize and uninitialize).

Note that a renderer is currently intended to always render to the canvas it is bound to. Hence, there is no interface for setting a frame target.





Protected _altered

_altered: ChangeLookup & object = Object.assign(new ChangeLookup(), {any: false, multiFrameNumber: false, frameSize: false, canvasSize: false, framePrecision: false,clearColor: false, debugTexture: false,})

Alterable auxiliary object for tracking changes on renderer input and lazy updates.

Protected _canvasSize

_canvasSize: GLsizei2 = [0, 0]

Actual, native resolution for the canvas currently in charge of controlling the renderer. This might differ from the targeted frame resolution but is required, e.g., for specific non-proportional ratios between frame size and canvas size.

Protected _clearColor

_clearColor: GLclampf4 = [0.0, 0.0, 0.0, 1.0]

The clear color, provided by the canvas the renderer is bound to. This is used in frame calls of inheritors.

Protected _context

_context: Context


Protected _debugTexture

_debugTexture: GLint

debugTexture This property can be observed, e.g., aRenderer.debugTextureObservable.subscribe().

Protected _debugTextureSubject

_debugTextureSubject: ReplaySubject<number> = new ReplaySubject<GLint>(1)

Protected _debugTextures

_debugTextures: string[] = new Array<string>()

List of textures for debugging purposes such as normals, ids, depth, masks, etc. that can be populated by the inheritor. The index of a texture identifier can then be for specifying a debug output of a render texture.

Protected _framePrecision

_framePrecision: Precision = Wizard.Precision.half

Targeted frame precision, e.g., used for frame accumulation. Note that any renderer is currently expected to take advantage of progressive rendering (e.g., multi-frame sampling) and accumulation as well as a blit pass (since main intend is multi-frame based rendering).

Protected _frameSize

_frameSize: GLsizei2 = [0, 0]

Targeted resolution for image synthesis. This might differ from the canvas resolution and should be used in frame calls of inheritors.

Protected _invalidate

_invalidate: Invalidate

The renderer's invalidation callback. This should usually be setup by the canvas and refer to a function in the canvas's controller, e.g., it should trigger an update within the controller.

Protected _multiFrameNumber

_multiFrameNumber: number

This multi-frame number is for lazy reconfiguration and set on update. The inheritor can react to changes using this.altered.multiFrameNumber.


Protected altered

  • get altered(): boolean
  • Whether or not any of the (relevant/monitored) rendering properties has been altered. This concept should be used by other classes (e.g., camera, rendering stages) for detecting modifications relevant for rendering output.

    Returns boolean

Protected canvasSize


  • Sets the color used for clearing the background. This setter should only be used by the canvas this renderer is bound to. Changing the frame size invalidates the renderer.


    • color: GLclampf4

      Red, green, blue, and alpha color components.

    Returns void

Protected context

  • Context that can be used for processing and rendering as well as passed to rendering stages.

    Returns Context


  • get debugTexture(): GLint
  • set debugTexture(index: GLint): void
  • The render texture index for debug output. This is -1 when debug output is disabled. This should be used in the renderers swap implementation.

    Returns GLint

  • Enables to specify the index of a render texture to be blit to the back buffer for debugging. This invalidates but should result in a blit only if nothing else changed. When the requested debug texture was blit (and debugTexture was actually altered) this.debugTextureNext() should be called to inform observers.


    • index: GLint

      Render texture index based on debuggableTextures array. This should be in [-1, length of array].

    Returns void


  • get debugTexture$(): Observable<GLint>
  • Observable that can be used to subscribe to debug texture changes.

    Returns Observable<GLint>


  • get debugTextures(): Array<string>
  • Read only access to the renderers registered render textures that can be blit to the back buffer for debugging.

    Returns Array<string>

    • Array of render texture identifiers.


  • set framePrecision(precision: Precision): void


  • Changes the frame size for rendering. This setter should only be used by the canvas this renderer is bound to. Changing the frame size invalidates the renderer.

    Note: the frame size is detached from the canvas size. When blitting the frame into the canvas, the frame is rescaled to fill or fit the canvas size.


    • size: GLsizei2

      Resolution of the framebuffer.

    Returns void


  • get initialized(): boolean


Protected assertInitialized

  • assertInitialized(): void
  • Asserts the objects initialization status to be true. Note that the implementation is cached and forwarded to either an empty function when initialized and to an acutal assert(false) otherwise.

    Returns void

Protected assertUninitialized

  • assertUninitialized(): undefined
  • Asserts the objects initialization status to be false. Note that the implementation is cached and forwarded to either an empty function when uninitialized and to an acutal assert(false) otherwise.

    Returns undefined

Protected debugTextureNext

  • debugTextureNext(): void
  • Utility for communicating this._debugTexture changes to its associated subject.

    Returns void


  • frame(frameNumber: number): void
  • Controllable interface intended to trigger rendering of a full pass of the renderer that results in either an intermediate frame for accumulation to a full multi-frame or full frame for itself. The inheritor should invoke frames of relevant rendering and processing stages.


    • frameNumber: number

      The current frame number forwarded to onFrame.

    Returns void


  • frameCoords(x: GLint, y: GLint): GLfloat2
  • Transforms local viewport coordinates into local intermediate frame coordinates.


    • x: GLint

      Horizontal coordinate for the upper left corner of the viewport origin.

    • y: GLint

      Vertical coordinate for the upper left corner of the viewport origin.

    Returns GLfloat2


  • When extending (specializing) this class, initialize should initialize all required stages and allocate assets that are shared between multiple stages. Note that super.initialize() should always be call first when 'overriding' this function.

    Note: the context handle is stored in a property, but should be passed to the stages by specializing renderer instead. The renderer itself should not allocate rendering resources directly, thus, it should not require a webgl context.


    • context: Context

      Wrapped gl context for function resolution (passed to all stages).

    • callback: Invalidate

      Functions that is invoked when the renderer (or any stage) is invalidated.

    • mouseEventProvider: MouseEventProvider | undefined

      Provider for mouse events referring to the canvas element.

    • touchEventProvider: TouchEventProvider | undefined

    Returns boolean

Protected invalidate

  • invalidate(force?: boolean): void
  • callback

    Invalidate A callback intended to be invoked whenever the specialized renderer itself or one of its objects is invalid. This callback should be passed during initialization to all objects that might handle invalidation internally as well. As a result, rendering of a new frame will be triggered and enforced.


    • Default value force: boolean = false

    Returns void

Protected Abstract onFrame

  • onFrame(frameNumber: number): void
  • Actual frame call specified by inheritor. After (1) update and (2) preparation are invoked, a frame is invoked. This should be used for actual rendering implementation.


    • frameNumber: number

    Returns void

Protected Abstract onInitialize

Protected Abstract onPrepare

  • onPrepare(): void
  • Actual prepare call specified by inheritor. This is invoked in order to prepare rendering of one or more frames. This should be used for rendering preparation, e.g., when using multi-frame rendering this might specify uniforms that do not change for every intermediate frame.

    Returns void

Protected onSwap

  • onSwap(): void
  • Actual swap call specified by inheritor. After (1) update, (2) preparation, and (3) frame are invoked, a swap might be invoked. In case of experimental batch rendering when using multi-frame a swap might be withhold for multiple frames. Any implementation is expected to ensure that contents of a frame to be on the OpenGL back buffer. The swap of front buffer and back buffer is scheduled after the invocation of this function by the browser.

    Returns void

Protected Abstract onUninitialize

  • onUninitialize(): void
  • Actual uninitialize call specified by inheritor.

    Returns void

Protected Abstract onUpdate

  • onUpdate(): boolean
  • Actual update call specified by inheritor. This is invoked in order to check if rendering of a frame is required by means of implementation specific evaluation (e.g., lazy non continuous rendering). Regardless of the return value a new frame (preparation, frame, swap) might be invoked anyway, e.g., when update is forced or canvas or context properties have changed or the renderer was invalidated @seeinvalidate.

    Returns boolean

    • Whether to redraw


  • prepare(): void
  • Prepares the rendering of the next frame (or subsequent frames when multi-frame rendering). This is part of the controllable interface. The renderer should reconfigure as lazy as possible.

    Returns void


  • swap(): void


  • uninitialize(): void
  • Should release all assets and uninitialize all stages. super.uninitialize() should always be call first when overriding this function.

    Returns void


  • update(multiFrameNumber: number): boolean

Static Protected assertInitializedFalse

Static Protected assertUninitializedFalse

Static assert_initialized

Static assert_uninitialized

Static initialize

  • Method decorator for initialization of Initializable inheritors. This decorator asserts the initialization status of the instance that is to be initialized, invokes its initialization with arbitrary number of parameters, and sets the initialization status to the initialization success (either false or true). In order to encourage the use of assertInitialized and assertUninitialized they are dynamically bound to either a static, always-failing assert or an empty/undefined function.

    Returns MethodDecorator

Static uninitialize

  • Method decorator for uninitialization of Initializable inheritors. This decorator asserts the initialization status of the instance that is to be uninitialized, invokes its uninitialization, and falsifies the initialization status. In order to encourage the use of assertInitialized and assertUninitialized they are dynamically bound to a static, always-failing assert and an empty/undefined function respectively.

    Returns MethodDecorator