WebGL 2: add read/write framebuffer binding points to related APIs

Source/core/html/canvas/WebGLFramebuffer.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 36 matching lines @@
         WebGLRenderbufferAttachment() { }
 
         virtual GLsizei width() const override;
         virtual GLsizei height() const override;
         virtual GLenum format() const override;
         virtual GLenum type() const override;
         virtual WebGLSharedObject* object() const override;
         virtual bool isSharedObject(WebGLSharedObject*) const override;
         virtual bool valid() const override;
         virtual void onDetached(WebGraphicsContext3D*) override;
-        virtual void attach(WebGraphicsContext3D*, GLenum attachment) override;
-        virtual void unattach(WebGraphicsContext3D*, GLenum attachment) override;
+        virtual void attach(WebGraphicsContext3D*, GLenum target, GLenum attachment) override;
+        virtual void unattach(WebGraphicsContext3D*, GLenum target, GLenum attachment) override;
 
         RefPtrWillBeMember<WebGLRenderbuffer> m_renderbuffer;
     };
 
     PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> WebGLRenderbufferAttachment::create(WebGLRenderbuffer* renderbuffer)
     {
         return adoptRefWillBeNoop(new WebGLRenderbufferAttachment(renderbuffer));
     }
 
     DEFINE_TRACE(WebGLRenderbufferAttachment)
@@ skipping 41 matching lines @@
     bool WebGLRenderbufferAttachment::valid() const
     {
         return m_renderbuffer->object();
     }
 
     void WebGLRenderbufferAttachment::onDetached(WebGraphicsContext3D* context)
     {
         m_renderbuffer->onDetached(context);
     }
 
-    void WebGLRenderbufferAttachment::attach(WebGraphicsContext3D* context, GLenum attachment)
+    void WebGLRenderbufferAttachment::attach(WebGraphicsContext3D* context, GLenum target, GLenum attachment)
     {
         Platform3DObject object = objectOrZero(m_renderbuffer.get());
         if (attachment == GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL && m_renderbuffer->emulatedStencilBuffer()) {
-            context->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, object);
-            context->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, objectOrZero(m_renderbuffer->emulatedStencilBuffer()));
+            context->framebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, object);
+            context->framebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, objectOrZero(m_renderbuffer->emulatedStencilBuffer()));
         } else {
-            context->framebufferRenderbuffer(GL_FRAMEBUFFER, attachment, GL_RENDERBUFFER, object);
+            context->framebufferRenderbuffer(target, attachment, GL_RENDERBUFFER, object);
         }
     }
 
-    void WebGLRenderbufferAttachment::unattach(WebGraphicsContext3D* context, GLenum attachment)
+    void WebGLRenderbufferAttachment::unattach(WebGraphicsContext3D* context, GLenum target, GLenum attachment)
     {
         if (attachment == GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL) {
-            context->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
-            context->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
+            context->framebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
+            context->framebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
         } else {
-            context->framebufferRenderbuffer(GL_FRAMEBUFFER, attachment, GL_RENDERBUFFER, 0);
+            context->framebufferRenderbuffer(target, attachment, GL_RENDERBUFFER, 0);
         }
     }
 
     GLenum WebGLRenderbufferAttachment::type() const
     {
         notImplemented();
         return 0;
     }
 
     class WebGLTextureAttachment final : public WebGLFramebuffer::WebGLAttachment {
     public:
         static PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> create(WebGLTexture*, GLenum target, GLint level);
 
         DECLARE_VIRTUAL_TRACE();
 
     private:
         WebGLTextureAttachment(WebGLTexture*, GLenum target, GLint level);
         WebGLTextureAttachment() { }
 
         virtual GLsizei width() const override;
         virtual GLsizei height() const override;
         virtual GLenum format() const override;
         virtual GLenum type() const override;
         virtual WebGLSharedObject* object() const override;
         virtual bool isSharedObject(WebGLSharedObject*) const override;
         virtual bool valid() const override;
         virtual void onDetached(WebGraphicsContext3D*) override;
-        virtual void attach(WebGraphicsContext3D*, GLenum attachment) override;
-        virtual void unattach(WebGraphicsContext3D*, GLenum attachment) override;
+        virtual void attach(WebGraphicsContext3D*, GLenum target, GLenum attachment) override;
+        virtual void unattach(WebGraphicsContext3D*, GLenum target, GLenum attachment) override;
 
         RefPtrWillBeMember<WebGLTexture> m_texture;
         GLenum m_target;
         GLint m_level;
     };
 
     PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> WebGLTextureAttachment::create(WebGLTexture* texture, GLenum target, GLint level)
     {
         return adoptRefWillBeNoop(new WebGLTextureAttachment(texture, target, level));
     }
