@luma.gl/webgl 9.0.0-alpha.9 → 9.0.0-beta.10

package/LICENSE

@@ -1,4 +1,6 @@
-Copyright (c) 2020 Urban Computing Foundation
+luma.gl is provided under the MIT license
+
+Copyright (c) 2020 vis.gl contributors
 
 This software includes parts initially developed by Uber and open sourced under MIT license.
 Copyright (c) 2015 Uber Technologies, Inc.

package/dist/adapter/converters/device-parameters.d.ts

@@ -1,6 +1,15 @@
-import { Device, Parameters, CompareFunction } from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import type { GLParameters } from '../../types/webgl';
+import { Device, Parameters, CompareFunction } from '@luma.gl/core';
+import { GL } from '@luma.gl/constants';
+import type { GLParameters } from '@luma.gl/constants';
+/**
+ * Execute a function with a set of temporary WebGL parameter overrides
+ * - Saves current "global" WebGL context settings
+ * - Sets the supplies WebGL context parameters,
+ * - Executes supplied function
+ * - Restores parameters
+ * - Returns the return value of the supplied function
+ */
+export declare function withDeviceAndGLParameters<T = unknown>(device: Device, parameters: Parameters, glParameters: GLParameters, func: (device?: Device) => T): T;
 /**
  * Execute a function with a set of temporary WebGL parameter overrides
  * - Saves current "global" WebGL context settings

package/dist/adapter/converters/device-parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/device-parameters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,eAAe,EAAuC,MAAM,cAAc,CAAC;AACvG,OAAO,EAAE,MAAM,oBAAoB,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAKtD;;;;;;;;GAQG;AACF,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAAG,CAAC,CAgBxH;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAAG,CAAC,CAgBzH;AAGD,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,QAoGzE;AAyBD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,EAAE,CAWpF;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,eAAe,CAWtF"}
+{"version":3,"file":"device-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/device-parameters.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,MAAM,EACN,UAAU,EACV,eAAe,EAMhB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,KAAK,EAAmC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAOvF;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,OAAO,EACnD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAC1C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAeH;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,OAAO,EAC9C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,QAkMzE;AAyBD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,EAAE,CAWpF;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,eAAe,CAWtF"}

package/dist/adapter/converters/device-parameters.js

@@ -1,168 +1,322 @@
-import { log, isObjectEmpty } from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import { pushContextState, popContextState } from '../../context/state-tracker/track-context-state';
-import { setParameters } from '../../context/parameters/unified-parameter-api';
-import WebGLDevice from '../webgl-device';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { log, isObjectEmpty } from '@luma.gl/core';
+import { GL } from '@luma.gl/constants';
+import { pushContextState, popContextState } from "../../context/state-tracker/track-context-state.js";
+import { setGLParameters } from "../../context/parameters/unified-parameter-api.js";
+/* eslint-disable no-unused-expressions */ // For expression ? gl.enable() : gl.disable()
+/**
+ * Execute a function with a set of temporary WebGL parameter overrides
+ * - Saves current "global" WebGL context settings
+ * - Sets the supplies WebGL context parameters,
+ * - Executes supplied function
+ * - Restores parameters
+ * - Returns the return value of the supplied function
+ */
+export function withDeviceAndGLParameters(device, parameters, glParameters, func) {
+    if (isObjectEmpty(parameters)) {
+        // Avoid setting state if no parameters provided. Just call and return
+        return func(device);
+    }
+    // Wrap in a try-catch to ensure that parameters are restored on exceptions
+    const webglDevice = device;
+    pushContextState(webglDevice.gl);
+    try {
+        setDeviceParameters(device, parameters);
+        setGLParameters(webglDevice.gl, glParameters);
+        return func(device);
+    }
+    finally {
+        popContextState(webglDevice.gl);
+    }
+}
+/**
+ * Execute a function with a set of temporary WebGL parameter overrides
+ * - Saves current "global" WebGL context settings
+ * - Sets the supplies WebGL context parameters,
+ * - Executes supplied function
+ * - Restores parameters
+ * - Returns the return value of the supplied function
+ * @deprecated use withDeviceParameters instead
+ */
 export function withGLParameters(device, parameters, func) {
-  if (isObjectEmpty(parameters)) {
-    return func(device);
-  }
-
-  pushContextState(device.gl);
-
-  try {
-    setParameters(device, parameters);
-    return func(device);
-  } finally {
-    popContextState(device.gl);
-  }
+    if (isObjectEmpty(parameters)) {
+        // Avoid setting state if no parameters provided. Just call and return
+        return func(device);
+    }
+    // Wrap in a try-catch to ensure that parameters are restored on exceptions
+    const webglDevice = device;
+    pushContextState(webglDevice.gl);
+    try {
+        setGLParameters(webglDevice.gl, parameters);
+        return func(device);
+    }
+    finally {
+        popContextState(webglDevice.gl);
+    }
 }
