maplibre-gl 6.2.0 → 6.3.0

package/src/webgl/program.ts

@@ -30,13 +30,34 @@ function getTokenizedAttributesAndUniforms(array: string[]): string[] {
     return result;
 }
 
+function getIntegerAttributeNames(gl: WebGL2RenderingContext, program: WebGLProgram): Set<string> {
+    const integerTypes = new Set<number>([
+        gl.INT, gl.INT_VEC2, gl.INT_VEC3, gl.INT_VEC4,
+        gl.UNSIGNED_INT, gl.UNSIGNED_INT_VEC2, gl.UNSIGNED_INT_VEC3, gl.UNSIGNED_INT_VEC4
+    ]);
+    const names = new Set<string>();
+    const numActiveAttributes = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+    for (let i = 0; i < numActiveAttributes; i++) {
+        const attribute = gl.getActiveAttrib(program, i);
+        if (attribute && integerTypes.has(attribute.type)) {
+            names.add(attribute.name);
+        }
+    }
+    return names;
+}
+
+export type ProgramAttribute = {
+    location: number;
+    isInteger: boolean;
+};
+
 /**
  * @internal
  * A webgl program to execute in the GPU space
  */
 export class Program<Us extends UniformBindings> {
     program: WebGLProgram;
-    attributes: {[_: string]: number};
+    attributes: {[_: string]: ProgramAttribute};
     numAttributes: number;
     fixedUniforms: Us;
     terrainUniforms: TerrainPreludeUniformsType;
@@ -123,27 +144,21 @@ export class Program<Us extends UniformBindings> {
 
         this.numAttributes = allAttrInfo.length;
 
-        for (let i = 0; i < this.numAttributes; i++) {
-            if (allAttrInfo[i]) {
-                this.attributes[allAttrInfo[i]] = i;
-            }
-        }
-
         gl.linkProgram(this.program);
 
-        for (const name in this.attributes) {
-            const actual = gl.getAttribLocation(this.program, name);
-            if (actual >= 0) {
-                this.attributes[name] = actual;
-            } else {
-                delete this.attributes[name];
-            }
-        }
-
         if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
             throw new Error(`Program failed to link: ${gl.getProgramInfoLog(this.program)}`);
         }
 
+        const integerAttributeNames = getIntegerAttributeNames(gl, this.program);
+        for (const name of allAttrInfo) {
+            if (!name) continue;
+            const location = gl.getAttribLocation(this.program, name);
+            if (location >= 0) {
+                this.attributes[name] = {location, isInteger: integerAttributeNames.has(name)};
+            }
+        }
+
         gl.deleteShader(vertexShader);
         gl.deleteShader(fragmentShader);
 

package/src/webgl/texture.test.ts

@@ -1,4 +1,4 @@
-import {describe, expect, test} from 'vitest';
+import {describe, expect, test, vi} from 'vitest';
 import {Context} from './context.ts';
 import {Texture} from './texture.ts';
 import {premultiplyAlpha, RGBAImage} from '../util/image.ts';
@@ -68,6 +68,21 @@ describe('Texture', () => {
         expect(gl.deleteTexture).toHaveBeenCalled();
     });
 
+    test('resizing re-applies filter and wrap to the new handle', () => {
+        const gl = createNullGL();
+        const context = new Context(gl);
+        const texture = new Texture(context, new RGBAImage({width: 2, height: 2}, new Uint8Array(2 * 2 * 4)), gl.RGBA);
+        texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE);
+
+        texture.update(new RGBAImage({width: 4, height: 4}, new Uint8Array(4 * 4 * 4)));
+        vi.mocked(gl.texParameteri).mockClear();
+        texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE);
+
+        // Same values as before, but on a new handle, so both have to be written again.
+        expect(gl.texParameteri).toHaveBeenCalledWith(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        expect(gl.texParameteri).toHaveBeenCalledWith(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    });
+
     test('premultiplyAlpha produces correct output', () => {
         // pixel: r=200, g=100, b=50, a=128 (half transparent)
         const data = new Uint8Array([200, 100, 50, 128]);

package/src/webgl/texture.ts

@@ -64,6 +64,9 @@ export class Texture {
             gl.deleteTexture(this.texture);
             this.texture = gl.createTexture();
             this._ownedHandle = this.texture;
+            // A fresh handle is back on GL's defaults, so bind() has to re-apply these.
+            this.filter = undefined;
+            this.wrap = undefined;
         }
 
         gl.bindTexture(gl.TEXTURE_2D, this.texture);

package/src/webgl/vertex_buffer.test.ts

@@ -40,7 +40,7 @@ describe('VertexBuffer', () => {
         const array = new TestArray();
         const buffer = new VertexBuffer(context, array, attributes);
         const spy = vi.spyOn(context.gl, 'enableVertexAttribArray').mockImplementation(() => {});
-        buffer.enableAttributes(context.gl, {attributes: {map: 5, box: 6}} as any);
+        buffer.enableAttributes(context.gl, {attributes: {map: {location: 5, isInteger: false}, box: {location: 6, isInteger: false}}} as any);
         expect(spy.mock.calls).toEqual([[5], [6]]);
     });
 
@@ -49,13 +49,28 @@ describe('VertexBuffer', () => {
         const array = new TestArray();
         const buffer = new VertexBuffer(context, array, attributes);
         const spy = vi.spyOn(context.gl, 'vertexAttribPointer').mockImplementation(() => {});
-        buffer.setVertexAttribPointers(context.gl, {attributes: {map: 5, box: 6}} as any, 50);
+        buffer.setVertexAttribPointers(context.gl, {attributes: {map: {location: 5, isInteger: false}, box: {location: 6, isInteger: false}}} as any, 50);
         expect(spy.mock.calls).toEqual([
             [5, 1, context.gl['SHORT'], false, 6, 300],
             [6, 2, context.gl['SHORT'], false, 6, 304]
         ]);
     });
 
+    test('setVertexAttribPointers uses vertexAttribIPointer for integer attributes', () => {
+        const context = new Context(gl);
+        const array = new TestArray();
+        const buffer = new VertexBuffer(context, array, attributes);
+        const integerSpy = vi.spyOn(context.gl, 'vertexAttribIPointer').mockImplementation(() => {});
+        const floatSpy = vi.spyOn(context.gl, 'vertexAttribPointer').mockImplementation(() => {});
+        buffer.setVertexAttribPointers(context.gl, {attributes: {map: {location: 5, isInteger: false}, box: {location: 6, isInteger: true}}} as any, 50);
+        expect(integerSpy.mock.calls).toEqual([
+            [6, 2, context.gl['SHORT'], 6, 304]
+        ]);
+        expect(floatSpy.mock.calls).toEqual([
+            [5, 1, context.gl['SHORT'], false, 6, 300]
+        ]);
+    });
+
     test('static buffer frees StructArray typed views after upload', () => {
         const context = new Context(gl);
         const array = new TestArray();

package/src/webgl/vertex_buffer.ts

@@ -66,9 +66,9 @@ export class VertexBuffer {
 
     enableAttributes(gl: WebGL2RenderingContext, program: Program<any>): void {
         for (const member of this.attributes) {
-            const attribIndex: number | void = program.attributes[member.name];
-            if (attribIndex !== undefined) {
-                gl.enableVertexAttribArray(attribIndex);
+            const attribute = program.attributes[member.name];
+            if (attribute !== undefined) {
+                gl.enableVertexAttribArray(attribute.location);
             }
         }
     }
@@ -81,17 +81,28 @@ export class VertexBuffer {
      */
     setVertexAttribPointers(gl: WebGL2RenderingContext, program: Program<any>, vertexOffset?: number | null): void {
         for (const member of this.attributes) {
-            const attribIndex: number | void = program.attributes[member.name];
+            const attribute = program.attributes[member.name];
 
-            if (attribIndex !== undefined) {
-                gl.vertexAttribPointer(
-                    attribIndex,
-                    member.components,
-                    gl[AttributeType[member.type]],
-                    false,
-                    this.itemSize,
-                    member.offset + (this.itemSize * (vertexOffset || 0))
-                );
+            if (attribute !== undefined) {
+                const offset = member.offset + (this.itemSize * (vertexOffset || 0));
+                if (attribute.isInteger) {
+                    gl.vertexAttribIPointer(
+                        attribute.location,
+                        member.components,
+                        gl[AttributeType[member.type]],
+                        this.itemSize,
+                        offset
+                    );
+                } else {
+                    gl.vertexAttribPointer(
+                        attribute.location,
+                        member.components,
+                        gl[AttributeType[member.type]],
+                        false,
+                        this.itemSize,
+                        offset
+                    );
+                }
             }
         }
     }