@predy-js/render-interface 0.0.6

package/dist/types/ShaderLibrary.d.ts

@@ -0,0 +1,78 @@
+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 SharedShaderWithSource {
+    fragment: string;
+    vertex: string;
+    name?: string;
+    downgrade?: boolean;
+    marcos?: ShaderMarcos;
+    cacheId?: string;
+    shared?: true;
+}
+export interface ShaderUseCacheId {
+    cacheId: string;
+}
+export type ShaderMarcos = [key: string, value: string | number | boolean][];
+export declare enum ShaderCompileResultStatus {
+    noShader = 0,
+    success = 1,
+    fail = 2,
+    compiling = 3
+}
+export interface ShaderCompileResult {
+    status: ShaderCompileResultStatus;
+    cacheId?: string;
+    error?: string | null;
+    shared?: boolean;
+    compileTime?: number;
+}
+/**
+ * @example
+ * const lib:ShaderLibrary = ...;
+ * const shaderCacheId = lib.addShader({fragment:'...',vertex:'...'});
+ * lib.compileShader(shaderCacheId);
+ * //pre-compiled program
+ * const mtl = new Material({
+ *   shader:{ shaderCacheId }
+ * })
+ */
+export interface ShaderLibrary {
+    readonly shaderResults: {
+        [cacheId: string]: ShaderCompileResult;
+    };
+    addShader(shader: Shader): string;
+    /**
+     * @param cacheId
+     */
+    deleteShader(cacheId: string): void;
+    /**
+     * 编译shader
+     * @param shaderCacheId
+     * @param asyncCallback 如果传入，则会启用异步编译，当所有编译完成后被回调
+     */
+    compileShader(shaderCacheId: string, asyncCallback?: (result: ShaderCompileResult) => void): ShaderCompileResult;
+    /***
+     * 编译现有的所有shader
+     * @param asyncCallback 如果传入，则会启用异步编译，当所有编译完成后被回调
+     */
+    compileAllShaders(asyncCallback?: (results: ShaderCompileResult[]) => void): void;
+    destroy(): void;
+}
+export declare class ShaderLibraryEmpty implements ShaderLibrary {
+    readonly shaderResults: {
+        [cacheId: string]: ShaderCompileResult;
+    };
+    addShader(shader: Shader, marcos?: ShaderMarcos): string;
+    compileAllShaders(asyncCallback?: (results: ShaderCompileResult[]) => void): never[];
+    deleteShader(cacheId: string): void;
+    compileShader(shaderCacheId: string): ShaderCompileResult;
+    destroy(): void;
+}

package/dist/types/Texture.d.ts

@@ -0,0 +1,212 @@
+import type { IGPURenderer, IGPUResource } from './IGPURenderer';
+import type { Immutable, TypedArray } from './type';
+import type { GPURenderer } from './Renderer';
+export declare enum TextureSourceType {
+    none = 0,
+    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;
+    }
+];
+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;
+    wrapT?: GLenum;
+    magFilter?: GLenum;
+    minFilter?: GLenum;
+    anisotropic?: number;
+    flipY?: boolean;
+    premultiplyAlpha?: boolean;
+    keepImageSource?: boolean;
+}
+export interface TextureConfigOptions extends TextureConfigOptionsBase {
+    sourceFrom?: TextureFactorySourceFrom;
+}
+export interface TextureFormatOptions {
+    format?: GLenum;
+    internalFormat?: GLenum;
+    type?: GLenum;
+}
+export interface TextureOptionsBase extends TextureConfigOptions, TextureFormatOptions {
+}
+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;
+export {};

package/dist/types/constants.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,26 @@
+import type { TextureFactory, Texture, TextureConfigOptions, TextureOptions, TextureFactorySourceFrom } from './Texture';
+import type { GPUCapability } from './GPUCapability';
+import type { TypedArray } from './type';
+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/dist/types/type.d.ts

@@ -0,0 +1,37 @@
+export type Immutable<O> = O extends Record<any, any> ? {
+    readonly [key in keyof O]: Immutable<O[key]>;
+} : O extends Array<infer X> ? ReadonlyArray<X> : O;
+export type vec4 = [x: number, y: number, z: number, w: number];
+export type vec3 = [x: number, y: number, z: number];
+export type vec2 = [x: number, y: number];
+export type mat2 = [m11: number, m12: number, m21: number, m22: number];
+export type mat3 = [
+    m11: number,
+    m12: number,
+    m13: number,
+    m21: number,
+    m22: number,
+    m23: number,
+    m31: number,
+    m32: number,
+    m33: number
+];
+export type mat4 = [
+    m11: number,
+    m12: number,
+    m13: number,
+    m14: number,
+    m21: number,
+    m22: number,
+    m23: number,
+    m24: number,
+    m31: number,
+    m32: number,
+    m33: number,
+    m34: number,
+    m41: number,
+    m42: number,
+    m43: number,
+    m44: number
+];
+export type TypedArray = Float32Array | Float64Array | Uint8Array | Uint32Array | Uint16Array | Int8Array | Int16Array | Int32Array;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@predy-js/render-interface",
+  "version": "0.0.6",
+  "license": "MIT",
+  "module": "./dist/index.mjs",
+  "main": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./statistic": "./dist/statistic.js"
+  },
+  "scripts": {
+    "dev": "rollup -c --watch",
+    "prebuild": "npm run clean:all",
+    "build": "npm run build:dist",
+    "build:dist": "rollup -c",
+    "lint": "eslint {src,types,test,demo} --ext .ts",
+    "lint:fix": "eslint {src,types,test,demo} --fix --quiet --ext .ts",
+    "check:ts": "tsc -b ./tsconfig.check.json",
+    "clean:all": "npm run clean:dist",
+    "clean:dist": "rm -rf dist/**",
+    "test": "rollup -c --watch --test",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^13.2.1",
+    "@commitlint/config-conventional": "^13.2.0",
+    "@rollup/plugin-commonjs": "^21.0.3",
+    "@rollup/plugin-node-resolve": "^13.1.3",
+    "@rollup/plugin-replace": "^5.0.0",
+    "@rollup/plugin-typescript": "^8.3.1",
+    "@types/chai": "^4.3.0",
+    "@types/chai-spies": "^1.0.3",
+    "@types/mocha": "^9.0.0",
+    "@types/webgl2": "0.0.6",
+    "@typescript-eslint/eslint-plugin": "^5.26.0",
+    "@typescript-eslint/parser": "^5.26.0",
+    "assert": "^2.0.0",
+    "chai": "^4.3.6",
+    "chai-spies": "^1.0.0",
+    "eslint": "^8.13.0",
+    "eslint-plugin-promise": "^5.2.0",
+    "husky": "^7.0.4",
+    "lint-staged": "^11.2.6",
+    "meshoptimizer": "^0.18.1"
+  }
+}