+/**
+ * Execute a function with a set of temporary WebGL parameter overrides
+ * - Saves current "global" WebGL context settings
+ * - Sets the supplies WebGL context parameters,
+ * - Executes supplied function
+ * - Restores parameters
+ * - Returns the return value of the supplied function
+ */
 export function withDeviceParameters(device, parameters, func) {
-  if (isObjectEmpty(parameters)) {
-    return func(device);
-  }
-
-  pushContextState(device.gl);
-
-  try {
-    setDeviceParameters(device, parameters);
-    return func(device);
-  } finally {
-    popContextState(device.gl);
-  }
+    if (isObjectEmpty(parameters)) {
+        // Avoid setting state if no parameters provided. Just call and return
+        return func(device);
+    }
+    // Wrap in a try-catch to ensure that parameters are restored on exceptions
+    // @ts-expect-error
+    pushContextState(device.gl);
+    try {
+        setDeviceParameters(device, parameters);
+        return func(device);
+    }
+    finally {
+        // @ts-expect-error
+        popContextState(device.gl);
+    }
 }
+/** Set WebGPU Style Parameters */
 export function setDeviceParameters(device, parameters) {
-  const webglDevice = WebGLDevice.attach(device);
-  const {
-    gl,
-    gl2
-  } = webglDevice;
-
-  if (parameters.cullMode) {
-    switch (parameters.cullMode) {
-      case 'none':
-        gl.disable(GL.CULL_FACE);
-        break;
-
-      case 'front':
-        gl.enable(GL.CULL_FACE);
-        gl.cullFace(GL.FRONT);
-        break;
-
-      case 'back':
-        gl.enable(GL.CULL_FACE);
-        gl.cullFace(GL.BACK);
-        break;
+    const webglDevice = device;
+    const { gl } = webglDevice;
+    // RASTERIZATION SETTINGS
+    if (parameters.cullMode) {
+        switch (parameters.cullMode) {
+            case 'none':
+                gl.disable(2884);
+                break;
+            case 'front':
+                gl.enable(2884);
+                gl.cullFace(1028);
+                break;
+            case 'back':
+                gl.enable(2884);
+                gl.cullFace(1029);
+                break;
+        }
     }
-  }
-
-  if (parameters.frontFace) {
-    gl.frontFace(map('frontFace', parameters.frontFace, {
-      ccw: GL.CCW,
-      cw: GL.CW
-    }));
-  }
-
-  if (parameters.depthBias !== undefined) {
-    gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
-  }
-
-  if (parameters.depthWriteEnabled !== undefined) {
-    gl.depthMask(mapBoolean('depthWriteEnabled', parameters.depthWriteEnabled));
-  }
-
-  if (parameters.depthCompare) {
-    parameters.depthCompare !== 'always' ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST);
-    gl.depthFunc(convertCompareFunction('depthCompare', parameters.depthCompare));
-  }
-
-  if (parameters.stencilWriteMask) {
-    const mask = parameters.stencilWriteMask;
-    gl.stencilMaskSeparate(GL.FRONT, mask);
-    gl.stencilMaskSeparate(GL.BACK, mask);
-  }
-
-  if (parameters.stencilReadMask) {
-    log.warn('stencilReadMask not supported under WebGL');
-  }
+    if (parameters.frontFace) {
+        gl.frontFace(map('frontFace', parameters.frontFace, {
+            ccw: 2305,
+            cw: 2304
+        }));
+    }
+    if (parameters.unclippedDepth) {
+        if (device.features.has('depth-clip-control')) {
+            // EXT_depth_clamp
+            gl.enable(34383);
+        }
+    }
+    if (parameters.depthBias !== undefined) {
+        gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
+    }
+    // depthBiasSlopeScale: {
+    //   // Handled by depthBias
+    // },
+    // WEBGL EXTENSIONS
+    if (device.features.has('provoking-vertex-webgl')) {
+        const extensions = webglDevice.getExtension('WEBGL_provoking_vertex');
+        const ext = extensions.WEBGL_provoking_vertex;
+        if (parameters.provokingVertex) {
+            const vertex = map('provokingVertex', parameters.provokingVertex, {
+                first: 36429,
+                last: 36430
+            });
+            ext?.provokingVertexWEBGL(vertex);
+        }
+    }
+    if (device.features.has('polygon-mode-webgl')) {
+        const extensions = webglDevice.getExtension('WEBGL_polygon_mode');
+        const ext = extensions.WEBGL_polygon_mode;
+        if (parameters.polygonMode) {
+            const mode = map('polygonMode', parameters.provokingVertex, {
+                fill: 6914,
+                lint: 6913
+            });
+            ext?.polygonModeWEBGL(1028, mode);
+            ext?.polygonModeWEBGL(1029, mode);
+        }
+        if (parameters.polygonOffsetLine) {
+            gl.enable(10754);
+        }
+    }
+    if (device.features.has('shader-clip-cull-distance-webgl')) {
+        if (parameters.clipDistance0) {
+            gl.enable(12288);
+        }
+        if (parameters.clipDistance1) {
+            gl.enable(12289);
+        }
+        if (parameters.clipDistance2) {
+            gl.enable(12290);
+        }
+        if (parameters.clipDistance3) {
+            gl.enable(12291);
+        }
+        if (parameters.clipDistance4) {
+            gl.enable(12292);
+        }
+        if (parameters.clipDistance5) {
+            gl.enable(12293);
+        }
+        if (parameters.clipDistance6) {
+            gl.enable(12294);
+        }
+        if (parameters.clipDistance7) {
+            gl.enable(12295);
+        }
+    }
+    // DEPTH STENCIL
+    if (parameters.depthWriteEnabled !== undefined) {
+        gl.depthMask(mapBoolean('depthWriteEnabled', parameters.depthWriteEnabled));
+    }
+    if (parameters.depthCompare) {
+        parameters.depthCompare !== 'always' ? gl.enable(2929) : gl.disable(2929);
+        gl.depthFunc(convertCompareFunction('depthCompare', parameters.depthCompare));
+    }
+    if (parameters.stencilWriteMask) {
+        const mask = parameters.stencilWriteMask;
+        gl.stencilMaskSeparate(1028, mask);
+        gl.stencilMaskSeparate(1029, mask);
+    }
+    if (parameters.stencilReadMask) {
+        // stencilReadMask is handle inside stencil***Compare.
+        log.warn('stencilReadMask not supported under WebGL');
+    }
+    if (parameters.stencilCompare) {
+        const mask = parameters.stencilReadMask || 0xffffffff;
+        const glValue = convertCompareFunction('depthCompare', parameters.stencilCompare);
+        // TODO - ensure back doesn't overwrite
+        parameters.stencilCompare !== 'always'
+            ? gl.enable(2960)
+            : gl.disable(2960);
+        gl.stencilFuncSeparate(1028, glValue, 0, mask);
+        gl.stencilFuncSeparate(1029, glValue, 0, mask);
+    }
+    if (parameters.stencilPassOperation &&
+        parameters.stencilFailOperation &&
+        parameters.stencilDepthFailOperation) {
+        const dppass = convertStencilOperation('stencilPassOperation', parameters.stencilPassOperation);
+        const sfail = convertStencilOperation('stencilFailOperation', parameters.stencilFailOperation);
+        const dpfail = convertStencilOperation('stencilDepthFailOperation', parameters.stencilDepthFailOperation);
+        gl.stencilOpSeparate(1028, sfail, dpfail, dppass);
+        gl.stencilOpSeparate(1029, sfail, dpfail, dppass);
+    }
+    // stencilDepthFailOperation() {
+    //   // handled by stencilPassOperation
+    // },
+    // stencilFailOperation() {
+    //   // handled by stencilPassOperation
+    // },
+    // COLOR STATE
+    if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
+        gl.enable(3042);
+        const colorEquation = convertBlendOperationToEquation('blendColorOperation', parameters.blendColorOperation || 'add');
+        const alphaEquation = convertBlendOperationToEquation('blendAlphaOperation', parameters.blendAlphaOperation || 'add');
+        gl.blendEquationSeparate(colorEquation, alphaEquation);
+        const colorSrcFactor = convertBlendFactorToFunction('blendColorSrcFactor', parameters.blendColorSrcFactor || 'one');
+        const colorDstFactor = convertBlendFactorToFunction('blendColorDstFactor', parameters.blendColorDstFactor || 'zero');
+        const alphaSrcFactor = convertBlendFactorToFunction('blendAlphaSrcFactor', parameters.blendAlphaSrcFactor || 'one');
+        const alphaDstFactor = convertBlendFactorToFunction('blendAlphaDstFactor', parameters.blendAlphaDstFactor || 'zero');
+        gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);
+    }
+}
+/*
+      rasterizationState: {
+        cullMode: "back",
+      },
 
-  if (parameters.stencilCompare) {
-    const mask = parameters.stencilReadMask || 0xffffffff;
-    const glValue = convertCompareFunction('depthCompare', parameters.stencilCompare);
-    parameters.stencilCompare !== 'always' ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST);
-    gl.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);
-    gl.stencilFuncSeparate(GL.BACK, glValue, 0, mask);
-  }
+      depthStencilState: {
+        depthWriteEnabled: true,
+        depthCompare: "less",
+        format: "depth24plus-stencil8",
+      },
 
-  if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
-    const dppass = convertStencilOperation('stencilPassOperation', parameters.stencilPassOperation);
-    const sfail = convertStencilOperation('stencilFailOperation', parameters.stencilFailOperation);
-    const dpfail = convertStencilOperation('stencilDepthFailOperation', parameters.stencilDepthFailOperation);
-    gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);
-  }
-}
+      colorStates: [
+        {
+          format: "bgra8unorm",
+          // colorBlend.srcFactor = wgpu::BlendFactor::SrcAlpha;
+          // colorBlend.dstFactor = wgpu::BlendFactor::OneMinusSrcAlpha;
+          // alphaBlend.srcFactor = wgpu::BlendFactor::SrcAlpha;
+          // alphaBlend.dstFactor = wgpu::BlendFactor::OneMinusSrcAlpha;
+        },
+      ],
+    });
+*/
 export function convertCompareFunction(parameter, value) {
-  return map(parameter, value, {
-    'never': GL.NEVER,
-    'less': GL.LESS,
-    'equal': GL.EQUAL,
-    'less-equal': GL.LEQUAL,
-    'greater': GL.GREATER,
-    'not-equal': GL.NOTEQUAL,
-    'greater-equal': GL.GEQUAL,
-    'always': GL.ALWAYS
-  });
+    return map(parameter, value, {
+        never: 512,
+        less: 513,
+        equal: 514,
+        'less-equal': 515,
+        greater: 516,
+        'not-equal': 517,
+        'greater-equal': 518,
+        always: 519
+    });
 }
 export function convertToCompareFunction(parameter, value) {
-  return map(parameter, value, {
-    [GL.NEVER]: 'never',
-    [GL.LESS]: 'less',
-    [GL.EQUAL]: 'equal',
-    [GL.LEQUAL]: 'less-equal',
-    [GL.GREATER]: 'greater',
-    [GL.NOTEQUAL]: 'not-equal',
-    [GL.GEQUAL]: 'greater-equal',
-    [GL.ALWAYS]: 'always'
-  });
+    return map(parameter, value, {
+        [512]: 'never',
+        [513]: 'less',
+        [514]: 'equal',
+        [515]: 'less-equal',
+        [516]: 'greater',
+        [517]: 'not-equal',
+        [518]: 'greater-equal',
+        [519]: 'always'
+    });
 }
