@predy-js/render-interface 0.1.61-beta.2 → 0.1.61-beta.22

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

@@ -26,7 +26,7 @@ export declare class MarsGeometry implements Geometry {
     _dirtyFlags: {
         [key: string]: BufferDirtyFlag;
     };
-    _index?: Uint8Array | Uint16Array | Uint32Array;
+    _index?: Uint16Array | Uint32Array;
     _indexReleasable: boolean;
     readonly internal: GLGeometry;
     readonly options?: GeometryOptions;
@@ -35,6 +35,7 @@ export declare class MarsGeometry implements Geometry {
     protected _drawStart: number;
     protected _mode: number;
     protected _isDestroyed: boolean;
+    indexDataType: number;
     get isDestroyed(): boolean;
     get mode(): number;
     set mode(n: number);
@@ -52,8 +53,8 @@ export declare class MarsGeometry implements Geometry {
     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;
+    getIndexData(): Uint16Array | Uint32Array | undefined;
+    setIndexData(data: Uint16Array | Uint32Array | undefined): void;
     setIndexSubData(offset: number, data: TypedArray): void;
     getAttributeStride(name: string): number;
     getAttributeDataLength(name: string): number;

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

@@ -1,5 +1,4 @@
 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';
@@ -14,16 +13,16 @@ export declare class MarsMaterial implements Material {
     readonly renderType: MaterialRenderType;
     readonly states: Immutable<MaterialRenderStates>;
     readonly renderer?: MarsRenderer;
+    private _dbMap;
     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;
+    getDataBlockByName(name: string): MarsMaterialDataBlock;
     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

@@ -1,24 +1,32 @@
-import type { MaterialDataBlock, MaterialDataBlockDestroyOptions, MaterialDataBlockOptions, UniformValue, vec2 } from '../../types';
+import type { MaterialDataBlock, MaterialDataBlockDestroyOptions, MaterialDataBlockOptions, UniformSemantic, UniformValue, vec2, Texture } from '../../types';
 import type { MarsRenderer } from './MarsRenderer';
+import { MarsTexture } from './MarsTexture';
 import type { UniformBlockSpec } from '../webgl/GLUniformUtils';
 import { UniformBlockBuffer } from '../webgl/GLUniformUtils';
 export declare class MarsMaterialDataBlock implements MaterialDataBlock {
     readonly _uniformValues: Record<string, UniformValue>;
+    readonly _uniformTextures: Record<string, MarsTexture | MarsTexture[]>;
     readonly _uniformFlags: Record<string, boolean>;
     readonly _uniformValueRanges: Record<string, vec2>;
     readonly name: string;
+    readonly uniformSemantics: {
+        [key: string]: UniformSemantic;
+    };
     readonly renderer?: MarsRenderer;
     readonly uboBufferMap: Record<string, UniformBlockBuffer>;
     protected _isDestroyed: boolean;
+    private _uniformPrivate;
     private readonly _keepUboData;
     constructor(props: MaterialDataBlockOptions & {
         keepUboData?: boolean;
     }, renderer?: MarsRenderer);
-    _assignUniformValueRenderer(value: UniformValue, renderer?: MarsRenderer): void;
+    _assignUniformValueRenderer(value: MarsTexture | MarsTexture[], renderer?: MarsRenderer): void;
     invalidAllFlags(): void;
     clearFlags(): void;
     isDirty(shaderCacheId: string, name: string): boolean;
     get isDestroyed(): boolean;
+    setUniformTexture(uniformName: string, texture: MarsTexture | MarsTexture[] | undefined): void;
+    getUniformTexture<T extends (Texture | Texture[]) = MarsTexture>(uniformName: string): T | undefined;
     assignRenderer(renderer: MarsRenderer): MaterialDataBlock;
     createUboBuffer(spec: UniformBlockSpec): UniformBlockBuffer | undefined;
     setUboBuffer(uboBuffer: UniformBlockBuffer): void;
@@ -29,9 +37,10 @@ export declare class MarsMaterialDataBlock implements MaterialDataBlock {
     getUniformValues(): {
         [p: string]: UniformValue;
     };
-    setUniformValue(name: string, value: UniformValue | undefined): boolean;
+    setUniformValue(name: string, value: UniformValue | undefined, isSemantic?: boolean): boolean;
     setUniformValues(map: {
         [p: string]: UniformValue;
     }): void;
+    setUniformSemantic(name: string, semantic: string | undefined): void;
     clone(name: string): MarsMaterialDataBlock;
 }

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

@@ -17,4 +17,7 @@ export declare class MarsRenderer implements GPURenderer {
     createRenderFrame(options?: RenderFrameOptions): MarsRenderFrame;
     destroy(haltGL?: boolean): void;
     resize(width: number, height: number): void;
+    cancelAnimationFrame(id: number): void;
+    getErrors(): string[];
+    requestAnimationFrame(cb: FrameRequestCallback): number;
 }

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

@@ -3,18 +3,15 @@ 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;
+    readonly target: GPUBufferTarget;
     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);
@@ -23,5 +20,6 @@ export declare class GLGPUBuffer implements GPUBuffer {
     bufferSubData(elementOffset: number, typedArray: TypedArray): void;
     destroy(): void;
     readSubData(elementOffset: number, typedArray: TypedArray): boolean;
+    getElementCount(bytePerElement: number): number;
     assignRenderer(renderer: MarsRenderer): GLGPUBuffer;
 }

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

@@ -26,6 +26,8 @@ export declare class GLGPURenderer implements GPURenderer {
     private _isDestroyed;
     extension: RendererExtensions;
     constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
+    requestAnimationFrame(cb: FrameRequestCallback): number;
+    cancelAnimationFrame(id: number): void;
     get isDestroyed(): boolean;
     onContextLose: (e: Event) => void;
     copy2(source: GLTexture, target: GLTexture): void;

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

@@ -7,6 +7,9 @@ import type { GLVertexArrayObject } from './GLVertexArrayObject';
 export declare const INDEX_TYPE_MAP: {
     [x: number]: number;
 };
+export declare const TYPE_BYTE_MAP: {
+    [x: number]: number;
+};
 export type GLGeometryOptions = {
     drawStart: number;
     drawCount: number;
@@ -31,6 +34,7 @@ export declare class GLGeometry {
     drawStart: number;
     drawCount: number;
     mode: GLenum;
+    indexBufferType: GLenum;
     attributes: {
         [key: string]: AttributeWithType;
     };
@@ -42,8 +46,8 @@ export declare class GLGeometry {
     constructor(option: GLGeometryOptions | GLGeometry, renderer: GLGPURenderer);
     createVao(name: string): GLVertexArrayObject;
     destroyVao(name: string): void;
-    setIndexBuffer(buffer: GLGPUBuffer): void;
-    createIndexBuffer(data: Uint16Array | Uint32Array | Uint8Array, renderer: GLGPURenderer): GLGPUBuffer;
+    setIndexBuffer(buffer: GLGPUBuffer, indexBufferType: GLenum): void;
+    createIndexBuffer(data: Uint16Array | Uint32Array | Uint8Array, renderer: GLGPURenderer): [buffer: GLGPUBuffer, type: GLenum];
     getGPUBuffer(name: string | number): GLGPUBuffer | null;
     destroy(): void;
     setAttributeBuffer(name: string, buffer: GPUBuffer): void;

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

@@ -3,6 +3,7 @@ import type { GLGeometry } from './GLGeometry';
 import type { RenderState } from '../../types/RenderFrame';
 import type { GLVertexArrayObject } from './GLVertexArrayObject';
 import type { UniformBlockSpec } from './GLUniformUtils';
+import type { UniformValue } from '../../types';
 export interface ProgramAttributeInfo {
     readonly name: string;
     readonly size: number;
@@ -35,6 +36,7 @@ export declare class GLProgram {
     constructor(renderer: GLGPURenderer, program: WebGLProgram, shared: boolean, id: string);
     init(renderer: GLGPURenderer, program: WebGLProgram): void;
     bind(): void;
+    getSemanticValue(state: RenderState, semanticName: string): UniformValue | import("../../types").GPUBuffer | null | undefined;
     setupUniforms(state: RenderState): void;
     setGLUniformValue(name: string, value: any, info: ProgramUniformInfo, gl: WebGL2RenderingContext | WebGLRenderingContext): void;
     setupAttributes(geometry: GLGeometry): GLVertexArrayObject;

package/dist/statistic.js

@@ -2,7 +2,7 @@
  * Name: @predy-js/render-interface
  * Description: undefined
  * Author: undefined
- * Version: v0.1.61-beta.2
+ * Version: v0.1.61-beta.22
  */
 
 // https://github.com/greggman/webgl-memory/blob/main/src/texture-utils.js

package/dist/types/GPUBuffer.d.ts

@@ -1,17 +1,22 @@
 import type { TypedArray } from './type';
 import type { IGPUResource, IGPURenderer } from './IGPURenderer';
 import type { GPURenderer } from './Renderer';
+export declare const GPUBufferOptionsMemoryShared: number;
 export type GPUBufferTarget = WebGLRenderingContext['ARRAY_BUFFER'] | WebGLRenderingContext['ELEMENT_ARRAY_BUFFER'] | WebGL2RenderingContext['COPY_READ_BUFFER'] | WebGL2RenderingContext['COPY_WRITE_BUFFER'] | WebGL2RenderingContext['TRANSFORM_FEEDBACK_BUFFER'] | WebGL2RenderingContext['UNIFORM_BUFFER'] | WebGL2RenderingContext['PIXEL_PACK_BUFFER'] | WebGL2RenderingContext['PIXEL_UNPACK_BUFFER'];
-type GPUBufferType = WebGLRenderingContext['FLOAT'] | WebGLRenderingContext['INT'] | WebGLRenderingContext['SHORT'];
 export interface GPUBufferOptions {
     name?: string;
-    target?: GPUBufferTarget;
-    type?: GPUBufferType;
     /**
-     * 数据元素的总量
+     * 数据长度，如果提供了data，忽略此参数
      */
-    elementCount?: number;
+    byteLength?: number;
     data?: TypedArray;
+    /**
+     * GL需要设置，Vulkan和Metal此属性忽略
+     */
+    target?: GPUBufferTarget;
+    /**
+     * GL需要设置，Vulkan和Metal此属性忽略
+     */
     usage?: WebGLRenderingContext['STATIC_DRAW'] | WebGLRenderingContext['DYNAMIC_DRAW'];
 }
 /**
@@ -23,16 +28,11 @@ export declare class GPUBuffer implements IGPUResource {
     readonly renderer?: IGPURenderer;
     readonly isDestroyed: boolean;
     readonly level: number;
-    readonly target: GPUBufferTarget;
-    readonly type: GPUBufferOptions['type'];
     readonly byteLength: number;
-    readonly bytesPerElement: number;
-    destroy(): void;
+    readonly target: GPUBufferTarget;
+    readonly usage?: WebGLRenderingContext['STATIC_DRAW'] | WebGLRenderingContext['DYNAMIC_DRAW'];
     constructor(options: GPUBufferOptions, renderer?: IGPURenderer);
-    /**
-     * 数据元素的总量
-     */
-    readonly elementCount: number;
+    getElementCount(bytePerElement: number): number;
     /**
      * 根据TypedArray容量，重新分配Buffer内存
      * @param typedArray
@@ -52,5 +52,5 @@ export declare class GPUBuffer implements IGPUResource {
      */
     readSubData(elementOffset: number, typedArray: TypedArray, elementCount?: number): boolean;
     assignRenderer(renderer: GPURenderer): GPUBuffer;
+    destroy(): void;
 }
-export {};

package/dist/types/Geometry.d.ts

@@ -62,7 +62,7 @@ export interface GeometryOptions {
         [key: string]: Attribute;
     };
     index?: {
-        data: Uint8Array | Uint16Array | Uint32Array;
+        data: GeometryIndexData;
         releasable?: boolean;
     };
     mode?: GeometryDrawMode;
@@ -70,6 +70,10 @@ export interface GeometryOptions {
     drawStart?: number;
     bufferUsage?: GLenum;
 }
+/**
+ * 不兼容Uint8的Index，只能使用Uin16和Uin32
+ */
+export type GeometryIndexData = Uint16Array | Uint32Array;
 export declare class Geometry implements IGPUResource {
     readonly renderer?: IGPURenderer;
     /**
@@ -80,6 +84,7 @@ export declare class Geometry implements IGPUResource {
     }>;
     readonly isDestroyed: boolean;
     readonly options?: Immutable<GeometryOptions>;
+    indexDataType?: WebGLRenderingContext['UNSIGNED_INT'] | WebGLRenderingContext['UNSIGNED_SHORT'];
     drawStart: number;
     drawCount: number;
     mode: number;
@@ -96,8 +101,8 @@ export declare class Geometry implements IGPUResource {
     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;
+    getIndexData(): GeometryIndexData | undefined;
+    setIndexData(data: GeometryIndexData | undefined): void;
     setIndexSubData(offset: number, data: TypedArray): void;
     /**
        * 获取Attribute的数据内存长度
@@ -119,7 +124,7 @@ export interface SharedGeometryOptions {
     drawCount?: number;
     mode?: number;
     index?: {
-        data: Uint8Array | Uint16Array | Uint32Array;
+        data: GeometryIndexData;
         releasable?: boolean;
     };
     geometry: Geometry;

package/dist/types/Material.d.ts

@@ -1,9 +1,9 @@
-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';
+import type { Texture } from './Texture';
 export type UniformSemantic = 'VIEW' | 'MODEL' | 'MODELVIEW' | 'PROJECTION' | 'VIEWPROJECTION' | 'MODELVIEWPROJECTION' | string;
 export interface MaterialRenderStates {
     sampleAlphaToCoverage?: boolean;
@@ -15,13 +15,13 @@ export interface MaterialRenderStates {
     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.
-     */
+       * 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;
@@ -52,12 +52,6 @@ export interface MaterialOptions {
     shader: ShaderWithSource | ShaderUseCacheId;
     name?: string;
     dataBlocks?: MaterialDataBlockOptions[];
-    uniformSemantics?: {
-        [key: string]: UniformSemantic;
-    };
-    uniformValues?: {
-        [key: string]: UniformValue;
-    };
 }
 /**
  * @example
@@ -85,7 +79,7 @@ export interface MaterialOptions {
  * });
  * mtl2 use the same program with mtl0
  */
-export type UniformValueDataType = TypedArray | number | number[] | Texture | Texture[] | number[][];
+export type UniformValueDataType = TypedArray | number | number[] | number[][];
 export type UniformValue = UniformValueDataType | UniformStruct | UniformStruct[];
 export type UniformStruct = {
     [key: string]: UniformValueDataType;
@@ -107,14 +101,17 @@ export declare class Material implements IGPUResource {
     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;
     };
+    uniformTextures?: Record<string, Texture | Texture[]>;
     name?: string;
+    uniformSemantics?: {
+        [key: string]: UniformSemantic;
+    };
 }
 export interface MaterialDataBlockDestroyOptions {
     textures?: DestroyOptions;
@@ -123,8 +120,12 @@ export declare class MaterialDataBlock implements IGPUResource {
     readonly renderer?: IGPURenderer;
     readonly isDestroyed: boolean;
     readonly name: string;
+    readonly uniformSemantics?: {
+        [key: string]: UniformSemantic;
+    };
     constructor(options: MaterialDataBlockOptions);
     hasUniformValue(name: string): boolean;
+    setUniformSemantic(name: string, semantic: string | undefined): void;
     setUniformValue(name: string, value: UniformValue): boolean;
     getUniformValue(name: string): UniformValue;
     getUniformValues(): {
@@ -133,15 +134,17 @@ export declare class MaterialDataBlock implements IGPUResource {
     setUniformValues(map: {
         [key: string]: UniformValue;
     }): void;
+    setUniformTexture(uniformName: string, texture: Texture | Texture[] | undefined): void;
+    getUniformTexture<T extends Texture[] | Texture = Texture>(uniformName: string): T | undefined;
     /**
-     * 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
-     */
+       * 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;

package/dist/types/RenderFrame.d.ts

@@ -1,7 +1,5 @@
-import type { UniformValue } from './Material';
-import type { RenderPass, RenderPassLoadAction, RenderPassDestroyOptions, SemanticMap } from './RenderPass';
+import type { RenderPass, RenderPassLoadAction, RenderPassDestroyOptions, SemanticMap, SemanticGetter } from './RenderPass';
 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';
@@ -16,12 +14,12 @@ export interface RenderFrameOptions {
     renderPasses?: RenderPass[];
     viewport?: vec4;
     semantics?: {
-        [key: string]: UniformValue | SemanticFunc | GPUBuffer;
+        [key: string]: SemanticGetter;
     };
     loadAction?: RenderPassLoadAction;
     name?: string;
 }
-export type SemanticFunc = (state: RenderState) => UniformValue | GPUBuffer | null | undefined;
+export type SemanticFunc = (state: RenderState) => SemanticGetter | null | undefined;
 export type RenderFrameDestroyOptions = {
     passes?: RenderPassDestroyOptions | DestroyOptions.keep;
     semantics?: DestroyOptions;

package/dist/types/RenderPass.d.ts

@@ -81,7 +81,7 @@ export interface RenderPassAttachmentOptions {
     viewportScale?: number;
     multiSample?: number;
 }
-export type SemanticGetter = UniformValue | SemanticFunc | GPUBuffer;
+export type SemanticGetter = UniformValue | SemanticFunc | GPUBuffer | Texture | Texture[];
 export interface RenderPassOptions extends RenderPassAttachmentOptions {
     name?: string;
     meshes?: Mesh[];
@@ -119,7 +119,7 @@ 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;
+    didRenderMesh?: (mesh: Mesh, state: RenderState) => void;
 }
 export declare class RenderPass implements IGPUResource {
     readonly isDestroyed: boolean;

package/dist/types/Renderer.d.ts

@@ -24,8 +24,8 @@ export declare class GPURenderer implements IGPURenderer {
     readonly height: number;
     readonly width: number;
     /**
-     * if webgl not support, gpu.level will be 0
-     */
+       * if webgl not support, gpu.level will be 0
+       */
     readonly shaderLibrary: ShaderLibrary;
     readonly gpu: GPUCapability;
     readonly canvas: Canvas;
@@ -35,17 +35,26 @@ export declare class GPURenderer implements IGPURenderer {
     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
-     */
+       * 根据不同平台封装实现 requestAnimationFrame，
+       * FrameRequestCallback函数回调中进行渲染数据更新，
+       * OpenGL/WebGL在绘制开始之前(传递此帧数据）
+       * Metal在commandBuffer提交后（传递下一帧数据）
+       * @param cb
+       */
+    requestAnimationFrame(cb: FrameRequestCallback): number;
+    cancelAnimationFrame(id: number): void;
+    /**
+       * 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 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/ShaderLibrary.d.ts

@@ -1,7 +1,7 @@
 export type Shader = ShaderWithSource | ShaderUseCacheId;
 export type ShaderWithSource = InstancedShaderWithSource | SharedShaderWithSource;
 export interface MetaShaderSpec {
-    mtlBinary?: ArrayBuffer;
+    mtlBinary?: ArrayBuffer | string;
     mtlSource?: string;
     mtlVertex?: string;
     mtlFragment?: string;
@@ -51,9 +51,9 @@ export interface ShaderLibrary {
     readonly cacheIds: string[];
     getShaderResult(cacheId: string): ShaderCompileResult | undefined;
     /**
-     * 添加shader
-     * @param shader
-     */
+       * 添加shader
+       * @param shader
+       */
     addShader(shader: Shader): string;
     /**
        * @param cacheId

package/dist/types/native/DataBlockInternal.d.ts

@@ -1,5 +1,6 @@
 import type { ResourceInternal } from './ResourceInternal';
 import type { TypedArray } from '../type';
+import type { TextureInternal } from './TextureInternal';
 export interface DataBlockInternalOptions {
     name: string;
 }
@@ -26,4 +27,6 @@ export declare abstract class DataBlockInternal implements ResourceInternal {
      * @param value
      */
     abstract getUniformValue(name: string, value: TypedArray): boolean;
+    abstract setUniformTextures(uniformName: string, texture: TextureInternal[] | undefined): void;
+    abstract getUniformTextures(uniformName: string): TextureInternal[] | undefined;
 }

package/dist/types/native/GPUBufferInternal.d.ts

@@ -1,6 +1,6 @@
 import type { ResourceInternal } from './ResourceInternal';
 import type { TypedArray } from '../type';
-export declare const GPUBufferOptionsMemoryShared: number;
+import type { GPUBufferOptionsMemoryShared } from '../GPUBuffer';
 export interface GPUBufferInternalOptions {
     data?: TypedArray;
     options?: typeof GPUBufferOptionsMemoryShared;

package/dist/types/native/ImageBitmapInternal.d.ts

@@ -1,6 +1,4 @@
 export interface ImageBitmapConstructor {
-    flipY?: boolean;
-    premultiplyAlpha?: boolean;
     resizeWidth?: number;
     resizeHeight?: number;
 }

package/dist/types/native/MaterialInternal.d.ts

@@ -1,7 +1,6 @@
 import type { ResourceInternal } from './ResourceInternal';
 import type { MaterialRenderStates } from '../Material';
 import type { DataBlockInternal } from './DataBlockInternal';
-import type { TextureInternal } from './TextureInternal';
 export interface MaterialInternalOptions {
     states: MaterialRenderStates;
     dataBlocks: DataBlockInternal[];
@@ -15,12 +14,4 @@ export declare abstract class MaterialInternal implements ResourceInternal {
     dataBlocks: DataBlockInternal[];
     protected constructor(options: MaterialInternalOptions);
     abstract destroy(): void;
-    /**
-     * 对于 uniform sampler2D uTex
-     * 和 uniform sampler2D uTextures[4] 都使用此函数
-     * @param name
-     * @param value
-     */
-    abstract setUniformTextures(name: string, value: TextureInternal[]): void;
-    abstract getUniformTextures(name: string): TextureInternal[];
 }

package/dist/types/native/RenderFrameInternal.d.ts

@@ -17,13 +17,9 @@ export declare abstract class RenderFrameInternal implements ResourceInternal {
     protected constructor(options: RenderFrameInternalOptions);
     abstract destroy(): void;
     /**
-     * warp层完成所有数据传输后，通知客户端，可以进行实际渲染，
-     * 实际渲染根据客户端时机进行,在调用end()之前，客户端会根据实际刷新进行绘制
+     * 代表此帧会在渲染队列的下一帧被渲染，调用此函数，也会调用renderer.invalid方法
+     * 由于渲染是异步的，此函数在Metal/Vulkan实现中，并不会直接绘制
      */
-    abstract begin(): void;
-    /**
-     * 将RenderFrame移除渲染队列
-     */
-    abstract end(): void;
+    abstract render(): void;
     abstract updateLoadAction(action: RenderPassLoadAction): void;
 }

package/dist/types/native/RendererInternal.d.ts

@@ -31,6 +31,10 @@ export declare abstract class RendererInternal implements ResourceInternal {
     readonly width: number;
     readonly height: number;
     abstract destroy(): void;
+    /**
+       * 需要进行重新渲染
+       */
+    abstract invalid(): void;
     abstract createBuffer(options: GPUBufferInternalOptions): GPUBufferInternal;
     abstract createGeometry(options: GeometryInternalOptions): GeometryInternal;
     abstract createDataBlock(options: DataBlockInternalOptions): DataBlockInternal;
@@ -42,6 +46,12 @@ export declare abstract class RendererInternal implements ResourceInternal {
     abstract getResourceInfo(): InternalResInfo;
     abstract requestAnimationFrame(callback: (timestamp: number) => void): number;
     abstract cancelAnimationFrame(id: number): void;
+    /**
+       * 获取错误信息，目前支持最大获取5条，
+       * 每次调用此函数后，清空错误队列
+       */
+    abstract getErrors(): string[];
+    abstract resize(width: number, height: number): void;
     abstract createImageBitmap(data: ArrayBuffer | string, //图片文件的数据
     options: ImageBitmapConstructor, callback: ImageBitmapCallback): void;
 }

package/dist/types/native/TextureInternal.d.ts

@@ -4,6 +4,7 @@ import type { TypedArray } from '../type';
 import type { ImageBitmapInternal } from './ImageBitmapInternal';
 export interface TextureInternalOptions extends TextureFormatOptions, Omit<TextureConfigOptionsBase, 'keepImageSource'> {
     target: WebGLRenderingContext['TEXTURE_CUBE_MAP'] | WebGLRenderingContext['TEXTURE_2D'];
+    generateMipmap?: boolean;
 }
 export interface TextureInternalConstructOptions extends TextureInternalOptions {
     width: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@predy-js/render-interface",
-  "version": "0.1.61-beta.2",
+  "version": "0.1.61-beta.22",
   "license": "MIT",
   "module": "./dist/index.mjs",
   "main": "./dist/index.js",