ris-framework 0.1.0-dev.6 → 0.1.0-dev.7

package/dist/webgl/render-pipelines/sprite/WebGlSpriteRenderPipeline.d.ts

@@ -0,0 +1,40 @@
+import type { IFramework, ISampler, ISpriteRenderPipeline, ITexture2D, IUniformBuffer, IVertexBuffer } from "ris-framework-api";
+import { AWebGlRenderPipeline } from "../AWebGlRenderPipeline.js";
+import { type IIndexBuffer } from "ris-framework-api";
+/**
+ * The WebGL implementation of the sprite render pipeline.
+ */
+export declare class WebGlSpriteRenderPipeline extends AWebGlRenderPipeline implements ISpriteRenderPipeline {
+    private static readonly CAMERA_BINDING_POINT;
+    private _texture;
+    private _sampler?;
+    private _projectionViewBuffer;
+    private _cameraBlockIndex;
+    private _buffersArray;
+    private _lastVertexBuffer;
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param projectionViewBuffer The projection view buffer.
+     */
+    constructor(framework: IFramework, projectionViewBuffer: IUniformBuffer);
+    /** @inheritdoc */
+    get projectionViewBuffer(): IUniformBuffer;
+    /** @inheritdoc */
+    set projectionViewBuffer(value: IUniformBuffer);
+    /** @inheritdoc */
+    get spriteTexture(): ITexture2D;
+    /** @inheritdoc */
+    set spriteTexture(value: ITexture2D);
+    /** @inheritdoc */
+    get textureSampler(): ISampler | undefined;
+    set textureSampler(value: ISampler | undefined);
+    /** @inheritdoc */
+    initialize(): void;
+    private _createResources;
+    /** @inheritdoc */
+    protected _provideBuffers(): WebGLBuffer[] | undefined | null;
+    /** @inheritdoc */
+    render(vertexBuffer: IVertexBuffer, indexBuffer: IIndexBuffer, indicesCount?: number, indicesOffset?: number): void;
+}
+//# sourceMappingURL=WebGlSpriteRenderPipeline.d.ts.map

package/dist/webgl/render-pipelines/sprite/WebGlSpriteRenderPipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlSpriteRenderPipeline.d.ts","sourceRoot":"","sources":["../../../../src/webgl/render-pipelines/sprite/WebGlSpriteRenderPipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,UAAU,EACV,cAAc,EACd,aAAa,EAChB,MAAM,mBAAmB,CAAC;AAO3B,OAAO,EAAC,oBAAoB,EAAC,MAAM,4BAA4B,CAAC;AAEhE,OAAO,EAAC,KAAK,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAGrE;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,oBAAqB,YAAW,qBAAqB;IAEhG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAa;IAEzD,OAAO,CAAC,QAAQ,CAAyB;IACzC,OAAO,CAAC,QAAQ,CAAC,CAAe;IAChC,OAAO,CAAC,qBAAqB,CAAqB;IAClD,OAAO,CAAC,iBAAiB,CAAc;IACvC,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,iBAAiB,CAAkC;IAE3D;;;;OAIG;gBACS,SAAS,EAAE,UAAU,EAAE,oBAAoB,EAAE,cAAc;IAKvE,kBAAkB;IAClB,IAAW,oBAAoB,IAAI,cAAc,CAEhD;IAED,kBAAkB;IAClB,IAAW,oBAAoB,CAAC,KAAK,EAAE,cAAc,EAEpD;IAED,kBAAkB;IAClB,IAAW,aAAa,IAAI,UAAU,CAErC;IAED,kBAAkB;IAClB,IAAW,aAAa,CAAC,KAAK,EAAE,UAAU,EAEzC;IAED,kBAAkB;IAClB,IAAW,cAAc,IAAI,QAAQ,GAAG,SAAS,CAEhD;IAED,IAAW,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAEpD;IAED,kBAAkB;IACF,UAAU,IAAI,IAAI;IASlC,OAAO,CAAC,gBAAgB;IAUxB,kBAAkB;IAClB,SAAS,CAAC,eAAe,IAAI,WAAW,EAAE,GAAG,SAAS,GAAG,IAAI;IAS7D,kBAAkB;IACX,MAAM,CAAC,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,GAAE,MAAW,EAAE,aAAa,GAAE,MAAU,GAAG,IAAI;CA4CpI"}

package/dist/webgl/rendering/webgl-vertex-attribute.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The WebGL implementation of a vertex attribute.
+ */
+export declare class WebGLVertexAttribute {
+    gl: WebGL2RenderingContext;
+    constructor(gl: WebGL2RenderingContext);
+    /** @inheritdoc */
+    initialize(): void;
+}
+//# sourceMappingURL=webgl-vertex-attribute.d.ts.map

package/dist/webgl/rendering/webgl-vertex-attribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-vertex-attribute.d.ts","sourceRoot":"","sources":["../../../src/webgl/rendering/webgl-vertex-attribute.ts"],"names":[],"mappings":"AACA;;GAEG;AACH,qBAAa,oBAAoB;IAElB,EAAE,EAAE,sBAAsB;gBAA1B,EAAE,EAAE,sBAAsB;IAKrC,kBAAkB;IAClB,UAAU,IAAI,IAAI;CAGrB"}

package/dist/webgl/rendering/webgl-vertex-buffer-layout.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The WebGL implementation of a vertex buffer layout.
+ */
+export declare class WebGLVertexBufferLayout {
+    private readonly _gl;
+    private _bufferTarget;
+    /**
+     * The constructor for the WebGLVertexBufferLayout class.
+     * @param gl The WebGL2 rendering context.
+     * @param buffer The WebGL buffer that is used to store the vertex data. This is used to determine the buffer target for the vertex buffer layout.
+     * @param bufferTarget The buffer target for the vertex buffer layout. This is used to determine how the vertex buffer is bound to the WebGL context. This is typically either gl.ARRAY_BUFFER or gl.ELEMENT_ARRAY_BUFFER.
+     */
+    constructor(gl: WebGL2RenderingContext, buffer: WebGLBuffer, bufferTarget: number);
+    /**
+     * The WebGL buffer that is used to store the vertex data.
+     */
+    buffer: WebGLBuffer | null;
+    /**
+     * Binds the vertex buffer to the WebGL context using the buffer target specified in the constructor.
+     */
+    bindBuffer(): void;
+    /**
+     * Initializes the vertex buffer layout. This method should be called after the buffer has been created and bound.
+     */
+    initialize(): void;
+}
+//# sourceMappingURL=webgl-vertex-buffer-layout.d.ts.map

