@luma.gl/webgl 9.0.0-alpha.5 → 9.0.0-alpha.51

package/dist/adapter/resources/webgl-render-pipeline.d.ts

@@ -1,38 +1,46 @@
-import type { RenderPipelineProps, RenderPass, Buffer, Binding, ShaderLayout } from '@luma.gl/api';
-import { RenderPipeline } from '@luma.gl/api';
-import WebGLDevice from '../webgl-device';
-import WEBGLShader from './webgl-shader';
-import WEBGLVertexArrayObject from '../objects/webgl-vertex-array-object';
+import type { UniformValue, RenderPipelineProps, Binding } from '@luma.gl/core';
+import type { ShaderLayout } from '@luma.gl/core';
+import type { RenderPass, VertexArray } from '@luma.gl/core';
+import { RenderPipeline } from '@luma.gl/core';
+import { WebGLDevice } from '../webgl-device';
+import { WEBGLShader } from './webgl-shader';
+import { WEBGLTransformFeedback } from './webgl-transform-feedback';
 /** Creates a new render pipeline */
-export default class WEBGLRenderPipeline extends RenderPipeline {
+export declare class WEBGLRenderPipeline extends RenderPipeline {
+    /** The WebGL device that created this render pipeline */
     device: WebGLDevice;
+    /** Handle to underlying WebGL program */
     handle: WebGLProgram;
+    /** vertex shader */
     vs: WEBGLShader;
+    /** fragment shader */
     fs: WEBGLShader;
-    layout: ShaderLayout;
-    varyings: string[];
-    vertexArrayObject: WEBGLVertexArrayObject;
-    _indexBuffer?: Buffer;
-    uniforms: Record<string, any>;
-    bindings: Record<string, any>;
-    _textureUniforms: Record<string, any>;
-    _textureIndexCounter: number;
+    /** The layout extracted from shader by WebGL introspection APIs */
+    introspectedLayout: ShaderLayout;
+    /** Uniforms set on this model */
+    uniforms: Record<string, UniformValue>;
+    /** Bindings set on this model */
+    bindings: Record<string, Binding>;
+    /** WebGL varyings */
+    varyings: string[] | null;
     _uniformCount: number;
     _uniformSetters: Record<string, Function>;
     constructor(device: WebGLDevice, props: RenderPipelineProps);
     destroy(): void;
-    setIndexBuffer(indexBuffer: Buffer): void;
-    /** @todo needed for portable model */
-    setAttributes(attributes: Record<string, Buffer>): void;
-    /** @todo needed for portable model */
+    /**
+     * Bindings include: textures, samplers and uniform buffers
+     * @todo needed for portable model
+     */
     setBindings(bindings: Record<string, Binding>): void;
-    setUniforms(uniforms: Record<string, any>): void;
+    setUniforms(uniforms: Record<string, UniformValue>): void;
     /** @todo needed for portable model
      * @note The WebGL API is offers many ways to draw things
      * This function unifies those ways into a single call using common parameters with sane defaults
      */
     draw(options: {
-        renderPass?: RenderPass;
+        renderPass: RenderPass;
+        /** vertex attributes */
+        vertexArray: VertexArray;
         vertexCount?: number;
         indexCount?: number;
         instanceCount?: number;
@@ -40,6 +48,7 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
         firstIndex?: number;
         firstInstance?: number;
         baseVertex?: number;
+        transformFeedback?: WEBGLTransformFeedback;
     }): boolean;
     protected _compileAndLink(): void;
     /**
@@ -48,8 +57,33 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
      * Note: This is currently done before every draw call
      */
     _areTexturesRenderable(): boolean;
-    /** Apply any bindings */
+    /**
+     * Constant attributes need to be reset before every draw call
+     * Any attribute that is disabled in the current vertex array object
+     * is read from the context's global constant value for that attribute location.
+     * @note Constant attributes are only supported in WebGL, not in WebGPU
+     *
+    _applyConstantAttributes(vertexArray: WEBGLVertexArray): void {
+      const attributeInfos = getAttributeInfosFromLayouts(this.shaderLayout, this.bufferLayout);
+      for (const [name, value] of Object.entries(this.)) {
+        const attributeInfo = attributeInfos[name];
+        if (!attributeInfo) {
+          log.warn(
+            `Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`
+          )();
+          continue; // eslint-disable-line no-continue
+        }
+        vertexArray.setConstant(attributeInfo.location, value);
+        vertexArray.enable(attributeInfo.location, false);
+      }
+    }
+    */
+    /** Apply any bindings (before each draw call) */
     _applyBindings(): void;
+    /**
+     * Due to program sharing, uniforms need to be reset before every draw call
+     * (though caching will avoid redundant WebGL calls)
+     */
     _applyUniforms(): void;
 }
 //# sourceMappingURL=webgl-render-pipeline.d.ts.map

package/dist/adapter/resources/webgl-render-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgl-render-pipeline.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgl-render-pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EAEnB,UAAU,EACV,MAAM,EACN,OAAO,EACP,YAAY,EAIb,MAAM,cAAc,CAAC;AACtB,OAAO,EAAC,cAAc,EAAgC,MAAM,cAAc,CAAC;AAQ3E,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAE1C,OAAO,WAAW,MAAM,gBAAgB,CAAC;AAEzC,OAAO,sBAAsB,MAAM,sCAAsC,CAAC;AAI1E,oCAAoC;AACpC,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,cAAc;IAC7D,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,YAAY,CAAC;IACrB,EAAE,EAAE,WAAW,CAAC;IAChB,EAAE,EAAE,WAAW,CAAC;IAChB,MAAM,EAAE,YAAY,CAAC;IAIrB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM;IACnC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM;IACnC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM;IAC3C,oBAAoB,EAAE,MAAM,CAAK;IACjC,aAAa,EAAE,MAAM,CAAK;IAC1B,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBAE9B,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,mBAAmB;IA4B3D,OAAO,IAAI,IAAI;IAOf,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAMzC,sCAAsC;IACtC,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAwBvD,sCAAsC;IACtC,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAoCpD,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAKzC;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE;QACZ,UAAU,CAAC,EAAE,UAAU,CAAC;QACxB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG,OAAO;IA2EX,SAAS,CAAC,eAAe;IA0BzB;;;;OAIG;IACH,sBAAsB;IAkBtB,yBAAyB;IACzB,cAAc;IA0Dd,cAAc;CASf"}
+{"version":3,"file":"webgl-render-pipeline.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgl-render-pipeline.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAE,mBAAmB,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAC9E,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAC,UAAU,EAAE,WAAW,EAAC,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAC,cAAc,EAAsC,MAAM,eAAe,CAAC;AAUlF,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAK3C,OAAO,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;AAKlE,oCAAoC;AACpC,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,yDAAyD;IACzD,MAAM,EAAE,WAAW,CAAC;IACpB,yCAAyC;IACzC,MAAM,EAAE,YAAY,CAAC;IACrB,oBAAoB;IACpB,EAAE,EAAE,WAAW,CAAC;IAChB,sBAAsB;IACtB,EAAE,EAAE,WAAW,CAAC;IAChB,mEAAmE;IACnE,kBAAkB,EAAE,YAAY,CAAC;IAEjC,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAM;IAC5C,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM;IACvC,qBAAqB;IACrB,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAQ;IAEjC,aAAa,EAAE,MAAM,CAAK;IAC1B,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAM;gBAEnC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,mBAAmB;IA+BlD,OAAO,IAAI,IAAI;IAyCxB;;;OAGG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAiDpD,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;IAWlD;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE;QACZ,UAAU,EAAE,UAAU,CAAC;QACvB,wBAAwB;QACxB,WAAW,EAAE,WAAW,CAAC;QACzB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,iBAAiB,CAAC,EAAE,sBAAsB,CAAC;KAC5C,GAAG,OAAO;IA+GX,SAAS,CAAC,eAAe;IA4BzB;;;;OAIG;IACH,sBAAsB;IAatB;;;;;;;;;;;;;;;;;;;;MAoBE;IAEF,iDAAiD;IACjD,cAAc;IAgFd;;;OAGG;IACH,cAAc;CASf"}

package/dist/adapter/resources/webgl-render-pipeline.js

@@ -1,400 +1,238 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { RenderPipeline, cast, log, decodeVertexFormat } from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import { getWebGLDataType } from '../converters/texture-formats';
-import { getShaderLayout } from '../helpers/get-shader-layout';
-import { withDeviceParameters } from '../converters/device-parameters';
-import { setUniform } from '../helpers/set-uniform';
-import WEBGLBuffer from './webgl-buffer';
-import WEBGLTexture from './webgl-texture';
-import WEBGLVertexArrayObject from '../objects/webgl-vertex-array-object';
+import { RenderPipeline, cast, splitUniformsAndBindings, log } from '@luma.gl/core';
+import { mergeShaderLayout } from '@luma.gl/core';
+import { getShaderLayout } from "../helpers/get-shader-layout.js";
+import { withDeviceAndGLParameters } from "../converters/device-parameters.js";
+import { setUniform } from "../helpers/set-uniform.js";
+import { WEBGLBuffer } from "./webgl-buffer.js";
+import { WEBGLFramebuffer } from "./webgl-framebuffer.js";
+import { WEBGLTexture } from "./webgl-texture.js";
+import { getGLDrawMode } from "../helpers/webgl-topology-utils.js";
 const LOG_PROGRAM_PERF_PRIORITY = 4;
-export default class WEBGLRenderPipeline extends RenderPipeline {
+export class WEBGLRenderPipeline extends RenderPipeline {
   constructor(device, props) {
     super(device, props);
-
-    _defineProperty(this, "device", void 0);
-
-    _defineProperty(this, "handle", void 0);
-
-    _defineProperty(this, "vs", void 0);
-
-    _defineProperty(this, "fs", void 0);
-
-    _defineProperty(this, "layout", void 0);
-
-    _defineProperty(this, "varyings", void 0);
-
-    _defineProperty(this, "vertexArrayObject", void 0);
-
-    _defineProperty(this, "_indexBuffer", void 0);
-
-    _defineProperty(this, "uniforms", {});
-
-    _defineProperty(this, "bindings", {});
-
-    _defineProperty(this, "_textureUniforms", {});
-
-    _defineProperty(this, "_textureIndexCounter", 0);
-
-    _defineProperty(this, "_uniformCount", 0);
-
-    _defineProperty(this, "_uniformSetters", void 0);
-
+    this.device = void 0;
+    this.handle = void 0;
+    this.vs = void 0;
+    this.fs = void 0;
+    this.introspectedLayout = void 0;
+    this.uniforms = {};
+    this.bindings = {};
+    this.varyings = null;
+    this._uniformCount = 0;
+    this._uniformSetters = {};
     this.device = device;
     this.handle = this.props.handle || this.device.gl.createProgram();
-    this.handle.__SPECTOR_Metadata = {
+    this.device.setSpectorMetadata(this.handle, {
       id: this.props.id
-    };
+    });
     this.vs = cast(props.vs);
     this.fs = cast(props.fs);
     const {
       varyings,
-      bufferMode = GL.SEPARATE_ATTRIBS
+      bufferMode = 35981
     } = props;
-
     if (varyings && varyings.length > 0) {
+      var _this$device$gl;
       this.device.assertWebGL2();
       this.varyings = varyings;
-      this.device.gl2.transformFeedbackVaryings(this.handle, varyings, bufferMode);
+      (_this$device$gl = this.device.gl2) === null || _this$device$gl === void 0 ? void 0 : _this$device$gl.transformFeedbackVaryings(this.handle, varyings, bufferMode);
     }
-
     this._compileAndLink();
-
-    this.layout = props.layout || getShaderLayout(this.device.gl, this.handle);
-    this.vertexArrayObject = new WEBGLVertexArrayObject(this.device);
+    this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
+    this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout);
   }
-
   destroy() {
     if (this.handle) {
       this.device.gl.deleteProgram(this.handle);
-      this.handle = null;
-    }
-  }
-
-  setIndexBuffer(indexBuffer) {
-    const webglBuffer = cast(indexBuffer);
-    this.vertexArrayObject.setElementBuffer(webglBuffer);
-    this._indexBuffer = indexBuffer;
-  }
-
-  setAttributes(attributes) {
-    for (const [name, buffer] of Object.entries(attributes)) {
-      const webglBuffer = cast(buffer);
-      const attribute = getAttributeLayout(this.layout, name);
-
-      if (!attribute) {
-        log.warn("Ignoring buffer supplied for unknown attribute \"".concat(name, "\" in pipeline \"").concat(this.id, "\" (buffer \"").concat(buffer.id, "\")"))();
-        continue;
-      }
-
-      const decoded = decodeVertexFormat(attribute.format);
-      const {
-        type: typeString,
-        components: size,
-        byteLength: stride,
-        normalized,
-        integer
-      } = decoded;
-      const divisor = attribute.stepMode === 'instance' ? 1 : 0;
-      const type = getWebGLDataType(typeString);
-      this.vertexArrayObject.setBuffer(attribute.location, webglBuffer, {
-        size,
-        type,
-        stride,
-        offset: 0,
-        normalized,
-        integer,
-        divisor: attribute.stepMode === 'instance' ? 1 : 0
-      });
+      this.destroyed = true;
     }
   }
-
   setBindings(bindings) {
     for (const [name, value] of Object.entries(bindings)) {
-      const binding = this.layout.bindings.find(binding => binding.name === name);
-
+      const binding = this.shaderLayout.bindings.find(binding => binding.name === name) || this.shaderLayout.bindings.find(binding => binding.name === `${name}Uniforms`);
       if (!binding) {
-        log.warn("Unknown binding ".concat(name, " in render pipeline ").concat(this.id))();
+        const validBindings = this.shaderLayout.bindings.map(binding => `"${binding.name}"`).join(', ');
+        log.warn(`Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`)();
+        continue;
       }
-
       if (!value) {
-        log.warn("Unsetting binding ".concat(name, " in render pipeline ").concat(this.id))();
+        log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
       }
-
       switch (binding.type) {
         case 'uniform':
           if (!(value instanceof WEBGLBuffer) && !(value.buffer instanceof WEBGLBuffer)) {
             throw new Error('buffer value');
           }
-
           break;
-
         case 'texture':
-          if (!(value instanceof WEBGLTexture)) {
+          if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
             throw new Error('texture value');
           }
-
           break;
-
         case 'sampler':
-          log.warn("Ignoring sampler ".concat(name))();
+          log.warn(`Ignoring sampler ${name}`)();
           break;
-
         default:
           throw new Error(binding.type);
       }
-
       this.bindings[name] = value;
     }
   }
-
   setUniforms(uniforms) {
+    const {
+      bindings
+    } = splitUniformsAndBindings(uniforms);
+    Object.keys(bindings).forEach(name => {
+      log.warn(`Unsupported value "${JSON.stringify(bindings[name])}" used in setUniforms() for key ${name}. Use setBindings() instead?`)();
+    });
     Object.assign(this.uniforms, uniforms);
   }
-
   draw(options) {
-    var _this$_indexBuffer;
-
+    var _vertexArray$indexBuf;
     const {
-      renderPass = this.device.getDefaultRenderPass(),
+      renderPass,
+      vertexArray,
       vertexCount,
-      indexCount,
       instanceCount,
       firstVertex = 0,
-      firstIndex,
-      firstInstance,
-      baseVertex
+      transformFeedback
     } = options;
-    const drawMode = getDrawMode(this.props.topology);
-    const isIndexed = Boolean(this._indexBuffer);
-    const indexType = ((_this$_indexBuffer = this._indexBuffer) === null || _this$_indexBuffer === void 0 ? void 0 : _this$_indexBuffer.props.indexType) === 'uint16' ? GL.UNSIGNED_SHORT : GL.UNSIGNED_INT;
-    const isInstanced = options.instanceCount > 0;
-
-    if (!this._areTexturesRenderable() || options.vertexCount === 0) {
+    const glDrawMode = getGLDrawMode(this.props.topology);
+    const isIndexed = Boolean(vertexArray.indexBuffer);
+    const glIndexType = (_vertexArray$indexBuf = vertexArray.indexBuffer) === null || _vertexArray$indexBuf === void 0 ? void 0 : _vertexArray$indexBuf.glIndexType;
+    const isInstanced = Number(instanceCount) > 0;
+    if (!this._areTexturesRenderable() || vertexCount === 0) {
       return false;
     }
-
     this.device.gl.useProgram(this.handle);
-    this.vertexArrayObject.bind(() => {
-      const parameters = { ...this.props.parameters,
-        framebuffer: renderPass.props.framebuffer
-      };
-      const primitiveMode = getGLPrimitive(this.props.topology);
-      const transformFeedback = null;
-
-      if (transformFeedback) {
-        transformFeedback.begin(primitiveMode);
+    vertexArray.bindBeforeRender(renderPass);
+    if (transformFeedback) {
+      transformFeedback.begin(this.props.topology);
+    }
+    this._applyBindings();
+    this._applyUniforms();
+    const webglRenderPass = renderPass;
+    withDeviceAndGLParameters(this.device, this.props.parameters, webglRenderPass.glParameters, () => {
+      if (isIndexed && isInstanced) {
+        var _this$device$gl2;
+        (_this$device$gl2 = this.device.gl2) === null || _this$device$gl2 === void 0 ? void 0 : _this$device$gl2.drawElementsInstanced(glDrawMode, vertexCount || 0, glIndexType, firstVertex, instanceCount || 0);
+      } else if (isIndexed) {
+        this.device.gl.drawElements(glDrawMode, vertexCount || 0, glIndexType, firstVertex);
+      } else if (isInstanced) {
+        var _this$device$gl3;
+        (_this$device$gl3 = this.device.gl2) === null || _this$device$gl3 === void 0 ? void 0 : _this$device$gl3.drawArraysInstanced(glDrawMode, firstVertex, vertexCount || 0, instanceCount || 0);
+      } else {
+        this.device.gl.drawArrays(glDrawMode, firstVertex, vertexCount || 0);
       }
-
-      this._applyBindings();
-
-      this._applyUniforms();
-
-      withDeviceParameters(this.device, parameters, () => {
-        if (isIndexed && isInstanced) {
-          this.device.gl2.drawElementsInstanced(drawMode, vertexCount, indexType, firstVertex, instanceCount);
-        } else if (isIndexed) {
-          this.device.gl.drawElements(drawMode, vertexCount, indexType, firstVertex);
-        } else if (isInstanced) {
-          this.device.gl2.drawArraysInstanced(drawMode, firstVertex, vertexCount, instanceCount);
-        } else {
-          this.device.gl.drawArrays(drawMode, firstVertex, vertexCount);
-        }
-      });
-
       if (transformFeedback) {
         transformFeedback.end();
       }
     });
+    vertexArray.unbindAfterRender(renderPass);
     return true;
   }
-
   _compileAndLink() {
     const {
       gl
     } = this.device;
     gl.attachShader(this.handle, this.vs.handle);
     gl.attachShader(this.handle, this.fs.handle);
-    log.time(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this.id))();
+    log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
     gl.linkProgram(this.handle);
-    log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this.id))();
-
-    if (gl.debug || log.level > 0) {
-      const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
-
-      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)));
-      }
+    log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    if (!gl.debug && log.level === 0) {}
+    const linked = gl.getProgramParameter(this.handle, 35714);
+    if (!linked) {
+      throw new Error(`Error linking: ${gl.getProgramInfoLog(this.handle)}`);
+    }
+    gl.validateProgram(this.handle);
+    const validated = gl.getProgramParameter(this.handle, 35715);
+    if (!validated) {
+      throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);
     }
   }
