WebGL: GL_RGB emulation for IOSurface backed textures. [For reference only]

gpu/command_buffer/service/framebuffer_manager.cc

 // 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.
 
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
@@ skipping 111 matching lines @@
                       std::string* signature) const override {
     DCHECK(signature);
     renderbuffer_->AddToSignature(signature);
   }
 
   bool FormsFeedbackLoop(TextureRef* /* texture */,
                          GLint /*level */) const override {
     return false;
   }
 
+  bool EmulatingRGB() const override { return false; }
+  bool Initialized() const override { return true; }
+  void SetInitialized(bool initialized) override {}
+
  protected:
   ~RenderbufferAttachment() override {}
 
  private:
   scoped_refptr<Renderbuffer> renderbuffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderbufferAttachment);
 };
 
 class TextureAttachment
     : public Framebuffer::Attachment {
  public:
-  TextureAttachment(
-      TextureRef* texture_ref, GLenum target, GLint level,
-      GLsizei samples, GLint layer)
+  TextureAttachment(TextureRef* texture_ref,
+                    GLenum target,
+                    GLint level,
+                    GLsizei samples,
+                    GLint layer)
       : texture_ref_(texture_ref),
         target_(target),
         level_(level),
         samples_(samples),
-        layer_(layer) {
-  }
+        layer_(layer),
+        initialized_(false) {}
 
   GLsizei width() const override {
     GLsizei temp_width = 0;
     GLsizei temp_height = 0;
     texture_ref_->texture()->GetLevelSize(
         target_, level_, &temp_width, &temp_height, nullptr);
     return temp_width;
   }
 
   GLsizei height() const override {
@@ skipping 80 matching lines @@
     GLenum internal_format = 0;
     if (!texture_ref_->texture()->GetLevelType(
         target_, level_, &type, &internal_format)) {
       return false;
     }
     uint32_t need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
     DCHECK_NE(0u, need);
     uint32_t have = GLES2Util::GetChannelsForFormat(internal_format);
 
+    have |= EmulatingRGB() ? GLES2Util::ChannelBits::kAlpha : 0;
+
     // Workaround for NVIDIA drivers that incorrectly expose these formats as
     // renderable:
     if (internal_format == GL_LUMINANCE || internal_format == GL_ALPHA ||
         internal_format == GL_LUMINANCE_ALPHA) {
       return false;
     }
     if (context_type == CONTEXT_TYPE_WEBGL1 &&
         DetectWebGL1DepthStencilAttachmentConflicts(need, have))
       return need == have;
     return (need & have) != 0;
   }
 
   size_t GetSignatureSize(TextureManager* texture_manager) const override {
     return texture_manager->GetSignatureSize();
   }
 
   void AddToSignature(TextureManager* texture_manager,
                       std::string* signature) const override {
     DCHECK(signature);
     texture_manager->AddToSignature(
         texture_ref_.get(), target_, level_, signature);
   }
 
   bool FormsFeedbackLoop(TextureRef* texture, GLint level) const override {
     return texture == texture_ref_.get() && level == level_;
   }
 
+  bool EmulatingRGB() const override {
+    return texture_ref_->texture()->EmulatingRGB();
+  }
+
+  bool Initialized() const override { return initialized_; }
+  void SetInitialized(bool initialized) override { initialized_ = initialized; }
+
  protected:
   ~TextureAttachment() override {}
 
  private:
   scoped_refptr<TextureRef> texture_ref_;
   GLenum target_;
   GLint level_;
   GLsizei samples_;
   GLint layer_;
+  bool initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureAttachment);
 };
 
 FramebufferManager::FramebufferManager(
     uint32_t max_draw_buffers,
     uint32_t max_color_attachments,
     ContextType context_type,
     const scoped_refptr<FramebufferCompletenessCache>&
         framebuffer_combo_complete_cache)
@@ skipping 94 matching lines @@
     if (it->first >= GL_COLOR_ATTACHMENT0 &&
         it->first < GL_COLOR_ATTACHMENT0 + manager_->max_draw_buffers_) {
       const Attachment* attachment = it->second.get();
       if (!attachment->cleared())
         return true;
     }
   }
   return false;
 }
 
