modern-canvas 0.13.5 → 0.14.0

package/dist/scene/resources/materials/Material.d.ts

@@ -1,17 +1,13 @@
-import type { WebGLRenderer } from '../../../core';
-import { Resource } from '../../../core';
-export interface MaterialOptions {
-    vert?: string;
-    frag?: string;
+import type { GlProgramOptions, GlRenderer, ShaderLikeReactiveObject } from '../../../core';
+import { GlProgram, Resource } from '../../../core';
+export interface MaterialProperties {
+    gl?: Partial<GlProgramOptions>;
     uniforms?: Record<string, any>;
 }
-export declare class Material extends Resource {
+export declare class Material extends Resource implements ShaderLikeReactiveObject {
     static instance: Material;
-    vert: string;
-    frag: string;
-    readonly uniforms: Map<string, any>;
-    constructor(options?: MaterialOptions);
-    /** @internal */
-    _glProgram(renderer: WebGLRenderer): WebGLProgram;
-    activate(renderer: WebGLRenderer, uniforms?: Record<string, any>): void;
+    readonly glProgram: GlProgram;
+    uniforms: Record<string, any>;
+    constructor(properties?: MaterialProperties);
+    activate(renderer: GlRenderer, uniforms?: Record<string, any>): void;
 }

package/dist/scene/resources/textures/CanvasTexture.d.ts

@@ -1,6 +1,8 @@
+import type { Texture2DProperties } from './Texture2D';
 import { Texture2D } from './Texture2D';
+export interface CanvasTextureProperties extends Texture2DProperties<HTMLCanvasElement> {
+}
 export declare class CanvasTexture extends Texture2D<HTMLCanvasElement> {
-    pixelRatio: number;
-    constructor(source?: HTMLCanvasElement);
+    constructor(properties?: CanvasTextureProperties);
     protected _updateProperty(key: string, value: any, oldValue: any): void;
 }

package/dist/scene/resources/textures/ColorTexture.d.ts

@@ -1,7 +1,8 @@
 import type { ColorValue } from '../../../core';
+import { Color } from '../../../core';
 import { Texture2D } from './Texture2D';
 export declare class ColorTexture extends Texture2D {
     protected static _cached: Map<string, ColorTexture>;
-    static get(value: ColorValue): Texture2D;
-    constructor(value: ColorValue);
+    static get(value: ColorValue): ColorTexture;
+    constructor(value: ColorValue | Color);
 }

package/dist/scene/resources/textures/GradientTexture.d.ts

@@ -1,8 +1,8 @@
 import type { LinearGradient, RadialGradient } from 'modern-idoc';
-import type { Texture2DPixelsSource } from './Texture2D';
+import type { Texture2DProperties } from './Texture2D';
 import { Texture2D } from './Texture2D';
 export declare class GradientTexture extends Texture2D {
     static test(value: string): boolean;
-    static linearGradient(linearGradient: LinearGradient, width: number, height: number): Texture2DPixelsSource;
+    static linearGradient(linearGradient: LinearGradient, width: number, height: number): Texture2DProperties;
     constructor(gradient: LinearGradient | RadialGradient, width: number, height: number);
 }

package/dist/scene/resources/textures/PixelsTexture.d.ts

@@ -1,6 +1,7 @@
-import type { Texture2DPixelsSource } from './Texture2D';
+import type { Texture2DProperties } from './Texture2D';
 import { Texture2D } from './Texture2D';
-export declare class PixelsTexture extends Texture2D<Texture2DPixelsSource> {
-    constructor(pixels?: number[] | ArrayBufferLike | ArrayBufferView | null, width?: number, height?: number);
-    protected _updateProperty(key: string, value: any, oldValue: any): void;
+export interface PixelsTextureProperties extends Texture2DProperties<ArrayBufferView | null> {
+}
+export declare class PixelsTexture extends Texture2D<ArrayBufferView | null> {
+    constructor(properties?: PixelsTextureProperties);
 }

package/dist/scene/resources/textures/Texture2D.d.ts

@@ -1,42 +1,40 @@
-import type { WebGLRenderer, WebGLTextureFilterMode, WebGLTextureOptions, WebGLTextureWrapMode } from '../../../core';
+import type { AlphaMode, GlRenderer, ScaleMode, TextureFormat, TextureLikeObject, TextureLikeReactiveObject, TextureSource, WrapMode } from '../../../core';
 import { Resource } from '../../../core';
-export type Texture2DFilterMode = WebGLTextureFilterMode;
-export type Texture2DWrapMode = WebGLTextureWrapMode;
-export interface Texture2DPixelsSource {
-    width: number;
-    height: number;
-    pixels: Uint8Array | null;
+export interface Texture2DProperties<T extends TextureSource = TextureSource> extends Partial<Omit<TextureLikeObject, 'source'>> {
+    source?: T;
 }
-export type Texture2DSource = TexImageSource | Texture2DPixelsSource;
-export declare class Texture2D<T extends Texture2DSource = Texture2DSource> extends Resource {
+export declare class Texture2D<T extends TextureSource = TextureSource> extends Resource implements TextureLikeReactiveObject {
     static get EMPTY(): Texture2D;
     static get WHITE(): Texture2D;
     static get BLACK(): Texture2D;
     static get RED(): Texture2D;
     static get GREEN(): Texture2D;
     static get BLUE(): Texture2D;
+    uploadMethodId: string;
     source: T;
     width: number;
     height: number;
-    filterMode: Texture2DFilterMode;
-    wrapMode: Texture2DWrapMode;
     pixelRatio: number;
-    protected _isPowerOfTwo: boolean;
-    protected _needsUpload: boolean;
-    get realWidth(): number;
-    get realHeight(): number;
-    constructor(source: T);
+    format: TextureFormat;
+    alphaMode: AlphaMode;
+    mipLevelCount: number;
+    mipmap: boolean;
+    addressModeU: WrapMode;
+    addressModeV: WrapMode;
+    addressModeW: WrapMode;
+    magFilter: ScaleMode;
+    minFilter: ScaleMode;
+    mipmapFilter: ScaleMode;
+    isPowerOfTwo: boolean;
+    get sourceWidth(): number;
+    get sourceHeight(): number;
+    get pixelWidth(): number;
+    get pixelHeight(): number;
+    constructor(properties?: Texture2DProperties<T>);
     isValid(): boolean;
-    /** @internal */
-    _glTextureOptions(renderer: WebGLRenderer, options?: Partial<WebGLTextureOptions>): WebGLTextureOptions;
-    /** @internal */
-    _glTexture(renderer: WebGLRenderer, options?: Partial<WebGLTextureOptions>): WebGLTexture;
     protected _updateProperty(key: string, value: any, oldValue: any): void;
-    protected _updatePOT(): void;
     updateSize(): void;
-    requestUpload(): void;
-    upload(renderer: WebGLRenderer, options?: Partial<WebGLTextureOptions>): boolean;
-    activate(renderer: WebGLRenderer, location?: number): boolean;
-    inactivate(renderer: WebGLRenderer): void;
+    activate(renderer: GlRenderer, location?: number): boolean;
+    inactivate(renderer: GlRenderer): void;
     destroy(): void;
 }

package/dist/scene/resources/textures/VideoTexture.d.ts

@@ -8,7 +8,7 @@ export interface VideoTextureOptions {
     muted?: boolean;
     playsinline?: boolean;
 }
-export interface VideoTextureSource {
+export interface VideoTextureLike {
     src: string;
     mime: string;
 }
@@ -30,7 +30,7 @@ export declare class VideoTexture extends Texture2D<HTMLVideoElement> {
     protected _requestId?: number;
     protected _resolve?: (val: this) => void;
     protected _reject?: (event: ErrorEvent) => void;
-    constructor(source: HTMLVideoElement | (string | VideoTextureSource)[] | string, options?: VideoTextureOptions);
+    constructor(source: HTMLVideoElement | (string | VideoTextureLike)[] | string, options?: VideoTextureOptions);
     protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _onPlayStart: () => void;
     protected _onPlayStop: () => void;

package/dist/scene/resources/textures/ViewportTexture.d.ts

@@ -1,3 +1,3 @@
-import { PixelsTexture } from './PixelsTexture';
-export declare class ViewportTexture extends PixelsTexture {
+import { Texture2D } from './Texture2D';
+export declare class ViewportTexture extends Texture2D<null> {
 }

package/dist/scene/resources/textures/index.d.ts

@@ -2,7 +2,6 @@ export * from './AnimatedTexture';
 export * from './CanvasTexture';
 export * from './ColorTexture';
 export * from './GradientTexture';
-export * from './ImageTexture';
 export * from './PixelsTexture';
 export * from './Texture2D';
 export * from './VideoTexture';

package/dist/scene/transitions/KawaseTransition.d.ts

@@ -1,4 +1,4 @@
-import type { WebGLRenderer } from '../../core';
+import type { GlRenderer } from '../../core';
 import type { Viewport } from '../main';
 import { Transition } from '../main/Transition';
 import { Material } from '../resources';
@@ -6,5 +6,5 @@ export declare class KawaseTransition extends Transition {
     blur: number;
     quality: number;
     static material: Material;
-    apply(renderer: WebGLRenderer, target: Viewport): void;
+    apply(renderer: GlRenderer, target: Viewport): void;
 }

package/dist/scene/transitions/LeftEraseTransition.d.ts

@@ -1,7 +1,7 @@
-import type { WebGLRenderer } from '../../core';
+import type { GlRenderer } from '../../core';
 import { Transition } from '../main/Transition';
 import { Material } from '../resources';
 export declare class LeftEraseTransition extends Transition {
     static material: Material;
-    apply(renderer: WebGLRenderer): void;
+    apply(renderer: GlRenderer): void;
 }

package/dist/scene/transitions/TiltShiftTransition.d.ts

@@ -1,4 +1,4 @@
-import type { WebGLRenderer } from '../../core';
+import type { GlRenderer } from '../../core';
 import type { Viewport } from '../main';
 import { Transition } from '../main/Transition';
 import { Material } from '../resources';
@@ -6,5 +6,5 @@ export declare class TiltShiftTransition extends Transition {
     blur: number;
     gradientBlur: number;
     static material: Material;
-    apply(renderer: WebGLRenderer, target: Viewport): void;
+    apply(renderer: GlRenderer, target: Viewport): void;
 }

package/dist/scene/transitions/TwistTransition.d.ts

@@ -1,4 +1,4 @@
-import type { WebGLRenderer } from '../../core';
+import type { GlRenderer } from '../../core';
 import type { Viewport } from '../main';
 import { Transition } from '../main/Transition';
 import { Material } from '../resources';
@@ -8,5 +8,5 @@ export declare class TwistTransition extends Transition {
     padding: number;
     offset?: number;
     static material: Material;
-    apply(renderer: WebGLRenderer, source: Viewport): void;
+    apply(renderer: GlRenderer, source: Viewport): void;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modern-canvas",
   "type": "module",
-  "version": "0.13.5",
+  "version": "0.14.0",
   "packageManager": "pnpm@10.19.0",
   "description": "A JavaScript WebGL rendering engine. only the ESM.",
   "author": "wxm",
@@ -64,7 +64,7 @@
     "colord": "^2.9.3",
     "earcut": "^3.0.2",
     "modern-font": "^0.4.4",
-    "modern-idoc": "^0.10.5",
+    "modern-idoc": "^0.10.6",
     "modern-path2d": "^1.4.11",
     "modern-text": "^1.10.4"
   },
@@ -85,20 +85,20 @@
     }
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^6.2.0",
+    "@antfu/eslint-config": "^6.4.2",
     "@types/earcut": "^3.0.0",
     "@types/node": "^24.10.1",
-    "bumpp": "^10.3.1",
+    "bumpp": "^10.3.2",
     "conventional-changelog-cli": "^5.0.0",
     "eslint": "^9.39.1",
-    "lint-staged": "^16.2.6",
+    "lint-staged": "^16.2.7",
     "lottie-web": "^5.13.0",
     "modern-gif": "^2.0.4",
     "simple-git-hooks": "^2.13.1",
     "typescript": "^5.9.3",
     "unbuild": "^3.6.1",
-    "vite": "^7.2.2",
-    "vitest": "^4.0.9",
+    "vite": "^7.2.6",
+    "vitest": "^4.0.15",
     "yoga-layout": "^3.2.1"
   },
   "simple-git-hooks": {

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

@@ -1,2 +0,0 @@
-export * from './Renderer';
-export * from './webgl';

package/dist/core/renderer/webgl/WebGLRenderer.d.ts

@@ -1,52 +0,0 @@
-import type { WebGLDrawOptions, WebGLExtensions, WebGLTarget } from './types';
-import { Renderer } from '../Renderer';
-import { WebGLBatch2DModule, WebGLBufferModule, WebGLFramebufferModule, WebGLMaskModule, WebGLProgramModule, WebGLScissorModule, WebGLStateModule, WebGLStencilModule, WebGLTextureModule, WebGLVertexArrayModule, WebGLViewportModule } from './modules';
-export interface WebGLRenderer {
-    texture: WebGLTextureModule;
-    buffer: WebGLBufferModule;
-    framebuffer: WebGLFramebufferModule;
-    program: WebGLProgramModule;
-    vertexArray: WebGLVertexArrayModule;
-    viewport: WebGLViewportModule;
-    state: WebGLStateModule;
-    mask: WebGLMaskModule;
-    scissor: WebGLScissorModule;
-    stencil: WebGLStencilModule;
-    batch2D: WebGLBatch2DModule;
-}
-export declare class WebGLRenderer extends Renderer {
-    gl: WebGLRenderingContext | WebGL2RenderingContext;
-    version: 1 | 2;
-    extensions: WebGLExtensions;
-    protected _modules: (WebGLTextureModule | WebGLBufferModule | WebGLFramebufferModule | WebGLProgramModule | WebGLVertexArrayModule | WebGLViewportModule | WebGLStateModule | WebGLMaskModule | WebGLScissorModule | WebGLStencilModule | WebGLBatch2DModule)[];
-    readonly bindPoints: Map<number, WebGLTarget>;
-    constructor(view?: HTMLCanvasElement | WebGLRenderingContext | WebGL2RenderingContext, options?: WebGLContextAttributes);
-    protected _setupContext(view: HTMLCanvasElement, options?: WebGLContextAttributes): this;
-    /**
-     * Setup extensions
-     *
-     * @protected
-     */
-    protected _setupExtensions(): this;
-    /**
-     * Setup bind points
-     *
-     * @protected
-     */
-    protected _setupBindPoints(): this;
-    /**
-     * Setup polyfill
-     *
-     * @protected
-     */
-    protected _setupPolyfill(): this;
-    protected _onContextLost(event: WebGLContextEvent): void;
-    protected _onContextRestored(): void;
-    getBindPoint(target: WebGLTarget): number;
-    clear(mask?: number): void;
-    draw(options?: WebGLDrawOptions): void;
-    reset(): void;
-    flush(): void;
-    destroy(): void;
-    toPixels(x?: number, y?: number, width?: number, height?: number): Uint8ClampedArray<ArrayBuffer>;
-}

package/dist/core/renderer/webgl/index.d.ts

@@ -1,3 +0,0 @@
-export * from './modules';
-export * from './types';
-export * from './WebGLRenderer';

package/dist/core/renderer/webgl/modules/WebGLBatch2DModule.d.ts

@@ -1,45 +0,0 @@
-import type { WebGLDrawOptions, WebGLVertexAttrib } from '../types';
-import type { WebGLRenderer } from '../WebGLRenderer';
-import { WebGLBlendMode } from './WebGLBlendMode';
-import { WebGLModule } from './WebGLModule';
-import { WebGLState } from './WebGLStateModule';
-export interface Batchable2D {
-    vertices: Float32Array;
-    indices: Float32Array;
-    uvs?: Float32Array;
-    size?: Float32Array;
-    texture?: WebGLTexture;
-    backgroundColor?: number[];
-    modulate?: number[];
-    blendMode?: WebGLBlendMode;
-    disableWrapMode?: boolean;
-}
-interface Shader {
-    update: (attributeBuffer: ArrayBuffer, indexBuffer: Uint16Array<ArrayBuffer>) => void;
-    draw: (options?: WebGLDrawOptions) => void;
-}
-export declare class WebGLBatch2DModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
-    protected _state: WebGLState;
-    protected _batchSize: number;
-    protected _drawCallUid: number;
-    protected _defaultModulate: number[];
-    protected _defaultBackgroundColor: number[];
-    protected _batchables: Batchable2D[];
-    protected _vertexCount: number;
-    protected _indexCount: number;
-    protected _attributeBuffer: ArrayBuffer[];
-    protected _indexBuffers: Uint16Array<ArrayBuffer>[];
-    protected _shaders: Map<number, Shader>;
-    protected _attributes: Record<string, Partial<WebGLVertexAttrib>>;
-    protected _vertexSize: number;
-    protected _getShader(maxTextureUnits: number): Shader;
-    protected _createShader(maxTextureUnits: number): Shader;
-    render(batchable: Batchable2D): void;
-    flush(): void;
-    protected _getAttributeBuffer(size: number): ArrayBuffer;
-    protected _getIndexBuffer(size: number): Uint16Array<ArrayBuffer>;
-}
-export declare function nextPow2(v: number): number;
-export declare function log2(v: number): number;
-export {};

package/dist/core/renderer/webgl/modules/WebGLBlendMode.d.ts

@@ -1,20 +0,0 @@
-export declare enum WebGLBlendMode {
-    NORMAL = "normal",
-    ADD = "add",
-    MULTIPLY = "multiply",
-    SCREEN = "screen",
-    NONE = "none",
-    NORMAL_NPM = "normal_npm",
-    ADD_NPM = "add_npm",
-    SCREEN_NPM = "screen_npm",
-    SRC_IN = "src_in",
-    SRC_OUT = "src_out",
-    SRC_ATOP = "src_atop",
-    DST_OVER = "dst_over",
-    DST_IN = "dst_in",
-    DST_OUT = "dst_out",
-    DST_ATOP = "dst_atop",
-    XOR = "xor",
-    SUBTRACT = "subtract"
-}
-export declare function mapWebGLBlendModes(gl: WebGLRenderingContext): Record<WebGLBlendMode, any>;

package/dist/core/renderer/webgl/modules/WebGLBufferModule.d.ts

@@ -1,18 +0,0 @@
-import type { WebGLBufferMeta, WebGLBufferOptions, WebGLBufferTarget } from '../types';
-import type { WebGLRenderer } from '../WebGLRenderer';
-import { WebGLModule } from './WebGLModule';
-export declare class WebGLBufferModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
-    boundArrayBuffer: WebGLBuffer | null;
-    boundTarget: WebGLBufferTarget;
-    create(options?: WebGLBufferOptions): WebGLBuffer;
-    getMeta(buffer: WebGLBuffer): WebGLBufferMeta;
-    update(options: WebGLBufferOptions): void;
-    update(buffer: WebGLBuffer, options: WebGLBufferOptions): void;
-    bind(options: {
-        target?: WebGLBufferTarget;
-        value: WebGLBuffer | null;
-    }): void;
-    unbind(target: WebGLBufferTarget): void;
-    reset(): void;
-}

package/dist/core/renderer/webgl/modules/WebGLFramebufferModule.d.ts

@@ -1,25 +0,0 @@
-import type { WebGLFramebufferMeta, WebGLFramebufferOptions } from '../types';
-import type { WebGLRenderer } from '../WebGLRenderer';
-import { WebGLModule } from './WebGLModule';
-export declare class WebGLFramebufferModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
-    boundFramebuffer: WebGLFramebuffer | null;
-    protected _msaaSamples: number[];
-    protected _hasMRT: boolean;
-    protected _writeDepthTexture: boolean;
-    onUpdateContext(): void;
-    create(options?: WebGLFramebufferOptions): WebGLFramebuffer;
-    getMeta(framebuffer: WebGLFramebuffer): WebGLFramebufferMeta;
-    update(options: WebGLFramebufferOptions): void;
-    update(framebuffer: WebGLFramebuffer, options: WebGLFramebufferOptions): void;
-    protected _getAttachmentAndFormat(meta: WebGLFramebufferMeta): {
-        attachment: number;
-        format: number;
-    };
-    resize(framebuffer: WebGLFramebuffer, width: number, height: number): void;
-    finishRenderPass(framebuffer: WebGLFramebuffer): void;
-    copyToTexture(framebuffer: WebGLFramebuffer, texture: WebGLTexture): void;
-    bind(framebuffer: WebGLFramebuffer | null): void;
-    forceStencil(): void;
-    reset(): void;
-}

package/dist/core/renderer/webgl/modules/WebGLMaskModule.d.ts

@@ -1,31 +0,0 @@
-import type { WebGLRenderer } from '../WebGLRenderer';
-import type { Renderable } from './types';
-import { WebGLModule } from './WebGLModule';
-export type MaskColor = number;
-export interface MaskRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-export type MaskObject = Renderable;
-export type Maskable = MaskColor | MaskRect | MaskObject;
-export interface MaskData {
-    source: Renderable;
-    mask: Maskable;
-    color?: number;
-    preComputedColor?: number;
-    scissorCounter?: number;
-    stencilCounter?: number;
-}
-export declare class WebGLMaskModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
-    stack: MaskData[];
-    get length(): number;
-    get last(): MaskData;
-    push(source: Renderable, mask: Maskable): void;
-    pop(source: Renderable): void;
-    pushColorMask(data: MaskData): void;
-    popColorMask(data: MaskData): void;
-    useColorMask(value: number): void;
-}

package/dist/core/renderer/webgl/modules/WebGLModule.d.ts

@@ -1,10 +0,0 @@
-import type { WebGLRenderer } from '../WebGLRenderer';
-export declare abstract class WebGLModule {
-    protected _renderer: WebGLRenderer;
-    get gl(): WebGLRenderingContext | WebGL2RenderingContext;
-    install(renderer: WebGLRenderer): void;
-    onUpdateContext(): void;
-    flush(): void;
-    reset(): void;
-    destroy(): void;
-}

package/dist/core/renderer/webgl/modules/WebGLProgramModule.d.ts

@@ -1,21 +0,0 @@
-import type { WebGLProgramMeta, WebGLProgramOptions } from '../types';
-import type { WebGLRenderer } from '../WebGLRenderer';
-import { WebGLModule } from './WebGLModule';
-export declare class WebGLProgramModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
-    boundProgram: WebGLProgram | null;
-    uniforms: {
-        projectionMatrix: number[];
-        viewMatrix: number[];
-    };
-    create(options?: WebGLProgramOptions): WebGLProgram;
-    getMeta(program: WebGLProgram): WebGLProgramMeta;
-    update(options: WebGLProgramOptions): void;
-    update(program: WebGLProgram, options: WebGLProgramOptions): void;
-    bind(program: WebGLProgram | null): void;
-    createShader(source: string, type: 'vertex_shader' | 'fragment_shader'): WebGLShader;
-    updateUniforms(program: WebGLProgram, uniforms: Record<string, any>): void;
-    updateUniforms(uniforms: Record<string, any>): void;
-    reset(): void;
-    destroy(): void;
-}

package/dist/core/renderer/webgl/modules/WebGLScissorModule.d.ts

@@ -1,10 +0,0 @@
-import type { WebGLRenderer } from '../WebGLRenderer';
-import type { MaskData } from './WebGLMaskModule';
-import { WebGLModule } from './WebGLModule';
-export declare class WebGLScissorModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
-    get length(): number;
-    push(data: MaskData): void;
-    pop(_data: MaskData): void;
-    use(): void;
-}

package/dist/core/renderer/webgl/modules/WebGLStencilModule.d.ts

@@ -1,10 +0,0 @@
-import type { WebGLRenderer } from '../WebGLRenderer';
-import type { MaskData } from './WebGLMaskModule';
-import { WebGLModule } from './WebGLModule';
-export declare class WebGLStencilModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
-    get length(): number;
-    push(data: MaskData): void;
-    pop(data: MaskData): void;
-    use(): void;
-}