-
   _areTexturesRenderable() {
     let texturesRenderable = true;
-
-    for (const [name, texture] of Object.entries(this._textureUniforms)) {
-      texture.update();
-      texturesRenderable = texturesRenderable && texture.loaded;
-    }
-
-    for (const [name, texture] of Object.entries(this.bindings)) {
-      if (texture.loaded !== undefined) {
+    for (const [, texture] of Object.entries(this.bindings)) {
+      if (texture instanceof WEBGLTexture) {
+        texture.update();
         texturesRenderable = texturesRenderable && texture.loaded;
       }
     }
-
     return texturesRenderable;
   }
-
   _applyBindings() {
     this.device.gl.useProgram(this.handle);
     const {
       gl2
     } = this.device;
+    if (!gl2) {
+      throw new Error('bindings');
+    }
     let textureUnit = 0;
     let uniformBufferIndex = 0;
-
-    for (const binding of this.layout.bindings) {
-      const value = this.bindings[binding.name];
-
+    for (const binding of this.shaderLayout.bindings) {
+      const value = this.bindings[binding.name] || this.bindings[binding.name.replace(/Uniforms$/, '')];
       if (!value) {
-        throw new Error("No value for binding ".concat(binding.name, " in ").concat(this.id));
+        throw new Error(`No value for binding ${binding.name} in ${this.id}`);
       }
-
       switch (binding.type) {
         case 'uniform':
           const {
             name
           } = binding;
           const location = gl2.getUniformBlockIndex(this.handle, name);
-
-          if (location === GL.INVALID_INDEX) {
-            throw new Error("Invalid uniform block name ".concat(name));
+          if (location === 4294967295) {
+            throw new Error(`Invalid uniform block name ${name}`);
           }
-
           gl2.uniformBlockBinding(this.handle, uniformBufferIndex, location);
-
           if (value instanceof WEBGLBuffer) {
-            gl2.bindBufferBase(GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
+            gl2.bindBufferBase(35345, uniformBufferIndex, value.handle);
           } else {
-            gl2.bindBufferRange(GL.UNIFORM_BUFFER, uniformBufferIndex, value.buffer.handle, value.offset || 0, value.size || value.buffer.byteLength - value.offset);
+            gl2.bindBufferRange(35345, uniformBufferIndex, value.buffer.handle, value.offset || 0, value.size || value.buffer.byteLength - value.offset);
           }
-
           uniformBufferIndex += 1;
           break;
-
         case 'texture':
-          if (!(value instanceof WEBGLTexture)) {
+          if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
             throw new Error('texture');
           }
-
-          const texture = value;
-          gl2.activeTexture(GL.TEXTURE0 + textureUnit);
+          let texture;
+          if (value instanceof WEBGLTexture) {
+            texture = value;
+          } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTexture) {
+            log.warn('Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead')();
+            texture = value.colorAttachments[0];
+          } else {
+            throw new Error('No texture');
+          }
+          gl2.activeTexture(33984 + textureUnit);
           gl2.bindTexture(texture.target, texture.handle);
           textureUnit += 1;
           break;
-
         case 'sampler':
           break;
-
         case 'storage':
         case 'read-only-storage':
-          throw new Error("binding type '".concat(binding.type, "' not supported in WebGL"));
+          throw new Error(`binding type '${binding.type}' not supported in WebGL`);
       }
     }
   }
-
   _applyUniforms() {
-    for (const uniformLayout of this.layout.uniforms || []) {
+    for (const uniformLayout of this.shaderLayout.uniforms || []) {
+      var _this$uniforms$name;
       const {
         name,
         location,
         type,
         textureUnit
       } = uniformLayout;
-      const value = this.uniforms[name] || textureUnit;
-
+      const value = (_this$uniforms$name = this.uniforms[name]) !== null && _this$uniforms$name !== void 0 ? _this$uniforms$name : textureUnit;
       if (value !== undefined) {
         setUniform(this.device.gl, location, type, value);
       }
     }
   }
-
-}
-
-function getDrawMode(topology) {
-  switch (topology) {
-    case 'point-list':
-      return GL.POINTS;
-
-    case 'line-list':
-      return GL.LINES;
-
-    case 'line-strip':
-      return GL.LINE_STRIP;
-
-    case 'triangle-list':
-      return GL.TRIANGLES;
-
-    case 'triangle-strip':
-      return GL.TRIANGLE_STRIP;
-
-    default:
-      throw new Error(topology);
-  }
-}
-
-function getGLPrimitive(topology) {
-  switch (topology) {
-    case 'point-list':
-      return GL.POINTS;
-
-    case 'line-list':
-      return GL.LINES;
-
-    case 'line-strip':
-      return GL.LINES;
-
-    case 'triangle-list':
-      return GL.TRIANGLES;
-
-    case 'triangle-strip':
-      return GL.TRIANGLES;
-
-    default:
-      throw new Error(topology);
-  }
-}
-
-function getAttributesByLocation(attributes, layout) {
-  const byLocation = {};
-
-  for (const [name, buffer] of Object.entries(attributes)) {
-    const attribute = getAttributeLayout(layout, name);
-    byLocation[attribute.location] = buffer;
-  }
-
-  return byLocation;
-}
-
-function getAttributeLayout(layout, name) {
-  return layout.attributes.find(binding => binding.name === name);
-}
-
-function getBindingLayout(layout, name) {
-  const binding = layout.bindings.find(binding => binding.name === name);
-
-  if (!binding) {
-    throw new Error("Unknown binding ".concat(name));
-  }
-
-  return binding;
 }
 //# sourceMappingURL=webgl-render-pipeline.js.map