@predy-js/render-interface 0.0.6

package/dist/src/common/console.d.ts

@@ -0,0 +1,3 @@
+export declare function consoleLog(msg: string, ...data: any[]): void;
+export declare function consoleWarn(msg: string, ...data: any[]): void;
+export declare function consoleError(msg: string, ...data: any[]): void;

package/dist/src/common/env.d.ts

@@ -0,0 +1 @@
+export declare function isAndroid(): boolean;

package/dist/src/common/raf.d.ts

@@ -0,0 +1,2 @@
+export declare function requestAnimationFrame(cb: (n: number) => void): number;
+export declare function cancelAnimationFrame(handle: number): void;

package/dist/src/common/request.d.ts

@@ -0,0 +1,10 @@
+export interface RequestOptions {
+    method?: 'get' | 'post';
+    responseType?: 'json' | 'blob' | 'arraybuffer';
+    data?: XMLHttpRequestBodyInit | null;
+}
+export declare function requestAsync(url: string, options?: RequestOptions): Promise<any>;
+export declare function loadImageAsync(imgOrURL: string | HTMLImageElement | Blob, options?: {
+    asImageBitMap?: boolean;
+    revokeURL?: boolean;
+}): Promise<HTMLImageElement | ImageBitmap>;

package/dist/src/common/utils.d.ts

@@ -0,0 +1,14 @@
+export declare function isFunc(val: any): boolean;
+export declare function isObj(a: any): boolean;
+export declare function isStr(a: any, withLength?: boolean): boolean;
+export declare function arrRemove(arr: Array<any>, ele: any): boolean;
+export declare function arrAdd<T>(arr: Array<T>, item: T): boolean;
+export declare function strHashCode(...strings: string[]): number;
+export declare function arrAddByOrder(arr: Array<any>, item: any, order?: number): boolean;
+export declare function sortByOrder(arr: Array<any>, order?: number): Array<any>;
+export declare function forEach<T>(object: null | undefined | {
+    [key: string]: T;
+}, callback: (val: T, key: string) => void, thisObj?: any): {
+    [key: string]: T;
+} | null | undefined;
+export declare function throwDestroyedError(): void;

package/dist/src/index.d.ts

@@ -0,0 +1,17 @@
+export * from '../types/constants';
+export * from '../types/RenderPass';
+export * from '../types/Texture';
+export * from '../types/GPUBuffer';
+export { constants } from './webgl/constants';
+export * from '../types/ShaderLibrary';
+export { MarsRenderFrame as RenderFrame } from './render/MarsRenderFrame';
+export { MarsRenderer as Renderer } from './render/MarsRenderer';
+export { MarsMesh as Mesh } from './render/MarsMesh';
+export { MarsGeometry as Geometry } from './render/MarsGeometry';
+export { MarsRenderPass as RenderPass } from './render/MarsRenderPass';
+export { MarsTexture as Texture } from './render/MarsTexture';
+export { MarsMaterial as Material } from './render/MarsMaterial';
+export { MarsMaterialDataBlock as MaterialDataBlock } from './render/MarsMaterialDataBlock';
+export { MarsSharedGeometry as SharedGeometry } from './render/MarsSharedGeometry';
+export { getDefaultGPUCapability } from './render/MarsGPUCapability';
+export { getDefaultTextureFactory, setDefaultTextureFactory, MarsTextureFactory } from './render/MarsTextureFactory';

package/dist/src/render/MarsExtWrap.d.ts

@@ -0,0 +1,15 @@
+import type { RendererExtensions, RenderPass, Texture } from '../../types';
+import type { MarsTexture } from './MarsTexture';
+import type { MarsRenderer } from './MarsRenderer';
+import { MarsRenderPass } from './MarsRenderPass';
+export declare class MarsExtWrap implements RendererExtensions {
+    _copyRenderPass?: MarsRenderPass;
+    renderer?: MarsRenderer;
+    constructor(renderer: MarsRenderer);
+    resetColorAttachments(rp: RenderPass, colorTextures: Texture[]): void;
+    copyTexture(source: Texture, tex: Texture): void;
+    copy2(source: MarsTexture, target: MarsTexture): void;
+    copy1(source: MarsTexture, target: MarsTexture): void;
+    _createCopyRenderPass(): MarsRenderPass;
+    destroy(): void;
+}

package/dist/src/render/MarsGPUCapability.d.ts

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

