@predy-js/render-interface 0.0.6

package/dist/types/Geometry.d.ts

@@ -0,0 +1,142 @@
+import type { GPUBuffer } from './GPUBuffer';
+import type { IGPUResource, IGPURenderer } from './IGPURenderer';
+import type { Immutable, TypedArray } from './type';
+import type { GPURenderer } from './Renderer';
+/**
+ * Attribute binding information,
+ * size:attribute size. the size attribute of vec4|vec3|vec2 is 4|3|2
+ * stride:used for interleaved attributes, 2 vec4 stride is 4 * 2 * Float32Array.BYTES_PER_ELEMENTS
+ * offset: offset for interleaved attributes, 1 vec4 offset is 4 * Float32Array.BYTES_PER_ELEMENTS
+ * normalize: attributed should be normalized
+ * Attribute的绑定信息
+ * size：向量的大小，vec4｜vec3｜vec2的大小分别为 4｜3｜2
+ * stride：如果使用交错存储顶点，2个vec4的stride为 2 * 4 * Float32Array.BYTES_PER_ELEMENTS
+ * offset：交错顶点的数据偏移，1个vec4的偏移为 4*Float32Array.BYTES_PER_ELEMENTS
+ */
+export interface AttributeBase {
+    size: number;
+    stride?: number;
+    offset?: number;
+    instanceDivisor?: number;
+    normalize?: boolean;
+}
+/**
+ * if data provided, type can be inferred from its data
+ * if data not provided, type will be FLOAT by default
+ * releasable is false by default,
+ * if releasable set true, geometry.getAttributeData will return null after data send to gpu buffer
+ * 如果有data字段，type会根据数据进行推断
+ * 如果没有data字段，type默认为FLOAT
+ * releasable默认为false，如果为true，在数据被提交到gpu buffer后geometry.getAttributeData方法返回null
+ */
+export interface AttributeWithData extends AttributeBase {
+    data?: TypedArray;
+    releasable?: boolean;
+    type?: WebGLRenderingContext['FLOAT'] | WebGLRenderingContext['INT'] | WebGLRenderingContext['SHORT'];
+}
+export interface AttributeWithType extends AttributeBase {
+    /**
+       * 如果使用interleaved attribute，此字段表示数据共享的attribute
+       */
+    dataSource: string;
+    type: WebGLRenderingContext['FLOAT'] | WebGLRenderingContext['INT'] | WebGLRenderingContext['SHORT'];
+}
+export interface AttributeWithDataSource extends AttributeBase {
+    /**
+       * 如果使用interleaved attribute，此字段表示数据共享的attribute
+       */
+    dataSource: string;
+    /**
+       * use FLOAT by default
+       */
+    type?: WebGLRenderingContext['FLOAT'] | WebGLRenderingContext['INT'] | WebGLRenderingContext['SHORT'];
+}
+export type Attribute = AttributeWithData | AttributeWithType | AttributeWithDataSource;
+export type GeometryDrawMode = WebGLRenderingContext['POINTS'] | WebGLRenderingContext['TRIANGLES'] | WebGLRenderingContext['TRIANGLE_STRIP'] | WebGLRenderingContext['TRIANGLE_FAN'] | WebGLRenderingContext['LINES'] | WebGLRenderingContext['LINE_STRIP'] | WebGLRenderingContext['LINE_LOOP'];
+export interface GeometryOptions {
+    name?: string;
+    attributes: {
+        [key: string]: Attribute;
+    };
+    index?: {
+        data: Uint8Array | Uint16Array | Uint32Array;
+        releasable?: boolean;
+    };
+    mode?: GeometryDrawMode;
+    drawCount?: number;
+    drawStart?: number;
+    instanceCount?: number;
+    TransformFeedbackTarget?: TransformFeedbackTarget;
+    bufferUsage?: GLenum;
+}
+type TransformFeedbackTarget = {
+    [key: string]: number;
+};
+export declare class Geometry implements IGPUResource {
+    readonly renderer?: IGPURenderer;
+    /**
+       * 集合体的attribute信息，只读
+       */
+    readonly attributes?: Immutable<{
+        [key: string]: Attribute;
+    }>;
+    readonly isDestroyed: boolean;
+    readonly options?: Immutable<GeometryOptions>;
+    drawStart: number;
+    drawCount: number;
+    mode: number;
+    constructor(options: GeometryOptions, renderer?: IGPURenderer);
+    assignRenderer(renderer: GPURenderer): Geometry;
+    destroy(): void;
+    setAttributeBuffer(name: string, buffer: GPUBuffer): void;
+    getAttributeBuffer(name: string): GPUBuffer | undefined;
+    /**
+       * Attribute的实际数据尺寸，如果没有配置stride，则通过attribute size和attribute数据类型进行计算
+       * @param name
+       */
+    getAttributeStride(name: string): number;
+    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;
+    /**
+       * 获取Attribute的数据内存长度
+       * 如果此Attribute设置了其他dataSource则返回 0
+       * 无论是否设置了attribute releasable，此函数总是返回实际数据长度
+       * //todo liyaohui.lyh@antgroup.com
+       * @param name
+       */
+    getAttributeDataLength(name: string): number;
+    getAttributeNames(): string[];
+    /**
+       * 数据写入的指令被缓存到JS中，在调用此函数后，所有JS数据指令开始调用对应的GPU函数
+       * 如果geometry对象没有进行GPU对象绑定，此函数不会成功
+       */
+    flush(): boolean;
+}
+export interface SharedGeometryOptions {
+    name?: string;
+    drawStart?: number;
+    drawCount?: number;
+    mode?: number;
+    index?: {
+        data: Uint8Array | Uint16Array | Uint32Array;
+        releasable?: boolean;
+    };
+    geometry: Geometry;
+}
+/**
+ * 重用Geometry的vao对象，可以进行indexBuffer的修改
+ */
+export declare class SharedGeometry extends Geometry {
+    /**
+       * clone geometry with same gpu buffers,
+       * if geometry renderer not assigned,this method returns void
+       * @param options
+       * @param renderer
+       */
+    constructor(options: SharedGeometryOptions, renderer?: IGPURenderer);
+}
+export {};

