@predy-js/render-interface 0.1.61-beta.1 → 0.1.61-beta.3

package/dist/statistic.js

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

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 | string;
+    mtlBinary?: ArrayBuffer;
     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/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@predy-js/render-interface",
-  "version": "0.1.61-beta.1",
+  "version": "0.1.61-beta.3",
   "license": "MIT",
   "module": "./dist/index.mjs",
   "main": "./dist/index.js",
   "types": "./dist/types/index.d.ts",
   "files": [
-    "dist",
-    "types"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"

package/types/Canvas.ts

@@ -1,20 +0,0 @@
-export interface Canvas {
-  width: number,
-  height: number,
-
-  addEventListener(name: string, handler: Function): void,
-
-  removeEventListener(name: string, handler: Function): void,
-
-}
-
-export class CanvasEmpty implements Canvas {
-  width = 0;
-  height = 0;
-
-  addEventListener (name: string, handler: Function) {
-  }
-
-  removeEventListener (name: string, handler: Function) {
-  }
-}

package/types/GPUBuffer.ts

@@ -1,85 +0,0 @@
-import type { TypedArray } from './type';
-import type { IGPUResource, IGPURenderer } from './IGPURenderer';
-import type { GPURenderer } from './Renderer';
-
-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,
-  /**
-   * 数据元素的总量
-   */
-  elementCount?: number,
-
-  data?: TypedArray,
-
-  usage?: WebGLRenderingContext['STATIC_DRAW'] | WebGLRenderingContext['DYNAMIC_DRAW'],
-}
-
-/**
- * GPU的Buffer对象，通过JS ArrayBuffer，可以向其中写入数据
- * JS调用写入数据后，会立即执行GPU写入的操作，此类型不会保存JS的ArrayBuffer对象
- *
- */
-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;
-
-  constructor (options: GPUBufferOptions, renderer?: IGPURenderer);
-
-  /**
-   * 数据元素的总量
-   */
-  readonly elementCount: number;
-
-  /**
-   * 根据TypedArray容量，重新分配Buffer内存
-   * @param typedArray
-   */
-  bufferData (typedArray: TypedArray): void;
-
-  /**
-   * 更新buffer数据,立即写入GPU中
-   * @param elementOffset 从buffer的第几个元素开始
-   * @param typedArray 要写入的数据
-   */
-
-  bufferSubData (elementOffset: number, typedArray: TypedArray): void;
-
-  /**
-   * 将数据从GPU中读出，写入到传入的typedArray中，只有当level为2时才能成功，webgl下此函数永远不会成功
-   * @param elementOffset 从第几个元素开始拷贝，默认为 0
-   * @param typedArray 要写入的typedArray
-   * @param elementCount 要写入多少个元素，如果不传入，则为typedArray元素长度
-   */
-  readSubData (elementOffset: number, typedArray: TypedArray, elementCount?: number): boolean;
-
-  assignRenderer (renderer: GPURenderer): GPUBuffer;
-}
-

package/types/GPUCapability.ts

