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

package/dist/es5/classes/program.js

@@ -7,21 +7,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
 
-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 _resource = _interopRequireDefault(require("./resource"));
+var _webglResource = _interopRequireDefault(require("./webgl-resource"));
 
 var _texture = _interopRequireDefault(require("./texture"));
 
@@ -29,420 +19,366 @@ var _framebuffer = _interopRequireDefault(require("./framebuffer"));
 
 var _uniforms = require("./uniforms");
 
-var _shader = require("./shader");
+var _webglShader = require("./webgl-shader");
 
 var _programConfiguration = _interopRequireDefault(require("./program-configuration"));
 
 var _gltools = require("@luma.gl/gltools");
 
-var _constantsToKeys = require("../webgl-utils/constants-to-keys");
+var _webglUtils = require("../webgl-utils");
 
 var _attributeUtils = require("../webgl-utils/attribute-utils");
 
-var _assert = require("../utils/assert");
+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);
+  }
 
-var _utils = require("../utils/utils");
+  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 _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { 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 = o[Symbol.iterator](); }, 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; } } }; }
+    this._compileAndLink();
 
-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._readUniformLocationsFromLinkedProgram();
 
-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.configuration = new _programConfiguration.default(this);
+    return this.setProps(props);
+  }
 
-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); }; }
+  delete(options = {}) {
+    if (this._isCached) {
+      return this;
+    }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+    return super.delete(options);
+  }
 
-var LOG_PROGRAM_PERF_PRIORITY = 4;
-var GL_SEPARATE_ATTRIBS = 0x8c8d;
-var V6_DEPRECATED_METHODS = ['setVertexArray', 'setAttributes', 'setBuffers', 'unsetBuffers', 'use', 'getUniformCount', 'getUniformInfo', 'getUniformLocation', 'getUniformValue', 'getVarying', 'getFragDataLocation', 'getAttachedShaders', 'getAttributeCount', 'getAttributeLocation', 'getAttributeInfo'];
+  setProps(props) {
+    if ('uniforms' in props) {
+      this.setUniforms(props.uniforms);
+    }
 
-var Program = function (_Resource) {
-  (0, _inherits2.default)(Program, _Resource);
+    return this;
+  }
 
-  var _super = _createSuper(Program);
+  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 || {});
+    }
 
-  function Program(gl) {
-    var _this;
+    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);
 
-    var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    (0, _classCallCheck2.default)(this, Program);
-    _this = _super.call(this, gl, props);
+      _gltools.log.log(logPriority, message)();
+    }
 
-    _this.stubRemovedMethods('Program', 'v6.0', V6_DEPRECATED_METHODS);
+    (0, _utils.assert)(vertexArray);
+    this.gl.useProgram(this.handle);
 
-    _this._isCached = false;
+    if (!this._areTexturesRenderable() || vertexCount === 0 || isInstanced && instanceCount === 0) {
+      return false;
+    }
 
-    _this.initialize(props);
+    vertexArray.bindForDraw(vertexCount, instanceCount, () => {
+      if (framebuffer !== undefined) {
+        parameters = Object.assign({}, parameters, {
+          framebuffer
+        });
+      }
 
-    Object.seal((0, _assertThisInitialized2.default)(_this));
+      if (transformFeedback) {
+        const primitiveMode = (0, _attributeUtils.getPrimitiveDrawMode)(drawMode);
+        transformFeedback.begin(primitiveMode);
+      }
 
-    _this._setId(props.id);
+      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);
+        }
+      });
 
-    return _this;
+      if (transformFeedback) {
+        transformFeedback.end();
+      }
+    });
+    return true;
   }
 
