1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES Utilities 3 * ------------------------------------------------ 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Render context implementation that does no rendering. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "tcuNullRenderContext.hpp" 25 #include "tcuTexture.hpp" 26 #include "tcuTextureUtil.hpp" 27 #include "deThreadLocal.hpp" 28 #include "gluRenderConfig.hpp" 29 #include "gluTextureUtil.hpp" 30 #include "glwEnums.hpp" 31 32 #include <string> 33 #include <vector> 34 35 namespace tcu 36 { 37 namespace null 38 { 39 40 using namespace glw; 41 42 #include "tcuNullRenderContextFuncs.inl" 43 44 using namespace glu; 45 using std::string; 46 using std::vector; 47 48 class ObjectManager 49 { 50 public: 51 ObjectManager (void) 52 : m_lastObject(0) 53 { 54 } 55 56 deUint32 allocate (void) 57 { 58 deUint32 object = ++m_lastObject; 59 if (object == 0) 60 object = ++m_lastObject; // Just ignore overflow. 61 return object; 62 } 63 64 void free (deUint32 object) 65 { 66 DE_UNREF(object); 67 } 68 69 private: 70 deUint32 m_lastObject; 71 }; 72 73 class Context 74 { 75 public: 76 Context (ContextType ctxType_); 77 ~Context (void); 78 79 private: 80 Context (const Context&); 81 Context& operator= (const Context&); 82 83 void addExtension (const char* name); 84 85 public: 86 // GL state exposed to implementation functions. 87 const ContextType ctxType; 88 89 string vendor; 90 string version; 91 string renderer; 92 string shadingLanguageVersion; 93 string extensions; 94 vector<string> extensionList; 95 vector<deUint32> compressedTextureList; 96 97 GLenum lastError; 98 99 int pixelPackRowLength; 100 int pixelPackSkipRows; 101 int pixelPackSkipPixels; 102 int pixelPackAlignment; 103 104 GLuint pixelPackBufferBufferBinding; 105 106 ObjectManager shaders; 107 ObjectManager programs; 108 ObjectManager textures; 109 ObjectManager buffers; 110 ObjectManager renderbuffers; 111 ObjectManager framebuffers; 112 ObjectManager samplers; 113 ObjectManager vertexArrays; 114 ObjectManager queries; 115 ObjectManager transformFeedbacks; 116 ObjectManager programPipelines; 117 }; 118 119 Context::Context (ContextType ctxType_) 120 : ctxType (ctxType_) 121 , vendor ("drawElements") 122 , renderer ("dummy") 123 , lastError (GL_NO_ERROR) 124 , pixelPackRowLength (0) 125 , pixelPackSkipRows (0) 126 , pixelPackSkipPixels (0) 127 , pixelPackAlignment (0) 128 , pixelPackBufferBufferBinding (0) 129 { 130 using glu::ApiType; 131 132 if (ctxType.getAPI() == ApiType::es(2, 0)) 133 { 134 version = "OpenGL ES 2.0"; 135 shadingLanguageVersion = "OpenGL ES GLSL ES 1.0"; 136 } 137 else if (ctxType.getAPI() == ApiType::es(3, 0)) 138 { 139 version = "OpenGL ES 3.0"; 140 shadingLanguageVersion = "OpenGL ES GLSL ES 3.0"; 141 } 142 else if (ctxType.getAPI() == ApiType::es(3, 1)) 143 { 144 version = "OpenGL ES 3.1"; 145 shadingLanguageVersion = "OpenGL ES GLSL ES 3.1"; 146 addExtension("GL_OES_texture_stencil8"); 147 addExtension("GL_OES_sample_shading"); 148 addExtension("GL_OES_sample_variables"); 149 addExtension("GL_OES_shader_multisample_interpolation"); 150 addExtension("GL_OES_shader_image_atomic"); 151 addExtension("GL_OES_texture_storage_multisample_2d_array"); 152 addExtension("GL_KHR_blend_equation_advanced"); 153 addExtension("GL_KHR_blend_equation_advanced_coherent"); 154 addExtension("GL_EXT_shader_io_blocks"); 155 addExtension("GL_EXT_geometry_shader"); 156 addExtension("GL_EXT_geometry_point_size"); 157 addExtension("GL_EXT_tessellation_shader"); 158 addExtension("GL_EXT_tessellation_point_size"); 159 addExtension("GL_EXT_gpu_shader5"); 160 addExtension("GL_EXT_shader_implicit_conversions"); 161 addExtension("GL_EXT_texture_buffer"); 162 addExtension("GL_EXT_texture_cube_map_array"); 163 addExtension("GL_EXT_draw_buffers_indexed"); 164 addExtension("GL_EXT_texture_sRGB_decode"); 165 addExtension("GL_EXT_texture_border_clamp"); 166 addExtension("GL_KHR_debug"); 167 addExtension("GL_EXT_primitive_bounding_box"); 168 addExtension("GL_ANDROID_extension_pack_es31a"); 169 addExtension("GL_EXT_copy_image"); 170 } 171 else if (ctxType.getAPI() == ApiType::es(3, 2)) 172 { 173 version = "OpenGL ES 3.2"; 174 shadingLanguageVersion = "OpenGL ES GLSL ES 3.2"; 175 } 176 else if (glu::isContextTypeGLCore(ctxType) && ctxType.getMajorVersion() == 3) 177 { 178 version = "3.3.0"; 179 shadingLanguageVersion = "3.30"; 180 } 181 else if (glu::isContextTypeGLCore(ctxType) && ctxType.getMajorVersion() == 4 && ctxType.getMinorVersion() <= 4) 182 { 183 version = "4.4.0"; 184 shadingLanguageVersion = "4.40"; 185 } 186 else if (glu::isContextTypeGLCore(ctxType) && ctxType.getMajorVersion() == 4 && ctxType.getMinorVersion() == 5) 187 { 188 version = "4.5.0"; 189 shadingLanguageVersion = "4.50"; 190 } 191 else if (glu::isContextTypeGLCore(ctxType) && ctxType.getMajorVersion() == 4 && ctxType.getMinorVersion() == 6) 192 { 193 version = "4.6.0"; 194 shadingLanguageVersion = "4.60"; 195 } 196 else 197 throw tcu::NotSupportedError("Unsupported GL version", "", __FILE__, __LINE__); 198 199 if (isContextTypeES(ctxType)) 200 { 201 addExtension("GL_EXT_color_buffer_float"); 202 addExtension("GL_EXT_color_buffer_half_float"); 203 } 204 205 // support compressed formats 206 { 207 static deUint32 compressedFormats[] = 208 { 209 GL_ETC1_RGB8_OES, 210 GL_COMPRESSED_R11_EAC, 211 GL_COMPRESSED_SIGNED_R11_EAC, 212 GL_COMPRESSED_RG11_EAC, 213 GL_COMPRESSED_SIGNED_RG11_EAC, 214 GL_COMPRESSED_RGB8_ETC2, 215 GL_COMPRESSED_SRGB8_ETC2, 216 GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, 217 GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 218 GL_COMPRESSED_RGBA8_ETC2_EAC, 219 GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, 220 GL_COMPRESSED_RGBA_ASTC_4x4_KHR, 221 GL_COMPRESSED_RGBA_ASTC_5x4_KHR, 222 GL_COMPRESSED_RGBA_ASTC_5x5_KHR, 223 GL_COMPRESSED_RGBA_ASTC_6x5_KHR, 224 GL_COMPRESSED_RGBA_ASTC_6x6_KHR, 225 GL_COMPRESSED_RGBA_ASTC_8x5_KHR, 226 GL_COMPRESSED_RGBA_ASTC_8x6_KHR, 227 GL_COMPRESSED_RGBA_ASTC_8x8_KHR, 228 GL_COMPRESSED_RGBA_ASTC_10x5_KHR, 229 GL_COMPRESSED_RGBA_ASTC_10x6_KHR, 230 GL_COMPRESSED_RGBA_ASTC_10x8_KHR, 231 GL_COMPRESSED_RGBA_ASTC_10x10_KHR, 232 GL_COMPRESSED_RGBA_ASTC_12x10_KHR, 233 GL_COMPRESSED_RGBA_ASTC_12x12_KHR, 234 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 235 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 236 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 237 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 238 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 239 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 240 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 241 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 242 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 243 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 244 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 245 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 246 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 247 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 248 }; 249 250 addExtension("GL_KHR_texture_compression_astc_hdr"); 251 addExtension("GL_KHR_texture_compression_astc_ldr"); 252 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compressedFormats); ++ndx) 253 compressedTextureList.push_back(compressedFormats[ndx]); 254 } 255 } 256 257 Context::~Context (void) 258 { 259 } 260 261 void Context::addExtension (const char* name) 262 { 263 if (!extensions.empty()) 264 extensions += " "; 265 extensions += name; 266 267 extensionList.push_back(name); 268 } 269 270 static de::ThreadLocal s_currentCtx; 271 272 void setCurrentContext (Context* context) 273 { 274 s_currentCtx.set((void*)context); 275 } 276 277 Context* getCurrentContext (void) 278 { 279 return (Context*)s_currentCtx.get(); 280 } 281 282 GLW_APICALL GLenum GLW_APIENTRY glGetError (void) 283 { 284 Context* const ctx = getCurrentContext(); 285 const GLenum lastErr = ctx->lastError; 286 287 ctx->lastError = GL_NO_ERROR; 288 289 return lastErr; 290 } 291 292 GLW_APICALL void GLW_APIENTRY glGetIntegerv (GLenum pname, GLint* params) 293 { 294 Context* const ctx = getCurrentContext(); 295 296 switch (pname) 297 { 298 case GL_NUM_EXTENSIONS: 299 *params = (int)ctx->extensionList.size(); 300 break; 301 302 case GL_MAX_VERTEX_ATTRIBS: 303 *params = 32; 304 break; 305 306 case GL_MAX_DRAW_BUFFERS: 307 case GL_MAX_COLOR_ATTACHMENTS: 308 *params = 8; 309 break; 310 311 case GL_MAX_TEXTURE_IMAGE_UNITS: 312 case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: 313 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: 314 case GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS: 315 case GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS: 316 case GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS: 317 *params = 32; 318 break; 319 320 case GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS: 321 case GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS: 322 case GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS: 323 case GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS: 324 case GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS: 325 case GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS: 326 *params = 8; 327 break; 328 329 case GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS: 330 case GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS: 331 case GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS: 332 case GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS: 333 case GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS: 334 case GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS: 335 *params = 8; 336 break; 337 338 case GL_MAX_SHADER_STORAGE_BLOCK_SIZE: 339 *params = 1u << 25; 340 break; 341 342 case GL_MAX_GEOMETRY_OUTPUT_VERTICES: 343 *params = 256; 344 break; 345 346 case GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS: 347 *params = 2048; 348 break; 349 350 case GL_MAX_GEOMETRY_SHADER_INVOCATIONS: 351 *params = 4; 352 break; 353 354 case GL_MAX_COLOR_TEXTURE_SAMPLES: 355 *params = 8; 356 break; 357 358 case GL_MAX_TEXTURE_SIZE: 359 case GL_MAX_CUBE_MAP_TEXTURE_SIZE: 360 case GL_MAX_3D_TEXTURE_SIZE: 361 case GL_MAX_RENDERBUFFER_SIZE: 362 case GL_MAX_TEXTURE_BUFFER_SIZE: 363 *params = 2048; 364 break; 365 366 case GL_MAX_ARRAY_TEXTURE_LAYERS: 367 *params = 128; 368 break; 369 370 case GL_NUM_SHADER_BINARY_FORMATS: 371 *params = 0; 372 break; 373 374 case GL_NUM_COMPRESSED_TEXTURE_FORMATS: 375 *params = (int)ctx->compressedTextureList.size(); 376 break; 377 378 case GL_COMPRESSED_TEXTURE_FORMATS: 379 deMemcpy(params, &ctx->compressedTextureList[0], ctx->compressedTextureList.size()*sizeof(deUint32)); 380 break; 381 382 case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 383 *params = 16; 384 break; 385 386 case GL_MAX_UNIFORM_BUFFER_BINDINGS: 387 *params = 32; 388 break; 389 390 case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT: 391 *params = 16; 392 break; 393 394 case GL_IMPLEMENTATION_COLOR_READ_FORMAT: 395 *params = GL_RGBA; 396 break; 397 398 case GL_IMPLEMENTATION_COLOR_READ_TYPE: 399 *params = GL_UNSIGNED_BYTE; 400 break; 401 402 case GL_SAMPLE_BUFFERS: 403 *params = 0; 404 break; 405 406 default: 407 break; 408 } 409 } 410 411 GLW_APICALL void GLW_APIENTRY glGetBooleanv (GLenum pname, GLboolean* params) 412 { 413 switch (pname) 414 { 415 case GL_SHADER_COMPILER: 416 *params = GL_TRUE; 417 break; 418 419 default: 420 break; 421 } 422 } 423 424 GLW_APICALL void GLW_APIENTRY glGetFloatv (GLenum pname, GLfloat* params) 425 { 426 switch (pname) 427 { 428 case GL_ALIASED_LINE_WIDTH_RANGE: 429 case GL_ALIASED_POINT_SIZE_RANGE: 430 params[0] = 0.0f; 431 params[1] = 64.0f; 432 break; 433 434 default: 435 break; 436 } 437 } 438 439 GLW_APICALL void GLW_APIENTRY glGetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) 440 { 441 static const int s_sampleCounts[] = { 16, 8, 4, 2, 1 }; 442 443 DE_UNREF(internalformat); 444 DE_UNREF(target); 445 446 switch (pname) 447 { 448 case GL_NUM_SAMPLE_COUNTS: 449 if (bufSize >= 1) 450 *params = DE_LENGTH_OF_ARRAY(s_sampleCounts); 451 break; 452 453 case GL_SAMPLES: 454 deMemcpy(params, s_sampleCounts, de::min(bufSize, DE_LENGTH_OF_ARRAY(s_sampleCounts))); 455 break; 456 457 default: 458 break; 459 } 460 } 461 462 GLW_APICALL const glw::GLubyte* GLW_APIENTRY glGetString (GLenum name) 463 { 464 Context* const ctx = getCurrentContext(); 465 466 switch (name) 467 { 468 case GL_VENDOR: return (const glw::GLubyte*)ctx->vendor.c_str(); 469 case GL_VERSION: return (const glw::GLubyte*)ctx->version.c_str(); 470 case GL_RENDERER: return (const glw::GLubyte*)ctx->renderer.c_str(); 471 case GL_SHADING_LANGUAGE_VERSION: return (const glw::GLubyte*)ctx->shadingLanguageVersion.c_str(); 472 case GL_EXTENSIONS: return (const glw::GLubyte*)ctx->extensions.c_str(); 473 default: 474 ctx->lastError = GL_INVALID_ENUM; 475 return DE_NULL; 476 } 477 } 478 479 GLW_APICALL const glw::GLubyte* GLW_APIENTRY glGetStringi (GLenum name, GLuint index) 480 { 481 Context* const ctx = getCurrentContext(); 482 483 if (name == GL_EXTENSIONS) 484 { 485 if ((size_t)index < ctx->extensionList.size()) 486 return (const glw::GLubyte*)ctx->extensionList[index].c_str(); 487 else 488 { 489 ctx->lastError = GL_INVALID_VALUE; 490 return DE_NULL; 491 } 492 } 493 else 494 { 495 ctx->lastError = GL_INVALID_ENUM; 496 return DE_NULL; 497 } 498 } 499 500 GLW_APICALL GLuint GLW_APIENTRY glCreateProgram () 501 { 502 Context* const ctx = getCurrentContext(); 503 return (GLuint)ctx->programs.allocate(); 504 } 505 506 GLW_APICALL GLuint GLW_APIENTRY glCreateShader (GLenum type) 507 { 508 Context* const ctx = getCurrentContext(); 509 DE_UNREF(type); 510 return (GLuint)ctx->shaders.allocate(); 511 } 512 513 GLW_APICALL void GLW_APIENTRY glGetShaderiv (GLuint shader, GLenum pname, GLint* params) 514 { 515 DE_UNREF(shader); 516 517 if (pname == GL_COMPILE_STATUS) 518 *params = GL_TRUE; 519 } 520 521 GLW_APICALL void GLW_APIENTRY glGetProgramiv (GLuint program, GLenum pname, GLint* params) 522 { 523 DE_UNREF(program); 524 525 if (pname == GL_LINK_STATUS) 526 *params = GL_TRUE; 527 } 528 529 GLW_APICALL void GLW_APIENTRY glGenTextures (GLsizei n, GLuint* textures) 530 { 531 Context* const ctx = getCurrentContext(); 532 533 if (textures) 534 { 535 for (int ndx = 0; ndx < n; ndx++) 536 textures[ndx] = ctx->textures.allocate(); 537 } 538 } 539 540 GLW_APICALL void GLW_APIENTRY glGenQueries (GLsizei n, GLuint* ids) 541 { 542 Context* const ctx = getCurrentContext(); 543 544 if (ids) 545 { 546 for (int ndx = 0; ndx < n; ndx++) 547 ids[ndx] = ctx->queries.allocate(); 548 } 549 } 550 551 GLW_APICALL void GLW_APIENTRY glGenBuffers (GLsizei n, GLuint* buffers) 552 { 553 Context* const ctx = getCurrentContext(); 554 555 if (buffers) 556 { 557 for (int ndx = 0; ndx < n; ndx++) 558 buffers[ndx] = ctx->buffers.allocate(); 559 } 560 } 561 562 GLW_APICALL void GLW_APIENTRY glGenRenderbuffers (GLsizei n, GLuint* renderbuffers) 563 { 564 Context* const ctx = getCurrentContext(); 565 566 if (renderbuffers) 567 { 568 for (int ndx = 0; ndx < n; ndx++) 569 renderbuffers[ndx] = ctx->renderbuffers.allocate(); 570 } 571 } 572 573 GLW_APICALL void GLW_APIENTRY glGenFramebuffers (GLsizei n, GLuint* framebuffers) 574 { 575 Context* const ctx = getCurrentContext(); 576 577 if (framebuffers) 578 { 579 for (int ndx = 0; ndx < n; ndx++) 580 framebuffers[ndx] = ctx->framebuffers.allocate(); 581 } 582 } 583 584 GLW_APICALL void GLW_APIENTRY glGenVertexArrays (GLsizei n, GLuint* arrays) 585 { 586 Context* const ctx = getCurrentContext(); 587 588 if (arrays) 589 { 590 for (int ndx = 0; ndx < n; ndx++) 591 arrays[ndx] = ctx->vertexArrays.allocate(); 592 } 593 } 594 595 GLW_APICALL void GLW_APIENTRY glGenSamplers (GLsizei count, GLuint* samplers) 596 { 597 Context* const ctx = getCurrentContext(); 598 599 if (samplers) 600 { 601 for (int ndx = 0; ndx < count; ndx++) 602 samplers[ndx] = ctx->samplers.allocate(); 603 } 604 } 605 606 GLW_APICALL void GLW_APIENTRY glGenTransformFeedbacks (GLsizei n, GLuint* ids) 607 { 608 Context* const ctx = getCurrentContext(); 609 610 if (ids) 611 { 612 for (int ndx = 0; ndx < n; ndx++) 613 ids[ndx] = ctx->transformFeedbacks.allocate(); 614 } 615 } 616 617 GLW_APICALL void GLW_APIENTRY glGenProgramPipelines (GLsizei n, GLuint* pipelines) 618 { 619 Context* const ctx = getCurrentContext(); 620 621 if (pipelines) 622 { 623 for (int ndx = 0; ndx < n; ndx++) 624 pipelines[ndx] = ctx->programPipelines.allocate(); 625 } 626 } 627 628 GLW_APICALL GLvoid* GLW_APIENTRY glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) 629 { 630 Context* const ctx = getCurrentContext(); 631 632 DE_UNREF(target); 633 DE_UNREF(offset); 634 DE_UNREF(length); 635 DE_UNREF(access); 636 637 if (ctx->lastError == GL_NO_ERROR) 638 ctx->lastError = GL_INVALID_OPERATION; 639 640 return (GLvoid*)0; 641 } 642 643 GLW_APICALL GLenum GLW_APIENTRY glCheckFramebufferStatus (GLenum target) 644 { 645 DE_UNREF(target); 646 return GL_FRAMEBUFFER_COMPLETE; 647 } 648 649 GLW_APICALL void GLW_APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) 650 { 651 DE_UNREF(x); 652 DE_UNREF(y); 653 654 Context* const ctx = getCurrentContext(); 655 const tcu::Vec4 clearColor (0.0f, 0.0f, 0.0f, 1.0f); // black 656 const tcu::TextureFormat transferFormat = glu::mapGLTransferFormat(format, type); 657 658 // invalid formats 659 if (transferFormat.order == TextureFormat::CHANNELORDER_LAST || transferFormat.type == TextureFormat::CHANNELTYPE_LAST) 660 { 661 if (ctx->lastError == GL_NO_ERROR) 662 ctx->lastError = GL_INVALID_ENUM; 663 return; 664 } 665 666 // unsupported formats 667 if (!(format == GL_RGBA && type == GL_UNSIGNED_BYTE) && 668 !(format == GL_RGBA_INTEGER && type == GL_INT) && 669 !(format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT) && 670 !(format == GL_RGBA && type == GL_FLOAT)) 671 { 672 if (ctx->lastError == GL_NO_ERROR) 673 ctx->lastError = GL_INVALID_ENUM; 674 return; 675 } 676 677 // invalid arguments 678 if (width < 0 || height < 0) 679 { 680 if (ctx->lastError == GL_NO_ERROR) 681 ctx->lastError = GL_INVALID_OPERATION; 682 return; 683 } 684 685 // read to buffer 686 if (ctx->pixelPackBufferBufferBinding) 687 return; 688 689 // read to use pointer 690 { 691 const int targetRowLength = (ctx->pixelPackRowLength != 0) ? (ctx->pixelPackRowLength) : (width); 692 const int targetSkipRows = ctx->pixelPackSkipRows; 693 const int targetSkipPixels = ctx->pixelPackSkipPixels; 694 const int infiniteHeight = targetSkipRows + height; // as much as needed 695 const int targetRowPitch = (ctx->pixelPackAlignment == 0) ? (targetRowLength * transferFormat.getPixelSize()) : (deAlign32(targetRowLength * transferFormat.getPixelSize(), ctx->pixelPackAlignment)); 696 697 // Create access to the whole copy target 698 const tcu::PixelBufferAccess targetAccess (transferFormat, targetRowLength, infiniteHeight, 1, targetRowPitch, 0, pixels); 699 700 // Select (skip_pixels, skip_rows, width, height) subregion from it. Clip to horizontal boundaries 701 const tcu::PixelBufferAccess targetRectAccess = tcu::getSubregion(targetAccess, 702 de::clamp(targetSkipPixels, 0, targetAccess.getWidth()-1), 703 targetSkipRows, 704 de::clamp(width, 0, de::max(0, targetAccess.getWidth() - targetSkipPixels)), 705 height); 706 707 tcu::clear(targetRectAccess, clearColor); 708 } 709 } 710 711 GLW_APICALL void GLW_APIENTRY glBindBuffer (GLenum target, GLuint buffer) 712 { 713 Context* const ctx = getCurrentContext(); 714 715 if (target == GL_PIXEL_PACK_BUFFER) 716 ctx->pixelPackBufferBufferBinding = buffer; 717 } 718 719 GLW_APICALL void GLW_APIENTRY glDeleteBuffers (GLsizei n, const GLuint* buffers) 720 { 721 Context* const ctx = getCurrentContext(); 722 723 for (GLsizei ndx = 0; ndx < n; ++ndx) 724 if (buffers[ndx] && buffers[ndx] == ctx->pixelPackBufferBufferBinding) 725 ctx->pixelPackBufferBufferBinding = 0; 726 } 727 728 GLW_APICALL GLint GLW_APIENTRY glGetAttribLocation (GLuint program, const GLchar* name) 729 { 730 DE_UNREF(program); 731 return (GLint)(deStringHash(name) & 0x7FFFFFFF); 732 } 733 734 void initFunctions (glw::Functions* gl) 735 { 736 # include "tcuNullRenderContextInitFuncs.inl" 737 } 738 739 static tcu::RenderTarget toRenderTarget (const RenderConfig& renderCfg) 740 { 741 const int width = getValueOrDefault(renderCfg, &RenderConfig::width, 256); 742 const int height = getValueOrDefault(renderCfg, &RenderConfig::height, 256); 743 const int redBits = getValueOrDefault(renderCfg, &RenderConfig::redBits, 8); 744 const int greenBits = getValueOrDefault(renderCfg, &RenderConfig::greenBits, 8); 745 const int blueBits = getValueOrDefault(renderCfg, &RenderConfig::blueBits, 8); 746 const int alphaBits = getValueOrDefault(renderCfg, &RenderConfig::alphaBits, 8); 747 const int depthBits = getValueOrDefault(renderCfg, &RenderConfig::depthBits, 24); 748 const int stencilBits = getValueOrDefault(renderCfg, &RenderConfig::stencilBits, 8); 749 const int numSamples = getValueOrDefault(renderCfg, &RenderConfig::numSamples, 0); 750 751 return tcu::RenderTarget(width, height, tcu::PixelFormat(redBits, greenBits, blueBits, alphaBits), depthBits, stencilBits, numSamples); 752 } 753 754 RenderContext::RenderContext (const RenderConfig& renderCfg) 755 : m_ctxType (renderCfg.type) 756 , m_renderTarget (toRenderTarget(renderCfg)) 757 , m_context (DE_NULL) 758 { 759 m_context = new Context(m_ctxType); 760 761 initFunctions(&m_functions); 762 setCurrentContext(m_context); 763 } 764 765 RenderContext::~RenderContext (void) 766 { 767 setCurrentContext(DE_NULL); 768 delete m_context; 769 } 770 771 void RenderContext::postIterate (void) 772 { 773 } 774 775 void RenderContext::makeCurrent (void) 776 { 777 } 778 779 } // null 780 } // tcu 781
