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

package/types/Texture.ts

@@ -0,0 +1,236 @@
+import type { IGPURenderer, IGPUResource } from './IGPURenderer';
+import type { Immutable, TypedArray } from './type';
+import type { GPURenderer } from './Renderer';
+
+export enum TextureSourceType {
+  none,
+  data = 1,
+  image = 2,
+  compressed = 3,
+  video = 4,
+  canvas = 5,
+  framebuffer = 6,
+  mipmaps = 7
+}
+
+export interface TextureFactorySource2DFrom {
+  type: TextureSourceType.image | TextureSourceType.video,
+  url: string,
+  target?: WebGLRenderingContext['TEXTURE_2D'],
+}
+
+export interface TextureFactorySourceFromCompressed {
+  type: TextureSourceType.compressed,
+  url: string,
+}
+
+export type TextureFactorySourceCubeFrom = {
+  type: TextureSourceType.image,
+  map: TextureCubeSourceURLMap | string[],
+  target: WebGLRenderingContext['TEXTURE_CUBE_MAP'],
+};
+
+type DataRange = [start: number, length: number];
+
+export type TextureFactorySourceCubeBinaryMipmapsFrom = {
+  target: WebGLRenderingContext['TEXTURE_CUBE_MAP'],
+  type: TextureSourceType.mipmaps,
+  bin: string,
+  mipmaps: Array<[
+    TEXTURE_CUBE_MAP_POSITIVE_X: DataRange,
+    TEXTURE_CUBE_MAP_NEGATIVE_X: DataRange,
+    TEXTURE_CUBE_MAP_POSITIVE_Y: DataRange,
+    TEXTURE_CUBE_MAP_NEGATIVE_Y: DataRange,
+    TEXTURE_CUBE_MAP_POSITIVE_Z: DataRange,
+    TEXTURE_CUBE_MAP_NEGATIVE_Z: DataRange
+  ]>,
+};
+
+export type TextureFactorySource2DBinaryMipmapsFrom = {
+  target?: WebGLRenderingContext['TEXTURE_2D'],
+  type: TextureSourceType.mipmaps,
+  bin: string,
+  mipmaps: Array<DataRange>,
+};
+
+export interface TextureFactorySourceCubeMipmapsFrom {
+  type: TextureSourceType.mipmaps,
+  target: WebGLRenderingContext['TEXTURE_CUBE_MAP'],
+  maps: TextureCubeSourceURLMap[] | string[][],
+}
+
+export interface TextureFactorySource2DMipmapsFrom {
+  type: TextureSourceType.mipmaps,
+  target?: WebGLRenderingContext['TEXTURE_2D'],
+  urls: string[],
+}
+
+export type TextureFactorySourceFrom =
+  TextureFactorySource2DBinaryMipmapsFrom
+  | TextureFactorySourceCubeBinaryMipmapsFrom
+  | TextureFactorySource2DFrom
+  | TextureFactorySourceCubeFrom
+  | TextureFactorySourceCubeMipmapsFrom
+  | TextureFactorySource2DMipmapsFrom
+  | TextureFactorySourceFromCompressed;
+
+export interface TextureFactory {
+  loadSourceAsync (options: TextureFactorySourceFrom, config?: TextureConfigOptions): Promise<TextureOptions>,
+
+  canOffloadTexture (texture: Texture): boolean,
+
+  reloadTextureAsync (texture: Texture): Promise<Texture>,
+
+  loadCompressedTextureFromArrayBuffer (arrayBuffer: ArrayBuffer, options?: TextureOptions): TextureOptions,
+}
+
+export declare class Texture implements IGPUResource {
+  readonly width: number;
+  readonly height: number;
+  readonly id: string;
+  readonly options: Immutable<TextureOptions>;
+  readonly renderer?: IGPURenderer;
+  readonly sourceType: TextureSourceType;
+  readonly name: string;
+  readonly isDestroyed: boolean;
+
+  constructor (options: TextureOptions, renderer?: IGPURenderer);
+
+  destroy (): void;
+
+  updateSource (options: TextureSourceOptions): void;
+
+  uploadCurrentVideoFrame (): boolean;
+
+  offloadData (): void;
+
+  reloadDataAsync (): Promise<Texture>;
+
+  assignRenderer (renderer: GPURenderer): Texture;
+
+}
+
+type ImageSource = ImageBitmap | HTMLImageElement | HTMLCanvasElement;
+
+export type TextureSourceCubeData = [
+  TEXTURE_CUBE_MAP_POSITIVE_X: ImageSource | { data: TypedArray, width: number, height: number },
+  TEXTURE_CUBE_MAP_NEGATIVE_X: ImageSource | { data: TypedArray, width: number, height: number },
+  TEXTURE_CUBE_MAP_POSITIVE_Y: ImageSource | { data: TypedArray, width: number, height: number },
+  TEXTURE_CUBE_MAP_NEGATIVE_Y: ImageSource | { data: TypedArray, width: number, height: number },
+  TEXTURE_CUBE_MAP_POSITIVE_Z: ImageSource | { data: TypedArray, width: number, height: number },
+  TEXTURE_CUBE_MAP_NEGATIVE_Z: ImageSource | { data: TypedArray, width: number, height: number }
+];
+
+// 为减少内存消耗，除了video之外，其余的数据内容会在texture生成后被置为undefined
+// const tex = new Texture({image:myImage},renderer)
+// tex.options.image === undefined
+
+export type TextureSourceOptions = Texture2DSourceOptions | TextureCubeSourceOptions;
+
+export interface Texture2DSourceOptionsNone extends TextureOptionsBase {
+  sourceType?: TextureSourceType.none,
+  target?: GLenum,
+}
+
+export interface Texture2DSourceOptionsImage extends TextureOptionsBase {
+  sourceType?: TextureSourceType.image,
+  image: ImageSource,
+  target?: WebGLRenderingContext['TEXTURE_2D'],
+  generateMipmap?: boolean,
+}
+
+export interface Texture2DSourceOptionsFrameBuffer extends TextureOptionsBase {
+  sourceType: TextureSourceType.framebuffer,
+  data?: { width: number, height: number },
+  target?: WebGLRenderingContext['TEXTURE_2D'],
+}
+
+export interface Texture2DSourceOptionsData extends TextureOptionsBase {
+  sourceType?: TextureSourceType.data,
+  data: { data: TypedArray, width: number, height: number },
+  target?: WebGLRenderingContext['TEXTURE_2D'],
+}
+
+export interface Texture2DSourceOptionsVideo extends TextureOptionsBase {
+  sourceType?: TextureSourceType.video,
+  video: HTMLVideoElement,
+  target?: WebGLRenderingContext['TEXTURE_2D'],
+  generateMipmap?: boolean,
+}
+
+export interface Texture2DSourceOptionsImageMipmaps extends TextureOptionsBase {
+  sourceType?: TextureSourceType.mipmaps,
+  mipmaps: Array<ImageSource | { data: TypedArray, width: number, height: number }>,
+  target?: WebGLRenderingContext['TEXTURE_2D'],
+}
+
+export interface Texture2DSourceOptionsCompressed extends TextureOptionsBase {
+  sourceType?: TextureSourceType.compressed,
+  mipmaps: Array<{ data: TypedArray, width: number, height: number }>,
+  target?: WebGLRenderingContext['TEXTURE_2D'],
+}
+
+export interface TextureCubeSourceOptionsImage extends TextureOptionsBase {
+  sourceType: TextureSourceType.image | TextureSourceType.data,
+  target: WebGLRenderingContext['TEXTURE_CUBE_MAP'],
+  cube: TextureSourceCubeData,
+  generateMipmap?: boolean,
+}
+
+export interface TextureCubeSourceOptionsImageMipmaps extends TextureOptionsBase {
+  sourceType?: TextureSourceType.mipmaps,
+  mipmaps: Array<TextureSourceCubeData>,
+  target: WebGLRenderingContext['TEXTURE_CUBE_MAP'],
+}
+
+export type TextureCubeSourceURLMap = [
+  TEXTURE_CUBE_MAP_POSITIVE_X: string,
+  TEXTURE_CUBE_MAP_NEGATIVE_X: string,
+  TEXTURE_CUBE_MAP_POSITIVE_Y: string,
+  TEXTURE_CUBE_MAP_NEGATIVE_Y: string,
+  TEXTURE_CUBE_MAP_POSITIVE_Z: string,
+  TEXTURE_CUBE_MAP_NEGATIVE_Z: string
+];
+
+export interface TextureConfigOptionsBase {
+  name?: string,
+  wrapS?: GLenum, // GL_CLAMP_TO_EDGE
+  wrapT?: GLenum, // GL_CLAMP_TO_EDGE
+  magFilter?: GLenum, // GL_NEAREST
+  minFilter?: GLenum, // GL_NEAREST
+  anisotropic?: number, //0
+  flipY?: boolean,
+  premultiplyAlpha?: boolean,
+  //when use ImageBitMap, the bitmap content will be closed after sent to GPU
+  keepImageSource?: boolean,
+}
+
+export interface TextureConfigOptions extends TextureConfigOptionsBase {
+  sourceFrom?: TextureFactorySourceFrom,
+}
+
+export interface TextureFormatOptions {
+  format?: GLenum, // GL_RGBA
+  internalFormat?: GLenum, // GL_RGBA
+  type?: GLenum, //GL_UNSIGNED_BYTE
+}
+
+export interface TextureOptionsBase extends TextureConfigOptions, TextureFormatOptions {
+  sourceType?: TextureSourceType,
+}
+
+export type TextureCubeSourceOptions = TextureCubeSourceOptionsImage | TextureCubeSourceOptionsImageMipmaps;
+
+export type Texture2DSourceOptions =
+  Texture2DSourceOptionsImage
+  | Texture2DSourceOptionsData
+  | Texture2DSourceOptionsVideo
+  | Texture2DSourceOptionsImageMipmaps
+  | Texture2DSourceOptionsCompressed
+  | Texture2DSourceOptionsFrameBuffer;
+
+export type Texture2DOptions = Texture2DSourceOptions;
+
+export type TextureCubeOptions = TextureCubeSourceOptions;
+
+export type TextureOptions = Texture2DOptions | TextureCubeOptions;