package/dist/src/render/MarsGeometry.d.ts

@@ -0,0 +1,64 @@
+import type { Immutable, TypedArray } from '../../types/type';
+import type { Geometry, GeometryOptions, AttributeWithType, Attribute } from '../../types/Geometry';
+import type { GPUBuffer, GPUBufferOptions } from '../../types/GPUBuffer';
+import { GLGeometry } from '../webgl/GLGeometry';
+import type { MarsRenderer } from './MarsRenderer';
+type BufferDirtyFlag = {
+    dirty: boolean;
+    discard?: boolean;
+    start?: number;
+    end?: number;
+};
+/**
+ * 应用层Geometry对象，本身不直接保存GPU资源而是通过geometryInternal成员保存GPU资源。
+ *
+ */
+export declare class MarsGeometry implements Geometry {
+    renderer?: MarsRenderer;
+    _buffers: {
+        [key: string]: GPUBufferOptions;
+    };
+    _attributes: Record<string, AttributeWithType>;
+    _attributesReleasable: {
+        [key: string]: boolean;
+    };
+    _attributesName: string[];
+    _dirtyFlags: {
+        [key: string]: BufferDirtyFlag;
+    };
+    _index?: Uint8Array | Uint16Array | Uint32Array;
+    _indexReleasable: boolean;
+    readonly internal: GLGeometry;
+    readonly options?: GeometryOptions;
+    readonly name: string;
+    protected _drawCount: number;
+    protected _drawStart: number;
+    protected _mode: number;
+    protected _isDestroyed: boolean;
+    get isDestroyed(): boolean;
+    get mode(): number;
+    set mode(n: number);
+    get attributes(): Immutable<{
+        [key: string]: Attribute;
+    }>;
+    get drawCount(): number;
+    set drawCount(n: number | undefined);
+    get drawStart(): number;
+    set drawStart(n: number);
+    constructor(option: GeometryOptions);
+    destroy(): void;
+    setAttributeBuffer(name: string, buffer: GPUBuffer): void;
+    getAttributeBuffer(name: string): GPUBuffer | undefined;
+    setAttributeData(name: string, data: TypedArray): void;
+    getAttributeData(name: string): TypedArray | undefined;
+    setAttributeSubData(name: string, offset: number, data: TypedArray): void;
+    getIndexData(): Uint8Array | Uint16Array | Uint32Array | undefined;
+    setIndexData(data: Uint8Array | Uint16Array | Uint32Array | undefined): void;
+    setIndexSubData(offset: number, data: TypedArray): void;
+    getAttributeStride(name: string): number;
+    getAttributeDataLength(name: string): number;
+    getAttributeNames(): string[];
+    assignRenderer(renderer: MarsRenderer): MarsGeometry;
+    flush(): boolean;
+}
+export {};

package/dist/src/render/MarsMaterial.d.ts

@@ -0,0 +1,29 @@
+import type { Material, MaterialDestroyOptions, MaterialOptions, MaterialRenderStates } from '../../types';
+import type { UniformSemantic } from '../../types';
+import { MaterialRenderType } from '../../types/Material';
+import type { Immutable } from '../../types/type';
+import { GLMaterial } from '../webgl/GLMaterial';
+import type { MarsRenderer } from './MarsRenderer';
+import { MarsMaterialDataBlock } from './MarsMaterialDataBlock';
+export declare class MarsMaterial implements Material {
+    readonly shaderCacheId: string;
+    readonly options: Immutable<MaterialOptions>;
+    readonly materialInternal?: GLMaterial;
+    readonly name: string;
+    readonly _dataBlocks: MarsMaterialDataBlock[];
+    readonly renderType: MaterialRenderType;
+    readonly states: Immutable<MaterialRenderStates>;
+    readonly renderer?: MarsRenderer;
+    private _isDestroyed;
+    readonly uniformSemantics: Record<string, UniformSemantic>;
+    get isDestroyed(): boolean;
+    get dataBlocks(): MarsMaterialDataBlock[];
+    get defaultDataBlock(): MarsMaterialDataBlock;
+    constructor(options: MaterialOptions);
+    createMaterialStates(states: MaterialRenderStates): Immutable<MaterialRenderStates>;
+    addDataBlock(b: MarsMaterialDataBlock): void;
+    removeDataBlock(b: MarsMaterialDataBlock): void;
+    setUniformSemantic(uniformName: string, semantic: string | undefined): void;
+    assignRenderer(renderer: MarsRenderer): MarsMaterial;
+    destroy(options?: MaterialDestroyOptions): void;
+}

