@scoova/mgl 1.0.0

package/src/gl/state.test.ts

@@ -0,0 +1,125 @@
+import {IValue, ClearColor, ClearDepth, ClearStencil, ColorMask, DepthMask, StencilMask, StencilFunc, StencilOp, StencilTest, DepthRange, DepthTest, DepthFunc, Blend, BlendFunc, BlendColor, ProgramValue, ActiveTextureUnit, Viewport, BindFramebuffer, BindRenderbuffer, BindTexture, BindVertexBuffer, BindElementBuffer, BindVertexArray, PixelStoreUnpack, PixelStoreUnpackPremultiplyAlpha} from './value';
+import {Context} from './context';
+import {Color} from '@maplibre/maplibre-gl-style-spec';
+import {deepEqual} from '../util/util';
+
+describe('Value classes', () => {
+
+    const gl = document.createElement('canvas').getContext('webgl') as WebGL2RenderingContext;
+    // Remove when https://github.com/Adamfsk/jest-webgl-canvas-mock/pull/5 is merged
+    gl.createVertexArray = gl.getExtension('OES_vertex_array_object')?.createVertexArrayOES;
+    gl.bindVertexArray = gl.getExtension('OES_vertex_array_object')?.bindVertexArrayOES;
+    const context = new Context(gl);
+
+    const valueTest = <T>(Constructor: new (...args:any[]) => IValue<T>,
+        options: {
+            setValue: T;
+            equality?: (a: T, b: T) => boolean;
+        }
+    ) => {
+        test('#constructor', () => {
+            const v = new Constructor(context);
+            expect(v).toBeTruthy();
+            const currentV = v.get();
+            expect(typeof currentV).not.toBe('undefined');
+        });
+
+        test('#set', () => {
+            const v = new Constructor(context);
+            v.set(options.setValue);
+            const equality = (options.equality) || ((a, b) => deepEqual(a, b));
+            expect(equality(v.get(), options.setValue)).toBeTruthy();
+        });
+    };
+
+    valueTest(ClearColor, {
+        setValue: new Color(1, 1, 0, 1)
+    });
+    valueTest(ClearDepth, {
+        setValue: 0.5
+    });
+    valueTest(ClearStencil, {
+        setValue: 0.5
+    });
+
+    valueTest(ColorMask, {
+        setValue: [false, false, true, true]
+    });
+    valueTest(DepthMask, {
+        setValue: false
+    });
+    valueTest(StencilMask, {
+        setValue: 0x00
+    });
+    valueTest(StencilFunc, {
+        setValue: {
+            func: context.gl.LEQUAL,
+            ref: 1,
+            mask: 0xFF
+        }
+    });
+    valueTest(StencilOp, {
+        setValue: [context.gl.KEEP, context.gl.REPLACE, context.gl.REPLACE]
+    });
+    valueTest(StencilTest, {
+        setValue: true
+    });
+    valueTest(DepthRange, {
+        setValue: [0, 0.1]
+    });
+    valueTest(DepthTest, {
+        setValue: true
+    });
+    valueTest(DepthFunc, {
+        setValue: context.gl.EQUAL
+    });
+    valueTest(Blend, {
+        setValue: false
+    });
+    valueTest(BlendFunc, {
+        setValue: [context.gl.SRC_ALPHA, context.gl.SRC_ALPHA]
+    });
+    valueTest(BlendColor, {
+        setValue: Color.white
+    });
+    valueTest(ProgramValue, {
+        equality: (a, b) => a === b,
+        setValue: context.gl.createProgram()
+    });
+    valueTest(ActiveTextureUnit, {
+        setValue: context.gl.TEXTURE1
+    });
+    valueTest(Viewport, {
+        setValue: [0, 0, 1, 1]
+    });
+    valueTest(BindFramebuffer, {
+        equality: (a, b) => a === b,
+        setValue: context.gl.createFramebuffer()
+    });
+    valueTest(BindRenderbuffer, {
+        equality: (a, b) => a === b,
+        setValue: context.gl.createRenderbuffer()
+    });
+    valueTest(BindTexture, {
+        equality: (a, b) => a === b,
+        setValue: context.gl.createTexture()
+    });
+    valueTest(BindVertexBuffer, {
+        equality: (a, b) => a === b,
+        setValue: context.gl.createBuffer()
+    });
+    valueTest(BindElementBuffer, {
+        equality: (a, b) => a === b,
+        setValue: context.gl.createBuffer()
+    });
+    valueTest(BindVertexArray, {
+        equality: (a, b) => a === b,
+        setValue: context.createVertexArray()
+    });
+    valueTest(PixelStoreUnpack, {
+        setValue: 8
+    });
+    valueTest(PixelStoreUnpackPremultiplyAlpha, {
+        setValue: true
+    });
+});

package/src/gl/stencil_mode.ts

