Class Rapid

The main application class for the Rapid rendering engine. Manages the WebGL context, rendering regions, state, and matrices.

Index

Constructors

constructor

Accessors

height width

Constructors

constructor

new Rapid(options: IAppOptions): Rapid
Creates a new Rapid application instance.
Parameters
- options: IAppOptions
  Initialization options including the target canvas.
Returns Rapid
- Defined in render.ts:204

Properties

antialias

antialias: boolean

Default texture filtering preference and requested canvas MSAA setting.

atlasSpriteRegion

atlasSpriteRegion: AtlasSpriteRegion

backgroundColor

backgroundColor: Color = Color.Black

Background clear color [r, g, b, a], values range from 0 to 255.

canvas

canvas: HTMLCanvasElement

The target HTMLCanvasElement.

currentRegion

currentRegion: Region | null = null

The currently active rendering region.

dpr

dpr: number

The current device pixel ratio.

drawcallCount

drawcallCount: number = 0

Counts the number of WebGL draw calls made in the current frame.

gl

gl: WebGL2RenderingContext

The active WebGL context.

graphicRegion

graphicRegion: GraphicRegion

Region dedicated to arbitrary geometry and shapes rendering.

inCreateMask

inCreateMask: boolean = false

Indicates whether we are currently writing to the stencil buffer to create a mask.

logicHeight

logicHeight: number = 0

Logical height in CSS pixels, used for coordinate system and projection matrix.

logicWidth

logicWidth: number = 0

Logical width in CSS pixels, used for coordinate system and projection matrix.

matrix

matrix: MatrixStore

Direct access to the underlying matrix store.

matrixStack

matrixStack: MatrixStack = ...

Matrix stack for hierarchical transformations.

maxTextureUnits

maxTextureUnits: number = 0

Maximum number of texture units supported by the device.

particleRegion

particleRegion: ParticleRegion

physicsHeight

physicsHeight: number = 0

Physical height (canvas actual pixels = logical height * dpr).

physicsWidth

physicsWidth: number = 0

Physical width (canvas actual pixels = logical width * dpr).

premultipliedAlpha

premultipliedAlpha: boolean

Whether textures use premultiplied alpha. Set once at construction.

projection

projection: Float32Array = ...

The current orthographic projection matrix (16 elements).

projectionDirty

projectionDirty: boolean = true

Indicates if the projection matrix has changed and needs to be uploaded to shaders.

roundPixels

roundPixels: boolean

`Optional`scaleMode

scaleMode?: CanvasScaleMode

spriteRegion

spriteRegion: SpriteRegion

Region dedicated to fast sprite rendering.

texture

texture: TextureManager

Manager for creating and organizing textures.

textureFilter

textureFilter: TextureFilterMode

Default filtering mode used when sampling textures.

Accessors

height

get height(): number
Returns number
- Defined in render.ts:194

width

get width(): number
Returns number
- Defined in render.ts:197

Methods

addCircleVertex

addCircleVertex(r: number, color?: Color, segments?: number): void
Pushes vertices for a circle geometry using TRIANGLES or similar primitives.
Parameters
- r: number
  The radius of the circle.
- Optionalcolor: Color
  An optional tint color.
- segments: number = 32
  The number of segments (polygons) used to approximate the circle.
Returns void
- Defined in render.ts:361

addGraphicVertex

addGraphicVertex(
    x: number,
    y: number,
    u?: number,
    v?: number,
    color: number | Color,
): void
Adds an individual vertex to the current graphics batch.
Parameters
- x: number
  The relative X coordinate of the vertex.
- y: number
  The relative Y coordinate of the vertex.
- u: number = 0
  The U texture coordinate (0 to 1).
- v: number = 0
  The V texture coordinate (0 to 1).
- color: number | Color
  The vertex color as a 32-bit unsigned integer.
Returns void
- Defined in render.ts:382

addRectVertex

addRectVertex(w: number, h: number, color?: Color): void
Pushes vertices for a rectangle geometry. Should be enclosed by startGraphic and endGraphic.
Parameters
- w: number
  The width of the rectangle.
- h: number
  The height of the rectangle.
- Optionalcolor: Color
  An optional tint color.
Returns void
- Defined in render.ts:347

applyCamera

applyCamera(transform: ITransformOptions): void
Parameters
- transform: ITransformOptions
Returns void
- Defined in render.ts:886

applyFilters