package/dist/src/render/MarsMaterialDataBlock.d.ts

@@ -0,0 +1,37 @@
+import type { MaterialDataBlock, MaterialDataBlockDestroyOptions, MaterialDataBlockOptions, UniformValue, vec2 } from '../../types';
+import type { MarsRenderer } from './MarsRenderer';
+import type { UniformBlockSpec } from '../webgl/GLUniformUtils';
+import { UniformBlockBuffer } from '../webgl/GLUniformUtils';
+export declare class MarsMaterialDataBlock implements MaterialDataBlock {
+    readonly _uniformValues: Record<string, UniformValue>;
+    readonly _uniformFlags: Record<string, boolean>;
+    readonly _uniformValueRanges: Record<string, vec2>;
+    readonly name: string;
+    readonly renderer?: MarsRenderer;
+    readonly uboBufferMap: Record<string, UniformBlockBuffer>;
+    protected _isDestroyed: boolean;
+    private readonly _keepUboData;
+    constructor(props: MaterialDataBlockOptions & {
+        keepUboData?: boolean;
+    }, renderer?: MarsRenderer);
+    _assignUniformValueRenderer(value: UniformValue, renderer?: MarsRenderer): void;
+    invalidAllFlags(): void;
+    clearFlags(): void;
+    isDirty(shaderCacheId: string, name: string): boolean;
+    get isDestroyed(): boolean;
+    assignRenderer(renderer: MarsRenderer): MaterialDataBlock;
+    createUboBuffer(spec: UniformBlockSpec): UniformBlockBuffer | undefined;
+    setUboBuffer(uboBuffer: UniformBlockBuffer): void;
+    updateUniformSubData(name: string, start: number, count: number): void;
+    hasUniformValue(name: string): boolean;
+    destroy(options?: MaterialDataBlockDestroyOptions): void;
+    getUniformValue(name: string): UniformValue;
+    getUniformValues(): {
+        [p: string]: UniformValue;
+    };
+    setUniformValue(name: string, value: UniformValue | undefined): boolean;
+    setUniformValues(map: {
+        [p: string]: UniformValue;
+    }): void;
+    clone(name: string): MarsMaterialDataBlock;
+}

package/dist/src/render/MarsMesh.d.ts

@@ -0,0 +1,24 @@
+import type { Mesh, MeshDestroyOptions, MeshOptions } from '../../types/Mesh';
+import { MarsMaterial } from './MarsMaterial';
+import { MarsGeometry } from './MarsGeometry';
+import type { Material, MaterialDestroyOptions, MaterialOptions } from '../../types/Material';
+import type { MarsRenderer } from './MarsRenderer';
+import type { mat4 } from '../../types';
+import { DestroyOptions } from '../../types/constants';
+export declare class MarsMesh implements Mesh {
+    readonly material: MarsMaterial;
+    readonly geometries: MarsGeometry[];
+    readonly name: string;
+    priority: number;
+    worldMatrix: mat4 | Float32Array;
+    hide: boolean;
+    renderer?: MarsRenderer;
+    private _isDestroyed;
+    get isDestroyed(): boolean;
+    get geometry(): MarsGeometry;
+    constructor(options: MeshOptions);
+    setMaterial(mtl: Material | MaterialOptions, destroyMtl?: MaterialDestroyOptions | DestroyOptions.keep): void;
+    setGeometries(geos: MarsGeometry[], destroyGeometries?: DestroyOptions): void;
+    destroy(options?: MeshDestroyOptions): void;
+    assignRenderer(renderer: MarsRenderer): MarsMesh;
+}

package/dist/src/render/MarsRenderFrame.d.ts

@@ -0,0 +1,22 @@
+import type { RenderFrame, RenderFrameDestroyOptions, RenderFrameOptions, RenderPass, RenderPassClearAction } from '../../types';
+import type { MarsRenderer } from './MarsRenderer';
+import { MarsSemanticMap } from './MarsSemanticMap';
+export declare class MarsRenderFrame implements RenderFrame {
+    clearAction: RenderPassClearAction;
+    readonly name: string;
+    readonly semantics: MarsSemanticMap;
+    _renderPasses: RenderPass[];
+    private _renderer;
+    private _isDestroyed;
+    get renderPasses(): RenderPass[];
+    get isDestroyed(): boolean;
+    get renderer(): MarsRenderer;
+    constructor(options: RenderFrameOptions, renderer?: MarsRenderer);
+    assignRenderer(renderer: MarsRenderer): MarsRenderFrame;
+    destroy(options?: RenderFrameDestroyOptions): void;
+    render(): void;
+    setRenderPasses(passes: RenderPass[]): void;
+    addRenderPass(pass: RenderPass): void;
+    removeRenderPass(pass: RenderPass): void;
+    forEachRenderPass(callback: (renderPass: RenderPass, index: number, pipeline: MarsRenderFrame) => void): void;
+}

