Validate fbo color image format and fragment shader output variable type.

gpu/command_buffer/service/framebuffer_manager.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_utils.h"
+#include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/gpu_export.h"
 
 namespace gpu {
 namespace gles2 {
 
 class FeatureInfo;
 class FramebufferCompletenessCache;
 class FramebufferManager;
 class Renderbuffer;
 class RenderbufferManager;
@@ skipping 142 matching lines @@
   // Check all attachments are cleared
   bool IsCleared() const;
 
   GLenum GetDrawBuffer(GLenum draw_buffer) const;
 
   void SetDrawBuffers(GLsizei n, const GLenum* bufs);
 
   // If a color buffer is attached to GL_COLOR_ATTACHMENTi, enable that
   // draw buffer for glClear().
   // Return true if the DrawBuffers() is actually called.
-  bool PrepareDrawBuffersForClear() const;
+  bool PrepareDrawBuffersForClearingUninitializedAttachments() const;
 
-  // Restore draw buffers states that have been changed in
-  // PrepareDrawBuffersForClear().
-  void RestoreDrawBuffersAfterClear() const;
+  // Restore |adjusted_draw_buffers_|.
+  void RestoreDrawBuffers() const;
+
+  // Checks if a draw buffer's format and its corresponding fragment shader
+  // output's type are compatible, i.e., a signed integer typed variable is
+  // incompatible with a float or unsigned integer buffer.
+  // Return false if incompaticle.
+  // Otherwise, filter out the draw buffers that are not written to but are not
+  // NONE through DrawBuffers, to be on the safe side. Return true.
+  // This is applied before a draw call.
+  bool ValidateAndAdjustDrawBuffers(uint32_t fragment_output_type_mask,
+                                    uint32_t fragment_output_written_mask);
+
+  bool ContainsActiveIntegerAttachments() const;
 
   // Return true if any draw buffers has an alpha channel.
   bool HasAlphaMRT() const;
 
   // Return false if any two active color attachments have different internal
   // formats.
   bool HasSameInternalFormatsMRT() const;
 
   void set_read_buffer(GLenum read_buffer) {
     read_buffer_ = read_buffer;
   }
 
   GLenum read_buffer() const {
     return read_buffer_;
   }
 
+  // See member declaration for details.
+  // The data are only valid if fbo is complete.
+  uint32_t draw_buffer_type_mask() const {
+    return draw_buffer_type_mask_;
+  }
+  uint32_t draw_buffer_bound_mask() const {
+    return draw_buffer_bound_mask_;
+  }
+
  private:
   friend class FramebufferManager;
   friend class base::RefCounted<Framebuffer>;
 
   ~Framebuffer();
 
   void MarkAsDeleted();
 
   void MarkAttachmentsAsCleared(
     RenderbufferManager* renderbuffer_manager,
     TextureManager* texture_manager,
     bool cleared);
 
   void MarkAsComplete(unsigned state_id) {
+    UpdateDrawBufferMasks();
     framebuffer_complete_state_count_id_ = state_id;
   }
 
   unsigned framebuffer_complete_state_count_id() const {
     return framebuffer_complete_state_count_id_;
   }
 
+  // Cache color attachments' base type mask (FLOAT, INT, UINT) and bound mask.
+  // If an attachment point has no image, it's set as UNDEFINED_TYPE.
+  // This call is only valid on a complete fbo.
+  void UpdateDrawBufferMasks();
+
   // The managers that owns this.
   FramebufferManager* manager_;
 
   bool deleted_;
 
   // Service side framebuffer id.
   GLuint service_id_;
 
   // Whether this framebuffer has ever been bound.
   bool has_been_bound_;
 
   // state count when this framebuffer was last checked for completeness.
   unsigned framebuffer_complete_state_count_id_;
 
   // A map of attachments.
   typedef base::hash_map<GLenum, scoped_refptr<Attachment> > AttachmentMap;
   AttachmentMap attachments_;
 
+  // User's draw buffers setting through DrawBuffers() call.
   std::unique_ptr<GLenum[]> draw_buffers_;
 
+  // If a draw buffer does not have an image, or it has no corresponding
+  // fragment shader output variable, it might be filtered out as NONE.
+  // Note that the actually draw buffers setting sent to the driver is always
+  // consistent with |adjusted_draw_buffers_|, not |draw_buffers_|.
+  std::unique_ptr<GLenum[]> adjusted_draw_buffers_;
+
+  // Draw buffer base types: FLOAT, INT, or UINT.
+  // We have up to 16 draw buffers, each is encoded into 2 bits, total 32 bits:
+  // the lowest 2 bits for draw buffer 0, the highest 2 bits for draw buffer 15.
+  uint32_t draw_buffer_type_mask_;
+  // Same layout as above, 2 bits per draw buffer, 0x03 if a draw buffer has a
+  // bound image, 0x00 if not.
+  uint32_t draw_buffer_bound_mask_;
+  // This is the mask for the actual draw buffers sent to driver.
+  uint32_t adjusted_draw_buffer_bound_mask_;
+
   GLenum read_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(Framebuffer);
 };
 
 struct DecoderFramebufferState {
   DecoderFramebufferState();
   ~DecoderFramebufferState();
 
   // State saved for clearing so we can clear render buffers and then
@@ skipping 80 matching lines @@
 
   scoped_refptr<FramebufferCompletenessCache> framebuffer_combo_complete_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(FramebufferManager);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_