@@ -0,0 +1,27 @@
+import type {StencilOpConstant, StencilTestGL} from './types';
+
+const ALWAYS = 0x0207;
+const KEEP = 0x1E00;
+
+export class StencilMode {
+    test: StencilTestGL;
+    ref: number;
+    mask: number;
+    fail: StencilOpConstant;
+    depthFail: StencilOpConstant;
+    pass: StencilOpConstant;
+
+    constructor(test: StencilTestGL, ref: number, mask: number, fail: StencilOpConstant,
+        depthFail: StencilOpConstant, pass: StencilOpConstant) {
+        this.test = test;
+        this.ref = ref;
+        this.mask = mask;
+        this.fail = fail;
+        this.depthFail = depthFail;
+        this.pass = pass;
+    }
+
+    static disabled: Readonly<StencilMode>;
+}
+
+StencilMode.disabled = new StencilMode({func: ALWAYS, mask: 0}, 0, 0, KEEP, KEEP, KEEP);

package/src/gl/types.ts

@@ -0,0 +1,59 @@
+type BlendFuncConstant = WebGLRenderingContextBase['ZERO'] | WebGLRenderingContextBase['ONE'] | WebGLRenderingContextBase['SRC_COLOR'] | WebGLRenderingContextBase['ONE_MINUS_SRC_COLOR'] | WebGLRenderingContextBase['DST_COLOR'] | WebGLRenderingContextBase['ONE_MINUS_DST_COLOR'] | WebGLRenderingContextBase['SRC_ALPHA'] | WebGLRenderingContextBase['ONE_MINUS_SRC_ALPHA'] | WebGLRenderingContextBase['DST_ALPHA'] | WebGLRenderingContextBase['ONE_MINUS_DST_ALPHA'] | WebGLRenderingContextBase['CONSTANT_COLOR'] | WebGLRenderingContextBase['ONE_MINUS_CONSTANT_COLOR'] | WebGLRenderingContextBase['CONSTANT_ALPHA'] | WebGLRenderingContextBase['ONE_MINUS_CONSTANT_ALPHA'] | WebGLRenderingContextBase['BLEND_COLOR'];
+
+export type BlendFuncType = [BlendFuncConstant, BlendFuncConstant];
+
+export type BlendEquationType = WebGLRenderingContextBase['FUNC_ADD'] | WebGLRenderingContextBase['FUNC_SUBTRACT'] | WebGLRenderingContextBase['FUNC_REVERSE_SUBTRACT'];
+
+export type ColorMaskType = [boolean, boolean, boolean, boolean];
+
+export type CompareFuncType = WebGLRenderingContextBase['NEVER'] | WebGLRenderingContextBase['LESS'] | WebGLRenderingContextBase['EQUAL'] | WebGLRenderingContextBase['LEQUAL'] | WebGLRenderingContextBase['GREATER'] | WebGLRenderingContextBase['NOTEQUAL'] | WebGLRenderingContextBase['GEQUAL'] | WebGLRenderingContextBase['ALWAYS'];
+
+export type DepthMaskType = boolean;
+
+export type DepthRangeType = [number, number];
+
+export type DepthFuncType = CompareFuncType;
+
+export type StencilFuncType = {
+    func: CompareFuncType;
+    ref: number;
+    mask: number;
+};
+
+export type StencilOpConstant = WebGLRenderingContextBase['KEEP'] | WebGLRenderingContextBase['ZERO'] | WebGLRenderingContextBase['REPLACE'] | WebGLRenderingContextBase['INCR'] | WebGLRenderingContextBase['INCR_WRAP'] | WebGLRenderingContextBase['DECR'] | WebGLRenderingContextBase['DECR_WRAP'] | WebGLRenderingContextBase['INVERT'];
+
+export type StencilOpType = [StencilOpConstant, StencilOpConstant, StencilOpConstant];
+
+export type TextureUnitType = number;
+
+export type ViewportType = [number, number, number, number];
+
+export type StencilTestGL = {
+    func: WebGLRenderingContextBase['NEVER'];
+    mask: 0;
+} | {
+    func: WebGLRenderingContextBase['LESS'];
+    mask: number;
+} | {
+    func: WebGLRenderingContextBase['EQUAL'];
+    mask: number;
+} | {
+    func: WebGLRenderingContextBase['LEQUAL'];
+    mask: number;
+} | {
+    func: WebGLRenderingContextBase['GREATER'];
+    mask: number;
+} | {
+    func: WebGLRenderingContextBase['NOTEQUAL'];
+    mask: number;
+} | {
+    func: WebGLRenderingContextBase['GEQUAL'];
+    mask: number;
+} | {
+    func: WebGLRenderingContextBase['ALWAYS'];
+    mask: 0;
+};
+
+export type CullFaceModeType = WebGLRenderingContextBase['FRONT'] | WebGLRenderingContextBase['BACK'] | WebGLRenderingContextBase['FRONT_AND_BACK'];
+
+export type FrontFaceType = WebGLRenderingContextBase['CW'] | WebGLRenderingContextBase['CCW'];