package/dist/src/render/MarsRenderPass.d.ts

@@ -0,0 +1,51 @@
+import type { RenderPass, RenderPassAttachmentOptions, RenderPassClearAction, RenderPassDelegate, RenderPassDepthStencilAttachment, RenderPassDestroyOptions, RenderPassOptions, RenderPassStoreAction } from '../../types/RenderPass';
+import { RenderPassAttachmentStorageType, RenderPassMeshOrder } from '../../types/RenderPass';
+import type { MarsMesh } from './MarsMesh';
+import type { Camera } from '../../types/Camera';
+import type { MarsRenderer } from './MarsRenderer';
+import { GLFrameBuffer } from '../webgl/GLFrameBuffer';
+import { MarsRenderPassColorAttachment } from './MarsRenderPassColorAttachment';
+import { MarsTexture } from './MarsTexture';
+import type { vec4 } from '../../types';
+import { MarsSemanticMap } from './MarsSemanticMap';
+export declare class MarsRenderPass implements RenderPass {
+    delegate: RenderPassDelegate;
+    readonly name: string;
+    readonly priority: number;
+    readonly meshes: MarsMesh[];
+    readonly camera: Camera;
+    readonly options: RenderPassAttachmentOptions;
+    readonly renderer: MarsRenderer;
+    readonly frameBuffer?: GLFrameBuffer;
+    readonly depthStencilType: RenderPassAttachmentStorageType;
+    readonly clearAction: RenderPassClearAction;
+    readonly storeAction: RenderPassStoreAction;
+    readonly semantics: MarsSemanticMap;
+    private _isDestroyed;
+    private _depthTexture?;
+    private _stencilTexture?;
+    private _attachments;
+    get isDestroyed(): boolean;
+    get attachments(): MarsRenderPassColorAttachment[];
+    viewportScale: number;
+    private _isCustomViewport;
+    private _customViewport?;
+    meshOrder: RenderPassMeshOrder;
+    constructor(options: RenderPassOptions, renderer?: MarsRenderer);
+    get viewport(): vec4;
+    get stencilAttachment(): RenderPassDepthStencilAttachment | undefined;
+    get depthAttachment(): RenderPassDepthStencilAttachment | undefined;
+    bind(): void;
+    private _getDepthTexture;
+    private _getStencilTexture;
+    private _setViewportOptions;
+    resetColorAttachments(colors: MarsTexture[]): void;
+    resetAttachments(options: RenderPassAttachmentOptions): RenderPassAttachmentOptions;
+    private _resetAttachments;
+    unbind(): void;
+    assignRenderer(renderer: MarsRenderer): MarsRenderPass;
+    destroy(options?: RenderPassDestroyOptions): void;
+    addMesh(mesh: MarsMesh): void;
+    removeMesh(mesh: MarsMesh): void;
+    setMeshes(meshes: MarsMesh[]): MarsMesh[];
+}

package/dist/src/render/MarsRenderPassColorAttachment.d.ts

@@ -0,0 +1,27 @@
+import type { RenderPassColorAttachment, RenderPassColorAttachmentOptions, RenderPassColorAttachmentTextureOptions } from '../../types/RenderPass';
+import { RenderPassAttachmentStorageType } from '../../types/RenderPass';
+import { MarsTexture } from './MarsTexture';
+import type { MarsRenderer } from './MarsRenderer';
+interface MarsRenderPassColorAttachmentOptions extends RenderPassColorAttachmentOptions {
+    size?: [x: number, y: number];
+    name?: string;
+}
+interface MarsRenderPassColorAttachmentTextureOptions extends RenderPassColorAttachmentTextureOptions {
+    size?: [x: number, y: number];
+}
+export declare class MarsRenderPassColorAttachment implements RenderPassColorAttachment {
+    readonly readable: boolean;
+    texture: MarsTexture;
+    readonly externalTexture: boolean;
+    textureOptions?: MarsRenderPassColorAttachmentTextureOptions;
+    private _isDestroyed;
+    get isDestroyed(): boolean;
+    get storageType(): RenderPassAttachmentStorageType;
+    constructor(options: MarsRenderPassColorAttachmentOptions);
+    get size(): [x: number, y: number];
+    get width(): number;
+    get height(): number;
+    assignRenderer(renderer: MarsRenderer): MarsRenderPassColorAttachment;
+    destroy(): void;
+}
+export {};