package/dist/types/IGPURenderer.d.ts

@@ -0,0 +1,14 @@
+export interface IGPURenderer {
+    readonly width: number;
+    readonly height: number;
+}
+export interface IGPUResource {
+    /**
+     * 大部分的JS数据对象创建不依赖于GPU接口，数据被存储在JS对象中，
+     * 当接收到GPU接口时，创建对应的GPU对象
+     */
+    readonly renderer?: IGPURenderer;
+    readonly isDestroyed: boolean;
+    assignRenderer(renderer: IGPURenderer): IGPUResource;
+    destroy(): void;
+}

package/dist/types/Material.d.ts

@@ -0,0 +1,156 @@
+import type { Texture } from './Texture';
+import type { ShaderUseCacheId, ShaderWithSource } from './ShaderLibrary';
+import type { IGPUResource, IGPURenderer } from './IGPURenderer';
+import type { Immutable, TypedArray } from './type';
+import type { GPURenderer } from './Renderer';
+import type { DestroyOptions } from './constants';
+export type UniformSemantic = 'VIEW' | 'MODEL' | 'MODELVIEW' | 'PROJECTION' | 'VIEWPROJECTION' | 'MODELVIEWPROJECTION' | string;
+export interface MaterialRenderStates {
+    sampleAlphaToCoverage?: boolean;
+    blending?: boolean;
+    blendEquationRGB?: number;
+    blendEquationAlpha?: number;
+    blendDstAlpha?: number;
+    blendSrcAlpha?: number;
+    blendSrc?: number;
+    blendDst?: number;
+    /**
+     * The blend color is a state value,
+     * like the blend equations and blend parameters. Therefore,
+     * it cannot change within a single draw call;
+     * fragment shaders cannot write to, modify,
+     * or even access the blend color.
+     * All buffers share the same blend color.
+     */
+    blendColor?: [r: number, g: number, b: number, a: number];
+    colorMask?: [r: boolean, g: boolean, b: boolean, a: boolean];
+    depthTest?: boolean;
+    depthMask?: boolean;
+    depthFunc?: number;
+    depthRange?: [zNear: number, zFar: number];
+    cullFace?: number;
+    cullFaceEnabled?: boolean;
+    frontFace?: number;
+    stencilTest?: boolean;
+    stencilMask?: number;
+    stencilMaskBack?: number;
+    stencilMaskFront?: number;
+    stencilFunc?: [func: GLenum, ref: GLint, mask: GLuint];
+    stencilFuncBack?: [func: GLenum, ref: GLint, mask: GLuint];
+    stencilFuncFront?: [func: GLenum, ref: GLint, mask: GLuint];
+    stencilOp?: [fail: GLenum, zfail: GLenum, zpass: GLenum];
+    stencilOpBack?: [fail: GLenum, zfail: GLenum, zpass: GLenum];
+    stencilOpFront?: [fail: GLenum, zfail: GLenum, zpass: GLenum];
+    polygonOffset?: [factor: number, units: number];
+    polygonOffsetFill?: boolean;
+}
+export declare const enum MaterialRenderType {
+    normal = 0,
+    transformFeedback = 1
+}
+export interface MaterialOptions {
+    states: MaterialRenderStates;
+    shader: ShaderWithSource | ShaderUseCacheId;
+    name?: string;
+    dataBlocks?: MaterialDataBlockOptions[];
+    uniformSemantics?: {
+        [key: string]: UniformSemantic;
+    };
+    renderType?: MaterialRenderType;
+    uniformValues?: {
+        [key: string]: UniformValue;
+    };
+    transformFeedbackOutput?: {
+        mode: WebGL2RenderingContext['INTERLEAVED_ATTRIBS'] | WebGL2RenderingContext['SEPARATE_ATTRIBS'];
+        varyings: string[];
+    };
+}
+/**
+ * @example
+ * const mtl0 = new Material({
+ *  shader:{
+ *   fragment:'...',
+ *   vertex:'...',
+ *   shaderCacheId:'mtl_01'
+ * }});
+ * console.log(mtl.shaderCacheId) // expect to be a none empty string
+ */
+/**
+ * @example
+ * const mtl0 = new Material({
+ *  shader:{
+ *   fragment:'...',
+ *   vertex:'...',
+ *   cacheId:'mtl_01'
+ * }});
+ *
+ * const mtl2 = new Material({
+ *   shader:{
+ *     cacheId:'mtl_01'
+ *   }
+ * });
+ * mtl2 use the same program with mtl0
+ */
+export type UniformValueDataType = TypedArray | number | number[] | Texture | Texture[] | number[][];
+export type UniformValue = UniformValueDataType | UniformStruct | UniformStruct[];
+export type UniformStruct = {
+    [key: string]: UniformValueDataType;
+};
+export interface MaterialDestroyOptions {
+    textures?: DestroyOptions;
+    blocks?: DestroyOptions;
+}
+export declare class Material implements IGPUResource {
+    readonly renderer?: IGPURenderer;
+    readonly name: string;
+    readonly defaultDataBlock: MaterialDataBlock;
+    readonly dataBlocks: MaterialDataBlock[];
+    readonly options: Immutable<MaterialOptions>;
+    readonly shaderCacheId: string;
+    readonly states: Immutable<MaterialRenderStates>;
+    readonly renderType: MaterialRenderType;
+    readonly isDestroyed: boolean;
+    constructor(options: MaterialOptions);
+    addDataBlock(b: MaterialDataBlock): void;
+    removeDataBlock(b: MaterialDataBlock): void;
+    destroy(options?: MaterialDestroyOptions): void;
+    setUniformSemantic(uniformName: string, semantic: string | undefined): void;
+    assignRenderer(renderer: GPURenderer): Material;
+}
+export interface MaterialDataBlockOptions {
+    uniformValues?: {
+        [key: string]: UniformValue;
+    };
+    name?: string;
+}
+export interface MaterialDataBlockDestroyOptions {
+    textures?: DestroyOptions;
+}
+export declare class MaterialDataBlock implements IGPUResource {
+    readonly renderer?: IGPURenderer;
+    readonly isDestroyed: boolean;
+    readonly name: string;
+    constructor(options: MaterialDataBlockOptions);
+    hasUniformValue(name: string): boolean;
+    setUniformValue(name: string, value: UniformValue): boolean;
+    getUniformValue(name: string): UniformValue;
+    getUniformValues(): {
+        [key: string]: UniformValue;
+    };
+    setUniformValues(map: {
+        [key: string]: UniformValue;
+    }): void;
+    /**
+     * indicate uniform data should be resent to GPU, but not the full range,
+     * only works for ubo,if not an ubo, this method has no side effect
+     * offset and count are counted by typed entry, not the number elements
+     * entry means matrix or vector in shader
+     * @param name uniform name
+     * @param offset entry offset,first entry to send to gpu, default 0
+     * @param count entry count,entry count to send to gpu,default to end
+     */
+    updateUniformSubData(name: string, offset: number, count: number): void;
+    destroy(options?: MaterialDataBlockDestroyOptions): void;
+    assignRenderer(renderer: GPURenderer): MaterialDataBlock;
+    clone(name: string): MaterialDataBlock;
+}