package/dist/webgl/rendering/webgl-vertex-buffer-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-vertex-buffer-layout.d.ts","sourceRoot":"","sources":["../../../src/webgl/rendering/webgl-vertex-buffer-layout.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,uBAAuB;IAEhC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAyB;IAC7C,OAAO,CAAC,aAAa,CAAa;IAElC;;;;;OAKG;gBAEC,EAAE,EAAE,sBAAsB,EAC1B,MAAM,EAAE,WAAW,EACnB,YAAY,EAAE,MAAM;IAOxB;;OAEG;IACI,MAAM,EAAE,WAAW,GAAG,IAAI,CAAQ;IAEzC;;OAEG;IACI,UAAU,IAAI,IAAI;IAIzB;;OAEG;IACI,UAAU,IAAI,IAAI;CAwB5B"}

package/dist/webgl/sampler/webgl-sampler.d.ts

@@ -0,0 +1,48 @@
+import { SamplerDescriptor } from "../../core/rendering/sampler/sampler-descriptor";
+import type { WebGlGraphicsDevice } from "../WebGlGraphicsDevice.js";
+import { type ISampler, MipMapSamplerFilter, SamplerAddressMode, SamplerFilter } from "ris-framework-api";
+/**
+ * The WebGL implementation of the ISampler interface.
+ */
+export declare class WebGlSampler implements ISampler {
+    private static _id;
+    private readonly _gl;
+    private _minFilter;
+    private _magFilter;
+    private _mipMapFilter;
+    private _addressModueU;
+    private _addressModueV;
+    private _addressModueW;
+    /**
+     * Creates an instance of WebGlSampler.
+     * @param graphicsDevice The WebGL graphics device that will be used to create the sampler. The graphics device provides access to the WebGL rendering context and other resources needed for creating and managing the sampler.
+     * @param descriptor The descriptor containing configuration details for the sampler. This parameter is optional, and if not provided, default values will be used for the sampler configuration. The descriptor allows you to specify various properties of the sampler, such as filtering methods and address modes, which determine how textures are sampled in the shader.
+     */
+    constructor(graphicsDevice: WebGlGraphicsDevice, descriptor?: SamplerDescriptor);
+    /** @inheritDoc */
+    readonly id: number;
+    /** @inheritdoc */
+    get minFilter(): SamplerFilter;
+    /** @inheritdoc */
+    get magFilter(): SamplerFilter;
+    /** @inheritdoc */
+    get mipmapFilter(): MipMapSamplerFilter;
+    /** @inheritdoc */
+    get addressModeU(): SamplerAddressMode;
+    /** @inheritdoc */
+    get addressModeV(): SamplerAddressMode;
+    /** @inheritdoc */
+    get addressModeW(): SamplerAddressMode;
+    /** @inheritdoc */
+    get handle(): any;
+    /**
+     * The handle of the sampler.
+     * This is used to bind the sampler to the graphics pipeline.
+     */
+    glSampler: globalThis.WebGLSampler;
+    /** @inheritdoc */
+    _createSampler(): void;
+    /** @inheritdoc */
+    dispose(): void;
+}
+//# sourceMappingURL=webgl-sampler.d.ts.map

package/dist/webgl/sampler/webgl-sampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-sampler.d.ts","sourceRoot":"","sources":["../../../src/webgl/sampler/webgl-sampler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iDAAiD,CAAC;AAEpF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAC,KAAK,QAAQ,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAExG;;GAEG;AACH,qBAAa,YAAa,YAAW,QAAQ;IAEzC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAyB;IAC7C,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,cAAc,CAAmC;IACzD,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,cAAc,CAAoC;IAE1D;;;;OAIG;gBACS,cAAc,EAAE,mBAAmB,EAAE,UAAU,CAAC,EAAE,iBAAiB;IAiB/E,kBAAkB;IAClB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,kBAAkB;IAClB,IAAW,SAAS,kBAEnB;IAED,kBAAkB;IAClB,IAAW,SAAS,kBAEnB;IAED,kBAAkB;IAClB,IAAW,YAAY,wBAEtB;IAED,kBAAkB;IAClB,IAAW,YAAY,uBAEtB;IAED,kBAAkB;IAClB,IAAW,YAAY,uBAEtB;IAED,kBAAkB;IAClB,IAAW,YAAY,uBAEtB;IAED,kBAAkB;IAClB,IAAW,MAAM,IAAI,GAAG,CAEvB;IAED;;;OAGG;IACI,SAAS,EAAE,UAAU,CAAC,YAAY,CAAS;IAElD,kBAAkB;IACX,cAAc,IAAI,IAAI;IAc7B,kBAAkB;IACX,OAAO,IAAI,IAAI;CAOzB"}

package/dist/webgl/shader/WebGlShaderModule.d.ts

@@ -0,0 +1,34 @@
+import { type IFramework, type IShaderModule, ShaderStage } from "ris-framework-api";
+/**
+ * The WebGL shader module.
+ */
+export declare class WebGlShaderModule implements IShaderModule {
+    private readonly _graphicsDevice;
+    private readonly _gl;
+    private _program?;
+    /**
+     * The constructor of the WebGL shader module.
+     * @param framework The framework.
+     * @param shaderFilePath
+     */
+    constructor(framework: IFramework, shaderFilePath: string);
+    /** @inheritDoc */
+    stages: ShaderStage[];
+    /** @inheritDoc */
+    nativeHandle?: any;
+    /**
+     * Tries to framework shader.
+     * These shaders are part of framework.
+     * @param id The id of internal shader.
+     */
+    private _tryResolveFrameworkShader;
+    /**
+     * The program of this shader module
+     */
+    get program(): WebGLProgram | null | undefined;
+    private _loadShaders;
+    /** @inheritdoc */
+    dispose(): void;
+}
+export default WebGlShaderModule;
+//# sourceMappingURL=WebGlShaderModule.d.ts.map

