@luma.gl/webgl 8.5.9 → 8.6.0-alpha.3

package/LICENSE

@@ -1,9 +1,16 @@
+Copyright (c) 2020 Urban Computing Foundation
+
+This software includes parts initially developed by Uber and open sourced under MIT license.
 Copyright (c) 2015 Uber Technologies, Inc.
 
 This software includes parts of PhiloGL (https://github.com/philogb/philogl)
 under MIT license. PhiloGL parts Copyright © 2013 Sencha Labs.
 
-This software includes adaptations of postprocessing code from THREE.js (https://github.com/mrdoob/three.js/) under MIT license. Additional attribution given in specific source files. THREE.js parts Copyright © 2010-2018 three.js authors.
+This software includes adaptations of some postprocessing code from 
+THREE.js (https://github.com/mrdoob/three.js/) under MIT license. 
+THREE.js parts Copyright © 2010-2018 three.js authors. 
+
+Additional attribution given in specific source files. 
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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

@@ -0,0 +1,5 @@
+import { Device, Parameters, CompareFunction } from '@luma.gl/api';
+/** Set WebGPU Style Parameters */
+export declare function setDeviceParameters(device: Device, parameters: Parameters): void;
+export declare function convertCompareFunction(parameter: any, value: CompareFunction): number;
+//# sourceMappingURL=set-device-parameters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"set-device-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/set-device-parameters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,eAAe,EAAwB,MAAM,cAAc,CAAC;AAIxF,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,QAoGzE;AA0BD,wBAAgB,sBAAsB,CAAC,SAAS,KAAA,EAAE,KAAK,EAAE,eAAe,GAAG,MAAM,CAWhF"}

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

@@ -0,0 +1,124 @@
+import { log } from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+import { WebGLDevice } from '@luma.gl/webgl';
+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;
+    }
+  }
+
+  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.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);
+  }
+
+  if (parameters.stencilPassOperation) {
+    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);
+  }
+}
+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
+  });
+}
+
+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
+  });
+}
+
+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
+  });
+}
+
+function message(parameter, value) {
+  return "Illegal parameter ".concat(value, " for ").concat(parameter);
+}
+
+function map(parameter, value, valueMap) {
+  if (!(value in valueMap)) {
+    throw new Error(message(parameter, value));
+  }
+
+  return valueMap[value];
+}
+
+function mapBoolean(parameter, value) {
+  return value;
+}
+//# sourceMappingURL=set-device-parameters.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapter/converters/set-device-parameters.ts"],"names":["log","GL","WebGLDevice","setDeviceParameters","device","parameters","webglDevice","attach","gl","gl2","cullMode","disable","CULL_FACE","enable","cullFace","FRONT","BACK","frontFace","map","ccw","CCW","cw","CW","depthBias","undefined","polygonOffset","depthBiasSlopeScale","depthWriteEnabled","depthMask","mapBoolean","depthCompare","DEPTH_TEST","depthFunc","convertCompareFunction","stencilWriteMask","mask","stencilMaskSeparate","stencilReadMask","warn","stencilCompare","glValue","STENCIL_TEST","stencilFuncSeparate","stencilPassOperation","dppass","convertStencilOperation","sfail","stencilFailOperation","dpfail","stencilDepthFailOperation","stencilOpSeparate","parameter","value","NEVER","LESS","EQUAL","LEQUAL","GREATER","NOTEQUAL","GEQUAL","ALWAYS","KEEP","ZERO","REPLACE","INVERT","INCR","DECR","INCR_WRAP","DECR_WRAP","convertBlendOperationToEquation","FUNC_ADD","FUNC_SUBTRACT","FUNC_REVERSE_SUBTRACT","MIN","MAX","message","valueMap","Error"],"mappings":"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","sourcesContent":["import {Device, Parameters, CompareFunction, StencilOperation, log} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport {WebGLDevice} from '@luma.gl/webgl';\n\n/** Set WebGPU Style Parameters */\nexport function setDeviceParameters(device: Device, parameters: Parameters) {\n  const webglDevice = WebGLDevice.attach(device);\n  const {gl, gl2} = webglDevice;\n\n  // RASTERIZATION SETTINGS\n  if (parameters.cullMode) {\n    switch (parameters.cullMode) {\n      case 'none':\n        gl.disable(GL.CULL_FACE);\n        break;\n      case 'front':\n        gl.enable(GL.CULL_FACE);\n        gl.cullFace(GL.FRONT);\n        break;\n      case 'back':\n        gl.enable(GL.CULL_FACE);\n        gl.cullFace(GL.BACK);\n        break;\n    }\n  }\n\n  if (parameters.frontFace) {\n    gl.frontFace(map('frontFace', parameters.frontFace, {\n      ccw: GL.CCW,\n      cw: GL.CW\n    }));\n  }\n\n  if (parameters.depthBias !== undefined) {\n    gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);\n  }\n\n  // depthBiasSlopeScale: {\n  //   // Handled by depthBias\n  // },\n\n  // DEPTH STENCIL\n\n  if (parameters.depthWriteEnabled !== undefined) {\n    gl.depthMask(mapBoolean('depthWriteEnabled', parameters.depthWriteEnabled));\n  }\n\n if (parameters.depthCompare) {\n    parameters.depthCompare !== 'always' ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST),\n    gl.depthFunc(convertCompareFunction('depthCompare', parameters.depthCompare));\n  }\n\n  if (parameters.stencilWriteMask) {\n    const mask = parameters.stencilWriteMask;\n    gl.stencilMaskSeparate(GL.FRONT, mask);\n    gl.stencilMaskSeparate(GL.BACK, mask);\n  }\n\n  if (parameters.stencilReadMask) {\n    // stencilReadMask is handle inside stencil***Compare.\n    log.warn('stencilReadMask not supported under WebGL');\n  }\n\n  if (parameters.stencilCompare) {\n    const mask = parameters.stencilReadMask || 0xffffffff;\n    const glValue = convertCompareFunction('depthCompare', parameters.stencilCompare);\n    // TODO - ensure back doesn't overwrite\n    parameters.stencilCompare !== 'always' ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST),\n    gl.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);\n    gl.stencilFuncSeparate(GL.BACK, glValue, 0, mask);\n  }\n\n  if (parameters.stencilPassOperation) {\n    const dppass = convertStencilOperation('stencilPassOperation', parameters.stencilPassOperation);\n    const sfail = convertStencilOperation('stencilFailOperation', parameters.stencilFailOperation);\n    const dpfail = convertStencilOperation('stencilDepthFailOperation', parameters.stencilDepthFailOperation);\n    gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);\n    gl.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);\n  }\n\n  // stencilDepthFailOperation() {\n  //   // handled by stencilPassOperation\n  // },\n\n  // stencilFailOperation() {\n  //   // handled by stencilPassOperation\n  // },\n\n  // COLOR STATE\n\n  // if (parameters.blend) {\n  //   gl.enable(GL.BLEND);\n\n  //   const blend = parameters.blend;\n\n  //   let colorEquation = (blend && blend.color && blend.color.operation) || 'add';\n  //   let alphaEquation = (blend && blend.alpha && blend.alpha.operation) || 'add';\n  //   gl.blendEquationSeparate(colorEquation, alphaEquation);\n\n  //   let colorSrcFactor = (blend && blend.color && blend.color.srcFactor) || 'one';\n  //   let colorDstFactor = (blend && blend.color && blend.color.dstFactor) || 'zero';\n  //   let alphaSrcFactor = (blend && blend.alpha && blend.alpha.srcFactor) || 'one';\n  //   let alphaDstFactor = (blend && blend.alpha && blend.alpha.dstFactor) || 'zero';\n  //   gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);\n  // }\n}\n\n/*\n      rasterizationState: {\n        cullMode: \"back\",\n      },\n\n      depthStencilState: {\n        depthWriteEnabled: true,\n        depthCompare: \"less\",\n        format: \"depth24plus-stencil8\",\n      },\n\n      colorStates: [\n        {\n          format: \"bgra8unorm\",\n          // colorBlend.srcFactor = wgpu::BlendFactor::SrcAlpha;\n          // colorBlend.dstFactor = wgpu::BlendFactor::OneMinusSrcAlpha;\n          // alphaBlend.srcFactor = wgpu::BlendFactor::SrcAlpha;\n          // alphaBlend.dstFactor = wgpu::BlendFactor::OneMinusSrcAlpha;\n        },\n      ],\n    });\n*/\n\n\nexport function convertCompareFunction(parameter, value: CompareFunction): number {\n  return map(parameter, value, {\n    'never': GL.NEVER,\n    'less': GL.LESS,\n    'equal': GL.EQUAL,\n    'less-equal': GL.LEQUAL,\n    'greater': GL.GREATER,\n    'not-equal': GL.NOTEQUAL,\n    'greater-equal': GL.GEQUAL,\n    'always': GL.ALWAYS\n  });\n}\n\nfunction convertStencilOperation(parameter, value: StencilOperation): number {\n  return map(parameter, value, {\n    'keep': GL.KEEP,\n    'zero': GL.ZERO,\n    'replace': GL.REPLACE,\n    'invert': GL.INVERT,\n    'increment-clamp': GL.INCR,\n    'decrement-clamp': GL.DECR,\n    'increment-wrap': GL.INCR_WRAP,\n    'decrement-wrap': GL.DECR_WRAP\n  });\n}\n\nfunction convertBlendOperationToEquation(parameter, value): number {\n  return map(parameter, value, {\n    'add': GL.FUNC_ADD,\n    'sub': GL.FUNC_SUBTRACT,\n    'reverse-subtract': GL.FUNC_REVERSE_SUBTRACT,\n    // When using a WebGL 2 context, the following values are available additionally:\n    'min': GL.MIN,\n    'max': GL.MAX\n  });\n}\n\nfunction message(parameter, value) {\n  return `Illegal parameter ${value} for ${parameter}`;\n}\n\nfunction map(parameter, value, valueMap) {\n  if (!(value in valueMap)) {\n    throw new Error(message(parameter, value));\n  }\n  return valueMap[value];\n}\n\nfunction mapBoolean(parameter, value) {\n  return value;\n}\n"],"file":"set-device-parameters.js"}

