playcanvas 1.57.0 → 1.57.1

package/build/playcanvas-extras.js

@@ -1,6 +1,6 @@
 /**
  * @license
- * PlayCanvas Engine v1.57.0 revision f1998a31e
+ * PlayCanvas Engine v1.57.1 revision 256dd83c2
  * Copyright 2011-2022 PlayCanvas Ltd. All rights reserved.
  */
 (function (global, factory) {
@@ -28,6 +28,21 @@
 	  return Constructor;
 	}
 
+	function _inheritsLoose(subClass, superClass) {
+	  subClass.prototype = Object.create(superClass.prototype);
+	  subClass.prototype.constructor = subClass;
+
+	  _setPrototypeOf(subClass, superClass);
+	}
+
+	function _setPrototypeOf(o, p) {
+	  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+	    o.__proto__ = p;
+	    return o;
+	  };
+	  return _setPrototypeOf(o, p);
+	}
+
 	var CpuTimer = function () {
 	  function CpuTimer(app) {
 	    this._frameIndex = 0;
@@ -831,6 +846,57 @@
 	  return MiniStats;
 	}();
 
+	var CoreExporter = function () {
+	  function CoreExporter() {}
+
+	  var _proto = CoreExporter.prototype;
+
+	  _proto.imageToCanvas = function imageToCanvas(image, options) {
+	    if (options === void 0) {
+	      options = {};
+	    }
+
+	    if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof OffscreenCanvas !== 'undefined' && image instanceof OffscreenCanvas || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
+	      var width = image.width,
+	          height = image.height;
+	      var maxTextureSize = options.maxTextureSize;
+
+	      if (maxTextureSize) {
+	        var scale = Math.min(maxTextureSize / Math.max(width, height), 1);
+	        width = Math.round(width * scale);
+	        height = Math.round(height * scale);
+	      }
+
+	      var canvas = document.createElement('canvas');
+	      canvas.width = width;
+	      canvas.height = height;
+	      var context = canvas.getContext('2d');
+	      context.drawImage(image, 0, 0, canvas.width, canvas.height);
+
+	      if (options.color) {
+	        var _options$color = options.color,
+	            r = _options$color.r,
+	            g = _options$color.g,
+	            b = _options$color.b;
+	        var imagedata = context.getImageData(0, 0, width, height);
+	        var data = imagedata.data;
+
+	        for (var i = 0; i < data.length; i += 4) {
+	          data[i + 0] = data[i + 0] * r;
+	          data[i + 1] = data[i + 1] * g;
+	          data[i + 2] = data[i + 2] * b;
+	        }
+
+	        context.putImageData(imagedata, 0, 0);
+	      }
+
+	      return canvas;
+	    }
+	  };
+
+	  return CoreExporter;
+	}();
+
 	var u8 = Uint8Array,
 	    u16 = Uint16Array,
 	    u32 = Uint32Array;
@@ -1518,16 +1584,16 @@
 	  wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4;
 	  if (ce != null) d[b++] = 20, d[b++] = f.os;
 	  d[b] = 20, b += 2;
-	  d[b++] = f.flag << 1 | (c == null && 8), d[b++] = u && 8;
+	  d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
 	  d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
 	  var dt = new Date(f.mtime == null ? Date.now() : f.mtime),
 	      y = dt.getFullYear() - 1980;
 	  if (y < 0 || y > 119) err(10);
 	  wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >>> 1), b += 4;
 
-	  if (c != null) {
+	  if (c != -1) {
 	    wbytes(d, b, f.crc);
-	    wbytes(d, b + 4, c);
+	    wbytes(d, b + 4, c < 0 ? -c - 2 : c);
 	    wbytes(d, b + 8, f.size);
 	  }
 
@@ -1637,14 +1703,24 @@
 	  return "                    " + type + " inputs:" + name + " = " + value;
 	};
 