package/dist/webgl/shader/WebGlShaderModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlShaderModule.d.ts","sourceRoot":"","sources":["../../../src/webgl/shader/WebGlShaderModule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,WAAW,EAAC,MAAM,mBAAmB,CAAC;AASnF;;GAEG;AACH,qBAAa,iBAAkB,YAAW,aAAa;IAEnD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsB;IACtD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAyB;IAC7C,OAAO,CAAC,QAAQ,CAAC,CAAe;IAEhC;;;;OAIG;gBACgB,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM;IAOhE,kBAAkB;IACX,MAAM,EAAE,WAAW,EAAE,CAAM;IAElC,kBAAkB;IACX,YAAY,CAAC,EAAE,GAAG,CAAC;IAE1B;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAelC;;OAEG;IACH,IAAW,OAAO,IAAI,YAAY,GAAG,IAAI,GAAG,SAAS,CAEpD;IAED,OAAO,CAAC,YAAY;IAkCpB,kBAAkB;IACX,OAAO,IAAI,IAAI;CAOzB;AAED,eAAe,iBAAiB,CAAA"}

package/dist/webgl/shader/WebGlShaderModuleLoader.d.ts

@@ -0,0 +1,19 @@
+import type { IFramework, IShaderModule } from "ris-framework-api";
+/**
+ * The content WebGL implementation of ShaderContentModule.
+ */
+export declare class WebGlShaderModuleLoader {
+    private readonly _shaderModules;
+    private readonly _framework;
+    /**
+     * The WebGL shader content module.
+     * @param framework The framework.
+     */
+    constructor(framework: IFramework);
+    /**
+     * The content types provided by this content module.
+     * @param assetFilePathOrIdentifier The asset file path or identifier of the content to load.
+     */
+    load(assetFilePathOrIdentifier: string): IShaderModule;
+}
+//# sourceMappingURL=WebGlShaderModuleLoader.d.ts.map

package/dist/webgl/shader/WebGlShaderModuleLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlShaderModuleLoader.d.ts","sourceRoot":"","sources":["../../../src/webgl/shader/WebGlShaderModuleLoader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAE,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAGjE;;GAEG;AACH,qBAAa,uBAAuB;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwE;IACvG,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IAExC;;;OAGG;gBACgB,SAAS,EAAE,UAAU;IAIxC;;;OAGG;IACI,IAAI,CAAC,yBAAyB,EAAE,MAAM,GAAG,aAAa;CAgBhE"}

package/dist/webgl/swap-chain/WebGlSwapChain.d.ts

@@ -0,0 +1,27 @@
+import { vec2 } from "gl-matrix";
+import { type IGraphicsDevice, type ISwapChain, TextureFormat } from "ris-framework-api";
+/**
+ * The WebGL implementation of the ISwapChain interface, which manages the swap chain for rendering operations in a WebGL context.
+ */
+export declare class WebGlSwapChain implements ISwapChain {
+    private readonly _canvas;
+    private readonly _graphicsDevice;
+    private _backBufferSize;
+    /**
+     * The WebGLSwapChain constructor.
+     * @param canvas The HTML canvas element that the swap chain will use for rendering.
+     * @param graphicsDevice The graphics device.
+     */
+    constructor(canvas: HTMLCanvasElement, graphicsDevice: IGraphicsDevice);
+    /** @inheritdoc */
+    get textureFormat(): TextureFormat;
+    /** @inheritdoc */
+    get backBufferSize(): vec2;
+    /** @inheritdoc */
+    resize(_width: number, _height: number): void;
+    /** @inheritdoc */
+    present(): void;
+    /** @inheritdoc */
+    dispose(): void;
+}
+//# sourceMappingURL=WebGlSwapChain.d.ts.map

package/dist/webgl/swap-chain/WebGlSwapChain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlSwapChain.d.ts","sourceRoot":"","sources":["../../../src/webgl/swap-chain/WebGlSwapChain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAC,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAGvF;;GAEG;AACH,qBAAa,cAAe,YAAW,UAAU;IAE7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsB;IAEtD,OAAO,CAAC,eAAe,CAAO;IAE9B;;;;OAIG;gBACgB,MAAM,EAAE,iBAAiB,EAAE,cAAc,EAAE,eAAe;IAW7E,kBAAkB;IAClB,IAAW,aAAa,IAAI,aAAa,CAExC;IAED,kBAAkB;IAClB,IAAW,cAAc,IAAI,IAAI,CAEhC;IAED,kBAAkB;IACX,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAIpD,kBAAkB;IACX,OAAO,IAAI,IAAI;IAKtB,kBAAkB;IACX,OAAO,IAAI,IAAI;CAGzB"}

package/dist/webgl/texture/WebGlTexture2D.d.ts