-  (0, _createClass2.default)(Program, [{
-    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' ? new _shader.VertexShader(this.gl, {
-        id: "".concat(props.id, "-vs"),
-        source: vs
-      }) : vs;
-      this.fs = typeof fs === 'string' ? new _shader.FragmentShader(this.gl, {
-        id: "".concat(props.id, "-fs"),
-        source: fs
-      }) : fs;
-      (0, _assert.assert)(this.vs instanceof _shader.VertexShader);
-      (0, _assert.assert)(this.fs instanceof _shader.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);
-      }
+  setUniforms(uniforms = {}) {
+    if (_gltools.log.priority >= 2) {
+      (0, _uniforms.checkUniformValues)(uniforms, this.id, this._uniformSetters);
+    }
 
-      this._compileAndLink();
+    this.gl.useProgram(this.handle);
 
-      this._readUniformLocationsFromLinkedProgram();
+    for (const uniformName in uniforms) {
+      const uniform = uniforms[uniformName];
+      const uniformSetter = this._uniformSetters[uniformName];
 
-      this.configuration = new _programConfiguration.default(this);
-      return this.setProps(props);
-    }
-  }, {
-    key: "delete",
-    value: function _delete() {
-      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      if (uniformSetter) {
+        let value = uniform;
+        let textureUpdate = false;
 
-      if (this._isCached) {
-        return this;
-      }
+        if (value instanceof _framebuffer.default) {
+          value = value.texture;
+        }
 
-      return (0, _get2.default)((0, _getPrototypeOf2.default)(Program.prototype), "delete", this).call(this, options);
-    }
-  }, {
-    key: "setProps",
-    value: function setProps(props) {
-      if ('uniforms' in props) {
-        this.setUniforms(props.uniforms);
-      }
+        if (value instanceof _texture.default) {
+          textureUpdate = this.uniforms[uniformName] !== uniform;
 
-      return this;
-    }
-  }, {
-    key: "draw",
-    value: function draw(_ref) {
-      var _this2 = this;
-
-      var logPriority = _ref.logPriority,
-          _ref$drawMode = _ref.drawMode,
-          drawMode = _ref$drawMode === void 0 ? 4 : _ref$drawMode,
-          vertexCount = _ref.vertexCount,
-          _ref$offset = _ref.offset,
-          offset = _ref$offset === void 0 ? 0 : _ref$offset,
-          start = _ref.start,
-          end = _ref.end,
-          _ref$isIndexed = _ref.isIndexed,
-          isIndexed = _ref$isIndexed === void 0 ? false : _ref$isIndexed,
-          _ref$indexType = _ref.indexType,
-          indexType = _ref$indexType === void 0 ? 5123 : _ref$indexType,
-          _ref$instanceCount = _ref.instanceCount,
-          instanceCount = _ref$instanceCount === void 0 ? 0 : _ref$instanceCount,
-          _ref$isInstanced = _ref.isInstanced,
-          isInstanced = _ref$isInstanced === void 0 ? instanceCount > 0 : _ref$isInstanced,
-          _ref$vertexArray = _ref.vertexArray,
-          vertexArray = _ref$vertexArray === void 0 ? null : _ref$vertexArray,
-          transformFeedback = _ref.transformFeedback,
-          framebuffer = _ref.framebuffer,
-          _ref$parameters = _ref.parameters,
-          parameters = _ref$parameters === void 0 ? {} : _ref$parameters,
-          uniforms = _ref.uniforms,
-          samplers = _ref.samplers;
-
-      if (uniforms || samplers) {
-        _gltools.log.deprecated('Program.draw({uniforms})', 'Program.setUniforms(uniforms)')();
-
-        this.setUniforms(uniforms || {});
-      }
+          if (textureUpdate) {
+            if (uniformSetter.textureIndex === undefined) {
+              uniformSetter.textureIndex = this._textureIndexCounter++;
+            }
 
-      if (_gltools.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);
+            const texture = value;
+            const {
+              textureIndex
+            } = uniformSetter;
+            texture.bind(textureIndex);
+            value = textureIndex;
+            this._textureUniforms[uniformName] = texture;
+          } else {
+            value = uniformSetter.textureIndex;
+          }
+        } else if (this._textureUniforms[uniformName]) {
+          delete this._textureUniforms[uniformName];
+        }
 
-        _gltools.log.log(logPriority, message)();
+        if (uniformSetter(value) || textureUpdate) {
+          (0, _uniforms.copyUniform)(this.uniforms, uniformName, uniform);
+        }
       }
+    }
 
-      (0, _assert.assert)(vertexArray);
-      this.gl.useProgram(this.handle);
+    return this;
+  }
 
