@predy-js/render-interface 0.1.25-beta.20 → 0.1.25-beta.22

package/dist/statistic.js

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

package/dist/types/Geometry.d.ts

@@ -67,12 +67,8 @@ export interface GeometryOptions {
     mode?: GeometryDrawMode;
     drawCount?: number;
     drawStart?: number;
-    TransformFeedbackTarget?: TransformFeedbackTarget;
     bufferUsage?: GLenum;
 }
-type TransformFeedbackTarget = {
-    [key: string]: number;
-};
 export declare class Geometry implements IGPUResource {
     readonly renderer?: IGPURenderer;
     /**
@@ -106,7 +102,6 @@ export declare class Geometry implements IGPUResource {
        * 获取Attribute的数据内存长度
        * 如果此Attribute设置了其他dataSource则返回 0
        * 无论是否设置了attribute releasable，此函数总是返回实际数据长度
-       * //todo liyaohui.lyh@antgroup.com
        * @param name
        */
     getAttributeDataLength(name: string): number;
@@ -140,4 +135,3 @@ export declare class SharedGeometry extends Geometry {
        */
     constructor(options: SharedGeometryOptions, renderer?: IGPURenderer);
 }
-export {};

package/dist/types/Material.d.ts

@@ -45,8 +45,7 @@ export interface MaterialRenderStates {
     polygonOffsetFill?: boolean;
 }
 export declare const enum MaterialRenderType {
-    normal = 0,
-    transformFeedback = 1
+    normal = 0
 }
 export interface MaterialOptions {
     states: MaterialRenderStates;
@@ -56,14 +55,9 @@ export interface MaterialOptions {
     uniformSemantics?: {
         [key: string]: UniformSemantic;
     };
-    renderType?: MaterialRenderType;
     uniformValues?: {
         [key: string]: UniformValue;
     };
-    transformFeedbackOutput?: {
-        mode: WebGL2RenderingContext['INTERLEAVED_ATTRIBS'] | WebGL2RenderingContext['SEPARATE_ATTRIBS'];
-        varyings: string[];
-    };
 }
 /**
  * @example
@@ -108,7 +102,6 @@ export declare class Material implements IGPUResource {
     readonly options: Immutable<MaterialOptions>;
     readonly shaderCacheId: string;
     readonly states: Immutable<MaterialRenderStates>;
-    readonly renderType: MaterialRenderType;
     readonly isDestroyed: boolean;
     constructor(options: MaterialOptions);
     addDataBlock(b: MaterialDataBlock): void;

package/dist/types/RenderPass.d.ts

@@ -48,7 +48,7 @@ export interface RenderPassColorAttachmentOptions {
     storage?: RenderPassStorageObject;
 }
 export interface RenderPassColorAttachment {
-    readonly storageType: RenderPassAttachmentStorageType;
+    readonly storageType: RenderPassAttachmentStorageType.color;
     readonly texture: Texture;
     readonly isDestroyed: boolean;
 }
@@ -86,7 +86,6 @@ export type SemanticGetter = UniformValue | SemanticFunc | GPUBuffer;
 export interface RenderPassOptions extends RenderPassAttachmentOptions {
     name?: string;
     meshes?: Mesh[];
-    camera?: Camera;
     priority?: number;
     meshOrder?: RenderPassMeshOrder;
     clearAction?: RenderPassClearAction;

package/dist/types/ShaderLibrary.d.ts

@@ -1,21 +1,24 @@
 export type Shader = ShaderWithSource | ShaderUseCacheId;
 export type ShaderWithSource = InstancedShaderWithSource | SharedShaderWithSource;
-export interface InstancedShaderWithSource {
-    fragment: string;
-    vertex: string;
-    name?: string;
-    marcos?: ShaderMarcos;
-    shared?: false;
-    downgrade?: boolean;
+export interface MetaShaderSpec {
+    mtlSource?: string;
+    mtlVertex?: string;
+    mtlFragment?: string;
+    mtlBinary?: ArrayBuffer;
 }
-export interface SharedShaderWithSource {
+export interface ShaderSourceBase extends MetaShaderSpec {
     fragment: string;
     vertex: string;
     name?: string;
     downgrade?: boolean;
     marcos?: ShaderMarcos;
+}
+export interface InstancedShaderWithSource extends ShaderSourceBase {
+    shared?: false;
+}
+export interface SharedShaderWithSource extends ShaderSourceBase {
     cacheId?: string;
-    shared?: true;
+    shared: true;
 }
 export interface ShaderUseCacheId {
     cacheId: string;
@@ -50,19 +53,19 @@ export interface ShaderLibrary {
     };
     addShader(shader: Shader): string;
     /**
-     * @param cacheId
-     */
+       * @param cacheId
+       */
     deleteShader(cacheId: string): void;
     /**
-     * 编译shader
-     * @param shaderCacheId
-     * @param asyncCallback 如果传入，则会启用异步编译，当所有编译完成后被回调
-     */
+       * 编译shader
+       * @param shaderCacheId
+       * @param asyncCallback 如果传入，则会启用异步编译，当所有编译完成后被回调
+       */
     compileShader(shaderCacheId: string, asyncCallback?: (result: ShaderCompileResult) => void): ShaderCompileResult;
     /***
-     * 编译现有的所有shader
-     * @param asyncCallback 如果传入，则会启用异步编译，当所有编译完成后被回调
-     */
+       * 编译现有的所有shader
+       * @param asyncCallback 如果传入，则会启用异步编译，当所有编译完成后被回调
+       */
     compileAllShaders(asyncCallback?: (results: ShaderCompileResult[]) => void): void;
     destroy(): void;
 }

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

@@ -0,0 +1,18 @@
+import type { ResourceInternal, ResourcePlatform } from './ResourceInternal';
+import type { TypedArray } from '../type';
+import type { TextureInternal } from './TextureInternal';
+export type UniformValueInternal = TypedArray | number | number[];
+export interface DataBlockInternalOptions {
+    name: string;
+}
+export declare abstract class DataBlockInternal implements ResourceInternal {
+    readonly isDestroyed: boolean;
+    readonly platform: ResourcePlatform;
+    readonly name: string;
+    protected constructor(options: DataBlockInternalOptions);
+    abstract destroy(): void;
+    abstract setUniformValue(name: string, value: UniformValueInternal): void;
+    abstract setUniformTexture(name: string, value: TextureInternal): void;
+    abstract getUniformValue(name: string): UniformValueInternal | void;
+    abstract getUniformTexture(name: string): TextureInternal;
+}

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

@@ -0,0 +1,37 @@
+import type { ResourceInternal, ResourcePlatform } from './ResourceInternal';
+import type { TypedArray } from '../type';
+export declare const GPUBufferOptionsMemoryShared: number;
+export interface GPUBufferInternalOptions {
+    data?: TypedArray;
+    options?: typeof GPUBufferOptionsMemoryShared;
+}
+/**
+ * 内存写入GPU的具体时机由框架自行决定，只要保证在渲染前输入GPU即可
+ */
+export declare abstract class GPUBufferInternal implements ResourceInternal {
+    readonly isDestroyed: boolean;
+    readonly platform: ResourcePlatform;
+    readonly byteLength: number;
+    protected constructor(options: GPUBufferInternalOptions);
+    abstract destroy(): void;
+    /**
+       * 整段替换数据，替换后byteLength会发生改变
+       * 内存写入GPU的具体时机由框架自行决定，只要保证在渲染前输入GPU即可
+       * 数据输入GPU后，可以丢弃内存端的数据
+       * @param typedArray
+       */
+    abstract bufferData(typedArray: TypedArray): void;
+    /**
+       * 部分替换数据，如果offset+data的长度大于目前的byteLength，需要重新申请新的内存，整段替换
+       * @param byteOffset 指针的offset，无类型区分
+       * @param data
+       */
+    abstract bufferSubData(byteOffset: number, data: TypedArray): void;
+    /**
+       * 读取GPU数据，当创建参数有 GPUBufferOptionsMemoryShared 时，必须能读取到数据
+       * 当框架没有读取到数据时，返回false
+       * @param typedArray 将数据写入的arrayBuffer
+       * @param offset 写入的指针偏移
+       */
+    abstract readSubData(typedArray: TypedArray, offset?: number): boolean;
+}

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

@@ -0,0 +1,30 @@
+import type { AttributeWithType, GeometryOptions } from '../Geometry';
+import type { ResourceInternal, ResourcePlatform } from './ResourceInternal';
+import type { AttributeBase } from '../Geometry';
+import type { GPUBufferInternal } from './GPUBufferInternal';
+interface AttributeWithBuffer extends AttributeBase {
+    buffer: GPUBufferInternal;
+}
+export interface GeometryInternalOptions extends Omit<GeometryOptions, 'attributes'> {
+    attributes: {
+        attr: AttributeWithBuffer | AttributeWithType;
+        name: string;
+    }[];
+}
+export type IndexBufferType = WebGLRenderingContext['UNSIGNED_SHORT'] | WebGLRenderingContext['UNSIGNED_INT'];
+/**
+ * geometry中的数据都以buffer形式保存
+ */
+export declare abstract class GeometryInternal implements ResourceInternal {
+    readonly isDestroyed: boolean;
+    readonly platform: ResourcePlatform;
+    drawStart: number;
+    drawCount: number;
+    mode: GLenum;
+    protected constructor(options: GeometryInternalOptions);
+    abstract setAttributeBuffer(name: string, buffer: GPUBufferInternal | undefined): void;
+    abstract getAttributeBuffer(name: string): GPUBufferInternal | undefined;
+    abstract setIndexBuffer(buffer: GPUBufferInternal | undefined, bufferType: IndexBufferType): void;
+    abstract destroy(): void;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import type { ResourceInternal, ResourcePlatform } from './ResourceInternal';
+import type { MaterialRenderStates } from '../Material';
+import type { DataBlockInternal } from './DataBlockInternal';
+export interface MaterialInternalOptions {
+    states: MaterialRenderStates;
+    shaderCacheId: string;
+    dataBlocks: DataBlockInternal[];
+    name?: string;
+}
+export declare abstract class MaterialInternal implements ResourceInternal {
+    readonly isDestroyed: boolean;
+    readonly platform: ResourcePlatform;
+    readonly name: string;
+    dataBlocks: DataBlockInternal[];
+    protected constructor(options: MaterialInternalOptions);
+    abstract destroy(): void;
+}

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

@@ -0,0 +1,20 @@
+import type { ResourceInternal, ResourcePlatform } from './ResourceInternal';
+import type { GeometryInternal } from './GeometryInternal';
+import type { MaterialInternal } from './MaterialInternal';
+export interface MeshInternalOptions {
+    name?: string;
+    geometries: GeometryInternal[];
+    material: MaterialInternal;
+    priority?: number;
+}
+export declare abstract class MeshInternal implements ResourceInternal {
+    readonly isDestroyed: boolean;
+    readonly platform: ResourcePlatform;
+    readonly name: string;
+    geometries: GeometryInternal[];
+    material: MaterialInternal;
+    priority: number;
+    hide: boolean;
+    protected constructor(options: MeshInternalOptions);
+    abstract destroy(): void;
+}

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

@@ -0,0 +1,26 @@
+import type { ResourceInternal, ResourcePlatform } from './ResourceInternal';
+import type { RenderPassInternal } from './RenderPassInternal';
+import type { RenderPassClearAction } from '../RenderPass';
+export interface RenderFrameInternalOptions {
+    renderPasses: RenderPassInternal[];
+    clearAction: RenderPassClearAction;
+    name: string;
+}
+export declare abstract class RenderFrameInternal implements ResourceInternal {
+    readonly isDestroyed: boolean;
+    readonly platform: ResourcePlatform;
+    readonly clearAction: RenderPassClearAction;
+    readonly name: string;
+    /**
+     * 增删改查的操作，在warp层对renderPassInternals进行后，得到的数据全部覆盖当前数据
+     */
+    renderPasses: RenderPassInternal[];
+    protected constructor(options: RenderFrameInternalOptions);
+    abstract destroy(): void;
+    /**
+     * warp层完成所有数据传输后，通知客户端，可以进行实际渲染，
+     * 实际渲染根据客户端时机进行
+     */
+    abstract flush(): void;
+    abstract updateClearAction(action: RenderPassClearAction): void;
+}

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

@@ -0,0 +1,56 @@
+import type { ResourceInternal, ResourcePlatform } from './ResourceInternal';
+import type { MeshInternal } from './MeshInternal';
+import type { RenderPassClearAction, RenderPassStoreAction } from '../RenderPass';
+import type { TextureInternal } from './TextureInternal';
+import type { RenderPassStorageObject } from '../RenderPass';
+import type { RenderPassAttachmentStorageType } from '../RenderPass';
+import type { Mesh } from '../Mesh';
+export interface RenderPassColorAttachmentInternal {
+    readonly storageType: RenderPassAttachmentStorageType.color;
+    readonly texture: TextureInternal;
+}
+export interface RenderPassDepthStencilAttachmentInternal {
+    readonly storageType: RenderPassAttachmentStorageType;
+    readonly texture?: TextureInternal;
+    readonly storage?: RenderPassStorageObjectInternal;
+}
+/**
+ * 在Metal里面，所有的RenderPassAttachment都以Texture存储
+ * 在GL中，可以使用RenderTarget/Texture作为fbo的attachment
+ */
+export interface RenderPassStorageObjectInternal extends RenderPassStorageObject {
+    _mtlTexture?: TextureInternal;
+    _glRenderBuffer?: WebGLRenderbuffer;
+}
+export interface RenderPassDepthStencilAttachmentOptionsInternal {
+    storageType: RenderPassAttachmentStorageType;
+    texture?: TextureInternal;
+    storage?: RenderPassStorageObjectInternal;
+}
+export interface RenderPassOptionsInternal {
+    clearAction: RenderPassClearAction;
+    storeAction: RenderPassStoreAction;
+    attachments: RenderPassColorAttachmentInternal[];
+    depthStencilAttachment: RenderPassDepthStencilAttachmentOptionsInternal;
+    name: string;
+    meshes: Mesh[];
+    multiSample: number;
+    viewport?: [x: number, y: number, width: number, height: number];
+}
+export declare abstract class RenderPassInternal implements ResourceInternal {
+    readonly isDestroyed: boolean;
+    readonly platform: ResourcePlatform;
+    readonly name: string;
+    readonly storeAction: RenderPassStoreAction;
+    readonly clearAction: RenderPassClearAction;
+    readonly multisample: number;
+    readonly depthStencilAttachment: RenderPassDepthStencilAttachmentInternal;
+    readonly attachments: RenderPassColorAttachmentInternal[];
+    /**
+     * 增删改查的操作，在warp层对Mesh进行后，得到的数据全部覆盖当前数据
+     */
+    meshes: MeshInternal[];
+    priority: number;
+    protected constructor(options: RenderPassOptionsInternal);
+    abstract destroy(): void;
+}

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

@@ -0,0 +1,32 @@
+import type { ResourceInternal, ResourcePlatform } from './ResourceInternal';
+import type { GPUBufferInternal, GPUBufferInternalOptions } from './GPUBufferInternal';
+import type { GeometryInternal, GeometryInternalOptions } from './GeometryInternal';
+import type { ShaderLibraryInternal } from './ShaderLibraryInternal';
+import type { DataBlockInternal, DataBlockInternalOptions } from './DataBlockInternal';
+import type { MaterialInternal, MaterialInternalOptions } from './MaterialInternal';
+import type { MeshInternal, MeshInternalOptions } from './MeshInternal';
+import type { RenderPassInternal, RenderPassOptionsInternal } from './RenderPassInternal';
+import type { RenderFrameInternal, RenderFrameInternalOptions } from './RenderFrameInternal';
+import type { GPUCapability } from '../GPUCapability';
+/**
+ * renderer 内部创建的对象，用来统计信息，排查资源泄漏的问题
+ */
+export interface InternalResInfo {
+    buffer: number;
+    geometry: number;
+}
+export declare abstract class RendererInternal implements ResourceInternal {
+    readonly isDestroyed: boolean;
+    readonly platform: ResourcePlatform;
+    readonly gpu: GPUCapability;
+    readonly shaderLibrary: ShaderLibraryInternal;
+    abstract destroy(): void;
+    abstract createBuffer(options: GPUBufferInternalOptions): GPUBufferInternal;
+    abstract createGeometry(options: GeometryInternalOptions): GeometryInternal;
+    abstract createDataBlock(options: DataBlockInternalOptions): DataBlockInternal;
+    abstract createMaterial(options: MaterialInternalOptions): MaterialInternal;
+    abstract createMesh(options: MeshInternalOptions): MeshInternal;
+    abstract createRenderPass(options: RenderPassOptionsInternal): RenderPassInternal;
+    abstract createRenderFrame(options: RenderFrameInternalOptions): RenderFrameInternal;
+    abstract getResourceInfo(): InternalResInfo;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * 客户端创建对象，iOS和android
+ */
+export declare enum ResourcePlatform {
+    iOS = 1,
+    android = 2
+}
+export interface ResourceInternal {
+    readonly platform: ResourcePlatform;
+    readonly isDestroyed: boolean;
+    destroy(): void;
+}

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

@@ -0,0 +1,11 @@
+import type { ShaderLibrary, Shader, ShaderCompileResult } from '../ShaderLibrary';
+export declare abstract class ShaderLibraryInternal implements ShaderLibrary {
+    readonly shaderResults: {
+        [p: string]: ShaderCompileResult;
+    };
+    abstract addShader(shader: Shader): string;
+    abstract compileAllShaders(asyncCallback?: (results: ShaderCompileResult[]) => void): void;
+    abstract compileShader(shaderCacheId: string, asyncCallback?: (result: ShaderCompileResult) => void): ShaderCompileResult;
+    abstract deleteShader(cacheId: string): void;
+    abstract destroy(): void;
+}

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

@@ -0,0 +1,25 @@
+import type { TextureFormatOptions, TextureConfigOptionsBase } from '../Texture';
+import type { ResourceInternal, ResourcePlatform } from './ResourceInternal';
+export interface TextureImageLike {
+    data: Uint8Array;
+    width: number;
+    height: number;
+}
+export interface TextureInternalOptions extends TextureFormatOptions, Omit<TextureConfigOptionsBase, 'keepImageSource'> {
+    target: WebGLRenderingContext['TEXTURE_CUBE_MAP'] | WebGLRenderingContext['TEXTURE_2D'];
+    image?: TextureImageLike;
+    cube?: TextureImageLike[];
+}
+export declare abstract class TextureInternal implements ResourceInternal {
+    readonly isDestroyed: boolean;
+    readonly platform: ResourcePlatform;
+    readonly width: number;
+    readonly height: number;
+    readonly name: string;
+    readonly options: Omit<TextureInternalOptions, 'cube' | 'image'>;
+    protected constructor(options: TextureInternalOptions);
+    abstract reset(options: TextureInternalOptions): void;
+    abstract destroy(): void;
+    abstract update2DData(image: TextureImageLike): void;
+    abstract updateCubeData(face: GLenum, image: TextureImageLike): void;
+}

package/package.json

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