package/dist/types/Mesh.d.ts

@@ -0,0 +1,50 @@
+import type { Material, MaterialDestroyOptions, MaterialOptions } from './Material';
+import type { Geometry, GeometryOptions } from './Geometry';
+import type { IGPUResource, IGPURenderer } from './IGPURenderer';
+import type { GPURenderer } from './Renderer';
+import type { mat4 } from './type';
+import type { DestroyOptions } from './constants';
+interface MeshOptionsBase {
+    material: Material | MaterialOptions;
+    name?: string;
+    worldMatrix?: mat4 | Float32Array;
+    priority?: number;
+}
+export interface GeometryMeshOptions extends MeshOptionsBase {
+    geometry: Geometry | GeometryOptions;
+}
+export interface GeometriesMeshOptions extends MeshOptionsBase {
+    geometries: Array<Geometry | GeometryOptions>;
+}
+export type MeshOptions = GeometryMeshOptions | GeometriesMeshOptions;
+export type MeshDestroyOptions = {
+    geometries?: DestroyOptions;
+    material?: MaterialDestroyOptions | DestroyOptions.keep;
+};
+export declare class Mesh implements IGPUResource {
+    readonly renderer?: IGPURenderer;
+    readonly isDestroyed: boolean;
+    readonly name: string;
+    readonly geometries: Geometry[];
+    readonly geometry?: Geometry;
+    readonly material: Material;
+    worldMatrix: mat4 | Float32Array;
+    hide: boolean;
+    priority: number;
+    constructor(options: MeshOptions, renderer?: IGPURenderer);
+    /**
+     * update geometries
+     * @param geos geometries to update
+     * @param destroyGeometries whether to destroy previous geometries,default is true
+     */
+    setGeometries(geos: Geometry[], destroyGeometries?: DestroyOptions): void;
+    /**
+     * update material
+     * @param mtl material to update
+     * @param destroyMtl whether to destroy previous material, set true equals MaterialDestroyOptions { all:true }
+     */
+    setMaterial(mtl: Material | MaterialOptions, destroyMtl?: MaterialDestroyOptions | DestroyOptions.keep): void;
+    destroy(options?: MeshDestroyOptions): void;
+    assignRenderer(renderer: GPURenderer): Mesh;
+}
+export {};