+bool Framebuffer::HasUninitializedDrawBuffers() const {
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
+    if (draw_buffers_[i] != GL_NONE) {
+      const Attachment* attachment = GetAttachment(draw_buffers_[i]);
+      if (!attachment)
+        continue;
+      if (!attachment->EmulatingRGB())
+        continue;
+      if (attachment->Initialized())
+        continue;
+      return true;
+    }
+  }
+  return false;
+}
+
+void Framebuffer::SetDrawBuffersAsInitialized() {
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
+    if (draw_buffers_[i] != GL_NONE) {
+      AttachmentMap::iterator it = attachments_.find(draw_buffers_[i]);
+      if (it == attachments_.end())
+        continue;
+      Attachment* attachment = it->second.get();
+      if (!attachment)
+        continue;
+      if (!attachment->EmulatingRGB())
+        continue;
+      if (attachment->Initialized())
+        continue;
+      attachment->SetInitialized(true);
+    }
+  }
+}
+
 bool Framebuffer::HasUnclearedIntRenderbufferAttachments() const {
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     if (!it->second->IsRenderbufferAttachment() || it->second->cleared())
       continue;
     if (GLES2Util::IsIntegerFormat(it->second->internal_format()))
       return true;
   }
   return false;
 }
@@ skipping 117 matching lines @@
 }
 
 GLenum Framebuffer::GetReadBufferInternalFormat() const {
   if (read_buffer_ == GL_NONE)
     return 0;
   AttachmentMap::const_iterator it = attachments_.find(read_buffer_);
   if (it == attachments_.end()) {
     return 0;
   }
   const Attachment* attachment = it->second.get();
+  if (attachment->EmulatingRGB()) {
+    switch (attachment->internal_format()) {
+      case GL_RGBA:
+        return GL_RGB;
+      case GL_BGRA_EXT:
+        return GL_BGR_EXT;
+      default:
+        break;
+    }
+  }
   return attachment->internal_format();
 }
 
 GLenum Framebuffer::GetReadBufferTextureType() const {
   if (read_buffer_ == GL_NONE)
     return 0;
   AttachmentMap::const_iterator it = attachments_.find(read_buffer_);
   if (it == attachments_.end()) {
     return 0;
   }
@@ skipping 105 matching lines @@
   for (GLsizei i = 0; i < n; ++i)
     draw_buffers_[i] = bufs[i];
 }
 
 bool Framebuffer::HasAlphaMRT() const {
   for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
     if (draw_buffers_[i] != GL_NONE) {
       const Attachment* attachment = GetAttachment(draw_buffers_[i]);
       if (!attachment)
         continue;
+      if (attachment->EmulatingRGB())
+        return false;
       if ((GLES2Util::GetChannelsForFormat(
                attachment->internal_format()) & 0x0008) != 0)
         return true;
     }
   }
   return false;
 }
 
+bool Framebuffer::EmulatingRGB() const {
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
+    if (draw_buffers_[i] != GL_NONE) {
+      const Attachment* attachment = GetAttachment(draw_buffers_[i]);
+      if (!attachment)
+        continue;
+      if (attachment->EmulatingRGB())
+        return true;
+    }
+  }
+  return false;
+}
+
 bool Framebuffer::HasSameInternalFormatsMRT() const {
   GLenum internal_format = 0;
   for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
     if (draw_buffers_[i] != GL_NONE) {
       const Attachment* attachment = GetAttachment(draw_buffers_[i]);
       if (!attachment)
         continue;
       if (!internal_format) {
         internal_format = attachment->internal_format();
       } else if (internal_format != attachment->internal_format()) {
@@ skipping 158 matching lines @@
 
 bool FramebufferManager::IsComplete(
     Framebuffer* framebuffer) {
   DCHECK(framebuffer);
   return framebuffer->framebuffer_complete_state_count_id() ==
       framebuffer_state_change_count_;
 }
 
 }  // namespace gles2
 }  // namespace gpu