package/dist/adapter/converters/webgpu-texture-formats.d.ts

@@ -0,0 +1,281 @@
+import GL from '@luma.gl/constants';
+export declare const TEXTURE_FORMAT_DEFINITIONS: {
+    r8unorm: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    r8snorm: {
+        b: number;
+        c: number;
+    };
+    r8uint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    r8sint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    r16uint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    r16sint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    r16float: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: string;
+    };
+    rg8unorm: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    rg8snorm: {
+        b: number;
+        c: number;
+    };
+    rg8uint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    rg8sint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    r32uint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+        bpp: number;
+    };
+    r32sint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+        bpp: number;
+    };
+    r32float: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: string;
+        bpp: number;
+    };
+    rg16uint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+        bpp: number;
+    };
+    rg16sint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+        bpp: number;
+    };
+    rg16float: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: string;
+        bpp: number;
+    };
+    rgba8unorm: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+        bpp: number;
+    };
+    'rgba8unorm-srgb': {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+        gl1: string;
+        bpp: number;
+    };
+    rgba8snorm: {
+        b: number;
+        c: number;
+    };
+    rgba8uint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+        bpp: number;
+    };
+    rgba8sint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+        bpp: number;
+    };
+    bgra8unorm: {
+        b: number;
+        c: number;
+    };
+    'bgra8unorm-srgb': {
+        b: number;
+        c: number;
+    };
+    rgb9e5ufloat: {
+        b: number;
+        c: number;
+        p: number;
+        gl: GL;
+        gl2: boolean;
+        gl1: string;
+    };
+    rg11b10ufloat: {
+        b: number;
+        c: number;
+        p: number;
+        gl: GL;
+        gl2: string;
+    };
+    rgb10a2unorm: {
+        b: number;
+        c: number;
+        p: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    rg32uint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    rg32sint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    rg32float: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: string;
+    };
+    rgba16uint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    rgba16sint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    rgba16float: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: string;
+    };
+    rgba32uint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    rgba32sint: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    rgba32float: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: string;
+    };
+    stencil8: {
+        b: number;
+        c: number;
+        gl: GL;
+    };
+    depth16unorm: {
+        b: number;
+        c: number;
+        gl: GL;
+    };
+    depth24plus: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    'depth24plus-stencil8': {
+        b: number;
+        c: number;
+        p: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    depth32float: {
+        b: number;
+        c: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    'depth24unorm-stencil8': {
+        b: number;
+        c: number;
+        p: number;
+        gl: GL;
+    };
+    "depth32float-stencil8": {
+        b: number;
+        c: number;
+        p: number;
+        gl: GL;
+        gl2: boolean;
+    };
+    'bc1-rgba-unorm': {};
+    'bc1-rgba-unorm-srgb': {};
+    'bc2-rgba-unorm': {};
+    'bc2-rgba-unorm-srgb': {};
+    'bc3-rgba-unorm': {};
+    'bc3-rgba-unorm-srgb': {};
+    'bc4-r-unorm': {};
+    'bc4-r-snorm': {};
+    'bc5-rg-unorm': {};
+    'bc5-rg-snorm': {};
+    'bc6h-rgb-ufloat': {};
+    'bc6h-rgb-float': {};
+    'bc7-rgba-unorm': {};
+    'bc7-rgba-unorm-srgb': {};
+};
+//# sourceMappingURL=webgpu-texture-formats.d.ts.map

package/dist/adapter/converters/webgpu-texture-formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-texture-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/webgpu-texture-formats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAqBpC,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6FtC,CAAC"}