package/dist/types/RenderFrame.d.ts

@@ -0,0 +1,50 @@
+import type { UniformValue } from './Material';
+import type { RenderPass, RenderPassClearAction, RenderPassDestroyOptions, SemanticMap } from './RenderPass';
+import type { Camera } from './Camera';
+import type { Mesh } from './Mesh';
+import type { GPUBuffer } from './GPUBuffer';
+import type { vec4 } from './type';
+import type { GPURenderer } from './index';
+import type { IGPURenderer, IGPUResource } from './IGPURenderer';
+import type { DestroyOptions } from './constants';
+export interface RenderState {
+    currentCamera: Camera;
+    currentMesh: Mesh;
+    currentFrame: RenderFrame;
+    currentPass: RenderPass;
+}
+export interface RenderFrameOptions {
+    renderPasses?: RenderPass[];
+    viewport?: vec4;
+    semantics?: {
+        [key: string]: UniformValue | SemanticFunc | GPUBuffer;
+    };
+    clearAction?: RenderPassClearAction;
+    name?: string;
+}
+export type SemanticFunc = (state: RenderState) => UniformValue | GPUBuffer | null | undefined;
+export type RenderFrameDestroyOptions = {
+    passes?: RenderPassDestroyOptions | DestroyOptions.keep;
+    semantics?: DestroyOptions;
+};
+export declare class RenderFrame implements IGPUResource {
+    clearAction: RenderPassClearAction;
+    constructor(options: RenderFrameOptions, renderer?: GPURenderer);
+    readonly renderPasses: RenderPass[];
+    readonly viewport?: vec4;
+    readonly semantics: SemanticMap;
+    readonly renderer?: IGPURenderer;
+    readonly isDestroyed: boolean;
+    setRenderPasses(passes: RenderPass[]): void;
+    addRenderPass(pass: RenderPass): void;
+    removeRenderPass(pass: RenderPass): void;
+    render(): void;
+    destroy(options?: RenderFrameDestroyOptions): void;
+    assignRenderer(renderer: IGPURenderer): RenderFrame;
+}
+/**
+ * RenderFrame 渲染顺序如下：
+ * 1. renderFrame 按照priority由底到高渲染renderPass，renderPass如果有设置attachments,则会创建frameBuffer对象
+ * 2. 每个renderPass渲染时，按照meshes数组顺序进行渲染，renderPass可以制定meshes数组的排序方式，对每个mesh的priority进行排序
+ * 3. 遍历Mesh时会将其Material中的Shader添加至shaderLibrary，再调用render之前，将所有shader进行编译
+ */