applyFilters(source: Texture, shaders: CustomGlShader[]): RenderTexture
Applies a chain of shaders to a texture sequentially using ping-pong RenderTextures. Each shader receives the output of the previous one as its input. Two internal RenderTextures are reused across calls (resized as needed).
Parameters
- source: Texture
  The input texture to start the filter chain from.
- shaders: CustomGlShader[]
  An ordered array of CustomGlShader to apply in sequence.
Returns RenderTexture
The RenderTexture containing the final filtered result. Draw it with rapid.drawSprite({ texture: result }) to display it on screen.
Example
```
const result = rapid.applyFilters(tex, [blurShader, outlineShader]);
rapid.drawSprite({ texture: result });
```
- Defined in render.ts:511

clear

clear(): void
Clears the active framebuffer applying the default background color.

Returns void
- Defined in render.ts:456

clearMask

clearMask(mask?: number): void
Clears bounds created into the stencil mask.
Parameters
- mask: number = 0xFF
  The bitmask specifying which stencil layer to clear.
Returns void
- Defined in render.ts:773

clearRenderTexture

clearRenderTexture(color?: Color): void
Clears a RenderTexture to a solid color. Must be called while the RT is the active render target (i.e. inside enterRenderTexture/leaveRenderTexture). Can also be called standalone — it will bind the RT, clear it, but NOT restore the main framebuffer.
Parameters
- color: Color = ...
  Clear color. Defaults to transparent black (0, 0, 0, 0).
Returns void
- Defined in render.ts:592

cssToDevicePixel

cssToDevicePixel(p: Vec2): Vec2
Parameters
- p: Vec2
Returns Vec2
- Defined in render.ts:907

cssToLogic

cssToLogic(p: Vec2): Vec2
Parameters
- p: Vec2
Returns Vec2
- Defined in render.ts:911

devicePixelToCss

devicePixelToCss(p: Vec2): Vec2
Parameters
- p: Vec2
Returns Vec2
- Defined in render.ts:917

drawCircle

drawCircle(options: ICircleOptions): void
Parameters
- options: ICircleOptions
Returns void
- Defined in render.ts:304

drawGraphic

drawGraphic(options: IGraphicOptions): void
Parameters
- options: IGraphicOptions
Returns void
- Defined in render.ts:296

drawLine

drawLine(options: ILineOptions): void
Parameters
- options: ILineOptions
Returns void
- Defined in render.ts:292

drawMaskImage

drawMaskImage(options: IMaskImageOptions): void
Utility method: Draws an image directly as a mask using a generic rectangle geometry.
Parameters
- options: IMaskImageOptions
Returns void
- Defined in render.ts:337

drawParticles

drawParticles(options: IDrawParticleBatchOptions): void
Parameters
- options: IDrawParticleBatchOptions
Returns void
- Defined in render.ts:284

drawRect

drawRect(options: IRectOptions): void
Parameters
- options: IRectOptions
Returns void
- Defined in render.ts:300

drawSprite

drawSprite(options: ISpriteOptions): void
Parameters
- options: ISpriteOptions
Returns void
- Defined in render.ts:288

drawToRenderTexture

drawToRenderTexture(
    rt: RenderTexture,
    cb: () => void,
    color?: Color | null,
): void
Convenience wrapper: enters a RenderTexture, optionally clears it, runs a callback, then leaves.
Parameters
- rt: RenderTexture
  The RenderTexture to render into.
- cb: () => void
  The callback containing draw calls to execute inside the RT.
- color: Color | null = ...
  Clear color before rendering. Pass null to skip clearing. Defaults to transparent black.
Returns void
Example
```
rapid.drawToRenderTexture(myRT, () => {
    rapid.drawSprite({ texture: mySprite });
});
```
- Defined in render.ts:621

endDrawMask

endDrawMask(): void
Finishes the mask drawing phase and restores color buffer writing.

Returns void
- Defined in render.ts:761

endGraphic

endGraphic(): void
Ends the current graphics geometry definition, readying it for rendering.

Returns void
- Defined in render.ts:393

endScissor

endScissor(): void
Disables scissor clipping, restoring full-canvas rendering.

Returns void
- Defined in render.ts:881

enterMask

enterMask(type: MaskType, ref?: number, mask?: number): void
Enters a constrained rendering phase masked by the existing stencil buffer values.
Parameters
- type: MaskType
  Equality check type. Use "equal" to draw inside the mask, or "notEqual" to draw outside.
- ref: number = 1
  The reference value to test against.
- mask: number = 0xFF
  The bitmask specifying which stencil bits to consider.
Returns void
- Defined in render.ts:787

enterRegion