-	var UsdzExporter = function () {
+	var UsdzExporter = function (_CoreExporter) {
+	  _inheritsLoose(UsdzExporter, _CoreExporter);
+
 	  function UsdzExporter() {
-	    this.meshMap = void 0;
-	    this.materialMap = void 0;
-	    this.materials = void 0;
-	    this.textureMap = void 0;
-	    this.nodeNames = void 0;
-	    this.files = void 0;
+	    var _this;
+
+	    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+	      args[_key] = arguments[_key];
+	    }
+
+	    _this = _CoreExporter.call.apply(_CoreExporter, [this].concat(args)) || this;
+	    _this.meshMap = void 0;
+	    _this.materialMap = void 0;
+	    _this.materials = void 0;
+	    _this.textureMap = void 0;
+	    _this.nodeNames = void 0;
+	    _this.files = void 0;
+	    return _this;
 	  }
 
 	  var _proto = UsdzExporter.prototype;
@@ -1667,15 +1743,19 @@
 	    this.nodeNames = null;
 	  };
 
-	  _proto.build = function build(root) {
-	    var _this = this;
+	  _proto.build = function build(entity, options) {
+	    var _this2 = this;
+
+	    if (options === void 0) {
+	      options = {};
+	    }
 
 	    this.init();
 	    this.addFile(null, ROOT_FILE_NAME);
 	    var allMeshInstances = [];
 
-	    if (root) {
-	      var renders = root.findComponents("render");
+	    if (entity) {
+	      var renders = entity.findComponents("render");
 	      renders.forEach(function (render) {
 	        allMeshInstances.push.apply(allMeshInstances, render.meshInstances);
 	      });
@@ -1683,21 +1763,25 @@
 
 	    var rootContent = '';
 	    allMeshInstances.forEach(function (meshInstance) {
-	      rootContent += _this.buildMeshInstance(meshInstance);
+	      rootContent += _this2.buildMeshInstance(meshInstance);
 	    });
 	    rootContent += materialListTemplate(this.materials);
 	    this.addFile(null, ROOT_FILE_NAME, '', rootContent);
+	    var textureOptions = {
+	      maxTextureSize: options.maxTextureSize
+	    };
 	    var textureArray = Array.from(this.textureMap.keys());
 	    var promises = [];
 
 	    var _loop = function _loop(i) {
+	      var mimeType = 'image/png' ;
 	      var texture = textureArray[i];
 	      var mipObject = texture._levels[0];
 
-	      var canvas = _this.imageToCanvas(mipObject, undefined);
+	      var canvas = _this2.imageToCanvas(mipObject, textureOptions);
 
 	      promises.push(new Promise(function (resolve) {
-	        return canvas.toBlob(resolve, 'image/png' , 1);
+	        return canvas.toBlob(resolve, mimeType, 1);
 	      }).then(function (blob) {
 	        return blob.arrayBuffer();
 	      }));
@@ -1711,18 +1795,18 @@
 	      values.forEach(function (textureArrayBuffer, index) {
 	        var texture = textureArray[index];
 
-	        var ids = _this.getTextureFileIds(texture);
+	        var ids = _this2.getTextureFileIds(texture);
 
-	        _this.files[ids.fileName] = new Uint8Array(textureArrayBuffer);
+	        _this2.files[ids.fileName] = new Uint8Array(textureArrayBuffer);
 	      });
 
-	      _this.alignFiles();
+	      _this2.alignFiles();
 
-	      var arraybuffer = zipSync(_this.files, {
+	      var arraybuffer = zipSync(_this2.files, {
 	        level: 0
 	      });
 
-	      _this.done();
+	      _this2.done();
 
 	      return arraybuffer;
 	    });
@@ -1791,36 +1875,6 @@
 	    return ids.refName;
 	  };
 
-	  _proto.imageToCanvas = function imageToCanvas(image, color) {
-	    if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof OffscreenCanvas !== 'undefined' && image instanceof OffscreenCanvas || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
-	      var scale = 1024 / Math.max(image.width, image.height);
-	      var canvas = document.createElement('canvas');
-	      canvas.width = image.width * Math.min(1, scale);
-	      canvas.height = image.height * Math.min(1, scale);
-	      var context = canvas.getContext('2d');
-	      context.drawImage(image, 0, 0, canvas.width, canvas.height);
-
-	      if (color !== undefined) {
-	        var hex = parseInt(color, 16);
-	        var r = (hex >> 16 & 255) / 255;
-	        var g = (hex >> 8 & 255) / 255;
-	        var b = (hex & 255) / 255;
-	        var imagedata = context.getImageData(0, 0, canvas.width, canvas.height);
-	        var data = imagedata.data;
-
-	        for (var i = 0; i < data.length; i += 4) {
-	          data[i + 0] = data[i + 0] * r;
-	          data[i + 1] = data[i + 1] * g;
-	          data[i + 2] = data[i + 2] * b;
-	        }
-
-	        context.putImageData(imagedata, 0, 0);
-	      }
-
-	      return canvas;
-	    }
-	  };
-
 	  _proto.getMaterialRef = function getMaterialRef(material) {
 	    var materialRef = this.materialMap.get(material);
 
@@ -1877,7 +1931,7 @@
 	  };
 
 	  _proto.buildMaterial = function buildMaterial(material) {
-	    var _this2 = this;
+	    var _this3 = this;
 
 	    var materialName = "Material_" + material.id;
 	    var materialPath = "/Materials/" + materialName;
@@ -1905,9 +1959,9 @@
 	      var texture = material[textureSlot];
 
 	      if (texture) {
-	        var textureIds = _this2.getTextureFileIds(texture);
+	        var textureIds = _this3.getTextureFileIds(texture);
 
-	        _this2.textureMap.set(texture, textureIds.refName);
+	        _this3.textureMap.set(texture, textureIds.refName);
 
 	        var channel = material[textureSlot + 'Channel'] || 'rgb';
 	        var textureValue = materialPropertyPath("/" + textureIds.name + "_" + valueName + ".outputs:" + channel);
@@ -1994,7 +2048,7 @@
 	  };
 
 	  return UsdzExporter;
-	}();
+	}(CoreExporter);
 
 	var ARRAY_BUFFER = 34962;
 	var ELEMENT_ARRAY_BUFFER = 34963;
@@ -2105,8 +2159,49 @@
 	  }
 	};
 
