1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef GL_GLEXT_PROTOTYPES 6 #define GL_GLEXT_PROTOTYPES 7 #endif 8 9 #include <GLES2/gl2.h> 10 #include <GLES2/gl2ext.h> 11 #include <GLES2/gl2extchromium.h> 12 13 #include "gpu/command_buffer/tests/gl_manager.h" 14 #include "gpu/command_buffer/tests/gl_test_utils.h" 15 #include "testing/gmock/include/gmock/gmock.h" 16 #include "testing/gtest/include/gtest/gtest.h" 17 18 namespace gpu { 19 20 // A collection of tests that exercise the GL_CHROMIUM_copy_texture extension. 21 class GLCopyTextureCHROMIUMTest : public testing::Test { 22 protected: 23 virtual void SetUp() { 24 gl_.Initialize(GLManager::Options()); 25 26 glGenTextures(2, textures_); 27 glBindTexture(GL_TEXTURE_2D, textures_[1]); 28 29 // Some drivers (NVidia/SGX) require texture settings to be a certain way or 30 // they won't report FRAMEBUFFER_COMPLETE. 31 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 32 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 33 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 34 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 35 36 glGenFramebuffers(1, &framebuffer_id_); 37 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_); 38 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 39 textures_[1], 0); 40 } 41 42 virtual void TearDown() { 43 glDeleteTextures(2, textures_); 44 glDeleteFramebuffers(1, &framebuffer_id_); 45 gl_.Destroy(); 46 } 47 48 GLManager gl_; 49 GLuint textures_[2]; 50 GLuint framebuffer_id_; 51 }; 52 53 // Test to ensure that the basic functionality of the extension works. 54 TEST_F(GLCopyTextureCHROMIUMTest, Basic) { 55 uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u }; 56 57 glBindTexture(GL_TEXTURE_2D, textures_[0]); 58 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 59 pixels); 60 61 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 62 GL_UNSIGNED_BYTE); 63 EXPECT_TRUE(glGetError() == GL_NO_ERROR); 64 65 // Check the FB is still bound. 66 GLint value = 0; 67 glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value); 68 GLuint fb_id = value; 69 EXPECT_EQ(framebuffer_id_, fb_id); 70 71 // Check that FB is complete. 72 EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE), 73 glCheckFramebufferStatus(GL_FRAMEBUFFER)); 74 75 GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels); 76 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 77 } 78 79 TEST_F(GLCopyTextureCHROMIUMTest, InternalFormat) { 80 GLint src_formats[] = {GL_ALPHA, GL_RGB, GL_RGBA, 81 GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_BGRA_EXT}; 82 GLint dest_formats[] = {GL_RGB, GL_RGBA}; 83 84 for (size_t src_index = 0; src_index < arraysize(src_formats); src_index++) { 85 for (size_t dest_index = 0; dest_index < arraysize(dest_formats); 86 dest_index++) { 87 glBindTexture(GL_TEXTURE_2D, textures_[0]); 88 glTexImage2D(GL_TEXTURE_2D, 89 0, 90 src_formats[src_index], 91 1, 92 1, 93 0, 94 src_formats[src_index], 95 GL_UNSIGNED_BYTE, 96 NULL); 97 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 98 99 glCopyTextureCHROMIUM(GL_TEXTURE_2D, 100 textures_[0], 101 textures_[1], 102 0, 103 dest_formats[dest_index], 104 GL_UNSIGNED_BYTE); 105 EXPECT_TRUE(GL_NO_ERROR == glGetError()) << "src_index:" << src_index 106 << " dest_index:" << dest_index; 107 } 108 } 109 } 110 111 TEST_F(GLCopyTextureCHROMIUMTest, InternalFormatNotSupported) { 112 glBindTexture(GL_TEXTURE_2D, textures_[0]); 113 glTexImage2D( 114 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 115 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 116 117 // Check unsupported format reports error. 118 GLint unsupported_dest_formats[] = {GL_ALPHA, GL_LUMINANCE, 119 GL_LUMINANCE_ALPHA}; 120 for (size_t dest_index = 0; dest_index < arraysize(unsupported_dest_formats); 121 dest_index++) { 122 glCopyTextureCHROMIUM(GL_TEXTURE_2D, 123 textures_[0], 124 textures_[1], 125 0, 126 unsupported_dest_formats[dest_index], 127 GL_UNSIGNED_BYTE); 128 EXPECT_TRUE(GL_INVALID_OPERATION == glGetError()) 129 << "dest_index:" << dest_index; 130 } 131 } 132 133 // Test to ensure that the destination texture is redefined if the properties 134 // are different. 135 TEST_F(GLCopyTextureCHROMIUMTest, RedefineDestinationTexture) { 136 uint8 pixels[4 * 4] = {255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u, 137 255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u}; 138 139 glBindTexture(GL_TEXTURE_2D, textures_[0]); 140 glTexImage2D( 141 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels); 142 143 glBindTexture(GL_TEXTURE_2D, textures_[1]); 144 glTexImage2D(GL_TEXTURE_2D, 145 0, 146 GL_BGRA_EXT, 147 1, 148 1, 149 0, 150 GL_BGRA_EXT, 151 GL_UNSIGNED_BYTE, 152 pixels); 153 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 154 155 // GL_INVALID_OPERATION due to "intrinsic format" != "internal format". 156 glTexSubImage2D( 157 GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels); 158 EXPECT_TRUE(GL_INVALID_OPERATION == glGetError()); 159 // GL_INVALID_VALUE due to bad dimensions. 160 glTexSubImage2D( 161 GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels); 162 EXPECT_TRUE(GL_INVALID_VALUE == glGetError()); 163 164 // If the dest texture has different properties, glCopyTextureCHROMIUM() 165 // redefines them. 166 glCopyTextureCHROMIUM( 167 GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, GL_UNSIGNED_BYTE); 168 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 169 170 // glTexSubImage2D() succeeds because textures_[1] is redefined into 2x2 171 // dimension and GL_RGBA format. 172 glBindTexture(GL_TEXTURE_2D, textures_[1]); 173 glTexSubImage2D( 174 GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels); 175 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 176 177 // Check the FB is still bound. 178 GLint value = 0; 179 glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value); 180 GLuint fb_id = value; 181 EXPECT_EQ(framebuffer_id_, fb_id); 182 183 // Check that FB is complete. 184 EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE), 185 glCheckFramebufferStatus(GL_FRAMEBUFFER)); 186 187 GLTestHelper::CheckPixels(1, 1, 1, 1, 0, &pixels[12]); 188 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 189 } 190 191 // Test that the extension respects the flip-y pixel storage setting. 192 TEST_F(GLCopyTextureCHROMIUMTest, FlipY) { 193 uint8 pixels[2][2][4]; 194 for (int x = 0; x < 2; ++x) { 195 for (int y = 0; y < 2; ++y) { 196 pixels[y][x][0] = x + y; 197 pixels[y][x][1] = x + y; 198 pixels[y][x][2] = x + y; 199 pixels[y][x][3] = 255u; 200 } 201 } 202 203 glBindTexture(GL_TEXTURE_2D, textures_[0]); 204 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 205 pixels); 206 207 glPixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE); 208 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 209 GL_UNSIGNED_BYTE); 210 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 211 212 uint8 copied_pixels[2][2][4] = {{{0}}}; 213 glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels); 214 for (int x = 0; x < 2; ++x) { 215 for (int y = 0; y < 2; ++y) { 216 EXPECT_EQ(pixels[1-y][x][0], copied_pixels[y][x][0]); 217 EXPECT_EQ(pixels[1-y][x][1], copied_pixels[y][x][1]); 218 EXPECT_EQ(pixels[1-y][x][2], copied_pixels[y][x][2]); 219 EXPECT_EQ(pixels[1-y][x][3], copied_pixels[y][x][3]); 220 } 221 } 222 223 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 224 } 225 226 // Test that the extension respects the GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM 227 // storage setting. 228 TEST_F(GLCopyTextureCHROMIUMTest, PremultiplyAlpha) { 229 uint8 pixels[1 * 4] = { 2, 2, 2, 128 }; 230 231 glBindTexture(GL_TEXTURE_2D, textures_[0]); 232 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 233 pixels); 234 235 glPixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE); 236 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 237 GL_UNSIGNED_BYTE); 238 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 239 240 uint8 copied_pixels[1 * 4] = {0}; 241 glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels); 242 EXPECT_EQ(1u, copied_pixels[0]); 243 EXPECT_EQ(1u, copied_pixels[1]); 244 EXPECT_EQ(1u, copied_pixels[2]); 245 EXPECT_EQ(128u, copied_pixels[3]); 246 247 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 248 } 249 250 // Test that the extension respects the GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM 251 // storage setting. 252 TEST_F(GLCopyTextureCHROMIUMTest, UnpremultiplyAlpha) { 253 uint8 pixels[1 * 4] = { 16, 16, 16, 128 }; 254 255 glBindTexture(GL_TEXTURE_2D, textures_[0]); 256 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 257 pixels); 258 259 glPixelStorei(GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE); 260 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 261 GL_UNSIGNED_BYTE); 262 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 263 264 uint8 copied_pixels[1 * 4] = {0}; 265 glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels); 266 EXPECT_EQ(32u, copied_pixels[0]); 267 EXPECT_EQ(32u, copied_pixels[1]); 268 EXPECT_EQ(32u, copied_pixels[2]); 269 EXPECT_EQ(128u, copied_pixels[3]); 270 271 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 272 } 273 274 TEST_F(GLCopyTextureCHROMIUMTest, FlipYAndPremultiplyAlpha) { 275 uint8 pixels[2][2][4]; 276 for (int x = 0; x < 2; ++x) { 277 for (int y = 0; y < 2; ++y) { 278 uint8 color = 16 * x + 16 * y; 279 pixels[y][x][0] = color; 280 pixels[y][x][1] = color; 281 pixels[y][x][2] = color; 282 pixels[y][x][3] = 128u; 283 } 284 } 285 286 glBindTexture(GL_TEXTURE_2D, textures_[0]); 287 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 288 pixels); 289 290 glPixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE); 291 glPixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE); 292 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 293 GL_UNSIGNED_BYTE); 294 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 295 296 uint8 copied_pixels[2][2][4] = {{{0}}}; 297 glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels); 298 for (int x = 0; x < 2; ++x) { 299 for (int y = 0; y < 2; ++y) { 300 EXPECT_EQ(pixels[1-y][x][0] / 2, copied_pixels[y][x][0]); 301 EXPECT_EQ(pixels[1-y][x][1] / 2, copied_pixels[y][x][1]); 302 EXPECT_EQ(pixels[1-y][x][2] / 2, copied_pixels[y][x][2]); 303 EXPECT_EQ(pixels[1-y][x][3], copied_pixels[y][x][3]); 304 } 305 } 306 307 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 308 } 309 310 TEST_F(GLCopyTextureCHROMIUMTest, FlipYAndUnpremultiplyAlpha) { 311 uint8 pixels[2][2][4]; 312 for (int x = 0; x < 2; ++x) { 313 for (int y = 0; y < 2; ++y) { 314 uint8 color = 16 * x + 16 * y; 315 pixels[y][x][0] = color; 316 pixels[y][x][1] = color; 317 pixels[y][x][2] = color; 318 pixels[y][x][3] = 128u; 319 } 320 } 321 322 glBindTexture(GL_TEXTURE_2D, textures_[0]); 323 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 324 pixels); 325 326 glPixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE); 327 glPixelStorei(GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE); 328 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 329 GL_UNSIGNED_BYTE); 330 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 331 332 uint8 copied_pixels[2][2][4] = {{{0}}}; 333 glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels); 334 for (int x = 0; x < 2; ++x) { 335 for (int y = 0; y < 2; ++y) { 336 EXPECT_EQ(pixels[1-y][x][0] * 2, copied_pixels[y][x][0]); 337 EXPECT_EQ(pixels[1-y][x][1] * 2, copied_pixels[y][x][1]); 338 EXPECT_EQ(pixels[1-y][x][2] * 2, copied_pixels[y][x][2]); 339 EXPECT_EQ(pixels[1-y][x][3], copied_pixels[y][x][3]); 340 } 341 } 342 343 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 344 } 345 346 namespace { 347 348 void glEnableDisable(GLint param, GLboolean value) { 349 if (value) 350 glEnable(param); 351 else 352 glDisable(param); 353 } 354 355 } // unnamed namespace 356 357 // Validate that some basic GL state is not touched upon execution of 358 // the extension. 359 TEST_F(GLCopyTextureCHROMIUMTest, BasicStatePreservation) { 360 uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u }; 361 362 glBindFramebuffer(GL_FRAMEBUFFER, 0); 363 364 glBindTexture(GL_TEXTURE_2D, textures_[0]); 365 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 366 pixels); 367 368 GLboolean reference_settings[2] = { GL_TRUE, GL_FALSE }; 369 for (int x = 0; x < 2; ++x) { 370 GLboolean setting = reference_settings[x]; 371 glEnableDisable(GL_DEPTH_TEST, setting); 372 glEnableDisable(GL_SCISSOR_TEST, setting); 373 glEnableDisable(GL_STENCIL_TEST, setting); 374 glEnableDisable(GL_CULL_FACE, setting); 375 glEnableDisable(GL_BLEND, setting); 376 glColorMask(setting, setting, setting, setting); 377 glDepthMask(setting); 378 379 glActiveTexture(GL_TEXTURE1 + x); 380 381 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 382 GL_RGBA, GL_UNSIGNED_BYTE); 383 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 384 385 EXPECT_EQ(setting, glIsEnabled(GL_DEPTH_TEST)); 386 EXPECT_EQ(setting, glIsEnabled(GL_SCISSOR_TEST)); 387 EXPECT_EQ(setting, glIsEnabled(GL_STENCIL_TEST)); 388 EXPECT_EQ(setting, glIsEnabled(GL_CULL_FACE)); 389 EXPECT_EQ(setting, glIsEnabled(GL_BLEND)); 390 391 GLboolean bool_array[4] = { GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE }; 392 glGetBooleanv(GL_DEPTH_WRITEMASK, bool_array); 393 EXPECT_EQ(setting, bool_array[0]); 394 395 bool_array[0] = GL_FALSE; 396 glGetBooleanv(GL_COLOR_WRITEMASK, bool_array); 397 EXPECT_EQ(setting, bool_array[0]); 398 EXPECT_EQ(setting, bool_array[1]); 399 EXPECT_EQ(setting, bool_array[2]); 400 EXPECT_EQ(setting, bool_array[3]); 401 402 GLint active_texture = 0; 403 glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture); 404 EXPECT_EQ(GL_TEXTURE1 + x, active_texture); 405 } 406 407 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 408 }; 409 410 // Verify that invocation of the extension does not modify the bound 411 // texture state. 412 TEST_F(GLCopyTextureCHROMIUMTest, TextureStatePreserved) { 413 // Setup the texture used for the extension invocation. 414 uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u }; 415 glBindTexture(GL_TEXTURE_2D, textures_[0]); 416 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 417 pixels); 418 419 GLuint texture_ids[2]; 420 glGenTextures(2, texture_ids); 421 422 glActiveTexture(GL_TEXTURE0); 423 glBindTexture(GL_TEXTURE_2D, texture_ids[0]); 424 425 glActiveTexture(GL_TEXTURE1); 426 glBindTexture(GL_TEXTURE_2D, texture_ids[1]); 427 428 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 429 GL_RGBA, GL_UNSIGNED_BYTE); 430 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 431 432 GLint active_texture = 0; 433 glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture); 434 EXPECT_EQ(GL_TEXTURE1, active_texture); 435 436 GLint bound_texture = 0; 437 glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_texture); 438 EXPECT_EQ(texture_ids[1], static_cast<GLuint>(bound_texture)); 439 glBindTexture(GL_TEXTURE_2D, 0); 440 441 bound_texture = 0; 442 glActiveTexture(GL_TEXTURE0); 443 glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_texture); 444 EXPECT_EQ(texture_ids[0], static_cast<GLuint>(bound_texture)); 445 glBindTexture(GL_TEXTURE_2D, 0); 446 447 glDeleteTextures(2, texture_ids); 448 449 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 450 } 451 452 // Verify that invocation of the extension does not perturb the currently 453 // bound FBO state. 454 TEST_F(GLCopyTextureCHROMIUMTest, FBOStatePreserved) { 455 // Setup the texture used for the extension invocation. 456 uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u }; 457 glBindTexture(GL_TEXTURE_2D, textures_[0]); 458 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 459 pixels); 460 461 GLuint texture_id; 462 glGenTextures(1, &texture_id); 463 glBindTexture(GL_TEXTURE_2D, texture_id); 464 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 465 0); 466 467 GLuint renderbuffer_id; 468 glGenRenderbuffers(1, &renderbuffer_id); 469 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_id); 470 glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 1, 1); 471 472 GLuint framebuffer_id; 473 glGenFramebuffers(1, &framebuffer_id); 474 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id); 475 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 476 texture_id, 0); 477 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, 478 GL_RENDERBUFFER, renderbuffer_id); 479 EXPECT_TRUE( 480 GL_FRAMEBUFFER_COMPLETE == glCheckFramebufferStatus(GL_FRAMEBUFFER)); 481 482 // Test that we can write to the bound framebuffer 483 uint8 expected_color[4] = { 255u, 255u, 0, 255u }; 484 glClearColor(1.0, 1.0, 0, 1.0); 485 glClear(GL_COLOR_BUFFER_BIT); 486 GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color); 487 488 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 489 GL_RGBA, GL_UNSIGNED_BYTE); 490 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 491 492 EXPECT_TRUE(glIsFramebuffer(framebuffer_id)); 493 494 // Ensure that reading from the framebuffer produces correct pixels. 495 GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color); 496 497 uint8 expected_color2[4] = { 255u, 0, 255u, 255u }; 498 glClearColor(1.0, 0, 1.0, 1.0); 499 glClear(GL_COLOR_BUFFER_BIT); 500 GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color2); 501 502 GLint bound_fbo = 0; 503 glGetIntegerv(GL_FRAMEBUFFER_BINDING, &bound_fbo); 504 EXPECT_EQ(framebuffer_id, static_cast<GLuint>(bound_fbo)); 505 506 GLint fbo_params = 0; 507 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 508 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, 509 &fbo_params); 510 EXPECT_EQ(GL_TEXTURE, fbo_params); 511 512 fbo_params = 0; 513 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 514 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, 515 &fbo_params); 516 EXPECT_EQ(texture_id, static_cast<GLuint>(fbo_params)); 517 518 fbo_params = 0; 519 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, 520 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, 521 &fbo_params); 522 EXPECT_EQ(GL_RENDERBUFFER, fbo_params); 523 524 fbo_params = 0; 525 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, 526 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, 527 &fbo_params); 528 EXPECT_EQ(renderbuffer_id, static_cast<GLuint>(fbo_params)); 529 530 glDeleteRenderbuffers(1, &renderbuffer_id); 531 glDeleteTextures(1, &texture_id); 532 glDeleteFramebuffers(1, &framebuffer_id); 533 534 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 535 } 536 537 TEST_F(GLCopyTextureCHROMIUMTest, ProgramStatePreservation) { 538 // unbind the one created in setup. 539 glBindFramebuffer(GL_FRAMEBUFFER, 0); 540 glBindTexture(GL_TEXTURE_2D, 0); 541 542 GLManager gl2; 543 GLManager::Options options; 544 options.size = gfx::Size(16, 16); 545 options.share_group_manager = &gl_; 546 gl2.Initialize(options); 547 gl_.MakeCurrent(); 548 549 static const char* v_shader_str = 550 "attribute vec4 g_Position;\n" 551 "void main()\n" 552 "{\n" 553 " gl_Position = g_Position;\n" 554 "}\n"; 555 static const char* f_shader_str = 556 "precision mediump float;\n" 557 "void main()\n" 558 "{\n" 559 " gl_FragColor = vec4(0,1,0,1);\n" 560 "}\n"; 561 562 GLuint program = GLTestHelper::LoadProgram(v_shader_str, f_shader_str); 563 glUseProgram(program); 564 GLuint position_loc = glGetAttribLocation(program, "g_Position"); 565 glFlush(); 566 567 // Delete program from other context. 568 gl2.MakeCurrent(); 569 glDeleteProgram(program); 570 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 571 glFlush(); 572 573 // Program should still be usable on this context. 574 gl_.MakeCurrent(); 575 576 GLTestHelper::SetupUnitQuad(position_loc); 577 578 // test using program before 579 uint8 expected[] = { 0, 255, 0, 255, }; 580 uint8 zero[] = { 0, 0, 0, 0, }; 581 glClear(GL_COLOR_BUFFER_BIT); 582 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero)); 583 glDrawArrays(GL_TRIANGLES, 0, 6); 584 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected)); 585 586 // Call copyTextureCHROMIUM 587 uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u }; 588 glBindTexture(GL_TEXTURE_2D, textures_[0]); 589 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 590 pixels); 591 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 592 GL_UNSIGNED_BYTE); 593 594 // test using program after 595 glClear(GL_COLOR_BUFFER_BIT); 596 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero)); 597 glDrawArrays(GL_TRIANGLES, 0, 6); 598 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected)); 599 600 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 601 602 gl2.MakeCurrent(); 603 gl2.Destroy(); 604 gl_.MakeCurrent(); 605 } 606 607 // Test that glCopyTextureCHROMIUM doesn't leak uninitialized textures. 608 TEST_F(GLCopyTextureCHROMIUMTest, UninitializedSource) { 609 const GLsizei kWidth = 64, kHeight = 64; 610 glBindTexture(GL_TEXTURE_2D, textures_[0]); 611 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kWidth, kHeight, 612 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 613 614 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 615 GL_UNSIGNED_BYTE); 616 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 617 618 uint8 pixels[kHeight][kWidth][4] = {{{1}}}; 619 glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels); 620 for (int x = 0; x < kWidth; ++x) { 621 for (int y = 0; y < kHeight; ++y) { 622 EXPECT_EQ(0, pixels[y][x][0]); 623 EXPECT_EQ(0, pixels[y][x][1]); 624 EXPECT_EQ(0, pixels[y][x][2]); 625 EXPECT_EQ(0, pixels[y][x][3]); 626 } 627 } 628 629 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 630 } 631 632 } // namespace gpu 633
