Set attachment for bound framebuffer in FramebufferTextureLayer

third_party/WebKit/Source/modules/webgl/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 128 matching lines @@
 }
 
 GLenum WebGLRenderbufferAttachment::type() const
 {
     notImplemented();
     return 0;
 }
 
 class WebGLTextureAttachment final : public WebGLFramebuffer::WebGLAttachment {
 public:
-    static WebGLFramebuffer::WebGLAttachment* create(WebGLTexture*, GLenum target, GLint level);
+    static WebGLFramebuffer::WebGLAttachment* create(WebGLTexture*, GLenum target, GLint level, GLint layer);
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
-    WebGLTextureAttachment(WebGLTexture*, GLenum target, GLint level);
+    WebGLTextureAttachment(WebGLTexture*, GLenum target, GLint level, GLint layer);
     WebGLTextureAttachment() { }
 
     GLsizei width() const override;
     GLsizei height() const override;
     GLenum format() const override;
     GLenum type() const override;
     WebGLSharedObject* object() const override;
     bool isSharedObject(WebGLSharedObject*) const override;
     bool valid() const override;
     void onDetached(WebGraphicsContext3D*) override;
     void attach(WebGraphicsContext3D*, GLenum target, GLenum attachment) override;
     void unattach(WebGraphicsContext3D*, GLenum target, GLenum attachment) override;
 
     Member<WebGLTexture> m_texture;
     GLenum m_target;
     GLint m_level;
+    GLint m_layer;
 };
 
-WebGLFramebuffer::WebGLAttachment* WebGLTextureAttachment::create(WebGLTexture* texture, GLenum target, GLint level)
+WebGLFramebuffer::WebGLAttachment* WebGLTextureAttachment::create(WebGLTexture* texture, GLenum target, GLint level, GLint layer)
 {
-    return new WebGLTextureAttachment(texture, target, level);
+    return new WebGLTextureAttachment(texture, target, level, layer);
 }
 
 DEFINE_TRACE(WebGLTextureAttachment)
 {
     visitor->trace(m_texture);
     WebGLFramebuffer::WebGLAttachment::trace(visitor);
 }
 
-WebGLTextureAttachment::WebGLTextureAttachment(WebGLTexture* texture, GLenum target, GLint level)
+WebGLTextureAttachment::WebGLTextureAttachment(WebGLTexture* texture, GLenum target, GLint level, GLint layer)
     : m_texture(texture)
     , m_target(target)
     , m_level(level)