-	var GltfExporter = function () {
-	  function GltfExporter() {}
+	var getFilter = function getFilter(filter) {
+	  switch (filter) {
+	    case pc.FILTER_NEAREST:
+	      return 9728;
+
+	    case pc.FILTER_LINEAR:
+	      return 9729;
+
+	    case pc.FILTER_NEAREST_MIPMAP_NEAREST:
+	      return 9984;
+
+	    case pc.FILTER_LINEAR_MIPMAP_NEAREST:
+	      return 9985;
+
+	    case pc.FILTER_NEAREST_MIPMAP_LINEAR:
+	      return 9986;
+
+	    case pc.FILTER_LINEAR_MIPMAP_LINEAR:
+	      return 9987;
+	  }
+	};
+
+	var getWrap = function getWrap(wrap) {
+	  switch (wrap) {
+	    case pc.ADDRESS_CLAMP_TO_EDGE:
+	      return 33071;
+
+	    case pc.ADDRESS_MIRRORED_REPEAT:
+	      return 33648;
+
+	    case pc.ADDRESS_REPEAT:
+	      return 10497;
+	  }
+	};
+
+	var textureSemantics = ['diffuseMap'];
+
+	var GltfExporter = function (_CoreExporter) {
+	  _inheritsLoose(GltfExporter, _CoreExporter);
+
+	  function GltfExporter() {
+	    return _CoreExporter.apply(this, arguments) || this;
+	  }
 
 	  var _proto = GltfExporter.prototype;
 
@@ -2116,10 +2211,13 @@
 	      cameras: [],
 	      entities: [],
 	      materials: [],
-	      meshInstances: []
+	      textures: [],
+	      entityMeshInstances: []
 	    };
 	    var materials = resources.materials,
-	        buffers = resources.buffers;
+	        buffers = resources.buffers,
+	        entityMeshInstances = resources.entityMeshInstances,
+	        textures = resources.textures;
 	    root.forEach(function (entity) {
 	      resources.entities.push(entity);
 	    });
@@ -2130,9 +2228,29 @@
 
 	        if (materials.indexOf(material) < 0) {
 	          resources.materials.push(material);
+	          textureSemantics.forEach(function (semantic) {
+	            var texture = material[semantic];
+
+	            if (texture && textures.indexOf(texture) < 0) {
+	              textures.push(texture);
+	            }
+	          });
 	        }
 
-	        resources.meshInstances.push(meshInstance);
+	        var node = meshInstance.node;
+	        var nodeMeshInstances = entityMeshInstances.find(function (e) {
+	          return e.node === node;
+	        });
+
+	        if (!nodeMeshInstances) {
+	          nodeMeshInstances = {
+	            node: node,
+	            meshInstances: []
+	          };
+	          entityMeshInstances.push(nodeMeshInstances);
+	        }
+
+	        nodeMeshInstances.meshInstances.push(meshInstance);
 	        var mesh = meshInstance.mesh;
 	        var vertexBuffer = mesh.vertexBuffer;
 
@@ -2153,11 +2271,11 @@
 	        resources.cameras.push(entity.camera);
 	      }
 