@@ -1,67 +0,0 @@
-import type { Immutable } from './type';
-
-export const COMPRESSED_TEXTURE_NONE = 0;
-export const COMPRESSED_TEXTURE_PVRTC = 1;
-export const COMPRESSED_TEXTURE_ASTC = 2;
-
-export interface GPUCapabilityDetail {
-  maxSample: number,
-  floatTexture: number,
-  halfFloatTexture: number,
-  //set currentPass color attachment type FLOAT
-  floatColorAttachment?: boolean,
-  //set currentPass color attachment type HALF_FLOAT
-  halfFloatColorAttachment?: boolean,
-  maxVertexUniforms: number,
-  maxVertexTextures: number,
-  maxFragmentUniforms: number,
-  maxFragmentTextures: number,
-  maxShaderTexCount: number,
-  maxTextureSize: number,
-  maxTextureAnisotropy: number,
-  compressedTexture: number,
-  shaderTextureLod: boolean,
-  instanceDraw?: boolean,
-  drawBuffers?: boolean,
-  asyncShaderCompile?: boolean,
-  //draw elements use uint32 Array
-  intIndexElementBuffer?: boolean,
-  //render pass depth and stencil texture readable
-  //in webgl, if not readable,use RenderBuffer which cannot readable
-  readableDepthStencilTextures?: boolean,
-  writableFragDepth?: boolean,
-}
-
-export interface GPUCapability {
-  type: 'webgl' | 'webgl2' | 'native-gl' | 'node-gl' | 'metal' | 'none',
-  level: number,
-  capability: Immutable<GPUCapabilityDetail>,
-
-  setup (gl: WebGLRenderingContext): void,
-}
-
-export class GPUCapabilityEmpty implements GPUCapability {
-  type: 'webgl' | 'webgl2' | 'native-gl' | 'node-gl' | 'metal' | 'none';
-  level = 0;
-  capability = {
-    maxSample: 0,
-    floatTexture: 0,
-    halfFloatTexture: 0,
-    maxVertexUniforms: 0,
-    maxVertexTextures: 0,
-    maxFragmentUniforms: 0,
-    maxFragmentTextures: 0,
-    maxTextureSize: 0,
-    maxShaderTexCount:0,
-    maxTextureAnisotropy: 0,
-    compressedTexture: 0,
-    shaderTextureLod: false,
-  };
-
-  constructor () {
-    this.type = 'none';
-  }
-
-  setup (gl: WebGLRenderingContext) {
-  }
-}

package/types/Geometry.ts

@@ -1,186 +0,0 @@
-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
- * location: attribute location
- * 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
- * location: attribute location 可以通过GL反射获得，Metal必须填写
- */
-export interface AttributeBase {
-
-  size: number,
-
-  stride?: number,
-
-  offset?: number,
-
-  instanceDivisor?: number,
-
-  normalize?: boolean,
-
-  location?: number,
-}
-
-/**
- * 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,
-
-  bufferUsage?: GLenum,
-}
-
-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，此函数总是返回实际数据长度
-     * @param name
-     */
-  getAttributeDataLength (name: string): number;
-
-  // attribute names without indexBuffer
-  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);
-}

package/types/IGPURenderer.ts

@@ -1,18 +0,0 @@
-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/types/Material.ts

@@ -1,190 +0,0 @@
-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 const enum MaterialRenderType {
-  normal = 0,
-}
-
-export interface MaterialOptions {
-  states: MaterialRenderStates,
-  shader: ShaderWithSource | ShaderUseCacheId,
-  name?: string,
-  dataBlocks?: MaterialDataBlockOptions[],
-  uniformSemantics?: { [key: string]: UniformSemantic },
-  uniformValues?: { [key: string]: UniformValue },
-}
-
-//使用shader即时编译,此参数会调用 shaderLibrary.addShader() 为 Material提供shaderCacheId属性值，
-//利用shaderCacheId，可以在渲染前进行编译，或者第一次渲染时自动编译
-/**
- * @example
- * const mtl0 = new Material({
- *  shader:{
- *   fragment:'...',
- *   vertex:'...',
- *   shaderCacheId:'mtl_01'
- * }});
- * console.log(mtl.shaderCacheId) // expect to be a none empty string
- */
-
-//使用提前编译的shader进行绘制，传递提前编译的shaderCacheId
-/**
- * @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[][];
-// 支持结构体Uniform数据
-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 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/types/Mesh.ts

@@ -1,82 +0,0 @@
-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 { DestroyOptions } from './constants';
-
-interface MeshOptionsBase {
-  material: Material | MaterialOptions,
-  name?: string,
-  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[];
-
-  // first geometry
-  readonly geometry?: Geometry;
-
-  readonly material: Material;
-
-  public hide: boolean;
-
-  public 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 interface InstancedGeometryMeshOptions extends GeometryMeshOptions {
-  instanceCount: number,
-}
-
-export interface InstancedGeometriesMeshOptions extends GeometriesMeshOptions {
-  instanceCount: number,
-}
-
-export type InstancedMeshOptions = InstancedGeometryMeshOptions | InstancedGeometriesMeshOptions;
-export declare class InstancedMesh extends Mesh {
-  public instanceCount: number;
-  constructor (options: InstancedMeshOptions, renderer?: IGPURenderer);
-}