@galacean/engine-rhi-webgl 0.9.0-beta.80

package/types/GLTexture.d.ts

@@ -0,0 +1,54 @@
+import { IPlatformTexture, Texture, TextureCubeFace, TextureDepthCompareFunction, TextureFilterMode, TextureWrapMode } from "@galacean/engine-core";
+import { WebGLRenderer } from "./WebGLRenderer";
+/**
+ * Texture in WebGL platform.
+ */
+export declare class GLTexture implements IPlatformTexture {
+    /**
+     * Wrapping mode for texture coordinate S.
+     */
+    set wrapModeU(value: TextureWrapMode);
+    /**
+     * Wrapping mode for texture coordinate T.
+     */
+    set wrapModeV(value: TextureWrapMode);
+    /**
+     * Filter mode for texture.
+     */
+    set filterMode(value: TextureFilterMode);
+    /**
+     * Anisotropic level for texture.
+     */
+    set anisoLevel(value: number);
+    set depthCompareFunction(value: TextureDepthCompareFunction);
+    /**
+     * Create texture in WebGL platform.
+     */
+    constructor(rhi: WebGLRenderer, texture: Texture, target: GLenum);
+    /**
+     * Destroy texture.
+     */
+    destroy(): void;
+    /**
+     * Generate multi-level textures based on the 0th level data.
+     */
+    generateMipmaps(): void;
+    protected _bind(): void;
+    /**
+     * Pre-development mipmapping GPU memory.
+     */
+    protected _init(isCube: boolean): void;
+    /**
+     * Get the pixel color buffer according to the specified cube face and area.
+     * @param face - You can choose which cube face to read
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     * @param width - Area width
+     * @param height - Area height
+     * @param out - Color buffer
+     * @param mipLevel - Set mip level the data want to get from
+     */
+    protected _getPixelBuffer(face: TextureCubeFace | null, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+    private _setWrapMode;
+    protected _getReadFrameBuffer(): WebGLFramebuffer;
+}

package/types/GLTexture2D.d.ts

@@ -0,0 +1,23 @@
+import { IPlatformTexture2D, Texture2D } from "@galacean/engine-core";
+import { GLTexture } from "./GLTexture";
+import { WebGLRenderer } from "./WebGLRenderer";
+/**
+ * Texture 2d in WebGL platform.
+ */
+export declare class GLTexture2D extends GLTexture implements IPlatformTexture2D {
+    /** Backward compatible with WebGL1.0. */
+    private _compressedMipFilled;
+    constructor(rhi: WebGLRenderer, texture2D: Texture2D);
+    /**
+     * {@inheritDoc IPlatformTexture2D.setPixelBuffer}
+     */
+    setPixelBuffer(colorBuffer: ArrayBufferView, mipLevel: number, x: number, y: number, width?: number, height?: number): void;
+    /**
+     * {@inheritDoc IPlatformTexture2D.setImageSource}
+     */
+    setImageSource(imageSource: TexImageSource, mipLevel: number, flipY: boolean, premultiplyAlpha: boolean, x: number, y: number): void;
+    /**
+     * {@inheritDoc IPlatformTexture2D.getPixelBuffer }
+     */
+    getPixelBuffer(x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}

package/types/GLTexture2DArray.d.ts

@@ -0,0 +1,21 @@
+import { IPlatformTexture2DArray, Texture2DArray } from "@galacean/engine-core";
+import { GLTexture } from "./GLTexture";
+import { WebGLRenderer } from "./WebGLRenderer";
+/**
+ * Texture 2D array in WebGL platform.
+ */
+export declare class GLTexture2DArray extends GLTexture implements IPlatformTexture2DArray {
+    constructor(rhi: WebGLRenderer, texture2DArray: Texture2DArray);
+    /**
+     * {@inheritDoc IPlatformTexture2DArray.setPixelBuffer}
+     */
+    setPixelBuffer(offsetIndex: number, colorBuffer: ArrayBufferView, mipLevel: number, x: number, y: number, width?: number, height?: number, length?: number): void;
+    /**
+     * {@inheritDoc IPlatformTexture2DArray.setImageSource}
+     */
+    setImageSource(elementIndex: number, imageSource: TexImageSource, mipLevel: number, flipY: boolean, premultiplyAlpha: boolean, x: number, y: number): void;
+    /**
+     * {@inheritDoc IPlatformTexture2DArray.getPixelBuffer}
+     */
+    getPixelBuffer(elementIndex: number, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}

package/types/GLTextureCube.d.ts

@@ -0,0 +1,23 @@
+import { IPlatformTextureCube, TextureCube, TextureCubeFace } from "@galacean/engine-core";
+import { GLTexture } from "./GLTexture";
+import { WebGLRenderer } from "./WebGLRenderer";
+/**
+ * Cube texture in WebGL platform.
+ */
+export declare class GLTextureCube extends GLTexture implements IPlatformTextureCube {
+    /** Backward compatible with WebGL1.0. */
+    private _compressedFaceFilled;
+    constructor(rhi: WebGLRenderer, textureCube: TextureCube);
+    /**
+     * {@inheritDoc IPlatformTextureCube.setPixelBuffer}
+     */
+    setPixelBuffer(face: TextureCubeFace, colorBuffer: ArrayBufferView, mipLevel: number, x: number, y: number, width?: number, height?: number): void;
+    /**
+     * {@inheritDoc IPlatformTextureCube.setImageSource}
+     */
+    setImageSource(face: TextureCubeFace, imageSource: TexImageSource, mipLevel: number, flipY: boolean, premultiplyAlpha: boolean, x: number, y: number): void;
+    /**
+     * {@inheritDoc IPlatformTextureCube.getPixelBuffer}
+     */
+    getPixelBuffer(face: TextureCubeFace, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}

package/types/WebCanvas.d.ts

@@ -0,0 +1,45 @@
+import { Canvas } from "@galacean/engine-core";
+import { Vector2 } from "@galacean/engine-math";
+type OffscreenCanvas = any;
+/**
+ * The canvas used on the web, which can support HTMLCanvasElement and OffscreenCanvas.
+ */
+export declare class WebCanvas implements Canvas {
+    _webCanvas: HTMLCanvasElement | OffscreenCanvas;
+    private _width;
+    private _height;
+    private _scale;
+    /**
+     * @inheritdoc
+     */
+    get width(): number;
+    set width(value: number);
+    /**
+     * @inheritdoc
+     */
+    get height(): number;
+    set height(value: number);
+    /**
+     * The scale of canvas, the value is visible width/height divide the render width/height.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get scale(): Vector2;
+    set scale(value: Vector2);
+    /**
+     * Resize the rendering size according to the clientWidth and clientHeight of the canvas.
+     * @param pixelRatio - Pixel ratio
+     */
+    resizeByClientSize(pixelRatio?: number): void;
+    /**
+     * Create a web canvas.
+     * @param webCanvas - Web native canvas
+     */
+    constructor(webCanvas: HTMLCanvasElement | OffscreenCanvas);
+    /**
+     * Set scale.
+     * @param x - Scale along the X axis
+     * @param y - Scale along the Y axis
+     */
+    setScale(x: number, y: number): void;
+}
+export {};

package/types/WebGLEngine.d.ts

@@ -0,0 +1,20 @@
+import { Engine } from "@galacean/engine-core";
+import { WebCanvas } from "./WebCanvas";
+import { WebGLRendererOptions } from "./WebGLRenderer";
+type OffscreenCanvas = any;
+/**
+ * WebGL platform engine,support includes WebGL1.0 and WebGL2.0.
+ */
+export declare class WebGLEngine extends Engine {
+    /**
+     * Create an engine suitable for the WebGL platform.
+     * @param canvas - Native web canvas
+     * @param webGLRendererOptions - WebGL renderer options
+     */
+    constructor(canvas: string | HTMLCanvasElement | OffscreenCanvas, webGLRendererOptions?: WebGLRendererOptions);
+    /**
+     * Web canvas.
+     */
+    get canvas(): WebCanvas;
+}
+export {};

package/types/WebGLGraphicDevice.d.ts

@@ -0,0 +1,86 @@
+import { BufferBindFlag, BufferUsage, CameraClearFlags, Canvas, Engine, GLCapabilityType, IHardwareRenderer, IPlatformBuffer, IPlatformRenderTarget, IPlatformTexture2D, IPlatformTextureCube, Mesh, RenderTarget, SubMesh, Texture2D, Texture2DArray, TextureCube } from "@oasis-engine/core";
+import { IPlatformPrimitive } from "@oasis-engine/design";
+import { Color, Vector4 } from "@oasis-engine/math";
+import { GLCapability } from "./GLCapability";
+import { GLRenderStates } from "./GLRenderStates";
+import { GLTexture } from "./GLTexture";
+import { GLTexture2DArray } from "./GLTexture2DArray";
+import { WebGLExtension } from "./type";
+/**
+ * WebGL mode.
+ */
+export declare enum WebGLMode {
+    /** Auto, use WebGL2.0 if support, or will fallback to WebGL1.0. */
+    Auto = 0,
+    /** WebGL2.0. */
+    WebGL2 = 1,
+    /** WebGL1.0, */
+    WebGL1 = 2
+}
+/**
+ * WebGL graphic device options.
+ */
+export interface WebGLGraphicDeviceOptions extends WebGLContextAttributes {
+    /** WebGL mode.*/
+    webGLMode?: WebGLMode;
+}
+/**
+ * WebGL graphic device, including WebGL1.0 and WebGL2.0.
+ */
+export declare class WebGLGraphicDevice implements IHardwareRenderer {
+    private _options;
+    private _gl;
+    private _renderStates;
+    private _extensions;
+    private _capability;
+    private _isWebGL2;
+    private _renderer;
+    private _webCanvas;
+    private _activeTextureID;
+    private _activeTextures;
+    private _lastViewport;
+    private _lastScissor;
+    private _lastClearColor;
+    private _scissorEnable;
+    private _onDeviceLost;
+    private _onDeviceRestored;
+    get isWebGL2(): boolean;
+    get renderer(): string;
+    /**
+     * GL Context
+     * @member {WebGLRenderingContext}
+     */
+    get gl(): (WebGLRenderingContext & WebGLExtension) | WebGL2RenderingContext;
+    get renderStates(): GLRenderStates;
+    get capability(): GLCapability;
+    get canIUseMoreJoints(): boolean;
+    constructor(initializeOptions?: WebGLGraphicDeviceOptions);
+    init(canvas: Canvas, onDeviceLost: () => void, onDeviceRestored: () => void): void;
+    createPlatformPrimitive(primitive: Mesh): IPlatformPrimitive;
+    createPlatformTexture2D(texture2D: Texture2D): IPlatformTexture2D;
+    createPlatformTexture2DArray(texture2D: Texture2DArray): GLTexture2DArray;
+    createPlatformTextureCube(textureCube: TextureCube): IPlatformTextureCube;
+    createPlatformRenderTarget(target: RenderTarget): IPlatformRenderTarget;
+    createPlatformBuffer(type: BufferBindFlag, byteLength: number, bufferUsage?: BufferUsage, data?: ArrayBuffer | ArrayBufferView): IPlatformBuffer;
+    requireExtension(ext: any): any;
+    canIUse(capabilityType: GLCapabilityType): boolean;
+    canIUseCompressedTextureInternalFormat(type: number): boolean;
+    viewport(x: number, y: number, width: number, height: number): void;
+    scissor(x: number, y: number, width: number, height: number): void;
+    colorMask(r: boolean, g: boolean, b: boolean, a: boolean): void;
+    clearRenderTarget(engine: Engine, clearFlags: CameraClearFlags, clearColor: Color): void;
+    drawPrimitive(primitive: Mesh, subPrimitive: SubMesh, shaderProgram: any): void;
+    activeRenderTarget(renderTarget: RenderTarget, viewport: Vector4, mipLevel: number): void;
+    activeTexture(textureID: number): void;
+    bindTexture(texture: GLTexture): void;
+    setGlobalDepthBias(bias: number, slopeBias: number): void;
+    flush(): void;
+    forceLoseDevice(): void;
+    forceRestoreDevice(): void;
+    resetState(): void;
+    protected _initGLState(gl: (WebGLRenderingContext & WebGLExtension) | WebGL2RenderingContext): void;
+    destroy(): void;
+    private _onContextCreationError;
+    private _onWebGLContextLost;
+    private _onWebGLContextRestored;
+}

package/types/WebGLRenderer.d.ts

@@ -0,0 +1,77 @@
+import { CameraClearFlags, Canvas, Engine, GLCapabilityType, IHardwareRenderer, IPlatformRenderTarget, IPlatformTexture2D, IPlatformTextureCube, Mesh, RenderTarget, SubMesh, Texture2D, Texture2DArray, TextureCube } from "@galacean/engine-core";
+import { IPlatformPrimitive } from "@galacean/engine-design";
+import { Color, Vector4 } from "@galacean/engine-math";
+import { GLCapability } from "./GLCapability";
+import { GLRenderStates } from "./GLRenderStates";
+import { GLTexture } from "./GLTexture";
+import { GLTexture2DArray } from "./GLTexture2DArray";
+import { WebGLExtension } from "./type";
+/**
+ * WebGL mode.
+ */
+export declare enum WebGLMode {
+    /** Auto, use WebGL2.0 if support, or will fallback to WebGL1.0. */
+    Auto = 0,
+    /** WebGL2.0. */
+    WebGL2 = 1,
+    /** WebGL1.0, */
+    WebGL1 = 2
+}
+/**
+ * WebGL renderer options.
+ */
+export interface WebGLRendererOptions extends WebGLContextAttributes {
+    /** WebGL mode.*/
+    webGLMode?: WebGLMode;
+}
+/**
+ * WebGL renderer, including WebGL1.0 and WebGL2.0.
+ */
+export declare class WebGLRenderer implements IHardwareRenderer {
+    _currentBind: any;
+    private _options;
+    private _gl;
+    private _renderStates;
+    private _extensions;
+    private _capability;
+    private _isWebGL2;
+    private _renderer;
+    private _webCanvas;
+    private _activeTextureID;
+    private _activeTextures;
+    private _lastViewport;
+    private _lastScissor;
+    private _lastClearColor;
+    private _scissorEnable;
+    get isWebGL2(): boolean;
+    get renderer(): string;
+    /**
+     * GL Context
+     * @member {WebGLRenderingContext}
+     */
+    get gl(): (WebGLRenderingContext & WebGLExtension) | WebGL2RenderingContext;
+    get renderStates(): GLRenderStates;
+    get capability(): GLCapability;
+    get canIUseMoreJoints(): boolean;
+    constructor(initializeOptions?: WebGLRendererOptions);
+    init(canvas: Canvas): void;
+    createPlatformPrimitive(primitive: Mesh): IPlatformPrimitive;
+    createPlatformTexture2D(texture2D: Texture2D): IPlatformTexture2D;
+    createPlatformTexture2DArray(texture2D: Texture2DArray): GLTexture2DArray;
+    createPlatformTextureCube(textureCube: TextureCube): IPlatformTextureCube;
+    createPlatformRenderTarget(target: RenderTarget): IPlatformRenderTarget;
+    requireExtension(ext: any): any;
+    canIUse(capabilityType: GLCapabilityType): boolean;
+    canIUseCompressedTextureInternalFormat(type: number): boolean;
+    viewport(x: number, y: number, width: number, height: number): void;
+    scissor(x: number, y: number, width: number, height: number): void;
+    colorMask(r: any, g: any, b: any, a: any): void;
+    clearRenderTarget(engine: Engine, clearFlags: CameraClearFlags, clearColor: Color): void;
+    drawPrimitive(primitive: Mesh, subPrimitive: SubMesh, shaderProgram: any): void;
+    activeRenderTarget(renderTarget: RenderTarget, viewport: Vector4, mipLevel: number): void;
+    activeTexture(textureID: number): void;
+    bindTexture(texture: GLTexture): void;
+    setGlobalDepthBias(bias: number, slopeBias: number): void;
+    flush(): void;
+    destroy(): void;
+}

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export { GLCompressedTextureInternalFormat } from "./type";
+export { WebCanvas } from "./WebCanvas";
+export { WebGLEngine } from "./WebGLEngine";
+export { WebGLMode, WebGLRenderer } from "./WebGLRenderer";
+export type { WebGLRendererOptions } from "./WebGLRenderer";

package/types/type.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Smoothing plug-in.
+ * */
+export interface WebGLExtension {
+    MAX_DRAW_BUFFERS: GLenum;
+    UNSIGNED_INT_24_8: GLenum;
+    MAX_SAMPLES: GLenum;
+    RGBA8: GLenum;
+    RGBA16F: GLenum;
+    RGBA32F: GLenum;
+    DEPTH_COMPONENT32F: GLenum;
+    READ_FRAMEBUFFER: GLenum;
+    DRAW_FRAMEBUFFER: GLenum;
+    createVertexArray(): WebGLVertexArrayObject | null;
+    deleteVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
+    isVertexArray(vertexArray: WebGLVertexArrayObject | null): GLboolean;
+    bindVertexArray(array: WebGLVertexArrayObject | null): void;
+    renderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
+    blitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum): void;
+    drawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei): void;
+    drawElementsInstanced(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei): void;
+    vertexAttribDivisor(index: GLuint, divisor: GLuint): void;
+    drawBuffers(buffers: Iterable<GLenum>): void;
+}
+export interface TextureFormatDetail {
+    internalFormat: GLint;
+    baseFormat?: GLenum;
+    dataType?: GLenum;
+    isCompressed: boolean;
+    attachment?: GLenum;
+}
+/**
+ * @deprecated
+ */
+export declare enum GLCompressedTextureInternalFormat {
+    RGBA_ASTC_4X4_KHR = 37808,
+    RGBA_ASTC_5X4_KHR = 37809,
+    RGBA_ASTC_5X5_KHR = 37810,
+    RGBA_ASTC_6X5_KHR = 37811,
+    RGBA_ASTC_6X6_KHR = 37812,
+    RGBA_ASTC_8X5_KHR = 37813,
+    RGBA_ASTC_8X6_KHR = 37814,
+    RGBA_ASTC_8X8_KHR = 37815,
+    RGBA_ASTC_10X5_KHR = 37816,
+    RGBA_ASTC_10X6_KHR = 37817,
+    RGBA_ASTC_10X8_KHR = 37818,
+    RGBA_ASTC_10X10_KHR = 37819,
+    RGBA_ASTC_12X10_KHR = 37820,
+    RGBA_ASTC_12X12_KHR = 37821,
+    SRGB8_ALPHA8_ASTC_4X4_KHR = 37840,
+    SRGB8_ALPHA8_ASTC_5X4_KHR = 37841,
+    SRGB8_ALPHA8_ASTC_5X5_KHR = 37842,
+    SRGB8_ALPHA8_ASTC_6X5_KHR = 37843,
+    SRGB8_ALPHA8_ASTC_6X6_KHR = 37844,
+    SRGB8_ALPHA8_ASTC_8X5_KHR = 37845,
+    SRGB8_ALPHA8_ASTC_8X6_KHR = 37846,
+    SRGB8_ALPHA8_ASTC_8X8_KHR = 37847,
+    SRGB8_ALPHA8_ASTC_10X5_KHR = 37848,
+    SRGB8_ALPHA8_ASTC_10X6_KHR = 37849,
+    SRGB8_ALPHA8_ASTC_10X8_KHR = 37850,
+    SRGB8_ALPHA8_ASTC_10X10_KHR = 37851,
+    SRGB8_ALPHA8_ASTC_12X10_KHR = 37852,
+    SRGB8_ALPHA8_ASTC_12X12_KHR = 37853,
+    RGB_ETC1_WEBGL = 36196,
+    R11_EAC = 37488,
+    SIGNED_R11_EAC = 37489,
+    RG11_EAC = 37490,
+    SIGNED_RG11_EAC = 37491,
+    RGB8_ETC2 = 37492,
+    SRGB8_ETC2 = 37493,
+    RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 37494,
+    SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 37495,
+    RGBA8_ETC2_EAC = 37496,
+    SRGB8_ALPHA8_ETC2_EAC = 37497,
+    RGB_PVRTC_4BPPV1_IMG = 35840,
+    RGB_PVRTC_2BPPV1_IMG = 35841,
+    RGBA_PVRTC_4BPPV1_IMG = 35842,
+    RGBA_PVRTC_2BPPV1_IMG = 35843,
+    RGB_S3TC_DXT1_EXT = 33776,
+    RGBA_S3TC_DXT1_EXT = 33777,
+    RGBA_S3TC_DXT3_EXT = 33778,
+    RGBA_S3TC_DXT5_EXT = 33779
+}