Implement support for rendering to 32-bit float textures on ES3

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 "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
+#include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace gpu {
 namespace gles2 {
 
 DecoderFramebufferState::DecoderFramebufferState()
     : clear_state_dirty(false),
       bound_read_framebuffer(NULL),
@@ skipping 76 matching lines @@
 
   virtual bool CanRenderTo() const OVERRIDE {
     return true;
   }
 
   virtual void DetachFromFramebuffer(Framebuffer* framebuffer) const OVERRIDE {
     // Nothing to do for renderbuffers.
   }
 
   virtual bool ValidForAttachmentType(
-      GLenum attachment_type, uint32 max_color_attachments) OVERRIDE {
+      GLenum attachment_type, uint32 max_color_attachments,
+      const FeatureInfo*) OVERRIDE {
     uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
     uint32 have = GLES2Util::GetChannelsForFormat(internal_format());
     return (need & have) != 0;
   }
 
   Renderbuffer* renderbuffer() const {
     return renderbuffer_.get();
   }
 
@@ skipping 93 matching lines @@
     return texture_ref_->texture()->CanRenderTo();
   }
 
   virtual void DetachFromFramebuffer(Framebuffer* framebuffer)
       const OVERRIDE {
     texture_ref_->texture()->DetachFromFramebuffer();
     framebuffer->OnTextureRefDetached(texture_ref_.get());
   }
 
   virtual bool ValidForAttachmentType(
-      GLenum attachment_type, uint32 max_color_attachments) OVERRIDE {
+      GLenum attachment_type, uint32 max_color_attachments,
+      const FeatureInfo* feature_info) OVERRIDE {
     GLenum type = 0;
     GLenum internal_format = 0;
     if (!texture_ref_->texture()->GetLevelType(
         target_, level_, &type, &internal_format)) {
       return false;
     }
     uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
     uint32 have = GLES2Util::GetChannelsForFormat(internal_format);
 
     // 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 ((internal_format == GL_RGBA32F &&
+         !feature_info->feature_flags().chromium_color_buffer_float_rgba) ||
+        (internal_format == GL_RGB32F &&
+         !feature_info->feature_flags().chromium_color_buffer_float_rgb) ||
+        (type == GL_FLOAT &&
+         internal_format != GL_RGBA32F && internal_format != GL_RGB32F)) {
+      return false;

[Ken Russell (switch to Gerrit), 2014/02/11 00:37:23]

I'm pretty sure this is going to break ANGLE's ability to render to
floating-point textures, since it currently advertises itself as an ES2
implementation but "happens" (deliberately, and in a way that violates specs,
sorry about that) to support rendering to GL_FLOAT/GL_RGBA textures.

Can you confirm this?

Can you think of a way to relax these checks slightly to avoid breaking FP
texture rendering on Windows? In other words, if
GL_CHROMIUM_color_buffer_float_rgb / GL_CHROMIUM_color_buffer_float_rgba are
advertised, then be strict about using a sized internal format when rendering to
FP textures?

[oetuaho-nv, 2014/02/11 12:42:16]

Right, I should have realized that ANGLE doesn't follow GL specs in any way as
it comes to rendering to float textures. I can change the patch so that when
is_angle in FeatureInfo is true, the unsized internalformats are still accepted
here. To fix this better, support for the sized internalformats could be added
to ANGLE and it could expose an ANGLE_color_buffer_float extension, but I won't
have time for implementing that.

+    }
     return (need & have) != 0;
   }
 
   virtual void AddToSignature(
       TextureManager* texture_manager, std::string* signature) const OVERRIDE {
     DCHECK(signature);
     texture_manager->AddToSignature(
         texture_ref_.get(), target_, level_, signature);
   }
 
@@ skipping 153 matching lines @@
 
 GLenum Framebuffer::GetColorAttachmentTextureType() const {
   AttachmentMap::const_iterator it = attachments_.find(GL_COLOR_ATTACHMENT0);
   if (it == attachments_.end()) {
     return 0;
   }
   const Attachment* attachment = it->second.get();
   return attachment->texture_type();
 }
 
-GLenum Framebuffer::IsPossiblyComplete() const {
+GLenum Framebuffer::IsPossiblyComplete(const FeatureInfo* feature_info) const {
   if (attachments_.empty()) {
     return GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
   }
 
   GLsizei width = -1;
   GLsizei height = -1;
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     GLenum attachment_type = it->first;
     Attachment* attachment = it->second.get();
     if (!attachment->ValidForAttachmentType(attachment_type,
-                                            manager_->max_color_attachments_)) {
+                                            manager_->max_color_attachments_,
+                                            feature_info)) {
       return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
     }
     if (width < 0) {
       width = attachment->width();
       height = attachment->height();
       if (width == 0 || height == 0) {
         return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
       }
     } else {
       if (attachment->width() != width || attachment->height() != height) {
@@ skipping 227 matching lines @@
        ++it) {
     TextureDetachObserver* observer = *it;
     observer->OnTextureRefDetachedFromFramebuffer(texture);
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu