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 == GL_DEPTH_STENCIL_ATTACHMENT && 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 == GL_DEPTH_STENCIL_ATTACHMENT) {
-            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 == GL_DEPTH_STENCIL_ATTACHMENT) {
-            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 39 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);
+    ASSERT(isBound(target));
+    removeAttachmentFromBoundFramebuffer(target, attachment);
     if (!m_object)
         return;
     if (texture && texture->object()) {
         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);
+    ASSERT(isBound(target));
+    removeAttachmentFromBoundFramebuffer(target, attachment);
     if (!m_object)
         return;
     if (renderbuffer && renderbuffer->object()) {
         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());
+    ASSERT(isBound(target));
     WebGLAttachment* attachmentObject = getAttachment(attachment);
     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 83 matching lines @@
     }
     return true;
 }
 
 WebGLFramebuffer::WebGLAttachment* WebGLFramebuffer::getAttachment(GLenum attachment) const
 {
     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 target, GLenum attachment)
 {
-    ASSERT(isBound());
+    ASSERT(isBound(target));
     if (!m_object)
         return;
 
     WebGLAttachment* attachmentObject = getAttachment(attachment);
     if (attachmentObject) {
         attachmentObject->onDetached(context()->webContext());
         m_attachments.remove(attachment);
         drawBuffersIfNecessary(false);
         switch (attachment) {
         case GL_DEPTH_STENCIL_ATTACHMENT:
-            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(GL_DEPTH_STENCIL_ATTACHMENT, GL_DEPTH_ATTACHMENT);
+            attach(target, GL_DEPTH_STENCIL_ATTACHMENT, GL_DEPTH_ATTACHMENT);
             break;
         case GL_STENCIL_ATTACHMENT:
-            attach(GL_DEPTH_STENCIL_ATTACHMENT, GL_STENCIL_ATTACHMENT);
+            attach(target, GL_DEPTH_STENCIL_ATTACHMENT, GL_STENCIL_ATTACHMENT);
             break;
         }
     }
 }
 
-void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(WebGLSharedObject* attachment)
+void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GLenum target, WebGLSharedObject* attachment)
 {
-    ASSERT(isBound());
+    ASSERT(isBound(target));
     if (!m_object)
         return;
     if (!attachment)
         return;
 
     bool checkMore = true;
     while (checkMore) {
         checkMore = false;
         for (const auto& it : 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(target, attachmentType);
                 checkMore = true;
                 break;
             }
         }
     }
 }
 
 GLenum WebGLFramebuffer::colorBufferFormat() const
 {
     if (!m_object)
@@ skipping 87 matching lines @@
     // on their own when finalizing, so the explicit notification is
     // not needed.
     for (const auto& attachment : m_attachments)
         attachment.value->onDetached(context3d);
 #endif
 
     context3d->deleteFramebuffer(m_object);
     m_object = 0;
 }
 
-bool WebGLFramebuffer::isBound() const
+bool WebGLFramebuffer::isBound(GLenum target) const
 {
-    return (context()->m_framebufferBinding.get() == this);
+    return (context()->getFramebufferBinding(target) == this);
 }
 
 void WebGLFramebuffer::drawBuffers(const Vector<GLenum>& bufs)
 {
     m_drawBuffers = bufs;
     m_filteredDrawBuffers.resize(m_drawBuffers.size());
     for (size_t i = 0; i < m_filteredDrawBuffers.size(); ++i)
         m_filteredDrawBuffers[i] = GL_NONE;
     drawBuffersIfNecessary(true);
 }
@@ skipping 36 matching lines @@
 
 DEFINE_TRACE(WebGLFramebuffer)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_attachments);
 #endif
     WebGLContextObject::trace(visitor);
 }
 
 }