@@ -0,0 +1,37 @@
+import { TextureDescriptor, type IFramework, type ITextureView, type TextureViewDescriptor } from "ris-framework-api";
+import { ATexture2D } from "../../core/rendering/texture/texture.js";
+/**
+ * The WebGL implementation of ITexture2D.
+ */
+export declare class WebGlTexture2D extends ATexture2D {
+    private readonly _framework;
+    private readonly _graphicsDevice;
+    private readonly _gl;
+    private _glTexture;
+    /**
+     * The constructor.
+     * @param _framework The framework instance.
+     * @param textureDescriptor The texture descriptor.
+     */
+    constructor(_framework: IFramework, textureDescriptor: TextureDescriptor);
+    /**
+     * Gets the underlying WebGL texture.
+     * @returns The WebGL texture.
+     */
+    get glTexture(): WebGLTexture;
+    /** @inheritdoc */
+    initialize(): void;
+    /** @inheritdoc */
+    createView(_descriptor?: TextureViewDescriptor): ITextureView;
+    /** @inheritdoc */
+    dispose(): void;
+    private static _defaultFilled;
+    /**
+     * Creates a default 1x1 white texture if it doesn't already exist and returns it.
+     * This can be used as a placeholder texture when a texture is expected but not available.
+     * @param framework The framework instance.
+     * @returns The default 1x1 white texture.
+     */
+    static getOrCreateDefault(framework: IFramework): WebGlTexture2D;
+}
+//# sourceMappingURL=WebGlTexture2D.d.ts.map

package/dist/webgl/texture/WebGlTexture2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlTexture2D.d.ts","sourceRoot":"","sources":["../../../src/webgl/texture/WebGlTexture2D.ts"],"names":[],"mappings":"AACA,OAAO,EACH,iBAAiB,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC7B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAC,UAAU,EAAC,MAAM,yCAAyC,CAAC;AAGnE;;GAEG;AACH,qBAAa,cAAe,SAAQ,UAAU;IAYtC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAV/B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsB;IACtD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAyB;IAC7C,OAAO,CAAC,UAAU,CAA6B;IAE/C;;;;OAIG;gBAEkB,UAAU,EAAE,UAAU,EACvC,iBAAiB,EAAE,iBAAiB;IAOxC;;;OAGG;IACH,IAAW,SAAS,IAAI,YAAY,CAEnC;IAED,kBAAkB;IACX,UAAU,IAAI,IAAI;IA0CzB,kBAAkB;IACX,UAAU,CAAC,WAAW,CAAC,EAAE,qBAAqB,GAAG,YAAY;IAKpE,kBAAkB;IACX,OAAO,IAAI,IAAI;IAetB,OAAO,CAAC,MAAM,CAAC,cAAc,CAA+B;IAE5D;;;;;OAKG;WACW,kBAAkB,CAAC,SAAS,EAAE,UAAU,GAAG,cAAc;CAiB1E"}

package/dist/webgl/texture/WebGlTextureFactory.d.ts

@@ -0,0 +1,17 @@
+import { Color, type IFramework, type ITexture2D, type ITextureFactory, TextureDescriptor, TextureFormat } from "ris-framework-api";
+import { type IKtx2Texture } from "ris-ktx2-api";
+export declare class WebGlTextureFactory implements ITextureFactory {
+    private readonly _framework;
+    /**
+     * The constructor for the WebGLTextureFactory class.
+     * @param _framework The framework instance.
+     */
+    constructor(_framework: IFramework);
+    /** @inheritDoc */
+    createFromKtx2(ktxTexture: IKtx2Texture, descriptor?: TextureDescriptor): ITexture2D;
+    /** @inheritdoc */
+    create(width: number, height: number, data?: Uint8Array | HTMLImageElement, channels?: number, label?: string | null | undefined, textureUsage?: number, textureFormat?: TextureFormat, useMipMaps?: boolean): ITexture2D;
+    /** @inheritdoc */
+    createEmpty(width: number, height: number, color?: Color | null, textureUsage?: number, textureFormat?: TextureFormat, label?: string | null, useMipmap?: boolean): ITexture2D;
+}
+//# sourceMappingURL=WebGlTextureFactory.d.ts.map

package/dist/webgl/texture/WebGlTextureFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlTextureFactory.d.ts","sourceRoot":"","sources":["../../../src/webgl/texture/WebGlTextureFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,iBAAiB,EACjB,aAAa,EAGhB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAC,KAAK,YAAY,EAAqE,MAAM,cAAc,CAAC;AAGnH,qBAAa,mBAAoB,YAAW,eAAe;IAM3C,OAAO,CAAC,QAAQ,CAAC,UAAU;IAJvC;;;OAGG;gBAC0B,UAAU,EAAE,UAAU;IAGnD,kBAAkB;IACX,cAAc,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,iBAAiB,GAAG,UAAU;IAsE3F,kBAAkB;IACX,MAAM,CACT,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAC7B,IAAI,CAAC,EAAE,UAAU,GAAG,gBAAgB,EACpC,QAAQ,GAAE,MAAU,EACpB,KAAK,GAAE,MAAM,GAAG,IAAI,GAAG,SAAgB,EACvC,YAAY,SAAuD,EACnE,aAAa,gBAA4B,EACzC,UAAU,UAAQ,GAAG,UAAU;IAgCnC,kBAAkB;IACX,WAAW,CACd,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAC7B,KAAK,GAAE,KAAK,GAAG,IAAW,EAC1B,YAAY,SAAuD,EACnE,aAAa,gBAA0B,EACvC,KAAK,GAAE,MAAM,GAAG,IAAW,EAC3B,SAAS,UAAQ,GAAG,UAAU;CA0CrC"}

package/dist/webgl/utilities/WebGlBufferUtilities.d.ts

