gpu/command_buffer/service/framebuffer_manager.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_
   6 #define GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_
   7
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/containers/hash_tables.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "gpu/command_buffer/service/context_group.h"
  15 #include "gpu/command_buffer/service/gl_utils.h"
  16 #include "gpu/gpu_export.h"
  17
  18 namespace gpu {
  19 namespace gles2 {
  20
  21 class FramebufferCompletenessCache;
  22 class FramebufferManager;
  23 class Renderbuffer;
  24 class RenderbufferManager;
  25 class Texture;
  26 class TextureRef;
  27 class TextureManager;
  28
  29 // Info about a particular Framebuffer.
  30 class GPU_EXPORT Framebuffer : public base::RefCounted<Framebuffer> {
  31  public:
  32   class Attachment : public base::RefCounted<Attachment> {
  33    public:
  34     virtual GLsizei width() const = 0;
  35     virtual GLsizei height() const = 0;
  36     virtual GLenum internal_format() const = 0;
  37     virtual GLenum texture_type() const = 0;
  38     virtual GLsizei samples() const = 0;
  39     virtual GLuint object_name() const = 0;
  40     virtual bool cleared() const = 0;
  41     virtual void SetCleared(
  42         RenderbufferManager* renderbuffer_manager,
  43         TextureManager* texture_manager,
  44         bool cleared) = 0;
  45     virtual bool IsTexture(TextureRef* texture) const = 0;
  46     virtual bool IsRenderbuffer(
  47         Renderbuffer* renderbuffer) const = 0;
  48     virtual bool CanRenderTo() const = 0;
  49     virtual void DetachFromFramebuffer(Framebuffer* framebuffer) const = 0;
  50     virtual bool ValidForAttachmentType(
  51         GLenum attachment_type, uint32 max_color_attachments) = 0;
  52     virtual size_t GetSignatureSize(TextureManager* texture_manager) const = 0;
  53     virtual void AddToSignature(
  54         TextureManager* texture_manager, std::string* signature) const = 0;
  55     virtual void OnWillRenderTo() const = 0;
  56     virtual void OnDidRenderTo() const = 0;
  57     virtual bool FormsFeedbackLoop(TextureRef* texture, GLint level) const = 0;
  58
  59    protected:
  60     friend class base::RefCounted<Attachment>;
  61     virtual ~Attachment() {}
  62   };
  63
  64   Framebuffer(FramebufferManager* manager, GLuint service_id);
  65
  66   GLuint service_id() const {
  67     return service_id_;
  68   }
  69
  70   bool HasUnclearedAttachment(GLenum attachment) const;
  71   bool HasUnclearedColorAttachments() const;
  72
  73   void MarkAttachmentAsCleared(
  74     RenderbufferManager* renderbuffer_manager,
  75     TextureManager* texture_manager,
  76     GLenum attachment,
  77     bool cleared);
  78
  79   // Unbinds all attachments from this framebuffer for workaround
  80   // 'unbind_attachments_on_bound_render_fbo_delete'.  The Framebuffer must be
  81   // bound when calling this.
  82   void DoUnbindGLAttachmentsForWorkaround(GLenum target);
  83
  84   // Attaches a renderbuffer to a particlar attachment.
  85   // Pass null to detach.
  86   void AttachRenderbuffer(
  87       GLenum attachment, Renderbuffer* renderbuffer);
  88
  89   // Attaches a texture to a particlar attachment. Pass null to detach.
  90   void AttachTexture(
  91       GLenum attachment, TextureRef* texture_ref, GLenum target,
  92       GLint level, GLsizei samples);
  93
  94   // Unbinds the given renderbuffer if it is bound.
  95   void UnbindRenderbuffer(
  96       GLenum target, Renderbuffer* renderbuffer);
  97
  98   // Unbinds the given texture if it is bound.
  99   void UnbindTexture(
 100       GLenum target, TextureRef* texture_ref);
 101
 102   const Attachment* GetAttachment(GLenum attachment) const;
 103
 104   const Attachment* GetReadBufferAttachment() const;
 105
 106   bool IsDeleted() const {
 107     return deleted_;
 108   }
 109
 110   void MarkAsValid() {
 111     has_been_bound_ = true;
 112   }
 113
 114   bool IsValid() const {
 115     return has_been_bound_ && !IsDeleted();
 116   }
 117
 118   bool HasDepthAttachment() const;
 119   bool HasStencilAttachment() const;
 120   GLenum GetDrawBufferInternalFormat() const;
 121   GLenum GetReadBufferInternalFormat() const;
 122   // If the color attachment is a texture, returns its type; otherwise,
 123   // returns 0.
 124   GLenum GetReadBufferTextureType() const;
 125
 126   // Verify all the rules in OpenGL ES 2.0.25 4.4.5 are followed.
 127   // Returns GL_FRAMEBUFFER_COMPLETE if there are no reasons we know we can't
 128   // use this combination of attachments. Otherwise returns the value
 129   // that glCheckFramebufferStatus should return for this set of attachments.
 130   // Note that receiving GL_FRAMEBUFFER_COMPLETE from this function does
 131   // not mean the real OpenGL will consider it framebuffer complete. It just
 132   // means it passed our tests.
 133   GLenum IsPossiblyComplete() const;
 134
 135   // Implements optimized glGetFramebufferStatus.
 136   GLenum GetStatus(TextureManager* texture_manager, GLenum target) const;
 137
 138   // Check all attachments are cleared
 139   bool IsCleared() const;
 140
 141   GLenum GetDrawBuffer(GLenum draw_buffer) const;
 142
 143   void SetDrawBuffers(GLsizei n, const GLenum* bufs);
 144
 145   // If a color buffer is attached to GL_COLOR_ATTACHMENTi, enable that
 146   // draw buffer for glClear().
 147   void PrepareDrawBuffersForClear() const;
 148
 149   // Restore draw buffers states that have been changed in
 150   // PrepareDrawBuffersForClear().
 151   void RestoreDrawBuffersAfterClear() const;
 152
 153   // Clear all the active INT or UINT type color buffers to (0, 0, 0, 0).
 154   void ClearIntegerBuffers();
 155
 156   // Return true if any draw buffers has an alpha channel.
 157   bool HasAlphaMRT() const;
 158
 159   // Return false if any two active color attachments have different internal
 160   // formats.
 161   bool HasSameInternalFormatsMRT() const;
 162
 163   void OnTextureRefDetached(TextureRef* texture);
 164
 165   // If attachment is 0, apply to all attachments; otherwise, apply only to
 166   // the specified attachment.
 167   void OnWillRenderTo(GLenum attachment) const;
 168   void OnDidRenderTo(GLenum attachment) const;
 169
 170   void set_read_buffer(GLenum read_buffer) {
 171     read_buffer_ = read_buffer;
 172   }
 173
 174   GLenum read_buffer() const {
 175     return read_buffer_;
 176   }
 177
 178  private:
 179   friend class FramebufferManager;
 180   friend class base::RefCounted<Framebuffer>;
 181
 182   ~Framebuffer();
 183
 184   void MarkAsDeleted();
 185
 186   void MarkAttachmentsAsCleared(
 187     RenderbufferManager* renderbuffer_manager,
 188     TextureManager* texture_manager,
 189     bool cleared);
 190
 191   void MarkAsComplete(unsigned state_id) {
 192     framebuffer_complete_state_count_id_ = state_id;
 193   }
 194
 195   unsigned framebuffer_complete_state_count_id() const {
 196     return framebuffer_complete_state_count_id_;
 197   }
 198
 199   // Helper function for PrepareDrawBuffersForClear() and
 200   // RestoreDrawBuffersAfterClear().
 201   void ChangeDrawBuffersHelper(bool recover) const;
 202
 203   // The managers that owns this.
 204   FramebufferManager* manager_;
 205
 206   bool deleted_;
 207
 208   // Service side framebuffer id.
 209   GLuint service_id_;
 210
 211   // Whether this framebuffer has ever been bound.
 212   bool has_been_bound_;
 213
 214   // state count when this framebuffer was last checked for completeness.
 215   unsigned framebuffer_complete_state_count_id_;
 216
 217   // A map of attachments.
 218   typedef base::hash_map<GLenum, scoped_refptr<Attachment> > AttachmentMap;
 219   AttachmentMap attachments_;
 220
 221   scoped_ptr<GLenum[]> draw_buffers_;
 222
 223   GLenum read_buffer_;
 224
 225   DISALLOW_COPY_AND_ASSIGN(Framebuffer);
 226 };
 227
 228 struct DecoderFramebufferState {
 229   DecoderFramebufferState();
 230   ~DecoderFramebufferState();
 231
 232   // State saved for clearing so we can clear render buffers and then
 233   // restore to these values.
 234   bool clear_state_dirty;
 235
 236   // The currently bound framebuffers
 237   scoped_refptr<Framebuffer> bound_read_framebuffer;
 238   scoped_refptr<Framebuffer> bound_draw_framebuffer;
 239 };
 240
 241 // This class keeps track of the frambebuffers and their attached renderbuffers
 242 // so we can correctly clear them.
 243 class GPU_EXPORT FramebufferManager {
 244  public:
 245   class GPU_EXPORT TextureDetachObserver {
 246    public:
 247     TextureDetachObserver();
 248     virtual ~TextureDetachObserver();
 249
 250     virtual void OnTextureRefDetachedFromFramebuffer(TextureRef* texture) = 0;
 251
 252    private:
 253     DISALLOW_COPY_AND_ASSIGN(TextureDetachObserver);
 254   };
 255
 256   FramebufferManager(uint32 max_draw_buffers,
 257                      uint32 max_color_attachments,
 258                      ContextGroup::ContextType context_type,
 259                      const scoped_refptr<FramebufferCompletenessCache>&
 260                          framebuffer_combo_complete_cache);
 261   ~FramebufferManager();
 262
 263   // Must call before destruction.
 264   void Destroy(bool have_context);
 265
 266   // Creates a Framebuffer for the given framebuffer.
 267   void CreateFramebuffer(GLuint client_id, GLuint service_id);
 268
 269   // Gets the framebuffer info for the given framebuffer.
 270   Framebuffer* GetFramebuffer(GLuint client_id);
 271
 272   // Removes a framebuffer info for the given framebuffer.
 273   void RemoveFramebuffer(GLuint client_id);
 274
 275   // Gets a client id for a given service id.
 276   bool GetClientId(GLuint service_id, GLuint* client_id) const;
 277
 278   void MarkAttachmentsAsCleared(
 279     Framebuffer* framebuffer,
 280     RenderbufferManager* renderbuffer_manager,
 281     TextureManager* texture_manager);
 282
 283   void MarkAsComplete(Framebuffer* framebuffer);
 284
 285   bool IsComplete(Framebuffer* framebuffer);
 286
 287   void IncFramebufferStateChangeCount() {
 288     // make sure this is never 0.
 289     framebuffer_state_change_count_ =
 290         (framebuffer_state_change_count_ + 1) | 0x80000000U;
 291   }
 292
 293   void AddObserver(TextureDetachObserver* observer) {
 294     texture_detach_observers_.push_back(observer);
 295   }
 296
 297   void RemoveObserver(TextureDetachObserver* observer) {
 298     texture_detach_observers_.erase(
 299         std::remove(texture_detach_observers_.begin(),
 300                     texture_detach_observers_.end(),
 301                     observer),
 302         texture_detach_observers_.end());
 303   }
 304
 305   ContextGroup::ContextType context_type() const {
 306     return context_type_;
 307   }
 308
 309  private:
 310   friend class Framebuffer;
 311
 312   void StartTracking(Framebuffer* framebuffer);
 313   void StopTracking(Framebuffer* framebuffer);
 314
 315   void OnTextureRefDetached(TextureRef* texture);
 316
 317   FramebufferCompletenessCache* GetFramebufferComboCompleteCache() {
 318     return framebuffer_combo_complete_cache_.get();
 319   }
 320
 321   // Info for each framebuffer in the system.
 322   typedef base::hash_map<GLuint, scoped_refptr<Framebuffer> >
 323       FramebufferMap;
 324   FramebufferMap framebuffers_;
 325
 326   // Incremented anytime anything changes that might effect framebuffer
 327   // state.
 328   unsigned framebuffer_state_change_count_;
 329
 330   // Counts the number of Framebuffer allocated with 'this' as its manager.
 331   // Allows to check no Framebuffer will outlive this.
 332   unsigned int framebuffer_count_;
 333
 334   bool have_context_;
 335
 336   uint32 max_draw_buffers_;
 337   uint32 max_color_attachments_;
 338
 339   ContextGroup::ContextType context_type_;
 340
 341   typedef std::vector<TextureDetachObserver*> TextureDetachObserverVector;
 342   TextureDetachObserverVector texture_detach_observers_;
 343
 344   scoped_refptr<FramebufferCompletenessCache> framebuffer_combo_complete_cache_;
 345
 346   DISALLOW_COPY_AND_ASSIGN(FramebufferManager);
 347 };
 348
 349 }  // namespace gles2
 350 }  // namespace gpu
 351
 352 #endif  // GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_