package/dist/types/RenderPass.d.ts

@@ -0,0 +1,156 @@
+import type { Texture, TextureConfigOptions, TextureFormatOptions } from './Texture';
+import type { Camera } from './Camera';
+import type { Mesh, MeshDestroyOptions } from './Mesh';
+import type { vec4 } from './type';
+import type { IGPURenderer, IGPUResource } from './IGPURenderer';
+import type { GPURenderer } from './Renderer';
+import type { UniformValue } from './Material';
+import type { GPUBuffer } from './GPUBuffer';
+import type { RenderState, SemanticFunc } from './RenderFrame';
+import type { DestroyOptions } from './constants';
+export declare enum RenderPassDestroyAttachmentType {
+    force = 0,
+    keep = 1,
+    keepExternal = 2,
+    destroy = 0
+}
+export declare const RenderPassPriorityPrepare = 0;
+export declare const RenderPassPriorityNormal = 1000;
+export declare const RenderPassPriorityPostprocess = 3000;
+export declare enum TextureLoadAction {
+    whatever = 0,
+    clear = 2
+}
+export declare enum TextureStoreAction {
+    store = 0,
+    clear = 2
+}
+export declare enum RenderPassAttachmentStorageType {
+    none = 0,
+    color = 1,
+    stencil_8_opaque = 2,
+    depth_16_opaque = 3,
+    depth_stencil_opaque = 4,
+    depth_16_texture = 5,
+    depth_24_stencil_8_texture = 6
+}
+export interface RenderPassStorageObject {
+    readonly attachment: GLenum;
+    readonly format: GLenum;
+    readonly size: [width: number, height: number];
+    readonly storageType: RenderPassAttachmentStorageType;
+    readonly multiSample: number;
+}
+export interface RenderPassColorAttachmentTextureOptions extends TextureFormatOptions, TextureConfigOptions {
+}
+export interface RenderPassColorAttachmentOptions {
+    texture?: Texture | RenderPassColorAttachmentTextureOptions;
+    storage?: RenderPassStorageObject;
+    multiSample?: number;
+}
+export interface RenderPassColorAttachment {
+    readonly storageType: RenderPassAttachmentStorageType;
+    readonly texture: Texture;
+    readonly isDestroyed: boolean;
+}
+export interface RenderPassDepthStencilAttachment {
+    readonly storageType: RenderPassAttachmentStorageType;
+    readonly texture?: Texture;
+    readonly storage: RenderPassStorageObject;
+}
+export interface RenderPassDepthStencilAttachmentOptions {
+    storageType: RenderPassAttachmentStorageType;
+    storage?: RenderPassStorageObject;
+    texture?: Texture;
+}
+export interface RenderPassStoreAction {
+    depthAction?: TextureStoreAction;
+    stencilAction?: TextureStoreAction;
+    colorAction?: TextureStoreAction;
+}
+export interface RenderPassClearAction {
+    clearColor?: vec4;
+    colorAction?: TextureLoadAction;
+    clearDepth?: number;
+    depthAction?: TextureLoadAction;
+    clearStencil?: number;
+    stencilAction?: TextureLoadAction;
+}
+export interface RenderPassAttachmentOptions {
+    attachments?: RenderPassColorAttachmentOptions[];
+    depthStencilAttachment?: RenderPassDepthStencilAttachmentOptions;
+    viewport?: [x: number, y: number, width: number, height: number];
+    viewportScale?: number;
+}
+export type SemanticGetter = UniformValue | SemanticFunc | GPUBuffer;
+export interface RenderPassOptions extends RenderPassAttachmentOptions {
+    name?: string;
+    meshes?: Mesh[];
+    camera?: Camera;
+    priority?: number;
+    meshOrder?: RenderPassMeshOrder;
+    clearAction?: RenderPassClearAction;
+    storeAction?: RenderPassStoreAction;
+    semantics?: {
+        [key: string]: SemanticGetter;
+    };
+    delegate?: RenderPassDelegate;
+}
+export declare enum RenderPassMeshOrder {
+    none = 1,
+    ascending = 2,
+    descending = 3
+}
+export type RenderPassDestroyOptions = {
+    meshes?: MeshDestroyOptions | DestroyOptions.keep;
+    depthStencilAttachment?: RenderPassDestroyAttachmentType;
+    colorAttachment?: RenderPassDestroyAttachmentType;
+    semantics?: DestroyOptions;
+};
+export declare class SemanticMap {
+    constructor(options?: {
+        [key: string]: SemanticGetter;
+    });
+    setSemantic(name: string, value: SemanticGetter | undefined): void;
+    getSemanticValue(name: string, state: RenderState): UniformValue | GPUBuffer | null | undefined;
+    hasSemanticValue(name: string): boolean;
+    toObject(): Record<string, SemanticGetter>;
+    destroy(): void;
+}
+export interface RenderPassDelegate {
+    willBeginRenderPass?: (renderPass: RenderPass, state: RenderState) => void;
+    didEndRenderPass?: (renderPass: RenderPass, state: RenderState) => void;
+    willRenderMesh?: (mesh: Mesh, state: RenderState) => void;
+    didiRenderMesh?: (mesh: Mesh, state: RenderState) => void;
+}
+export declare class RenderPass implements IGPUResource {
+    readonly isDestroyed: boolean;
+    readonly name: string;
+    readonly priority: number;
+    readonly attachments: RenderPassColorAttachment[];
+    readonly depthAttachment?: RenderPassDepthStencilAttachment;
+    readonly stencilAttachment?: RenderPassDepthStencilAttachment;
+    readonly viewport: [x: number, y: number, width: number, height: number];
+    readonly camera: Camera;
+    readonly meshes: Mesh[];
+    readonly renderer?: IGPURenderer;
+    readonly semantics: SemanticMap;
+    readonly storeAction: RenderPassStoreAction;
+    readonly clearAction: RenderPassClearAction;
+    delegate: RenderPassDelegate;
+    meshOrder: RenderPassMeshOrder;
+    constructor(options: RenderPassOptions, renderer?: IGPURenderer);
+    /**
+     * reset color/depth_stencil attachments,
+     * if color/depth_stencil texture is external, this will not destroy textures
+     * if color/depth_stencil texture is internal created, this will also delete those textures
+     * this method will delete previous fbo if exists
+     * returns previous options
+     **/
+    resetAttachments(options: RenderPassAttachmentOptions): RenderPassAttachmentOptions;
+    setMeshes(meshes: Mesh[]): Mesh[];
+    addMesh(mesh: Mesh): void;
+    removeMesh(mesh: Mesh): void;
+    destroy(options?: RenderPassDestroyOptions): void;
+    assignRenderer(renderer: GPURenderer): RenderPass;
+}