enterRegion(region: Region, customShader?: GLShader | CustomGlShader): void
Enters a specific rendering region, flushing the previous one if necessary.
Parameters
- region: Region
  The rendering region to enter.
- OptionalcustomShader: GLShader | CustomGlShader
  An optional custom shader to use for this region.
Returns void
- Defined in render.ts:275

enterRenderTexture

enterRenderTexture(rt: RenderTexture): void
Parameters
- rt: RenderTexture
Returns void
- Defined in render.ts:577

exitMask

exitMask(): void
Exits the masked rendering phase, restoring default full-screen stencil values tests.

Returns void
- Defined in render.ts:801

flush

flush(): void
Flushes currently buffered rendering operations across all active regions.

Returns void
- Defined in render.ts:490

getColorUint32

getColorUint32(color?: Color): number
Parameters
- Optionalcolor: Color
Returns number
- Defined in render.ts:266

leaveRenderTexture

leaveRenderTexture(): void
Completes rendering to an offscreen render texture and reverts rendering back to the main canvas.

Returns void
- Defined in render.ts:602

logicToPhysics

logicToPhysics(p: Vec2): Vec2
Parameters
- p: Vec2
Returns Vec2
- Defined in render.ts:893

physicsToLogic

physicsToLogic(p: Vec2): Vec2
Parameters
- p: Vec2
Returns Vec2
- Defined in render.ts:900

resize

resize(
    logicWidth: number,
    logicHeight: number,
    cssWidth?: number,
    cssHeight?: number,
): void
Resizes the canvas, updates internal viewport values, and recreates projection boundaries.
Parameters
- logicWidth: number
  The new logical display width.
- logicHeight: number
  The new logical display height.
- OptionalcssWidth: number
  Optional CSS display width.
- OptionalcssHeight: number
  Optional CSS display height.
Returns void
- Defined in render.ts:404

setAntialias

setAntialias(antialias: boolean): void
Parameters
- antialias: boolean
Returns void
- Defined in render.ts:262

setBlendMode

setBlendMode(mode: BlendMode): void
Configures the global WebGL blending behavior.
Parameters
- mode: BlendMode
  The targeted BlendMode to switch onto.
Returns void
- Defined in render.ts:816

setTextureFilter

setTextureFilter(filter: TextureFilterMode): void
Parameters
- filter: TextureFilterMode
Returns void
- Defined in render.ts:258

startDrawMask

startDrawMask(ref?: number, mask?: number): void
Starts drawing into the stencil buffer to construct a rendering mask.
Parameters
- ref: number = 1
  The stencil reference value.
- mask: number = 0xFF
  The stencil bitmask.
Returns void
- Defined in render.ts:743

startGraphic

startGraphic(
    drawMode?: number,
    texture?: Texture,
    customShader?: GLShader | CustomGlShader,
    customMatrix?: number,
): void
Starts rendering arbitrary graphics geometries.
Parameters
- drawMode: number = ...
  The WebGL drawing mode (e.g., gl.TRIANGLES, gl.TRIANGLE_FAN).
- Optionaltexture: Texture
  An optional texture applied to the graphic vertices.
- OptionalcustomShader: GLShader | CustomGlShader
  An optional custom shader overriding the region's default shader.
- OptionalcustomMatrix: number
Returns void
- Defined in render.ts:314

startMaskGraphic

startMaskGraphic(
    drawMode?: number,
    texture?: Texture,
    customMatrix?: number,
): void
Starts rendering graphics explicitly for use as a mask, overriding the shader.
Parameters
- drawMode: number = ...
  The WebGL drawing mode (e.g., gl.TRIANGLES).
- Optionaltexture: Texture
  An optional texture whose alpha channel may dictate masking rules.
- OptionalcustomMatrix: number
Returns void
- Defined in render.ts:329

startScissor

startScissor(x: number, y: number, width: number, height: number): void
Enables rectangular scissor clipping. Only pixels within the specified rectangle (in logical coordinates) will be rendered. Coordinates use the same system as your drawing calls (top-left origin).
Parameters
- x: number
  Left edge in logical pixels.
- y: number
  Top edge in logical pixels.
- width: number
  Width in logical pixels.
- height: number
  Height in logical pixels.
Returns void
- Defined in render.ts:862

toCSSMatrix