package/types/constants.ts

@@ -0,0 +1,7 @@
+export declare const constants: WebGL2RenderingContext;
+
+export enum DestroyOptions {
+  destroy = 0,
+  keep = 1,
+  force = destroy,
+}

package/types/index.ts

@@ -0,0 +1,37 @@
+import type {
+  TextureFactory, Texture, TextureConfigOptions, TextureOptions, TextureFactorySourceFrom,
+} from './Texture';
+import type { GPUCapability } from './GPUCapability';
+import type { TypedArray } from './type';
+export * from './native/index';
+export * from './constants';
+export * from './GPUCapability';
+export * from './Renderer';
+export * from './RenderFrame';
+export * from './Texture';
+export * from './Material';
+export * from './GPUBuffer';
+export * from './RenderPass';
+export * from './Mesh';
+export * from './Geometry';
+export * from './ShaderLibrary';
+export { GPURenderer as Renderer } from './Renderer';
+export * from './type';
+
+export declare function getDefaultTextureFactory (): TextureFactory;
+
+export declare function setDefaultTextureFactory (factory: TextureFactory): void;
+
+export declare function getDefaultGPUCapability (): GPUCapability;
+
+export declare class MarsTextureFactory implements TextureFactory {
+  canOffloadTexture (texture: Texture): boolean;
+
+  loadSourceAsync (options: TextureFactorySourceFrom, config?: TextureConfigOptions): Promise<TextureOptions>;
+
+  reloadTextureAsync (texture: Texture): Promise<Texture>;
+
+  loadCompressedTextureFromArrayBuffer (arrayBuffer: ArrayBuffer, options?: TextureOptions): TextureOptions;
+
+  loadImageBinaryAsync (binary: ArrayBuffer | TypedArray | Blob, mime?: string): Promise<HTMLImageElement | ImageBitmap>;
+}

