daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1 | // |
Geoff Lang | cec3590 | 2014-04-16 10:52:36 -0400 | [diff] [blame] | 2 | // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved. |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 3 | // Use of this source code is governed by a BSD-style license that can be |
| 4 | // found in the LICENSE file. |
| 5 | // |
| 6 | |
| 7 | // Framebuffer.cpp: Implements the gl::Framebuffer class. Implements GL framebuffer |
| 8 | // objects and related functionality. [OpenGL ES 2.0.24] section 4.4 page 105. |
| 9 | |
daniel@transgaming.com | bbf56f7 | 2010-04-20 18:52:13 +0000 | [diff] [blame] | 10 | #include "libGLESv2/Framebuffer.h" |
daniel@transgaming.com | bbf56f7 | 2010-04-20 18:52:13 +0000 | [diff] [blame] | 11 | #include "libGLESv2/main.h" |
shannonwoods@chromium.org | f6fb959 | 2013-05-30 00:09:40 +0000 | [diff] [blame] | 12 | #include "libGLESv2/formatutils.h" |
shannon.woods@transgaming.com | 486d9e9 | 2013-02-28 23:15:41 +0000 | [diff] [blame] | 13 | #include "libGLESv2/Texture.h" |
| 14 | #include "libGLESv2/Context.h" |
shannon.woods@transgaming.com | 486d9e9 | 2013-02-28 23:15:41 +0000 | [diff] [blame] | 15 | #include "libGLESv2/Renderbuffer.h" |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 16 | #include "libGLESv2/FramebufferAttachment.h" |
Geoff Lang | 0b7eef7 | 2014-06-12 14:10:47 -0400 | [diff] [blame] | 17 | #include "libGLESv2/renderer/Renderer.h" |
Jamie Madill | 400a441 | 2014-08-29 15:46:45 -0400 | [diff] [blame] | 18 | #include "libGLESv2/renderer/RenderTarget.h" |
Jamie Madill | 9f0b42a | 2014-09-12 10:25:27 -0400 | [diff] [blame] | 19 | #include "libGLESv2/renderer/d3d/TextureD3D.h" |
Geoff Lang | 0b7eef7 | 2014-06-12 14:10:47 -0400 | [diff] [blame] | 20 | |
| 21 | #include "common/utilities.h" |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 22 | |
Jamie Madill | 9f0b42a | 2014-09-12 10:25:27 -0400 | [diff] [blame] | 23 | namespace rx |
| 24 | { |
| 25 | RenderTarget *GetAttachmentRenderTarget(gl::FramebufferAttachment *attachment) |
| 26 | { |
| 27 | if (attachment->isTexture()) |
| 28 | { |
| 29 | gl::Texture *texture = attachment->getTexture(); |
| 30 | ASSERT(texture); |
| 31 | TextureD3D *textureD3D = TextureD3D::makeTextureD3D(texture->getImplementation()); |
Jamie Madill | ac7579c | 2014-09-17 16:59:33 -0400 | [diff] [blame] | 32 | const gl::ImageIndex *index = attachment->getTextureImageIndex(); |
| 33 | ASSERT(index); |
| 34 | return textureD3D->getRenderTarget(*index); |
Jamie Madill | 9f0b42a | 2014-09-12 10:25:27 -0400 | [diff] [blame] | 35 | } |
| 36 | |
| 37 | gl::Renderbuffer *renderbuffer = attachment->getRenderbuffer(); |
| 38 | ASSERT(renderbuffer); |
| 39 | |
| 40 | // TODO: cast to RenderbufferD3D |
| 41 | return renderbuffer->getStorage()->getRenderTarget(); |
| 42 | } |
| 43 | |
Jamie Madill | 612e2e4 | 2014-09-12 13:26:55 -0400 | [diff] [blame] | 44 | // Note: RenderTarget serials should ideally be in the RenderTargets themselves. |
| 45 | unsigned int GetAttachmentSerial(gl::FramebufferAttachment *attachment) |
| 46 | { |
| 47 | if (attachment->isTexture()) |
| 48 | { |
| 49 | gl::Texture *texture = attachment->getTexture(); |
| 50 | ASSERT(texture); |
| 51 | TextureD3D *textureD3D = TextureD3D::makeTextureD3D(texture->getImplementation()); |
Jamie Madill | ac7579c | 2014-09-17 16:59:33 -0400 | [diff] [blame] | 52 | const gl::ImageIndex *index = attachment->getTextureImageIndex(); |
| 53 | ASSERT(index); |
| 54 | return textureD3D->getRenderTargetSerial(*index); |
Jamie Madill | 612e2e4 | 2014-09-12 13:26:55 -0400 | [diff] [blame] | 55 | } |
| 56 | |
| 57 | gl::Renderbuffer *renderbuffer = attachment->getRenderbuffer(); |
| 58 | ASSERT(renderbuffer); |
| 59 | |
| 60 | // TODO: cast to RenderbufferD3D |
| 61 | return renderbuffer->getStorage()->getSerial(); |
| 62 | } |
| 63 | |
Jamie Madill | 9f0b42a | 2014-09-12 10:25:27 -0400 | [diff] [blame] | 64 | } |
| 65 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 66 | namespace gl |
| 67 | { |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 68 | |
Shannon Woods | aa2ab7d | 2014-06-24 17:51:51 -0400 | [diff] [blame] | 69 | Framebuffer::Framebuffer(rx::Renderer *renderer, GLuint id) |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 70 | : mRenderer(renderer), |
Shannon Woods | aa2ab7d | 2014-06-24 17:51:51 -0400 | [diff] [blame] | 71 | mId(id), |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 72 | mReadBufferState(GL_COLOR_ATTACHMENT0_EXT), |
| 73 | mDepthbuffer(NULL), |
| 74 | mStencilbuffer(NULL) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 75 | { |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 76 | for (unsigned int colorAttachment = 0; colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++) |
| 77 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 78 | mColorbuffers[colorAttachment] = NULL; |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 79 | mDrawBufferStates[colorAttachment] = GL_NONE; |
| 80 | } |
| 81 | mDrawBufferStates[0] = GL_COLOR_ATTACHMENT0_EXT; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | Framebuffer::~Framebuffer() |
| 85 | { |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 86 | for (unsigned int colorAttachment = 0; colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++) |
| 87 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 88 | SafeDelete(mColorbuffers[colorAttachment]); |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 89 | } |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 90 | SafeDelete(mDepthbuffer); |
| 91 | SafeDelete(mStencilbuffer); |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 92 | } |
| 93 | |
Jamie Madill | aef95de | 2014-09-05 10:12:41 -0400 | [diff] [blame] | 94 | FramebufferAttachment *Framebuffer::createAttachment(GLenum binding, GLenum type, GLuint handle, GLint level, GLint layer) const |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 95 | { |
Jamie Madill | 6c7b4ad | 2014-06-16 10:33:59 -0400 | [diff] [blame] | 96 | if (handle == 0) |
| 97 | { |
| 98 | return NULL; |
| 99 | } |
| 100 | |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 101 | gl::Context *context = gl::getContext(); |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 102 | |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 103 | switch (type) |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 104 | { |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 105 | case GL_NONE: |
| 106 | return NULL; |
| 107 | |
| 108 | case GL_RENDERBUFFER: |
Jamie Madill | aef95de | 2014-09-05 10:12:41 -0400 | [diff] [blame] | 109 | return new RenderbufferAttachment(binding, context->getRenderbuffer(handle)); |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 110 | |
| 111 | case GL_TEXTURE_2D: |
| 112 | { |
| 113 | Texture *texture = context->getTexture(handle); |
| 114 | if (texture && texture->getTarget() == GL_TEXTURE_2D) |
| 115 | { |
Jamie Madill | eeb7b0e | 2014-09-03 15:07:20 -0400 | [diff] [blame] | 116 | return new TextureAttachment(binding, texture, ImageIndex::Make2D(level)); |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 117 | } |
| 118 | else |
| 119 | { |
| 120 | return NULL; |
| 121 | } |
| 122 | } |
| 123 | |
| 124 | case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
| 125 | case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
| 126 | case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
| 127 | case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
| 128 | case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
| 129 | case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
| 130 | { |
| 131 | Texture *texture = context->getTexture(handle); |
| 132 | if (texture && texture->getTarget() == GL_TEXTURE_CUBE_MAP) |
| 133 | { |
Jamie Madill | eeb7b0e | 2014-09-03 15:07:20 -0400 | [diff] [blame] | 134 | return new TextureAttachment(binding, texture, ImageIndex::MakeCube(type, level)); |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 135 | } |
| 136 | else |
| 137 | { |
| 138 | return NULL; |
| 139 | } |
| 140 | } |
| 141 | |
| 142 | case GL_TEXTURE_3D: |
| 143 | { |
| 144 | Texture *texture = context->getTexture(handle); |
| 145 | if (texture && texture->getTarget() == GL_TEXTURE_3D) |
| 146 | { |
Jamie Madill | eeb7b0e | 2014-09-03 15:07:20 -0400 | [diff] [blame] | 147 | return new TextureAttachment(binding, texture, ImageIndex::Make3D(level, layer)); |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 148 | } |
| 149 | else |
| 150 | { |
| 151 | return NULL; |
| 152 | } |
| 153 | } |
| 154 | |
| 155 | case GL_TEXTURE_2D_ARRAY: |
| 156 | { |
| 157 | Texture *texture = context->getTexture(handle); |
| 158 | if (texture && texture->getTarget() == GL_TEXTURE_2D_ARRAY) |
| 159 | { |
Jamie Madill | eeb7b0e | 2014-09-03 15:07:20 -0400 | [diff] [blame] | 160 | return new TextureAttachment(binding, texture, ImageIndex::Make2DArray(level, layer)); |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 161 | } |
| 162 | else |
| 163 | { |
| 164 | return NULL; |
| 165 | } |
| 166 | } |
| 167 | |
| 168 | default: |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 169 | UNREACHABLE(); |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 170 | return NULL; |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 171 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 172 | } |
| 173 | |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 174 | void Framebuffer::setColorbuffer(unsigned int colorAttachment, GLenum type, GLuint colorbuffer, GLint level, GLint layer) |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 175 | { |
| 176 | ASSERT(colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS); |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 177 | SafeDelete(mColorbuffers[colorAttachment]); |
Jamie Madill | aef95de | 2014-09-05 10:12:41 -0400 | [diff] [blame] | 178 | GLenum binding = colorAttachment + GL_COLOR_ATTACHMENT0; |
| 179 | mColorbuffers[colorAttachment] = createAttachment(binding, type, colorbuffer, level, layer); |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 180 | } |
| 181 | |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 182 | void Framebuffer::setDepthbuffer(GLenum type, GLuint depthbuffer, GLint level, GLint layer) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 183 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 184 | SafeDelete(mDepthbuffer); |
Jamie Madill | aef95de | 2014-09-05 10:12:41 -0400 | [diff] [blame] | 185 | mDepthbuffer = createAttachment(GL_DEPTH_ATTACHMENT, type, depthbuffer, level, layer); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 186 | } |
| 187 | |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 188 | void Framebuffer::setStencilbuffer(GLenum type, GLuint stencilbuffer, GLint level, GLint layer) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 189 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 190 | SafeDelete(mStencilbuffer); |
Jamie Madill | aef95de | 2014-09-05 10:12:41 -0400 | [diff] [blame] | 191 | mStencilbuffer = createAttachment(GL_STENCIL_ATTACHMENT, type, stencilbuffer, level, layer); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 192 | } |
| 193 | |
Geoff Lang | 309c92a | 2013-07-25 16:23:19 -0400 | [diff] [blame] | 194 | void Framebuffer::setDepthStencilBuffer(GLenum type, GLuint depthStencilBuffer, GLint level, GLint layer) |
Geoff Lang | 55ba29c | 2013-07-11 16:57:53 -0400 | [diff] [blame] | 195 | { |
Jamie Madill | aef95de | 2014-09-05 10:12:41 -0400 | [diff] [blame] | 196 | FramebufferAttachment *attachment = createAttachment(GL_DEPTH_STENCIL_ATTACHMENT, type, depthStencilBuffer, level, layer); |
Jamie Madill | 6c7b4ad | 2014-06-16 10:33:59 -0400 | [diff] [blame] | 197 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 198 | SafeDelete(mDepthbuffer); |
| 199 | SafeDelete(mStencilbuffer); |
| 200 | |
| 201 | // ensure this is a legitimate depth+stencil format |
Geoff Lang | e4a492b | 2014-06-19 14:14:41 -0400 | [diff] [blame] | 202 | if (attachment && attachment->getDepthSize() > 0 && attachment->getStencilSize() > 0) |
Geoff Lang | 55ba29c | 2013-07-11 16:57:53 -0400 | [diff] [blame] | 203 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 204 | mDepthbuffer = attachment; |
Jamie Madill | 28bedaf | 2014-06-26 13:17:22 -0400 | [diff] [blame] | 205 | |
| 206 | // Make a new attachment object to ensure we do not double-delete |
| 207 | // See angle issue 686 |
Jamie Madill | aef95de | 2014-09-05 10:12:41 -0400 | [diff] [blame] | 208 | mStencilbuffer = createAttachment(GL_DEPTH_STENCIL_ATTACHMENT, type, depthStencilBuffer, level, layer); |
Geoff Lang | 55ba29c | 2013-07-11 16:57:53 -0400 | [diff] [blame] | 209 | } |
| 210 | } |
| 211 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 212 | void Framebuffer::detachTexture(GLuint textureId) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 213 | { |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 214 | for (unsigned int colorAttachment = 0; colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 215 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 216 | FramebufferAttachment *attachment = mColorbuffers[colorAttachment]; |
| 217 | |
| 218 | if (attachment && attachment->isTextureWithId(textureId)) |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 219 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 220 | SafeDelete(mColorbuffers[colorAttachment]); |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 221 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 222 | } |
daniel@transgaming.com | fbc0953 | 2010-04-26 15:33:41 +0000 | [diff] [blame] | 223 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 224 | if (mDepthbuffer && mDepthbuffer->isTextureWithId(textureId)) |
daniel@transgaming.com | fbc0953 | 2010-04-26 15:33:41 +0000 | [diff] [blame] | 225 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 226 | SafeDelete(mDepthbuffer); |
daniel@transgaming.com | fbc0953 | 2010-04-26 15:33:41 +0000 | [diff] [blame] | 227 | } |
| 228 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 229 | if (mStencilbuffer && mStencilbuffer->isTextureWithId(textureId)) |
daniel@transgaming.com | fbc0953 | 2010-04-26 15:33:41 +0000 | [diff] [blame] | 230 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 231 | SafeDelete(mStencilbuffer); |
daniel@transgaming.com | fbc0953 | 2010-04-26 15:33:41 +0000 | [diff] [blame] | 232 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 233 | } |
| 234 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 235 | void Framebuffer::detachRenderbuffer(GLuint renderbufferId) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 236 | { |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 237 | for (unsigned int colorAttachment = 0; colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 238 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 239 | FramebufferAttachment *attachment = mColorbuffers[colorAttachment]; |
| 240 | |
| 241 | if (attachment && attachment->isRenderbufferWithId(renderbufferId)) |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 242 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 243 | SafeDelete(mColorbuffers[colorAttachment]); |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 244 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 245 | } |
| 246 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 247 | if (mDepthbuffer && mDepthbuffer->isRenderbufferWithId(renderbufferId)) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 248 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 249 | SafeDelete(mDepthbuffer); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 250 | } |
| 251 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 252 | if (mStencilbuffer && mStencilbuffer->isRenderbufferWithId(renderbufferId)) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 253 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 254 | SafeDelete(mStencilbuffer); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 255 | } |
| 256 | } |
| 257 | |
Jamie Madill | 3c7fa22 | 2014-06-05 13:08:51 -0400 | [diff] [blame] | 258 | FramebufferAttachment *Framebuffer::getColorbuffer(unsigned int colorAttachment) const |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 259 | { |
| 260 | ASSERT(colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS); |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 261 | return mColorbuffers[colorAttachment]; |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 262 | } |
| 263 | |
Jamie Madill | 3c7fa22 | 2014-06-05 13:08:51 -0400 | [diff] [blame] | 264 | FramebufferAttachment *Framebuffer::getDepthbuffer() const |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 265 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 266 | return mDepthbuffer; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 267 | } |
| 268 | |
Jamie Madill | 3c7fa22 | 2014-06-05 13:08:51 -0400 | [diff] [blame] | 269 | FramebufferAttachment *Framebuffer::getStencilbuffer() const |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 270 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 271 | return mStencilbuffer; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 272 | } |
| 273 | |
Jamie Madill | 3c7fa22 | 2014-06-05 13:08:51 -0400 | [diff] [blame] | 274 | FramebufferAttachment *Framebuffer::getDepthStencilBuffer() const |
Geoff Lang | 646559f | 2013-08-15 11:08:15 -0400 | [diff] [blame] | 275 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 276 | return (hasValidDepthStencil() ? mDepthbuffer : NULL); |
Geoff Lang | 646559f | 2013-08-15 11:08:15 -0400 | [diff] [blame] | 277 | } |
| 278 | |
Jamie Madill | 3c7fa22 | 2014-06-05 13:08:51 -0400 | [diff] [blame] | 279 | FramebufferAttachment *Framebuffer::getDepthOrStencilbuffer() const |
daniel@transgaming.com | d2b4702 | 2012-11-28 19:40:10 +0000 | [diff] [blame] | 280 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 281 | FramebufferAttachment *depthstencilbuffer = mDepthbuffer; |
daniel@transgaming.com | d2b4702 | 2012-11-28 19:40:10 +0000 | [diff] [blame] | 282 | |
| 283 | if (!depthstencilbuffer) |
| 284 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 285 | depthstencilbuffer = mStencilbuffer; |
daniel@transgaming.com | d2b4702 | 2012-11-28 19:40:10 +0000 | [diff] [blame] | 286 | } |
| 287 | |
| 288 | return depthstencilbuffer; |
| 289 | } |
| 290 | |
Jamie Madill | 3c7fa22 | 2014-06-05 13:08:51 -0400 | [diff] [blame] | 291 | FramebufferAttachment *Framebuffer::getReadColorbuffer() const |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 292 | { |
| 293 | // Will require more logic if glReadBuffers is supported |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 294 | return mColorbuffers[0]; |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 295 | } |
| 296 | |
shannon.woods%transgaming.com@gtempaccount.com | f6863e0 | 2013-04-13 03:34:00 +0000 | [diff] [blame] | 297 | GLenum Framebuffer::getReadColorbufferType() const |
| 298 | { |
| 299 | // Will require more logic if glReadBuffers is supported |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 300 | return (mColorbuffers[0] ? mColorbuffers[0]->type() : GL_NONE); |
shannon.woods%transgaming.com@gtempaccount.com | f6863e0 | 2013-04-13 03:34:00 +0000 | [diff] [blame] | 301 | } |
| 302 | |
Jamie Madill | 3c7fa22 | 2014-06-05 13:08:51 -0400 | [diff] [blame] | 303 | FramebufferAttachment *Framebuffer::getFirstColorbuffer() const |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 304 | { |
| 305 | for (unsigned int colorAttachment = 0; colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++) |
| 306 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 307 | if (mColorbuffers[colorAttachment]) |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 308 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 309 | return mColorbuffers[colorAttachment]; |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 310 | } |
| 311 | } |
| 312 | |
| 313 | return NULL; |
| 314 | } |
| 315 | |
Jamie Madill | e92a354 | 2014-07-03 10:38:58 -0400 | [diff] [blame] | 316 | FramebufferAttachment *Framebuffer::getAttachment(GLenum attachment) const |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 317 | { |
Jamie Madill | e92a354 | 2014-07-03 10:38:58 -0400 | [diff] [blame] | 318 | if (attachment >= GL_COLOR_ATTACHMENT0 && attachment <= GL_COLOR_ATTACHMENT15) |
| 319 | { |
| 320 | return getColorbuffer(attachment - GL_COLOR_ATTACHMENT0); |
| 321 | } |
| 322 | else |
| 323 | { |
| 324 | switch (attachment) |
| 325 | { |
| 326 | case GL_DEPTH_ATTACHMENT: |
| 327 | return getDepthbuffer(); |
| 328 | case GL_STENCIL_ATTACHMENT: |
| 329 | return getStencilbuffer(); |
| 330 | case GL_DEPTH_STENCIL_ATTACHMENT: |
| 331 | return getDepthStencilBuffer(); |
| 332 | default: |
| 333 | UNREACHABLE(); |
| 334 | return NULL; |
| 335 | } |
| 336 | } |
Geoff Lang | 55ba29c | 2013-07-11 16:57:53 -0400 | [diff] [blame] | 337 | } |
| 338 | |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 339 | GLenum Framebuffer::getDrawBufferState(unsigned int colorAttachment) const |
| 340 | { |
| 341 | return mDrawBufferStates[colorAttachment]; |
| 342 | } |
| 343 | |
| 344 | void Framebuffer::setDrawBufferState(unsigned int colorAttachment, GLenum drawBuffer) |
| 345 | { |
| 346 | mDrawBufferStates[colorAttachment] = drawBuffer; |
| 347 | } |
| 348 | |
shannon.woods%transgaming.com@gtempaccount.com | dae2409 | 2013-04-13 03:31:31 +0000 | [diff] [blame] | 349 | bool Framebuffer::isEnabledColorAttachment(unsigned int colorAttachment) const |
| 350 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 351 | return (mColorbuffers[colorAttachment] && mDrawBufferStates[colorAttachment] != GL_NONE); |
shannon.woods%transgaming.com@gtempaccount.com | dae2409 | 2013-04-13 03:31:31 +0000 | [diff] [blame] | 352 | } |
| 353 | |
| 354 | bool Framebuffer::hasEnabledColorAttachment() const |
| 355 | { |
| 356 | for (unsigned int colorAttachment = 0; colorAttachment < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++) |
| 357 | { |
| 358 | if (isEnabledColorAttachment(colorAttachment)) |
| 359 | { |
| 360 | return true; |
| 361 | } |
| 362 | } |
| 363 | |
| 364 | return false; |
| 365 | } |
| 366 | |
shannon.woods%transgaming.com@gtempaccount.com | 3b57b4f | 2013-04-13 03:28:29 +0000 | [diff] [blame] | 367 | bool Framebuffer::hasStencil() const |
daniel@transgaming.com | a27ff1e | 2010-08-24 19:20:11 +0000 | [diff] [blame] | 368 | { |
Geoff Lang | e4a492b | 2014-06-19 14:14:41 -0400 | [diff] [blame] | 369 | return (mStencilbuffer && mStencilbuffer->getStencilSize() > 0); |
daniel@transgaming.com | a27ff1e | 2010-08-24 19:20:11 +0000 | [diff] [blame] | 370 | } |
| 371 | |
shannonwoods@chromium.org | 24ac850 | 2013-05-30 00:01:37 +0000 | [diff] [blame] | 372 | bool Framebuffer::usingExtendedDrawBuffers() const |
| 373 | { |
| 374 | for (unsigned int colorAttachment = 1; colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++) |
| 375 | { |
| 376 | if (isEnabledColorAttachment(colorAttachment)) |
| 377 | { |
| 378 | return true; |
| 379 | } |
| 380 | } |
| 381 | |
| 382 | return false; |
| 383 | } |
| 384 | |
shannon.woods%transgaming.com@gtempaccount.com | 3b57b4f | 2013-04-13 03:28:29 +0000 | [diff] [blame] | 385 | GLenum Framebuffer::completeness() const |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 386 | { |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 387 | int width = 0; |
| 388 | int height = 0; |
shannonwoods@chromium.org | f6fb959 | 2013-05-30 00:09:40 +0000 | [diff] [blame] | 389 | unsigned int colorbufferSize = 0; |
daniel@transgaming.com | 1f135d8 | 2010-08-24 19:20:36 +0000 | [diff] [blame] | 390 | int samples = -1; |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 391 | bool missingAttachment = true; |
shannonwoods@chromium.org | f6fb959 | 2013-05-30 00:09:40 +0000 | [diff] [blame] | 392 | GLuint clientVersion = mRenderer->getCurrentClientVersion(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 393 | |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 394 | for (unsigned int colorAttachment = 0; colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 395 | { |
Jamie Madill | bb94f34 | 2014-06-23 15:23:02 -0400 | [diff] [blame] | 396 | const FramebufferAttachment *colorbuffer = mColorbuffers[colorAttachment]; |
| 397 | |
| 398 | if (colorbuffer) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 399 | { |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 400 | if (colorbuffer->getWidth() == 0 || colorbuffer->getHeight() == 0) |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 401 | { |
| 402 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
| 403 | } |
daniel@transgaming.com | 0186813 | 2010-08-24 19:21:17 +0000 | [diff] [blame] | 404 | |
Geoff Lang | cec3590 | 2014-04-16 10:52:36 -0400 | [diff] [blame] | 405 | GLenum internalformat = colorbuffer->getInternalFormat(); |
Geoff Lang | c0b9ef4 | 2014-07-02 10:02:37 -0400 | [diff] [blame] | 406 | // TODO(geofflang): use context's texture caps |
| 407 | const TextureCaps &formatCaps = mRenderer->getRendererTextureCaps().get(internalformat); |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 408 | const InternalFormat &formatInfo = GetInternalFormatInfo(internalformat); |
Jamie Madill | bb94f34 | 2014-06-23 15:23:02 -0400 | [diff] [blame] | 409 | if (colorbuffer->isTexture()) |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 410 | { |
Geoff Lang | 6cf8e1b | 2014-07-03 13:03:57 -0400 | [diff] [blame] | 411 | if (!formatCaps.renderable) |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 412 | { |
| 413 | return GL_FRAMEBUFFER_UNSUPPORTED; |
| 414 | } |
| 415 | |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 416 | if (formatInfo.depthBits > 0 || formatInfo.stencilBits > 0) |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 417 | { |
| 418 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
| 419 | } |
| 420 | } |
| 421 | else |
| 422 | { |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 423 | if (!formatCaps.renderable || formatInfo.depthBits > 0 || formatInfo.stencilBits > 0) |
Jamie Madill | bb94f34 | 2014-06-23 15:23:02 -0400 | [diff] [blame] | 424 | { |
| 425 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
| 426 | } |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 427 | } |
| 428 | |
| 429 | if (!missingAttachment) |
| 430 | { |
| 431 | // all color attachments must have the same width and height |
| 432 | if (colorbuffer->getWidth() != width || colorbuffer->getHeight() != height) |
| 433 | { |
| 434 | return GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS; |
| 435 | } |
| 436 | |
| 437 | // APPLE_framebuffer_multisample, which EXT_draw_buffers refers to, requires that |
| 438 | // all color attachments have the same number of samples for the FBO to be complete. |
| 439 | if (colorbuffer->getSamples() != samples) |
| 440 | { |
| 441 | return GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT; |
| 442 | } |
| 443 | |
shannon.woods%transgaming.com@gtempaccount.com | c347152 | 2013-04-13 03:34:52 +0000 | [diff] [blame] | 444 | // in GLES 2.0, all color attachments attachments must have the same number of bitplanes |
| 445 | // in GLES 3.0, there is no such restriction |
shannonwoods@chromium.org | f6fb959 | 2013-05-30 00:09:40 +0000 | [diff] [blame] | 446 | if (clientVersion < 3) |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 447 | { |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 448 | if (formatInfo.pixelBytes != colorbufferSize) |
shannon.woods%transgaming.com@gtempaccount.com | c347152 | 2013-04-13 03:34:52 +0000 | [diff] [blame] | 449 | { |
| 450 | return GL_FRAMEBUFFER_UNSUPPORTED; |
| 451 | } |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 452 | } |
| 453 | |
| 454 | // D3D11 does not allow for overlapping RenderTargetViews, so ensure uniqueness |
| 455 | for (unsigned int previousColorAttachment = 0; previousColorAttachment < colorAttachment; previousColorAttachment++) |
| 456 | { |
Jamie Madill | e92a354 | 2014-07-03 10:38:58 -0400 | [diff] [blame] | 457 | const FramebufferAttachment *previousAttachment = mColorbuffers[previousColorAttachment]; |
| 458 | |
| 459 | if (previousAttachment && |
| 460 | (colorbuffer->id() == previousAttachment->id() && |
| 461 | colorbuffer->type() == previousAttachment->type())) |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 462 | { |
| 463 | return GL_FRAMEBUFFER_UNSUPPORTED; |
| 464 | } |
| 465 | } |
| 466 | } |
| 467 | else |
| 468 | { |
| 469 | width = colorbuffer->getWidth(); |
| 470 | height = colorbuffer->getHeight(); |
| 471 | samples = colorbuffer->getSamples(); |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 472 | colorbufferSize = formatInfo.pixelBytes; |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 473 | missingAttachment = false; |
| 474 | } |
| 475 | } |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 476 | } |
| 477 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 478 | if (mDepthbuffer) |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 479 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 480 | if (mDepthbuffer->getWidth() == 0 || mDepthbuffer->getHeight() == 0) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 481 | { |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 482 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 483 | } |
| 484 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 485 | GLenum internalformat = mDepthbuffer->getInternalFormat(); |
Geoff Lang | c0b9ef4 | 2014-07-02 10:02:37 -0400 | [diff] [blame] | 486 | // TODO(geofflang): use context's texture caps |
| 487 | const TextureCaps &formatCaps = mRenderer->getRendererTextureCaps().get(internalformat); |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 488 | const InternalFormat &formatInfo = GetInternalFormatInfo(internalformat); |
Jamie Madill | bb94f34 | 2014-06-23 15:23:02 -0400 | [diff] [blame] | 489 | if (mDepthbuffer->isTexture()) |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 490 | { |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 491 | // depth texture attachments require OES/ANGLE_depth_texture |
Geoff Lang | c0b9ef4 | 2014-07-02 10:02:37 -0400 | [diff] [blame] | 492 | // TODO(geofflang): use context's extensions |
| 493 | if (!mRenderer->getRendererExtensions().depthTextures) |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 494 | { |
| 495 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
| 496 | } |
| 497 | |
Geoff Lang | 6cf8e1b | 2014-07-03 13:03:57 -0400 | [diff] [blame] | 498 | if (!formatCaps.renderable) |
Geoff Lang | cec3590 | 2014-04-16 10:52:36 -0400 | [diff] [blame] | 499 | { |
| 500 | return GL_FRAMEBUFFER_UNSUPPORTED; |
| 501 | } |
| 502 | |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 503 | if (formatInfo.depthBits == 0) |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 504 | { |
| 505 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
| 506 | } |
| 507 | } |
| 508 | else |
| 509 | { |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 510 | if (!formatCaps.renderable || formatInfo.depthBits == 0) |
Jamie Madill | bb94f34 | 2014-06-23 15:23:02 -0400 | [diff] [blame] | 511 | { |
| 512 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
| 513 | } |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 514 | } |
| 515 | |
| 516 | if (missingAttachment) |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 517 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 518 | width = mDepthbuffer->getWidth(); |
| 519 | height = mDepthbuffer->getHeight(); |
| 520 | samples = mDepthbuffer->getSamples(); |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 521 | missingAttachment = false; |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 522 | } |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 523 | else if (width != mDepthbuffer->getWidth() || height != mDepthbuffer->getHeight()) |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 524 | { |
| 525 | return GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS; |
| 526 | } |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 527 | else if (samples != mDepthbuffer->getSamples()) |
daniel@transgaming.com | 1f135d8 | 2010-08-24 19:20:36 +0000 | [diff] [blame] | 528 | { |
| 529 | return GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE; |
| 530 | } |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 531 | } |
| 532 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 533 | if (mStencilbuffer) |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 534 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 535 | if (mStencilbuffer->getWidth() == 0 || mStencilbuffer->getHeight() == 0) |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 536 | { |
| 537 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
| 538 | } |
| 539 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 540 | GLenum internalformat = mStencilbuffer->getInternalFormat(); |
Geoff Lang | c0b9ef4 | 2014-07-02 10:02:37 -0400 | [diff] [blame] | 541 | // TODO(geofflang): use context's texture caps |
| 542 | const TextureCaps &formatCaps = mRenderer->getRendererTextureCaps().get(internalformat); |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 543 | const InternalFormat &formatInfo = GetInternalFormatInfo(internalformat); |
Jamie Madill | bb94f34 | 2014-06-23 15:23:02 -0400 | [diff] [blame] | 544 | if (mStencilbuffer->isTexture()) |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 545 | { |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 546 | // texture stencil attachments come along as part |
| 547 | // of OES_packed_depth_stencil + OES/ANGLE_depth_texture |
Geoff Lang | c0b9ef4 | 2014-07-02 10:02:37 -0400 | [diff] [blame] | 548 | // TODO(geofflang): use context's extensions |
| 549 | if (!mRenderer->getRendererExtensions().depthTextures) |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 550 | { |
| 551 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
| 552 | } |
| 553 | |
Geoff Lang | 6cf8e1b | 2014-07-03 13:03:57 -0400 | [diff] [blame] | 554 | if (!formatCaps.renderable) |
Geoff Lang | cec3590 | 2014-04-16 10:52:36 -0400 | [diff] [blame] | 555 | { |
| 556 | return GL_FRAMEBUFFER_UNSUPPORTED; |
| 557 | } |
| 558 | |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 559 | if (formatInfo.stencilBits == 0) |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 560 | { |
| 561 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
| 562 | } |
| 563 | } |
| 564 | else |
| 565 | { |
Geoff Lang | 5d60138 | 2014-07-22 15:14:06 -0400 | [diff] [blame] | 566 | if (!formatCaps.renderable || formatInfo.stencilBits == 0) |
Jamie Madill | bb94f34 | 2014-06-23 15:23:02 -0400 | [diff] [blame] | 567 | { |
| 568 | return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; |
| 569 | } |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 570 | } |
| 571 | |
| 572 | if (missingAttachment) |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 573 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 574 | width = mStencilbuffer->getWidth(); |
| 575 | height = mStencilbuffer->getHeight(); |
| 576 | samples = mStencilbuffer->getSamples(); |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 577 | missingAttachment = false; |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 578 | } |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 579 | else if (width != mStencilbuffer->getWidth() || height != mStencilbuffer->getHeight()) |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 580 | { |
| 581 | return GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS; |
| 582 | } |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 583 | else if (samples != mStencilbuffer->getSamples()) |
daniel@transgaming.com | 1f135d8 | 2010-08-24 19:20:36 +0000 | [diff] [blame] | 584 | { |
| 585 | return GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE; |
| 586 | } |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 587 | } |
| 588 | |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 589 | // if we have both a depth and stencil buffer, they must refer to the same object |
| 590 | // since we only support packed_depth_stencil and not separate depth and stencil |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 591 | if (mDepthbuffer && mStencilbuffer && !hasValidDepthStencil()) |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 592 | { |
daniel@transgaming.com | 6b7c84c | 2012-05-31 01:14:39 +0000 | [diff] [blame] | 593 | return GL_FRAMEBUFFER_UNSUPPORTED; |
| 594 | } |
| 595 | |
| 596 | // we need to have at least one attachment to be complete |
| 597 | if (missingAttachment) |
| 598 | { |
| 599 | return GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT; |
daniel@transgaming.com | cdacc8e | 2010-07-28 19:20:50 +0000 | [diff] [blame] | 600 | } |
| 601 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 602 | return GL_FRAMEBUFFER_COMPLETE; |
| 603 | } |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 604 | |
Jamie Madill | 2d96b9e | 2014-08-29 15:46:47 -0400 | [diff] [blame] | 605 | void Framebuffer::invalidate(const Caps &caps, GLsizei numAttachments, const GLenum *attachments) |
| 606 | { |
| 607 | GLuint maxDimension = caps.maxRenderbufferSize; |
| 608 | invalidateSub(caps, numAttachments, attachments, 0, 0, maxDimension, maxDimension); |
| 609 | } |
| 610 | |
| 611 | void Framebuffer::invalidateSub(const Caps &caps, GLsizei numAttachments, const GLenum *attachments, |
| 612 | GLint x, GLint y, GLsizei width, GLsizei height) |
Jamie Madill | 400a441 | 2014-08-29 15:46:45 -0400 | [diff] [blame] | 613 | { |
| 614 | ASSERT(completeness() == GL_FRAMEBUFFER_COMPLETE); |
Jamie Madill | 6d70826 | 2014-09-03 15:07:13 -0400 | [diff] [blame] | 615 | for (GLsizei attachIndex = 0; attachIndex < numAttachments; ++attachIndex) |
Jamie Madill | 400a441 | 2014-08-29 15:46:45 -0400 | [diff] [blame] | 616 | { |
Jamie Madill | 6d70826 | 2014-09-03 15:07:13 -0400 | [diff] [blame] | 617 | GLenum attachmentTarget = attachments[attachIndex]; |
Jamie Madill | 400a441 | 2014-08-29 15:46:45 -0400 | [diff] [blame] | 618 | |
Jamie Madill | 6d70826 | 2014-09-03 15:07:13 -0400 | [diff] [blame] | 619 | gl::FramebufferAttachment *attachment = |
| 620 | (attachmentTarget == GL_DEPTH_STENCIL_ATTACHMENT) ? getDepthOrStencilbuffer() : |
| 621 | getAttachment(attachmentTarget); |
Jamie Madill | 400a441 | 2014-08-29 15:46:45 -0400 | [diff] [blame] | 622 | |
Jamie Madill | 6d70826 | 2014-09-03 15:07:13 -0400 | [diff] [blame] | 623 | if (attachment) |
Jamie Madill | 400a441 | 2014-08-29 15:46:45 -0400 | [diff] [blame] | 624 | { |
Jamie Madill | 9f0b42a | 2014-09-12 10:25:27 -0400 | [diff] [blame] | 625 | rx::RenderTarget *renderTarget = rx::GetAttachmentRenderTarget(attachment); |
Jamie Madill | 6d70826 | 2014-09-03 15:07:13 -0400 | [diff] [blame] | 626 | if (renderTarget) |
| 627 | { |
| 628 | renderTarget->invalidate(x, y, width, height); |
| 629 | } |
Jamie Madill | 400a441 | 2014-08-29 15:46:45 -0400 | [diff] [blame] | 630 | } |
| 631 | } |
| 632 | } |
| 633 | |
daniel@transgaming.com | 16418b1 | 2012-11-28 19:32:22 +0000 | [diff] [blame] | 634 | DefaultFramebuffer::DefaultFramebuffer(rx::Renderer *renderer, Colorbuffer *colorbuffer, DepthStencilbuffer *depthStencil) |
Shannon Woods | aa2ab7d | 2014-06-24 17:51:51 -0400 | [diff] [blame] | 635 | : Framebuffer(renderer, 0) |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 636 | { |
Geoff Lang | e4a492b | 2014-06-19 14:14:41 -0400 | [diff] [blame] | 637 | Renderbuffer *colorRenderbuffer = new Renderbuffer(0, colorbuffer); |
Jamie Madill | aef95de | 2014-09-05 10:12:41 -0400 | [diff] [blame] | 638 | mColorbuffers[0] = new RenderbufferAttachment(GL_BACK, colorRenderbuffer); |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 639 | |
Jamie Madill | 04ab0eb | 2014-11-22 23:07:51 -0500 | [diff] [blame] | 640 | GLenum depthStencilActualFormat = depthStencil->getActualFormat(); |
| 641 | const gl::InternalFormat &depthStencilFormatInfo = GetInternalFormatInfo(depthStencilActualFormat); |
Jamie Madill | 28bedaf | 2014-06-26 13:17:22 -0400 | [diff] [blame] | 642 | |
Jamie Madill | 04ab0eb | 2014-11-22 23:07:51 -0500 | [diff] [blame] | 643 | if (depthStencilFormatInfo.depthBits != 0 || depthStencilFormatInfo.stencilBits != 0) |
| 644 | { |
| 645 | Renderbuffer *depthStencilBuffer = new Renderbuffer(0, depthStencil); |
| 646 | |
| 647 | // Make a new attachment objects to ensure we do not double-delete |
| 648 | // See angle issue 686 |
| 649 | mDepthbuffer = (depthStencilFormatInfo.depthBits != 0 ? new RenderbufferAttachment(GL_DEPTH_ATTACHMENT, depthStencilBuffer) : NULL); |
| 650 | mStencilbuffer = (depthStencilFormatInfo.stencilBits != 0 ? new RenderbufferAttachment(GL_STENCIL_ATTACHMENT, depthStencilBuffer) : NULL); |
| 651 | } |
| 652 | else |
| 653 | { |
| 654 | // This method transfers ownership, so delete the unused storage if we don't keep it. |
| 655 | SafeDelete(depthStencil); |
| 656 | } |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 657 | |
| 658 | mDrawBufferStates[0] = GL_BACK; |
| 659 | mReadBufferState = GL_BACK; |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 660 | } |
| 661 | |
shannon.woods%transgaming.com@gtempaccount.com | 3b57b4f | 2013-04-13 03:28:29 +0000 | [diff] [blame] | 662 | int Framebuffer::getSamples() const |
daniel@transgaming.com | 1f135d8 | 2010-08-24 19:20:36 +0000 | [diff] [blame] | 663 | { |
| 664 | if (completeness() == GL_FRAMEBUFFER_COMPLETE) |
| 665 | { |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 666 | // for a complete framebuffer, all attachments must have the same sample count |
| 667 | // in this case return the first nonzero sample size |
| 668 | for (unsigned int colorAttachment = 0; colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++) |
| 669 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 670 | if (mColorbuffers[colorAttachment]) |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 671 | { |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 672 | return mColorbuffers[colorAttachment]->getSamples(); |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 673 | } |
| 674 | } |
daniel@transgaming.com | 1f135d8 | 2010-08-24 19:20:36 +0000 | [diff] [blame] | 675 | } |
shannon.woods%transgaming.com@gtempaccount.com | f30ccc2 | 2013-04-13 03:28:36 +0000 | [diff] [blame] | 676 | |
| 677 | return 0; |
daniel@transgaming.com | 1f135d8 | 2010-08-24 19:20:36 +0000 | [diff] [blame] | 678 | } |
| 679 | |
Jamie Madill | e261b44 | 2014-06-25 12:42:21 -0400 | [diff] [blame] | 680 | bool Framebuffer::hasValidDepthStencil() const |
| 681 | { |
| 682 | // A valid depth-stencil attachment has the same resource bound to both the |
| 683 | // depth and stencil attachment points. |
| 684 | return (mDepthbuffer && mStencilbuffer && |
| 685 | mDepthbuffer->type() == mStencilbuffer->type() && |
| 686 | mDepthbuffer->id() == mStencilbuffer->id()); |
| 687 | } |
| 688 | |
Jamie Madill | ce20c7f | 2014-09-03 11:56:29 -0400 | [diff] [blame] | 689 | ColorbufferInfo Framebuffer::getColorbuffersForRender() const |
| 690 | { |
| 691 | ColorbufferInfo colorbuffersForRender; |
| 692 | |
| 693 | for (size_t colorAttachment = 0; colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS; ++colorAttachment) |
| 694 | { |
| 695 | GLenum drawBufferState = mDrawBufferStates[colorAttachment]; |
| 696 | FramebufferAttachment *colorbuffer = mColorbuffers[colorAttachment]; |
| 697 | |
| 698 | if (colorbuffer != NULL && drawBufferState != GL_NONE) |
| 699 | { |
| 700 | ASSERT(drawBufferState == GL_BACK || drawBufferState == (GL_COLOR_ATTACHMENT0_EXT + colorAttachment)); |
| 701 | colorbuffersForRender.push_back(colorbuffer); |
| 702 | } |
Jamie Madill | 3f2e61d | 2014-09-05 10:38:05 -0400 | [diff] [blame] | 703 | #if (ANGLE_MRT_PERF_WORKAROUND == ANGLE_WORKAROUND_DISABLED) |
Jamie Madill | ce20c7f | 2014-09-03 11:56:29 -0400 | [diff] [blame] | 704 | else |
| 705 | { |
| 706 | colorbuffersForRender.push_back(NULL); |
| 707 | } |
Jamie Madill | 3f2e61d | 2014-09-05 10:38:05 -0400 | [diff] [blame] | 708 | #endif |
Jamie Madill | ce20c7f | 2014-09-03 11:56:29 -0400 | [diff] [blame] | 709 | } |
| 710 | |
| 711 | return colorbuffersForRender; |
| 712 | } |
| 713 | |
shannon.woods%transgaming.com@gtempaccount.com | 3b57b4f | 2013-04-13 03:28:29 +0000 | [diff] [blame] | 714 | GLenum DefaultFramebuffer::completeness() const |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 715 | { |
shannon.woods@transgaming.com | 3e3da58 | 2013-02-28 23:09:03 +0000 | [diff] [blame] | 716 | // The default framebuffer *must* always be complete, though it may not be |
| 717 | // subject to the same rules as application FBOs. ie, it could have 0x0 size. |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 718 | return GL_FRAMEBUFFER_COMPLETE; |
| 719 | } |
| 720 | |
Jamie Madill | e92a354 | 2014-07-03 10:38:58 -0400 | [diff] [blame] | 721 | FramebufferAttachment *DefaultFramebuffer::getAttachment(GLenum attachment) const |
| 722 | { |
| 723 | switch (attachment) |
| 724 | { |
Jamie Madill | 6d70826 | 2014-09-03 15:07:13 -0400 | [diff] [blame] | 725 | case GL_COLOR: |
Jamie Madill | e92a354 | 2014-07-03 10:38:58 -0400 | [diff] [blame] | 726 | case GL_BACK: |
| 727 | return getColorbuffer(0); |
| 728 | case GL_DEPTH: |
| 729 | return getDepthbuffer(); |
| 730 | case GL_STENCIL: |
| 731 | return getStencilbuffer(); |
| 732 | case GL_DEPTH_STENCIL: |
| 733 | return getDepthStencilBuffer(); |
| 734 | default: |
| 735 | UNREACHABLE(); |
| 736 | return NULL; |
| 737 | } |
| 738 | } |
| 739 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 740 | } |