package/dist/src/render/MarsRenderer.d.ts

@@ -0,0 +1,20 @@
+import type { GPUBuffer, GPUBufferOptions, GPUCapability, GPURenderer, RendererOptions, RenderFrameOptions, ShaderLibrary } from '../../types';
+import { GLGPURenderer } from '../webgl/GLGPURenderer';
+import { MarsRenderFrame } from './MarsRenderFrame';
+import type { Canvas } from '../../types/Canvas';
+import { MarsExtWrap } from './MarsExtWrap';
+export declare class MarsRenderer implements GPURenderer {
+    readonly gpu: GPUCapability;
+    readonly shaderLibrary: ShaderLibrary;
+    readonly internal: GLGPURenderer;
+    readonly canvas: Canvas;
+    readonly extension: MarsExtWrap;
+    get isDestroyed(): boolean;
+    get height(): number;
+    get width(): number;
+    constructor(options: RendererOptions);
+    createBuffer(options: GPUBufferOptions): GPUBuffer;
+    createRenderFrame(options?: RenderFrameOptions): MarsRenderFrame;
+    destroy(haltGL?: boolean): void;
+    resize(width: number, height: number): void;
+}

package/dist/src/render/MarsSemanticMap.d.ts

@@ -0,0 +1,10 @@
+import type { GPUBuffer, RenderState, UniformValue, SemanticMap, SemanticGetter } from '../../types';
+export declare class MarsSemanticMap implements SemanticMap {
+    readonly semantics: Record<string, SemanticGetter>;
+    constructor(semantics?: Record<string, SemanticGetter>);
+    toObject(): Record<string, SemanticGetter>;
+    setSemantic(name: string, value: SemanticGetter | undefined): void;
+    getSemanticValue(name: string, state: RenderState): UniformValue | GPUBuffer | null | undefined;
+    hasSemanticValue(name: string): boolean;
+    destroy(): void;
+}

package/dist/src/render/MarsSharedGeometry.d.ts

@@ -0,0 +1,13 @@
+import { MarsGeometry } from './MarsGeometry';
+import type { SharedGeometry, SharedGeometryOptions } from '../../types';
+import type { MarsRenderer } from './MarsRenderer';
+export declare class MarsSharedGeometry extends MarsGeometry implements SharedGeometry {
+    private readonly _source;
+    renderer: MarsRenderer;
+    constructor(opt: SharedGeometryOptions, renderer?: MarsRenderer);
+    assignRenderer(renderer: MarsRenderer): MarsSharedGeometry;
+    getAttributeNames(): string[];
+    getAttributeDataLength(name: string): number;
+    flush(): boolean;
+    destroy(): void;
+}

package/dist/src/render/MarsTexture.d.ts

@@ -0,0 +1,29 @@
+import type { Texture, TextureOptions, TextureSourceOptions } from '../../types/Texture';
+import { TextureSourceType } from '../../types/Texture';
+import type { GLGPURenderer } from '../webgl/GLGPURenderer';
+import { GLTexture } from '../webgl/GLTexture';
+import type { Immutable } from '../../types/type';
+import type { MarsRenderer } from './MarsRenderer';
+export declare function closeImageBitMap(img: any): void;
+export declare class MarsTexture implements Texture {
+    readonly id: string;
+    readonly options: Immutable<TextureOptions>;
+    readonly sourceType: TextureSourceType;
+    readonly name: string;
+    readonly renderer?: MarsRenderer;
+    readonly internal?: GLTexture;
+    private _offloaded;
+    private _isDestroyed;
+    get isDestroyed(): boolean;
+    constructor(options: TextureOptions | GLTexture, renderer?: MarsRenderer);
+    checkOptions(options: TextureOptions): Immutable<TextureOptions>;
+    get width(): number;
+    get height(): number;
+    assignRenderer(renderer: MarsRenderer): MarsTexture;
+    _assignRenderer(renderer: GLGPURenderer): void;
+    uploadCurrentVideoFrame(): boolean;
+    destroy(): void;
+    reloadDataAsync(): Promise<Texture>;
+    offloadData(): void;
+    updateSource(options: TextureSourceOptions): void;
+}

