@predy-js/render-interface 0.0.6

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

@@ -0,0 +1,52 @@
+import type { AttributeWithType } from '../../types/Geometry';
+import type { GPUBuffer, GPUBufferOptions } from '../../types/GPUBuffer';
+import { GLGPUBuffer } from './GLGPUBuffer';
+import type { GLGPURenderer } from './GLGPURenderer';
+import type { RenderState } from '../../types/RenderFrame';
+import type { GLVertexArrayObject } from './GLVertexArrayObject';
+export declare const INDEX_TYPE_MAP: {
+    [x: number]: number;
+};
+export type GLGeometryOptions = {
+    drawStart: number;
+    drawCount: number;
+    attributes: {
+        [key: string]: AttributeWithType;
+    };
+    buffers: {
+        [key: string]: GPUBufferOptions;
+    };
+    mode: GLenum;
+    index?: GPUBufferOptions;
+    name: string;
+    vaoMap?: Record<string, GLVertexArrayObject | undefined>;
+};
+/**
+ * GLGeometry对象，保存GLGPUBuffer对象。
+ *
+ */
+export declare class GLGeometry {
+    name?: string;
+    renderer?: GLGPURenderer | undefined;
+    drawStart: number;
+    drawCount: number;
+    mode: GLenum;
+    attributes: {
+        [key: string]: AttributeWithType;
+    };
+    _buffersMap: {
+        [key: string]: GLGPUBuffer;
+    };
+    _indexBuffer?: GLGPUBuffer;
+    readonly vaoMap: Record<string, GLVertexArrayObject | undefined>;
+    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;
+    getGPUBuffer(name: string | number): GLGPUBuffer | null;
+    destroy(): void;
+    setAttributeBuffer(name: string, buffer: GPUBuffer): void;
+    getAttributeBuffer(name: string): GPUBuffer | null;
+    draw(state: RenderState): void;
+}

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

@@ -0,0 +1,15 @@
+import type { MaterialRenderStates } from '../../types/Material';
+import type { GLGPURenderer } from './GLGPURenderer';
+import type { MarsMaterial } from '../render/MarsMaterial';
+import type { Immutable } from '../../types/type';
+import type { GLProgram } from './GLProgram';
+export declare class GLMaterial {
+    readonly renderer: GLGPURenderer;
+    readonly shaderCacheId: string;
+    readonly states: Immutable<MaterialRenderStates>;
+    readonly material: MarsMaterial;
+    constructor(renderer: GLGPURenderer, material: MarsMaterial);
+    setupStates(): void;
+    getProgram(): GLProgram | null;
+    destroy(): void;
+}

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

@@ -0,0 +1,42 @@
+import type { GLGPURenderer } from './GLGPURenderer';
+import type { GLGeometry } from './GLGeometry';
+import type { RenderState } from '../../types/RenderFrame';
+import type { GLVertexArrayObject } from './GLVertexArrayObject';
+import type { UniformBlockSpec } from './GLUniformUtils';
+export interface ProgramAttributeInfo {
+    readonly name: string;
+    readonly size: number;
+    readonly type: number;
+    readonly loc: number;
+}
+export interface ProgramUniformInfo {
+    readonly loc: WebGLUniformLocation;
+    readonly subInfos: ProgramUniformInfo[];
+    readonly name: string;
+    readonly size: number;
+    readonly type: number;
+    readonly textureIndex: number;
+    readonly isTexture: boolean;
+}
+export declare class GLProgram {
+    readonly glHandle: WebGLProgram;
+    readonly renderer: GLGPURenderer;
+    readonly shared: boolean;
+    readonly id: string;
+    readonly _vaos: GLVertexArrayObject[];
+    readonly uniformBlockMap: Record<string, UniformBlockSpec>;
+    attrInfoMap: {
+        [key: string]: ProgramAttributeInfo;
+    };
+    uniformInfoMap: {
+        [key: string]: ProgramUniformInfo;
+    };
+    private _uniformBlocks;
+    constructor(renderer: GLGPURenderer, program: WebGLProgram, shared: boolean, id: string);
+    init(renderer: GLGPURenderer, program: WebGLProgram): void;
+    bind(): void;
+    setupUniforms(state: RenderState): void;
+    setGLUniformValue(name: string, value: any, info: ProgramUniformInfo, gl: WebGL2RenderingContext | WebGLRenderingContext): void;
+    setupAttributes(geometry: GLGeometry): GLVertexArrayObject;
+    destroy(): void;
+}

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