package/dist/types/Renderer.d.ts

@@ -0,0 +1,52 @@
+import type { RenderFrame, RenderFrameOptions } from './RenderFrame';
+import type { ShaderLibrary } from './ShaderLibrary';
+import type { GPUCapability } from './GPUCapability';
+import type { GPUBuffer, GPUBufferOptions } from './GPUBuffer';
+import type { IGPURenderer } from './IGPURenderer';
+import type { Canvas } from './Canvas';
+import type { Texture } from './Texture';
+import type { RenderPass } from './RenderPass';
+export { Camera, CameraOptions } from './Camera';
+export interface RendererOptions {
+    gl?: WebGLRenderingContext | WebGL2RenderingContext;
+    canvas?: HTMLCanvasElement;
+    frameworks?: Array<'webgl' | 'webgl2'>;
+    willCaptureImage?: boolean;
+    premultiplyAlpha?: boolean;
+}
+/**
+ * 常用的GPU方法，不是规范必须实现的
+ */
+export interface RendererExtensions {
+    copyTexture?: (source: Texture, tex: Texture) => void;
+    resetColorAttachments?: (rp: RenderPass, colorAttachments: Texture[]) => void;
+}
+export declare class GPURenderer implements IGPURenderer {
+    readonly height: number;
+    readonly width: number;
+    /**
+     * if webgl not support, gpu.level will be 0
+     */
+    readonly shaderLibrary: ShaderLibrary;
+    readonly gpu: GPUCapability;
+    readonly canvas: Canvas;
+    readonly extension: RendererExtensions;
+    readonly isDestroyed: boolean;
+    constructor(options: RendererOptions);
+    createRenderFrame(options?: RenderFrameOptions): RenderFrame;
+    createBuffer(options: GPUBufferOptions): GPUBuffer;
+    /**
+     * only resize when width or height is different from now,
+     * when resized,all full-screen renderPasses attached to this renderer should be resized as well
+     * 只有当宽高不同的时候，才实际进行函数
+     * 当重新调整宽高后，这个renderer创建的renderPasses，如果没有被指定 viewport（全屏），那么需要resize 所有的renderPass
+     * @param width
+     * @param height
+     */
+    resize(width: number, height: number): void;
+    /**
+     * destroy all resources created by this renderer
+     * @param haltGL if true, this method will call webgl lose context extension which leads webgl absolutely halt
+     */
+    destroy(haltGL?: boolean): void;
+}