package/dist/src/render/MarsTextureFactory.d.ts

@@ -0,0 +1,20 @@
+import type { Texture, TextureConfigOptions, TextureCubeSourceURLMap, TextureFactory, TextureFactorySourceFrom, TextureOptions, TextureSourceCubeData } from '../../types/Texture';
+import type { TypedArray, vec2 } from '../../types';
+export declare class MarsTextureFactory implements TextureFactory {
+    reloadPending: {
+        [key: string]: Promise<Texture>;
+    };
+    constructor();
+    loadMipmapImagesAsync(pointers: vec2[], bin: ArrayBuffer): Promise<(HTMLImageElement | ImageBitmap)[]>;
+    loadImageAsync(url: string | HTMLImageElement | Blob): Promise<HTMLImageElement | ImageBitmap>;
+    requestBinaryAsync(url: string): Promise<ArrayBuffer>;
+    loadImageBinaryAsync(binary: ArrayBuffer | TypedArray | Blob, mime?: string): Promise<HTMLImageElement | ImageBitmap>;
+    canOffloadTexture(texture: Texture): boolean;
+    loadSourceAsync(sourceFrom: TextureFactorySourceFrom, config?: TextureConfigOptions): Promise<TextureOptions>;
+    _loadVideoAsync(url: string | null | MediaProvider): Promise<HTMLVideoElement>;
+    _loadCubeMapAsync(map: TextureCubeSourceURLMap | string[]): Promise<TextureSourceCubeData>;
+    loadCompressedTextureFromArrayBuffer(arrayBuffer: ArrayBuffer, options?: TextureOptions): TextureOptions;
+    reloadTextureAsync(texture: Texture): Promise<Texture>;
+}
+export declare function getDefaultTextureFactory(): TextureFactory;
+export declare function setDefaultTextureFactory(factory: TextureFactory): void;

package/dist/src/render/RenderFrameInternal.d.ts

@@ -0,0 +1,8 @@
+import type { MarsRenderFrame } from './MarsRenderFrame';
+import type { RenderState } from '../../types/RenderFrame';
+import type { MarsRenderPass } from './MarsRenderPass';
+import type { MarsRenderer } from './MarsRenderer';
+export declare class RenderFrameInternal {
+    static render(frame: MarsRenderFrame): void;
+    static renderRenderPass(renderer: MarsRenderer, pass: MarsRenderPass, renderState: RenderState): void;
+}

package/dist/src/statistic/index.d.ts

@@ -0,0 +1,20 @@
+import type { MarsRenderer } from '../render/MarsRenderer';
+import type { GLTexture } from '../webgl/GLTexture';
+export interface TextureStatistic {
+    name: string;
+    memory: number;
+}
+export interface BufferStatistic {
+    name: string;
+    memory: number;
+}
+export interface RendererStatistic {
+    textures: TextureStatistic[];
+    buffers: BufferStatistic[];
+    memory: {
+        texture: number;
+        buffer: number;
+    };
+}
+export declare function getRendererStatistic(renderer: MarsRenderer): RendererStatistic;
+export declare function getTextureMemory(tex: GLTexture | undefined): number;

package/dist/src/webgl/GLFrameBuffer.d.ts

