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:
ObjectManager(void)51 ObjectManager (void)
52 : m_lastObject(0)
53 {
54 }
55
allocate(void)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
free(deUint32 object)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
Context(ContextType ctxType_)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 (glu::isContextTypeGLCore(ctxType) && ctxType.getMajorVersion() == 3)
172 {
173 version = "3.3.0";
174 shadingLanguageVersion = "3.30";
175 }
176 else if (glu::isContextTypeGLCore(ctxType) && ctxType.getMajorVersion() == 4 && ctxType.getMinorVersion() <= 4)
177 {
178 version = "4.4.0";
179 shadingLanguageVersion = "4.40";
180 }
181 else
182 throw tcu::NotSupportedError("Unsupported GL version", "", __FILE__, __LINE__);
183
184 if (isContextTypeES(ctxType))
185 {
186 addExtension("GL_EXT_color_buffer_float");
187 addExtension("GL_EXT_color_buffer_half_float");
188 }
189
190 // support compressed formats
191 {
192 static deUint32 compressedFormats[] =
193 {
194 GL_ETC1_RGB8_OES,
195 GL_COMPRESSED_R11_EAC,
196 GL_COMPRESSED_SIGNED_R11_EAC,
197 GL_COMPRESSED_RG11_EAC,
198 GL_COMPRESSED_SIGNED_RG11_EAC,
199 GL_COMPRESSED_RGB8_ETC2,
200 GL_COMPRESSED_SRGB8_ETC2,
201 GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
202 GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
203 GL_COMPRESSED_RGBA8_ETC2_EAC,
204 GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
205 GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
206 GL_COMPRESSED_RGBA_ASTC_5x4_KHR,
207 GL_COMPRESSED_RGBA_ASTC_5x5_KHR,
208 GL_COMPRESSED_RGBA_ASTC_6x5_KHR,
209 GL_COMPRESSED_RGBA_ASTC_6x6_KHR,
210 GL_COMPRESSED_RGBA_ASTC_8x5_KHR,
211 GL_COMPRESSED_RGBA_ASTC_8x6_KHR,
212 GL_COMPRESSED_RGBA_ASTC_8x8_KHR,
213 GL_COMPRESSED_RGBA_ASTC_10x5_KHR,
214 GL_COMPRESSED_RGBA_ASTC_10x6_KHR,
215 GL_COMPRESSED_RGBA_ASTC_10x8_KHR,
216 GL_COMPRESSED_RGBA_ASTC_10x10_KHR,
217 GL_COMPRESSED_RGBA_ASTC_12x10_KHR,
218 GL_COMPRESSED_RGBA_ASTC_12x12_KHR,
219 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
220 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
221 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
222 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
223 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
224 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
225 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
226 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
227 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
228 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
229 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
230 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
231 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
232 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
233 };
234
235 addExtension("GL_KHR_texture_compression_astc_hdr");
236 addExtension("GL_KHR_texture_compression_astc_ldr");
237 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compressedFormats); ++ndx)
238 compressedTextureList.push_back(compressedFormats[ndx]);
239 }
240 }
241
~Context(void)242 Context::~Context (void)
243 {
244 }
245
addExtension(const char * name)246 void Context::addExtension (const char* name)
247 {
248 if (!extensions.empty())
249 extensions += " ";
250 extensions += name;
251
252 extensionList.push_back(name);
253 }
254
255 static de::ThreadLocal s_currentCtx;
256
setCurrentContext(Context * context)257 void setCurrentContext (Context* context)
258 {
259 s_currentCtx.set((void*)context);
260 }
261
getCurrentContext(void)262 Context* getCurrentContext (void)
263 {
264 return (Context*)s_currentCtx.get();
265 }
266
glGetError(void)267 GLW_APICALL GLenum GLW_APIENTRY glGetError (void)
268 {
269 Context* const ctx = getCurrentContext();
270 const GLenum lastErr = ctx->lastError;
271
272 ctx->lastError = GL_NO_ERROR;
273
274 return lastErr;
275 }
276
glGetIntegerv(GLenum pname,GLint * params)277 GLW_APICALL void GLW_APIENTRY glGetIntegerv (GLenum pname, GLint* params)
278 {
279 Context* const ctx = getCurrentContext();
280
281 switch (pname)
282 {
283 case GL_NUM_EXTENSIONS:
284 *params = (int)ctx->extensionList.size();
285 break;
286
287 case GL_MAX_VERTEX_ATTRIBS:
288 *params = 32;
289 break;
290
291 case GL_MAX_DRAW_BUFFERS:
292 case GL_MAX_COLOR_ATTACHMENTS:
293 *params = 8;
294 break;
295
296 case GL_MAX_TEXTURE_IMAGE_UNITS:
297 case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
298 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
299 case GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:
300 case GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS:
301 case GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS:
302 *params = 32;
303 break;
304
305 case GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS:
306 case GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS:
307 case GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS:
308 case GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS:
309 case GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS:
310 case GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS:
311 *params = 8;
312 break;
313
314 case GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS:
315 case GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS:
316 case GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS:
317 case GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS:
318 case GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS:
319 case GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS:
320 *params = 8;
321 break;
322
323 case GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
324 *params = 1u << 25;
325 break;
326
327 case GL_MAX_GEOMETRY_OUTPUT_VERTICES:
328 *params = 256;
329 break;
330
331 case GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
332 *params = 2048;
333 break;
334
335 case GL_MAX_GEOMETRY_SHADER_INVOCATIONS:
336 *params = 4;
337 break;
338
339 case GL_MAX_COLOR_TEXTURE_SAMPLES:
340 *params = 8;
341 break;
342
343 case GL_MAX_TEXTURE_SIZE:
344 case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
345 case GL_MAX_3D_TEXTURE_SIZE:
346 case GL_MAX_RENDERBUFFER_SIZE:
347 case GL_MAX_TEXTURE_BUFFER_SIZE:
348 *params = 2048;
349 break;
350
351 case GL_MAX_ARRAY_TEXTURE_LAYERS:
352 *params = 128;
353 break;
354
355 case GL_NUM_SHADER_BINARY_FORMATS:
356 *params = 0;
357 break;
358
359 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
360 *params = (int)ctx->compressedTextureList.size();
361 break;
362
363 case GL_COMPRESSED_TEXTURE_FORMATS:
364 deMemcpy(params, &ctx->compressedTextureList[0], ctx->compressedTextureList.size()*sizeof(deUint32));
365 break;
366
367 case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
368 *params = 16;
369 break;
370
371 case GL_MAX_UNIFORM_BUFFER_BINDINGS:
372 *params = 32;
373 break;
374
375 case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
376 *params = 16;
377 break;
378
379 case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
380 *params = GL_RGBA;
381 break;
382
383 case GL_IMPLEMENTATION_COLOR_READ_TYPE:
384 *params = GL_UNSIGNED_BYTE;
385 break;
386
387 case GL_SAMPLE_BUFFERS:
388 *params = 0;
389 break;
390
391 default:
392 break;
393 }
394 }
395
glGetBooleanv(GLenum pname,GLboolean * params)396 GLW_APICALL void GLW_APIENTRY glGetBooleanv (GLenum pname, GLboolean* params)
397 {
398 switch (pname)
399 {
400 case GL_SHADER_COMPILER:
401 *params = GL_TRUE;
402 break;
403
404 default:
405 break;
406 }
407 }
408
glGetFloatv(GLenum pname,GLfloat * params)409 GLW_APICALL void GLW_APIENTRY glGetFloatv (GLenum pname, GLfloat* params)
410 {
411 switch (pname)
412 {
413 case GL_ALIASED_LINE_WIDTH_RANGE:
414 case GL_ALIASED_POINT_SIZE_RANGE:
415 params[0] = 0.0f;
416 params[1] = 64.0f;
417 break;
418
419 default:
420 break;
421 }
422 }
423
glGetInternalformativ(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint * params)424 GLW_APICALL void GLW_APIENTRY glGetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
425 {
426 static const int s_sampleCounts[] = { 16, 8, 4, 2, 1 };
427
428 DE_UNREF(internalformat);
429 DE_UNREF(target);
430
431 switch (pname)
432 {
433 case GL_NUM_SAMPLE_COUNTS:
434 if (bufSize >= 1)
435 *params = DE_LENGTH_OF_ARRAY(s_sampleCounts);
436 break;
437
438 case GL_SAMPLES:
439 deMemcpy(params, s_sampleCounts, de::min(bufSize, DE_LENGTH_OF_ARRAY(s_sampleCounts)));
440 break;
441
442 default:
443 break;
444 }
445 }
446
glGetString(GLenum name)447 GLW_APICALL const glw::GLubyte* GLW_APIENTRY glGetString (GLenum name)
448 {
449 Context* const ctx = getCurrentContext();
450
451 switch (name)
452 {
453 case GL_VENDOR: return (const glw::GLubyte*)ctx->vendor.c_str();
454 case GL_VERSION: return (const glw::GLubyte*)ctx->version.c_str();
455 case GL_RENDERER: return (const glw::GLubyte*)ctx->renderer.c_str();
456 case GL_SHADING_LANGUAGE_VERSION: return (const glw::GLubyte*)ctx->shadingLanguageVersion.c_str();
457 case GL_EXTENSIONS: return (const glw::GLubyte*)ctx->extensions.c_str();
458 default:
459 ctx->lastError = GL_INVALID_ENUM;
460 return DE_NULL;
461 }
462 }
463
glGetStringi(GLenum name,GLuint index)464 GLW_APICALL const glw::GLubyte* GLW_APIENTRY glGetStringi (GLenum name, GLuint index)
465 {
466 Context* const ctx = getCurrentContext();
467
468 if (name == GL_EXTENSIONS)
469 {
470 if ((size_t)index < ctx->extensionList.size())
471 return (const glw::GLubyte*)ctx->extensionList[index].c_str();
472 else
473 {
474 ctx->lastError = GL_INVALID_VALUE;
475 return DE_NULL;
476 }
477 }
478 else
479 {
480 ctx->lastError = GL_INVALID_ENUM;
481 return DE_NULL;
482 }
483 }
484
glCreateProgram()485 GLW_APICALL GLuint GLW_APIENTRY glCreateProgram ()
486 {
487 Context* const ctx = getCurrentContext();
488 return (GLuint)ctx->programs.allocate();
489 }
490
glCreateShader(GLenum type)491 GLW_APICALL GLuint GLW_APIENTRY glCreateShader (GLenum type)
492 {
493 Context* const ctx = getCurrentContext();
494 DE_UNREF(type);
495 return (GLuint)ctx->shaders.allocate();
496 }
497
glGetShaderiv(GLuint shader,GLenum pname,GLint * params)498 GLW_APICALL void GLW_APIENTRY glGetShaderiv (GLuint shader, GLenum pname, GLint* params)
499 {
500 DE_UNREF(shader);
501
502 if (pname == GL_COMPILE_STATUS)
503 *params = GL_TRUE;
504 }
505
glGetProgramiv(GLuint program,GLenum pname,GLint * params)506 GLW_APICALL void GLW_APIENTRY glGetProgramiv (GLuint program, GLenum pname, GLint* params)
507 {
508 DE_UNREF(program);
509
510 if (pname == GL_LINK_STATUS)
511 *params = GL_TRUE;
512 }
513
glGenTextures(GLsizei n,GLuint * textures)514 GLW_APICALL void GLW_APIENTRY glGenTextures (GLsizei n, GLuint* textures)
515 {
516 Context* const ctx = getCurrentContext();
517
518 if (textures)
519 {
520 for (int ndx = 0; ndx < n; ndx++)
521 textures[ndx] = ctx->textures.allocate();
522 }
523 }
524
glGenQueries(GLsizei n,GLuint * ids)525 GLW_APICALL void GLW_APIENTRY glGenQueries (GLsizei n, GLuint* ids)
526 {
527 Context* const ctx = getCurrentContext();
528
529 if (ids)
530 {
531 for (int ndx = 0; ndx < n; ndx++)
532 ids[ndx] = ctx->queries.allocate();
533 }
534 }
535
glGenBuffers(GLsizei n,GLuint * buffers)536 GLW_APICALL void GLW_APIENTRY glGenBuffers (GLsizei n, GLuint* buffers)
537 {
538 Context* const ctx = getCurrentContext();
539
540 if (buffers)
541 {
542 for (int ndx = 0; ndx < n; ndx++)
543 buffers[ndx] = ctx->buffers.allocate();
544 }
545 }
546
glGenRenderbuffers(GLsizei n,GLuint * renderbuffers)547 GLW_APICALL void GLW_APIENTRY glGenRenderbuffers (GLsizei n, GLuint* renderbuffers)
548 {
549 Context* const ctx = getCurrentContext();
550
551 if (renderbuffers)
552 {
553 for (int ndx = 0; ndx < n; ndx++)
554 renderbuffers[ndx] = ctx->renderbuffers.allocate();
555 }
556 }
557
glGenFramebuffers(GLsizei n,GLuint * framebuffers)558 GLW_APICALL void GLW_APIENTRY glGenFramebuffers (GLsizei n, GLuint* framebuffers)
559 {
560 Context* const ctx = getCurrentContext();
561
562 if (framebuffers)
563 {
564 for (int ndx = 0; ndx < n; ndx++)
565 framebuffers[ndx] = ctx->framebuffers.allocate();
566 }
567 }
568
glGenVertexArrays(GLsizei n,GLuint * arrays)569 GLW_APICALL void GLW_APIENTRY glGenVertexArrays (GLsizei n, GLuint* arrays)
570 {
571 Context* const ctx = getCurrentContext();
572
573 if (arrays)
574 {
575 for (int ndx = 0; ndx < n; ndx++)
576 arrays[ndx] = ctx->vertexArrays.allocate();
577 }
578 }
579
glGenSamplers(GLsizei count,GLuint * samplers)580 GLW_APICALL void GLW_APIENTRY glGenSamplers (GLsizei count, GLuint* samplers)
581 {
582 Context* const ctx = getCurrentContext();
583
584 if (samplers)
585 {
586 for (int ndx = 0; ndx < count; ndx++)
587 samplers[ndx] = ctx->samplers.allocate();
588 }
589 }
590
glGenTransformFeedbacks(GLsizei n,GLuint * ids)591 GLW_APICALL void GLW_APIENTRY glGenTransformFeedbacks (GLsizei n, GLuint* ids)
592 {
593 Context* const ctx = getCurrentContext();
594
595 if (ids)
596 {
597 for (int ndx = 0; ndx < n; ndx++)
598 ids[ndx] = ctx->transformFeedbacks.allocate();
599 }
600 }
601
glGenProgramPipelines(GLsizei n,GLuint * pipelines)602 GLW_APICALL void GLW_APIENTRY glGenProgramPipelines (GLsizei n, GLuint* pipelines)
603 {
604 Context* const ctx = getCurrentContext();
605
606 if (pipelines)
607 {
608 for (int ndx = 0; ndx < n; ndx++)
609 pipelines[ndx] = ctx->programPipelines.allocate();
610 }
611 }
612
glMapBufferRange(GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access)613 GLW_APICALL GLvoid* GLW_APIENTRY glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
614 {
615 Context* const ctx = getCurrentContext();
616
617 DE_UNREF(target);
618 DE_UNREF(offset);
619 DE_UNREF(length);
620 DE_UNREF(access);
621
622 if (ctx->lastError == GL_NO_ERROR)
623 ctx->lastError = GL_INVALID_OPERATION;
624
625 return (GLvoid*)0;
626 }
627
glCheckFramebufferStatus(GLenum target)628 GLW_APICALL GLenum GLW_APIENTRY glCheckFramebufferStatus (GLenum target)
629 {
630 DE_UNREF(target);
631 return GL_FRAMEBUFFER_COMPLETE;
632 }
633
glReadPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLvoid * pixels)634 GLW_APICALL void GLW_APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
635 {
636 DE_UNREF(x);
637 DE_UNREF(y);
638
639 Context* const ctx = getCurrentContext();
640 const tcu::Vec4 clearColor (0.0f, 0.0f, 0.0f, 1.0f); // black
641 const tcu::TextureFormat transferFormat = glu::mapGLTransferFormat(format, type);
642
643 // invalid formats
644 if (transferFormat.order == TextureFormat::CHANNELORDER_LAST || transferFormat.type == TextureFormat::CHANNELTYPE_LAST)
645 {
646 if (ctx->lastError == GL_NO_ERROR)
647 ctx->lastError = GL_INVALID_ENUM;
648 return;
649 }
650
651 // unsupported formats
652 if (!(format == GL_RGBA && type == GL_UNSIGNED_BYTE) &&
653 !(format == GL_RGBA_INTEGER && type == GL_INT) &&
654 !(format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT) &&
655 !(format == GL_RGBA && type == GL_FLOAT))
656 {
657 if (ctx->lastError == GL_NO_ERROR)
658 ctx->lastError = GL_INVALID_ENUM;
659 return;
660 }
661
662 // invalid arguments
663 if (width < 0 || height < 0)
664 {
665 if (ctx->lastError == GL_NO_ERROR)
666 ctx->lastError = GL_INVALID_OPERATION;
667 return;
668 }
669
670 // read to buffer
671 if (ctx->pixelPackBufferBufferBinding)
672 return;
673
674 // read to use pointer
675 {
676 const int targetRowLength = (ctx->pixelPackRowLength != 0) ? (ctx->pixelPackRowLength) : (width);
677 const int targetSkipRows = ctx->pixelPackSkipRows;
678 const int targetSkipPixels = ctx->pixelPackSkipPixels;
679 const int infiniteHeight = targetSkipRows + height; // as much as needed
680 const int targetRowPitch = (ctx->pixelPackAlignment == 0) ? (targetRowLength * transferFormat.getPixelSize()) : (deAlign32(targetRowLength * transferFormat.getPixelSize(), ctx->pixelPackAlignment));
681
682 // Create access to the whole copy target
683 const tcu::PixelBufferAccess targetAccess (transferFormat, targetRowLength, infiniteHeight, 1, targetRowPitch, 0, pixels);
684
685 // Select (skip_pixels, skip_rows, width, height) subregion from it. Clip to horizontal boundaries
686 const tcu::PixelBufferAccess targetRectAccess = tcu::getSubregion(targetAccess,
687 de::clamp(targetSkipPixels, 0, targetAccess.getWidth()-1),
688 targetSkipRows,
689 de::clamp(width, 0, de::max(0, targetAccess.getWidth() - targetSkipPixels)),
690 height);
691
692 tcu::clear(targetRectAccess, clearColor);
693 }
694 }
695
glBindBuffer(GLenum target,GLuint buffer)696 GLW_APICALL void GLW_APIENTRY glBindBuffer (GLenum target, GLuint buffer)
697 {
698 Context* const ctx = getCurrentContext();
699
700 if (target == GL_PIXEL_PACK_BUFFER)
701 ctx->pixelPackBufferBufferBinding = buffer;
702 }
703
glDeleteBuffers(GLsizei n,const GLuint * buffers)704 GLW_APICALL void GLW_APIENTRY glDeleteBuffers (GLsizei n, const GLuint* buffers)
705 {
706 Context* const ctx = getCurrentContext();
707
708 for (GLsizei ndx = 0; ndx < n; ++ndx)
709 if (buffers[ndx] && buffers[ndx] == ctx->pixelPackBufferBufferBinding)
710 ctx->pixelPackBufferBufferBinding = 0;
711 }
712
glGetAttribLocation(GLuint program,const GLchar * name)713 GLW_APICALL GLint GLW_APIENTRY glGetAttribLocation (GLuint program, const GLchar* name)
714 {
715 DE_UNREF(program);
716 return (GLint)(deStringHash(name) & 0x7FFFFFFF);
717 }
718
initFunctions(glw::Functions * gl)719 void initFunctions (glw::Functions* gl)
720 {
721 # include "tcuNullRenderContextInitFuncs.inl"
722 }
723
toRenderTarget(const RenderConfig & renderCfg)724 static tcu::RenderTarget toRenderTarget (const RenderConfig& renderCfg)
725 {
726 const int width = getValueOrDefault(renderCfg, &RenderConfig::width, 256);
727 const int height = getValueOrDefault(renderCfg, &RenderConfig::height, 256);
728 const int redBits = getValueOrDefault(renderCfg, &RenderConfig::redBits, 8);
729 const int greenBits = getValueOrDefault(renderCfg, &RenderConfig::greenBits, 8);
730 const int blueBits = getValueOrDefault(renderCfg, &RenderConfig::blueBits, 8);
731 const int alphaBits = getValueOrDefault(renderCfg, &RenderConfig::alphaBits, 8);
732 const int depthBits = getValueOrDefault(renderCfg, &RenderConfig::depthBits, 24);
733 const int stencilBits = getValueOrDefault(renderCfg, &RenderConfig::stencilBits, 8);
734 const int numSamples = getValueOrDefault(renderCfg, &RenderConfig::numSamples, 0);
735
736 return tcu::RenderTarget(width, height, tcu::PixelFormat(redBits, greenBits, blueBits, alphaBits), depthBits, stencilBits, numSamples);
737 }
738
RenderContext(const RenderConfig & renderCfg)739 RenderContext::RenderContext (const RenderConfig& renderCfg)
740 : m_ctxType (renderCfg.type)
741 , m_renderTarget (toRenderTarget(renderCfg))
742 , m_context (DE_NULL)
743 {
744 m_context = new Context(m_ctxType);
745
746 initFunctions(&m_functions);
747 setCurrentContext(m_context);
748 }
749
~RenderContext(void)750 RenderContext::~RenderContext (void)
751 {
752 setCurrentContext(DE_NULL);
753 delete m_context;
754 }
755
postIterate(void)756 void RenderContext::postIterate (void)
757 {
758 }
759
760 } // null
761 } // tcu
762