@@ -0,0 +1,45 @@
+import type { BufferUsage } from "ris-framework-api";
+/**
+ * This file contains utility functions for working with WebGL buffers,
+ * such as creating and managing vertex buffers, index buffers, and uniform buffers.
+ * It provides a higher-level abstraction over the raw WebGL API to simplify buffer management in a WebGL application.
+ */
+export declare class WebGlBufferUtilities {
+    /**
+     * Creates a vertex buffer in WebGL with the given data and usage.
+     * @param gl The WebGL2RenderingContext to use for creating the buffer.
+     * @param dataOrByteSize The data to upload to the vertex buffer, typically a Float32Array containing vertex attributes, or a number representing the byte size of the buffer to create.
+     * @param usage The intended usage of the buffer, which can affect how the buffer is created and optimized by the graphics API. For example, a vertex buffer may be optimized for use as a vertex buffer in rendering operations.
+     * @returns The created WebGLBuffer object that represents the vertex buffer in WebGL.
+     */
+    createVertexBuffer(gl: WebGL2RenderingContext, dataOrByteSize: Float32Array | number, usage: BufferUsage): WebGLBuffer;
+    /**
+     * Creates an index buffer in WebGL with the given data and usage.
+     * @param gl The WebGL2RenderingContext to use for creating the buffer.
+     * @param dataOrByteSize The data to upload to the index buffer, typically a Uint16Array or Uint32Array containing index data, or a number representing the byte size of the buffer to create.
+     * @param usage The intended usage of the buffer, which can affect how the buffer is created and optimized by the graphics API. For example, an index buffer may be optimized for use as an index buffer in rendering operations.
+     * @param label The label.
+     * @returns The created WebGLBuffer object that represents the index buffer in WebGL.
+     */
+    createIndexBuffer(gl: WebGL2RenderingContext, dataOrByteSize: Uint16Array | Uint32Array | number, usage: BufferUsage, label?: string): WebGLBuffer;
+    /**
+     * Creates a uniform buffer in WebGL with the given data and usage.
+     * @param gl The WebGL2RenderingContext to use for creating the buffer.
+     * @param dataOrByteSize The data to upload to the uniform buffer, typically an ArrayBuffer or a TypedArray containing uniform data, or a number representing the byte size of the buffer to create.
+     * @param usage The intended usage of the buffer, which can affect how the buffer is created and optimized by the graphics API. For example, a uniform buffer may be optimized for use as a uniform buffer in rendering operations.
+     * @param label An optional label for the buffer, which can be used for debugging purposes to identify the buffer in graphics debugging tools.
+    * @returns The created WebGLBuffer object that represents the uniform buffer in WebGL.
+     */
+    createUniformBuffer(gl: WebGL2RenderingContext, dataOrByteSize: ArrayBuffer | ArrayBufferView | number, usage: BufferUsage, label?: string): WebGLBuffer;
+    /**
+     * Updates the vertex buffer.
+     * @param gl
+     * @param buffer
+     * @param data The data.
+     * @param destOffset Offset into destination.
+     * @param srcOffset
+     * @param srcLength
+     */
+    updateVertexBuffer(gl: WebGL2RenderingContext, buffer: WebGLBuffer, data: Float32Array, destOffset?: number, srcOffset?: number, srcLength?: number): void;
+}
+//# sourceMappingURL=WebGlBufferUtilities.d.ts.map

package/dist/webgl/utilities/WebGlBufferUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlBufferUtilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/WebGlBufferUtilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAEnD;;;;GAIG;AACH,qBAAa,oBAAoB;IAE7B;;;;;;OAMG;IACI,kBAAkB,CAAC,EAAE,EAAE,sBAAsB,EAAE,cAAc,EAAE,YAAY,GAAG,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,WAAW;IAiB7H;;;;;;;OAOG;IACI,iBAAiB,CAAC,EAAE,EAAE,sBAAsB,EAC1B,cAAc,EAAE,WAAW,GAAG,WAAW,GAAG,MAAM,EAClD,KAAK,EAAE,WAAW,EAClB,KAAK,CAAC,EAAE,MAAM,GACpC,WAAW;IAyBd;;;;;;;OAOG;IACI,mBAAmB,CAAC,EAAE,EAAE,sBAAsB,EAAE,cAAc,EAAE,WAAW,GAAG,eAAe,GAAG,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,WAAW;IAqB/J;;;;;;;;OAQG;IACI,kBAAkB,CACrB,EAAE,EAAE,sBAAsB,EAC1B,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,YAAY,EAClB,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAU,EACrB,SAAS,GAAE,MAAU;CAQ5B"}

package/dist/webgl/utilities/WebGlConverter.d.ts

