modern-canvas 0.13.6 → 0.14.0

package/dist/Engine.d.ts

@@ -1,6 +1,7 @@
-import type { SceneTreeEvents, SceneTreeProperties } from './scene';
-import { WebGLRenderer } from './core';
+import type { Node, SceneTreeEvents, SceneTreeProperties } from './scene';
+import { GlRenderer } from './core';
 import { SceneTree } from './scene';
+export type EngineData = Record<string, any> | Node | (Node | Record<string, any>)[];
 export interface EngineProperties extends WebGLContextAttributes, SceneTreeProperties {
     view?: HTMLCanvasElement | WebGLRenderingContext | WebGL2RenderingContext;
     width?: number;
@@ -8,6 +9,7 @@ export interface EngineProperties extends WebGLContextAttributes, SceneTreePrope
     pixelRatio?: number;
     autoResize: boolean;
     autoStart: boolean;
+    data?: EngineData;
 }
 interface EngineEvents extends SceneTreeEvents {
 }
@@ -28,7 +30,7 @@ export declare const defaultOptions: {
 export declare class Engine extends SceneTree {
     autoResize: boolean;
     autoStart: boolean;
-    readonly renderer: WebGLRenderer;
+    readonly renderer: GlRenderer;
     get view(): HTMLCanvasElement | undefined;
     get gl(): WebGLRenderingContext | WebGL2RenderingContext;
     get screen(): {

package/dist/core/index.d.ts

@@ -5,5 +5,5 @@ export * from './io';
 export * from './math';
 export * from './object';
 export * from './os';
-export * from './renderer';
+export * from './renderers';
 export * from './shared';

package/dist/core/math/{Rect2.d.ts → Rectangle.d.ts}

@@ -1,18 +1,32 @@
 import type { Vector2Data } from './Vector2';
 import { Vector2 } from './Vector2';
-export declare class Rect2 {
+export interface RectangleLike {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class Rectangle implements RectangleLike {
     get x(): number;
+    set x(val: number);
     get y(): number;
+    set y(val: number);
     get left(): number;
+    set left(val: number);
     get top(): number;
+    set top(val: number);
     get right(): number;
+    set right(val: number);
     get bottom(): number;
+    set bottom(val: number);
     get width(): number;
+    set width(val: number);
     get height(): number;
+    set height(val: number);
     readonly end: Vector2;
     readonly position: Vector2;
     readonly size: Vector2;
-    constructor(from: Rect2);
+    constructor(from: RectangleLike);
     constructor(pointArray: Vector2Data[]);
     constructor(position: Vector2Data, size: Vector2Data);
     constructor(x: number, y: number, width: number, height: number);

package/dist/core/math/index.d.ts

@@ -5,7 +5,7 @@ export * from './Matrix2';
 export * from './Matrix3';
 export * from './Matrix4';
 export * from './Projection2D';
-export * from './Rect2';
+export * from './Rectangle';
 export * from './Transform2D';
 export * from './utils';
 export * from './Vector';

package/dist/core/renderers/gl/GlBatch2DSystem.d.ts

@@ -0,0 +1,44 @@
+import type { BufferLike, GeometryAttributeLike, TextureLike } from '../shared';
+import type { GlDrawOptions } from './geometry';
+import type { GlRenderer } from './GlRenderer';
+import { GlBlendMode, GlState } from './state';
+import { GlSystem } from './system';
+export interface Batchable2D {
+    vertices: Float32Array;
+    indices: Uint32Array;
+    uvs?: Float32Array;
+    size?: {
+        width: number;
+        height: number;
+    };
+    texture?: TextureLike;
+    blendMode?: GlBlendMode;
+    roundPixels?: boolean;
+    clipOutsideUv?: boolean;
+}
+interface Shader {
+    update: (bufferData: BufferLike['data'], indexBufferData: BufferLike['data']) => void;
+    draw: (options?: GlDrawOptions) => void;
+}
+export declare class GlBatch2DSystem extends GlSystem {
+    install(renderer: GlRenderer): void;
+    protected _state: GlState;
+    protected _batchSize: number;
+    protected _batchables: Batchable2D[];
+    protected _vertexCount: number;
+    protected _indexCount: number;
+    protected _attributeBuffer: ArrayBuffer[];
+    protected _indexBuffers: Uint32Array<ArrayBuffer>[];
+    protected _shaders: Map<number, Shader>;
+    protected _attributes: Record<string, Partial<GeometryAttributeLike>>;
+    protected _vertexSize: number;
+    protected _getShader(maxTextureUnits: number): Shader;
+    protected _createShader(maxTextureUnits: number): Shader;
+    render(batchable: Batchable2D): void;
+    flush(): void;
+    protected _getBufferData(size: number): ArrayBuffer;
+    protected _getIndexBufferData(size: number): Uint32Array<ArrayBuffer>;
+}
+export declare function nextPow2(v: number): number;
+export declare function log2(v: number): number;
+export {};

package/dist/core/renderers/gl/GlColorMaskSystem.d.ts

@@ -0,0 +1,7 @@
+import type { GlRenderer } from './GlRenderer';
+import { GlSystem } from './system';
+export declare class GlColorMaskSystem extends GlSystem {
+    install(renderer: GlRenderer): void;
+    current: number;
+    bind(colorMask: number): void;
+}

package/dist/core/renderers/gl/GlMaskSystem.d.ts

@@ -0,0 +1,17 @@
+import type { GlRenderer } from './GlRenderer';
+import type { GlRenderable } from './types';
+import { GlSystem } from './system';
+export type MaskLike = GlRenderable;
+export interface MaskStackItem {
+    source: GlRenderable;
+    mask: MaskLike;
+}
+export declare class GlMaskSystem extends GlSystem {
+    install(renderer: GlRenderer): void;
+    stack: MaskStackItem[];
+    protected _maskStackHash: Record<number, number>;
+    get length(): number;
+    get last(): MaskStackItem;
+    push(source: GlRenderable, mask: MaskLike): void;
+    pop(source: GlRenderable): void;
+}

package/dist/core/renderers/gl/GlRenderer.d.ts

@@ -0,0 +1,63 @@
+import type { ClearOrBool } from './const';
+import type { GlExtensions, GlRenderingContext, GlTarget } from './types';
+import { Renderer } from '../shared';
+import { GlBufferSystem } from './buffer';
+import { GlGeometrySystem } from './geometry';
+import { GlBatch2DSystem } from './GlBatch2DSystem';
+import { GlColorMaskSystem } from './GlColorMaskSystem';
+import { GlMaskSystem } from './GlMaskSystem';
+import { GlStencilSystem } from './GlStencilSystem';
+import { GlViewportSystem } from './GlViewportSystem';
+import { GlRenderTargetSystem } from './renderTarget';
+import { GlShaderSystem } from './shader';
+import { GlStateSystem } from './state';
+import { GlTextureSystem } from './texture';
+export interface GlRenderer {
+    texture: GlTextureSystem;
+    buffer: GlBufferSystem;
+    shader: GlShaderSystem;
+    geometry: GlGeometrySystem;
+    renderTarget: GlRenderTargetSystem;
+    state: GlStateSystem;
+    mask: GlMaskSystem;
+    colorMask: GlColorMaskSystem;
+    stencil: GlStencilSystem;
+    batch2D: GlBatch2DSystem;
+    viewport: GlViewportSystem;
+}
+export declare class GlRenderer extends Renderer {
+    contextLost: boolean;
+    gl: GlRenderingContext;
+    version: 1 | 2;
+    extensions: GlExtensions;
+    protected _systems: (GlShaderSystem | GlTextureSystem | GlGeometrySystem | GlBufferSystem | GlStateSystem | GlBatch2DSystem | GlColorMaskSystem | GlMaskSystem | GlRenderTargetSystem | GlStencilSystem | GlViewportSystem)[];
+    readonly bindPoints: Map<number, GlTarget>;
+    readonly supports: {
+        uint32Indices: boolean;
+        uniformBufferObject: boolean;
+        vertexArrayObject: boolean;
+        srgbTextures: boolean;
+        nonPowOf2wrapping: boolean;
+        msaa: boolean;
+        nonPowOf2mipmaps: boolean;
+    };
+    constructor(view?: HTMLCanvasElement | WebGLRenderingContext | WebGL2RenderingContext, options?: WebGLContextAttributes);
+    protected _setupContext(view: HTMLCanvasElement, options?: WebGLContextAttributes): this;
+    protected _setupExtensions(): this;
+    protected _setupSupports(): this;
+    protected _setupBindPoints(): this;
+    /**
+     * Setup polyfill
+     *
+     * @protected
+     */
+    protected _setupPolyfill(): this;
+    protected _contextLost(event: WebGLContextEvent): void;
+    protected _contextRestored(): void;
+    resize(width: number, height: number, updateStyle?: boolean): void;
+    clear(clear?: ClearOrBool): void;
+    reset(): void;
+    flush(): void;
+    destroy(): void;
+    toPixels(x?: number, y?: number, width?: number, height?: number): Uint8ClampedArray<ArrayBuffer>;
+}

package/dist/core/renderers/gl/GlStencilSystem.d.ts

@@ -0,0 +1,56 @@
+import type { RenderTargetLike } from '../shared';
+import type { GlRenderer } from './GlRenderer';
+import type { GlRenderingContext } from './types';
+import { StencilMode } from './const';
+import { GlSystem } from './system';
+export interface StencilState {
+    stencilWriteMask?: number;
+    stencilReadMask?: number;
+    stencilFront?: {
+        compare: 'always' | 'equal' | 'not-equal';
+        passOp: 'increment-clamp' | 'decrement-clamp' | 'keep' | 'replace';
+    };
+    stencilBack?: {
+        compare: 'always' | 'equal' | 'not-equal';
+        passOp: 'increment-clamp' | 'decrement-clamp' | 'keep' | 'replace';
+    };
+}
+/** @internal */
+export declare const stencilModeMap: StencilState[];
+export declare class GlStencilSystem extends GlSystem {
+    install(renderer: GlRenderer): void;
+    protected readonly _cache: {
+        enabled: boolean;
+        stencilMode: StencilMode;
+        refCount: number;
+    };
+    current: Record<number, {
+        stencilMode: StencilMode;
+        refCount: number;
+    }>;
+    protected _passOpMap: {
+        'keep': number;
+        'zero': number;
+        'replace': number;
+        'invert': number;
+        'increment-clamp': number;
+        'decrement-clamp': number;
+        'increment-wrap': number;
+        'decrement-wrap': number;
+    };
+    protected _compareMap: {
+        'always': number;
+        'never': number;
+        'equal': number;
+        'not-equal': number;
+        'less': number;
+        'less-equal': number;
+        'greater': number;
+        'greater-equal': number;
+    };
+    onUpdateContext(gl: GlRenderingContext): void;
+    reset(): void;
+    protected _activeRenderTarget: RenderTargetLike | null;
+    onRenderTargetChange(renderTarget: RenderTargetLike | null): void;
+    bind(stencilMode: StencilMode, refCount: number): void;
+}

package/dist/core/renderers/gl/GlViewportSystem.d.ts

@@ -0,0 +1,9 @@
+import type { RectangleLike } from '../../math';
+import type { GlRenderer } from './GlRenderer';
+import { Rectangle } from '../../math';
+import { GlSystem } from './system';
+export declare class GlViewportSystem extends GlSystem {
+    readonly current: Rectangle;
+    install(renderer: GlRenderer): void;
+    bind(rect: RectangleLike): void;
+}

package/dist/core/renderers/gl/buffer/GlBuffer.d.ts

@@ -0,0 +1,8 @@
+import { GlBufferTarget } from './const';
+export declare class GlBuffer {
+    native: WebGLBuffer;
+    target: GlBufferTarget;
+    byteLength: number;
+    dirty: boolean;
+    constructor(native: WebGLBuffer);
+}

package/dist/core/renderers/gl/buffer/GlBufferSystem.d.ts

@@ -0,0 +1,14 @@
+import type { BufferLike } from '../../shared';
+import type { GlRenderer } from '../GlRenderer';
+import { GlSystem } from '../system';
+import { GlBuffer } from './GlBuffer';
+export declare class GlBufferSystem extends GlSystem {
+    install(renderer: GlRenderer): void;
+    readonly buffers: Map<number, BufferLike>;
+    readonly glBuffers: Map<number, GlBuffer>;
+    getGlBuffer(source: BufferLike): GlBuffer;
+    protected _createGlBuffer(buffer: BufferLike): GlBuffer;
+    bind(buffer: BufferLike): void;
+    update(buffer: BufferLike, force?: boolean): GlBuffer;
+    reset(): void;
+}

package/dist/core/renderers/gl/buffer/const.d.ts

@@ -0,0 +1,5 @@
+export declare enum GlBufferTarget {
+    elementArrayBuffer = 34963,
+    arrayBuffer = 34962,
+    uniformBuffer = 35345
+}

package/dist/core/renderers/gl/buffer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './const';
+export * from './GlBuffer';
+export * from './GlBufferSystem';

package/dist/core/renderers/gl/const.d.ts

@@ -0,0 +1,19 @@
+export declare enum StencilMode {
+    disabled = 0,
+    renderingMaskAdd = 1,
+    maskActive = 2,
+    inverseMaskActive = 3,
+    renderingMaskRemove = 4,
+    none = 5
+}
+export declare enum Clear {
+    none = 0,
+    color = 16384,
+    stencil = 1024,
+    depth = 256,
+    colorDepth = 16640,
+    colorStencil = 17408,
+    depthStencil = 1280,
+    all = 17664
+}
+export type ClearOrBool = Clear | boolean;

package/dist/core/renderers/gl/geometry/GlGeometrySystem.d.ts

@@ -0,0 +1,29 @@
+import type { BufferLike, GeometryLike, Topology } from '../../shared';
+import type { GlRenderer } from '../GlRenderer';
+import type { GlProgram } from '../shader';
+import { GlSystem } from '../system';
+export interface GlDrawOptions {
+    topology?: Topology;
+    size?: number;
+    start?: number;
+    instanceCount?: number;
+}
+export declare class GlGeometrySystem extends GlSystem {
+    protected _geometryVaoHash: Record<number, Record<string, WebGLVertexArrayObject>>;
+    hasInstance: boolean;
+    current: GeometryLike | null;
+    currentVao: WebGLVertexArrayObject | null;
+    install(renderer: GlRenderer): void;
+    bind(geometry: GeometryLike | null, program?: GlProgram): void;
+    protected getVao(geometry: GeometryLike, program: GlProgram): WebGLVertexArrayObject;
+    protected _getBuffers(geometry: GeometryLike): BufferLike[];
+    protected _ensureAttributes(geometry: GeometryLike, program: GlProgram, buffers: BufferLike[]): void;
+    protected _createVao(geometry: GeometryLike, program: GlProgram): WebGLVertexArrayObject;
+    protected _activateVao(geometry: GeometryLike, glProgram: GlProgram): void;
+    updateBuffers(): void;
+    protected _getSignature(geometry: GeometryLike, program: GlProgram): string;
+    unbind(): void;
+    getSize(geometry: GeometryLike): number;
+    draw(options?: GlDrawOptions): this;
+    reset(): void;
+}

package/dist/core/renderers/gl/geometry/getGlTypeFromFormat.d.ts

@@ -0,0 +1,6 @@
+import type { VertexFormat } from '../../shared';
+/**
+ * @param format
+ * @internal
+ */
+export declare function getGlTypeFromFormat(format: VertexFormat): number;

package/dist/core/renderers/gl/geometry/index.d.ts

@@ -0,0 +1 @@
+export * from './GlGeometrySystem';

package/dist/core/renderers/gl/index.d.ts

@@ -0,0 +1,11 @@
+export * from './buffer';
+export * from './GlBatch2DSystem';
+export * from './GlMaskSystem';
+export * from './GlRenderer';
+export * from './GlStencilSystem';
+export * from './GlViewportSystem';
+export * from './renderTarget';
+export * from './shader';
+export * from './state';
+export * from './system';
+export * from './types';

package/dist/core/renderers/gl/renderTarget/GlRenderTarget.d.ts

@@ -0,0 +1,10 @@
+export declare class GlRenderTarget {
+    framebuffer: WebGLFramebuffer;
+    width: number;
+    height: number;
+    msaa: boolean;
+    framebuffer2?: WebGLFramebuffer;
+    msaaRenderBuffer: WebGLRenderbuffer[];
+    depthStencilRenderBuffer?: WebGLRenderbuffer;
+    constructor(framebuffer: WebGLFramebuffer);
+}

package/dist/core/renderers/gl/renderTarget/GlRenderTargetSystem.d.ts

@@ -0,0 +1,31 @@
+import type { RectangleLike } from '../../../math';
+import type { RenderTargetLike, TextureLike } from '../../shared';
+import type { GlRenderer } from '../GlRenderer';
+import { Projection2D } from '../../../math';
+import { GlSystem } from '../system';
+import { GlRenderTarget } from './GlRenderTarget';
+export declare class GlRenderTargetSystem extends GlSystem {
+    install(renderer: GlRenderer): void;
+    readonly renderTargets: Map<number, RenderTargetLike>;
+    readonly glRenderTargets: Map<number, GlRenderTarget>;
+    current: RenderTargetLike | null;
+    protected _msaaSamples: number[];
+    protected _hasMRT: boolean;
+    protected _writeDepthTexture: boolean;
+    projectionMatrix: Projection2D;
+    onUpdateContext(): void;
+    bind(renderTarget: RenderTargetLike | null, frame?: RectangleLike): void;
+    unbind(): void;
+    getGlRenderTarget(renderTarget: RenderTargetLike): GlRenderTarget;
+    protected _createGlRenderTarget(renderTarget: RenderTargetLike): GlRenderTarget;
+    protected _init(renderTarget: RenderTargetLike): void;
+    ensureDepthStencil(): void;
+    destroyGpuRenderTarget(gpuRenderTarget: GlRenderTarget): void;
+    resizeGpuRenderTarget(renderTarget: RenderTargetLike): void;
+    protected _initStencil(glRenderTarget: GlRenderTarget): void;
+    protected _resizeStencil(glRenderTarget: GlRenderTarget): void;
+    protected _resizeColorTextures(renderTarget: RenderTargetLike, glRenderTarget: GlRenderTarget): void;
+    finishRenderPass(viewport: RenderTargetLike): void;
+    copyToTexture(framebuffer: RenderTargetLike, texture: TextureLike): void;
+    reset(): void;
+}

package/dist/core/renderers/gl/renderTarget/index.d.ts

@@ -0,0 +1,2 @@
+export * from './GlRenderTarget';
+export * from './GlRenderTargetSystem';

package/dist/core/renderers/gl/shader/GlProgram.d.ts

@@ -0,0 +1,39 @@
+import type { GeometryAttributeLike } from '../../shared';
+export interface GlAttribute extends Omit<GeometryAttributeLike, 'buffer'> {
+    location: number;
+}
+export interface GlUniform {
+    name: string;
+    index: number;
+    type: string;
+    size: number;
+    isArray: boolean;
+    value: any;
+}
+export interface GlProgramOptions {
+    fragment: string;
+    vertex: string;
+    name?: string;
+    preferredVertexPrecision?: string;
+    preferredFragmentPrecision?: string;
+    transformFeedbackVaryings?: {
+        names: string[];
+        bufferMode: 'separate' | 'interleaved';
+    };
+}
+export declare class GlProgram {
+    static defaultOptions: Partial<GlProgramOptions>;
+    readonly id: number;
+    fragment: string;
+    vertex: string;
+    transformFeedbackVaryings?: {
+        names: string[];
+        bufferMode: 'separate' | 'interleaved';
+    };
+    _cacheKey?: string;
+    attributes: Record<string, GlAttribute>;
+    uniforms: Record<string, GlUniform>;
+    constructor(options: GlProgramOptions);
+    destroy(): void;
+    static from(options: GlProgramOptions): GlProgram;
+}

package/dist/core/renderers/gl/shader/GlProgramData.d.ts

@@ -0,0 +1,4 @@
+export declare class GlProgramData {
+    native: WebGLProgram;
+    constructor(native: WebGLProgram);
+}

package/dist/core/renderers/gl/shader/GlShaderSystem.d.ts

@@ -0,0 +1,22 @@
+import type { ShaderLike } from '../../shared';
+import type { GlRenderer } from '../GlRenderer';
+import type { GlProgram } from './GlProgram';
+import { GlSystem } from '../system';
+import { GlProgramData } from './GlProgramData';
+export declare class GlShaderSystem extends GlSystem {
+    install(renderer: GlRenderer): void;
+    readonly glProgramDatas: Map<number, GlProgramData>;
+    currentProgram: GlProgram | null;
+    uniforms: {
+        projectionMatrix: number[];
+        viewMatrix: number[];
+    };
+    bind(source: ShaderLike | null): void;
+    useProgram(glProgram: GlProgram | null): void;
+    getGlProgramData(source: GlProgram): GlProgramData;
+    protected _createGlProgramData(glProgram: GlProgram): GlProgramData;
+    protected _createGlShader(source: string, target: number): WebGLShader;
+    updateUniforms(source: ShaderLike): void;
+    reset(): void;
+    destroy(): void;
+}

package/dist/core/renderers/gl/shader/const.d.ts

@@ -0,0 +1 @@
+export type GlPrecision = 'highp' | 'mediump' | 'lowp';

package/dist/core/renderers/gl/shader/defaultValue.d.ts

@@ -0,0 +1 @@
+export declare function defaultValue(type: string, size: number): number | Float32Array | Int32Array | Uint32Array | boolean | boolean[];

package/dist/core/renderers/gl/shader/getMaxFragmentPrecision.d.ts

@@ -0,0 +1,3 @@
+import type { GlPrecision } from './const';
+/** @internal */
+export declare function getMaxFragmentPrecision(): GlPrecision;

package/dist/core/renderers/gl/shader/getTestContext.d.ts

@@ -0,0 +1,2 @@
+import type { GlRenderingContext } from '../types';
+export declare function getTestContext(): GlRenderingContext;

package/dist/core/renderers/gl/shader/index.d.ts

@@ -0,0 +1,2 @@
+export * from './GlProgram';
+export * from './GlShaderSystem';

package/dist/core/renderers/gl/shader/mapType.d.ts

@@ -0,0 +1,3 @@
+import type { VertexFormat } from '../../shared';
+export declare function mapType(gl: any, type: number): string;
+export declare function mapGlToVertexFormat(gl: any, type: number): VertexFormat;

package/dist/core/renderers/gl/shader/preprocessors/addProgramDefines.d.ts

@@ -0,0 +1 @@
+export declare function addProgramDefines(src: string, isES300: boolean, isFragment?: boolean): string;

package/dist/core/renderers/gl/shader/preprocessors/ensurePrecision.d.ts

@@ -0,0 +1,9 @@
+import type { GlPrecision } from '../const';
+interface EnsurePrecisionOptions {
+    requestedVertexPrecision: GlPrecision;
+    requestedFragmentPrecision: GlPrecision;
+    maxSupportedVertexPrecision: GlPrecision;
+    maxSupportedFragmentPrecision: GlPrecision;
+}
+export declare function ensurePrecision(src: string, options: EnsurePrecisionOptions, isFragment?: boolean): string;
+export {};

package/dist/core/renderers/gl/shader/preprocessors/insertVersion.d.ts

@@ -0,0 +1 @@
+export declare function insertVersion(src: string, isES300: boolean): string;

package/dist/core/renderers/gl/shader/preprocessors/setProgramName.d.ts

@@ -0,0 +1,3 @@
+export declare function setProgramName(src: string, { name }: {
+    name: string;
+}, isFragment?: boolean): string;

package/dist/core/renderers/gl/shader/preprocessors/stripVersion.d.ts

@@ -0,0 +1 @@
+export declare function stripVersion(src: string, isES300: boolean): string;

package/dist/core/renderers/gl/state/GlBlendMode.d.ts

@@ -0,0 +1,20 @@
+export declare enum GlBlendMode {
+    normal = "normal",
+    add = "add",
+    multiply = "multiply",
+    screen = "screen",
+    none = "none",
+    normalNpm = "normalNpm",
+    addNpm = "add_npm",
+    screenNpm = "screenNpm",
+    srcIn = "srcIn",
+    srcOut = "srcOut",
+    srcAtop = "srcAtop",
+    dstOver = "dstOver",
+    dstIn = "dstIn",
+    dstOut = "dstOut",
+    dstAtop = "dstAtop",
+    xor = "xor",
+    subtract = "subtract"
+}
+export declare function mapGlBlendModes(gl: WebGLRenderingContext): Record<GlBlendMode, any>;

package/dist/core/{renderer/webgl/modules/WebGLStateModule.d.ts → renderers/gl/state/GlStateSystem.d.ts}

@@ -1,7 +1,8 @@
-import type { WebGLRenderer } from '../WebGLRenderer';
-import { WebGLBlendMode } from './WebGLBlendMode';
-import { WebGLModule } from './WebGLModule';
-export interface WebGLState {
+import type { GlRenderer } from '../GlRenderer';
+import type { GlRenderingContext } from '../types';
+import { GlSystem } from '../system';
+import { GlBlendMode } from './GlBlendMode';
+export interface GlState {
     blend: boolean;
     offsets: boolean;
     culling: boolean;
@@ -9,28 +10,28 @@ export interface WebGLState {
     clockwiseFrontFace: boolean;
     depthMask: boolean;
 }
-export declare class WebGLState {
+export declare class GlState {
     static readonly _properties: string[];
     static _init(): void;
-    static for2D(): WebGLState;
-    protected _blendMode: WebGLBlendMode;
+    static for2D(): GlState;
+    protected _blendMode: GlBlendMode;
     protected _polygonOffset: number;
     bitmap: number;
-    get blendMode(): WebGLBlendMode;
-    set blendMode(value: WebGLBlendMode);
+    get blendMode(): GlBlendMode;
+    set blendMode(value: GlBlendMode);
     get polygonOffset(): number;
     set polygonOffset(value: number);
-    constructor(options?: Partial<WebGLState>);
+    constructor(options?: Partial<GlState>);
 }
-export declare class WebGLStateModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
+export declare class GlStateSystem extends GlSystem {
+    install(renderer: GlRenderer): void;
     protected _blendEq: boolean;
     protected _setters: any[];
     boundStateBitmap: number;
     boundBlendMode?: string;
-    blendModes: Record<WebGLBlendMode, any>;
-    defaultState: WebGLState;
-    onUpdateContext(): void;
+    blendModes: Record<GlBlendMode, any>;
+    defaultState: GlState;
+    onUpdateContext(gl: GlRenderingContext): void;
     toggle(boundPoint: number, enable: boolean): void;
     setBlend(value: boolean): void;
     setOffsets(value: boolean): void;
@@ -38,8 +39,8 @@ export declare class WebGLStateModule extends WebGLModule {
     setDepthTest(value: boolean): void;
     setDepthMask(value: boolean): void;
     setClockwiseFrontFace(value: boolean): void;
-    setBlendMode(value: WebGLBlendMode): void;
+    setBlendMode(value: GlBlendMode): void;
     setPolygonOffset(value: number, scale: number): void;
-    bind(state: WebGLState): void;
+    bind(state: GlState): void;
     reset(): void;
 }