package/dist/core/renderer/webgl/modules/WebGLTextureModule.d.ts

@@ -1,26 +0,0 @@
-import type { WebGLTextureLocation, WebGLTextureMeta, WebGLTextureOptions, WebGLTextureTarget } from '../types';
-import type { WebGLRenderer } from '../WebGLRenderer';
-import { WebGLModule } from './WebGLModule';
-export declare class WebGLTextureModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
-    maxTextureSize: number;
-    maxUnits: number;
-    boundLocation: WebGLTextureLocation;
-    boundTarget: WebGLTextureTarget;
-    boundTextures: Record<WebGLTextureTarget, WebGLTexture | null>[];
-    emptyTextures: Record<WebGLTextureTarget, WebGLTexture | null>;
-    onUpdateContext(): void;
-    create(options?: WebGLTextureOptions): WebGLTexture;
-    getMeta(texture: WebGLTexture): WebGLTextureMeta;
-    update(options: WebGLTextureOptions): void;
-    update(texture: WebGLTexture, options: WebGLTextureOptions): void;
-    bind(texture: {
-        location?: WebGLTextureLocation;
-        forceUpdateLocation?: boolean;
-        target?: WebGLTextureTarget;
-        value: WebGLTexture | null;
-    } | null): void;
-    unbind(location: number, target?: WebGLTextureTarget): void;
-    unbind(texture: WebGLTexture): void;
-    reset(): void;
-}