@@ -0,0 +1,124 @@
+import { Culling } from "../../core/renderer/enums";
+import { BlendFactor, BlendOperation } from "../../core/rendering/blending/enums";
+import { CullMode, FrontFace, PrimitiveTopology } from "../../core/rendering/primitive/enums";
+import { VertexFormat } from "../../VertexFormat.js";
+import { BufferUsage, MipMapSamplerFilter, SamplerAddressMode, SamplerFilter, TextureFormat } from "ris-framework-api";
+export declare class WebGlConverter {
+    /** BC3 */
+    private static GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+    /** BC7 */
+    private static GL_COMPRESSED_RGBA_BPTC_UNORM;
+    /** ETC2 */
+    private static GL_COMPRESSED_RGBA8_ETC2_EAC;
+    private static GL_COMPRESSED_RGBA_ASTC_4x4_KHR;
+    /**
+     * Converts PrimitiveTopology to WebGL enum.
+     * @param topology The PrimitiveTopology.
+     * @returns The WebGL enum.
+     */
+    static convertPrimitiveType(topology: PrimitiveTopology): number;
+    /**
+     * Converts CullMode to WebGL enum.
+     * @param cullFace The CullMode.
+     * @return The WebGL enum.
+     */
+    static convertCullFace(cullFace: CullMode): number;
+    /**
+     * Converts FrontFace to WebGL enum.
+     * @param frontFace The FrontFace.
+     * @return The WebGL enum.
+     */
+    static convertFrontFace(frontFace: FrontFace): number;
+    /**
+     * Converts BufferUsage to WebGL enum.
+     * @param usage The BufferUsage.
+     * @return The WebGL enum.
+     */
+    static convertBufferUsage(usage: BufferUsage): GLenum;
+    /**
+     * Conversts BlendOperation to WebGL enum.
+     * @parma gl The WebGL2RenderingContext.
+     * @param blendOperation The BlendOperation.
+     * @return The WebGL enum.
+     */
+    static convertBlendOperation(gl: WebGL2RenderingContext, blendOperation: BlendOperation): GLenum;
+    /**
+     * Converts BlendFactor to WebGL enum.
+     * @param gl The WebGL2RenderingContext.
+     * @param blendingFactor The BlendFactor.
+     * @returns The WebGL enum.
+     */
+    static convertBlendFactor(gl: WebGL2RenderingContext, blendingFactor: BlendFactor): number;
+    /**
+     * Converts Culling to WebGL enum.
+     * @param gl The WebGL2RenderingContext.
+     * @param culling The Culling.
+     * @returns The WebGL enum.
+     */
+    static convertCulling(gl: WebGL2RenderingContext, culling: Culling): number;
+    /**
+     * Converts TextureFormat to WebGL internal format, format, and type.
+     * @param gl The WebGL2RenderingContext.
+     * @param textureFormat The TextureFormat.
+     * @returns The WebGL internal format.
+     */
+    static convertInternalFormat(gl: WebGL2RenderingContext, textureFormat: TextureFormat): number;
+    /**
+     * Converts TextureFormat to WebGL format.
+     * @param gl The WebGL2RenderingContext.
+     * @param textureFormat The TextureFormat.
+     * @returns The WebGL format.
+     */
+    static convertToPixelFormat(gl: WebGL2RenderingContext, textureFormat: TextureFormat): number;
+    /**
+     * Converts TextureFormat to WebGL texture type.
+     * @param gl The WebGL2RenderingContext.
+     * @param textureFormat The TextureFormat.
+     * @returns The WebGL texture type.
+     */
+    static convertToTextureType(gl: WebGL2RenderingContext, textureFormat: TextureFormat): number;
+    /**
+     * Converts SamplerMinFilter to WebGL enum.
+     * @param gl The WebGL2RenderingContext.
+     * @param minFilter The SamplerMinFilter.
+     * @param mipMapFilter The MipmapSamplerFilter.
+     * @returns The WebGL enum.
+     */
+    static convertToMinFilter(gl: WebGL2RenderingContext, minFilter: SamplerFilter, mipMapFilter: MipMapSamplerFilter): number;
+    /**
+     * Converts SamplerMagFilter to WebGL enum.
+     * @param gl The WebGL2RenderingContext.
+     * @param magFilter The SamplerMagFilter.
+     * @returns The WebGL enum.
+     */
+    static convertToMagFilter(gl: WebGL2RenderingContext, magFilter: SamplerFilter): number;
+    /**
+     * Converts VertexFormat to the number of components for WebGL vertex attribute pointer.
+     * @param vertexFormat The VertexFormat.
+     * @returns The number of components for WebGL vertex attribute pointer.
+     */
+    static convertVertexFormat(vertexFormat: VertexFormat): number;
+    /**
+     * Converts SamplerFilter to WebGL enum.
+     * @param gl The WebGL2RenderingContext.
+     * @param filter The SamplerFilter.
+     * @returns The WebGL enum.
+     */
+    static convertMagFilter(gl: WebGL2RenderingContext, filter: SamplerFilter): number;
+    /**
+     * Converts SamplerFilter and MipmapSamplerFilter to WebGL enum for minification filter.
+     * @param gl The WebGL2RenderingContext.
+     * @param filter The SamplerFilter.
+     * @param mipMapFilter The MipmapSamplerFilter.
+     * @returns The WebGL enum.
+     */
+    static convertMinFIlter(gl: WebGL2RenderingContext, filter: SamplerFilter, mipMapFilter: MipMapSamplerFilter): number;
+    /**
+     * Converts SamplerAddressMode to WebGL enum.
+     * @param gl The WebGL2RenderingContext.
+     * @param addressMode The SamplerAddressMode.
+     * @returns The WebGL enum.
+     */
+    static convertAddressMode(gl: WebGL2RenderingContext, addressMode: SamplerAddressMode): number;
+}
+//# sourceMappingURL=WebGlConverter.d.ts.map

package/dist/webgl/utilities/WebGlConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlConverter.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/WebGlConverter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,2BAA2B,CAAC;AAClD,OAAO,EAAC,WAAW,EAAE,cAAc,EAAC,MAAM,qCAAqC,CAAC;AAChF,OAAO,EAAC,QAAQ,EAAE,SAAS,EAAE,iBAAiB,EAAC,MAAM,sCAAsC,CAAC;AAC5F,OAAO,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAC,WAAW,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAErH,qBAAa,cAAc;IAIvB,UAAU;IACV,OAAO,CAAC,MAAM,CAAC,gCAAgC,CAAU;IAEzD,UAAU;IACV,OAAO,CAAC,MAAM,CAAC,6BAA6B,CAAU;IAGtD,WAAW;IACX,OAAO,CAAC,MAAM,CAAC,4BAA4B,CAAU;IAErD,OAAO,CAAC,MAAM,CAAC,+BAA+B,CAAU;IAExD;;;;OAIG;WACW,oBAAoB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM;IAgBvE;;;;OAIG;WACW,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM;IAczD;;;;OAIG;WACW,gBAAgB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM;IAW5D;;;;OAIG;WACW,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM;IAW5D;;;;;OAKG;WACW,qBAAqB,CAC/B,EAAE,EAAE,sBAAsB,EAC1B,cAAc,EAAE,cAAc,GAC/B,MAAM;IAiBT;;;;;OAKG;WACW,kBAAkB,CAC5B,EAAE,EAAE,sBAAsB,EAC1B,cAAc,EAAE,WAAW,GAC5B,MAAM;IAqBT;;;;;OAKG;WACW,cAAc,CAAC,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM;IAalF;;;;;OAKG;WACW,qBAAqB,CAAC,EAAE,EAAE,sBAAsB,EAAE,aAAa,EAAE,aAAa,GAAG,MAAM;IAyBrG;;;;;OAKG;WACW,oBAAoB,CAAC,EAAE,EAAE,sBAAsB,EAAE,aAAa,EAAE,aAAa,GAAG,MAAM;IAcpG;;;;;OAKG;WACW,oBAAoB,CAAC,EAAE,EAAE,sBAAsB,EAAE,aAAa,EAAE,aAAa,GAAG,MAAM;IAapG;;;;;;OAMG;WACW,kBAAkB,CAAC,EAAE,EAAE,sBAAsB,EAC1B,SAAS,EAAE,aAAa,EACxB,YAAY,EAAE,mBAAmB,GAAG,MAAM;IA6B3E;;;;;OAKG;WACW,kBAAkB,CAAC,EAAE,EAAE,sBAAsB,EAAE,SAAS,EAAE,aAAa,GAAG,MAAM;IAW9F;;;;OAIG;WACW,mBAAmB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM;IAiBrE;;;;;OAKG;WACW,gBAAgB,CAAC,EAAE,EAAE,sBAAsB,EAAE,MAAM,EAAE,aAAa,GAAG,MAAM;IAWzF;;;;;;OAMG;WACW,gBAAgB,CAAC,EAAE,EAAE,sBAAsB,EAAE,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,mBAAmB,GAAG,MAAM;IA6B5H;;;;;OAKG;WACW,kBAAkB,CAAC,EAAE,EAAE,sBAAsB,EAAE,WAAW,EAAE,kBAAkB,GAAG,MAAM;CAexG"}

