ris-framework 0.1.0 → 0.2.0-dev.12

package/src/webgl/render-pipelines/material/WebGlUnlitRenderPipeline.ts

@@ -1,9 +1,10 @@
-import type {
-    IFramework, IPrimitiveState,
-    ISampler,
-    ITexture2D,
-    IUniformBuffer, IUnlitRenderPipeline,
-    IVertexBuffer
+import {
+    GeometryFormat,
+    type IFramework, type IPrimitiveState,
+    type ISampler,
+    type ITexture2D,
+    type IUniformBuffer, type IUnlitRenderPipeline,
+    type IVertexBuffer
 } from "../../../api/index.ts";
 import {VertexBufferLayout} from "../../../core/rendering/vertex-buffer-layout";
 import type {WebGlUniformBuffer} from "../../buffers/WebGlUniformBuffer.ts";
@@ -50,12 +51,18 @@ export class WebGlUnlitRenderPipeline extends AWebGlRenderPipeline implements IU
                 materialBuffer: IUniformBuffer,
                 primitiveState?: IPrimitiveState,
     ) {
+        // Validated before super(), which touches WebGL.
+        if (!modelBuffer) {
+            throw new Error("WebGlUnlitRenderPipeline: modelBuffer is required (the mesh's model buffer, std140 mat4).");
+        }
         super(framework, primitiveState);
         this._projectionViewBuffer = projectionViewBuffer as WebGlUniformBuffer;
         this._modelBuffer = modelBuffer as WebGlUniformBuffer;
         this._materialBuffer = materialBuffer as WebGlUniformBuffer;
     }
 