-
 function convertStencilOperation(parameter, value) {
-  return map(parameter, value, {
-    'keep': GL.KEEP,
-    'zero': GL.ZERO,
-    'replace': GL.REPLACE,
-    'invert': GL.INVERT,
-    'increment-clamp': GL.INCR,
-    'decrement-clamp': GL.DECR,
-    'increment-wrap': GL.INCR_WRAP,
-    'decrement-wrap': GL.DECR_WRAP
-  });
+    return map(parameter, value, {
+        keep: 7680,
+        zero: 0,
+        replace: 7681,
+        invert: 5386,
+        'increment-clamp': 7682,
+        'decrement-clamp': 7683,
+        'increment-wrap': 34055,
+        'decrement-wrap': 34056
+    });
 }
-
 function convertBlendOperationToEquation(parameter, value) {
-  return map(parameter, value, {
-    'add': GL.FUNC_ADD,
-    'sub': GL.FUNC_SUBTRACT,
-    'reverse-subtract': GL.FUNC_REVERSE_SUBTRACT,
-    'min': GL.MIN,
-    'max': GL.MAX
-  });
+    return map(parameter, value, {
+        add: 32774,
+        subtract: 32778,
+        'reverse-subtract': 32779,
+        min: 32775,
+        max: 32776
+    });
+}
+function convertBlendFactorToFunction(parameter, value) {
+    return map(parameter, value, {
+        one: 1,
+        zero: 0,
+        'src-color': 768,
+        'one-minus-src-color': 769,
+        'dst-color': 774,
+        'one-minus-dst-color': 775,
+        'src-alpha': 770,
+        'one-minus-src-alpha': 771,
+        'dst-alpha': 772,
+        'one-minus-dst-alpha': 773
+    });
 }