-      if (!this._areTexturesRenderable() || vertexCount === 0 || isInstanced && instanceCount === 0) {
-        return false;
-      }
+  _areTexturesRenderable() {
+    let texturesRenderable = true;
 
-      vertexArray.bindForDraw(vertexCount, instanceCount, function () {
-        if (framebuffer !== undefined) {
-          parameters = Object.assign({}, parameters, {
-            framebuffer: framebuffer
-          });
-        }
+    for (const uniformName in this._textureUniforms) {
+      const texture = this._textureUniforms[uniformName];
+      texture.update();
+      texturesRenderable = texturesRenderable && texture.loaded;
+    }
 
-        if (transformFeedback) {
-          var primitiveMode = (0, _attributeUtils.getPrimitiveDrawMode)(drawMode);
-          transformFeedback.begin(primitiveMode);
-        }
+    return texturesRenderable;
+  }
 
-        _this2._bindTextures();
-
-        (0, _gltools.withParameters)(_this2.gl, parameters, function () {
-          if (isIndexed && isInstanced) {
-            _this2.gl2.drawElementsInstanced(drawMode, vertexCount, indexType, offset, instanceCount);
-          } else if (isIndexed && (0, _gltools.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 {
-            _this2.gl.drawArrays(drawMode, offset, vertexCount);
-          }
-        });
+  _bindTextures() {
+    for (const uniformName in this._textureUniforms) {
+      const textureIndex = this._uniformSetters[uniformName].textureIndex;
 
-        if (transformFeedback) {
-          transformFeedback.end();
-        }
-      });
-      return true;
+      this._textureUniforms[uniformName].bind(textureIndex);
     }
-  }, {
-    key: "setUniforms",
-    value: function setUniforms() {
-      var uniforms = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  }
 
-      if (_gltools.log.priority >= 2) {
-        (0, _uniforms.checkUniformValues)(uniforms, this.id, this._uniformSetters);
-      }
+  _createHandle() {
+    return this.gl.createProgram();
+  }
 
-      this.gl.useProgram(this.handle);
+  _deleteHandle() {
+    this.gl.deleteProgram(this.handle);
+  }
 
-      for (var uniformName in uniforms) {
-        var uniform = uniforms[uniformName];
-        var uniformSetter = this._uniformSetters[uniformName];
+  _getOptionsFromHandle(handle) {
+    const shaderHandles = this.gl.getAttachedShaders(handle);
+    const opts = {};
 
-        if (uniformSetter) {
-          var value = uniform;
-          var textureUpdate = false;
+    for (const shaderHandle of shaderHandles) {
+      const type = this.gl.getShaderParameter(this.handle, _constants.default.SHADER_TYPE);
 
-          if (value instanceof _framebuffer.default) {
-            value = value.texture;
-          }
+      switch (type) {
+        case _constants.default.VERTEX_SHADER:
+          opts.vs = new _webglShader.VertexShader({
+            handle: shaderHandle
+          });
+          break;
 
-          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];
-          }
+        case _constants.default.FRAGMENT_SHADER:
+          opts.fs = new _webglShader.FragmentShader({
+            handle: shaderHandle
+          });
+          break;
 
-          if (uniformSetter(value) || textureUpdate) {
-            (0, _uniforms.copyUniform)(this.uniforms, uniformName, uniform);
-          }
-        }
+        default:
       }
-
-      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;
-      }
 
-      return texturesRenderable;
-    }
-  }, {
-    key: "_bindTextures",
-    value: function _bindTextures() {
-      for (var uniformName in this._textureUniforms) {
-        var textureIndex = this._uniformSetters[uniformName].textureIndex;
+    return opts;
+  }
 
-        this._textureUniforms[uniformName].bind(textureIndex);
-      }
-    }
-  }, {
-    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, 35663);
-
-          switch (type) {
-            case 35633:
-              opts.vs = new _shader.VertexShader({
-                handle: shaderHandle
-              });
-              break;
-
-            case 35632:
-              opts.fs = new _shader.FragmentShader({
-                handle: shaderHandle
-              });
-              break;
-
-            default:
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
+  _getParameter(pname) {
+    return this.gl.getProgramParameter(this.handle, pname);
+  }
 
-      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();
+  _setId(id) {
+    if (!id) {
+      const programName = this._getName();
 
-        this.id = (0, _utils.uid)(programName);
-      }
-    }
-  }, {
-    key: "_getName",
-    value: function _getName() {
-      var programName = this.vs.getName() || this.fs.getName();
-      programName = programName.replace(/shader/i, '');
-      programName = programName ? "".concat(programName, "-program") : 'program';
-      return programName;
+      this.id = (0, _utils.uid)(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()))();
+  _getName() {
+    let programName = this.vs.getName() || this.fs.getName();
+    programName = programName.replace(/shader/i, '');
+    programName = programName ? "".concat(programName, "-program") : 'program';
+    return programName;
+  }
 
-      gl.linkProgram(this.handle);
+  _compileAndLink() {
+    const {
+      gl
+    } = this;
+    gl.attachShader(this.handle, this.vs.handle);
+    gl.attachShader(this.handle, this.fs.handle);
 
-      _gltools.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))();
+    _gltools.log.time(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))();
 
-      if (gl.debug || _gltools.log.level > 0) {
-        var linked = gl.getProgramParameter(this.handle, 35714);
+    gl.linkProgram(this.handle);
 
-        if (!linked) {
-          throw new Error("Error linking: ".concat(gl.getProgramInfoLog(this.handle)));
-        }
+    _gltools.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))();
 
-        gl.validateProgram(this.handle);
-        var validated = gl.getProgramParameter(this.handle, 35715);
+    if (gl.debug || _gltools.log.level > 0) {
+      const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
 
-        if (!validated) {
-          throw new Error("Error validating: ".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);
+
+      if (!validated) {
+        throw new Error("Error validating: ".concat(gl.getProgramInfoLog(this.handle)));
       }
     }
-  }, {
-    key: "_readUniformLocationsFromLinkedProgram",
-    value: function _readUniformLocationsFromLinkedProgram() {
-      var gl = this.gl;
-      this._uniformSetters = {};
-      this._uniformCount = this._getParameter(35718);
-
-      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);
-          }
+  }
+
+  _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);
         }
       }
-
-      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;
-}(_resource.default);
+
+    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);
+  }
+
+}
 
 exports.default = Program;
 //# sourceMappingURL=program.js.map