Add FramebufferManager class

Source/Renderer/FramebufferManager.js

@@ -0,0 +1,308 @@
+import Framebuffer from "./Framebuffer.js";
+import PixelDatatype from "./PixelDatatype.js";
+import Renderbuffer from "./Renderbuffer.js";
+import RenderbufferFormat from "./RenderbufferFormat.js";
+import Sampler from "./Sampler.js";
+import Texture from "./Texture.js";
+import Color from "../Core/Color.js";
+import defaultValue from "../Core/defaultValue.js";
+import defined from "../Core/defined.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import PixelFormat from "../Core/PixelFormat.js";
+
+/**
+ * Creates a wrapper object around a framebuffer and its resources.
+ *
+ * @param {Object} options Object with the following properties:
+ * @param {Number} [options.colorAttachmentsLength=1] The number of color attachments this FramebufferManager will create.
+ * @param {Boolean} [options.color=true] Whether the FramebufferManager will use color attachments.
+ * @param {Boolean} [options.depth=false] Whether the FramebufferManager will use depth attachments.
+ * @param {Boolean} [options.depthStencil=false] Whether the FramebufferManager will use depth-stencil attachments.
+ * @param {Boolean} [options.createColorAttachments=true] Whether the FramebufferManager will construct its own color attachments.
+ * @param {Boolean} [options.createDepthAttachments=true] Whether the FramebufferManager will construct its own depth attachments.*
+ *
+ * @exception {DeveloperError} Cannot have both a depth and depth-stencil attachment.
+ *
+ * @private
+ * @constructor
+ */
+function FramebufferManager(options) {
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  this._colorAttachmentsLength = defaultValue(
+    options.colorAttachmentsLength,
+    1
+  );
+
+  this._color = defaultValue(options.color, true);
+  this._depth = defaultValue(options.depth, false);
+  this._depthStencil = defaultValue(options.depthStencil, false);
+  //>>includeStart('debug', pragmas.debug);
+  if (this._depth && this._depthStencil) {
+    throw new DeveloperError(
+      "Cannot have both a depth and depth-stencil attachment."
+    );
+  }
+  //>>includeEnd('debug');
+
+  this._createColorAttachments = defaultValue(
+    options.createColorAttachments,
+    true
+  );
+  this._createDepthAttachments = defaultValue(
+    options.createDepthAttachments,
+    true
+  );
+
+  this._useHdr = false;
+
+  this._framebuffer = undefined;
+  this._colorRenderbuffer = undefined;
+  this._colorTextures = [];
+  this._depthStencilRenderbuffer = undefined;
+  this._depthStencilTexture = undefined;
+  this._depthRenderbuffer = undefined;
+  this._depthTexture = undefined;
+
+  this._attachmentsSet = false;
+}
+
+Object.defineProperties(FramebufferManager.prototype, {
+  framebuffer: {
+    get: function () {
+      return this._framebuffer;
+    },
+  },
+  status: {
+    get: function () {
+      return this._framebuffer.status;
+    },
+  },
+});
+
+FramebufferManager.prototype.isDirty = function (width, height, hdr) {
+  hdr = defaultValue(hdr, false);
+
+  var texturesDirty = false;
+  var length = this._colorTextures.length;
+  var texture;
+  for (var i = 0; i < length; ++i) {
+    texture = this._colorTextures[i];
+    if (
+      !defined(texture) ||
+      texture.width !== width ||
+      texture.height !== height
+    ) {
+      texturesDirty = true;
+      break;
+    }
+  }
+  return length === 0 || texturesDirty || this._useHdr !== hdr;
+};
+
+FramebufferManager.prototype.update = function (
+  context,
+  width,
+  height,
+  depthTexture,
+  hdr
+) {
+  //>>includeStart('debug', pragmas.debug);
+  if (
+    (!defined(width) || !defined(height)) &&
+    ((this._color && this._createColorAttachments) ||
+      ((this._depth || this._depthStencil) && this._createDepthAttachments))
+  ) {
+    throw new DeveloperError(
+      "width and height must be provided if color or depth attachments are created."
+    );
+  }
+  if (!this._color && !this._depth && !this._depthStencil) {
+    throw new DeveloperError(
+      "must enable at least one type of framebuffer attachment."
+    );
+  }
+  //>>includeEnd('debug');
+  depthTexture = defaultValue(depthTexture, false);
+  hdr = defaultValue(hdr, false);
+
+  if (this._attachmentsSet || this.isDirty(width, height, hdr)) {
+    if (!this._attachmentsSet) {
+      this.destroyResources();
+    }
+    this._useHdr = hdr;
+
+    // Create color texture
+    if (this._color && this._createColorAttachments) {
+      var pixelDatatype = hdr
+        ? context.halfFloatingPointTexture
+          ? PixelDatatype.HALF_FLOAT
+          : PixelDatatype.FLOAT
+        : PixelDatatype.UNSIGNED_BYTE;
+      for (var i = 0; i < this._colorAttachmentsLength; ++i) {
+        this._colorTextures.push(
+          new Texture({
+            context: context,
+            width: width,
+            height: height,
+            pixelFormat: PixelFormat.RGBA,
+            pixelDatatype: pixelDatatype,
+            sampler: Sampler.NEAREST,
+          })
+        );
+      }
+    }
+
+    // Create depth stencil texture or renderbuffer
+    if (this._depthStencil && this._createDepthAttachments) {
+      if (depthTexture) {
+        this._depthStencilTexture = new Texture({
+          context: context,
+          width: width,
+          height: height,
+          pixelFormat: PixelFormat.DEPTH_STENCIL,
+          pixelDatatype: PixelDatatype.UNSIGNED_INT_24_8,
+          sampler: Sampler.NEAREST,
+        });
+      } else {
+        this._depthStencilRenderbuffer = new Renderbuffer({
+          context: context,
+          width: width,
+          height: height,
+          format: RenderbufferFormat.DEPTH_STENCIL,
+        });
+      }
+    }
+
+    // Create depth texture
+    if (this._depth && this._createDepthAttachments) {
+      if (depthTexture) {
+        this._depthTexture = new Texture({
+          context: context,
+          width: width,
+          height: height,
+          pixelFormat: PixelFormat.DEPTH_COMPONENT,
+          pixelDatatype: PixelDatatype.UNSIGNED_INT,
+          sampler: Sampler.NEAREST,
+        });
+      } else {
+        this._depthRenderbuffer = new Renderbuffer({
+          context: context,
+          width: width,
+          height: height,
+          format: RenderbufferFormat.DEPTH_COMPONENT16,
+        });
+      }
+    }
+
+    this._framebuffer = new Framebuffer({
+      context: context,
+      colorTextures: this._colorTextures,
+      depthTexture: this._depthTexture,
+      depthRenderbuffer: this._depthRenderbuffer,
+      depthStencilTexture: this._depthStencilTexture,
+      depthStencilRenderbuffer: this._depthStencilRenderbuffer,
+      destroyAttachments: false,
+    });
+    this._attachmentsSet = false;
+  }
+};
+
+FramebufferManager.prototype.getColorTexture = function (index) {
+  index = defaultValue(index, 0);
+  return this._colorTextures[index];
+};
+
+FramebufferManager.prototype.setColorTexture = function (texture, index) {
+  //>>includeStart('debug', pragmas.debug);
+  if (this._createColorAttachments) {
+    throw new DeveloperError(
+      "If setColorTexture is called, createColorAttachments must be false."
+    );
+  }
+  //>>includeEnd('debug');
+  index = defaultValue(index, 0);
+  this._colorTextures[index] = texture;
+  this._attachmentsSet = true;
+};
+
+FramebufferManager.prototype.getDepthStencilRenderbuffer = function () {
+  return this._depthStencilRenderbuffer;
+};
+
+FramebufferManager.prototype.setDepthStencilRenderbuffer = function (
+  renderbuffer
+) {
+  //>>includeStart('debug', pragmas.debug);
+  if (this._createDepthAttachments) {
+    throw new DeveloperError(
+      "If setDepthStencilRenderbuffer is called, createDepthAttachments must be false."
+    );
+  }
+  //>>includeEnd('debug');
+  this._depthStencilRenderbuffer = renderbuffer;
+  this._attachmentsSet = true;
+};
+
+FramebufferManager.prototype.getDepthStencilTexture = function () {
+  return this._depthStencilTexture;
+};
+
+FramebufferManager.prototype.setDepthStencilTexture = function (texture) {
+  //>>includeStart('debug', pragmas.debug);
+  if (this._createDepthAttachments) {
+    throw new DeveloperError(
+      "If setDepthStencilTexture is called, createDepthAttachments must be false."
+    );
+  }
+  //>>includeEnd('debug');
+  this._depthStencilTexture = texture;
+  this._attachmentsSet = true;
+};
+
+FramebufferManager.prototype.clear = function (
+  context,
+  passState,
+  clearColor,
+  clearCommand
+) {
+  var framebuffer = passState.framebuffer;
+  var clearCommandColor = clearCommand.color;
+
+  passState.framebuffer = this._framebuffer;
+  clearCommand.color = Color.clone(clearColor, clearCommand.color);
+  clearCommand.execute(context, passState);
+
+  clearCommand.color = clearCommandColor;
+  passState.framebuffer = framebuffer;
+};
+
+FramebufferManager.prototype.destroyFramebuffer = function () {
+  this._framebuffer = this._framebuffer && this._framebuffer.destroy();
+};
+
+FramebufferManager.prototype.destroyResources = function () {
+  var length = this._colorTextures.length;
+  for (var i = 0; i < length; ++i) {
+    var texture = this._colorTextures[i];
+    if (defined(texture) && !texture.isDestroyed()) {
+      this._colorTextures[i].destroy();
+    }
+  }
+  this._colorTextures = [];
+
+  if (
+    defined(this._depthStencilTexture) &&
+    !this._depthStencilTexture.isDestroyed()
+  ) {
+    this._depthStencilTexture.destroy();
+    this._depthStencilTexture = undefined;
+  }
+
+  if (defined(this._depthTexture) && !this._depthTexture.isDestroyed()) {
+    this._depthTexture.destroy();
+    this._depthTexture = undefined;
+  }
+
+  this.destroyFramebuffer();
+};
+export default FramebufferManager;