-	      if (entity.render) {
+	      if (entity.render && entity.render.enabled) {
 	        collectMeshInstances(entity.render.meshInstances);
 	      }
 
-	      if (entity.model) {
+	      if (entity.model && entity.model.enabled && entity.model.meshInstances) {
 	        collectMeshInstances(entity.model.meshInstances);
 	      }
 	    });
@@ -2239,6 +2357,18 @@
 	  };
 
 	  _proto.writeMaterials = function writeMaterials(resources, json) {
+	    var attachTexture = function attachTexture(material, destination, name, textureSemantic) {
+	      var texture = material[textureSemantic];
+
+	      if (texture) {
+	        var textureIndex = resources.textures.indexOf(texture);
+	        if (textureIndex < 0) console.logWarn("Texture " + texture.name + " wasn't collected.");
+	        destination[name] = {
+	          "index": textureIndex
+	        };
+	      }
+	    };
+
 	    if (resources.materials.length > 0) {
 	      json.materials = resources.materials.map(function (mat) {
 	        var name = mat.name,
@@ -2247,17 +2377,21 @@
 	            opacity = mat.opacity,
 	            blendType = mat.blendType,
 	            cull = mat.cull;
-	        var material = {};
+	        var material = {
+	          pbrMetallicRoughness: {}
+	        };
+	        var pbr = material.pbrMetallicRoughness;
 
 	        if (name && name.length > 0) {
 	          material.name = name;
 	        }
 
 	        if (!diffuse.equals(pc.Color.WHITE) || opacity !== 1) {
-	          material.pbrMetallicRoughness = {};
-	          material.pbrMetallicRoughness.baseColorFactor = [diffuse.r, diffuse.g, diffuse.b, opacity];
+	          pbr.baseColorFactor = [diffuse.r, diffuse.g, diffuse.b, opacity];
 	        }
 
+	        attachTexture(mat, pbr, 'baseColorTexture', 'diffuseMap');
+
 	        if (!emissive.equals(pc.Color.BLACK)) {
 	          material.emissiveFactor = [emissive.r, emissive.g, emissive.b];
 	        }
@@ -2304,16 +2438,12 @@
 	          node.camera = resources.cameras.indexOf(entity.camera);
 	        }
 
-	        if (entity.render && entity.render.enabled) {
-	          entity.render.meshInstances.forEach(function (meshInstance) {
-	            node.mesh = resources.meshInstances.indexOf(meshInstance);
-	          });
-	        }
+	        var entityMeshInstance = resources.entityMeshInstances.find(function (e) {
+	          return e.node === entity;
+	        });
 
-	        if (entity.model && entity.model.enabled) {
-	          entity.model.meshInstances.forEach(function (meshInstance) {
-	            node.mesh = resources.meshInstances.indexOf(meshInstance);
-	          });
+	        if (entityMeshInstance) {
+	          node.mesh = resources.entityMeshInstances.indexOf(entityMeshInstance);
 	        }
 
 	        if (entity.children.length > 0) {
@@ -2329,68 +2459,98 @@
 	  };
 
 	  _proto.writeMeshes = function writeMeshes(resources, json) {
-	    if (resources.meshInstances.length > 0) {
+	    if (resources.entityMeshInstances.length > 0) {
 	      json.accessors = [];
 	      json.meshes = [];
-	      resources.meshInstances.forEach(function (meshInstance) {
-	        var indexBuffer = meshInstance.mesh.indexBuffer[0];
-	        var vertexBuffer = meshInstance.mesh.vertexBuffer;
-	        var vertexFormat = vertexBuffer.getFormat();
-	        var numVertices = vertexBuffer.getNumVertices();
+	      resources.entityMeshInstances.forEach(function (entityMeshInstances) {
 	        var mesh = {
 	          primitives: []
 	        };
-	        var primitive = {
-	          attributes: {},
-	          material: resources.materials.indexOf(meshInstance.material)
-	        };
-
-	        var writeAccessor = function writeAccessor(element) {
-	          var accessor = {
-	            bufferView: resources.buffers.indexOf(vertexBuffer),
-	            byteOffset: element.offset,
-	            componentType: getComponentType(element.dataType),
-	            type: getAccessorType(element.numComponents),
-	            count: numVertices
+	        var meshInstances = entityMeshInstances.meshInstances;
+	        meshInstances.forEach(function (meshInstance) {
+	          var indexBuffer = meshInstance.mesh.indexBuffer[0];
+	          var vertexBuffer = meshInstance.mesh.vertexBuffer;
+	          var vertexFormat = vertexBuffer.getFormat();
+	          var numVertices = vertexBuffer.getNumVertices();
+	          var primitive = {
+	            attributes: {},
+	            material: resources.materials.indexOf(meshInstance.material)
 	          };
-	          var idx = json.accessors.length;
-	          json.accessors.push(accessor);
-	          var semantic = getSemantic(element.name);
-	          primitive.attributes[semantic] = idx;
-
-	          if (element.name === pc.SEMANTIC_POSITION) {
-	            var positions = [];
-	            meshInstance.mesh.getPositions(positions);
-	            var min = new pc.Vec3(),
-	                max = new pc.Vec3();
-	            pc.BoundingBox.computeMinMax(positions, min, max);
-	            accessor.min = [min.x, min.y, min.z];
-	            accessor.max = [max.x, max.y, max.z];
-	          }
-	        };
-
-	        vertexFormat.elements.forEach(writeAccessor);
-
-	        if (indexBuffer) {
-	          var ibIdx = resources.buffers.indexOf(indexBuffer);
-	          var accessor = {
-	            bufferView: ibIdx,
-	            componentType: getIndexComponentType(indexBuffer.getFormat()),
-	            count: indexBuffer.getNumIndices(),
-	            type: "SCALAR"
+	          mesh.primitives.push(primitive);
+
+	          var writeAccessor = function writeAccessor(element) {
+	            var accessor = {
+	              bufferView: resources.buffers.indexOf(vertexBuffer),
+	              byteOffset: element.offset,
+	              componentType: getComponentType(element.dataType),
+	              type: getAccessorType(element.numComponents),
+	              count: numVertices
+	            };
+	            var idx = json.accessors.length;
+	            json.accessors.push(accessor);
+	            var semantic = getSemantic(element.name);
+	            primitive.attributes[semantic] = idx;
+
+	            if (element.name === pc.SEMANTIC_POSITION) {
+	              var positions = [];
+	              meshInstance.mesh.getPositions(positions);
+	              var min = new pc.Vec3(),
+	                  max = new pc.Vec3();
+	              pc.BoundingBox.computeMinMax(positions, min, max);
+	              accessor.min = [min.x, min.y, min.z];
+	              accessor.max = [max.x, max.y, max.z];
+	            }
 	          };
-	          json.accessors.push(accessor);
-	          var idx = json.accessors.indexOf(accessor);
-	          primitive.indices = idx;
-	        }
 
-	        mesh.primitives.push(primitive);
+	          vertexFormat.elements.forEach(writeAccessor);
+
+	          if (indexBuffer) {
+	            var ibIdx = resources.buffers.indexOf(indexBuffer);
+	            var accessor = {
+	              bufferView: ibIdx,
+	              componentType: getIndexComponentType(indexBuffer.getFormat()),
+	              count: indexBuffer.getNumIndices(),
+	              type: "SCALAR"
+	            };
+	            json.accessors.push(accessor);
+	            var idx = json.accessors.indexOf(accessor);
+	            primitive.indices = idx;
+	          }
+	        });
 	        json.meshes.push(mesh);
 	      });
 	    }
 	  };
 
-	  _proto.buildJson = function buildJson(resources) {
+	  _proto.convertTextures = function convertTextures(textures, json, options) {
+	    var textureOptions = {
+	      maxTextureSize: options.maxTextureSize
+	    };
+
+	    for (var i = 0; i < textures.length; i++) {
+	      var isRGBA = true;
+	      var mimeType = isRGBA ? 'image/png' : 'image/jpeg';
+	      var texture = textures[i];
+	      var mipObject = texture._levels[0];
+	      var canvas = this.imageToCanvas(mipObject, textureOptions);
+	      var uri = canvas.toDataURL(mimeType);
+	      json.images[i] = {
+	        'uri': uri
+	      };
+	      json.samplers[i] = {
+	        'minFilter': getFilter(texture.minFilter),
+	        'magFilter': getFilter(texture.magFilter),
+	        'wrapS': getWrap(texture.addressU),
+	        'wrapT': getWrap(texture.addressV)
+	      };
+	      json.textures[i] = {
+	        'sampler': i,
+	        'source': i
+	      };
+	    }
+	  };
+
+	  _proto.buildJson = function buildJson(resources, options) {
 	    var json = {
 	      asset: {
 	        version: "2.0",
@@ -2399,6 +2559,9 @@
 	      scenes: [{
 	        nodes: [0]
 	      }],
+	      images: [],
+	      samplers: [],
+	      textures: [],
 	      scene: 0
 	    };
 	    this.writeBuffers(resources, json);
@@ -2407,12 +2570,17 @@
 	    this.writeNodes(resources, json);
 	    this.writeMaterials(resources, json);
 	    this.writeMeshes(resources, json);
+	    this.convertTextures(resources.textures, json, options);
 	    return json;
 	  };
 
-	  _proto.build = function build(entity) {
+	  _proto.build = function build(entity, options) {
+	    if (options === void 0) {
+	      options = {};
+	    }
+
 	    var resources = this.collectResources(entity);
-	    var json = this.buildJson(resources);
+	    var json = this.buildJson(resources, options);
 	    var jsonText = JSON.stringify(json);
 	    var headerLength = 12;
 	    var jsonHeaderLength = 8;
@@ -2475,7 +2643,7 @@
 	  };
 
 	  return GltfExporter;
-	}();
+	}(CoreExporter);
 
 	exports.GltfExporter = GltfExporter;
 	exports.MiniStats = MiniStats;

package/build/playcanvas.d.ts

@@ -10348,6 +10348,15 @@ declare class MorphInstance {
  * @ignore
  */
 declare class Light {
+    /**
+     * Get conversion factor for luminance -> light specific light unit.
+     *
+     * @param {number} type - The type of light.
+     * @param {number} [outerAngle] - The outer angle of a spot light.
+     * @param {number} [innerAngle] - The inner angle of a spot light.
+     * @returns {number} The scaling factor to multiply with the luminance value.
+     */
+    static getLightUnitConversion(type: number, outerAngle?: number, innerAngle?: number): number;
     constructor(graphicsDevice: any);
     device: any;
     id: number;
@@ -10487,6 +10496,7 @@ declare class Light {
 declare class LightComponentData {
 }
 
+/** @typedef {import('../../app-base.js').AppBase} AppBase */
 /**
  * A Light Component is used to dynamically light the scene.
  *
@@ -32009,8 +32019,6 @@ declare class WebglIndexBuffer extends WebglBuffer {
 
 
 
-/** @typedef {import('./webgl-graphics-device.js').WebglGraphicsDevice} WebglGraphicsDevice */
-/** @typedef {import('../shader.js').Shader} Shader */
 /**
  * A WebGL implementation of the Shader.
  *