@@ skipping 39 matching lines @@
     bool WebGLTextureAttachment::valid() const
     {
         return m_texture->object();
     }
 
     void WebGLTextureAttachment::onDetached(WebGraphicsContext3D* context)
     {
         m_texture->onDetached(context);
     }
 
-    void WebGLTextureAttachment::attach(WebGraphicsContext3D* context, GLenum attachment)
+    void WebGLTextureAttachment::attach(WebGraphicsContext3D* context, GLenum target, GLenum attachment)
     {
         Platform3DObject object = objectOrZero(m_texture.get());
-        context->framebufferTexture2D(GL_FRAMEBUFFER, attachment, m_target, object, m_level);
+        context->framebufferTexture2D(target, attachment, m_target, object, m_level);
     }
 
-    void WebGLTextureAttachment::unattach(WebGraphicsContext3D* context, GLenum attachment)
+    void WebGLTextureAttachment::unattach(WebGraphicsContext3D* context, GLenum target, GLenum attachment)
     {
         if (attachment == GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL) {
-            context->framebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_target, 0, m_level);
-            context->framebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, m_target, 0, m_level);
+            context->framebufferTexture2D(target, GL_DEPTH_ATTACHMENT, m_target, 0, m_level);
+            context->framebufferTexture2D(target, GL_STENCIL_ATTACHMENT, m_target, 0, m_level);
         } else {
-            context->framebufferTexture2D(GL_FRAMEBUFFER, attachment, m_target, 0, m_level);
+            context->framebufferTexture2D(target, attachment, m_target, 0, m_level);
         }
     }
 
     GLenum WebGLTextureAttachment::type() const
     {
         return m_texture->getType(m_target, m_level);
     }
 
     bool isColorRenderable(GLenum internalformat)
     {
@@ skipping 36 matching lines @@
     // is for the benefit of Oilpan, where the framebuffer object
     // isn't detached when it and the WebGLRenderingContextBase object
     // it is registered with are both finalized. Without Oilpan, the
     // object will have been detached.
     //
     // To keep the code regular, the trivial detach()ment is always
     // performed.
     detachAndDeleteObject();
 }
 
-void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GLenum attachment, GLenum texTarget, WebGLTexture* texture, GLint level)
+void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GLenum target, GLenum attachment, GLenum texTarget, WebGLTexture* texture, GLint level)
 {
     ASSERT(isBound());
-    removeAttachmentFromBoundFramebuffer(attachment);
+    removeAttachmentFromBoundFramebuffer(attachment, target);
     if (!m_object)
         return;
     if (texture && texture->object()) {
-        m_attachments.add(attachment, WebGLTextureAttachment::create(texture, texTarget, level));
+        if (target == GL_READ_FRAMEBUFFER)
+            m_readAttachments.add(attachment, WebGLTextureAttachment::create(texture, texTarget, level));
+        else
+            m_attachments.add(attachment, WebGLTextureAttachment::create(texture, texTarget, level));
         drawBuffersIfNecessary(false);
         texture->onAttached();
     }
 }
 
-void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GLenum attachment, WebGLRenderbuffer* renderbuffer)
+void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GLenum target, GLenum attachment, WebGLRenderbuffer* renderbuffer)
 {
     ASSERT(isBound());
-    removeAttachmentFromBoundFramebuffer(attachment);
+    removeAttachmentFromBoundFramebuffer(attachment, target);
     if (!m_object)
         return;
     if (renderbuffer && renderbuffer->object()) {
-        m_attachments.add(attachment, WebGLRenderbufferAttachment::create(renderbuffer));
+        if (target == GL_READ_FRAMEBUFFER)
+            m_readAttachments.add(attachment, WebGLRenderbufferAttachment::create(renderbuffer));
+        else
+            m_attachments.add(attachment, WebGLRenderbufferAttachment::create(renderbuffer));
         drawBuffersIfNecessary(false);
         renderbuffer->onAttached();
     }
 }
 