Source/Scene/BrdfLutGenerator.js

@@ -1,33 +1,33 @@
 import BoundingRectangle from "../Core/BoundingRectangle.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
-import PixelFormat from "../Core/PixelFormat.js";
-import Framebuffer from "../Renderer/Framebuffer.js";
-import PixelDatatype from "../Renderer/PixelDatatype.js";
+import FramebufferManager from "../Renderer/FramebufferManager.js";
 import RenderState from "../Renderer/RenderState.js";
-import Sampler from "../Renderer/Sampler.js";
-import Texture from "../Renderer/Texture.js";
 import BrdfLutGeneratorFS from "../Shaders/BrdfLutGeneratorFS.js";
 
 /**
  * @private
  */
 function BrdfLutGenerator() {
-  this._framebuffer = undefined;
-  this._colorTexture = undefined;
+  this._framebuffer = new FramebufferManager();
   this._drawCommand = undefined;
 }
 
 Object.defineProperties(BrdfLutGenerator.prototype, {
+  framebuffer: {
+    get: function () {
+      return this._framebuffer.framebuffer;
+    },
+  },
   colorTexture: {
     get: function () {
-      return this._colorTexture;
+      return this._framebuffer.getColorTexture();
     },
   },
 });
 
 function createCommand(generator, context) {
-  var framebuffer = generator._framebuffer;
+  var framebuffer = generator.framebuffer;
 
   var drawCommand = context.createViewportQuadCommand(BrdfLutGeneratorFS, {
     framebuffer: framebuffer,
@@ -39,35 +39,14 @@ function createCommand(generator, context) {
   generator._drawCommand = drawCommand;
 }
 
-function createFramebuffer(generator, context) {
-  var colorTexture = new Texture({
-    context: context,
-    width: 256,
-    height: 256,
-    pixelFormat: PixelFormat.RGBA,
-    pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
-    sampler: Sampler.NEAREST,
-  });
-
-  generator._colorTexture = colorTexture;
-
-  var framebuffer = new Framebuffer({
-    context: context,
-    colorTextures: [colorTexture],
-    destroyAttachments: false,
-  });
-
-  generator._framebuffer = framebuffer;
-}
-
 BrdfLutGenerator.prototype.update = function (frameState) {
-  if (!defined(this._colorTexture)) {
+  if (!defined(this.colorTexture)) {
     var context = frameState.context;
 
-    createFramebuffer(this, context);
+    this._framebuffer.update(context, 256, 256);
     createCommand(this, context);
     this._drawCommand.execute(context);
-    this._framebuffer = this._framebuffer && this._framebuffer.destroy();
+    this._framebuffer.destroyFramebuffer();
     this._drawCommand.shaderProgram =
       this._drawCommand.shaderProgram &&
       this._drawCommand.shaderProgram.destroy();
@@ -79,7 +58,7 @@ BrdfLutGenerator.prototype.isDestroyed = function () {
 };
 
 BrdfLutGenerator.prototype.destroy = function () {
-  this._colorTexture = this._colorTexture && this._colorTexture.destroy();
+  this._framebuffer.destroyResources();
   return destroyObject(this);
 };
 export default BrdfLutGenerator;