package/dist/types/Scene.d.ts

@@ -0,0 +1,48 @@
+import type { Geometry, GeometryOptions } from './Geometry';
+import type { Material, MaterialOptions, UniformValue } from './Material';
+import type { Texture, TextureOptions } from './Texture';
+import type { RenderPass, RenderPassOptions } from './RenderPass';
+import type { Camera, CameraOptions } from './Camera';
+import type { Mesh } from './Mesh';
+type SceneNode = {
+    meshes: number[];
+    camera: number;
+};
+type SceneMaterial = MaterialOptions | {
+    extends: number;
+    vertexShader: string | number;
+    fragmentShader: string | number;
+    uniforms: {
+        [key: string]: UniformValue;
+    };
+    textures: {
+        [key: string]: number | number[];
+    };
+};
+type SceneMesh = {
+    name: string;
+    material: number;
+    geometries: number[];
+};
+type SceneRenderPass = RenderPassOptions | {
+    attachments: number[];
+};
+export interface SceneSchema {
+    texture: TextureOptions[];
+    geometries: GeometryOptions[];
+    materials: SceneMaterial[];
+    meshes: SceneMesh[];
+    nodes: SceneNode[];
+    renderPasses: SceneRenderPass[];
+    cameras: CameraOptions[];
+    shaders: string[];
+}
+export interface ParsedScene {
+    texture: Texture[];
+    geometries: Geometry[];
+    materials: Material[];
+    meshes: Mesh[];
+    renderPasses: RenderPass[];
+    cameras: Camera[];
+}
+export {};