package/types/native/DataBlockInternal.ts

@@ -0,0 +1,35 @@
+import type { ResourceInternal } from './ResourceInternal';
+import type { TypedArray } from '../type';
+
+export interface DataBlockInternalOptions {
+  name: string,
+}
+export abstract class DataBlockInternal implements ResourceInternal {
+  readonly isDestroyed: boolean;
+  /**
+   * UBO的name，如果没有找到对应的UBO就用setUniform
+   * UBO的Layout只有一种，如果不同shader中使用同名UBO，请创建不同的DataBlock对象
+   */
+  readonly name: string;
+
+  protected constructor (options: DataBlockInternalOptions) {}
+
+  abstract destroy (): void;
+
+  /**
+   * uniform 的数据都以TypedArray形式传入，
+   * 在OpenGL中，使用UBO时，作为UBO的数据buffer，
+   * 不使用UBO时根据反射类型进行数据转化
+   * Metal中，直接当作 argument buffer
+   */
+  abstract setUniformValue (name: string, value: TypedArray): void;
+
+  /**
+   * 将uniform的数据拷贝到指定的TypedArray中,
+   * 如果传入的TypedArray buffer 长度不足，将只写入传入长度的数据
+   * @param name
+   * @param value
+   */
+  abstract getUniformValue (name: string, value: TypedArray): boolean;
+
+}