@@ -0,0 +1,45 @@
+import type { GLGPURenderer } from './GLGPURenderer';
+import type { RenderPassDepthStencilAttachmentOptions, RenderPassStorageObject, RenderPassStoreAction } from '../../types/RenderPass';
+import { RenderPassAttachmentStorageType, RenderPassDestroyAttachmentType } from '../../types/RenderPass';
+import { GLRenderBuffer } from './GLRenderBuffer';
+import { GLTexture } from './GLTexture';
+export interface GLFrameBufferOptions {
+    attachments: GLTexture[];
+    depthStencilAttachment?: RenderPassDepthStencilAttachmentOptions;
+    isCustomViewport?: boolean;
+    viewport: [x: number, y: number, width: number, height: number];
+    viewportScale?: number;
+    storeAction: RenderPassStoreAction;
+    name?: string;
+}
+export declare class GLFrameBuffer {
+    readonly renderer: GLGPURenderer;
+    readonly viewport: [x: number, y: number, width: number, height: number];
+    readonly ready: boolean;
+    readonly depthStencilStorageType: RenderPassAttachmentStorageType;
+    readonly name: string;
+    externalStorage: boolean;
+    storeAction: RenderPassStoreAction;
+    storeInvalidAttachments?: GLenum[];
+    isCustomViewport: boolean;
+    depthStencilRenderBuffer?: GLRenderBuffer;
+    depthTexture?: GLTexture;
+    stencilTexture?: GLTexture;
+    colorTextures: GLTexture[];
+    fbo?: WebGLFramebuffer;
+    viewportScale: number;
+    readonly _attachmentHandles: WebGLTexture[];
+    constructor(options: GLFrameBufferOptions, renderer: GLGPURenderer);
+    get stencilStorage(): RenderPassStorageObject | undefined;
+    get depthStorage(): RenderPassStorageObject | undefined;
+    _getHandles(): void;
+    checkOptions(options: GLFrameBufferOptions): void;
+    getStoreAttachments(storeAction: RenderPassStoreAction, separateDepthStencil: boolean): GLenum[] | undefined;
+    unbind(): void;
+    bind(): void;
+    resetColorTextures(colors?: GLTexture[]): void;
+    destroy(opt?: {
+        depthStencilAttachment?: RenderPassDestroyAttachmentType;
+    }): void;
+    resize(x: number, y: number, width: number, height: number): void;
+}

package/dist/src/webgl/GLGPUBuffer.d.ts

@@ -0,0 +1,27 @@
+import type { GPUBuffer, GPUBufferOptions, GPUBufferTarget } from '../../types/GPUBuffer';
+import type { GLGPURenderer } from './GLGPURenderer';
+import type { TypedArray } from '../../types/type';
+import type { MarsRenderer } from '../render/MarsRenderer';
+export declare class GLGPUBuffer implements GPUBuffer {
+    readonly bytesPerElement: number;
+    readonly target: GPUBufferTarget;
+    readonly type: WebGLRenderingContext['FLOAT'] | WebGLRenderingContext['INT'] | WebGLRenderingContext['SHORT'];
+    readonly usage: WebGLRenderingContext['STATIC_DRAW'] | WebGLRenderingContext['DYNAMIC_DRAW'] | WebGLRenderingContext['STREAM_DRAW'];
+    readonly renderer?: GLGPURenderer;
+    readonly glBuffer: WebGLBuffer | null;
+    private _byteLength;
+    private _isDestroyed;
+    readonly name: string;
+    get byteLength(): number;
+    get isBuffer(): boolean;
+    get elementCount(): number;
+    get level(): number;
+    get isDestroyed(): boolean;
+    constructor(options: GPUBufferOptions, renderer: GLGPURenderer);
+    bind(): void;
+    bufferData(typedArray: TypedArray | number): void;
+    bufferSubData(elementOffset: number, typedArray: TypedArray): void;
+    destroy(): void;
+    readSubData(elementOffset: number, typedArray: TypedArray): boolean;
+    assignRenderer(renderer: MarsRenderer): GLGPUBuffer;
+}

package/dist/src/webgl/GLGPUCapability.d.ts

@@ -0,0 +1,32 @@
+import type { GPUCapability, GPUCapabilityDetail } from '../../types/GPUCapability';
+import type { Immutable } from '../../types/type';
+interface GLGPUCapabilityDetail extends GPUCapabilityDetail {
+    vao: boolean;
+    standardDerivatives: boolean;
+    halfFloatLinear: boolean;
+    floatLinear: boolean;
+    maxSample: number;
+    maxShaderTexCount: number;
+}
+export declare class GLGPUCapability implements GPUCapability {
+    readonly capability: Immutable<GLGPUCapabilityDetail>;
+    readonly level: number;
+    readonly type: 'webgl' | 'webgl2' | 'node-gl' | 'none';
+    drawBufferExtension: any;
+    vaoExt: any;
+    UNSIGNED_INT_24_8: number;
+    internalFormatDepth16: number;
+    internalFormatDepth24_stencil8: number;
+    constructor(opt: {
+        glType?: 'webgl' | 'webgl2';
+        gl?: WebGLRenderingContext | WebGL2RenderingContext;
+    });
+    _setupCapability(gl?: WebGLRenderingContext | WebGL2RenderingContext): void;
+    checkLinearTextureFilter(gl: WebGL2RenderingContext, type: number): boolean;
+    framebufferTexture2D(gl: WebGLRenderingContext | WebGL2RenderingContext, target: GLenum, index: number, textarget: number, texture: WebGLTexture): void;
+    drawBuffers(gl: WebGLRenderingContext | WebGL2RenderingContext, bufferStates: boolean[]): void;
+    setTextureAnisotropic(gl: WebGLRenderingContext | WebGL2RenderingContext, target: GLenum, level: number): void;
+    setup(gl: WebGLRenderingContext): void;
+}
+export declare function registerCompressedTexture(gl: WebGLRenderingContext | WebGL2RenderingContext): number;
+export {};