package/dist/core/renderer/webgl/modules/WebGLVertexArrayModule.d.ts

@@ -1,19 +0,0 @@
-import type { WebGLVertexArrayObjectMeta, WebGLVertexArrayObjectOptions, WebGLVertexAttrib } from '../types';
-import type { WebGLRenderer } from '../WebGLRenderer';
-import { WebGLModule } from './WebGLModule';
-export declare class WebGLVertexArrayModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
-    boundVertexArrayNull: WebGLVertexArrayObjectMeta;
-    boundVertexArrayObject: WebGLVertexArrayObject | null;
-    boundVertexArray: WebGLVertexArrayObjectMeta;
-    enableVertexAttrib(key: string, location: number, attrib: WebGLVertexAttrib, dimension?: number): void;
-    create(options?: WebGLVertexArrayObjectOptions): WebGLVertexArrayObject | null;
-    create(program?: WebGLProgram, options?: WebGLVertexArrayObjectOptions): WebGLVertexArrayObject | null;
-    getVertexArrayMeta(vertexArray: WebGLVertexArrayObject): WebGLVertexArrayObjectMeta;
-    update(options: WebGLVertexArrayObjectOptions): void;
-    update(vertexArray: WebGLVertexArrayObject, options: WebGLVertexArrayObjectOptions): void;
-    update(program: WebGLProgram, vertexArray: WebGLVertexArrayObject, options: WebGLVertexArrayObjectOptions): void;
-    bind(vertexArrayObject: WebGLVertexArrayObject | null | WebGLVertexArrayObjectOptions): void;
-    unbind(): void;
-    reset(): void;
-}