package/dist/webgl/utilities/WebGlFrameBufferUtilities.d.ts

@@ -0,0 +1,54 @@
+import { TextureFormat } from "ris-framework-api";
+/**
+ * This file defines the WebGLFrameBufferUtilities class, which provides utility functions for working with WebGL framebuffers.
+ * The WebGLFrameBufferUtilities class includes methods for creating framebuffers with specific configurations, such as attaching textures as color and depth attachments.
+ * These utilities simplify the process of setting up framebuffers for rendering to textures, which is a common technique in graphics programming for effects like render-to-texture, post-processing, and off-screen rendering.
+ */
+export declare class WebGlFrameBufferUtilities {
+    /**
+     * Creates a framebuffer and attaches the provided texture(s) as color attachments.
+     * This method is useful for setting up a framebuffer for rendering to one or more textures.
+     * @param gl The WebGL2 rendering context.
+     * @param textureIds The texture(s) to be attached as color attachments.
+     * @param framebufferLabel An optional label for the framebuffer, which can be used for debugging purposes.
+     * @returns The created framebuffer.
+     */
+    create(gl: WebGL2RenderingContext, textureIds: WebGLTexture[] | WebGLTexture, framebufferLabel?: string | null): WebGLFramebuffer;
+    /**
+     * Creates a framebuffer with texture being attached as color attachment 0 and depth render buffer.
+     * @param gl The WebGL2 rendering context.
+     * @param textureAttachment0 The texture to be attached as color attachment 0.
+     * @param depthAttachmentType The type of the depth attachment, which can be DepthAttachment, DepthStencilAttachment or StencilAttachment.
+     * @param depthStencilRenderBuffer The render buffer to be attached as the depth/stencil attachment.
+     * @param label An optional label for the framebuffer, which can be used for debugging purposes.
+     * @return The created framebuffer.
+     */
+    createWithRenderBufferAsDepthBuffer(gl: WebGL2RenderingContext, textureAttachment0: WebGLTexture, depthAttachmentType: GLenum, depthStencilRenderBuffer: WebGLRenderbuffer, label: string | null | undefined): WebGLFramebuffer;
+    /**
+     * Creates a framebuffer with texture being attached as color attachment 0 and depth render buffer.
+     * @param gl The WebGL2 rendering context.
+     * @param textureAttachment0 The texture to be attached as color attachment 0.
+     * @param depthAttachmentType The type of the depth attachment, which can be DepthAttachment, DepthStencilAttachment or StencilAttachment.
+     * @param depthStencilTexture The texture to be attached as the depth/stencil attachment.
+     * @param label An optional label for the framebuffer, which can be used for debugging purposes.
+     * @returns The created framebuffer.
+     */
+    createWithRenderTextureAsDepthBuffer(gl: WebGL2RenderingContext, textureAttachment0: WebGLTexture, depthAttachmentType: GLenum, depthStencilTexture: WebGLTexture, label?: string): WebGLFramebuffer;
+    /**
+     * Attaches a depth/stencil render buffer to the framebuffer.
+     * @param gl The WebGL2 rendering context.
+     * @param frameBuffer The framebuffer to which the depth/stencil render buffer will be attached.
+     * @param depthStencilRenderBuffer The depth/stencil render buffer to be attached.
+     * @param format The format of the depth/stencil render buffer, which determines the type of attachment (depth, stencil, or depth-stencil).
+     */
+    attachDepthStencilRenderBuffer(gl: WebGL2RenderingContext, frameBuffer: WebGLFramebuffer, depthStencilRenderBuffer: WebGLRenderbuffer, format: TextureFormat): void;
+    /**
+     * Attaches a depth/stencil texture to the framebuffer.
+     * @param gl The WebGL2 rendering context.
+     * @param frameBuffer The framebuffer to which the depth/stencil texture will be attached.
+     * @param depthStencilTexture The depth/stencil texture to be attached.
+     * @param textureFormat The format of the depth/stencil texture, which determines the type of attachment (depth, stencil, or depth-stencil).
+     */
+    attachDepthStencilTexture(gl: WebGL2RenderingContext, frameBuffer: WebGLFramebuffer, depthStencilTexture: WebGLTexture, textureFormat: TextureFormat): void;
+}
+//# sourceMappingURL=WebGlFrameBufferUtilities.d.ts.map

