@luma.gl/webgl 8.5.8 → 8.6.0-alpha.2

package/dist/esm/classes/framebuffer.js

@@ -1,40 +1,231 @@
-import { getWebGL2Context, assertWebGL2Context, log } from '@luma.gl/gltools';
-import Resource from './resource';
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { log, assert } from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+import WebGLDevice from '../device/webgl-device';
+import { getWebGL2Context, assertWebGL2Context } from '../context/context/webgl-checks';
+import { getKey } from '../webgl-utils/constants-to-keys';
+import Resource from './webgl-resource';
 import Texture2D from './texture-2d';
 import Renderbuffer from './renderbuffer';
 import { clear, clearBuffer } from './clear';
-import { copyToDataUrl } from './copy-and-blit.js';
-import { getFeatures } from '../features';
-import { getKey } from '../webgl-utils/constants-to-keys';
-import { assert } from '../utils/assert';
+import { copyToDataUrl } from './copy-and-blit';
 const ERR_MULTIPLE_RENDERTARGETS = 'Multiple render targets not supported';
-export default class Framebuffer extends Resource {
-  static isSupported(gl, options = {}) {
+export class ImmutableFramebuffer extends Resource {
+  constructor(gl, props) {
+    super(WebGLDevice.attach(gl), props, {});
+
+    this._initialize({
+      attachments: (props === null || props === void 0 ? void 0 : props.attachments) || {},
+      readBuffer: props === null || props === void 0 ? void 0 : props.readBuffer,
+      drawBuffers: props === null || props === void 0 ? void 0 : props.drawBuffers
+    });
+  }
+
+  checkStatus() {
+    const {
+      gl
+    } = this;
+    const status = this.getStatus();
+
+    if (status !== gl.FRAMEBUFFER_COMPLETE) {
+      throw new Error(_getFrameBufferStatus(status));
+    }
+
+    return this;
+  }
+
+  getStatus() {
     const {
-      colorBufferFloat,
-      colorBufferHalfFloat
+      gl
+    } = this;
+    const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
+    const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER);
+    gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+    return status;
+  }
+
+  show() {
+    if (typeof window !== 'undefined') {
+      window.open(copyToDataUrl(this), 'luma-debug-texture');
+    }
+
+    return this;
+  }
+
+  log(logLevel = 0, message = '') {
+    if (logLevel > log.level || typeof window === 'undefined') {
+      return this;
+    }
+
+    message = message || "Framebuffer ".concat(this.id);
+    const image = copyToDataUrl(this, {
+      targetMaxHeight: 100
+    });
+    log.image({
+      logLevel,
+      message,
+      image
+    })();
+    return this;
+  }
+
+  bind({
+    target = GL.FRAMEBUFFER
+  } = {}) {
+    this.gl.bindFramebuffer(target, this.handle);
+    return this;
+  }
+
+  unbind({
+    target = GL.FRAMEBUFFER
+  } = {}) {
+    this.gl.bindFramebuffer(target, null);
+    return this;
+  }
+
+  _initialize(options) {
+    const {
+      attachments = {},
+      readBuffer,
+      drawBuffers
     } = options;
-    let supported = true;
 
-    if (colorBufferFloat) {
-      supported = Boolean(gl.getExtension('EXT_color_buffer_float') || gl.getExtension('WEBGL_color_buffer_float') || gl.getExtension('OES_texture_float'));
+    this._attach(attachments);
+
+    const prevHandle = this.gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
+
+    if (readBuffer) {
+      this._setReadBuffer(readBuffer);
     }
 
-    if (colorBufferHalfFloat) {
-      supported = supported && Boolean(gl.getExtension('EXT_color_buffer_float') || gl.getExtension('EXT_color_buffer_half_float'));
+    if (drawBuffers) {
+      this._setDrawBuffers(drawBuffers);
     }
 
-    return supported;
+    this.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+    return this;
+  }
+
+  _attach(attachments) {
+    const prevHandle = this.gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
+
+    for (const key in attachments) {
+      assert(key !== undefined, 'Misspelled framebuffer binding point?');
+      const attachmentPoint = Number(key);
+      const attachment = attachments[attachmentPoint];
+
+      this._attachOne(attachmentPoint, attachment);
+    }
+
+    this.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+  }
+
+  _attachOne(attachmentPoint, attachment) {
+    if (attachment instanceof Renderbuffer) {
+      this._attachRenderbuffer(attachmentPoint, attachment);
+
+      return attachment;
+    } else if (Array.isArray(attachment)) {
+      const [texture, layer = 0, level = 0] = attachment;
+
+      this._attachTexture(attachmentPoint, texture, layer, level);
+
+      return texture;
+    } else if (attachment instanceof Texture2D) {
+      this._attachTexture(attachmentPoint, attachment, 0, 0);
+
+      return attachment;
+    }
+  }
+
+  _attachRenderbuffer(attachment, renderbuffer) {
+    this.gl.framebufferRenderbuffer(GL.FRAMEBUFFER, attachment, GL.RENDERBUFFER, renderbuffer.handle);
+  }
+
+  _attachTexture(attachment, texture, layer, level) {
+    const {
+      gl
+    } = this;
+    gl.bindTexture(texture.target, texture.handle);
+
+    switch (texture.target) {
+      case GL.TEXTURE_2D_ARRAY:
+      case GL.TEXTURE_3D:
+        const gl2 = assertWebGL2Context(gl);
+        gl2.framebufferTextureLayer(GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+        break;
+
+      case GL.TEXTURE_CUBE_MAP:
+        const face = mapIndexToCubeMapFace(layer);
+        gl.framebufferTexture2D(GL.FRAMEBUFFER, attachment, face, texture.handle, level);
+        break;
+
+      case GL.TEXTURE_2D:
+        gl.framebufferTexture2D(GL.FRAMEBUFFER, attachment, GL.TEXTURE_2D, texture.handle, level);
+        break;
+
+      default:
+        assert(false, 'Illegal texture type');
+    }
+
+    gl.bindTexture(texture.target, null);
+  }
+
+  _setReadBuffer(readBuffer) {
+    const gl2 = getWebGL2Context(this.gl);
+
+    if (gl2) {
+      gl2.readBuffer(readBuffer);
+    } else {
+      assert(readBuffer === GL.COLOR_ATTACHMENT0 || readBuffer === GL.BACK, ERR_MULTIPLE_RENDERTARGETS);
+    }
+  }
+
+  _setDrawBuffers(drawBuffers) {
+    const {
+      gl
+    } = this;
+    const gl2 = assertWebGL2Context(gl);
+
+    if (gl2) {
+      gl2.drawBuffers(drawBuffers);
+    } else {
+      const ext = gl.getExtension('WEBGL_draw_buffers');
+
+      if (ext) {
+        ext.drawBuffersWEBGL(drawBuffers);
+      } else {
+        assert(drawBuffers.length === 1 && (drawBuffers[0] === GL.COLOR_ATTACHMENT0 || drawBuffers[0] === GL.BACK), ERR_MULTIPLE_RENDERTARGETS);
+      }
+    }
+  }
+
+  _createHandle() {
+    return this.gl.createFramebuffer();
+  }
+
+  _deleteHandle() {
+    this.gl.deleteFramebuffer(this.handle);
+  }
+
+  _bindHandle(handle) {
+    return this.gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
+  }
+
+}
+export default class Framebuffer extends ImmutableFramebuffer {
+  static isSupported(gl, options) {
+    return isFloatColorBufferSupported(gl, options);
   }
 
   static getDefaultFramebuffer(gl) {
-    gl.luma = gl.luma || {};
-    gl.luma.defaultFramebuffer = gl.luma.defaultFramebuffer || new Framebuffer(gl, {
+    const webglDevice = WebGLDevice.fromContext(gl);
+    webglDevice.defaultFramebuffer = webglDevice.defaultFramebuffer || new Framebuffer(gl, {
       id: 'default-framebuffer',
       handle: null,
       attachments: {}
     });
-    return gl.luma.defaultFramebuffer;
+    return webglDevice.defaultFramebuffer;
   }
 
   get MAX_COLOR_ATTACHMENTS() {
@@ -47,45 +238,55 @@ export default class Framebuffer extends Resource {
     return gl2.getParameter(gl2.MAX_DRAW_BUFFERS);
   }
 
-  constructor(gl, opts = {}) {
-    super(gl, opts);
-    this.width = null;
-    this.height = null;
-    this.attachments = {};
-    this.readBuffer = 36064;
-    this.drawBuffers = [36064];
-    this.ownResources = [];
-    this.initialize(opts);
+  constructor(gl, props) {
+    super(gl, props);
+
+    _defineProperty(this, "width", null);
+
+    _defineProperty(this, "height", null);
+
+    _defineProperty(this, "attachments", {});
+
+    _defineProperty(this, "readBuffer", GL.COLOR_ATTACHMENT0);
+
+    _defineProperty(this, "drawBuffers", [GL.COLOR_ATTACHMENT0]);
+
+    _defineProperty(this, "ownResources", []);
+
+    this.initialize(props);
     Object.seal(this);
   }
 
   get color() {
-    return this.attachments[36064] || null;
+    return this.attachments[GL.COLOR_ATTACHMENT0] || null;
   }
 
   get texture() {
-    return this.attachments[36064] || null;
+    return this.attachments[GL.COLOR_ATTACHMENT0] || null;
   }
 
   get depth() {
-    return this.attachments[36096] || this.attachments[33306] || null;
+    return this.attachments[GL.DEPTH_ATTACHMENT] || this.attachments[GL.DEPTH_STENCIL_ATTACHMENT] || null;
   }
 
   get stencil() {
-    return this.attachments[36128] || this.attachments[33306] || null;
-  }
-
-  initialize({
-    width = 1,
-    height = 1,
-    attachments = null,
-    color = true,
-    depth = true,
-    stencil = false,
-    check = true,
-    readBuffer = undefined,
-    drawBuffers = undefined
-  }) {
+    return this.attachments[GL.STENCIL_ATTACHMENT] || this.attachments[GL.DEPTH_STENCIL_ATTACHMENT] || null;
+  }
+
+  initialize(props) {
+    let {
+      attachments = null
+    } = props || {};
+    const {
+      width = 1,
+      height = 1,
+      color = true,
+      depth = true,
+      stencil = false,
+      check = true,
+      readBuffer = undefined,
+      drawBuffers = undefined
+    } = props || {};
     assert(width >= 0 && height >= 0, 'Width and height need to be integers');
     this.width = width;
     this.height = height;
@@ -124,13 +325,14 @@ export default class Framebuffer extends Resource {
     return this;
   }
 
-  update({
-    attachments = {},
-    readBuffer,
-    drawBuffers,
-    clearAttachments = false,
-    resizeAttachments = true
-  }) {
+  update(options) {
+    const {
+      attachments = {},
+      readBuffer,
+      drawBuffers,
+      clearAttachments = false,
+      resizeAttachments = true
+    } = options;
     this.attach(attachments, {
       clearAttachments,
       resizeAttachments
@@ -138,25 +340,29 @@ export default class Framebuffer extends Resource {
     const {
       gl
     } = this;
-    const prevHandle = gl.bindFramebuffer(36160, this.handle);
+    const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
 
     if (readBuffer) {
       this._setReadBuffer(readBuffer);
+
+      this.readBuffer = readBuffer;
     }
 
     if (drawBuffers) {
       this._setDrawBuffers(drawBuffers);
+
+      this.drawBuffers = drawBuffers;
     }
 
-    gl.bindFramebuffer(36160, prevHandle || null);
+    gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
     return this;
   }
 
-  resize(options = {}) {
+  resize(size) {
     let {
       width,
       height
-    } = options;
+    } = size || {};
 
     if (this.handle === null) {
       assert(width === undefined && height === undefined);
@@ -174,7 +380,7 @@ export default class Framebuffer extends Resource {
     }
 
     if (width !== this.width && height !== this.height) {
-      log.log(2, `Resizing framebuffer ${this.id} to ${width}x${height}`)();
+      log.log(2, "Resizing framebuffer ".concat(this.id, " to ").concat(width, "x").concat(height))();
     }
 
     for (const attachmentPoint in this.attachments) {
@@ -202,7 +408,7 @@ export default class Framebuffer extends Resource {
     }
 
     Object.assign(newAttachments, attachments);
-    const prevHandle = this.gl.bindFramebuffer(36160, this.handle);
+    const prevHandle = this.gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
 
     for (const key in newAttachments) {
       assert(key !== undefined, 'Misspelled framebuffer binding point?');
@@ -212,28 +418,9 @@ export default class Framebuffer extends Resource {
 
       if (!object) {
         this._unattach(attachment);
-      } else if (object instanceof Renderbuffer) {
-        this._attachRenderbuffer({
-          attachment,
-          renderbuffer: object
-        });
-      } else if (Array.isArray(descriptor)) {
-        const [texture, layer = 0, level = 0] = descriptor;
-        object = texture;
-
-        this._attachTexture({
-          attachment,
-          texture,
-          layer,
-          level
-        });
       } else {
-        this._attachTexture({
-          attachment,
-          texture: object,
-          layer: 0,
-          level: 0
-        });
+        object = this._attachOne(attachment, object);
+        this.attachments[attachment] = object;
       }
 
       if (resizeAttachments && object) {
@@ -244,44 +431,21 @@ export default class Framebuffer extends Resource {
       }
     }
 
-    this.gl.bindFramebuffer(36160, prevHandle || null);
+    this.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
     Object.assign(this.attachments, attachments);
     Object.keys(this.attachments).filter(key => !this.attachments[key]).forEach(key => {
       delete this.attachments[key];
     });
   }
 
-  checkStatus() {
-    const {
-      gl
-    } = this;
-    const status = this.getStatus();
-
-    if (status !== 36053) {
-      throw new Error(_getFrameBufferStatus(status));
-    }
-
-    return this;
-  }
-
-  getStatus() {
-    const {
-      gl
-    } = this;
-    const prevHandle = gl.bindFramebuffer(36160, this.handle);
-    const status = gl.checkFramebufferStatus(36160);
-    gl.bindFramebuffer(36160, prevHandle || null);
-    return status;
-  }
-
-  clear(options = {}) {
+  clear(options) {
     const {
       color,
       depth,
       stencil,
       drawBuffers = []
     } = options;
-    const prevHandle = this.gl.bindFramebuffer(36160, this.handle);
+    const prevHandle = this.gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
 
     if (color || depth || stencil) {
       clear(this.gl, {
@@ -297,58 +461,34 @@ export default class Framebuffer extends Resource {
         value
       });
     });
-    this.gl.bindFramebuffer(36160, prevHandle || null);
+    this.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
     return this;
   }
 
-  readPixels(opts = {}) {
-    log.error('Framebuffer.readPixels() is no logner supported, use readPixelsToArray(framebuffer)')();
-    return null;
-  }
-
-  readPixelsToBuffer(opts = {}) {
-    log.error('Framebuffer.readPixelsToBuffer()is no logner supported, use readPixelsToBuffer(framebuffer)')();
-    return null;
-  }
-
-  copyToDataUrl(opts = {}) {
-    log.error('Framebuffer.copyToDataUrl() is no logner supported, use copyToDataUrl(framebuffer)')();
-    return null;
-  }
-
-  copyToImage(opts = {}) {
-    log.error('Framebuffer.copyToImage() is no logner supported, use copyToImage(framebuffer)')();
-    return null;
-  }
-
-  copyToTexture(opts = {}) {
-    log.error('Framebuffer.copyToTexture({...}) is no logner supported, use copyToTexture(source, target, opts})')();
-    return null;
-  }
-
   blit(opts = {}) {
     log.error('Framebuffer.blit({...}) is no logner supported, use blit(source, target, opts)')();
     return null;
   }
 
-  invalidate({
-    attachments = [],
-    x = 0,
-    y = 0,
-    width,
-    height
-  }) {
+  invalidate(options) {
+    const {
+      attachments = [],
+      x = 0,
+      y = 0,
+      width,
+      height
+    } = options;
     const gl2 = assertWebGL2Context(this.gl);
-    const prevHandle = gl2.bindFramebuffer(36008, this.handle);
+    const prevHandle = gl2.bindFramebuffer(GL.READ_FRAMEBUFFER, this.handle);
     const invalidateAll = x === 0 && y === 0 && width === undefined && height === undefined;
 
     if (invalidateAll) {
-      gl2.invalidateFramebuffer(36008, attachments);
+      gl2.invalidateFramebuffer(GL.READ_FRAMEBUFFER, attachments);
     } else {
-      gl2.invalidateFramebuffer(36008, attachments, x, y, width, height);
+      gl2.invalidateFramebuffer(GL.READ_FRAMEBUFFER, attachments, x, y, width, height);
     }
 
-    gl2.bindFramebuffer(36008, prevHandle);
+    gl2.bindFramebuffer(GL.READ_FRAMEBUFFER, prevHandle);
     return this;
   }
 
@@ -356,9 +496,9 @@ export default class Framebuffer extends Resource {
     let value = this._getAttachmentParameterFallback(pname);
 
     if (value === null) {
-      this.gl.bindFramebuffer(36160, this.handle);
-      value = this.gl.getFramebufferAttachmentParameter(36160, attachment, pname);
-      this.gl.bindFramebuffer(36160, null);
+      this.gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
+      value = this.gl.getFramebufferAttachmentParameter(GL.FRAMEBUFFER, attachment, pname);
+      this.gl.bindFramebuffer(GL.FRAMEBUFFER, null);
     }
 
     if (keys && value > 1000) {
@@ -368,7 +508,7 @@ export default class Framebuffer extends Resource {
     return value;
   }
 
-  getAttachmentParameters(attachment = 36064, keys, parameters = this.constructor.ATTACHMENT_PARAMETERS || []) {
+  getAttachmentParameters(attachment = GL.COLOR_ATTACHMENT0, keys, parameters = this.constructor.ATTACHMENT_PARAMETERS || []) {
     const values = {};
 
     for (const pname of parameters) {
@@ -392,86 +532,47 @@ export default class Framebuffer extends Resource {
     return parameters;
   }
 
-  show() {
-    if (typeof window !== 'undefined') {
-      window.open(copyToDataUrl(this), 'luma-debug-texture');
-    }
-
-    return this;
-  }
-
-  log(logLevel = 0, message = '') {
-    if (logLevel > log.level || typeof window === 'undefined') {
-      return this;
-    }
-
-    message = message || `Framebuffer ${this.id}`;
-    const image = copyToDataUrl(this, {
-      targetMaxHeight: 100
-    });
-    log.image({
-      logLevel,
-      message,
-      image
-    }, message)();
-    return this;
-  }
-
-  bind({
-    target = 36160
-  } = {}) {
-    this.gl.bindFramebuffer(target, this.handle);
-    return this;
-  }
-
-  unbind({
-    target = 36160
-  } = {}) {
-    this.gl.bindFramebuffer(target, null);
-    return this;
-  }
-
   _createDefaultAttachments(color, depth, stencil, width, height) {
     let defaultAttachments = null;
 
     if (color) {
       defaultAttachments = defaultAttachments || {};
-      defaultAttachments[36064] = new Texture2D(this.gl, {
-        id: `${this.id}-color0`,
+      defaultAttachments[GL.COLOR_ATTACHMENT0] = new Texture2D(this.gl, {
+        id: "".concat(this.id, "-color0"),
         pixels: null,
-        format: 6408,
-        type: 5121,
+        format: GL.RGBA,
+        type: GL.UNSIGNED_BYTE,
         width,
         height,
         mipmaps: false,
         parameters: {
-          [10241]: 9729,
-          [10240]: 9729,
-          [10242]: 33071,
-          [10243]: 33071
+          [GL.TEXTURE_MIN_FILTER]: GL.LINEAR,
+          [GL.TEXTURE_MAG_FILTER]: GL.LINEAR,
+          [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
+          [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE
         }
       });
-      this.ownResources.push(defaultAttachments[36064]);
+      this.ownResources.push(defaultAttachments[GL.COLOR_ATTACHMENT0]);
     }
 
     if (depth && stencil) {
       defaultAttachments = defaultAttachments || {};
-      defaultAttachments[33306] = new Renderbuffer(this.gl, {
-        id: `${this.id}-depth-stencil`,
-        format: 35056,
+      defaultAttachments[GL.DEPTH_STENCIL_ATTACHMENT] = new Renderbuffer(this.gl, {
+        id: "".concat(this.id, "-depth-stencil"),
+        format: GL.DEPTH24_STENCIL8,
         width,
         height: 111
       });
-      this.ownResources.push(defaultAttachments[33306]);
+      this.ownResources.push(defaultAttachments[GL.DEPTH_STENCIL_ATTACHMENT]);
     } else if (depth) {
       defaultAttachments = defaultAttachments || {};
-      defaultAttachments[36096] = new Renderbuffer(this.gl, {
-        id: `${this.id}-depth`,
-        format: 33189,
+      defaultAttachments[GL.DEPTH_ATTACHMENT] = new Renderbuffer(this.gl, {
+        id: "".concat(this.id, "-depth"),
+        format: GL.DEPTH_COMPONENT16,
         width,
         height
       });
-      this.ownResources.push(defaultAttachments[36096]);
+      this.ownResources.push(defaultAttachments[GL.DEPTH_ATTACHMENT]);
     } else if (stencil) {
       assert(false);
     }
@@ -487,142 +588,69 @@ export default class Framebuffer extends Resource {
     }
 
     if (oldAttachment instanceof Renderbuffer) {
-      this.gl.framebufferRenderbuffer(36160, attachment, 36161, null);
+      this.gl.framebufferRenderbuffer(GL.FRAMEBUFFER, attachment, GL.RENDERBUFFER, null);
     } else {
-      this.gl.framebufferTexture2D(36160, attachment, 3553, null, 0);
+      this.gl.framebufferTexture2D(GL.FRAMEBUFFER, attachment, GL.TEXTURE_2D, null, 0);
     }
 
     delete this.attachments[attachment];
   }
 
-  _attachRenderbuffer({
-    attachment = 36064,
-    renderbuffer
-  }) {
-    const {
-      gl
-    } = this;
-    gl.framebufferRenderbuffer(36160, attachment, 36161, renderbuffer.handle);
-    this.attachments[attachment] = renderbuffer;
-  }
-
-  _attachTexture({
-    attachment = 36064,
-    texture,
-    layer,
-    level
-  }) {
-    const {
-      gl
-    } = this;
-    gl.bindTexture(texture.target, texture.handle);
-
-    switch (texture.target) {
-      case 35866:
-      case 32879:
-        const gl2 = assertWebGL2Context(gl);
-        gl2.framebufferTextureLayer(36160, attachment, texture.target, level, layer);
-        break;
-
-      case 34067:
-        const face = mapIndexToCubeMapFace(layer);
-        gl.framebufferTexture2D(36160, attachment, face, texture.handle, level);
-        break;
-
-      case 3553:
-        gl.framebufferTexture2D(36160, attachment, 3553, texture.handle, level);
-        break;
-
-      default:
-        assert(false, 'Illegal texture type');
-    }
-
-    gl.bindTexture(texture.target, null);
-    this.attachments[attachment] = texture;
-  }
-
-  _setReadBuffer(readBuffer) {
-    const gl2 = getWebGL2Context(this.gl);
-
-    if (gl2) {
-      gl2.readBuffer(readBuffer);
-    } else {
-      assert(readBuffer === 36064 || readBuffer === 1029, ERR_MULTIPLE_RENDERTARGETS);
-    }
-
-    this.readBuffer = readBuffer;
-  }
-
-  _setDrawBuffers(drawBuffers) {
-    const {
-      gl
-    } = this;
-    const gl2 = assertWebGL2Context(gl);
-
-    if (gl2) {
-      gl2.drawBuffers(drawBuffers);
-    } else {
-      const ext = gl.getExtension('WEBGL_draw_buffers');
-
-      if (ext) {
-        ext.drawBuffersWEBGL(drawBuffers);
-      } else {
-        assert(drawBuffers.length === 1 && (drawBuffers[0] === 36064 || drawBuffers[0] === 1029), ERR_MULTIPLE_RENDERTARGETS);
-      }
-    }
-
-    this.drawBuffers = drawBuffers;
-  }
-
   _getAttachmentParameterFallback(pname) {
-    const caps = getFeatures(this.gl);
+    const webglDevice = WebGLDevice.fromContext(this.gl);
+    const features = webglDevice.features;
 
     switch (pname) {
-      case 36052:
-        return !caps.WEBGL2 ? 0 : null;
+      case GL.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
+        return !features.has('webgl2') ? 0 : null;
 
-      case 33298:
-      case 33299:
-      case 33300:
-      case 33301:
-      case 33302:
-      case 33303:
-        return !caps.WEBGL2 ? 8 : null;
+      case GL.FRAMEBUFFER_ATTACHMENT_RED_SIZE:
+      case GL.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
+      case GL.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
+      case GL.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
+      case GL.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
+      case GL.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
+        return !features.has('webgl2') ? 8 : null;
 
-      case 33297:
-        return !caps.WEBGL2 ? 5125 : null;
+      case GL.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
+        return !features.has('webgl2') ? GL.UNSIGNED_INT : null;
 
-      case 33296:
-        return !caps.WEBGL2 && !caps.EXT_sRGB ? 9729 : null;
+      case GL.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
+        return !features.has('webgl2') && !features.has('webgl-color-encoding-srgb') ? GL.LINEAR : null;
 
       default:
         return null;
     }
   }
 
-  _createHandle() {
-    return this.gl.createFramebuffer();
-  }
-
-  _deleteHandle() {
-    this.gl.deleteFramebuffer(this.handle);
-  }
-
-  _bindHandle(handle) {
-    return this.gl.bindFramebuffer(36160, handle);
-  }
-
 }
 
+_defineProperty(Framebuffer, "FRAMEBUFFER_ATTACHMENT_PARAMETERS", [GL.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, GL.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, GL.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, GL.FRAMEBUFFER_ATTACHMENT_RED_SIZE, GL.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, GL.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, GL.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, GL.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, GL.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE]);
+
 function mapIndexToCubeMapFace(layer) {
-  return layer < 34069 ? layer + 34069 : layer;
+  return layer < GL.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + GL.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
 }
 
 function _getFrameBufferStatus(status) {
   const STATUS = Framebuffer.STATUS || {};
-  return STATUS[status] || `Framebuffer error ${status}`;
+  return STATUS[status] || "Framebuffer error ".concat(status);
 }
 
-export const FRAMEBUFFER_ATTACHMENT_PARAMETERS = [36049, 36048, 33296, 33298, 33299, 33300, 33301, 33302, 33303];
-Framebuffer.ATTACHMENT_PARAMETERS = FRAMEBUFFER_ATTACHMENT_PARAMETERS;
+function isFloatColorBufferSupported(gl, options) {
+  const {
+    colorBufferFloat,
+    colorBufferHalfFloat
+  } = options;
+  let supported = true;
+
+  if (colorBufferFloat) {
+    supported = Boolean(gl.getExtension('EXT_color_buffer_float') || gl.getExtension('WEBGL_color_buffer_float') || gl.getExtension('OES_texture_float'));
+  }
+
+  if (colorBufferHalfFloat) {
+    supported = supported && Boolean(gl.getExtension('EXT_color_buffer_float') || gl.getExtension('EXT_color_buffer_half_float'));
+  }
+
+  return supported;
+}
 //# sourceMappingURL=framebuffer.js.map