package/dist/core/renderer/webgl/modules/WebGLViewportModule.d.ts

@@ -1,9 +0,0 @@
-import type { WebGLViewport } from '../types';
-import type { WebGLRenderer } from '../WebGLRenderer';
-import { WebGLModule } from './WebGLModule';
-export declare class WebGLViewportModule extends WebGLModule {
-    install(renderer: WebGLRenderer): void;
-    boundViewport: WebGLViewport;
-    bind(viewport: WebGLViewport): void;
-    reset(): void;
-}

package/dist/core/renderer/webgl/modules/index.d.ts

@@ -1,14 +0,0 @@
-export * from './types';
-export * from './WebGLBatch2DModule';
-export * from './WebGLBlendMode';
-export * from './WebGLBufferModule';
-export * from './WebGLFramebufferModule';
-export * from './WebGLMaskModule';
-export * from './WebGLModule';
-export * from './WebGLProgramModule';
-export * from './WebGLScissorModule';
-export * from './WebGLStateModule';
-export * from './WebGLStencilModule';
-export * from './WebGLTextureModule';
-export * from './WebGLVertexArrayModule';
-export * from './WebGLViewportModule';

package/dist/core/renderer/webgl/modules/types.d.ts

@@ -1,4 +0,0 @@
-import type { WebGLRenderer } from '../WebGLRenderer';
-export interface Renderable {
-    render: (renderer: WebGLRenderer) => void;
-}

package/dist/core/renderer/webgl/modules/utils.d.ts

@@ -1 +0,0 @@
-export declare function getChanged(source: Record<string, any>, target: Record<string, any>): Record<string, boolean>;