-void WebGLFramebuffer::attach(GLenum attachment, GLenum attachmentPoint)
+void WebGLFramebuffer::attach(GLenum target, GLenum attachment, GLenum attachmentPoint)
 {
     ASSERT(isBound());
-    WebGLAttachment* attachmentObject = getAttachment(attachment);
+    WebGLAttachment* attachmentObject = getAttachment(attachment, target);
     if (attachmentObject)
-        attachmentObject->attach(context()->webContext(), attachmentPoint);
+        attachmentObject->attach(context()->webContext(), target, attachmentPoint);
 }
 
 WebGLSharedObject* WebGLFramebuffer::getAttachmentObject(GLenum attachment) const
 {
     if (!m_object)
         return nullptr;
     WebGLAttachment* attachmentObject = getAttachment(attachment);
     return attachmentObject ? attachmentObject->object() : nullptr;
 }
 
@@ skipping 77 matching lines @@
         return false;
     }
 
     if (!attachedObject->width() || !attachedObject->height()) {
         *reason = "attachment has a 0 dimension";
         return false;
     }
     return true;
 }
 
-WebGLFramebuffer::WebGLAttachment* WebGLFramebuffer::getAttachment(GLenum attachment) const
+WebGLFramebuffer::WebGLAttachment* WebGLFramebuffer::getAttachment(GLenum attachment, GLenum target) const
 {
+    if (target == GL_READ_FRAMEBUFFER) {
+        const AttachmentMap::const_iterator it = m_readAttachments.find(attachment);
+        return (it != m_readAttachments.end()) ? it->value.get() : 0;
+    }
     const AttachmentMap::const_iterator it = m_attachments.find(attachment);
     return (it != m_attachments.end()) ? it->value.get() : 0;
 }
 
-void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GLenum attachment)
+void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GLenum attachment, GLenum target)
 {
     ASSERT(isBound());
     if (!m_object)
         return;
 
-    WebGLAttachment* attachmentObject = getAttachment(attachment);
+    WebGLAttachment* attachmentObject = getAttachment(attachment, target);
     if (attachmentObject) {
         attachmentObject->onDetached(context()->webContext());
-        m_attachments.remove(attachment);
+        if (target == GL_READ_FRAMEBUFFER)
+            m_readAttachments.remove(attachment);
+        else
+            m_attachments.remove(attachment);
         drawBuffersIfNecessary(false);
         switch (attachment) {
         case GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL:
-            attach(GL_DEPTH_ATTACHMENT, GL_DEPTH_ATTACHMENT);
-            attach(GL_STENCIL_ATTACHMENT, GL_STENCIL_ATTACHMENT);
+            attach(target, GL_DEPTH_ATTACHMENT, GL_DEPTH_ATTACHMENT);
+            attach(target, GL_STENCIL_ATTACHMENT, GL_STENCIL_ATTACHMENT);
             break;
         case GL_DEPTH_ATTACHMENT:
-            attach(GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL, GL_DEPTH_ATTACHMENT);
+            attach(target, GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL, GL_DEPTH_ATTACHMENT);
             break;
         case GL_STENCIL_ATTACHMENT:
-            attach(GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL, GL_STENCIL_ATTACHMENT);
+            attach(target, GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL, GL_STENCIL_ATTACHMENT);
             break;
         }
     }
 }
 
