@luma.gl/webgl 8.6.0-alpha.1 → 8.6.0-alpha.5

package/dist/es5/classes/program.js

@@ -7,10 +7,28 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
+var _api = require("@luma.gl/api");
+
 var _constants = _interopRequireDefault(require("@luma.gl/constants"));
 
+var _webglDevice = _interopRequireDefault(require("../adapter/webgl-device"));
+
 var _webglResource = _interopRequireDefault(require("./webgl-resource"));
 
 var _texture = _interopRequireDefault(require("./texture"));
@@ -19,366 +37,435 @@ var _framebuffer = _interopRequireDefault(require("./framebuffer"));
 
 var _uniforms = require("./uniforms");
 
-var _webglShader = require("./webgl-shader");
-
 var _programConfiguration = _interopRequireDefault(require("./program-configuration"));
 
-var _gltools = require("@luma.gl/gltools");
+var _webglChecks = require("../context/context/webgl-checks");
+
+var _withParameters = require("../context/state-tracker/with-parameters");
 
-var _webglUtils = require("../webgl-utils");
+var _constantsToKeys = require("../webgl-utils/constants-to-keys");
 
 var _attributeUtils = require("../webgl-utils/attribute-utils");
 
-var _utils = require("../utils");
-
-const LOG_PROGRAM_PERF_PRIORITY = 4;
-const GL_SEPARATE_ATTRIBS = 0x8c8d;
-
-class Program extends _webglResource.default {
-  constructor(gl, props = {}) {
-    super(gl, props, {});
-    (0, _defineProperty2.default)(this, "configuration", void 0);
-    (0, _defineProperty2.default)(this, "_isCached", false);
-    (0, _defineProperty2.default)(this, "_textureIndexCounter", 0);
-    (0, _defineProperty2.default)(this, "hash", void 0);
-    (0, _defineProperty2.default)(this, "vs", void 0);
-    (0, _defineProperty2.default)(this, "fs", void 0);
-    (0, _defineProperty2.default)(this, "uniforms", void 0);
-    (0, _defineProperty2.default)(this, "_textureUniforms", void 0);
-    (0, _defineProperty2.default)(this, "varyings", void 0);
-    (0, _defineProperty2.default)(this, "_uniformCount", 0);
-    (0, _defineProperty2.default)(this, "_uniformSetters", void 0);
-    this.initialize(props);
-    Object.seal(this);
-
-    this._setId(props.id);
-  }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
-  initialize(props = {}) {
-    const {
-      hash,
-      vs,
-      fs,
-      varyings,
-      bufferMode = GL_SEPARATE_ATTRIBS
-    } = props;
-    this.hash = hash || '';
-    this.vs = typeof vs === 'string' ? new _webglShader.VertexShader(this.gl, {
-      id: "".concat(props.id, "-vs"),
-      source: vs
-    }) : vs;
-    this.fs = typeof fs === 'string' ? new _webglShader.FragmentShader(this.gl, {
-      id: "".concat(props.id, "-fs"),
-      source: fs
-    }) : fs;
-    (0, _utils.assert)(this.vs instanceof _webglShader.VertexShader);
-    (0, _utils.assert)(this.fs instanceof _webglShader.FragmentShader);
-    this.uniforms = {};
-    this._textureUniforms = {};
-
-    if (varyings && varyings.length > 0) {
-      (0, _gltools.assertWebGL2Context)(this.gl);
-      this.varyings = varyings;
-      this.gl2.transformFeedbackVaryings(this.handle, varyings, bufferMode);
-    }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-    this._compileAndLink();
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-    this._readUniformLocationsFromLinkedProgram();
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
 
-    this.configuration = new _programConfiguration.default(this);
-    return this.setProps(props);
-  }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-  delete(options = {}) {
-    if (this._isCached) {
-      return this;
-    }
+var LOG_PROGRAM_PERF_PRIORITY = 4;
+var GL_SEPARATE_ATTRIBS = 0x8c8d;
 
-    return super.delete(options);
-  }
+var Program = function (_WebGLResource) {
+  (0, _inherits2.default)(Program, _WebGLResource);
 
-  setProps(props) {
-    if ('uniforms' in props) {
-      this.setUniforms(props.uniforms);
-    }
+  var _super = _createSuper(Program);
 
-    return this;
-  }
+  function Program(device) {
+    var _this;
 
-  draw(options) {
-    const {
-      logPriority,
-      drawMode = _constants.default.TRIANGLES,
-      vertexCount,
-      offset = 0,
-      start,
-      end,
-      isIndexed = false,
-      indexType = _constants.default.UNSIGNED_SHORT,
-      instanceCount = 0,
-      isInstanced = instanceCount > 0,
-      vertexArray = null,
-      transformFeedback,
-      framebuffer,
-      uniforms,
-      samplers
-    } = options;
-    let {
-      parameters = {}
-    } = options;
-
-    if (uniforms || samplers) {
-      _gltools.log.deprecated('Program.draw({uniforms})', 'Program.setUniforms(uniforms)')();
-
-      this.setUniforms(uniforms || {});
-    }
+    var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _classCallCheck2.default)(this, Program);
+    _this = _super.call(this, _webglDevice.default.attach(device), props, {});
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "configuration", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "hash", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "vs", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "fs", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "uniforms", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "varyings", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_textureUniforms", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_isCached", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_textureIndexCounter", 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_uniformCount", 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_uniformSetters", void 0);
 
-    if (_gltools.log.priority >= logPriority) {
-      const fb = framebuffer ? framebuffer.id : 'default';
-      const message = "mode=".concat((0, _webglUtils.getKey)(this.gl, drawMode), " verts=").concat(vertexCount, " ") + "instances=".concat(instanceCount, " indexType=").concat((0, _webglUtils.getKey)(this.gl, indexType), " ") + "isInstanced=".concat(isInstanced, " isIndexed=").concat(isIndexed, " ") + "Framebuffer=".concat(fb);
+    _this.initialize(props);
 
-      _gltools.log.log(logPriority, message)();
-    }
+    Object.seal((0, _assertThisInitialized2.default)(_this));
 
-    (0, _utils.assert)(vertexArray);
-    this.gl.useProgram(this.handle);
+    _this._setId(props.id);
 
-    if (!this._areTexturesRenderable() || vertexCount === 0 || isInstanced && instanceCount === 0) {
-      return false;
+    return _this;
+  }
+
+  (0, _createClass2.default)(Program, [{
+    key: "destroy",
+    value: function destroy() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      if (this._isCached) {
+        return this;
+      }
+
+      return (0, _get2.default)((0, _getPrototypeOf2.default)(Program.prototype), "delete", this).call(this, options);
     }
+  }, {
+    key: "delete",
+    value: function _delete() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-    vertexArray.bindForDraw(vertexCount, instanceCount, () => {
-      if (framebuffer !== undefined) {
-        parameters = Object.assign({}, parameters, {
-          framebuffer
-        });
+      if (this._isCached) {
+        return this;
       }
 
-      if (transformFeedback) {
-        const primitiveMode = (0, _attributeUtils.getPrimitiveDrawMode)(drawMode);
-        transformFeedback.begin(primitiveMode);
+      return (0, _get2.default)((0, _getPrototypeOf2.default)(Program.prototype), "delete", this).call(this, options);
+    }
+  }, {
+    key: "initialize",
+    value: function initialize() {
+      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var hash = props.hash,
+          vs = props.vs,
+          fs = props.fs,
+          varyings = props.varyings,
+          _props$bufferMode = props.bufferMode,
+          bufferMode = _props$bufferMode === void 0 ? GL_SEPARATE_ATTRIBS : _props$bufferMode;
+      this.hash = hash || '';
+      this.vs = typeof vs === 'string' ? this.device.createShader({
+        id: "".concat(props.id, "-vs"),
+        source: vs,
+        stage: 'vertex'
+      }) : (0, _api.cast)(vs);
+      this.fs = typeof fs === 'string' ? this.device.createShader({
+        id: "".concat(props.id, "-fs"),
+        source: fs,
+        stage: 'fragment'
+      }) : (0, _api.cast)(fs);
+      (0, _api.assert)(this.vs.stage === 'vertex');
+      (0, _api.assert)(this.fs.stage === 'fragment');
+      this.uniforms = {};
+      this._textureUniforms = {};
+
+      if (varyings && varyings.length > 0) {
+        (0, _webglChecks.assertWebGL2Context)(this.gl);
+        this.varyings = varyings;
+        this.gl2.transformFeedbackVaryings(this.handle, varyings, bufferMode);
       }
 
-      this._bindTextures();
-
-      (0, _gltools.withParameters)(this.gl, parameters, () => {
-        if (isIndexed && isInstanced) {
-          this.gl2.drawElementsInstanced(drawMode, vertexCount, indexType, offset, instanceCount);
-        } else if (isIndexed && (0, _gltools.isWebGL2)(this.gl) && !isNaN(start) && !isNaN(end)) {
-          this.gl2.drawRangeElements(drawMode, start, end, vertexCount, indexType, offset);
-        } else if (isIndexed) {
-          this.gl.drawElements(drawMode, vertexCount, indexType, offset);
-        } else if (isInstanced) {
-          this.gl2.drawArraysInstanced(drawMode, offset, vertexCount, instanceCount);
-        } else {
-          this.gl.drawArrays(drawMode, offset, vertexCount);
-        }
-      });
+      this._compileAndLink();
+
+      this._readUniformLocationsFromLinkedProgram();
 
-      if (transformFeedback) {
-        transformFeedback.end();
+      this.configuration = new _programConfiguration.default(this);
+      return this.setProps(props);
+    }
+  }, {
+    key: "setProps",
+    value: function setProps(props) {
+      if ('uniforms' in props) {
+        this.setUniforms(props.uniforms);
       }
-    });
-    return true;
-  }
 
-  setUniforms(uniforms = {}) {
-    if (_gltools.log.priority >= 2) {
-      (0, _uniforms.checkUniformValues)(uniforms, this.id, this._uniformSetters);
+      return this;
     }
+  }, {
+    key: "draw",
+    value: function draw(options) {
+      var _this2 = this;
+
+      var logPriority = options.logPriority,
+          _options$drawMode = options.drawMode,
+          drawMode = _options$drawMode === void 0 ? _constants.default.TRIANGLES : _options$drawMode,
+          vertexCount = options.vertexCount,
+          _options$offset = options.offset,
+          offset = _options$offset === void 0 ? 0 : _options$offset,
+          start = options.start,
+          end = options.end,
+          _options$isIndexed = options.isIndexed,
+          isIndexed = _options$isIndexed === void 0 ? false : _options$isIndexed,
+          _options$indexType = options.indexType,
+          indexType = _options$indexType === void 0 ? _constants.default.UNSIGNED_SHORT : _options$indexType,
+          _options$instanceCoun = options.instanceCount,
+          instanceCount = _options$instanceCoun === void 0 ? 0 : _options$instanceCoun,
+          _options$isInstanced = options.isInstanced,
+          isInstanced = _options$isInstanced === void 0 ? instanceCount > 0 : _options$isInstanced,
+          _options$vertexArray = options.vertexArray,
+          vertexArray = _options$vertexArray === void 0 ? null : _options$vertexArray,
+          transformFeedback = options.transformFeedback,
+          framebuffer = options.framebuffer,
+          uniforms = options.uniforms,
+          samplers = options.samplers;
+      var _options$parameters = options.parameters,
+          parameters = _options$parameters === void 0 ? {} : _options$parameters;
+
+      if (uniforms || samplers) {
+        _api.log.deprecated('Program.draw({uniforms})', 'Program.setUniforms(uniforms)')();
+
+        this.setUniforms(uniforms || {});
+      }
 
-    this.gl.useProgram(this.handle);
+      if (_api.log.priority >= logPriority) {
+        var fb = framebuffer ? framebuffer.id : 'default';
+        var message = "mode=".concat((0, _constantsToKeys.getKey)(this.gl, drawMode), " verts=").concat(vertexCount, " ") + "instances=".concat(instanceCount, " indexType=").concat((0, _constantsToKeys.getKey)(this.gl, indexType), " ") + "isInstanced=".concat(isInstanced, " isIndexed=").concat(isIndexed, " ") + "Framebuffer=".concat(fb);
 
-    for (const uniformName in uniforms) {
-      const uniform = uniforms[uniformName];
-      const uniformSetter = this._uniformSetters[uniformName];
+        _api.log.log(logPriority, message)();
+      }
 
-      if (uniformSetter) {
-        let value = uniform;
-        let textureUpdate = false;
+      (0, _api.assert)(vertexArray);
+      this.gl.useProgram(this.handle);
 
-        if (value instanceof _framebuffer.default) {
-          value = value.texture;
-        }
+      if (!this._areTexturesRenderable() || vertexCount === 0 || isInstanced && instanceCount === 0) {
+        return false;
+      }
 
-        if (value instanceof _texture.default) {
-          textureUpdate = this.uniforms[uniformName] !== uniform;
+      vertexArray.bindForDraw(vertexCount, instanceCount, function () {
+        if (framebuffer !== undefined) {
+          parameters = Object.assign({}, parameters, {
+            framebuffer: framebuffer
+          });
+        }
 
-          if (textureUpdate) {
-            if (uniformSetter.textureIndex === undefined) {
-              uniformSetter.textureIndex = this._textureIndexCounter++;
-            }
+        if (transformFeedback) {
+          var primitiveMode = (0, _attributeUtils.getPrimitiveDrawMode)(drawMode);
+          transformFeedback.begin(primitiveMode);
+        }
 
-            const texture = value;
-            const {
-              textureIndex
-            } = uniformSetter;
-            texture.bind(textureIndex);
-            value = textureIndex;
-            this._textureUniforms[uniformName] = texture;
+        _this2._bindTextures();
+
+        (0, _withParameters.withParameters)(_this2.gl, parameters, function () {
+          if (isIndexed && isInstanced) {
+            _this2.gl2.drawElementsInstanced(drawMode, vertexCount, indexType, offset, instanceCount);
+          } else if (isIndexed && (0, _webglChecks.isWebGL2)(_this2.gl) && !isNaN(start) && !isNaN(end)) {
+            _this2.gl2.drawRangeElements(drawMode, start, end, vertexCount, indexType, offset);
+          } else if (isIndexed) {
+            _this2.gl.drawElements(drawMode, vertexCount, indexType, offset);
+          } else if (isInstanced) {
+            _this2.gl2.drawArraysInstanced(drawMode, offset, vertexCount, instanceCount);
           } else {
-            value = uniformSetter.textureIndex;
+            _this2.gl.drawArrays(drawMode, offset, vertexCount);
           }
-        } else if (this._textureUniforms[uniformName]) {
-          delete this._textureUniforms[uniformName];
-        }
+        });
 
-        if (uniformSetter(value) || textureUpdate) {
-          (0, _uniforms.copyUniform)(this.uniforms, uniformName, uniform);
+        if (transformFeedback) {
+          transformFeedback.end();
         }
-      }
-    }
-
-    return this;
-  }
-
-  _areTexturesRenderable() {
-    let texturesRenderable = true;
-
-    for (const uniformName in this._textureUniforms) {
-      const texture = this._textureUniforms[uniformName];
-      texture.update();
-      texturesRenderable = texturesRenderable && texture.loaded;
+      });
+      return true;
     }
+  }, {
+    key: "setUniforms",
+    value: function setUniforms() {
+      var uniforms = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-    return texturesRenderable;
-  }
+      if (_api.log.priority >= 2) {
+        (0, _uniforms.checkUniformValues)(uniforms, this.id, this._uniformSetters);
+      }
 
-  _bindTextures() {
-    for (const uniformName in this._textureUniforms) {
-      const textureIndex = this._uniformSetters[uniformName].textureIndex;
+      this.gl.useProgram(this.handle);
 
-      this._textureUniforms[uniformName].bind(textureIndex);
-    }
-  }
+      for (var uniformName in uniforms) {
+        var uniform = uniforms[uniformName];
+        var uniformSetter = this._uniformSetters[uniformName];
 
-  _createHandle() {
-    return this.gl.createProgram();
-  }
+        if (uniformSetter) {
+          var value = uniform;
+          var textureUpdate = false;
 
-  _deleteHandle() {
-    this.gl.deleteProgram(this.handle);
-  }
+          if (value instanceof _framebuffer.default) {
+            value = value.texture;
+          }
 
-  _getOptionsFromHandle(handle) {
-    const shaderHandles = this.gl.getAttachedShaders(handle);
-    const opts = {};
+          if (value instanceof _texture.default) {
+            textureUpdate = this.uniforms[uniformName] !== uniform;
+
+            if (textureUpdate) {
+              if (uniformSetter.textureIndex === undefined) {
+                uniformSetter.textureIndex = this._textureIndexCounter++;
+              }
+
+              var texture = value;
+              var textureIndex = uniformSetter.textureIndex;
+              texture.bind(textureIndex);
+              value = textureIndex;
+              this._textureUniforms[uniformName] = texture;
+            } else {
+              value = uniformSetter.textureIndex;
+            }
+          } else if (this._textureUniforms[uniformName]) {
+            delete this._textureUniforms[uniformName];
+          }
 
-    for (const shaderHandle of shaderHandles) {
-      const type = this.gl.getShaderParameter(this.handle, _constants.default.SHADER_TYPE);
+          if (uniformSetter(value) || textureUpdate) {
+            (0, _uniforms.copyUniform)(this.uniforms, uniformName, uniform);
+          }
+        }
+      }
 
-      switch (type) {
-        case _constants.default.VERTEX_SHADER:
-          opts.vs = new _webglShader.VertexShader({
-            handle: shaderHandle
-          });
-          break;
+      return this;
+    }
+  }, {
+    key: "_areTexturesRenderable",
+    value: function _areTexturesRenderable() {
+      var texturesRenderable = true;
+
+      for (var uniformName in this._textureUniforms) {
+        var texture = this._textureUniforms[uniformName];
+        texture.update();
+        texturesRenderable = texturesRenderable && texture.loaded;
+      }
 
-        case _constants.default.FRAGMENT_SHADER:
-          opts.fs = new _webglShader.FragmentShader({
-            handle: shaderHandle
-          });
-          break;
+      return texturesRenderable;
+    }
+  }, {
+    key: "_bindTextures",
+    value: function _bindTextures() {
+      for (var uniformName in this._textureUniforms) {
+        var textureIndex = this._uniformSetters[uniformName].textureIndex;
 
-        default:
+        this._textureUniforms[uniformName].bind(textureIndex);
       }
     }
-
-    return opts;
-  }
-
-  _getParameter(pname) {
-    return this.gl.getProgramParameter(this.handle, pname);
-  }
-
-  _setId(id) {
-    if (!id) {
-      const programName = this._getName();
-
-      this.id = (0, _utils.uid)(programName);
+  }, {
+    key: "_createHandle",
+    value: function _createHandle() {
+      return this.gl.createProgram();
     }
-  }
+  }, {
+    key: "_deleteHandle",
+    value: function _deleteHandle() {
+      this.gl.deleteProgram(this.handle);
+    }
+  }, {
+    key: "_getOptionsFromHandle",
+    value: function _getOptionsFromHandle(handle) {
+      var shaderHandles = this.gl.getAttachedShaders(handle);
+      var opts = {};
+
+      var _iterator = _createForOfIteratorHelper(shaderHandles),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var shaderHandle = _step.value;
+          var type = this.gl.getShaderParameter(this.handle, _constants.default.SHADER_TYPE);
+
+          switch (type) {
+            case _constants.default.VERTEX_SHADER:
+              opts.vs = new VertexShader({
+                handle: shaderHandle
+              });
+              break;
+
+            case _constants.default.FRAGMENT_SHADER:
+              opts.fs = new FragmentShader({
+                handle: shaderHandle
+              });
+              break;
+
+            default:
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
 
-  _getName() {
-    let programName = this.vs.getName() || this.fs.getName();
-    programName = programName.replace(/shader/i, '');
-    programName = programName ? "".concat(programName, "-program") : 'program';
-    return programName;
-  }
+      return opts;
+    }
+  }, {
+    key: "_getParameter",
+    value: function _getParameter(pname) {
+      return this.gl.getProgramParameter(this.handle, pname);
+    }
+  }, {
+    key: "_setId",
+    value: function _setId(id) {
+      if (!id) {
+        var programName = this._getName();
 
-  _compileAndLink() {
-    const {
-      gl
-    } = this;
-    gl.attachShader(this.handle, this.vs.handle);
-    gl.attachShader(this.handle, this.fs.handle);
+        this.id = (0, _api.uid)(programName);
+      }
+    }
+  }, {
+    key: "_getName",
+    value: function _getName() {
+      var programName = this.vs.id || this.fs.id;
+      programName = programName.replace(/shader/i, '');
+      programName = programName ? "".concat(programName, "-program") : 'program';
+      return programName;
+    }
+  }, {
+    key: "_compileAndLink",
+    value: function _compileAndLink() {
+      var gl = this.gl;
+      gl.attachShader(this.handle, this.vs.handle);
+      gl.attachShader(this.handle, this.fs.handle);
 
-    _gltools.log.time(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))();
+      _api.log.time(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))();
 
-    gl.linkProgram(this.handle);
+      gl.linkProgram(this.handle);
 
-    _gltools.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))();
+      _api.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))();
 
-    if (gl.debug || _gltools.log.level > 0) {
-      const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
+      if (gl.debug || _api.log.level > 0) {
+        var linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
 
-      if (!linked) {
-        throw new Error("Error linking: ".concat(gl.getProgramInfoLog(this.handle)));
-      }
+        if (!linked) {
+          throw new Error("Error linking: ".concat(gl.getProgramInfoLog(this.handle)));
+        }
 
-      gl.validateProgram(this.handle);
-      const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
+        gl.validateProgram(this.handle);
+        var validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
 
-      if (!validated) {
-        throw new Error("Error validating: ".concat(gl.getProgramInfoLog(this.handle)));
+        if (!validated) {
+          throw new Error("Error validating: ".concat(gl.getProgramInfoLog(this.handle)));
+        }
       }
     }
-  }
-
-  _readUniformLocationsFromLinkedProgram() {
-    const {
-      gl
-    } = this;
-    this._uniformSetters = {};
-    this._uniformCount = this._getParameter(_constants.default.ACTIVE_UNIFORMS);
-
-    for (let i = 0; i < this._uniformCount; i++) {
-      const info = this.gl.getActiveUniform(this.handle, i);
-      const {
-        name
-      } = (0, _uniforms.parseUniformName)(info.name);
-      let location = gl.getUniformLocation(this.handle, name);
-      this._uniformSetters[name] = (0, _uniforms.getUniformSetter)(gl, location, info);
-
-      if (info.size > 1) {
-        for (let l = 0; l < info.size; l++) {
-          location = gl.getUniformLocation(this.handle, "".concat(name, "[").concat(l, "]"));
-          this._uniformSetters["".concat(name, "[").concat(l, "]")] = (0, _uniforms.getUniformSetter)(gl, location, info);
+  }, {
+    key: "_readUniformLocationsFromLinkedProgram",
+    value: function _readUniformLocationsFromLinkedProgram() {
+      var gl = this.gl;
+      this._uniformSetters = {};
+      this._uniformCount = this._getParameter(_constants.default.ACTIVE_UNIFORMS);
+
+      for (var i = 0; i < this._uniformCount; i++) {
+        var info = this.gl.getActiveUniform(this.handle, i);
+
+        var _parseUniformName = (0, _uniforms.parseUniformName)(info.name),
+            name = _parseUniformName.name;
+
+        var location = gl.getUniformLocation(this.handle, name);
+        this._uniformSetters[name] = (0, _uniforms.getUniformSetter)(gl, location, info);
+
+        if (info.size > 1) {
+          for (var l = 0; l < info.size; l++) {
+            location = gl.getUniformLocation(this.handle, "".concat(name, "[").concat(l, "]"));
+            this._uniformSetters["".concat(name, "[").concat(l, "]")] = (0, _uniforms.getUniformSetter)(gl, location, info);
+          }
         }
       }
-    }
-
-    this._textureIndexCounter = 0;
-  }
 
-  getActiveUniforms(uniformIndices, pname) {
-    return this.gl2.getActiveUniforms(this.handle, uniformIndices, pname);
-  }
-
-  getUniformBlockIndex(blockName) {
-    return this.gl2.getUniformBlockIndex(this.handle, blockName);
-  }
-
-  getActiveUniformBlockParameter(blockIndex, pname) {
-    return this.gl2.getActiveUniformBlockParameter(this.handle, blockIndex, pname);
-  }
-
-  uniformBlockBinding(blockIndex, blockBinding) {
-    this.gl2.uniformBlockBinding(this.handle, blockIndex, blockBinding);
-  }
-
-}
+      this._textureIndexCounter = 0;
+    }
+  }, {
+    key: "getActiveUniforms",
+    value: function getActiveUniforms(uniformIndices, pname) {
+      return this.gl2.getActiveUniforms(this.handle, uniformIndices, pname);
+    }
+  }, {
+    key: "getUniformBlockIndex",
+    value: function getUniformBlockIndex(blockName) {
+      return this.gl2.getUniformBlockIndex(this.handle, blockName);
+    }
+  }, {
+    key: "getActiveUniformBlockParameter",
+    value: function getActiveUniformBlockParameter(blockIndex, pname) {
+      return this.gl2.getActiveUniformBlockParameter(this.handle, blockIndex, pname);
+    }
+  }, {
+    key: "uniformBlockBinding",
+    value: function uniformBlockBinding(blockIndex, blockBinding) {
+      this.gl2.uniformBlockBinding(this.handle, blockIndex, blockBinding);
+    }
+  }]);
+  return Program;
+}(_webglResource.default);
 
 exports.default = Program;
 //# sourceMappingURL=program.js.map