package/dist/webgl/utilities/WebGlFrameBufferUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlFrameBufferUtilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/WebGlFrameBufferUtilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAGhD;;;;GAIG;AACH,qBAAa,yBAAyB;IAGlC;;;;;;;OAOG;IACI,MAAM,CAAC,EAAE,EAAE,sBAAsB,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,gBAAgB,GAAE,MAAM,GAAG,IAAW,GAAG,gBAAgB;IA8C9I;;;;;;;;OAQG;IACI,mCAAmC,CAAC,EAAE,EAAE,sBAAsB,EACjE,kBAAkB,EAAE,YAAY,EAChC,mBAAmB,EAAE,MAAM,EAC3B,wBAAwB,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,gBAAgB;IA2CpG;;;;;;;;OAQG;IACI,oCAAoC,CAAC,EAAE,EAAE,sBAAsB,EAClE,kBAAkB,EAAE,YAAY,EAChC,mBAAmB,EAAE,MAAM,EAC3B,mBAAmB,EAAE,YAAY,EACjC,KAAK,CAAC,EAAE,MAAM,GAAG,gBAAgB;IA2CrC;;;;;;OAMG;IACI,8BAA8B,CACjC,EAAE,EAAE,sBAAsB,EAC1B,WAAW,EAAE,gBAAgB,EAC7B,wBAAwB,EAAE,iBAAiB,EAC3C,MAAM,EAAE,aAAa,GAAG,IAAI;IAwBhC;;;;;;OAMG;IACI,yBAAyB,CAC5B,EAAE,EAAE,sBAAsB,EAC1B,WAAW,EAAE,gBAAgB,EAC7B,mBAAmB,EAAE,YAAY,EACjC,aAAa,EAAE,aAAa,GAAG,IAAI;CAiB1C"}

package/dist/webgl/utilities/WebGlSamplerUtilities.d.ts

@@ -0,0 +1,23 @@
+import { SamplerCompareFunction } from '../../common/sampler-enums';
+import { MipMapSamplerFilter, SamplerAddressMode, SamplerFilter } from "ris-framework-api";
+/**
+ * The utility class for working with WebGLSampler object.
+ */
+export declare class WebGlSamplerUtilities {
+    /**
+     * Creates a WebGLSampler with the specified parameters.
+     * @param gl The WebGL2RenderingContext.
+     * @param minFilter The minification filter of the sampler.
+     * @param magFilter The magnification filter of the sampler.
+     * @param mipMapFilter The mipmap filter of the sampler.
+     * @param addressModeU The address mode of the sampler for the U coordinate.
+     * @param addressModeV The address mode of the sampler for the V coordinate.
+     * @param addressModeW The address mode of the sampler for the W coordinate.
+     * @param compareFunction The compare function of the sampler. This is used for shadow samplers.
+     * @param _anisotropy The anisotropy level of the sampler. This is used for anisotropic filtering. The default value is 1, which means no anisotropic filtering.
+     * @param label The label of the sampler. This is used for debugging purposes and can be viewed in graphics debuggers like SpectorJS.
+     * @returns
+     */
+    create(gl: WebGL2RenderingContext, minFilter?: SamplerFilter, magFilter?: SamplerFilter, mipMapFilter?: MipMapSamplerFilter, addressModeU?: SamplerAddressMode, addressModeV?: SamplerAddressMode, addressModeW?: SamplerAddressMode, compareFunction?: SamplerCompareFunction, _anisotropy?: number, label?: string): WebGLSampler;
+}
+//# sourceMappingURL=WebGlSamplerUtilities.d.ts.map

package/dist/webgl/utilities/WebGlSamplerUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlSamplerUtilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/WebGlSamplerUtilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAGpE,OAAO,EAAC,mBAAmB,EAAE,kBAAkB,EAAE,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAEzF;;GAEG;AACH,qBAAa,qBAAqB;IAE9B;;;;;;;;;;;;;OAaG;IACI,MAAM,CAAC,EAAE,EAAE,sBAAsB,EAC1B,SAAS,GAAE,aAAoC,EAC/C,SAAS,GAAE,aAAoC,EAC/C,YAAY,GAAE,mBAA8C,EAC5D,YAAY,GAAE,kBAAqD,EACnE,YAAY,GAAE,kBAAqD,EACnE,YAAY,GAAE,kBAAqD,EACnE,eAAe,GAAE,sBAAqD,EACtE,WAAW,GAAE,MAAU,EACjC,KAAK,GAAE,MAAW,GAAI,YAAY;CA+CzC"}

package/dist/webgl/utilities/WebGlShaderUtilities.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This module provides utility functions for working with WebGL shaders, including shader creation and compilation.
+ */
+export declare class WebGlShaderUtilities {
+    /**
+     * Creates a WebGL shader of the specified type using the provided shader source code.
+     * @param gl The WebGL2 rendering context.
+     * @param shaderSource The source code of the shader.
+     * @param shaderType The type of the shader (e.g., gl.VERTEX_SHADER or gl.FRAGMENT_SHADER).
+     * @returns The compiled WebGLShader object.
+     */
+    create(gl: WebGL2RenderingContext, shaderSource: string, shaderType: GLenum): WebGLShader;
+    /**
+     * Creates a vertex shader using the provided shader source code.
+     * @param gl The WebGL2 rendering context.
+     * @param shaderSource The source code of the vertex shader.
+     * @returns The compiled WebGLShader object representing the vertex shader.
+     */
+    createVertexShader(gl: WebGL2RenderingContext, shaderSource: string): WebGLShader;
+    /**
+     * Creates a fragment shader using the provided shader source code.
+     * @param gl The WebGL2 rendering context.
+     * @param shaderSource The source code of the fragment shader.
+     * @returns The compiled WebGLShader object representing the fragment shader.
+     */
+    createFragmentShader(gl: WebGL2RenderingContext, shaderSource: string): WebGLShader;
+}
+//# sourceMappingURL=WebGlShaderUtilities.d.ts.map

package/dist/webgl/utilities/WebGlShaderUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlShaderUtilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/WebGlShaderUtilities.ts"],"names":[],"mappings":"AACA;;GAEG;AACH,qBAAa,oBAAoB;IAE7B;;;;;;OAMG;IACI,MAAM,CAAC,EAAE,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAG,MAAM,GAAG,WAAW;IAejG;;;;;OAKG;IACI,kBAAkB,CAAC,EAAE,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,GAAG,WAAW;IAIxF;;;;;OAKG;IACI,oBAAoB,CAAC,EAAE,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,GAAG,WAAW;CAG7F"}