package/dist/src/webgl/GLGPURenderer.d.ts

@@ -0,0 +1,57 @@
+import { GLGPUBuffer } from './GLGPUBuffer';
+import { WebGLState } from './WebGLState';
+import { GLShaderLibrary } from './GLShaderLibrary';
+import type { GPURenderer, RendererExtensions } from '../../types';
+import type { GPUBufferOptions } from '../../types/GPUBuffer';
+import type { RenderFrame, RenderFrameOptions } from '../../types/RenderFrame';
+import type { ParsedScene, SceneSchema } from '../../types/Scene';
+import { GLGPUCapability } from './GLGPUCapability';
+import { GLTexture } from './GLTexture';
+import type { GLRenderBuffer } from './GLRenderBuffer';
+import type { GLFrameBuffer } from './GLFrameBuffer';
+export declare class GLGPURenderer implements GPURenderer {
+    readonly gl: WebGLRenderingContext | WebGL2RenderingContext;
+    readonly level: number;
+    readonly gpu: GLGPUCapability;
+    readonly state: WebGLState;
+    readonly shaderLibrary: GLShaderLibrary;
+    readonly emptyTexture2D: GLTexture;
+    readonly emptyTextureCube: GLTexture;
+    readonly _buffers: GLGPUBuffer[];
+    readonly _textures: GLTexture[];
+    readonly _renderBuffers: GLRenderBuffer[];
+    readonly _frameBuffers: GLFrameBuffer[];
+    readonly _vaos: WebGLVertexArrayObject[];
+    private _sourceFbo;
+    private _targetFbo;
+    private _isDestroyed;
+    extension: RendererExtensions;
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
+    get isDestroyed(): boolean;
+    onContextLose: (e: Event) => void;
+    copy2(source: GLTexture, target: GLTexture): void;
+    resetColorAttachments(rp: GLFrameBuffer, colors: GLTexture[]): void;
+    createGLRenderBuffer(renderbuffer: GLRenderBuffer): WebGLRenderbuffer | null;
+    createPipeline(options?: RenderFrameOptions): RenderFrame;
+    createBuffer(options: GPUBufferOptions): GLGPUBuffer;
+    parseSceneSchema(schema: SceneSchema): ParsedScene;
+    resize(width: number, height: number): void;
+    _assignInspectorName(obj: any, name?: string, id?: string): void;
+    createGLFrameBuffer(frameBuffer: GLFrameBuffer, name?: string): WebGLFramebuffer | null;
+    createGLTexture(texture: GLTexture, name?: string): WebGLTexture | null;
+    createGLBuffer(gpuBuffer: GLGPUBuffer, name?: string): WebGLBuffer | null;
+    deleteGLTexture(texture: GLTexture): void;
+    deleteGPUBuffer(buffer: GLGPUBuffer | null): void;
+    deleteGLFrameBuffer(frameBuffer: GLFrameBuffer): void;
+    deleteGLRenderBuffer(renderbuffer: GLRenderBuffer): void;
+    createVertexArray(name?: string): WebGLVertexArrayObject | undefined;
+    _bindVertexArray(vao: WebGLVertexArrayObject | null): void;
+    _bindVertexArrayOES(vao: WebGLVertexArrayObject | null): void;
+    bindVertexArray(vao: WebGLVertexArrayObject | null): void;
+    deleteVertexArray(vao: WebGLVertexArrayObject): void;
+    destroy(haltGL?: boolean): void;
+    get height(): number;
+    get width(): number;
+    get canvas(): HTMLCanvasElement | OffscreenCanvas;
+    createRenderFrame(options?: RenderFrameOptions): RenderFrame;
+}