@@ -0,0 +1,22 @@
+import type { RenderPassStorageObject, RenderPassAttachmentStorageType } from '../../types/RenderPass';
+import type { GLGPURenderer } from './GLGPURenderer';
+interface GLRenderBufferOptions {
+    storageType: RenderPassAttachmentStorageType;
+    format: GLenum;
+    attachment: GLenum;
+}
+export declare class GLRenderBuffer implements RenderPassStorageObject {
+    readonly renderer: GLGPURenderer;
+    readonly storageType: RenderPassAttachmentStorageType;
+    readonly internalFormat: GLenum;
+    readonly glHandle: WebGLRenderbuffer;
+    readonly size: [x: number, y: number];
+    readonly ready: boolean;
+    readonly format: GLenum;
+    readonly attachment: GLenum;
+    readonly multiSample: number;
+    constructor(renderer: GLGPURenderer, options: GLRenderBufferOptions);
+    setSize(width: number, height: number): GLRenderBuffer;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,33 @@
+import type { ShaderCompileResult, ShaderLibrary, ShaderWithSource } from '../../types/ShaderLibrary';
+import type { GLGPURenderer } from './GLGPURenderer';
+import { GLProgram } from './GLProgram';
+interface GLShaderCompileResult extends ShaderCompileResult {
+    program?: WebGLProgram;
+}
+declare enum ShaderType {
+    vertex = 0,
+    fragment = 1
+}
+export declare class GLShaderLibrary implements ShaderLibrary {
+    readonly renderer: GLGPURenderer;
+    readonly shaderResults: {
+        [p: string]: ShaderCompileResult;
+    };
+    private _shaderMap;
+    private _programMap;
+    private _glVertShaderMap;
+    private _glFragShaderMap;
+    private readonly _glAsyncCompileExt?;
+    private _shaderAllDone;
+    constructor(renderer: GLGPURenderer);
+    compileAllShaders(asyncCallback?: (results: ShaderCompileResult[]) => void): void;
+    getProgram(shaderCacheId: string): GLProgram | null;
+    addMarcosHeader(header: string, shader: string, type: ShaderType, downgrade?: boolean): string;
+    addShader(shader: ShaderWithSource): string;
+    compileShader(shaderCacheId: string, asyncCallback?: (result: ShaderCompileResult) => void): ShaderCompileResult;
+    createProgram(gl: WebGLRenderingContext, vs: string, fs: string, result: GLShaderCompileResult): () => (WebGLProgram | null);
+    createShader(gl: WebGLRenderingContext, shaderType: GLenum, code: string): WebGLShader | null;
+    deleteShader(cacheId: string): void;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,35 @@
+import type { TextureConfigOptions, TextureOptions, TextureSourceOptions } from '../../types/Texture';
+import type { GLGPURenderer } from './GLGPURenderer';
+import type { TypedArray, vec2 } from '../../types/type';
+type HTMLImageLike = ImageBitmap | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
+type GLContext = WebGLRenderingContext | WebGL2RenderingContext;
+export declare const imageBitMapAvailable: boolean;
+export declare class GLTexture {
+    readonly renderer?: GLGPURenderer;
+    readonly glHandle: WebGLTexture | null;
+    readonly options: TextureOptions;
+    readonly target: GLenum;
+    readonly gpuInfo: [format: number, type: number, target: number, mipmaps: vec2[]];
+    width: number;
+    height: number;
+    _mipmapUsed: boolean;
+    constructor(option: TextureOptions, renderer: GLGPURenderer);
+    setInspectorName(name: string): void;
+    errorLog(): void;
+    update(source: TextureSourceOptions): void;
+    setTextureFilters(gl: GLContext, target: GLenum, options: TextureConfigOptions): void;
+    texImage2D(gl: GLContext, target: GLenum, level: number, internalformat: GLenum, format: GLenum, type: GLenum, image: HTMLImageLike): vec2;
+    flipImageBitmap(bitmap: ImageBitmap): HTMLCanvasElement;
+    texImage2DData(gl: GLContext, target: GLenum, level: number, internalformat: GLenum, format: GLenum, type: GLenum, data: {
+        data: TypedArray;
+        width: number;
+        height: number;
+    }): vec2;
+    resizeImage(image: HTMLImageLike, targetWidth?: number, targetHeight?: number): HTMLCanvasElement | HTMLImageElement;
+    offloadData(): void;
+    destroy(): void;
+    _assignRenderer(renderer: GLGPURenderer): void;
+}
+export declare function nearestPowerOfTwo(value: number): number;
+export declare function isPowerOfTwo(value: number): boolean;
+export {};

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

@@ -0,0 +1,42 @@
+import type { GLGPURenderer } from './GLGPURenderer';
+import type { TypedArray, UniformValue, vec2 } from '../../types';
+import { GLGPUBuffer } from './GLGPUBuffer';
+export interface UniformBlockSpec {
+    index: number;
+    usedByVertexShader: boolean;
+    usedByFragmentShader: boolean;
+    size: number;
+    uniformIndices: number[];
+    used: boolean;
+    name: string;
+    uniforms: Record<string, BlockUniformInfo>;
+    id: string;
+}
+type BlockUniformInfo = [
+    type: number,
+    offset: number,
+    size: number,
+    blockIndex: number,
+    arrayStride: number,
+    maxStride: number,
+    rowMajor: number,
+    index: number,
+    byteLength: number
+];
+export declare function createUniformBlockSpecsFromProgram(gl: WebGL2RenderingContext, program: WebGLProgram, blockUniformNames: string[]): UniformBlockSpec[];
+interface UBODirtyFlag {
+    start: number;
+    dirty: boolean;
+    buffer?: TypedArray;
+}
+export declare class UniformBlockBuffer {
+    buffer?: GLGPUBuffer;
+    info: UniformBlockSpec;
+    dirtyFlags: Record<string, UBODirtyFlag>;
+    keepData: boolean;
+    constructor(renderer: GLGPURenderer, info: UniformBlockSpec);
+    setValues(uniformValues: Record<string, UniformValue>, dirtyFlags: Record<string, boolean>, uniformValueOffsets: Record<string, vec2>): void;
+    bind(gl: WebGL2RenderingContext, program: WebGLProgram, bufferBindIndex: number): void;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,11 @@
+import type { GLGPURenderer } from './GLGPURenderer';
+export declare function createVAO(renderer: GLGPURenderer, name?: string): GLVertexArrayObject | undefined;
+export declare class GLVertexArrayObject {
+    readonly renderer: GLGPURenderer;
+    readonly vao: WebGLVertexArrayObject;
+    ready: boolean;
+    constructor(renderer: GLGPURenderer, name?: string);
+    destroy(): void;
+    bind(): void;
+    unbind(): void;
+}

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

@@ -0,0 +1,25 @@
+import type { TextureOptions, TypedArray } from '../../types';
+export declare class KhronosTextureContainer {
+    arrayBuffer: ArrayBuffer;
+    baseOffset: number;
+    glType: number;
+    glTypeSize: number;
+    glFormat: number;
+    glInternalFormat: number;
+    glBaseInternalFormat: number;
+    pixelWidth: number;
+    pixelHeight: number;
+    loadType: number;
+    pixelDepth: number;
+    numberOfArrayElements: number;
+    numberOfFaces: number;
+    numberOfMipmapLevels: number;
+    bytesOfKeyValueData: number;
+    constructor(arrayBuffer: ArrayBuffer, facesExpected: number, baseOffset?: number);
+    mipmaps(loadMipmaps: boolean): Array<{
+        data: TypedArray;
+        width: number;
+        height: number;
+    }>;
+}
+export declare function getCompressedTextureOptions(data: ArrayBuffer): TextureOptions;

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

@@ -0,0 +1,285 @@
+export declare class WebGLState {
+    noCache: boolean;
+    readonly _gl: WebGLRenderingContext | WebGL2RenderingContext;
+    private _dict;
+    private _currentFramebuffer;
+    private _currentTextureBinding;
+    private _currentRenderBuffer;
+    private _activeTextureIndex;
+    private readonly _maxTextureCount;
+    private _pixelStorei;
+    _textureUnitDict: {
+        [key: string]: WebGLTexture | null;
+    };
+    bindingVAO?: WebGLVertexArrayObject;
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
+    destroy(): void;
+    private _reset;
+    toggle(capability: GLenum, enable?: boolean): void;
+    /**
+     * 对于该上下文开启某种特性
+     * @param capability
+     * example:
+     * gl.enable(gl.DITHER);
+     */
+    enable(capability: GLenum): void;
+    /**
+     * 基于某种上下文关闭特性
+     * @param capability
+     * example:
+     * gl.disable(gl.DITHER);
+     */
+    disable(capability: GLenum): void;
+    /**
+     * 绑定framebuffer webgl2新增: gl.DRAW_FRAMEBUFFER 和 gl.READ_FRAMEBUFFER
+     * @param target
+     * @param framebuffer
+     * example:
+     * const framebuffer = gl.createFramebuffer();
+     * gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+     */
+    bindFramebuffer(target: GLenum, framebuffer: WebGLFramebuffer | null): void;
+    bindRenderBuffer(target: GLenum, renderBuffer: WebGLRenderbuffer | null): void;
+    /**
+     * 绑定系统framebuffer
+     */
+    bindSystemFramebuffer(): void;
+    /**
+     * 将定义好的WebGLProgram 对象添加到当前的渲染状态中。
+     * @param program
+     * example:
+     * gl.useProgram(program);
+     * gl.useProgram(null);
+     */
+    useProgram(program: WebGLProgram | null): void;
+    /**
+     * 使用预设值来清空缓冲
+     * @param mask
+     * example:
+     * gl.clear(gl.DEPTH_BUFFER_BIT);
+     * gl.clear(gl.DEPTH_BUFFER_BIT | gl.COLOR_BUFFER_BIT);
+     */
+    clear(mask: number): void;
+    /**
+     * 设置深度缓冲区的深度清除值
+     * @param depth
+     * example:
+     * gl.clearDepth(0.5);
+     */
+    clearDepth(depth: GLclampf): void;
+    /**
+     * 指定将输入像素深度与当前深度缓冲区值进行比较的函数。
+     * @param func
+     * example:
+     * gl.enable(gl.DEPTH_TEST);
+     * gl.depthFunc(gl.NEVER);
+     */
+    depthFunc(func: GLenum): void;
+    /**
+     * 设置是否启用写入深度缓冲。
+     * @param flag
+     * example:
+     * gl.depthMask(false);
+     */
+    depthMask(flag: boolean): void;
+    polygonOffset(factor: number, unit: number): void;
+    /**
+     * 将 z 值从规范化设备坐标映射到窗口坐标
+     * @param zNear
+     * @param zFar
+     * example:
+     * gl.depthRange(0.2, 0.6);
+     */
+    depthRange(zNear: number, zFar: number): void;
+    /**
+     * 模版测试设置函数和引用值。
+     * @param func
+     * @param ref
+     * @param mask
+     * example:
+     * gl.enable(gl.STENCIL_TEST);
+     * gl.stencilFunc(gl.LESS, 0, 0b1110011);
+     */
+    clearStencil(s: GLint): void;
+    /**
+     * 控制启用和禁用模板平面中单个位的正面和背面写入
+     * @param mask
+     * example:
+     * gl.stencilMask(0xff);
+     */
+    stencilMask(mask: number): void;
+    /**
+     * 模版测试设置函数和引用值。
+     * @param func
+     * @param ref
+     * @param mask
+     * example:
+     * gl.enable(gl.STENCIL_TEST);
+     * gl.stencilFunc(gl.LESS, 0, 0b1110011);
+     */
+    stencilFunc(func: GLenum, ref: GLint, mask: GLuint): void;
+    /**
+     * 单面模版测试
+     * @param face
+     * @param func
+     * @param ref
+     * @param mask
+     * example:
+     * gl.enable(gl.STENCIL_TEST);
+     * gl.stencilFuncSeparate(gl.FRONT, gl.LESS, 0.2, 1110011);
+     */
+    stencilFuncSeparate(face: GLenum, func: GLenum, ref: GLint, mask: GLuint): void;
+    /**
+     * 单面的mask写入
+     * @param face
+     * @param mask
+     * example:
+     * gl.stencilMaskSeparate(gl.FRONT, 110101);
+     */
+    stencilMaskSeparate(face: GLenum, mask: GLuint): void;
+    /**
+     * 设置正面和背面模板测试操作
+     * @param fail
+     * @param zfail
+     * @param zpass
+     * example:
+     * gl.enable(gl.STENCIL_TEST);
+     * gl.stencilOp(gl.INCR, gl.DECR, gl.INVERT);
+     */
+    stencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum): void;
+    /**
+     * 设置正面和/或背面模板测试操作
+     * @param face
+     * @param fail
+     * @param zfail
+     * @param zpass
+     * example:
+     * gl.enable(gl.STENCIL_TEST);
+     * gl.stencilOpSeparate(gl.FRONT, gl.INCR, gl.DECR, gl.INVERT);
+     */
+    stencilOpSeparate(face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum): void;
+    /**
+     * 剔除方式
+     * @param mode
+     * example:
+     * gl.enable(gl.CULL_FACE);
+     * gl.cullFace(gl.FRONT_AND_BACK);
+     */
+    cullFace(mode: GLenum): void;
+    /**
+     * 设置卷绕方向
+     * @param mode
+     * example:
+     * gl.frontFace(gl.CW);
+     */
+    frontFace(mode: GLenum): void;
+    /**
+     * 设置颜色写入
+     * @param red
+     * @param green
+     * @param blue
+     * @param alpha
+     * example:
+     * gl.colorMask(true, true, true, false);
+     */
+    clearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
+    /**
+     * 设置颜色写入
+     * @param red
+     * @param green
+     * @param blue
+     * @param alpha
+     * example:
+     * gl.colorMask(true, true, true, false);
+     */
+    colorMask(red: boolean, green: boolean, blue: boolean, alpha: boolean): void;
+    /**
+     * 设置源和目标混合因子
+     * @param red
+     * @param green
+     * @param blue
+     * @param alpha
+     * example:
+     * gl.blendColor(0, 0.5, 1, 1);
+     */
+    blendColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
+    /**
+     * 用于混合像素算法
+     * @param sfactor
+     * @param dfactor
+     * example:
+     * gl.enable(gl.BLEND);
+     * gl.blendFunc(gl.SRC_COLOR, gl.DST_COLOR);
+     */
+    blendFunc(sfactor: GLenum, dfactor: GLenum): void;
+    /**
+     * 分别设置应用在 RGB 和 Alpha 上的 factor
+     * @param srcRGB
+     * @param dstRGB
+     * @param srcAlpha
+     * @param dstAlpha
+     * example:
+     * gl.enable(gl.BLEND);
+     * gl.blendFuncSeparate(gl.SRC_COLOR, gl.DST_COLOR, gl.ONE, gl.ZERO);
+     */
+    blendFuncSeparate(srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum): void;
+    /**
+     * 设置混合模式
+     * @param mode
+     * example:
+     * gl.blendEquation(gl.FUNC_ADD);
+     * gl.blendEquation(gl.FUNC_SUBTRACT);
+     * gl.blendEquation(gl.FUNC_REVERSE_SUBTRACT);
+     */
+    blendEquation(mode: GLenum): void;
+    /**
+     * 可以分别对 RGB 和 Alpha 做不同的操作处理
+     * @param modeRGB
+     * @param modeAlpha
+     * example:
+     * gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_SUBTRACT);
+     */
+    blendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum): void;
+    /**
+     * 图像预处理
+     * @param pname
+     * @param param
+     * example:
+     * var tex = gl.createTexture();
+     * gl.bindTexture(gl.TEXTURE_2D, tex);
+     * gl.pixelStorei(gl.PACK_ALIGNMENT, 4);
+     */
+    pixelStorei(pname: GLenum, param: GLenum): void;
+    /**
+     * 用来设置视口，即指定从标准设备到窗口坐标的x、y仿射变换。
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     * example:
+     * gl.viewport(0, 0, width, height);
+     */
+    viewport(x: number, y: number, width: number, height: number): void;
+    /**
+     * 激活指定的纹理单元
+     * @param texture
+     * example:
+     * gl.activeTexture(gl.TEXTURE1);
+     */
+    activeTexture(texture: GLenum): void;
+    /**
+     * 绑定WebGLTexture
+     * @param target
+     * @param texture
+     * @param force
+     * example:
+     * var texture = gl.createTexture();
+     * gl.bindTexture(gl.TEXTURE_2D, texture)
+     */
+    bindTexture(target: GLenum, texture: WebGLTexture | null, force?: boolean): void;
+    private _set1;
+    private _set2;
+    private _set3;
+    private _set4;
+    get(name: string): any;
+}

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

@@ -0,0 +1,4 @@
+import type { TypedArray } from '../../types/type';
+export declare let constants: WebGL2RenderingContext;
+export declare function createTypedArrayByGLType(type: number, elementCount: number | ArrayBuffer): TypedArray;
+export declare function getBytesPerElementByGLType(type: number): number;

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

@@ -0,0 +1,8 @@
+import type { ProgramUniformInfo } from './GLProgram';
+import type { GLGPURenderer } from './GLGPURenderer';
+export declare const DATA_DICT: {
+    [k: string | number]: {
+        name: number;
+        uniform: (gl: WebGL2RenderingContext | WebGLRenderingContext, info: ProgramUniformInfo, value: any, renderer: GLGPURenderer) => void;
+    };
+};