-
 function message(parameter, value) {
-  return "Illegal parameter ".concat(value, " for ").concat(parameter);
+    return `Illegal parameter ${value} for ${parameter}`;
 }
-
 function map(parameter, value, valueMap) {
-  if (!(value in valueMap)) {
-    throw new Error(message(parameter, value));
-  }
-
-  return valueMap[value];
+    if (!(value in valueMap)) {
+        throw new Error(message(parameter, value));
+    }
+    return valueMap[value];
 }
-
 function mapBoolean(parameter, value) {
-  return value;
+    return value;
 }
-//# sourceMappingURL=device-parameters.js.map

package/dist/adapter/converters/sampler-parameters.d.ts

@@ -1,19 +1,9 @@
-import { SamplerParameters } from '@luma.gl/api';
-import { GLSamplerParameters } from '../../types/webgl';
+import { SamplerProps } from '@luma.gl/core';
+import { GLSamplerParameters } from '@luma.gl/constants';
 /**
  * Convert WebGPU-style sampler props to WebGL
  * @param props
  * @returns
  */
-export declare function convertSamplerParametersToWebGL(props: SamplerParameters): GLSamplerParameters;
-/**
- * Convert WebGL-style sampler props to WebGPU
- * @param props
- * @returns
- */
-export declare function convertToSamplerParameters(params: GLSamplerParameters): SamplerParameters;
-/**
- * Override sampler settings that are not supported by Non-Power-of-Two textures in WebGL1.
-*/
-export declare function updateSamplerParametersForNPOT(parameters: GLSamplerParameters): GLSamplerParameters;
+export declare function convertSamplerParametersToWebGL(props: SamplerProps): GLSamplerParameters;
 //# sourceMappingURL=sampler-parameters.d.ts.map

package/dist/adapter/converters/sampler-parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/sampler-parameters.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,iBAAiB,EAAC,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAC,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAGtD;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,iBAAiB,GAAG,mBAAmB,CAoC7F;AAkCD;;;;GAIG;AACF,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,mBAAmB,GAAG,iBAAiB,CAqC1F;AA+CD;;EAEE;AACF,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,mBAAmB,GAAG,mBAAmB,CAUnG"}
+{"version":3,"file":"sampler-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/sampler-parameters.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAK,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAG3D;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,YAAY,GAAG,mBAAmB,CAuCxF"}