ris-framework 0.1.0 → 0.2.0-dev.11

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

@@ -0,0 +1,300 @@
+import {
+    GeometryFormat,
+    type IFramework, type IPrimitiveState,
+    type ISampler,
+    type ITexture2D,
+    type IUniformBuffer,
+    type IVertexBuffer
+} from "../../../api";
+import {VertexBufferLayout} from "../../../core/rendering/vertex-buffer-layout";
+import type {WebGlUniformBuffer} from "../../buffers/WebGlUniformBuffer.ts";
+import {asWebGLUniformBuffer} from "../../cast/cast";
+import WebGlShaderModule from "../../shader/WebGlShaderModule.ts";
+import {WebGlTexture2D} from "../../texture/WebGlTexture2D.ts";
+import {WebGlVertexBuffer} from '../../buffers/WebGlVertexBuffer.ts';
+import {AWebGlRenderPipeline} from "../AWebGlRenderPipeline.ts";
+import type {WebGLIndexBuffer} from "../../buffers/webgl-index-buffer";
+import {
+    type IIndexBuffer,
+    IndexBufferType,
+    DEFAULT_DIRECTIONAL_LIGHTS_COUNT,
+    DEFAULT_POINT_LIGHTS_COUNT
+} from "../../../api";
+import type {WebGlSampler} from "../../sampler/webgl-sampler.ts";
+import type {
+    IForwardBlinnPhongRenderPipeline
+} from "../../../api/rendering/render-pipelines/IForwardBlinnPhongRenderPipeline.ts";
+
+/**
+ * The WebGL implementation of Blinn-Phong with forward calculated lighting.
+ * @internal
+ **/
+export class WebGlForwardBlinnPhongRenderPipeline extends AWebGlRenderPipeline implements IForwardBlinnPhongRenderPipeline {
+
+    private static readonly CAMERA_BINDING_POINT = 0;
+    private static readonly MODEL_BINDING_POINT = 1;
+    private static readonly MATERIAL_BINDING_POINT = 2;
+    private static readonly LIGHTS_BINDING_POINT = 3;
+    private static readonly CAMERA_POSITION_BINDING_POINT = 4;
+
+    private _texture: WebGlTexture2D = null!;
+    private _sampler?: WebGlSampler;
+    private _projectionViewBuffer: WebGlUniformBuffer;
+    private _modelBuffer: WebGlUniformBuffer;
+    private _materialBuffer: WebGlUniformBuffer;
+    private _lightsBuffer: WebGlUniformBuffer;
+    private _cameraBlockIndex = -1;
+    private _modelBlockIndex = -1;
+    private _materialBlockIndex = -1;
+    private _lightsBlockIndex = -1;
+    private _cameraPositionBuffer: WebGlUniformBuffer;
+    private _cameraPositionBlockIndex = -1;
+    private _maxDirectionalLights = DEFAULT_DIRECTIONAL_LIGHTS_COUNT;
+    private _maxPointLights = DEFAULT_POINT_LIGHTS_COUNT;
+    private _initialized = false;
+    private _buffersArray: WebGLBuffer[] = [null!];
+    private _lastVertexBuffer: WebGlVertexBuffer | null = null;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param projectionViewBuffer The projection view buffer.
+     * @param modelBuffer The model buffer.
+     * @param materialBuffer The material buffer.
+     * @param lightsBuffer The lights buffer (`LightsBuffer.buffer`). May be set later.
+     * @param cameraPositionBuffer The camera position buffer (world-space eye).
+     * @param primitiveState The primitive state.
+     */
+    public constructor(framework: IFramework,
+                       projectionViewBuffer: IUniformBuffer,
+                       modelBuffer: IUniformBuffer,
+                       materialBuffer: IUniformBuffer,
+                       lightsBuffer: IUniformBuffer | undefined,
+                       cameraPositionBuffer: IUniformBuffer,
+                       primitiveState?: IPrimitiveState,
+    ) {
+        // Validated before super(), which touches WebGL.
+        if (!modelBuffer) {
+            throw new Error("WebGlForwardBlinnPhongRenderPipeline: 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;
+        this._lightsBuffer = lightsBuffer as WebGlUniformBuffer;
+        this._cameraPositionBuffer = cameraPositionBuffer as WebGlUniformBuffer;
+    }
+
+    /** @inheritDoc */
+    public readonly geometryFormat = GeometryFormat.POS3_COLOR4_TEXTURECOORDS2_NORMAL3;
+
+    /** @inheritdoc */
+    public get projectionViewBuffer(): IUniformBuffer {
+        return this._projectionViewBuffer;
+    }
+
+    /** @inheritdoc */
+    public set projectionViewBuffer(value: IUniformBuffer) {
+        this._projectionViewBuffer = asWebGLUniformBuffer(value);
+    }
+
+    /** @inheritdoc */
+    public get modelBuffer(): IUniformBuffer {
+        return this._modelBuffer;
+    }
+
+    /** @inheritdoc */
+    public set modelBuffer(value: IUniformBuffer) {
+        if (!value) {
+            throw new Error("WebGlForwardBlinnPhongRenderPipeline: modelBuffer is required (the mesh's model buffer, std140 mat4).");
+        }
+        this._modelBuffer = asWebGLUniformBuffer(value);
+    }
+
+    /** @inheritdoc */
+    public get materialBuffer(): IUniformBuffer {
+        return this._materialBuffer;
+    }
+
+    /** @inheritdoc */
+    public set materialBuffer(value: IUniformBuffer) {
+        this._materialBuffer = asWebGLUniformBuffer(value);
+    }
+
+    /** @inheritdoc */
+    public get lightsBuffer(): IUniformBuffer {
+        return this._lightsBuffer;
+    }
+
+    /** @inheritdoc */
+    public set lightsBuffer(value: IUniformBuffer) {
+        this._lightsBuffer = asWebGLUniformBuffer(value);
+    }
+
+    /** @inheritdoc */
+    public get maxDirectionalLights(): number {
+        return this._maxDirectionalLights;
+    }
+
+    /** @inheritdoc */
+    public get maxPointLights(): number {
+        return this._maxPointLights;
+    }
+
+    /** @inheritdoc */
+    public setLightCounts(maxDirectionalLights: number, maxPointLights: number): void {
+        if (maxDirectionalLights === this._maxDirectionalLights && maxPointLights === this._maxPointLights) {
+            return;
+        }
+        this._maxDirectionalLights = maxDirectionalLights;
+        this._maxPointLights = maxPointLights;
+        if (this._initialized) {
+            // The vertex array object only depends on the vertex layout, so only the program and block bindings change.
+            this._loadProgram();
+        }
+    }
+
+    /** @inheritdoc */
+    public get cameraPositionBuffer(): IUniformBuffer {
+        return this._cameraPositionBuffer;
+    }
+
+    /** @inheritdoc */
+    public set cameraPositionBuffer(value: IUniformBuffer) {
+        this._cameraPositionBuffer = asWebGLUniformBuffer(value);
+    }
+
+    /** @inheritdoc */
+    public get diffuseTexture(): ITexture2D {
+        return this._texture;
+    }
+
+    /** @inheritdoc */
+    public set diffuseTexture(value: ITexture2D) {
+        this._texture = value as WebGlTexture2D;
+    }
+
+    /** @inheritdoc */
+    public get diffuseTextureSampler(): ISampler | undefined {
+        return this._sampler;
+    }
+
+    public set diffuseTextureSampler(value: ISampler | undefined) {
+        this._sampler = value as WebGlSampler | undefined;
+    }
+
+    /** @inheritdoc */
+    public override initialize(): void {
+
+        this._loadProgram();
+        this.vertexBufferLayouts = [VertexBufferLayout.createFloat3Float4Float2Float3Layout()];
+        super.initialize();
+        this._initialized = true;
+    }
+
+    /** Loads the shader variant for the current light counts (cached per counts by the shader loader). */
+    private _loadProgram(): void {
+        const module = this._framework.content.loadShaderModule("forward_blinn_phong_material", {
+            "DIRECTIONAL_LIGHTS_COUNT": this._maxDirectionalLights,
+            "POINT_LIGHTS_COUNT": this._maxPointLights,
+        }) as WebGlShaderModule;
+        this._program = module.program!;
+        this._createResources();
+    }
+
+    private _createResources(): void {
+        {
+            this._texture = WebGlTexture2D.getOrCreateDefault(this._framework);
+
+            this._cameraBlockIndex = this._gl.getUniformBlockIndex(this._program, "CameraBuffer");
+            this._gl.uniformBlockBinding(this._program, this._cameraBlockIndex, WebGlForwardBlinnPhongRenderPipeline.CAMERA_BINDING_POINT);
+
+            this._modelBlockIndex = this._gl.getUniformBlockIndex(this._program, "ModelBuffer");
+            this._gl.uniformBlockBinding(this._program, this._modelBlockIndex, WebGlForwardBlinnPhongRenderPipeline.MODEL_BINDING_POINT);
+
+            this._materialBlockIndex = this._gl.getUniformBlockIndex(this._program, "MaterialBuffer");
+            this._gl.uniformBlockBinding(this._program, this._materialBlockIndex, WebGlForwardBlinnPhongRenderPipeline.MATERIAL_BINDING_POINT);
+
+            this._lightsBlockIndex = this._gl.getUniformBlockIndex(this._program, "LightsBuffer");
+            this._gl.uniformBlockBinding(this._program, this._lightsBlockIndex, WebGlForwardBlinnPhongRenderPipeline.LIGHTS_BINDING_POINT);
+
+            this._cameraPositionBlockIndex = this._gl.getUniformBlockIndex(this._program, "CameraPositionBuffer");
+            this._gl.uniformBlockBinding(this._program, this._cameraPositionBlockIndex, WebGlForwardBlinnPhongRenderPipeline.CAMERA_POSITION_BINDING_POINT);
+        }
+    }
+
+
+    /** @inheritdoc */
+    protected _provideBuffers(): WebGLBuffer[] | undefined | null {
+        if (this._lastVertexBuffer === null) {
+            return null;
+        }
+
+        this._buffersArray[0] = this._lastVertexBuffer.buffer!;
+        return this._buffersArray;
+    }
+
+    /** @inheritdoc */
+    public render(vertexBuffer: IVertexBuffer, indexBuffer: IIndexBuffer, indicesCount: number = -1, indicesOffset: number = 0): void {
+
+        if (indicesCount == 0) {
+            return;
+        }
+
+        const webGlVertexBuffer = vertexBuffer as WebGlVertexBuffer;
+        const webGlIndexBuffer = indexBuffer as WebGLIndexBuffer;
+        const webGlSampler = this._sampler ?? this._defaultTextureSampler;
+
+        this.primitiveState.apply(this._gl);
+        this._blendState.apply(this._gl);
+
+        // if it was changed, we need to create a new vao.
+        if (this._lastVertexBuffer != webGlVertexBuffer) {
+            // Create a new VAO. Internally deletes the old one.
+            this._lastVertexBuffer = webGlVertexBuffer;
+            this._createVertexArrayObject();
+        }
+
+        this._gl.useProgram(this._program);
+        // Bind the vao. It contains all the information about the vertex buffer layout ( vertices + instances)
+        this._gl.bindVertexArray(this._vertexArrayObject);
+        this._gl.bindBuffer(this._gl.ELEMENT_ARRAY_BUFFER, webGlIndexBuffer.buffer);
+        this._gl.bindBufferBase(this._gl.UNIFORM_BUFFER,
+            WebGlForwardBlinnPhongRenderPipeline.CAMERA_BINDING_POINT,
+            this._projectionViewBuffer.glBuffer!);
+        this._gl.bindBufferBase(this._gl.UNIFORM_BUFFER,
+            WebGlForwardBlinnPhongRenderPipeline.MODEL_BINDING_POINT,
+            this._modelBuffer.glBuffer!);
+
+        if (this.materialBuffer) {
+            this._gl.bindBufferBase(this._gl.UNIFORM_BUFFER,
+                WebGlForwardBlinnPhongRenderPipeline.MATERIAL_BINDING_POINT,
+                this._materialBuffer.glBuffer!);
+        }
+        if (this._lightsBuffer) {
+            this._gl.bindBufferBase(this._gl.UNIFORM_BUFFER,
+                WebGlForwardBlinnPhongRenderPipeline.LIGHTS_BINDING_POINT,
+                this._lightsBuffer.glBuffer!);
+        }
+        this._gl.bindBufferBase(this._gl.UNIFORM_BUFFER,
+            WebGlForwardBlinnPhongRenderPipeline.CAMERA_POSITION_BINDING_POINT,
+            this._cameraPositionBuffer.glBuffer!);
+        this._gl.activeTexture(this._gl.TEXTURE0);
+        this._gl.bindTexture(this._gl.TEXTURE_2D, this._texture!.glTexture);
+        this._gl.bindSampler(0, webGlSampler.glSampler);
+
+        // We can only really use two types uint16 and uint32. Boolean check to see which one to use.
+        const type = indexBuffer.type == IndexBufferType.UINT_16
+            ? this._gl.UNSIGNED_SHORT
+            : this._gl.UNSIGNED_INT;
+
+        // api.PolygonMode(GLEnum.FrontAndBack, GLEnum.Line);
+
+        // Either draw all indices or a specific amount. If indicesCount is -1, draw all as defined by the index buffer.
+        const toIndices = indicesCount > 0 ? indicesCount : indexBuffer.indicesCount;
+        const fromIndices = indicesOffset * indexBuffer.elementByteSize;
+
+        this._gl.drawElements(this.primitiveState.glPrimitiveType, toIndices, type, fromIndices);
+    }
+
+}

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/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/utilities/webgl-filter-anisotropic-utilities.ts

@@ -7,18 +7,17 @@ export class WebGLFilterAnisotropicUtilities {
      */
     private MAX_ANISOTROPY_EXT: string = "EXT_texture_filter_anisotropic";
 
-    private _extension: any;
-
     /**
      * Gets the max anisotropy.
      * @param gl The WebGL2 rendering context.
      * @returns The maximum supported level of anisotropic filtering. `0` if not supported.
      */
     public getMaxAnisotropy(gl: WebGL2RenderingContext): number {
-        this._extension = gl.getExtension(this.MAX_ANISOTROPY_EXT);
+        // Looked up per context: this utility is a shared static, and an extension object belongs to one context.
+        const extension = gl.getExtension(this.MAX_ANISOTROPY_EXT);
 
-        if (this._extension) {
-            return gl.getParameter(this._extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
+        if (extension) {
+            return gl.getParameter(extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
         }
 
         return 0;
@@ -31,7 +30,11 @@ export class WebGLFilterAnisotropicUtilities {
      * @param anisotropy The level of anisotropic filtering
      */
     public setAnisotropy(gl: WebGL2RenderingContext, texture: WebGLTexture, anisotropy: number) {
+        const extension = gl.getExtension(this.MAX_ANISOTROPY_EXT);
+        if (!extension) {
+            return;
+        }
         gl.bindTexture(gl.TEXTURE_2D, texture);
-        gl.texParameterf(gl.TEXTURE_2D, this._extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
+        gl.texParameterf(gl.TEXTURE_2D, extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
     }
 }

package/dist/api/shader/shader-loader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader-loader.d.ts","sourceRoot":"","sources":["../../../src/api/shader/shader-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAE,KAAK,WAAW,EAAC,MAAM,aAAa,CAAC;AAE/D,qBAAa,YAAY;IAErB;;;;;;OAMG;IACU,IAAI,CAAC,cAAc,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;CAexH"}