toCSSMatrix(index?: number): string
Exports a world matrix as a CSS matrix(...) string, ready to assign directly to a DOM element's style.transform. Unlike matrixStack.toCSSMatrix(), this bakes in the logic-pixel → CSS-pixel scale (accounting for dpr and a custom logicWidth/logicHeight), so the result lines up with the canvas without any extra scale(...) on your end.
Parameters
- Optionalindex: number
  Matrix index to export. Defaults to the current world matrix.
Returns string
- Defined in render.ts:929

withBlendMode

withBlendMode(mode: BlendMode, cb: () => void): void
Convenience wrapper: sets a blend mode, runs a callback, then restores NORMAL blend mode.
Parameters
- mode: BlendMode
  The BlendMode to apply for the duration of the callback.
- cb: () => void
  The callback to execute under the given blend mode.
Returns void
Example
```
rapid.withBlendMode(BlendMode.ADD, () => {
    rapid.drawSprite({ texture: glowTexture });
});
```
- Defined in render.ts:729

withMask

withMask(
    maskCb: () => void,
    drawCb: () => void,
    type?: MaskType,
    ref?: number,
): void
Convenience wrapper: writes a mask using the stencil buffer, then renders within it, then exits the mask.
Parameters
- maskCb: () => void
  Callback that defines the mask geometry (drawn to stencil, not visible).
- drawCb: () => void
  Callback containing the actual draw calls masked by the stencil.
- type: MaskType = MaskType.EQUAL
  Mask type: EQUAL (draw inside) or NOT_EQUAL (draw outside). Defaults to EQUAL.
- ref: number = 1
  Stencil reference value. Defaults to 1.
Returns void
Example
```
rapid.withMask(
    () => rapid.drawRect({ width: 200, height: 200 }),
    () => rapid.drawSprite({ texture: myTexture }),
);
```
- Defined in render.ts:646

withScissor

withScissor(
    x: number,
    y: number,
    width: number,
    height: number,
    cb: () => void,
): void
Convenience wrapper: enables scissor clipping for a region, runs a callback, then disables it.
Parameters
- x: number
  Left edge in logical pixels.
- y: number
  Top edge in logical pixels.
- width: number
  Width in logical pixels.
- height: number
  Height in logical pixels.
- cb: () => void
  The callback to execute within the scissor region.
Returns void
Example
```
rapid.withScissor(50, 50, 300, 200, () => {
    rapid.drawSprite({ texture: myTexture });
});
```
- Defined in render.ts:710

withTransform

withTransform(
    cb: () => void,
    transform?: ITransformOptions,
    width?: number,
    height?: number,
): void
Convenience wrapper: saves the matrix stack, applies an optional transform, runs a callback, then restores. When transform is provided, delegates to matrixStack.applyTransform() which handles position, rotation, scale, offset, and origin automatically.
Parameters
- cb: () => void
  The callback to execute within the saved transform context.
- Optionaltransform: ITransformOptions
  Optional transform options to apply before running the callback.
- width: number = 0
  The logical width used to resolve origin anchoring. Defaults to 0.
- height: number = 0
  The logical height used to resolve origin anchoring. Defaults to 0.
Returns void
Example
```
// Simple save/restore
rapid.withTransform(() => {
    rapid.matrixStack.translate(100, 100);
    rapid.drawSprite({ texture: myTexture });
});
```
Example
```
// With a transform applied
rapid.withTransform(() => {
    rapid.drawSprite({ texture: myTexture });
}, { x: 100, y: 50, rotation: Math.PI / 4, origin: 0.5 }, myTexture.width, myTexture.height);
```
- Defined in render.ts:685

Class Rapid

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Returns Rapid

Properties

antialias

atlasSpriteRegion

backgroundColor

canvas

currentRegion

dpr

drawcallCount

gl

graphicRegion

inCreateMask

logicHeight

logicWidth

matrix

matrixStack

maxTextureUnits

particleRegion

physicsHeight

physicsWidth

premultipliedAlpha

projection

projectionDirty

roundPixels

OptionalscaleMode

spriteRegion

texture

textureFilter

Accessors

height

Returns number

width

Returns number

Methods

addCircleVertex

Parameters

Returns void

addGraphicVertex

Parameters

Returns void

addRectVertex

Parameters

Returns void

applyCamera

Parameters

Returns void

applyFilters

Parameters

Returns RenderTexture

Example

clear

Returns void

clearMask

Parameters

Returns void

clearRenderTexture

Parameters

Returns void

cssToDevicePixel

Parameters

Returns Vec2

cssToLogic

Parameters

Returns Vec2

devicePixelToCss

Parameters

Returns Vec2

drawCircle

Parameters

Returns void

drawGraphic

`Optional`scaleMode