+    , m_layer(layer)
 {
 }
 
 GLsizei WebGLTextureAttachment::width() const
 {
     return m_texture->getWidth(m_target, m_level);
 }
 
 GLsizei WebGLTextureAttachment::height() const
 {
@@ skipping 21 matching lines @@
 }
 
 void WebGLTextureAttachment::onDetached(WebGraphicsContext3D* context)
 {
     m_texture->onDetached(context);
 }
 
 void WebGLTextureAttachment::attach(WebGraphicsContext3D* context, GLenum target, GLenum attachment)
 {
     Platform3DObject object = objectOrZero(m_texture.get());
-    context->framebufferTexture2D(target, attachment, m_target, object, m_level);
+    if (target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY) {
+        context->framebufferTextureLayer(target, attachment, object, m_level, m_layer);
+    } else {
+        context->framebufferTexture2D(target, attachment, m_target, object, m_level);
+    }
 }
 
 void WebGLTextureAttachment::unattach(WebGraphicsContext3D* context, GLenum target, GLenum attachment)
 {
-    if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
-        context->framebufferTexture2D(target, GL_DEPTH_ATTACHMENT, m_target, 0, m_level);
-        context->framebufferTexture2D(target, GL_STENCIL_ATTACHMENT, m_target, 0, m_level);
+    // GL_DEPTH_STENCIL_ATTACHMENT attachment is valid in ES3.
+    if (m_target == GL_TEXTURE_3D || m_target == GL_TEXTURE_2D_ARRAY) {

[Ken Russell (switch to Gerrit), 2015/10/28 23:48:32]

This changed to test "m_target" instead of "target", since "target" will be
GL_FRAMEBUFFER (from e.g. WebGLRenderingContextBase::framebufferTexture2D ->
WebGLFramebuffer::setAttachmentForBoundFramebuffer ->
WebGLAttachment::unattach). WebGLTextureAttachment::attach, above, wasn't
changed; why not?

I have a feeling that the WebGLAttachment::attach and unattach methods are only
used for depth/stencil emulation in WebGL 1.0. Note that the *only* caller of
WebGLAttachment::attach is
WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GLenum target, GLenum
attachment) and it only passes the depth/stencil arguments. I still have doubts
about the correctness of and need for these WebGLAttachment::attach and unattach
methods, and think it may be worth a TODO to rethink them.

[qiankun, 2015/10/29 01:03:26]

Done.
I will check the attach path. But the unattach is used when deleting texture.
#0  blink::(anonymous namespace)::WebGLTextureAttachment::unattach
(this=0x2c93eae81ad0, context=0x2228adcb43a0, target=36160, attachment=36064) at
../../third_
party/WebKit/Source/modules/webgl/WebGLFramebuffer.cpp:241
#1  0x00007f7d15c7b779 in
blink::WebGLFramebuffer::removeAttachmentFromBoundFramebuffer
(this=0x17eaa7b62d98, target=36160, attachment=0x17eaa7b62d28) at ../../
third_party/WebKit/Source/modules/webgl/WebGLFramebuffer.cpp:496
#2  0x00007f7d15c9a7a2 in blink::WebGLRenderingContextBase::deleteTexture
(this=0x17d59f83c010, texture=0x17eaa7b62d28) at
../../third_party/WebKit/Source/modul
es/webgl/WebGLRenderingContextBase.cpp:2183

+        context->framebufferTextureLayer(target, attachment, 0, m_level, m_layer);
     } else {
-        context->framebufferTexture2D(target, attachment, m_target, 0, m_level);
+        if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+            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(target, attachment, m_target, 0, m_level);
+        }
     }
 }
 
 GLenum WebGLTextureAttachment::type() const
 {
     return m_texture->getType(m_target, m_level);
 }
 
 bool isColorRenderable(GLenum internalformat)
 {
@@ skipping 94 matching lines @@
 {
     // Attachments in |m_attachments| will be deleted from other
     // places, and we must not touch that map in deleteObjectImpl once
     // the destructor has been entered.
     m_destructionInProgress = true;
 
     // See the comment in WebGLObject::detachAndDeleteObject().
     detachAndDeleteObject();
 }
 
-void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GLenum target, GLenum attachment, GLenum texTarget, WebGLTexture* texture, GLint level)
+void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GLenum target, GLenum attachment, GLenum texTarget, WebGLTexture* texture, GLint level, GLint layer)
 {
     ASSERT(isBound(target));
     removeAttachmentFromBoundFramebuffer(target, attachment);
     if (!m_object)
         return;
     if (texture && texture->object()) {
-        m_attachments.add(attachment, WebGLTextureAttachment::create(texture, texTarget, level));
+        m_attachments.add(attachment, WebGLTextureAttachment::create(texture, texTarget, level, 0));
         drawBuffersIfNecessary(false);
         texture->onAttached();
     }
 }
 
 void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GLenum target, GLenum attachment, WebGLRenderbuffer* renderbuffer)
 {
     ASSERT(isBound(target));
     removeAttachmentFromBoundFramebuffer(target, attachment);
     if (!m_object)
@@ skipping 289 matching lines @@
     return true;
 }
 
 DEFINE_TRACE(WebGLFramebuffer)
 {
     visitor->trace(m_attachments);
     WebGLContextObject::trace(visitor);
 }
 
 }