package/types/native/GPUBufferInternal.ts

@@ -0,0 +1,46 @@
+import type { ResourceInternal } from './ResourceInternal';
+import type { TypedArray } from '../type';
+
+export const GPUBufferOptionsMemoryShared = 1 << 1;
+
+export interface GPUBufferInternalOptions {
+  data?: TypedArray,
+  options?: typeof GPUBufferOptionsMemoryShared,
+}
+
+/**
+ * 内存写入GPU的具体时机由框架自行决定，只要保证在渲染前输入GPU即可
+ */
+export abstract class GPUBufferInternal implements ResourceInternal {
+  readonly isDestroyed: boolean;
+  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/types/native/GeometryInternal.ts

@@ -0,0 +1,55 @@
+import type { AttributeWithType, GeometryOptions } from '../Geometry';
+import type { ResourceInternal } from './ResourceInternal';
+import type { GPUBufferInternal } from './GPUBufferInternal';
+
+interface GeometryBufferLayout {
+  index: number,
+  name: string,
+}
+export interface GeometryInternalOptions extends Omit<GeometryOptions, 'attributes' | 'index'> {
+  attributes: Record<string, AttributeWithType>,
+  buffers: Record<string, GPUBufferInternal>,
+  bufferLayouts: GeometryBufferLayout[],
+  indexBuffer?: GPUBufferInternal,
+  indexBufferType?: IndexBufferType,
+}
+
+export type IndexBufferType = WebGLRenderingContext['UNSIGNED_SHORT'] | WebGLRenderingContext['UNSIGNED_INT'];
+
+/**
+ * geometry中的数据都以buffer形式保存
+ */
+export abstract class GeometryInternal implements ResourceInternal {
+  readonly isDestroyed: boolean;
+
+  readonly name: string;
+
+  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 getIndexBuffer (): [buffer: GPUBufferInternal | undefined, type: number];
+
+  /**
+     * 获得当前所有的attributeBuffer
+     */
+  abstract getAttributeBufferMap (): Record<string, GPUBufferInternal>;
+
+  abstract setIndexBuffer (buffer: GPUBufferInternal | undefined, bufferType?: IndexBufferType): void;
+
+  /**
+     * 并不会销毁attributeBuffers和IndexBuffer，
+     * 但会清除内部buffer的引用，如果需要销毁buffers，
+     * 调用destroy之前，需要手动调用 getAttributeBufferMap 和 getIndexBuffer 将获得的buffer显式销毁
+     */
+  abstract destroy (): void;
+}

package/types/native/ImageBitmapInternal.ts

@@ -0,0 +1,28 @@
+export interface ImageBitmapConstructor {
+  flipY?: boolean,
+  premultiplyAlpha?: boolean,
+  resizeWidth?: number,
+  resizeHeight?: number,
+}
+
+export abstract class ImageBitmapInternal {
+  /**
+   * 释放内存，释放后不可再用,
+   * 释放后 width,height,byteLength都为0
+   */
+  abstract close (): void;
+
+  /**
+   * 将内存拷贝到指定的Uint8Array中
+   * @param target
+   */
+  abstract copyTo (target: Uint8Array): void;
+  abstract readonly width: number;
+  abstract readonly height: number;
+  abstract readonly byteLength: number;
+}
+
+export type ImageBitmapCallback = (
+  error: Error | undefined,
+  image: ImageBitmapInternal
+) => void;

package/types/native/MaterialInternal.ts

@@ -0,0 +1,31 @@
+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[],
+  shaderCacheId: string,
+  name: string,
+}
+export abstract class MaterialInternal implements ResourceInternal {
+  readonly isDestroyed: boolean;
+  readonly name: string;
+  readonly shaderCacheId: string;
+
+  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/types/native/MeshInternal.ts

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

package/types/native/RenderFrameInternal.ts

@@ -0,0 +1,34 @@
+import type { ResourceInternal } from './ResourceInternal';
+import type { RenderPassInternal } from './RenderPassInternal';
+import type { RenderPassLoadAction } from '../RenderPass';
+
+export interface RenderFrameInternalOptions {
+  renderPasses: RenderPassInternal[],
+  loadAction: RenderPassLoadAction,
+  name: string,
+}
+export abstract class RenderFrameInternal implements ResourceInternal {
+  readonly isDestroyed: boolean;
+  readonly loadAction: RenderPassLoadAction;
+  readonly name: string;
+  /**
+   * 增删改查的操作，在warp层对renderPassInternals进行后，得到的数据全部覆盖当前数据
+   */
+  renderPasses: RenderPassInternal[];
+
+  protected constructor (options: RenderFrameInternalOptions) {
+  }
+  abstract destroy (): void;
+  /**
+   * warp层完成所有数据传输后，通知客户端，可以进行实际渲染，
+   * 实际渲染根据客户端时机进行,在调用end()之前，客户端会根据实际刷新进行绘制
+   */
+  abstract begin (): void;
+
+  /**
+   * 将RenderFrame移除渲染队列
+   */
+  abstract end (): void;
+
+  abstract updateLoadAction (action: RenderPassLoadAction): void;
+}

package/types/native/RenderPassInternal.ts

@@ -0,0 +1,69 @@
+import type { ResourceInternal } from './ResourceInternal';
+import type { MeshInternal } from './MeshInternal';
+import type { RenderPassLoadAction, RenderPassStoreAction } from '../RenderPass';
+import type { TextureInternal } from './TextureInternal';
+import type { RenderPassStorageObject } from '../RenderPass';
+import type { RenderPassAttachmentStorageType } from '../RenderPass';
+
+//--- color ---
+export interface RenderPassColorAttachmentInternal {
+  readonly storageType: RenderPassAttachmentStorageType.color,
+  readonly texture: TextureInternal,
+}
+
+//--- depth stencil ---
+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 {
+  loadAction: RenderPassLoadAction,
+  attachments: RenderPassColorAttachmentInternal[],
+  name: string,
+  meshes: MeshInternal[],
+  width: number,
+  height: number,
+  multiSample?: number,
+  storeAction?: RenderPassStoreAction,
+  depthStencilAttachment?: RenderPassDepthStencilAttachmentOptionsInternal,
+}
+
+export abstract class RenderPassInternal implements ResourceInternal {
+  readonly isDestroyed: boolean;
+  readonly name: string;
+  readonly storeAction: RenderPassStoreAction;
+  readonly loadAction: RenderPassLoadAction;
+  readonly multisample: number;
+  readonly depthStencilAttachment: RenderPassDepthStencilAttachmentInternal;
+  readonly attachments: RenderPassColorAttachmentInternal[];
+  readonly width: number;
+  readonly height: number;
+  /**
+   * 增删改查的操作，在warp层对Mesh进行后，得到的数据全部覆盖当前数据
+   */
+  meshes: MeshInternal[];
+
+  priority: number;
+
+  protected constructor (options: RenderPassOptionsInternal) {
+  }
+  abstract destroy (): void;
+
+  abstract resize (width: number, height: number): void;
+}

package/types/native/RendererInternal.ts

@@ -0,0 +1,66 @@
+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';
+import type { TextureInternal, TextureInternalConstructOptions } from './TextureInternal';
+import type { ImageBitmapCallback, ImageBitmapConstructor } from './ImageBitmapInternal';
+
+/**
+ * renderer 内部创建的对象，用来统计信息，排查资源泄漏的问题
+ */
+export interface InternalResInfo {
+  buffer: number,
+  geometry: number,
+  material: number,
+  texture: number,
+  dataBlock: number,
+  mesh: number,
+  renderPass: number,
+  frame: number,
+}
+
+export abstract class RendererInternal implements ResourceInternal {
+  readonly isDestroyed: boolean;
+  readonly platform: ResourcePlatform;
+  readonly gpu: GPUCapability;
+  readonly shaderLibrary: ShaderLibraryInternal;
+  readonly width: number;
+  readonly height: number;
+
+  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 createTexture (options: TextureInternalConstructOptions): TextureInternal;
+
+  abstract getResourceInfo (): InternalResInfo;
+
+  abstract requestAnimationFrame (callback: (timestamp: number) => void): number;
+
+  abstract cancelAnimationFrame (id: number): void;
+
+  abstract createImageBitmap (
+    data: ArrayBuffer | string, //图片文件的数据
+    options: ImageBitmapConstructor,
+    callback: ImageBitmapCallback
+  ): void;
+}
+

package/types/native/ResourceInternal.ts

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