-void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(WebGLSharedObject* attachment)
+void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(WebGLSharedObject* attachment, GLenum target)
 {
     ASSERT(isBound());
     if (!m_object)
         return;
     if (!attachment)
         return;
 
     bool checkMore = true;
     while (checkMore) {
         checkMore = false;
-        for (const auto& it : m_attachments) {
+        for (const auto& it : (target == GL_READ_FRAMEBUFFER ? m_readAttachments : m_attachments)) {
             WebGLAttachment* attachmentObject = it.value.get();
             if (attachmentObject->isSharedObject(attachment)) {
                 GLenum attachmentType = it.key;
-                attachmentObject->unattach(context()->webContext(), attachmentType);
-                removeAttachmentFromBoundFramebuffer(attachmentType);
+                attachmentObject->unattach(context()->webContext(), target, attachmentType);
+                removeAttachmentFromBoundFramebuffer(attachmentType, target);
                 checkMore = true;
                 break;
             }
         }
     }
 }
 
 GLenum WebGLFramebuffer::colorBufferFormat() const
 {
     if (!m_object)
         return 0;
     WebGLAttachment* attachment = getAttachment(GL_COLOR_ATTACHMENT0);
     if (!attachment)
         return 0;
     return attachment->format();
 }
 
-GLenum WebGLFramebuffer::checkStatus(const char** reason) const
+GLenum WebGLFramebuffer::checkStatus(const char** reason, GLenum target) const
 {
     unsigned count = 0;
     GLsizei width = 0, height = 0;
     bool haveDepth = false;
     bool haveStencil = false;
     bool haveDepthStencil = false;
-    for (const auto& it : m_attachments) {
+    for (const auto& it : (target == GL_READ_FRAMEBUFFER ? m_readAttachments : m_attachments)) {
         WebGLAttachment* attachment = it.value.get();
         if (!isAttachmentComplete(attachment, it.key, reason))
             return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
         if (!attachment->valid()) {
             *reason = "attachment is not valid";
             return GL_FRAMEBUFFER_UNSUPPORTED;
         }
         if (!attachment->format()) {
             *reason = "attachment is an unsupported format";
             return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
@@ skipping 29 matching lines @@
         return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
     }
     // WebGL specific: no conflicting DEPTH/STENCIL/DEPTH_STENCIL attachments.
     if ((haveDepthStencil && (haveDepth || haveStencil)) || (haveDepth && haveStencil)) {
         *reason = "conflicting DEPTH/STENCIL/DEPTH_STENCIL attachments";
         return GL_FRAMEBUFFER_UNSUPPORTED;
     }
     return GL_FRAMEBUFFER_COMPLETE;
 }
 
-bool WebGLFramebuffer::onAccess(WebGraphicsContext3D* context3d, const char** reason)
+bool WebGLFramebuffer::onAccess(WebGraphicsContext3D* context3d, const char** reason, GLenum target)
 {
-    if (checkStatus(reason) != GL_FRAMEBUFFER_COMPLETE)
+    if (checkStatus(reason, target) != GL_FRAMEBUFFER_COMPLETE)
         return false;
     return true;
 }
 
 bool WebGLFramebuffer::hasStencilBuffer() const
 {
     WebGLAttachment* attachment = getAttachment(GL_STENCIL_ATTACHMENT);
     if (!attachment)
         attachment = getAttachment(GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL);
     return attachment && attachment->valid();
 }
 
 void WebGLFramebuffer::deleteObjectImpl(WebGraphicsContext3D* context3d)
 {
 #if !ENABLE(OILPAN)
     // With Oilpan, both the AttachmentMap and its WebGLAttachment objects are
     // GCed objects and cannot be accessed, as they may have been finalized
     // already during the same GC sweep.
     //
     // The WebGLAttachment-derived classes instead handle detachment
     // on their own when finalizing, so the explicit notification is
     // not needed.
     for (const auto& attachment : m_attachments)
         attachment.value->onDetached(context3d);
+    for (const auto& attachment : m_readAttachments)
+        attachment.value->onDetached(context3d);
 #endif
 
     context3d->deleteFramebuffer(m_object);
     m_object = 0;
 }
 
 bool WebGLFramebuffer::isBound() const
 {
     return (context()->m_framebufferBinding.get() == this);
 }
@@ skipping 40 matching lines @@
         return m_drawBuffers[index];
     if (drawBuffer == GL_DRAW_BUFFER0_EXT)
         return GL_COLOR_ATTACHMENT0;
     return GL_NONE;
 }
 
 DEFINE_TRACE(WebGLFramebuffer)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_attachments);
+    visitor->trace(m_readAttachments);
 #endif
     WebGLContextObject::trace(visitor);
 }
 
 }