1 // Copyright 2014 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 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" 6 7 #include "base/command_line.h" 8 #include "base/strings/string_number_conversions.h" 9 #include "gpu/command_buffer/common/gles2_cmd_format.h" 10 #include "gpu/command_buffer/common/gles2_cmd_utils.h" 11 #include "gpu/command_buffer/common/id_allocator.h" 12 #include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h" 13 #include "gpu/command_buffer/service/async_pixel_transfer_manager.h" 14 #include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h" 15 #include "gpu/command_buffer/service/cmd_buffer_engine.h" 16 #include "gpu/command_buffer/service/context_group.h" 17 #include "gpu/command_buffer/service/context_state.h" 18 #include "gpu/command_buffer/service/gl_surface_mock.h" 19 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h" 20 21 #include "gpu/command_buffer/service/gpu_switches.h" 22 #include "gpu/command_buffer/service/image_manager.h" 23 #include "gpu/command_buffer/service/mailbox_manager.h" 24 #include "gpu/command_buffer/service/mocks.h" 25 #include "gpu/command_buffer/service/program_manager.h" 26 #include "gpu/command_buffer/service/test_helper.h" 27 #include "testing/gtest/include/gtest/gtest.h" 28 #include "ui/gl/gl_implementation.h" 29 #include "ui/gl/gl_mock.h" 30 #include "ui/gl/gl_surface_stub.h" 31 32 #if !defined(GL_DEPTH24_STENCIL8) 33 #define GL_DEPTH24_STENCIL8 0x88F0 34 #endif 35 36 using ::gfx::MockGLInterface; 37 using ::testing::_; 38 using ::testing::DoAll; 39 using ::testing::InSequence; 40 using ::testing::Invoke; 41 using ::testing::MatcherCast; 42 using ::testing::Mock; 43 using ::testing::Pointee; 44 using ::testing::Return; 45 using ::testing::SaveArg; 46 using ::testing::SetArrayArgument; 47 using ::testing::SetArgumentPointee; 48 using ::testing::SetArgPointee; 49 using ::testing::StrEq; 50 using ::testing::StrictMock; 51 52 namespace gpu { 53 namespace gles2 { 54 55 using namespace cmds; 56 57 class GLES2DecoderGeometryInstancingTest : public GLES2DecoderWithShaderTest { 58 public: 59 GLES2DecoderGeometryInstancingTest() : GLES2DecoderWithShaderTest() {} 60 61 virtual void SetUp() { 62 InitState init; 63 init.extensions = "GL_ANGLE_instanced_arrays"; 64 init.gl_version = "opengl es 2.0"; 65 init.has_alpha = true; 66 init.has_depth = true; 67 init.request_alpha = true; 68 init.request_depth = true; 69 init.bind_generates_resource = true; 70 InitDecoder(init); 71 SetupDefaultProgram(); 72 } 73 }; 74 75 INSTANTIATE_TEST_CASE_P(Service, 76 GLES2DecoderGeometryInstancingTest, 77 ::testing::Bool()); 78 79 void GLES2DecoderManualInitTest::DirtyStateMaskTest(GLuint color_bits, 80 bool depth_mask, 81 GLuint front_stencil_mask, 82 GLuint back_stencil_mask) { 83 ColorMask color_mask_cmd; 84 color_mask_cmd.Init((color_bits & 0x1000) != 0, 85 (color_bits & 0x0100) != 0, 86 (color_bits & 0x0010) != 0, 87 (color_bits & 0x0001) != 0); 88 EXPECT_EQ(error::kNoError, ExecuteCmd(color_mask_cmd)); 89 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 90 91 DepthMask depth_mask_cmd; 92 depth_mask_cmd.Init(depth_mask); 93 EXPECT_EQ(error::kNoError, ExecuteCmd(depth_mask_cmd)); 94 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 95 96 StencilMaskSeparate front_stencil_mask_cmd; 97 front_stencil_mask_cmd.Init(GL_FRONT, front_stencil_mask); 98 EXPECT_EQ(error::kNoError, ExecuteCmd(front_stencil_mask_cmd)); 99 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 100 101 StencilMaskSeparate back_stencil_mask_cmd; 102 back_stencil_mask_cmd.Init(GL_BACK, back_stencil_mask); 103 EXPECT_EQ(error::kNoError, ExecuteCmd(back_stencil_mask_cmd)); 104 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 105 106 SetupExpectationsForApplyingDirtyState( 107 false, // Framebuffer is RGB 108 true, // Framebuffer has depth 109 true, // Framebuffer has stencil 110 color_bits, // color bits 111 depth_mask, // depth mask 112 false, // depth enabled 113 front_stencil_mask, // front stencil mask 114 back_stencil_mask, // back stencil mask 115 false); // stencil enabled 116 117 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 118 .Times(1) 119 .RetiresOnSaturation(); 120 DrawArrays draw_cmd; 121 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices); 122 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 123 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 124 } 125 126 // Test that with an RGB backbuffer if we set the color mask to 1,1,1,1 it is 127 // set to 1,1,1,0 at Draw time but is 1,1,1,1 at query time. 128 TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMask) { 129 ColorMask cmd; 130 cmd.Init(true, true, true, true); 131 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 132 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 133 134 SetupTexture(); 135 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 136 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB 137 false, // Framebuffer has depth 138 false, // Framebuffer has stencil 139 0x1110, // color bits 140 false, // depth mask 141 false, // depth enabled 142 0, // front stencil mask 143 0, // back stencil mask 144 false); // stencil enabled 145 146 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 147 .Times(1) 148 .RetiresOnSaturation(); 149 DrawArrays draw_cmd; 150 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices); 151 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 152 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 153 154 EXPECT_CALL(*gl_, GetError()) 155 .WillOnce(Return(GL_NO_ERROR)) 156 .WillOnce(Return(GL_NO_ERROR)) 157 .RetiresOnSaturation(); 158 typedef GetIntegerv::Result Result; 159 Result* result = static_cast<Result*>(shared_memory_address_); 160 EXPECT_CALL(*gl_, GetIntegerv(GL_COLOR_WRITEMASK, result->GetData())) 161 .Times(0); 162 result->size = 0; 163 GetIntegerv cmd2; 164 cmd2.Init(GL_COLOR_WRITEMASK, shared_memory_id_, shared_memory_offset_); 165 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2)); 166 EXPECT_EQ( 167 decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_COLOR_WRITEMASK), 168 result->GetNumResults()); 169 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 170 EXPECT_EQ(1, result->GetData()[0]); 171 EXPECT_EQ(1, result->GetData()[1]); 172 EXPECT_EQ(1, result->GetData()[2]); 173 EXPECT_EQ(1, result->GetData()[3]); 174 } 175 176 // Test that with no depth if we set DepthMask true that it's set to false at 177 // draw time but querying it returns true. 178 TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferDepthMask) { 179 EXPECT_CALL(*gl_, DepthMask(true)).Times(0).RetiresOnSaturation(); 180 DepthMask cmd; 181 cmd.Init(true); 182 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 183 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 184 185 SetupTexture(); 186 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 187 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB 188 false, // Framebuffer has depth 189 false, // Framebuffer has stencil 190 0x1110, // color bits 191 false, // depth mask 192 false, // depth enabled 193 0, // front stencil mask 194 0, // back stencil mask 195 false); // stencil enabled 196 197 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 198 .Times(1) 199 .RetiresOnSaturation(); 200 DrawArrays draw_cmd; 201 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices); 202 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 203 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 204 205 EXPECT_CALL(*gl_, GetError()) 206 .WillOnce(Return(GL_NO_ERROR)) 207 .WillOnce(Return(GL_NO_ERROR)) 208 .RetiresOnSaturation(); 209 typedef GetIntegerv::Result Result; 210 Result* result = static_cast<Result*>(shared_memory_address_); 211 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_WRITEMASK, result->GetData())) 212 .Times(0); 213 result->size = 0; 214 GetIntegerv cmd2; 215 cmd2.Init(GL_DEPTH_WRITEMASK, shared_memory_id_, shared_memory_offset_); 216 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2)); 217 EXPECT_EQ( 218 decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_WRITEMASK), 219 result->GetNumResults()); 220 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 221 EXPECT_EQ(1, result->GetData()[0]); 222 } 223 224 // Test that with no stencil if we set the stencil mask it's still set to 0 at 225 // draw time but gets our value if we query. 226 TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferStencilMask) { 227 const GLint kMask = 123; 228 EXPECT_CALL(*gl_, StencilMask(kMask)).Times(0).RetiresOnSaturation(); 229 StencilMask cmd; 230 cmd.Init(kMask); 231 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 232 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 233 234 SetupTexture(); 235 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 236 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB 237 false, // Framebuffer has depth 238 false, // Framebuffer has stencil 239 0x1110, // color bits 240 false, // depth mask 241 false, // depth enabled 242 0, // front stencil mask 243 0, // back stencil mask 244 false); // stencil enabled 245 246 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 247 .Times(1) 248 .RetiresOnSaturation(); 249 DrawArrays draw_cmd; 250 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices); 251 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 252 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 253 254 EXPECT_CALL(*gl_, GetError()) 255 .WillOnce(Return(GL_NO_ERROR)) 256 .WillOnce(Return(GL_NO_ERROR)) 257 .RetiresOnSaturation(); 258 typedef GetIntegerv::Result Result; 259 Result* result = static_cast<Result*>(shared_memory_address_); 260 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_WRITEMASK, result->GetData())) 261 .Times(0); 262 result->size = 0; 263 GetIntegerv cmd2; 264 cmd2.Init(GL_STENCIL_WRITEMASK, shared_memory_id_, shared_memory_offset_); 265 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2)); 266 EXPECT_EQ( 267 decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_WRITEMASK), 268 result->GetNumResults()); 269 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 270 EXPECT_EQ(kMask, result->GetData()[0]); 271 } 272 273 // Test that if an FBO is bound we get the correct masks. 274 TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMaskFBO) { 275 ColorMask cmd; 276 cmd.Init(true, true, true, true); 277 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 278 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 279 280 SetupTexture(); 281 SetupVertexBuffer(); 282 DoEnableVertexAttribArray(0); 283 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0); 284 DoEnableVertexAttribArray(1); 285 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 286 DoEnableVertexAttribArray(2); 287 DoVertexAttribPointer(2, 2, GL_FLOAT, 0, 0); 288 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB 289 false, // Framebuffer has depth 290 false, // Framebuffer has stencil 291 0x1110, // color bits 292 false, // depth mask 293 false, // depth enabled 294 0, // front stencil mask 295 0, // back stencil mask 296 false); // stencil enabled 297 298 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 299 .Times(1) 300 .RetiresOnSaturation(); 301 DrawArrays draw_cmd; 302 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices); 303 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 304 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 305 306 // Check that no extra calls are made on the next draw. 307 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 308 .Times(1) 309 .RetiresOnSaturation(); 310 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 311 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 312 313 // Setup Frame buffer. 314 // needs to be 1x1 or else it's not renderable. 315 const GLsizei kWidth = 1; 316 const GLsizei kHeight = 1; 317 const GLenum kFormat = GL_RGB; 318 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId); 319 // Pass some data so the texture will be marked as cleared. 320 DoTexImage2D(GL_TEXTURE_2D, 321 0, 322 kFormat, 323 kWidth, 324 kHeight, 325 0, 326 kFormat, 327 GL_UNSIGNED_BYTE, 328 kSharedMemoryId, 329 kSharedMemoryOffset); 330 DoBindFramebuffer( 331 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId); 332 DoFramebufferTexture2D(GL_FRAMEBUFFER, 333 GL_COLOR_ATTACHMENT0, 334 GL_TEXTURE_2D, 335 client_texture_id_, 336 kServiceTextureId, 337 0, 338 GL_NO_ERROR); 339 EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER)) 340 .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE)) 341 .RetiresOnSaturation(); 342 343 // This time state needs to be set. 344 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB 345 false, // Framebuffer has depth 346 false, // Framebuffer has stencil 347 0x1110, // color bits 348 false, // depth mask 349 false, // depth enabled 350 0, // front stencil mask 351 0, // back stencil mask 352 false); // stencil enabled 353 354 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 355 .Times(1) 356 .RetiresOnSaturation(); 357 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 358 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 359 360 // Check that no extra calls are made on the next draw. 361 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 362 .Times(1) 363 .RetiresOnSaturation(); 364 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 365 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 366 367 // Unbind 368 DoBindFramebuffer(GL_FRAMEBUFFER, 0, 0); 369 370 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB 371 false, // Framebuffer has depth 372 false, // Framebuffer has stencil 373 0x1110, // color bits 374 false, // depth mask 375 false, // depth enabled 376 0, // front stencil mask 377 0, // back stencil mask 378 false); // stencil enabled 379 380 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 381 .Times(1) 382 .RetiresOnSaturation(); 383 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 384 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 385 } 386 387 TEST_P(GLES2DecoderManualInitTest, DepthEnableWithDepth) { 388 InitState init; 389 init.gl_version = "3.0"; 390 init.has_depth = true; 391 init.request_depth = true; 392 init.bind_generates_resource = true; 393 InitDecoder(init); 394 395 Enable cmd; 396 cmd.Init(GL_DEPTH_TEST); 397 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 398 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 399 400 SetupDefaultProgram(); 401 SetupTexture(); 402 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 403 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB 404 true, // Framebuffer has depth 405 false, // Framebuffer has stencil 406 0x1110, // color bits 407 true, // depth mask 408 true, // depth enabled 409 0, // front stencil mask 410 0, // back stencil mask 411 false); // stencil enabled 412 413 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 414 .Times(1) 415 .RetiresOnSaturation(); 416 DrawArrays draw_cmd; 417 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices); 418 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 419 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 420 421 EXPECT_CALL(*gl_, GetError()) 422 .WillOnce(Return(GL_NO_ERROR)) 423 .WillOnce(Return(GL_NO_ERROR)) 424 .RetiresOnSaturation(); 425 typedef GetIntegerv::Result Result; 426 Result* result = static_cast<Result*>(shared_memory_address_); 427 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_TEST, _)) 428 .Times(0) 429 .RetiresOnSaturation(); 430 result->size = 0; 431 GetIntegerv cmd2; 432 cmd2.Init(GL_DEPTH_TEST, shared_memory_id_, shared_memory_offset_); 433 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2)); 434 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_TEST), 435 result->GetNumResults()); 436 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 437 EXPECT_EQ(1, result->GetData()[0]); 438 } 439 440 TEST_P(GLES2DecoderManualInitTest, DepthEnableWithoutRequestedDepth) { 441 InitState init; 442 init.gl_version = "3.0"; 443 init.has_depth = true; 444 init.bind_generates_resource = true; 445 InitDecoder(init); 446 447 Enable cmd; 448 cmd.Init(GL_DEPTH_TEST); 449 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 450 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 451 452 SetupDefaultProgram(); 453 SetupTexture(); 454 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 455 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB 456 false, // Framebuffer has depth 457 false, // Framebuffer has stencil 458 0x1110, // color bits 459 false, // depth mask 460 false, // depth enabled 461 0, // front stencil mask 462 0, // back stencil mask 463 false); // stencil enabled 464 465 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 466 .Times(1) 467 .RetiresOnSaturation(); 468 DrawArrays draw_cmd; 469 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices); 470 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 471 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 472 473 EXPECT_CALL(*gl_, GetError()) 474 .WillOnce(Return(GL_NO_ERROR)) 475 .WillOnce(Return(GL_NO_ERROR)) 476 .RetiresOnSaturation(); 477 typedef GetIntegerv::Result Result; 478 Result* result = static_cast<Result*>(shared_memory_address_); 479 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_TEST, _)) 480 .Times(0) 481 .RetiresOnSaturation(); 482 result->size = 0; 483 GetIntegerv cmd2; 484 cmd2.Init(GL_DEPTH_TEST, shared_memory_id_, shared_memory_offset_); 485 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2)); 486 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_TEST), 487 result->GetNumResults()); 488 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 489 EXPECT_EQ(1, result->GetData()[0]); 490 } 491 492 TEST_P(GLES2DecoderManualInitTest, StencilEnableWithStencil) { 493 InitState init; 494 init.gl_version = "3.0"; 495 init.has_stencil = true; 496 init.request_stencil = true; 497 init.bind_generates_resource = true; 498 InitDecoder(init); 499 500 Enable cmd; 501 cmd.Init(GL_STENCIL_TEST); 502 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 503 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 504 505 SetupDefaultProgram(); 506 SetupTexture(); 507 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 508 SetupExpectationsForApplyingDirtyState( 509 true, // Framebuffer is RGB 510 false, // Framebuffer has depth 511 true, // Framebuffer has stencil 512 0x1110, // color bits 513 false, // depth mask 514 false, // depth enabled 515 GLES2Decoder::kDefaultStencilMask, // front stencil mask 516 GLES2Decoder::kDefaultStencilMask, // back stencil mask 517 true); // stencil enabled 518 519 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 520 .Times(1) 521 .RetiresOnSaturation(); 522 DrawArrays draw_cmd; 523 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices); 524 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 525 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 526 527 EXPECT_CALL(*gl_, GetError()) 528 .WillOnce(Return(GL_NO_ERROR)) 529 .WillOnce(Return(GL_NO_ERROR)) 530 .RetiresOnSaturation(); 531 typedef GetIntegerv::Result Result; 532 Result* result = static_cast<Result*>(shared_memory_address_); 533 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_TEST, _)) 534 .Times(0) 535 .RetiresOnSaturation(); 536 result->size = 0; 537 GetIntegerv cmd2; 538 cmd2.Init(GL_STENCIL_TEST, shared_memory_id_, shared_memory_offset_); 539 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2)); 540 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_TEST), 541 result->GetNumResults()); 542 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 543 EXPECT_EQ(1, result->GetData()[0]); 544 } 545 546 TEST_P(GLES2DecoderManualInitTest, StencilEnableWithoutRequestedStencil) { 547 InitState init; 548 init.gl_version = "3.0"; 549 init.has_stencil = true; 550 init.bind_generates_resource = true; 551 InitDecoder(init); 552 553 Enable cmd; 554 cmd.Init(GL_STENCIL_TEST); 555 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 556 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 557 558 SetupDefaultProgram(); 559 SetupTexture(); 560 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 561 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB 562 false, // Framebuffer has depth 563 false, // Framebuffer has stencil 564 0x1110, // color bits 565 false, // depth mask 566 false, // depth enabled 567 0, // front stencil mask 568 0, // back stencil mask 569 false); // stencil enabled 570 571 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 572 .Times(1) 573 .RetiresOnSaturation(); 574 DrawArrays draw_cmd; 575 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices); 576 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd)); 577 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 578 579 EXPECT_CALL(*gl_, GetError()) 580 .WillOnce(Return(GL_NO_ERROR)) 581 .WillOnce(Return(GL_NO_ERROR)) 582 .RetiresOnSaturation(); 583 typedef GetIntegerv::Result Result; 584 Result* result = static_cast<Result*>(shared_memory_address_); 585 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_TEST, _)) 586 .Times(0) 587 .RetiresOnSaturation(); 588 result->size = 0; 589 GetIntegerv cmd2; 590 cmd2.Init(GL_STENCIL_TEST, shared_memory_id_, shared_memory_offset_); 591 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2)); 592 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_TEST), 593 result->GetNumResults()); 594 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 595 EXPECT_EQ(1, result->GetData()[0]); 596 } 597 598 TEST_P(GLES2DecoderManualInitTest, CachedColorMask) { 599 InitState init; 600 init.gl_version = "3.0"; 601 init.has_alpha = true; 602 init.has_depth = true; 603 init.has_stencil = true; 604 init.request_alpha = true; 605 init.request_depth = true; 606 init.request_stencil = true; 607 init.bind_generates_resource = true; 608 InitDecoder(init); 609 610 SetupDefaultProgram(); 611 SetupAllNeededVertexBuffers(); 612 SetupTexture(); 613 614 // Test all color_bits combinations twice. 615 for (int i = 0; i < 32; i++) { 616 GLuint color_bits = (i & 1 ? 0x0001 : 0x0000) | (i & 2 ? 0x0010 : 0x0000) | 617 (i & 4 ? 0x0100 : 0x0000) | (i & 8 ? 0x1000 : 0x0000); 618 619 // Toggle depth_test to force ApplyDirtyState each time. 620 DirtyStateMaskTest(color_bits, false, 0xffffffff, 0xffffffff); 621 DirtyStateMaskTest(color_bits, true, 0xffffffff, 0xffffffff); 622 DirtyStateMaskTest(color_bits, false, 0xffffffff, 0xffffffff); 623 } 624 } 625 626 TEST_P(GLES2DecoderManualInitTest, CachedDepthMask) { 627 InitState init; 628 init.gl_version = "3.0"; 629 init.has_alpha = true; 630 init.has_depth = true; 631 init.has_stencil = true; 632 init.request_alpha = true; 633 init.request_depth = true; 634 init.request_stencil = true; 635 init.bind_generates_resource = true; 636 InitDecoder(init); 637 638 SetupDefaultProgram(); 639 SetupAllNeededVertexBuffers(); 640 SetupTexture(); 641 642 // Test all depth_mask combinations twice. 643 for (int i = 0; i < 4; i++) { 644 bool depth_mask = (i & 1) == 1; 645 646 // Toggle color masks to force ApplyDirtyState each time. 647 DirtyStateMaskTest(0x1010, depth_mask, 0xffffffff, 0xffffffff); 648 DirtyStateMaskTest(0x0101, depth_mask, 0xffffffff, 0xffffffff); 649 DirtyStateMaskTest(0x1010, depth_mask, 0xffffffff, 0xffffffff); 650 } 651 } 652 653 TEST_P(GLES2DecoderManualInitTest, CachedStencilMask) { 654 InitState init; 655 init.gl_version = "3.0"; 656 init.has_alpha = true; 657 init.has_depth = true; 658 init.has_stencil = true; 659 init.request_alpha = true; 660 init.request_depth = true; 661 init.request_stencil = true; 662 init.bind_generates_resource = true; 663 InitDecoder(init); 664 665 SetupDefaultProgram(); 666 SetupAllNeededVertexBuffers(); 667 SetupTexture(); 668 669 // Test all stencil_mask combinations twice. 670 for (int i = 0; i < 4; i++) { 671 GLuint stencil_mask = (i & 1) ? 0xf0f0f0f0 : 0x0f0f0f0f; 672 673 // Toggle color masks to force ApplyDirtyState each time. 674 DirtyStateMaskTest(0x1010, true, stencil_mask, 0xffffffff); 675 DirtyStateMaskTest(0x0101, true, stencil_mask, 0xffffffff); 676 DirtyStateMaskTest(0x1010, true, stencil_mask, 0xffffffff); 677 } 678 679 for (int i = 0; i < 4; i++) { 680 GLuint stencil_mask = (i & 1) ? 0xf0f0f0f0 : 0x0f0f0f0f; 681 682 // Toggle color masks to force ApplyDirtyState each time. 683 DirtyStateMaskTest(0x1010, true, 0xffffffff, stencil_mask); 684 DirtyStateMaskTest(0x0101, true, 0xffffffff, stencil_mask); 685 DirtyStateMaskTest(0x1010, true, 0xffffffff, stencil_mask); 686 } 687 } 688 689 TEST_P(GLES2DecoderWithShaderTest, DrawArraysNoAttributesSucceeds) { 690 SetupTexture(); 691 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 692 SetupExpectationsForApplyingDefaultDirtyState(); 693 694 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 695 .Times(1) 696 .RetiresOnSaturation(); 697 DrawArrays cmd; 698 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 699 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 700 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 701 } 702 703 // Tests when the math overflows (0x40000000 * sizeof GLfloat) 704 TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OverflowFails) { 705 const GLsizei kLargeCount = 0x40000000; 706 SetupTexture(); 707 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation(); 708 DrawArrays cmd; 709 cmd.Init(GL_TRIANGLES, 0, kLargeCount); 710 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 711 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError()); 712 EXPECT_FALSE(GetDecoder()->WasContextLost()); 713 } 714 715 // Tests when the math overflows (0x7FFFFFFF + 1 = 0x8000000 verts) 716 TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0PosToNegFails) { 717 const GLsizei kLargeCount = 0x7FFFFFFF; 718 SetupTexture(); 719 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation(); 720 DrawArrays cmd; 721 cmd.Init(GL_TRIANGLES, 0, kLargeCount); 722 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 723 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError()); 724 EXPECT_FALSE(GetDecoder()->WasContextLost()); 725 } 726 727 // Tests when the driver returns an error 728 TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OOMFails) { 729 const GLsizei kFakeLargeCount = 0x1234; 730 SetupTexture(); 731 AddExpectationsForSimulatedAttrib0WithError( 732 kFakeLargeCount, 0, GL_OUT_OF_MEMORY); 733 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation(); 734 DrawArrays cmd; 735 cmd.Init(GL_TRIANGLES, 0, kFakeLargeCount); 736 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 737 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError()); 738 EXPECT_FALSE(GetDecoder()->WasContextLost()); 739 } 740 741 // Test that we lose context. 742 TEST_P(GLES2DecoderManualInitTest, LoseContextWhenOOM) { 743 InitState init; 744 init.gl_version = "3.0"; 745 init.has_alpha = true; 746 init.has_depth = true; 747 init.request_alpha = true; 748 init.request_depth = true; 749 init.bind_generates_resource = true; 750 init.lose_context_when_out_of_memory = true; 751 InitDecoder(init); 752 SetupDefaultProgram(); 753 754 const GLsizei kFakeLargeCount = 0x1234; 755 SetupTexture(); 756 AddExpectationsForSimulatedAttrib0WithError( 757 kFakeLargeCount, 0, GL_OUT_OF_MEMORY); 758 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation(); 759 // Other contexts in the group should be lost also. 760 EXPECT_CALL(*mock_decoder_, LoseContext(GL_UNKNOWN_CONTEXT_RESET_ARB)) 761 .Times(1) 762 .RetiresOnSaturation(); 763 DrawArrays cmd; 764 cmd.Init(GL_TRIANGLES, 0, kFakeLargeCount); 765 // This context should be lost. 766 EXPECT_EQ(error::kLostContext, ExecuteCmd(cmd)); 767 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError()); 768 EXPECT_TRUE(decoder_->WasContextLost()); 769 } 770 771 TEST_P(GLES2DecoderWithShaderTest, DrawArraysBadTextureUsesBlack) { 772 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId); 773 // This is an NPOT texture. As the default filtering requires mips 774 // this should trigger replacing with black textures before rendering. 775 DoTexImage2D(GL_TEXTURE_2D, 776 0, 777 GL_RGBA, 778 3, 779 1, 780 0, 781 GL_RGBA, 782 GL_UNSIGNED_BYTE, 783 kSharedMemoryId, 784 kSharedMemoryOffset); 785 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 786 { 787 InSequence sequence; 788 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0)) 789 .Times(1) 790 .RetiresOnSaturation(); 791 EXPECT_CALL( 792 *gl_, BindTexture(GL_TEXTURE_2D, TestHelper::kServiceBlackTexture2dId)) 793 .Times(1) 794 .RetiresOnSaturation(); 795 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 796 .Times(1) 797 .RetiresOnSaturation(); 798 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0)) 799 .Times(1) 800 .RetiresOnSaturation(); 801 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kServiceTextureId)) 802 .Times(1) 803 .RetiresOnSaturation(); 804 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0)) 805 .Times(1) 806 .RetiresOnSaturation(); 807 } 808 SetupExpectationsForApplyingDefaultDirtyState(); 809 DrawArrays cmd; 810 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 811 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 812 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 813 } 814 815 TEST_P(GLES2DecoderWithShaderTest, DrawArraysMissingAttributesFails) { 816 DoEnableVertexAttribArray(1); 817 818 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0); 819 DrawArrays cmd; 820 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 821 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 822 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 823 } 824 825 TEST_P(GLES2DecoderWithShaderTest, 826 DrawArraysMissingAttributesZeroCountSucceeds) { 827 DoEnableVertexAttribArray(1); 828 829 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0); 830 DrawArrays cmd; 831 cmd.Init(GL_TRIANGLES, 0, 0); 832 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 833 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 834 } 835 836 TEST_P(GLES2DecoderWithShaderTest, DrawArraysValidAttributesSucceeds) { 837 SetupTexture(); 838 SetupVertexBuffer(); 839 DoEnableVertexAttribArray(1); 840 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 841 AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId); 842 SetupExpectationsForApplyingDefaultDirtyState(); 843 844 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 845 .Times(1) 846 .RetiresOnSaturation(); 847 DrawArrays cmd; 848 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 849 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 850 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 851 } 852 853 // Same as DrawArraysValidAttributesSucceeds, but with workaround 854 // |init_vertex_attributes|. 855 TEST_P(GLES2DecoderManualInitTest, InitVertexAttributes) { 856 CommandLine command_line(0, NULL); 857 command_line.AppendSwitchASCII( 858 switches::kGpuDriverBugWorkarounds, 859 base::IntToString(gpu::INIT_VERTEX_ATTRIBUTES)); 860 InitState init; 861 init.gl_version = "3.0"; 862 init.has_alpha = true; 863 init.has_depth = true; 864 init.request_alpha = true; 865 init.request_depth = true; 866 init.bind_generates_resource = true; 867 InitDecoderWithCommandLine(init, &command_line); 868 SetupDefaultProgram(); 869 SetupTexture(); 870 SetupVertexBuffer(); 871 DoEnableVertexAttribArray(1); 872 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 873 AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId); 874 SetupExpectationsForApplyingDefaultDirtyState(); 875 876 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 877 .Times(1) 878 .RetiresOnSaturation(); 879 DrawArrays cmd; 880 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 881 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 882 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 883 } 884 885 TEST_P(GLES2DecoderWithShaderTest, DrawArraysDeletedBufferFails) { 886 SetupVertexBuffer(); 887 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 888 DeleteVertexBuffer(); 889 890 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0); 891 DrawArrays cmd; 892 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 893 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 894 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 895 } 896 897 TEST_P(GLES2DecoderWithShaderTest, DrawArraysDeletedProgramSucceeds) { 898 SetupTexture(); 899 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 900 SetupExpectationsForApplyingDefaultDirtyState(); 901 DoDeleteProgram(client_program_id_, kServiceProgramId); 902 903 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(1).RetiresOnSaturation(); 904 EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId)).Times(1); 905 DrawArrays cmd; 906 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 907 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 908 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 909 } 910 911 TEST_P(GLES2DecoderWithShaderTest, DrawArraysWithInvalidModeFails) { 912 SetupVertexBuffer(); 913 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 914 915 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0); 916 DrawArrays cmd; 917 cmd.Init(GL_QUADS, 0, 1); 918 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 919 EXPECT_EQ(GL_INVALID_ENUM, GetGLError()); 920 cmd.Init(GL_POLYGON, 0, 1); 921 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 922 EXPECT_EQ(GL_INVALID_ENUM, GetGLError()); 923 } 924 925 TEST_P(GLES2DecoderWithShaderTest, DrawArraysInvalidCountFails) { 926 SetupVertexBuffer(); 927 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 928 929 // Try start > 0 930 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0); 931 DrawArrays cmd; 932 cmd.Init(GL_TRIANGLES, 1, kNumVertices); 933 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 934 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 935 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 936 937 // Try with count > size 938 cmd.Init(GL_TRIANGLES, 0, kNumVertices + 1); 939 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 940 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 941 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 942 943 // Try with attrib offset > 0 944 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 945 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 4); 946 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 947 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 948 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 949 950 // Try with size > 2 (ie, vec3 instead of vec2) 951 DoVertexAttribPointer(1, 3, GL_FLOAT, 0, 0); 952 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 953 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 954 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 955 956 // Try with stride > 8 (vec2 + vec2 byte) 957 DoVertexAttribPointer(1, 2, GL_FLOAT, sizeof(GLfloat) * 3, 0); 958 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 959 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 960 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 961 } 962 963 TEST_P(GLES2DecoderWithShaderTest, DrawArraysInstancedANGLEFails) { 964 SetupTexture(); 965 SetupVertexBuffer(); 966 DoEnableVertexAttribArray(1); 967 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 968 969 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)) 970 .Times(0) 971 .RetiresOnSaturation(); 972 DrawArraysInstancedANGLE cmd; 973 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1); 974 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 975 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 976 } 977 978 TEST_P(GLES2DecoderWithShaderTest, VertexAttribDivisorANGLEFails) { 979 SetupTexture(); 980 SetupVertexBuffer(); 981 DoEnableVertexAttribArray(1); 982 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 983 984 EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(_, _)) 985 .Times(0) 986 .RetiresOnSaturation(); 987 988 VertexAttribDivisorANGLE cmd; 989 cmd.Init(0, 1); 990 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 991 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 992 } 993 994 TEST_P(GLES2DecoderGeometryInstancingTest, 995 DrawArraysInstancedANGLENoAttributesFails) { 996 SetupTexture(); 997 998 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)) 999 .Times(0) 1000 .RetiresOnSaturation(); 1001 DrawArraysInstancedANGLE cmd; 1002 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1); 1003 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1004 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1005 } 1006 1007 TEST_P(GLES2DecoderGeometryInstancingTest, 1008 DrawArraysInstancedANGLESimulatedAttrib0) { 1009 SetupTexture(); 1010 SetupVertexBuffer(); 1011 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1012 1013 AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId); 1014 SetupExpectationsForApplyingDefaultDirtyState(); 1015 1016 DoVertexAttribDivisorANGLE(0, 1); 1017 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices, 3)) 1018 .Times(1) 1019 .RetiresOnSaturation(); 1020 EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 0)) 1021 .Times(1) 1022 .RetiresOnSaturation(); 1023 EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 1)) 1024 .Times(1) 1025 .RetiresOnSaturation(); 1026 DrawArraysInstancedANGLE cmd; 1027 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 3); 1028 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1029 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1030 } 1031 1032 TEST_P(GLES2DecoderGeometryInstancingTest, 1033 DrawArraysInstancedANGLEMissingAttributesFails) { 1034 DoEnableVertexAttribArray(1); 1035 1036 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)).Times(0); 1037 DrawArraysInstancedANGLE cmd; 1038 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1); 1039 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1040 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1041 } 1042 1043 TEST_P(GLES2DecoderGeometryInstancingTest, 1044 DrawArraysInstancedANGLEMissingAttributesZeroCountSucceeds) { 1045 DoEnableVertexAttribArray(1); 1046 1047 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)).Times(0); 1048 DrawArraysInstancedANGLE cmd; 1049 cmd.Init(GL_TRIANGLES, 0, 0, 1); 1050 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1051 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1052 } 1053 1054 TEST_P(GLES2DecoderGeometryInstancingTest, 1055 DrawArraysInstancedANGLEValidAttributesSucceeds) { 1056 SetupTexture(); 1057 SetupVertexBuffer(); 1058 DoEnableVertexAttribArray(1); 1059 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1060 AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId); 1061 SetupExpectationsForApplyingDefaultDirtyState(); 1062 1063 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices, 1)) 1064 .Times(1) 1065 .RetiresOnSaturation(); 1066 DrawArraysInstancedANGLE cmd; 1067 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1); 1068 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1069 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1070 } 1071 1072 TEST_P(GLES2DecoderGeometryInstancingTest, 1073 DrawArraysInstancedANGLEWithInvalidModeFails) { 1074 SetupVertexBuffer(); 1075 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1076 1077 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)).Times(0); 1078 DrawArraysInstancedANGLE cmd; 1079 cmd.Init(GL_QUADS, 0, 1, 1); 1080 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1081 EXPECT_EQ(GL_INVALID_ENUM, GetGLError()); 1082 cmd.Init(GL_POLYGON, 0, 1, 1); 1083 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1084 EXPECT_EQ(GL_INVALID_ENUM, GetGLError()); 1085 } 1086 1087 TEST_P(GLES2DecoderGeometryInstancingTest, 1088 DrawArraysInstancedANGLEInvalidPrimcountFails) { 1089 SetupVertexBuffer(); 1090 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1091 1092 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)).Times(0); 1093 DrawArraysInstancedANGLE cmd; 1094 cmd.Init(GL_TRIANGLES, 0, 1, -1); 1095 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1096 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); 1097 } 1098 1099 // Per-instance data is twice as large, but number of instances is half 1100 TEST_P(GLES2DecoderGeometryInstancingTest, 1101 DrawArraysInstancedANGLELargeInstanceSucceeds) { 1102 SetupTexture(); 1103 SetupVertexBuffer(); 1104 SetupExpectationsForApplyingDefaultDirtyState(); 1105 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1106 1107 DoEnableVertexAttribArray(0); 1108 DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0); 1109 DoVertexAttribDivisorANGLE(0, 1); 1110 EXPECT_CALL( 1111 *gl_, 1112 DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices, kNumVertices / 2)) 1113 .Times(1) 1114 .RetiresOnSaturation(); 1115 DrawArraysInstancedANGLE cmd; 1116 cmd.Init(GL_TRIANGLES, 0, kNumVertices, kNumVertices / 2); 1117 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1118 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1119 } 1120 1121 // Regular drawArrays takes the divisor into account 1122 TEST_P(GLES2DecoderGeometryInstancingTest, 1123 DrawArraysWithDivisorSucceeds) { 1124 SetupTexture(); 1125 SetupVertexBuffer(); 1126 SetupExpectationsForApplyingDefaultDirtyState(); 1127 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1128 1129 DoEnableVertexAttribArray(0); 1130 // Access the data right at the end of the buffer. 1131 DoVertexAttribPointer( 1132 0, 2, GL_FLOAT, 0, (kNumVertices - 1) * 2 * sizeof(GLfloat)); 1133 DoVertexAttribDivisorANGLE(0, 1); 1134 EXPECT_CALL( 1135 *gl_, 1136 DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 1137 .Times(1) 1138 .RetiresOnSaturation(); 1139 DrawArrays cmd; 1140 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 1141 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1142 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1143 } 1144 1145 // Per-instance data is twice as large, but divisor is twice 1146 TEST_P(GLES2DecoderGeometryInstancingTest, 1147 DrawArraysInstancedANGLELargeDivisorSucceeds) { 1148 SetupTexture(); 1149 SetupVertexBuffer(); 1150 SetupExpectationsForApplyingDefaultDirtyState(); 1151 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1152 1153 DoEnableVertexAttribArray(0); 1154 DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0); 1155 DoVertexAttribDivisorANGLE(0, 2); 1156 EXPECT_CALL( 1157 *gl_, 1158 DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices, kNumVertices)) 1159 .Times(1) 1160 .RetiresOnSaturation(); 1161 DrawArraysInstancedANGLE cmd; 1162 cmd.Init(GL_TRIANGLES, 0, kNumVertices, kNumVertices); 1163 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1164 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1165 } 1166 1167 TEST_P(GLES2DecoderGeometryInstancingTest, DrawArraysInstancedANGLELargeFails) { 1168 SetupTexture(); 1169 SetupVertexBuffer(); 1170 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1171 1172 DoEnableVertexAttribArray(0); 1173 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0); 1174 DoVertexAttribDivisorANGLE(0, 1); 1175 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)) 1176 .Times(0) 1177 .RetiresOnSaturation(); 1178 DrawArraysInstancedANGLE cmd; 1179 cmd.Init(GL_TRIANGLES, 0, kNumVertices, kNumVertices + 1); 1180 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1181 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1182 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1183 1184 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)) 1185 .Times(0) 1186 .RetiresOnSaturation(); 1187 cmd.Init(GL_TRIANGLES, 0, kNumVertices + 1, kNumVertices); 1188 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1189 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1190 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1191 } 1192 1193 // Per-index data is twice as large, but number of indices is half 1194 TEST_P(GLES2DecoderGeometryInstancingTest, 1195 DrawArraysInstancedANGLELargeIndexSucceeds) { 1196 SetupTexture(); 1197 SetupVertexBuffer(); 1198 SetupExpectationsForApplyingDefaultDirtyState(); 1199 DoVertexAttribPointer(1, 4, GL_FLOAT, 0, 0); 1200 1201 DoEnableVertexAttribArray(0); 1202 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0); 1203 DoVertexAttribDivisorANGLE(0, 1); 1204 EXPECT_CALL( 1205 *gl_, 1206 DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices / 2, kNumVertices)) 1207 .Times(1) 1208 .RetiresOnSaturation(); 1209 DrawArraysInstancedANGLE cmd; 1210 cmd.Init(GL_TRIANGLES, 0, kNumVertices / 2, kNumVertices); 1211 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1212 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1213 } 1214 1215 TEST_P(GLES2DecoderGeometryInstancingTest, 1216 DrawArraysInstancedANGLENoDivisor0Fails) { 1217 SetupTexture(); 1218 SetupVertexBuffer(); 1219 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1220 1221 DoEnableVertexAttribArray(0); 1222 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0); 1223 DoVertexAttribDivisorANGLE(0, 1); 1224 DoVertexAttribDivisorANGLE(1, 1); 1225 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)) 1226 .Times(0) 1227 .RetiresOnSaturation(); 1228 DrawArraysInstancedANGLE cmd; 1229 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1); 1230 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1231 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1232 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1233 } 1234 1235 TEST_P(GLES2DecoderGeometryInstancingTest, 1236 DrawArraysNoDivisor0Fails) { 1237 SetupTexture(); 1238 SetupVertexBuffer(); 1239 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1240 1241 DoEnableVertexAttribArray(0); 1242 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0); 1243 DoVertexAttribDivisorANGLE(0, 1); 1244 DoVertexAttribDivisorANGLE(1, 1); 1245 EXPECT_CALL(*gl_, DrawArrays(_, _, _)) 1246 .Times(0) 1247 .RetiresOnSaturation(); 1248 DrawArrays cmd; 1249 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 1250 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1251 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1252 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1253 } 1254 1255 TEST_P(GLES2DecoderWithShaderTest, DrawElementsNoAttributesSucceeds) { 1256 SetupTexture(); 1257 SetupIndexBuffer(); 1258 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, 0); 1259 SetupExpectationsForApplyingDefaultDirtyState(); 1260 EXPECT_CALL(*gl_, 1261 DrawElements(GL_TRIANGLES, 1262 kValidIndexRangeCount, 1263 GL_UNSIGNED_SHORT, 1264 BufferOffset(kValidIndexRangeStart * 2))) 1265 .Times(1) 1266 .RetiresOnSaturation(); 1267 DrawElements cmd; 1268 cmd.Init(GL_TRIANGLES, 1269 kValidIndexRangeCount, 1270 GL_UNSIGNED_SHORT, 1271 kValidIndexRangeStart * 2); 1272 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1273 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1274 } 1275 1276 TEST_P(GLES2DecoderWithShaderTest, DrawElementsMissingAttributesFails) { 1277 SetupIndexBuffer(); 1278 DoEnableVertexAttribArray(1); 1279 1280 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0); 1281 DrawElements cmd; 1282 cmd.Init(GL_TRIANGLES, 1283 kValidIndexRangeCount, 1284 GL_UNSIGNED_SHORT, 1285 kValidIndexRangeStart * 2); 1286 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1287 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1288 } 1289 1290 TEST_P(GLES2DecoderWithShaderTest, 1291 DrawElementsMissingAttributesZeroCountSucceeds) { 1292 SetupIndexBuffer(); 1293 DoEnableVertexAttribArray(1); 1294 1295 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0); 1296 DrawElements cmd; 1297 cmd.Init(GL_TRIANGLES, 0, GL_UNSIGNED_SHORT, kValidIndexRangeStart * 2); 1298 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1299 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1300 } 1301 1302 TEST_P(GLES2DecoderWithShaderTest, DrawElementsExtraAttributesFails) { 1303 SetupIndexBuffer(); 1304 DoEnableVertexAttribArray(6); 1305 1306 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0); 1307 DrawElements cmd; 1308 cmd.Init(GL_TRIANGLES, 1309 kValidIndexRangeCount, 1310 GL_UNSIGNED_SHORT, 1311 kValidIndexRangeStart * 2); 1312 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1313 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1314 } 1315 1316 TEST_P(GLES2DecoderWithShaderTest, DrawElementsValidAttributesSucceeds) { 1317 SetupTexture(); 1318 SetupVertexBuffer(); 1319 SetupIndexBuffer(); 1320 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1321 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, kServiceBufferId); 1322 SetupExpectationsForApplyingDefaultDirtyState(); 1323 1324 EXPECT_CALL(*gl_, 1325 DrawElements(GL_TRIANGLES, 1326 kValidIndexRangeCount, 1327 GL_UNSIGNED_SHORT, 1328 BufferOffset(kValidIndexRangeStart * 2))) 1329 .Times(1) 1330 .RetiresOnSaturation(); 1331 DrawElements cmd; 1332 cmd.Init(GL_TRIANGLES, 1333 kValidIndexRangeCount, 1334 GL_UNSIGNED_SHORT, 1335 kValidIndexRangeStart * 2); 1336 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1337 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1338 } 1339 1340 TEST_P(GLES2DecoderWithShaderTest, DrawElementsDeletedBufferFails) { 1341 SetupVertexBuffer(); 1342 SetupIndexBuffer(); 1343 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1344 DeleteIndexBuffer(); 1345 1346 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0); 1347 DrawElements cmd; 1348 cmd.Init(GL_TRIANGLES, 1349 kValidIndexRangeCount, 1350 GL_UNSIGNED_SHORT, 1351 kValidIndexRangeStart * 2); 1352 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1353 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1354 } 1355 1356 TEST_P(GLES2DecoderWithShaderTest, DrawElementsDeletedProgramSucceeds) { 1357 SetupTexture(); 1358 SetupIndexBuffer(); 1359 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, 0); 1360 SetupExpectationsForApplyingDefaultDirtyState(); 1361 DoDeleteProgram(client_program_id_, kServiceProgramId); 1362 1363 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(1); 1364 EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId)).Times(1); 1365 DrawElements cmd; 1366 cmd.Init(GL_TRIANGLES, 1367 kValidIndexRangeCount, 1368 GL_UNSIGNED_SHORT, 1369 kValidIndexRangeStart * 2); 1370 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1371 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1372 } 1373 1374 TEST_P(GLES2DecoderWithShaderTest, DrawElementsWithInvalidModeFails) { 1375 SetupVertexBuffer(); 1376 SetupIndexBuffer(); 1377 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1378 1379 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0); 1380 DrawElements cmd; 1381 cmd.Init(GL_QUADS, 1382 kValidIndexRangeCount, 1383 GL_UNSIGNED_SHORT, 1384 kValidIndexRangeStart * 2); 1385 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1386 EXPECT_EQ(GL_INVALID_ENUM, GetGLError()); 1387 cmd.Init(GL_POLYGON, 1388 kValidIndexRangeCount, 1389 GL_UNSIGNED_SHORT, 1390 kValidIndexRangeStart); 1391 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1392 EXPECT_EQ(GL_INVALID_ENUM, GetGLError()); 1393 } 1394 1395 TEST_P(GLES2DecoderWithShaderTest, DrawElementsInvalidCountFails) { 1396 SetupVertexBuffer(); 1397 SetupIndexBuffer(); 1398 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1399 1400 // Try start > 0 1401 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0); 1402 DrawElements cmd; 1403 cmd.Init(GL_TRIANGLES, kNumIndices, GL_UNSIGNED_SHORT, 2); 1404 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1405 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1406 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1407 1408 // Try with count > size 1409 cmd.Init(GL_TRIANGLES, kNumIndices + 1, GL_UNSIGNED_SHORT, 0); 1410 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1411 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1412 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1413 } 1414 1415 TEST_P(GLES2DecoderWithShaderTest, DrawElementsOutOfRangeIndicesFails) { 1416 SetupVertexBuffer(); 1417 SetupIndexBuffer(); 1418 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1419 1420 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0); 1421 DrawElements cmd; 1422 cmd.Init(GL_TRIANGLES, 1423 kInvalidIndexRangeCount, 1424 GL_UNSIGNED_SHORT, 1425 kInvalidIndexRangeStart * 2); 1426 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1427 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1428 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1429 } 1430 1431 TEST_P(GLES2DecoderWithShaderTest, DrawElementsOddOffsetForUint16Fails) { 1432 SetupVertexBuffer(); 1433 SetupIndexBuffer(); 1434 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1435 1436 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0); 1437 DrawElements cmd; 1438 cmd.Init(GL_TRIANGLES, kInvalidIndexRangeCount, GL_UNSIGNED_SHORT, 1); 1439 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1440 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1441 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1442 } 1443 1444 TEST_P(GLES2DecoderWithShaderTest, DrawElementsInstancedANGLEFails) { 1445 SetupTexture(); 1446 SetupVertexBuffer(); 1447 SetupIndexBuffer(); 1448 DoEnableVertexAttribArray(1); 1449 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1450 1451 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)) 1452 .Times(0) 1453 .RetiresOnSaturation(); 1454 DrawElementsInstancedANGLE cmd; 1455 cmd.Init(GL_TRIANGLES, 1456 kValidIndexRangeCount, 1457 GL_UNSIGNED_SHORT, 1458 kValidIndexRangeStart * 2, 1459 1); 1460 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1461 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1462 } 1463 1464 TEST_P(GLES2DecoderGeometryInstancingTest, 1465 DrawElementsInstancedANGLENoAttributesFails) { 1466 SetupTexture(); 1467 SetupIndexBuffer(); 1468 1469 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)) 1470 .Times(0) 1471 .RetiresOnSaturation(); 1472 DrawElementsInstancedANGLE cmd; 1473 cmd.Init(GL_TRIANGLES, 1474 kValidIndexRangeCount, 1475 GL_UNSIGNED_SHORT, 1476 kValidIndexRangeStart * 2, 1477 1); 1478 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1479 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1480 } 1481 1482 TEST_P(GLES2DecoderGeometryInstancingTest, 1483 DrawElementsInstancedANGLESimulatedAttrib0) { 1484 SetupTexture(); 1485 SetupVertexBuffer(); 1486 SetupIndexBuffer(); 1487 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1488 1489 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, kServiceBufferId); 1490 SetupExpectationsForApplyingDefaultDirtyState(); 1491 1492 DoVertexAttribDivisorANGLE(0, 1); 1493 EXPECT_CALL( 1494 *gl_, 1495 DrawElementsInstancedANGLE(GL_TRIANGLES, 1496 kValidIndexRangeCount, 1497 GL_UNSIGNED_SHORT, 1498 BufferOffset(kValidIndexRangeStart * 2), 1499 3)) 1500 .Times(1) 1501 .RetiresOnSaturation(); 1502 EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 0)) 1503 .Times(1) 1504 .RetiresOnSaturation(); 1505 EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 1)) 1506 .Times(1) 1507 .RetiresOnSaturation(); 1508 DrawElementsInstancedANGLE cmd; 1509 cmd.Init(GL_TRIANGLES, 1510 kValidIndexRangeCount, 1511 GL_UNSIGNED_SHORT, 1512 kValidIndexRangeStart * 2, 1513 3); 1514 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1515 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1516 } 1517 1518 TEST_P(GLES2DecoderGeometryInstancingTest, 1519 DrawElementsInstancedANGLEMissingAttributesFails) { 1520 SetupIndexBuffer(); 1521 DoEnableVertexAttribArray(1); 1522 1523 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)).Times(0); 1524 DrawElementsInstancedANGLE cmd; 1525 cmd.Init(GL_TRIANGLES, 1526 kValidIndexRangeCount, 1527 GL_UNSIGNED_SHORT, 1528 kValidIndexRangeStart * 2, 1529 1); 1530 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1531 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1532 } 1533 1534 TEST_P(GLES2DecoderGeometryInstancingTest, 1535 DrawElementsInstancedANGLEMissingAttributesZeroCountSucceeds) { 1536 SetupIndexBuffer(); 1537 DoEnableVertexAttribArray(1); 1538 1539 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)).Times(0); 1540 DrawElementsInstancedANGLE cmd; 1541 cmd.Init(GL_TRIANGLES, 0, GL_UNSIGNED_SHORT, kValidIndexRangeStart * 2, 1); 1542 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1543 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1544 } 1545 1546 TEST_P(GLES2DecoderGeometryInstancingTest, 1547 DrawElementsInstancedANGLEValidAttributesSucceeds) { 1548 SetupIndexBuffer(); 1549 SetupTexture(); 1550 SetupVertexBuffer(); 1551 DoEnableVertexAttribArray(1); 1552 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1553 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, kServiceBufferId); 1554 SetupExpectationsForApplyingDefaultDirtyState(); 1555 1556 EXPECT_CALL( 1557 *gl_, 1558 DrawElementsInstancedANGLE(GL_TRIANGLES, 1559 kValidIndexRangeCount, 1560 GL_UNSIGNED_SHORT, 1561 BufferOffset(kValidIndexRangeStart * 2), 1562 1)) 1563 .Times(1) 1564 .RetiresOnSaturation(); 1565 DrawElementsInstancedANGLE cmd; 1566 cmd.Init(GL_TRIANGLES, 1567 kValidIndexRangeCount, 1568 GL_UNSIGNED_SHORT, 1569 kValidIndexRangeStart * 2, 1570 1); 1571 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1572 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1573 } 1574 1575 TEST_P(GLES2DecoderGeometryInstancingTest, 1576 DrawElementsInstancedANGLEWithInvalidModeFails) { 1577 SetupIndexBuffer(); 1578 SetupVertexBuffer(); 1579 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1580 1581 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)).Times(0); 1582 DrawElementsInstancedANGLE cmd; 1583 cmd.Init(GL_QUADS, 1584 kValidIndexRangeCount, 1585 GL_UNSIGNED_SHORT, 1586 kValidIndexRangeStart * 2, 1587 1); 1588 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1589 EXPECT_EQ(GL_INVALID_ENUM, GetGLError()); 1590 cmd.Init(GL_INVALID_ENUM, 1591 kValidIndexRangeCount, 1592 GL_UNSIGNED_SHORT, 1593 kValidIndexRangeStart * 2, 1594 1); 1595 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1596 EXPECT_EQ(GL_INVALID_ENUM, GetGLError()); 1597 } 1598 1599 // Per-instance data is twice as large, but number of instances is half 1600 TEST_P(GLES2DecoderGeometryInstancingTest, 1601 DrawElementsInstancedANGLELargeInstanceSucceeds) { 1602 SetupTexture(); 1603 SetupIndexBuffer(); 1604 SetupVertexBuffer(); 1605 SetupExpectationsForApplyingDefaultDirtyState(); 1606 // Add offset so we're sure we're accessing data near the end of the buffer. 1607 DoVertexAttribPointer( 1608 1, 1609 2, 1610 GL_FLOAT, 1611 0, 1612 (kNumVertices - kMaxValidIndex - 1) * 2 * sizeof(GLfloat)); 1613 1614 DoEnableVertexAttribArray(0); 1615 DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0); 1616 DoVertexAttribDivisorANGLE(0, 1); 1617 EXPECT_CALL( 1618 *gl_, 1619 DrawElementsInstancedANGLE(GL_TRIANGLES, 1620 kValidIndexRangeCount, 1621 GL_UNSIGNED_SHORT, 1622 BufferOffset(kValidIndexRangeStart * 2), 1623 kNumVertices / 2)) 1624 .Times(1) 1625 .RetiresOnSaturation(); 1626 DrawElementsInstancedANGLE cmd; 1627 cmd.Init(GL_TRIANGLES, 1628 kValidIndexRangeCount, 1629 GL_UNSIGNED_SHORT, 1630 kValidIndexRangeStart * 2, 1631 kNumVertices / 2); 1632 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1633 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1634 } 1635 1636 // Regular drawElements takes the divisor into account 1637 TEST_P(GLES2DecoderGeometryInstancingTest, 1638 DrawElementsWithDivisorSucceeds) { 1639 SetupTexture(); 1640 SetupIndexBuffer(); 1641 SetupVertexBuffer(); 1642 SetupExpectationsForApplyingDefaultDirtyState(); 1643 // Add offset so we're sure we're accessing data near the end of the buffer. 1644 DoVertexAttribPointer( 1645 1, 1646 2, 1647 GL_FLOAT, 1648 0, 1649 (kNumVertices - kMaxValidIndex - 1) * 2 * sizeof(GLfloat)); 1650 1651 DoEnableVertexAttribArray(0); 1652 // Access the data right at the end of the buffer. 1653 DoVertexAttribPointer( 1654 0, 2, GL_FLOAT, 0, (kNumVertices - 1) * 2 * sizeof(GLfloat)); 1655 DoVertexAttribDivisorANGLE(0, 1); 1656 EXPECT_CALL( 1657 *gl_, 1658 DrawElements(GL_TRIANGLES, 1659 kValidIndexRangeCount, 1660 GL_UNSIGNED_SHORT, 1661 BufferOffset(kValidIndexRangeStart * 2))) 1662 .Times(1) 1663 .RetiresOnSaturation(); 1664 DrawElements cmd; 1665 cmd.Init(GL_TRIANGLES, 1666 kValidIndexRangeCount, 1667 GL_UNSIGNED_SHORT, 1668 kValidIndexRangeStart * 2); 1669 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1670 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1671 } 1672 1673 // Per-instance data is twice as large, but divisor is twice 1674 TEST_P(GLES2DecoderGeometryInstancingTest, 1675 DrawElementsInstancedANGLELargeDivisorSucceeds) { 1676 SetupTexture(); 1677 SetupIndexBuffer(); 1678 SetupVertexBuffer(); 1679 SetupExpectationsForApplyingDefaultDirtyState(); 1680 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1681 1682 DoEnableVertexAttribArray(0); 1683 DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0); 1684 DoVertexAttribDivisorANGLE(0, 2); 1685 EXPECT_CALL( 1686 *gl_, 1687 DrawElementsInstancedANGLE(GL_TRIANGLES, 1688 kValidIndexRangeCount, 1689 GL_UNSIGNED_SHORT, 1690 BufferOffset(kValidIndexRangeStart * 2), 1691 kNumVertices)) 1692 .Times(1) 1693 .RetiresOnSaturation(); 1694 DrawElementsInstancedANGLE cmd; 1695 cmd.Init(GL_TRIANGLES, 1696 kValidIndexRangeCount, 1697 GL_UNSIGNED_SHORT, 1698 kValidIndexRangeStart * 2, 1699 kNumVertices); 1700 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1701 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1702 } 1703 1704 TEST_P(GLES2DecoderGeometryInstancingTest, 1705 DrawElementsInstancedANGLELargeFails) { 1706 SetupTexture(); 1707 SetupIndexBuffer(); 1708 SetupVertexBuffer(); 1709 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1710 1711 DoEnableVertexAttribArray(0); 1712 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0); 1713 DoVertexAttribDivisorANGLE(0, 1); 1714 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)) 1715 .Times(0) 1716 .RetiresOnSaturation(); 1717 DrawElementsInstancedANGLE cmd; 1718 cmd.Init(GL_TRIANGLES, 1719 kValidIndexRangeCount, 1720 GL_UNSIGNED_SHORT, 1721 kValidIndexRangeStart * 2, 1722 kNumVertices + 1); 1723 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1724 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1725 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1726 1727 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)) 1728 .Times(0) 1729 .RetiresOnSaturation(); 1730 cmd.Init(GL_TRIANGLES, 1731 kInvalidIndexRangeCount, 1732 GL_UNSIGNED_SHORT, 1733 kInvalidIndexRangeStart * 2, 1734 kNumVertices); 1735 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1736 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1737 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1738 } 1739 1740 TEST_P(GLES2DecoderGeometryInstancingTest, 1741 DrawElementsInstancedANGLEInvalidPrimcountFails) { 1742 SetupTexture(); 1743 SetupIndexBuffer(); 1744 SetupVertexBuffer(); 1745 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1746 1747 DoEnableVertexAttribArray(0); 1748 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0); 1749 DoVertexAttribDivisorANGLE(0, 1); 1750 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)) 1751 .Times(0) 1752 .RetiresOnSaturation(); 1753 DrawElementsInstancedANGLE cmd; 1754 cmd.Init(GL_TRIANGLES, 1755 kValidIndexRangeCount, 1756 GL_UNSIGNED_SHORT, 1757 kValidIndexRangeStart * 2, 1758 -1); 1759 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1760 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); 1761 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1762 } 1763 1764 // Per-index data is twice as large, but values of indices are smaller 1765 TEST_P(GLES2DecoderGeometryInstancingTest, 1766 DrawElementsInstancedANGLELargeIndexSucceeds) { 1767 SetupTexture(); 1768 SetupIndexBuffer(); 1769 SetupVertexBuffer(); 1770 SetupExpectationsForApplyingDefaultDirtyState(); 1771 DoVertexAttribPointer(1, 4, GL_FLOAT, 0, 0); 1772 1773 DoEnableVertexAttribArray(0); 1774 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0); 1775 DoVertexAttribDivisorANGLE(0, 1); 1776 EXPECT_CALL( 1777 *gl_, 1778 DrawElementsInstancedANGLE(GL_TRIANGLES, 1779 kValidIndexRangeCount, 1780 GL_UNSIGNED_SHORT, 1781 BufferOffset(kValidIndexRangeStart * 2), 1782 kNumVertices)) 1783 .Times(1) 1784 .RetiresOnSaturation(); 1785 DrawElementsInstancedANGLE cmd; 1786 cmd.Init(GL_TRIANGLES, 1787 kValidIndexRangeCount, 1788 GL_UNSIGNED_SHORT, 1789 kValidIndexRangeStart * 2, 1790 kNumVertices); 1791 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1792 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1793 } 1794 1795 TEST_P(GLES2DecoderGeometryInstancingTest, 1796 DrawElementsInstancedANGLENoDivisor0Fails) { 1797 SetupTexture(); 1798 SetupIndexBuffer(); 1799 SetupVertexBuffer(); 1800 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1801 1802 DoEnableVertexAttribArray(0); 1803 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0); 1804 DoVertexAttribDivisorANGLE(0, 1); 1805 DoVertexAttribDivisorANGLE(1, 1); 1806 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)) 1807 .Times(0) 1808 .RetiresOnSaturation(); 1809 DrawElementsInstancedANGLE cmd; 1810 cmd.Init(GL_TRIANGLES, 1811 kValidIndexRangeCount, 1812 GL_UNSIGNED_SHORT, 1813 kValidIndexRangeStart * 2, 1814 kNumVertices); 1815 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1816 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1817 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1818 } 1819 1820 TEST_P(GLES2DecoderGeometryInstancingTest, 1821 DrawElementsNoDivisor0Fails) { 1822 SetupTexture(); 1823 SetupIndexBuffer(); 1824 SetupVertexBuffer(); 1825 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0); 1826 1827 DoEnableVertexAttribArray(0); 1828 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0); 1829 DoVertexAttribDivisorANGLE(0, 1); 1830 DoVertexAttribDivisorANGLE(1, 1); 1831 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)) 1832 .Times(0) 1833 .RetiresOnSaturation(); 1834 DrawElements cmd; 1835 cmd.Init(GL_TRIANGLES, 1836 kValidIndexRangeCount, 1837 GL_UNSIGNED_SHORT, 1838 kValidIndexRangeStart * 2); 1839 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1840 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); 1841 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1842 } 1843 1844 TEST_P(GLES2DecoderWithShaderTest, DrawArraysClearsAfterTexImage2DNULL) { 1845 SetupAllNeededVertexBuffers(); 1846 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId); 1847 // Create an uncleared texture with 2 levels. 1848 DoTexImage2D( 1849 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0); 1850 DoTexImage2D( 1851 GL_TEXTURE_2D, 1, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0); 1852 // Expect 2 levels will be cleared. 1853 SetupClearTextureExpectations(kServiceTextureId, 1854 kServiceTextureId, 1855 GL_TEXTURE_2D, 1856 GL_TEXTURE_2D, 1857 0, 1858 GL_RGBA, 1859 GL_RGBA, 1860 GL_UNSIGNED_BYTE, 1861 2, 1862 2); 1863 SetupClearTextureExpectations(kServiceTextureId, 1864 kServiceTextureId, 1865 GL_TEXTURE_2D, 1866 GL_TEXTURE_2D, 1867 1, 1868 GL_RGBA, 1869 GL_RGBA, 1870 GL_UNSIGNED_BYTE, 1871 1, 1872 1); 1873 SetupExpectationsForApplyingDefaultDirtyState(); 1874 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 1875 .Times(1) 1876 .RetiresOnSaturation(); 1877 DrawArrays cmd; 1878 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 1879 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1880 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1881 1882 // But not again 1883 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 1884 .Times(1) 1885 .RetiresOnSaturation(); 1886 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1887 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1888 } 1889 1890 TEST_P(GLES2DecoderWithShaderTest, DrawElementsClearsAfterTexImage2DNULL) { 1891 SetupAllNeededVertexBuffers(); 1892 SetupIndexBuffer(); 1893 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId); 1894 // Create an uncleared texture with 2 levels. 1895 DoTexImage2D( 1896 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0); 1897 DoTexImage2D( 1898 GL_TEXTURE_2D, 1, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0); 1899 // Expect 2 levels will be cleared. 1900 SetupClearTextureExpectations(kServiceTextureId, 1901 kServiceTextureId, 1902 GL_TEXTURE_2D, 1903 GL_TEXTURE_2D, 1904 0, 1905 GL_RGBA, 1906 GL_RGBA, 1907 GL_UNSIGNED_BYTE, 1908 2, 1909 2); 1910 SetupClearTextureExpectations(kServiceTextureId, 1911 kServiceTextureId, 1912 GL_TEXTURE_2D, 1913 GL_TEXTURE_2D, 1914 1, 1915 GL_RGBA, 1916 GL_RGBA, 1917 GL_UNSIGNED_BYTE, 1918 1, 1919 1); 1920 SetupExpectationsForApplyingDefaultDirtyState(); 1921 1922 EXPECT_CALL(*gl_, 1923 DrawElements(GL_TRIANGLES, 1924 kValidIndexRangeCount, 1925 GL_UNSIGNED_SHORT, 1926 BufferOffset(kValidIndexRangeStart * 2))) 1927 .Times(1) 1928 .RetiresOnSaturation(); 1929 DrawElements cmd; 1930 cmd.Init(GL_TRIANGLES, 1931 kValidIndexRangeCount, 1932 GL_UNSIGNED_SHORT, 1933 kValidIndexRangeStart * 2); 1934 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1935 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1936 1937 // But not again 1938 EXPECT_CALL(*gl_, 1939 DrawElements(GL_TRIANGLES, 1940 kValidIndexRangeCount, 1941 GL_UNSIGNED_SHORT, 1942 BufferOffset(kValidIndexRangeStart * 2))) 1943 .Times(1) 1944 .RetiresOnSaturation(); 1945 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 1946 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 1947 } 1948 1949 TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterTexImage2DNULLInFBO) { 1950 const GLuint kFBOClientTextureId = 4100; 1951 const GLuint kFBOServiceTextureId = 4101; 1952 1953 SetupAllNeededVertexBuffers(); 1954 // Register a texture id. 1955 EXPECT_CALL(*gl_, GenTextures(_, _)) 1956 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId)) 1957 .RetiresOnSaturation(); 1958 GenHelper<GenTexturesImmediate>(kFBOClientTextureId); 1959 1960 // Setup "render to" texture. 1961 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId); 1962 DoTexImage2D( 1963 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0); 1964 DoBindFramebuffer( 1965 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId); 1966 DoFramebufferTexture2D(GL_FRAMEBUFFER, 1967 GL_COLOR_ATTACHMENT0, 1968 GL_TEXTURE_2D, 1969 kFBOClientTextureId, 1970 kFBOServiceTextureId, 1971 0, 1972 GL_NO_ERROR); 1973 1974 // Setup "render from" texture. 1975 SetupTexture(); 1976 1977 SetupExpectationsForFramebufferClearing(GL_FRAMEBUFFER, // target 1978 GL_COLOR_BUFFER_BIT, // clear bits 1979 0, 1980 0, 1981 0, 1982 0, // color 1983 0, // stencil 1984 1.0f, // depth 1985 false); // scissor test 1986 1987 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB 1988 false, // Framebuffer has depth 1989 false, // Framebuffer has stencil 1990 0x1111, // color bits 1991 false, // depth mask 1992 false, // depth enabled 1993 0, // front stencil mask 1994 0, // back stencil mask 1995 false); // stencil enabled 1996 1997 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 1998 .Times(1) 1999 .RetiresOnSaturation(); 2000 DrawArrays cmd; 2001 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 2002 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 2003 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 2004 2005 // But not again. 2006 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 2007 .Times(1) 2008 .RetiresOnSaturation(); 2009 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 2010 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 2011 } 2012 2013 TEST_P(GLES2DecoderWithShaderTest, DrawWitFBOThatCantClearDoesNotDraw) { 2014 const GLuint kFBOClientTextureId = 4100; 2015 const GLuint kFBOServiceTextureId = 4101; 2016 2017 // Register a texture id. 2018 EXPECT_CALL(*gl_, GenTextures(_, _)) 2019 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId)) 2020 .RetiresOnSaturation(); 2021 GenHelper<GenTexturesImmediate>(kFBOClientTextureId); 2022 2023 // Setup "render to" texture. 2024 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId); 2025 DoTexImage2D( 2026 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0); 2027 DoBindFramebuffer( 2028 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId); 2029 DoFramebufferTexture2D(GL_FRAMEBUFFER, 2030 GL_COLOR_ATTACHMENT0, 2031 GL_TEXTURE_2D, 2032 kFBOClientTextureId, 2033 kFBOServiceTextureId, 2034 0, 2035 GL_NO_ERROR); 2036 2037 // Setup "render from" texture. 2038 SetupTexture(); 2039 2040 EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER)) 2041 .WillOnce(Return(GL_FRAMEBUFFER_UNSUPPORTED)) 2042 .RetiresOnSaturation(); 2043 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation(); 2044 DrawArrays cmd; 2045 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 2046 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 2047 EXPECT_EQ(GL_INVALID_FRAMEBUFFER_OPERATION, GetGLError()); 2048 } 2049 2050 TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterRenderbufferStorageInFBO) { 2051 SetupTexture(); 2052 DoBindRenderbuffer( 2053 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId); 2054 DoBindFramebuffer( 2055 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId); 2056 DoRenderbufferStorage( 2057 GL_RENDERBUFFER, GL_RGBA4, GL_RGBA, 100, 50, GL_NO_ERROR); 2058 DoFramebufferRenderbuffer(GL_FRAMEBUFFER, 2059 GL_COLOR_ATTACHMENT0, 2060 GL_RENDERBUFFER, 2061 client_renderbuffer_id_, 2062 kServiceRenderbufferId, 2063 GL_NO_ERROR); 2064 2065 SetupExpectationsForFramebufferClearing(GL_FRAMEBUFFER, // target 2066 GL_COLOR_BUFFER_BIT, // clear bits 2067 0, 2068 0, 2069 0, 2070 0, // color 2071 0, // stencil 2072 1.0f, // depth 2073 false); // scissor test 2074 2075 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 2076 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB 2077 false, // Framebuffer has depth 2078 false, // Framebuffer has stencil 2079 0x1111, // color bits 2080 false, // depth mask 2081 false, // depth enabled 2082 0, // front stencil mask 2083 0, // back stencil mask 2084 false); // stencil enabled 2085 2086 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 2087 .Times(1) 2088 .RetiresOnSaturation(); 2089 DrawArrays cmd; 2090 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 2091 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 2092 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 2093 } 2094 2095 TEST_P(GLES2DecoderManualInitTest, DrawArraysClearsAfterTexImage2DNULLCubemap) { 2096 InitState init; 2097 init.gl_version = "opengl es 2.0"; 2098 init.has_alpha = true; 2099 init.has_depth = true; 2100 init.request_alpha = true; 2101 init.request_depth = true; 2102 InitDecoder(init); 2103 2104 static const GLenum faces[] = { 2105 GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 2106 GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 2107 GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 2108 }; 2109 SetupCubemapProgram(); 2110 DoBindTexture(GL_TEXTURE_CUBE_MAP, client_texture_id_, kServiceTextureId); 2111 // Fill out all the faces for 2 levels, leave 2 uncleared. 2112 for (int ii = 0; ii < 6; ++ii) { 2113 GLenum face = faces[ii]; 2114 int32 shm_id = 2115 (face == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y) ? 0 : kSharedMemoryId; 2116 uint32 shm_offset = 2117 (face == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y) ? 0 : kSharedMemoryOffset; 2118 DoTexImage2D(face, 2119 0, 2120 GL_RGBA, 2121 2, 2122 2, 2123 0, 2124 GL_RGBA, 2125 GL_UNSIGNED_BYTE, 2126 shm_id, 2127 shm_offset); 2128 DoTexImage2D(face, 2129 1, 2130 GL_RGBA, 2131 1, 2132 1, 2133 0, 2134 GL_RGBA, 2135 GL_UNSIGNED_BYTE, 2136 shm_id, 2137 shm_offset); 2138 } 2139 // Expect 2 levels will be cleared. 2140 SetupClearTextureExpectations(kServiceTextureId, 2141 kServiceTextureId, 2142 GL_TEXTURE_CUBE_MAP, 2143 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 2144 0, 2145 GL_RGBA, 2146 GL_RGBA, 2147 GL_UNSIGNED_BYTE, 2148 2, 2149 2); 2150 SetupClearTextureExpectations(kServiceTextureId, 2151 kServiceTextureId, 2152 GL_TEXTURE_CUBE_MAP, 2153 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 2154 1, 2155 GL_RGBA, 2156 GL_RGBA, 2157 GL_UNSIGNED_BYTE, 2158 1, 2159 1); 2160 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 2161 SetupExpectationsForApplyingDefaultDirtyState(); 2162 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 2163 .Times(1) 2164 .RetiresOnSaturation(); 2165 DrawArrays cmd; 2166 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 2167 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 2168 } 2169 2170 TEST_P(GLES2DecoderWithShaderTest, 2171 DrawClearsAfterRenderbuffersWithMultipleAttachments) { 2172 const GLuint kFBOClientTextureId = 4100; 2173 const GLuint kFBOServiceTextureId = 4101; 2174 2175 // Register a texture id. 2176 EXPECT_CALL(*gl_, GenTextures(_, _)) 2177 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId)) 2178 .RetiresOnSaturation(); 2179 GenHelper<GenTexturesImmediate>(kFBOClientTextureId); 2180 2181 // Setup "render to" texture. 2182 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId); 2183 DoTexImage2D( 2184 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0); 2185 DoBindFramebuffer( 2186 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId); 2187 DoFramebufferTexture2D(GL_FRAMEBUFFER, 2188 GL_COLOR_ATTACHMENT0, 2189 GL_TEXTURE_2D, 2190 kFBOClientTextureId, 2191 kFBOServiceTextureId, 2192 0, 2193 GL_NO_ERROR); 2194 2195 DoBindRenderbuffer( 2196 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId); 2197 DoBindFramebuffer( 2198 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId); 2199 DoRenderbufferStorage(GL_RENDERBUFFER, 2200 GL_DEPTH_COMPONENT16, 2201 GL_DEPTH_COMPONENT, 2202 1, 2203 1, 2204 GL_NO_ERROR); 2205 DoFramebufferRenderbuffer(GL_FRAMEBUFFER, 2206 GL_DEPTH_ATTACHMENT, 2207 GL_RENDERBUFFER, 2208 client_renderbuffer_id_, 2209 kServiceRenderbufferId, 2210 GL_NO_ERROR); 2211 2212 SetupTexture(); 2213 SetupExpectationsForFramebufferClearing( 2214 GL_FRAMEBUFFER, // target 2215 GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, // clear bits 2216 0, 2217 0, 2218 0, 2219 0, // color 2220 0, // stencil 2221 1.0f, // depth 2222 false); // scissor test 2223 2224 AddExpectationsForSimulatedAttrib0(kNumVertices, 0); 2225 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB 2226 true, // Framebuffer has depth 2227 false, // Framebuffer has stencil 2228 0x1111, // color bits 2229 true, // depth mask 2230 false, // depth enabled 2231 0, // front stencil mask 2232 0, // back stencil mask 2233 false); // stencil enabled 2234 2235 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 2236 .Times(1) 2237 .RetiresOnSaturation(); 2238 DrawArrays cmd; 2239 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 2240 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 2241 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 2242 } 2243 2244 TEST_P(GLES2DecoderWithShaderTest, 2245 DrawingWithFBOTwiceChecksForFBOCompleteOnce) { 2246 const GLuint kFBOClientTextureId = 4100; 2247 const GLuint kFBOServiceTextureId = 4101; 2248 2249 SetupAllNeededVertexBuffers(); 2250 2251 // Register a texture id. 2252 EXPECT_CALL(*gl_, GenTextures(_, _)) 2253 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId)) 2254 .RetiresOnSaturation(); 2255 GenHelper<GenTexturesImmediate>(kFBOClientTextureId); 2256 2257 // Setup "render to" texture that is cleared. 2258 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId); 2259 DoTexImage2D(GL_TEXTURE_2D, 2260 0, 2261 GL_RGBA, 2262 1, 2263 1, 2264 0, 2265 GL_RGBA, 2266 GL_UNSIGNED_BYTE, 2267 kSharedMemoryId, 2268 kSharedMemoryOffset); 2269 DoBindFramebuffer( 2270 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId); 2271 DoFramebufferTexture2D(GL_FRAMEBUFFER, 2272 GL_COLOR_ATTACHMENT0, 2273 GL_TEXTURE_2D, 2274 kFBOClientTextureId, 2275 kFBOServiceTextureId, 2276 0, 2277 GL_NO_ERROR); 2278 2279 // Setup "render from" texture. 2280 SetupTexture(); 2281 2282 // Make sure we check for framebuffer complete. 2283 EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER)) 2284 .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE)) 2285 .RetiresOnSaturation(); 2286 2287 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB 2288 false, // Framebuffer has depth 2289 false, // Framebuffer has stencil 2290 0x1111, // color bits 2291 false, // depth mask 2292 false, // depth enabled 2293 0, // front stencil mask 2294 0, // back stencil mask 2295 false); // stencil enabled 2296 2297 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 2298 .Times(1) 2299 .RetiresOnSaturation(); 2300 DrawArrays cmd; 2301 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 2302 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 2303 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 2304 2305 // But not again. 2306 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 2307 .Times(1) 2308 .RetiresOnSaturation(); 2309 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 2310 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 2311 } 2312 2313 TEST_P(GLES2DecoderManualInitTest, DrawClearsDepthTexture) { 2314 InitState init; 2315 init.extensions = "GL_ANGLE_depth_texture"; 2316 init.gl_version = "opengl es 2.0"; 2317 init.has_alpha = true; 2318 init.has_depth = true; 2319 init.request_alpha = true; 2320 init.request_depth = true; 2321 init.bind_generates_resource = true; 2322 InitDecoder(init); 2323 2324 SetupDefaultProgram(); 2325 SetupAllNeededVertexBuffers(); 2326 const GLenum attachment = GL_DEPTH_ATTACHMENT; 2327 const GLenum target = GL_TEXTURE_2D; 2328 const GLint level = 0; 2329 DoBindTexture(target, client_texture_id_, kServiceTextureId); 2330 2331 // Create a depth texture. 2332 DoTexImage2D(target, 2333 level, 2334 GL_DEPTH_COMPONENT, 2335 1, 2336 1, 2337 0, 2338 GL_DEPTH_COMPONENT, 2339 GL_UNSIGNED_INT, 2340 0, 2341 0); 2342 2343 // Enable GL_SCISSOR_TEST to make sure we disable it in the clear, 2344 // then re-enable it. 2345 DoEnableDisable(GL_SCISSOR_TEST, true); 2346 2347 EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _)).Times(1).RetiresOnSaturation(); 2348 EXPECT_CALL(*gl_, BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, _)) 2349 .Times(1) 2350 .RetiresOnSaturation(); 2351 2352 EXPECT_CALL(*gl_, 2353 FramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT, 2354 attachment, 2355 target, 2356 kServiceTextureId, 2357 level)) 2358 .Times(1) 2359 .RetiresOnSaturation(); 2360 EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT)) 2361 .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE)) 2362 .RetiresOnSaturation(); 2363 2364 EXPECT_CALL(*gl_, ClearStencil(0)).Times(1).RetiresOnSaturation(); 2365 SetupExpectationsForStencilMask(GLES2Decoder::kDefaultStencilMask, 2366 GLES2Decoder::kDefaultStencilMask); 2367 EXPECT_CALL(*gl_, ClearDepth(1.0f)).Times(1).RetiresOnSaturation(); 2368 SetupExpectationsForDepthMask(true); 2369 SetupExpectationsForEnableDisable(GL_SCISSOR_TEST, false); 2370 2371 EXPECT_CALL(*gl_, Clear(GL_DEPTH_BUFFER_BIT)).Times(1).RetiresOnSaturation(); 2372 2373 SetupExpectationsForRestoreClearState(0.0f, 0.0f, 0.0f, 0.0f, 0, 1.0f, true); 2374 2375 EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, _)).Times(1).RetiresOnSaturation(); 2376 EXPECT_CALL(*gl_, BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0)) 2377 .Times(1) 2378 .RetiresOnSaturation(); 2379 2380 SetupExpectationsForApplyingDefaultDirtyState(); 2381 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices)) 2382 .Times(1) 2383 .RetiresOnSaturation(); 2384 DrawArrays cmd; 2385 cmd.Init(GL_TRIANGLES, 0, kNumVertices); 2386 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 2387 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 2388 } 2389 2390 } // namespace gles2 2391 } // namespace gpu 2392