+    /** @inheritDoc */
+    public readonly geometryFormat = GeometryFormat.POS3_COLOR4_TEXTURECOORDS2;
 
     /** @inheritdoc */
     public get projectionViewBuffer(): IUniformBuffer {
@@ -74,6 +81,9 @@ export class WebGlUnlitRenderPipeline extends AWebGlRenderPipeline implements IU
 
     /** @inheritdoc */
     public set modelBuffer(value: IUniformBuffer) {
+        if (!value) {
+            throw new Error("WebGlUnlitRenderPipeline: modelBuffer is required (the mesh's model buffer, std140 mat4).");
+        }
         this._modelBuffer = asWebGLUniformBuffer(value);
     }
 

package/src/webgl/render-pipelines/sprite/WebGlSpriteRenderPipeline.ts

@@ -1,10 +1,11 @@
-import type {
-    IFramework,
-    ISampler,
-    ISpriteRenderPipeline,
-    ITexture2D,
-    IUniformBuffer,
-    IVertexBuffer
+import {
+    GeometryFormat,
+    type IFramework,
+    type ISampler,
+    type ISpriteRenderPipeline,
+    type ITexture2D,
+    type IUniformBuffer,
+    type IVertexBuffer
 } from "../../../api/index.ts";
 import {VertexBufferLayout} from "../../../core/rendering/vertex-buffer-layout";
 import type {WebGlUniformBuffer} from "../../buffers/WebGlUniformBuffer.ts";
@@ -41,6 +42,9 @@ export class WebGlSpriteRenderPipeline extends AWebGlRenderPipeline implements I
         this._projectionViewBuffer = asWebGLUniformBuffer(projectionViewBuffer);
     }
 
+    /** @inheritDoc */
+    public readonly geometryFormat = GeometryFormat.POS3_COLOR4_TEXTURECOORDS2;
+
     /** @inheritdoc */
     public get projectionViewBuffer(): IUniformBuffer {
         return this._projectionViewBuffer;

package/src/webgl/shader/WebGlShaderModule.ts

@@ -22,12 +22,12 @@ export class WebGlShaderModule implements IShaderModule {
      * The constructor of the WebGL shader module.
      * @param framework The framework.
      * @param shaderFilePath
+     * @param @param keyValueDictionary - If present, tries to find key in shader such that it replaced ##DIRECTIONAL_LIGHT_COUNT## by given value for key DIRECTIONAL_LIGHST_COUNT.
      */
-    public constructor(framework: IFramework, shaderFilePath: string) {
+    public constructor(framework: IFramework, shaderFilePath: string, keyValueDictionary?: {[id:string]: number} ) {
         this._graphicsDevice = framework.renderer.graphicsDevice as WebGlGraphicsDevice;
         this._gl = this._graphicsDevice.gl;
-        this._program = this._loadShaders(shaderFilePath);
-
+        this._program = this._loadShaders(shaderFilePath, keyValueDictionary);
     }
 
     /** @inheritDoc */
@@ -63,7 +63,7 @@ export class WebGlShaderModule implements IShaderModule {
         return this._program;
     }
 
-    private _loadShaders(shaderFilePath: string): WebGLProgram {
+    private _loadShaders(shaderFilePath: string, keyValueDictionary?: {[id:string]: number} ): WebGLProgram {
 
         const internalShader = this._tryResolveFrameworkShader(shaderFilePath);
 
@@ -72,6 +72,7 @@ export class WebGlShaderModule implements IShaderModule {
         if (internalShader) {
             vertexShaderSource = internalShader.vertex;
             fragmentShaderSource = internalShader.fragment;
+
         } else {
 
             throw new Error("Not implemented");
@@ -84,6 +85,12 @@ export class WebGlShaderModule implements IShaderModule {
             // fragmentShaderSource = await this._shaderLoader.load(shaderFilePath, RenderingBackend.WEB_GL, [ShaderStage.FRAGMENT]);
         }
 
+        if(keyValueDictionary) {
+            for(const key in keyValueDictionary) {
+                vertexShaderSource = vertexShaderSource.replace(`##${key}##`, String(keyValueDictionary[key]));
+                fragmentShaderSource = fragmentShaderSource.replace(`##${key}##`, String(keyValueDictionary[key]));
+            }
+        }
 
         const vertexShader = WebGlUtilities.shader.createVertexShader(this._gl, vertexShaderSource);
         const fragmentShader = WebGlUtilities.shader.createFragmentShader(this._gl, fragmentShaderSource);

package/src/webgl/shader/WebGlShaderModuleLoader.ts

@@ -2,6 +2,21 @@ import WebGlShaderModule from "./WebGlShaderModule.ts";
 import type {IFramework, IShaderModule} from "../../api/index.ts";
 
 
+/**
+ * Builds the cache key of a shader module: the id plus the sorted replacement values,
+ * so the same shader with different `##KEY##` values (e.g. light counts) is compiled separately.
+ * @param id The shader module id.
+ * @param keyValueDictionary The optional replacement values.
+ * @internal
+ */
+export function shaderModuleCacheKey(id: string, keyValueDictionary?: {[id: string]: number}): string {
+    if (!keyValueDictionary) {
+        return id;
+    }
+    const entries = Object.keys(keyValueDictionary).sort().map(key => `${key}=${keyValueDictionary[key]}`);
+    return entries.length === 0 ? id : `${id}?${entries.join("&")}`;
+}
+
 /**
  * The content WebGL implementation of ShaderContentModule.
  */
@@ -17,24 +32,28 @@ export class WebGlShaderModuleLoader {
         this._framework = framework;
     }
 
-    /**
-     * The content types provided by this content module.
-     * @param assetFilePathOrIdentifier The asset file path or identifier of the content to load.
-     */
-    public load(assetFilePathOrIdentifier: string): IShaderModule {
+    /** @inheritDoc */
+    public load(assetFilePathOrIdentifier: string, keyValueDictionary?: {[id:string]: number} ): IShaderModule {
 
         // Here something like 'sprite' is provided, we must resolve it.
 
         // Is it already cached?
-        let shaderModule = this._shaderModules.get(assetFilePathOrIdentifier);
+        const cacheKey = shaderModuleCacheKey(assetFilePathOrIdentifier, keyValueDictionary);
+        let shaderModule = this._shaderModules.get(cacheKey);
         if (!shaderModule) {
 
             // If it does not exist create one and set it.
-            shaderModule = new WebGlShaderModule(this._framework, assetFilePathOrIdentifier);
-            this._shaderModules.set(assetFilePathOrIdentifier, shaderModule);
+            shaderModule = new WebGlShaderModule(this._framework, assetFilePathOrIdentifier, keyValueDictionary);
+            this._shaderModules.set(cacheKey, shaderModule);
         }
         return shaderModule;
     }
 
-
-}
+    /** Deletes every cached shader program and clears the cache. */
+    public dispose(): void {
+        for (const shaderModule of this._shaderModules.values()) {
+            shaderModule.dispose();
+        }
+        this._shaderModules.clear();
+    }
+}

package/src/webgl/swap-chain/WebGlSwapChain.ts

@@ -1,4 +1,4 @@
-import { vec2 } from "gl-matrix";
+import {vec2} from "gl-matrix";
 import {type IGraphicsDevice, type ISwapChain, TextureFormat} from "../../api/index.ts";
 import type {WebGlGraphicsDevice} from "../WebGlGraphicsDevice.ts";
 
@@ -16,8 +16,9 @@ export class WebGlSwapChain implements ISwapChain {
      * The WebGLSwapChain constructor.
      * @param canvas The HTML canvas element that the swap chain will use for rendering.
      * @param graphicsDevice The graphics device.
+     * @param srgb Prefer use of
      */
-    public constructor(canvas: HTMLCanvasElement, graphicsDevice: IGraphicsDevice) {
+    public constructor(canvas: HTMLCanvasElement, graphicsDevice: IGraphicsDevice, srgb = true) {
         this._canvas = canvas;
         this._graphicsDevice = graphicsDevice as WebGlGraphicsDevice;
         this._backBufferSize = vec2.fromValues(this._canvas.width, this._canvas.height);
@@ -25,13 +26,13 @@ export class WebGlSwapChain implements ISwapChain {
             this._backBufferSize[0] = this._canvas.width;
             this._backBufferSize[1] = this._canvas.height;
         });
-    }
 
+        // Nothing else to do. Typically, framebuffer should be srgb, but that is already handled through canvas.
+        this.textureFormat = srgb ? TextureFormat.RGBA_8_UNORM_SRGB : TextureFormat.RGBA_8_UNORM;
+    }
 
     /** @inheritdoc */
-    public get textureFormat(): TextureFormat {
-        return TextureFormat.RGBA_8_UNORM;
-    }
+    public readonly textureFormat: TextureFormat;
 
     /** @inheritdoc */
     public get backBufferSize(): vec2 {

package/src/webgl/texture/WebGlTexture2D.ts

@@ -107,16 +107,19 @@ export class WebGlTexture2D extends ATexture2D {
         }
     }
 
-    private static _defaultFilled: WebGlTexture2D | null = null;
+    /** One default texture per framework, so a new framework (and GL context) never gets a texture of an old one. */
+    private static readonly _defaultFilled = new WeakMap<IFramework, WebGlTexture2D>();
 
     /**
      * 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.
+     * The texture belongs to that framework's GL context; each framework gets its own.
      * @returns The default 1x1 white texture.
      */
     public static getOrCreateDefault(framework: IFramework): WebGlTexture2D {
-        if (this._defaultFilled === null || this._defaultFilled.state === State.DISPOSED) {
+        let texture = WebGlTexture2D._defaultFilled.get(framework);
+        if (!texture || texture.state === State.DISPOSED) {
 
             const desc = new TextureDescriptor();
             desc.width = 1;
@@ -125,11 +128,22 @@ export class WebGlTexture2D extends ATexture2D {
             desc.textureFormat = framework.renderer.preferredTextureFormat;
             desc.label = "RisDefaultFilledTexture";
 
-            this._defaultFilled = new WebGlTexture2D(framework, desc);
-            this._defaultFilled.initialize();
+            texture = new WebGlTexture2D(framework, desc);
+            texture.initialize();
+            WebGlTexture2D._defaultFilled.set(framework, texture);
         }
 
-        return this._defaultFilled;
+        return texture;
+    }
+
+    /**
+     * Disposes and forgets the default texture of a framework. Called from `Framework.dispose()`.
+     * @param framework The framework instance.
+     */
+    public static disposeDefault(framework: IFramework): void {
+        const texture = WebGlTexture2D._defaultFilled.get(framework);
+        WebGlTexture2D._defaultFilled.delete(framework);
+        texture?.dispose();
     }
 
 }

package/src/webgl/texture/WebGlTextureFactory.ts

@@ -9,7 +9,7 @@ import {
     TextureUtilities
 } from "../../api/index.ts"
 import {WebGlTexture2D} from "./WebGlTexture2D.ts";
-import {type IKtx2Texture, KtxTranscodeFlags, KtxTranscodeFormat, TextureFormatInfo, VkFormat} from "ris-ktx2";
+import {type IKtx2Texture, KtxTranscodeFlags, KtxTranscodeFormat, VkFormat} from "ris-ktx2";
 import {vec2} from "gl-matrix";
 
 export class WebGlTextureFactory implements ITextureFactory {
@@ -31,13 +31,13 @@ export class WebGlTextureFactory implements ITextureFactory {
         let transcodeFormat = KtxTranscodeFormat.NO_SELECTION;
         let textureFormat = descriptor.textureFormat;
         const gpuFeatures = this._framework.graphicsDevice.features;
-        let texFormatInfo: TextureFormatInfo | null = null;
 
         if (ktxTexture.needsTranscoding && vkFormat == VkFormat.UNDEFINED)
         {
             // If descriptor format is UNDEFINED, we will use format according to the GPU features.
             if(descriptor.textureFormat == TextureFormat.UNDEFINED)
             {
+                // BC7 needs BPTC (supportsTextureCompressionBC), BC3 needs S3TC.
                 if(gpuFeatures.supportsTextureCompressionBC)
                 {
                     transcodeFormat = KtxTranscodeFormat.BC7_RGBA;
@@ -46,7 +46,7 @@ export class WebGlTextureFactory implements ITextureFactory {
                 else if(gpuFeatures.supportsTextureCompressionASTC)
                 {
                     transcodeFormat = KtxTranscodeFormat.ASTC_4X4_RGBA;
-                    textureFormat = TextureFormat.ASTC_4X4_RGBA
+                    textureFormat = TextureFormat.ASTC_4X4_RGBA_UNORM
                 }
                 else if(gpuFeatures.supportsTextureCompressionS3TC)
                 {
@@ -58,6 +58,16 @@ export class WebGlTextureFactory implements ITextureFactory {
                     transcodeFormat = KtxTranscodeFormat.ETC2_RGBA;
                     textureFormat = TextureFormat.ETC2_RGBA8_UNORM;
                 }
+                else if(gpuFeatures.supportsTextureCompressionPVRTC)
+                {
+                    transcodeFormat = KtxTranscodeFormat.PVRTC1_4_RGBA;
+                    textureFormat = TextureFormat.PVRTC_4BPPV1_RGBA;
+                }
+                else
+                {
+                    transcodeFormat = KtxTranscodeFormat.RGBA32;
+                    textureFormat = TextureFormat.RGBA_8_UNORM;
+                }
             }
             else
             {
@@ -65,12 +75,23 @@ export class WebGlTextureFactory implements ITextureFactory {
             }
 
             ktxTexture.transcodeBasis(transcodeFormat, KtxTranscodeFlags.HIGH_QUALITY);
-            texFormatInfo = ktxTexture.getTextureFormatInfo(TextureUtilities.convertKtxTranscodeFormatToVkFormat(transcodeFormat));
+
+            // After transcoding, libktx reports the sRGB vkFormat when the file's DFD transfer function is sRGB.
+            if (descriptor.textureFormat == TextureFormat.UNDEFINED && WebGlTextureFactory._isSrgbVkFormat(ktxTexture.vkFormat))
+            {
+                textureFormat = TextureUtilities.toSrgbFormat(textureFormat);
+            }
         }
         else {
-            // No transcoding path, but still get info about the texture format.
+            // No transcoding path, the vkFormat already says linear or sRGB.
             textureFormat = TextureUtilities.convertVkFormatToTextureFormat(vkFormat);
-            texFormatInfo = ktxTexture.getTextureFormatInfo(vkFormat);
+        }
+
+        textureFormat = this._ensureSrgbSupported(textureFormat, ktxTexture.filePath);
+
+        const blockSize = TextureUtilities.getBlockSize(textureFormat);
+        if (!blockSize) {
+            throw new Error(`Unknown block size for texture format ${textureFormat}.`);
         }
 
         const data: Uint8Array[] = [];
@@ -85,13 +106,34 @@ export class WebGlTextureFactory implements ITextureFactory {
         textureDescriptor.data = data;
         textureDescriptor.textureFormat = textureFormat;
         textureDescriptor.generateMipmaps = descriptor.generateMipmaps;
-        textureDescriptor.blockSize = vec2.fromValues(texFormatInfo.blockWidth, texFormatInfo.blockHeight);
+        textureDescriptor.blockSize = vec2.fromValues(blockSize[0], blockSize[1]);
 
         const texture = new WebGlTexture2D(this._framework, textureDescriptor);
         texture.initialize();
         return texture;
     }
 
+    /** Whether the Vulkan format is an sRGB format. */
+    private static _isSrgbVkFormat(vkFormat: VkFormat): boolean {
+        const name = (VkFormat as unknown as Record<number, string>)[vkFormat];
+        return typeof name === "string" && name.includes("_SRGB");
+    }
+
+    /**
+     * Falls back to the linear variant (with a warning) when the GPU cannot sample the sRGB format.
+     * Only S3TC sRGB (BC1/BC3) has its own WebGL extension; BC7, ETC2 and ASTC sRGB ship with their base extension.
+     */
+    private _ensureSrgbSupported(textureFormat: TextureFormat, source?: string): TextureFormat {
+        const isS3tcSrgb = textureFormat === TextureFormat.BC3_RGBA_SRGB || textureFormat === TextureFormat.BC1_RGB_SRGB;
+        if (isS3tcSrgb && !this._framework.graphicsDevice.features.supportsTextureCompressionS3TCSrgb) {
+            const linear = TextureUtilities.toLinearFormat(textureFormat);
+            console.warn(`sRGB S3TC is not supported (WEBGL_compressed_texture_s3tc_srgb missing); ` +
+                `loading ${source ?? "texture"} as ${linear}. Colours will look washed out.`);
+            return linear;
+        }
+        return textureFormat;
+    }
+
     /** @inheritdoc */
     public create(
         width: number, height: number,

package/src/webgl/utilities/WebGlConstants.ts

@@ -0,0 +1,136 @@
+/**
+ * WebGL extension constants that WebGL2RenderingContext does not expose.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Constants
+ */
+export class WebGlConstants {
+
+    /** BC1 RGB */
+    public static readonly GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0;
+
+    /** BC1 RGB sRGB (WEBGL_compressed_texture_s3tc_srgb) */
+    public static readonly GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C;
+
+    /** BC3 sRGB (WEBGL_compressed_texture_s3tc_srgb) */
+    public static readonly GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F;
+
+    /** BC7 sRGB (EXT_texture_compression_bptc) */
+    public static readonly GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D;
+
+    /** ETC2 RGB8 */
+    public static readonly GL_COMPRESSED_RGB8_ETC2 = 0x9274;
+
+    /** ETC2 RGB8 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ETC2 = 0x9275;
+
+    /** ETC2 RGBA8 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279;
+
+    /** BC3 */
+    public static readonly GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3;
+
+    /** BC7 */
+    public static readonly GL_COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C;
+
+    /** ETC2 */
+    public static readonly GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278;
+
+    // ASTC (WEBGL_compressed_texture_astc).
+
+    /** ASTC 4x4 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0;
+
+    /** ASTC 4x4 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93D0;
+
+    /** ASTC 5x4 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93B1;
+
+    /** ASTC 5x4 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93D1;
+
+    /** ASTC 5x5 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93B2;
+
+    /** ASTC 5x5 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93D2;
+
+    /** ASTC 6x5 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93B3;
+
+    /** ASTC 6x5 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93D3;
+
+    /** ASTC 6x6 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93B4;
+
+    /** ASTC 6x6 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93D4;
+
+    /** ASTC 8x5 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93B5;
+
+    /** ASTC 8x5 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93D5;
+
+    /** ASTC 8x6 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93B6;
+
+    /** ASTC 8x6 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93D6;
+
+    /** ASTC 8x8 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93B7;
+
+    /** ASTC 8x8 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93D7;
+
+    /** ASTC 10x5 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93B8;
+
+    /** ASTC 10x5 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93D8;
+
+    /** ASTC 10x6 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93B9;
+
+    /** ASTC 10x6 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93D9;
+
+    /** ASTC 10x8 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93BA;
+
+    /** ASTC 10x8 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93DA;
+
+    /** ASTC 10x10 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93BB;
+
+    /** ASTC 10x10 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93DB;
+
+    /** ASTC 12x10 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93BC;
+
+    /** ASTC 12x10 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93DC;
+
+    /** ASTC 12x12 */
+    public static readonly GL_COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93BD;
+
+    /** ASTC 12x12 sRGB */
+    public static readonly GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93DD;
+
+    // PVRTC (WEBGL_compressed_texture_pvrtc).
+
+    /** PVRTC 4 bits per pixel, RGB */
+    public static readonly GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 0x8C00;
+
+    /** PVRTC 2 bits per pixel, RGB */
+    public static readonly GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 0x8C01;
+
+    /** PVRTC 4 bits per pixel, RGBA */
+    public static readonly GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 0x8C02;
+
+    /** PVRTC 2 bits per pixel, RGBA */
+    public static readonly GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 0x8C03;
+}

package/src/webgl/utilities/WebGlConverter.ts

@@ -1,3 +1,4 @@
+import {WebGlConstants} from "./WebGlConstants.ts";
 import {Culling} from "../../api/rendering/enums.ts";
 import {BlendFactor, BlendOperation} from "../../core/rendering/blending/enums";
 import {VertexFormat} from "../../api/geometry/VertexFormat.ts";
@@ -14,20 +15,6 @@ import {
 
 export class WebGlConverter {
 
-    // https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Constants
-
-    /** BC3 */
-    private static GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3;
-
-    /** BC7 */
-    private static GL_COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C;
-
-
-    /** ETC2 */
-    private static GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278;
-
-    private static GL_COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0;
-
     /**
      * Converts PrimitiveTopology to WebGL enum.
      * @param topology The PrimitiveTopology.
@@ -65,7 +52,8 @@ export class WebGlConverter {
                 return WebGL2RenderingContext.BACK;
             case CullMode.FRONT:
                 return WebGL2RenderingContext.FRONT;
-            default: throw new Error("Method not implemented.");
+            default:
+                throw new Error("Method not implemented.");
         }
 
     }
@@ -95,13 +83,13 @@ export class WebGlConverter {
 
         let bufferUsage: number = WebGL2RenderingContext.STATIC_DRAW;
 
-        if((usage & BufferUsage.COPY_DST) == BufferUsage.COPY_DST)
-        {
+        if ((usage & BufferUsage.COPY_DST) == BufferUsage.COPY_DST) {
             bufferUsage = WebGL2RenderingContext.DYNAMIC_DRAW;
         }
 
         return bufferUsage;
     }
+
     /**
      * Converts BlendOperation to WebGL enum.
      * @param gl The WebGL2RenderingContext.
@@ -195,13 +183,94 @@ export class WebGlConverter {
             case TextureFormat.DEPTH_24_STENCIL_8:
                 return gl.DEPTH24_STENCIL8;
             case TextureFormat.BC3_RGBA_UNORM:
-                return WebGlConverter.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+                return WebGlConstants.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
             case TextureFormat.ETC2_RGBA8_UNORM:
-                return WebGlConverter.GL_COMPRESSED_RGBA8_ETC2_EAC;
+                return WebGlConstants.GL_COMPRESSED_RGBA8_ETC2_EAC;
             case TextureFormat.BC7_RGBA_UNORM:
-                return WebGlConverter.GL_COMPRESSED_RGBA_BPTC_UNORM;
-            case TextureFormat.ASTC_4X4_RGBA:
-                return WebGlConverter.GL_COMPRESSED_RGBA_ASTC_4x4_KHR;
+                return WebGlConstants.GL_COMPRESSED_RGBA_BPTC_UNORM;
+            case TextureFormat.BC7_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM;
+            case TextureFormat.BC3_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
+            case TextureFormat.BC1_RGB_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+            case TextureFormat.BC1_RGB_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB_S3TC_DXT1_EXT;
+            case TextureFormat.ETC2_RGBA8_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC;
+            case TextureFormat.ETC2_RGB8_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGB8_ETC2;
+            case TextureFormat.ETC2_RGB8_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ETC2;
+
+            // ASTC
+            case TextureFormat.ASTC_4X4_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_4x4_KHR;
+            case TextureFormat.ASTC_4X4_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;
+            case TextureFormat.ASTC_5X4_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_5x4_KHR;
+            case TextureFormat.ASTC_5X4_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR;
+            case TextureFormat.ASTC_5X5_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_5x5_KHR;
+            case TextureFormat.ASTC_5X5_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR;
+            case TextureFormat.ASTC_6X5_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_6x5_KHR;
+            case TextureFormat.ASTC_6X5_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR;
+            case TextureFormat.ASTC_6X6_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_6x6_KHR;
+            case TextureFormat.ASTC_6X6_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR;
+            case TextureFormat.ASTC_8X5_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_8x5_KHR;
+            case TextureFormat.ASTC_8X5_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR;
+            case TextureFormat.ASTC_8X6_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_8x6_KHR;
+            case TextureFormat.ASTC_8X6_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR;
+            case TextureFormat.ASTC_8X8_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_8x8_KHR;
+            case TextureFormat.ASTC_8X8_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR;
+            case TextureFormat.ASTC_10X5_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_10x5_KHR;
+            case TextureFormat.ASTC_10X5_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR;
+            case TextureFormat.ASTC_10X6_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_10x6_KHR;
+            case TextureFormat.ASTC_10X6_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR;
+            case TextureFormat.ASTC_10X8_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_10x8_KHR;
+            case TextureFormat.ASTC_10X8_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR;
+            case TextureFormat.ASTC_10X10_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_10x10_KHR;
+            case TextureFormat.ASTC_10X10_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR;
+            case TextureFormat.ASTC_12X10_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_12x10_KHR;
+            case TextureFormat.ASTC_12X10_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR;
+            case TextureFormat.ASTC_12X12_RGBA_UNORM:
+                return WebGlConstants.GL_COMPRESSED_RGBA_ASTC_12x12_KHR;
+            case TextureFormat.ASTC_12X12_RGBA_SRGB:
+                return WebGlConstants.GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR;
+
+            // PVRTC
+            case TextureFormat.PVRTC_4BPPV1_RGBA:
+                return WebGlConstants.GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
+            case TextureFormat.PVRTC_4BPPV1_RGB:
+                return WebGlConstants.GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
+
+            case TextureFormat.PVRTC_2BPPV1_RGBA:
+                return WebGlConstants.GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
+            case TextureFormat.PVRTC_2BPPV1_RGB:
+                return WebGlConstants.GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
 
             default:
                 throw new Error("NotImplementedException");