1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.0 Module
3 * -------------------------------------------------
5 * Copyright 2014 The Android Open Source Project
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * \brief Texture specification tests.
23 * \todo [pyry] Following tests are missing:
24 * - Specify mipmap incomplete texture, use without mipmaps, re-specify
25 * as complete and render.
26 * - Randomly re-specify levels to eventually reach mipmap-complete texture.
27 *//*--------------------------------------------------------------------*/
29 #include "es3fTextureSpecificationTests.hpp"
30 #include "tcuTestLog.hpp"
31 #include "tcuImageCompare.hpp"
32 #include "tcuTextureUtil.hpp"
33 #include "tcuVectorUtil.hpp"
34 #include "gluStrUtil.hpp"
35 #include "gluTexture.hpp"
36 #include "gluTextureUtil.hpp"
37 #include "sglrContextUtil.hpp"
38 #include "sglrContextWrapper.hpp"
39 #include "sglrGLContext.hpp"
40 #include "sglrReferenceContext.hpp"
41 #include "glsTextureTestUtil.hpp"
42 #include "deRandom.hpp"
43 #include "deStringUtil.hpp"
45 // \todo [2012-04-29 pyry] Should be named SglrUtil
46 #include "es3fFboTestUtil.hpp"
48 #include "glwEnums.hpp"
64 using namespace FboTestUtil;
66 tcu::TextureFormat mapGLUnsizedInternalFormat (deUint32 internalFormat)
68 using tcu::TextureFormat;
69 switch (internalFormat)
71 case GL_ALPHA: return TextureFormat(TextureFormat::A, TextureFormat::UNORM_INT8);
72 case GL_LUMINANCE: return TextureFormat(TextureFormat::L, TextureFormat::UNORM_INT8);
73 case GL_LUMINANCE_ALPHA: return TextureFormat(TextureFormat::LA, TextureFormat::UNORM_INT8);
74 case GL_RGB: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8);
75 case GL_RGBA: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
77 throw tcu::InternalError(string("Can't map GL unsized internal format (") + tcu::toHex(internalFormat).toString() + ") to texture format");
87 static inline int maxLevelCount (int width, int height)
89 return (int)deLog2Floor32(de::max(width, height))+1;
92 static inline int maxLevelCount (int width, int height, int depth)
94 return (int)deLog2Floor32(de::max(width, de::max(height, depth)))+1;
98 static tcu::Vector<float, Size> randomVector (de::Random& rnd, const tcu::Vector<float, Size>& minVal = tcu::Vector<float, Size>(0.0f), const tcu::Vector<float, Size>& maxVal = tcu::Vector<float, Size>(1.0f))
100 tcu::Vector<float, Size> res;
101 for (int ndx = 0; ndx < Size; ndx++)
102 res[ndx] = rnd.getFloat(minVal[ndx], maxVal[ndx]);
106 static const deUint32 s_cubeMapFaces[] =
108 GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
109 GL_TEXTURE_CUBE_MAP_POSITIVE_X,
110 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
111 GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
112 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
113 GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
116 static tcu::IVec4 getPixelFormatCompareDepth (const tcu::PixelFormat& pixelFormat, tcu::TextureFormat textureFormat)
118 switch (textureFormat.order)
120 case tcu::TextureFormat::L:
121 case tcu::TextureFormat::LA:
122 return tcu::IVec4(pixelFormat.redBits, pixelFormat.redBits, pixelFormat.redBits, pixelFormat.alphaBits);
124 return tcu::IVec4(pixelFormat.redBits, pixelFormat.greenBits, pixelFormat.blueBits, pixelFormat.alphaBits);
128 static IVec4 getEffectiveTextureFormatBitDepth (tcu::TextureFormat textureFormat)
130 if (textureFormat.order == tcu::TextureFormat::DS)
132 // When sampling depth-stencil texture, we actually sample just
133 // the depth component.
134 return tcu::getTextureFormatBitDepth(tcu::getEffectiveDepthStencilTextureFormat(textureFormat, tcu::Sampler::MODE_DEPTH));
137 return tcu::getTextureFormatBitDepth(textureFormat);
140 static tcu::UVec4 computeCompareThreshold (const tcu::PixelFormat& pixelFormat, tcu::TextureFormat textureFormat)
142 const IVec4 texFormatBits = getEffectiveTextureFormatBitDepth(textureFormat);
143 const IVec4 pixelFormatBits = getPixelFormatCompareDepth(pixelFormat, textureFormat);
144 const IVec4 accurateFmtBits = min(pixelFormatBits, texFormatBits);
145 const IVec4 compareBits = select(accurateFmtBits, IVec4(8), greaterThan(accurateFmtBits, IVec4(0))) - 1;
147 return (IVec4(1) << (8-compareBits)).asUint();
150 class TextureSpecCase : public TestCase, public sglr::ContextWrapper
153 TextureSpecCase (Context& context, const char* name, const char* desc);
154 ~TextureSpecCase (void);
156 IterateResult iterate (void);
159 virtual void createTexture (void) = DE_NULL;
160 virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext) = DE_NULL;
163 void renderTex (tcu::Surface& dst, deUint32 program, int width, int height);
164 void readPixels (tcu::Surface& dst, int x, int y, int width, int height);
167 TextureSpecCase (const TextureSpecCase& other);
168 TextureSpecCase& operator= (const TextureSpecCase& other);
171 TextureSpecCase::TextureSpecCase (Context& context, const char* name, const char* desc)
172 : TestCase(context, name, desc)
176 TextureSpecCase::~TextureSpecCase (void)
180 TextureSpecCase::IterateResult TextureSpecCase::iterate (void)
182 glu::RenderContext& renderCtx = TestCase::m_context.getRenderContext();
183 const tcu::RenderTarget& renderTarget = renderCtx.getRenderTarget();
184 tcu::TestLog& log = m_testCtx.getLog();
186 if (renderTarget.getWidth() < VIEWPORT_WIDTH || renderTarget.getHeight() < VIEWPORT_HEIGHT)
187 throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__);
189 // Context size, and viewport for GLES3
190 de::Random rnd (deStringHash(getName()));
191 int width = deMin32(renderTarget.getWidth(), VIEWPORT_WIDTH);
192 int height = deMin32(renderTarget.getHeight(), VIEWPORT_HEIGHT);
193 int x = rnd.getInt(0, renderTarget.getWidth() - width);
194 int y = rnd.getInt(0, renderTarget.getHeight() - height);
197 sglr::GLContext gles3Context (renderCtx, log, sglr::GLCONTEXT_LOG_CALLS, tcu::IVec4(x, y, width, height));
198 sglr::ReferenceContextBuffers refBuffers (tcu::PixelFormat(8,8,8,renderTarget.getPixelFormat().alphaBits?8:0), 0 /* depth */, 0 /* stencil */, width, height);
199 sglr::ReferenceContext refContext (sglr::ReferenceContextLimits(renderCtx), refBuffers.getColorbuffer(), refBuffers.getDepthbuffer(), refBuffers.getStencilbuffer());
201 // Clear color buffer.
202 for (int ndx = 0; ndx < 2; ndx++)
204 setContext(ndx ? (sglr::Context*)&refContext : (sglr::Context*)&gles3Context);
205 glClearColor(0.125f, 0.25f, 0.5f, 1.0f);
206 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
209 // Construct texture using both GLES3 and reference contexts.
210 for (int ndx = 0; ndx < 2; ndx++)
212 setContext(ndx ? (sglr::Context*)&refContext : (sglr::Context*)&gles3Context);
214 TCU_CHECK(glGetError() == GL_NO_ERROR);
217 // Initialize case result to pass.
218 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
221 gles3Context.enableLogging(0);
224 verifyTexture(gles3Context, refContext);
229 void TextureSpecCase::renderTex (tcu::Surface& dst, deUint32 program, int width, int height)
231 int targetW = getWidth();
232 int targetH = getHeight();
234 float w = (float)width / (float)targetW;
235 float h = (float)height / (float)targetH;
237 sglr::drawQuad(*getCurrentContext(), program, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(-1.0f + w*2.0f, -1.0f + h*2.0f, 0.0f));
240 readPixels(dst, 0, 0, width, height);
243 void TextureSpecCase::readPixels (tcu::Surface& dst, int x, int y, int width, int height)
245 dst.setSize(width, height);
246 glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, dst.getAccess().getDataPtr());
249 class Texture2DSpecCase : public TextureSpecCase
252 Texture2DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLevels);
253 ~Texture2DSpecCase (void);
256 virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext);
258 tcu::TextureFormat m_texFormat;
259 tcu::TextureFormatInfo m_texFormatInfo;
265 Texture2DSpecCase::Texture2DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLevels)
266 : TextureSpecCase (context, name, desc)
267 , m_texFormat (format)
268 , m_texFormatInfo (tcu::getTextureFormatInfo(format))
271 , m_numLevels (numLevels)
275 Texture2DSpecCase::~Texture2DSpecCase (void)
279 void Texture2DSpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext)
281 Texture2DShader shader (DataTypes() << glu::getSampler2DType(m_texFormat), glu::TYPE_FLOAT_VEC4);
282 deUint32 shaderIDgles = gles3Context.createProgram(&shader);
283 deUint32 shaderIDRef = refContext.createProgram(&shader);
285 shader.setTexScaleBias(0, m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias);
288 for (int ndx = 0; ndx < 2; ndx++)
290 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
294 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
295 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
296 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
297 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
298 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, m_numLevels-1);
301 for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++)
303 int levelW = de::max(1, m_width >> levelNdx);
304 int levelH = de::max(1, m_height >> levelNdx);
305 tcu::Surface reference;
308 for (int ndx = 0; ndx < 2; ndx++)
310 tcu::Surface& dst = ndx ? reference : result;
311 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
312 deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles;
315 shader.setUniforms(*ctx, shaderID);
316 renderTex(dst, shaderID, levelW, levelH);
319 UVec4 threshold = computeCompareThreshold(m_context.getRenderTarget().getPixelFormat(), m_texFormat);
320 string levelStr = de::toString(levelNdx);
321 string name = string("Level") + levelStr;
322 string desc = string("Level ") + levelStr;
323 bool isOk = tcu::intThresholdCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference.getAccess(), result.getAccess(), threshold,
324 levelNdx == 0 ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR);
328 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
334 class TextureCubeSpecCase : public TextureSpecCase
337 TextureCubeSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int size, int numLevels);
338 ~TextureCubeSpecCase (void);
341 virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext);
343 tcu::TextureFormat m_texFormat;
344 tcu::TextureFormatInfo m_texFormatInfo;
349 TextureCubeSpecCase::TextureCubeSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int size, int numLevels)
350 : TextureSpecCase (context, name, desc)
351 , m_texFormat (format)
352 , m_texFormatInfo (tcu::getTextureFormatInfo(format))
354 , m_numLevels (numLevels)
358 TextureCubeSpecCase::~TextureCubeSpecCase (void)
362 void TextureCubeSpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext)
364 TextureCubeShader shader (glu::getSamplerCubeType(m_texFormat), glu::TYPE_FLOAT_VEC4);
365 deUint32 shaderIDgles = gles3Context.createProgram(&shader);
366 deUint32 shaderIDRef = refContext.createProgram(&shader);
368 shader.setTexScaleBias(m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias);
371 for (int ndx = 0; ndx < 2; ndx++)
373 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
377 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
378 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
379 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
380 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
381 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, m_numLevels-1);
384 for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++)
386 int levelSize = de::max(1, m_size >> levelNdx);
389 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
391 tcu::Surface reference;
395 continue; // Fuzzy compare doesn't work for images this small.
397 shader.setFace((tcu::CubeFace)face);
399 for (int ndx = 0; ndx < 2; ndx++)
401 tcu::Surface& dst = ndx ? reference : result;
402 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
403 deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles;
406 shader.setUniforms(*ctx, shaderID);
407 renderTex(dst, shaderID, levelSize, levelSize);
410 const float threshold = 0.02f;
411 string faceStr = de::toString((tcu::CubeFace)face);
412 string levelStr = de::toString(levelNdx);
413 string name = string("Level") + levelStr;
414 string desc = string("Level ") + levelStr + ", face " + faceStr;
415 bool isFaceOk = tcu::fuzzyCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference, result, threshold,
416 levelNdx == 0 ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR);
420 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
431 class Texture2DArraySpecCase : public TextureSpecCase
434 Texture2DArraySpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLayers, int numLevels);
435 ~Texture2DArraySpecCase (void);
438 virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext);
440 tcu::TextureFormat m_texFormat;
441 tcu::TextureFormatInfo m_texFormatInfo;
448 Texture2DArraySpecCase::Texture2DArraySpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLayers, int numLevels)
449 : TextureSpecCase (context, name, desc)
450 , m_texFormat (format)
451 , m_texFormatInfo (tcu::getTextureFormatInfo(format))
454 , m_numLayers (numLayers)
455 , m_numLevels (numLevels)
459 Texture2DArraySpecCase::~Texture2DArraySpecCase (void)
463 void Texture2DArraySpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext)
465 Texture2DArrayShader shader (glu::getSampler2DArrayType(m_texFormat), glu::TYPE_FLOAT_VEC4);
466 deUint32 shaderIDgles = gles3Context.createProgram(&shader);
467 deUint32 shaderIDRef = refContext.createProgram(&shader);
469 shader.setTexScaleBias(m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias);
472 for (int ndx = 0; ndx < 2; ndx++)
474 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
478 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
479 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
480 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
481 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
482 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
483 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, m_numLevels-1);
486 for (int layerNdx = 0; layerNdx < m_numLayers; layerNdx++)
490 shader.setLayer(layerNdx);
492 for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++)
494 int levelW = de::max(1, m_width >> levelNdx);
495 int levelH = de::max(1, m_height >> levelNdx);
496 tcu::Surface reference;
499 for (int ndx = 0; ndx < 2; ndx++)
501 tcu::Surface& dst = ndx ? reference : result;
502 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
503 deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles;
506 shader.setUniforms(*ctx, shaderID);
507 renderTex(dst, shaderID, levelW, levelH);
510 UVec4 threshold = computeCompareThreshold(m_context.getRenderTarget().getPixelFormat(), m_texFormat);
511 string levelStr = de::toString(levelNdx);
512 string layerStr = de::toString(layerNdx);
513 string name = string("Layer") + layerStr + "Level" + levelStr;
514 string desc = string("Layer ") + layerStr + ", Level " + levelStr;
515 bool depthOk = tcu::intThresholdCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference.getAccess(), result.getAccess(), threshold,
516 (levelNdx == 0 && layerNdx == 0) ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR);
520 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
531 class Texture3DSpecCase : public TextureSpecCase
534 Texture3DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int depth, int numLevels);
535 ~Texture3DSpecCase (void);
538 virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext);
540 tcu::TextureFormat m_texFormat;
541 tcu::TextureFormatInfo m_texFormatInfo;
548 Texture3DSpecCase::Texture3DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int depth, int numLevels)
549 : TextureSpecCase (context, name, desc)
550 , m_texFormat (format)
551 , m_texFormatInfo (tcu::getTextureFormatInfo(format))
555 , m_numLevels (numLevels)
559 Texture3DSpecCase::~Texture3DSpecCase (void)
563 void Texture3DSpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext)
565 Texture3DShader shader (glu::getSampler3DType(m_texFormat), glu::TYPE_FLOAT_VEC4);
566 deUint32 shaderIDgles = gles3Context.createProgram(&shader);
567 deUint32 shaderIDRef = refContext.createProgram(&shader);
569 shader.setTexScaleBias(m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias);
572 for (int ndx = 0; ndx < 2; ndx++)
574 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
578 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
579 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
580 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
581 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
582 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
583 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, m_numLevels-1);
586 for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++)
588 int levelW = de::max(1, m_width >> levelNdx);
589 int levelH = de::max(1, m_height >> levelNdx);
590 int levelD = de::max(1, m_depth >> levelNdx);
593 for (int depth = 0; depth < levelD; depth++)
595 tcu::Surface reference;
598 shader.setDepth(((float)depth + 0.5f) / (float)levelD);
600 for (int ndx = 0; ndx < 2; ndx++)
602 tcu::Surface& dst = ndx ? reference : result;
603 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
604 deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles;
607 shader.setUniforms(*ctx, shaderID);
608 renderTex(dst, shaderID, levelW, levelH);
611 UVec4 threshold = computeCompareThreshold(m_context.getRenderTarget().getPixelFormat(), m_texFormat);
612 string levelStr = de::toString(levelNdx);
613 string sliceStr = de::toString(depth);
614 string name = string("Level") + levelStr + "Slice" + sliceStr;
615 string desc = string("Level ") + levelStr + ", Slice " + sliceStr;
616 bool depthOk = tcu::intThresholdCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference.getAccess(), result.getAccess(), threshold,
617 (levelNdx == 0 && depth == 0) ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR);
621 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
632 // Basic TexImage2D() with 2D texture usage
633 class BasicTexImage2DCase : public Texture2DSpecCase
636 // Unsized internal format.
637 BasicTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height)
638 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height))
639 , m_internalFormat (format)
641 , m_dataType (dataType)
645 // Sized internal format.
646 BasicTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height)
647 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height))
648 , m_internalFormat (internalFormat)
650 , m_dataType (GL_NONE)
652 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
653 m_format = fmt.format;
654 m_dataType = fmt.dataType;
658 void createTexture (void)
661 tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType));
662 de::Random rnd (deStringHash(getName()));
664 glGenTextures(1, &tex);
665 glBindTexture(GL_TEXTURE_2D, tex);
666 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
668 for (int ndx = 0; ndx < m_numLevels; ndx++)
670 int levelW = de::max(1, m_width >> ndx);
671 int levelH = de::max(1, m_height >> ndx);
672 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
673 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
675 levelData.setSize(levelW, levelH);
676 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
678 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, levelData.getAccess().getDataPtr());
682 deUint32 m_internalFormat;
687 // Basic TexImage2D() with cubemap usage
688 class BasicTexImageCubeCase : public TextureCubeSpecCase
692 BasicTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size)
693 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1)
694 , m_internalFormat (format)
696 , m_dataType (dataType)
700 // Sized internal formats.
701 BasicTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size)
702 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1)
703 , m_internalFormat (internalFormat)
705 , m_dataType (GL_NONE)
707 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
708 m_format = fmt.format;
709 m_dataType = fmt.dataType;
713 void createTexture (void)
716 tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType));
717 de::Random rnd (deStringHash(getName()));
719 glGenTextures(1, &tex);
720 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
721 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
723 for (int ndx = 0; ndx < m_numLevels; ndx++)
725 int levelSize = de::max(1, m_size >> ndx);
727 levelData.setSize(levelSize, levelSize);
729 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
731 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
732 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
734 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
736 glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, levelData.getAccess().getDataPtr());
741 deUint32 m_internalFormat;
746 // Basic TexImage3D() with 2D array texture usage
747 class BasicTexImage2DArrayCase : public Texture2DArraySpecCase
750 BasicTexImage2DArrayCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLayers)
751 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLayers, maxLevelCount(width, height))
752 , m_internalFormat (internalFormat)
757 void createTexture (void)
760 de::Random rnd (deStringHash(getName()));
761 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
762 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
764 glGenTextures(1, &tex);
765 glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
766 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
768 for (int ndx = 0; ndx < m_numLevels; ndx++)
770 int levelW = de::max(1, m_width >> ndx);
771 int levelH = de::max(1, m_height >> ndx);
772 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
773 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
775 levelData.setSize(levelW, levelH, m_numLayers);
776 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
778 glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
782 deUint32 m_internalFormat;
785 // Basic TexImage3D() with 3D texture usage
786 class BasicTexImage3DCase : public Texture3DSpecCase
789 BasicTexImage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth)
790 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, maxLevelCount(width, height, depth))
791 , m_internalFormat (internalFormat)
796 void createTexture (void)
799 de::Random rnd (deStringHash(getName()));
800 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
801 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
803 glGenTextures(1, &tex);
804 glBindTexture(GL_TEXTURE_3D, tex);
805 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
807 for (int ndx = 0; ndx < m_numLevels; ndx++)
809 int levelW = de::max(1, m_width >> ndx);
810 int levelH = de::max(1, m_height >> ndx);
811 int levelD = de::max(1, m_depth >> ndx);
812 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
813 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
815 levelData.setSize(levelW, levelH, levelD);
816 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
818 glTexImage3D(GL_TEXTURE_3D, ndx, m_internalFormat, levelW, levelH, levelD, 0, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
822 deUint32 m_internalFormat;
825 // Randomized 2D texture specification using TexImage2D
826 class RandomOrderTexImage2DCase : public Texture2DSpecCase
829 RandomOrderTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height)
830 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height))
831 , m_internalFormat (format)
833 , m_dataType (dataType)
837 RandomOrderTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height)
838 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height))
839 , m_internalFormat (internalFormat)
841 , m_dataType (GL_NONE)
843 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
844 m_format = fmt.format;
845 m_dataType = fmt.dataType;
849 void createTexture (void)
852 tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType));
853 de::Random rnd (deStringHash(getName()));
855 glGenTextures(1, &tex);
856 glBindTexture(GL_TEXTURE_2D, tex);
857 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
859 vector<int> levels (m_numLevels);
861 for (int i = 0; i < m_numLevels; i++)
863 rnd.shuffle(levels.begin(), levels.end());
865 for (int ndx = 0; ndx < m_numLevels; ndx++)
867 int levelNdx = levels[ndx];
868 int levelW = de::max(1, m_width >> levelNdx);
869 int levelH = de::max(1, m_height >> levelNdx);
870 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
871 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
873 levelData.setSize(levelW, levelH);
874 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
876 glTexImage2D(GL_TEXTURE_2D, levelNdx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, levelData.getAccess().getDataPtr());
880 deUint32 m_internalFormat;
885 // Randomized cubemap texture specification using TexImage2D
886 class RandomOrderTexImageCubeCase : public TextureCubeSpecCase
889 RandomOrderTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size)
890 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1)
891 , m_internalFormat (GL_NONE)
893 , m_dataType (dataType)
897 RandomOrderTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size)
898 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1)
899 , m_internalFormat (internalFormat)
901 , m_dataType (GL_NONE)
903 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
904 m_format = fmt.format;
905 m_dataType = fmt.dataType;
909 void createTexture (void)
912 tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType));
913 de::Random rnd (deStringHash(getName()));
915 glGenTextures(1, &tex);
916 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
917 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
920 vector<pair<int, tcu::CubeFace> > images (m_numLevels*6);
922 for (int ndx = 0; ndx < m_numLevels; ndx++)
923 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
924 images[ndx*6 + face] = std::make_pair(ndx, (tcu::CubeFace)face);
926 rnd.shuffle(images.begin(), images.end());
928 for (int ndx = 0; ndx < (int)images.size(); ndx++)
930 int levelNdx = images[ndx].first;
931 tcu::CubeFace face = images[ndx].second;
932 int levelSize = de::max(1, m_size >> levelNdx);
933 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
934 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
936 levelData.setSize(levelSize, levelSize);
937 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
939 glTexImage2D(s_cubeMapFaces[face], levelNdx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, levelData.getAccess().getDataPtr());
943 deUint32 m_internalFormat;
948 // TexImage2D() unpack alignment case.
949 class TexImage2DAlignCase : public Texture2DSpecCase
952 TexImage2DAlignCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height, int numLevels, int alignment)
953 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, numLevels)
954 , m_internalFormat (format)
956 , m_dataType (dataType)
957 , m_alignment (alignment)
961 TexImage2DAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLevels, int alignment)
962 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLevels)
963 , m_internalFormat (internalFormat)
965 , m_dataType (GL_NONE)
966 , m_alignment (alignment)
968 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
969 m_format = fmt.format;
970 m_dataType = fmt.dataType;
974 void createTexture (void)
977 vector<deUint8> data;
979 glGenTextures(1, &tex);
980 glBindTexture(GL_TEXTURE_2D, tex);
981 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
983 for (int ndx = 0; ndx < m_numLevels; ndx++)
985 int levelW = de::max(1, m_width >> ndx);
986 int levelH = de::max(1, m_height >> ndx);
987 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin;
988 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin;
989 int rowPitch = deAlign32(levelW*m_texFormat.getPixelSize(), m_alignment);
990 int cellSize = de::max(1, de::min(levelW >> 2, levelH >> 2));
992 data.resize(rowPitch*levelH);
993 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, levelW, levelH, 1, rowPitch, 0, &data[0]), cellSize, colorA, colorB);
995 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, &data[0]);
999 deUint32 m_internalFormat;
1001 deUint32 m_dataType;
1005 // TexImage2D() unpack alignment case.
1006 class TexImageCubeAlignCase : public TextureCubeSpecCase
1009 TexImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size, int numLevels, int alignment)
1010 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, numLevels)
1011 , m_internalFormat (format)
1013 , m_dataType (dataType)
1014 , m_alignment (alignment)
1018 TexImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int numLevels, int alignment)
1019 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, numLevels)
1020 , m_internalFormat (internalFormat)
1021 , m_format (GL_NONE)
1022 , m_dataType (GL_NONE)
1023 , m_alignment (alignment)
1025 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
1026 m_format = fmt.format;
1027 m_dataType = fmt.dataType;
1031 void createTexture (void)
1034 vector<deUint8> data;
1036 glGenTextures(1, &tex);
1037 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
1038 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
1040 for (int ndx = 0; ndx < m_numLevels; ndx++)
1042 int levelSize = de::max(1, m_size >> ndx);
1043 int rowPitch = deAlign32(m_texFormat.getPixelSize()*levelSize, m_alignment);
1044 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin;
1045 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin;
1046 int cellSize = de::max(1, levelSize >> 2);
1048 data.resize(rowPitch*levelSize);
1049 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, levelSize, levelSize, 1, rowPitch, 0, &data[0]), cellSize, colorA, colorB);
1051 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
1052 glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, &data[0]);
1056 deUint32 m_internalFormat;
1058 deUint32 m_dataType;
1062 // TexImage2D() unpack parameters case.
1063 class TexImage2DParamsCase : public Texture2DSpecCase
1066 TexImage2DParamsCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int rowLength, int skipRows, int skipPixels, int alignment)
1067 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1)
1068 , m_internalFormat (internalFormat)
1069 , m_rowLength (rowLength)
1070 , m_skipRows (skipRows)
1071 , m_skipPixels (skipPixels)
1072 , m_alignment (alignment)
1077 void createTexture (void)
1079 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
1080 int pixelSize = m_texFormat.getPixelSize();
1081 int rowLength = m_rowLength > 0 ? m_rowLength : m_width;
1082 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
1084 vector<deUint8> data;
1086 DE_ASSERT(m_numLevels == 1);
1088 // Fill data with grid.
1089 data.resize(pixelSize * m_skipPixels + rowPitch * (m_height + m_skipRows));
1091 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
1092 Vec4 cBias = m_texFormatInfo.valueMin;
1093 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
1094 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
1096 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB);
1099 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
1100 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
1101 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
1102 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
1104 glGenTextures(1, &tex);
1105 glBindTexture(GL_TEXTURE_2D, tex);
1106 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]);
1109 deUint32 m_internalFormat;
1116 // TexImage3D() unpack parameters case.
1117 class TexImage3DParamsCase : public Texture3DSpecCase
1120 TexImage3DParamsCase (Context& context,
1123 deUint32 internalFormat,
1133 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
1134 , m_internalFormat (internalFormat)
1135 , m_imageHeight (imageHeight)
1136 , m_rowLength (rowLength)
1137 , m_skipImages (skipImages)
1138 , m_skipRows (skipRows)
1139 , m_skipPixels (skipPixels)
1140 , m_alignment (alignment)
1145 void createTexture (void)
1147 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
1148 int pixelSize = m_texFormat.getPixelSize();
1149 int rowLength = m_rowLength > 0 ? m_rowLength : m_width;
1150 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
1151 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height;
1152 int slicePitch = imageHeight*rowPitch;
1154 vector<deUint8> data;
1156 DE_ASSERT(m_numLevels == 1);
1158 // Fill data with grid.
1159 data.resize(pixelSize * m_skipPixels + rowPitch * m_skipRows + slicePitch * (m_skipImages + m_depth));
1161 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
1162 Vec4 cBias = m_texFormatInfo.valueMin;
1163 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
1164 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
1166 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB);
1169 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
1170 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
1171 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
1172 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
1173 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
1174 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
1176 glGenTextures(1, &tex);
1177 glBindTexture(GL_TEXTURE_3D, tex);
1178 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]);
1181 deUint32 m_internalFormat;
1190 // Basic TexSubImage2D() with 2D texture usage
1191 class BasicTexSubImage2DCase : public Texture2DSpecCase
1194 BasicTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height)
1195 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height))
1196 , m_internalFormat (format)
1198 , m_dataType (dataType)
1202 BasicTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height)
1203 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height))
1204 , m_internalFormat (internalFormat)
1205 , m_format (GL_NONE)
1206 , m_dataType (GL_NONE)
1208 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
1209 m_format = fmt.format;
1210 m_dataType = fmt.dataType;
1214 void createTexture (void)
1217 tcu::TextureLevel data (m_texFormat);
1218 de::Random rnd (deStringHash(getName()));
1220 glGenTextures(1, &tex);
1221 glBindTexture(GL_TEXTURE_2D, tex);
1222 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1224 // First specify full texture.
1225 for (int ndx = 0; ndx < m_numLevels; ndx++)
1227 int levelW = de::max(1, m_width >> ndx);
1228 int levelH = de::max(1, m_height >> ndx);
1229 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1230 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1232 data.setSize(levelW, levelH);
1233 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax);
1235 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, data.getAccess().getDataPtr());
1238 // Re-specify parts of each level.
1239 for (int ndx = 0; ndx < m_numLevels; ndx++)
1241 int levelW = de::max(1, m_width >> ndx);
1242 int levelH = de::max(1, m_height >> ndx);
1244 int w = rnd.getInt(1, levelW);
1245 int h = rnd.getInt(1, levelH);
1246 int x = rnd.getInt(0, levelW-w);
1247 int y = rnd.getInt(0, levelH-h);
1249 Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1250 Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1251 int cellSize = rnd.getInt(2, 16);
1254 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB);
1256 glTexSubImage2D(GL_TEXTURE_2D, ndx, x, y, w, h, m_format, m_dataType, data.getAccess().getDataPtr());
1260 deUint32 m_internalFormat;
1262 deUint32 m_dataType;
1265 // Basic TexSubImage2D() with cubemap usage
1266 class BasicTexSubImageCubeCase : public TextureCubeSpecCase
1269 BasicTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size)
1270 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1)
1271 , m_internalFormat (format)
1273 , m_dataType (dataType)
1277 BasicTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size)
1278 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1)
1279 , m_internalFormat (internalFormat)
1280 , m_format (GL_NONE)
1281 , m_dataType (GL_NONE)
1283 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
1284 m_format = fmt.format;
1285 m_dataType = fmt.dataType;
1289 void createTexture (void)
1292 tcu::TextureLevel data (m_texFormat);
1293 de::Random rnd (deStringHash(getName()));
1295 glGenTextures(1, &tex);
1296 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
1297 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1299 for (int ndx = 0; ndx < m_numLevels; ndx++)
1301 int levelSize = de::max(1, m_size >> ndx);
1303 data.setSize(levelSize, levelSize);
1305 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
1307 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1308 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1310 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax);
1312 glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, data.getAccess().getDataPtr());
1316 // Re-specify parts of each face and level.
1317 for (int ndx = 0; ndx < m_numLevels; ndx++)
1319 int levelSize = de::max(1, m_size >> ndx);
1321 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
1323 int w = rnd.getInt(1, levelSize);
1324 int h = rnd.getInt(1, levelSize);
1325 int x = rnd.getInt(0, levelSize-w);
1326 int y = rnd.getInt(0, levelSize-h);
1328 Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1329 Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1330 int cellSize = rnd.getInt(2, 16);
1333 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB);
1335 glTexSubImage2D(s_cubeMapFaces[face], ndx, x, y, w, h, m_format, m_dataType, data.getAccess().getDataPtr());
1340 deUint32 m_internalFormat;
1342 deUint32 m_dataType;
1345 // TexSubImage2D() unpack parameters case.
1346 class TexSubImage2DParamsCase : public Texture2DSpecCase
1349 TexSubImage2DParamsCase (Context& context,
1352 deUint32 internalFormat,
1363 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1)
1364 , m_internalFormat (internalFormat)
1369 , m_rowLength (rowLength)
1370 , m_skipRows (skipRows)
1371 , m_skipPixels (skipPixels)
1372 , m_alignment (alignment)
1377 void createTexture (void)
1379 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
1380 int pixelSize = m_texFormat.getPixelSize();
1382 vector<deUint8> data;
1384 DE_ASSERT(m_numLevels == 1);
1386 glGenTextures(1, &tex);
1387 glBindTexture(GL_TEXTURE_2D, tex);
1389 // First fill texture with gradient.
1390 data.resize(deAlign32(m_width*pixelSize, 4)*m_height);
1391 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, deAlign32(m_width*pixelSize, 4), 0, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1392 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]);
1394 // Fill data with grid.
1396 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
1397 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
1398 int height = m_subH + m_skipRows;
1399 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
1400 Vec4 cBias = m_texFormatInfo.valueMin;
1401 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
1402 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
1404 data.resize(rowPitch*height);
1405 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB);
1408 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
1409 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
1410 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
1411 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
1412 glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, &data[0]);
1415 deUint32 m_internalFormat;
1426 // Basic TexSubImage3D() with 3D texture usage
1427 class BasicTexSubImage3DCase : public Texture3DSpecCase
1430 BasicTexSubImage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth)
1431 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, maxLevelCount(width, height, depth))
1432 , m_internalFormat (internalFormat)
1437 void createTexture (void)
1440 tcu::TextureLevel data (m_texFormat);
1441 de::Random rnd (deStringHash(getName()));
1442 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
1444 glGenTextures(1, &tex);
1445 glBindTexture(GL_TEXTURE_3D, tex);
1446 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1448 // First specify full texture.
1449 for (int ndx = 0; ndx < m_numLevels; ndx++)
1451 int levelW = de::max(1, m_width >> ndx);
1452 int levelH = de::max(1, m_height >> ndx);
1453 int levelD = de::max(1, m_depth >> ndx);
1454 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1455 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1457 data.setSize(levelW, levelH, levelD);
1458 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax);
1460 glTexImage3D(GL_TEXTURE_3D, ndx, m_internalFormat, levelW, levelH, levelD, 0, transferFmt.format, transferFmt.dataType, data.getAccess().getDataPtr());
1463 // Re-specify parts of each level.
1464 for (int ndx = 0; ndx < m_numLevels; ndx++)
1466 int levelW = de::max(1, m_width >> ndx);
1467 int levelH = de::max(1, m_height >> ndx);
1468 int levelD = de::max(1, m_depth >> ndx);
1470 int w = rnd.getInt(1, levelW);
1471 int h = rnd.getInt(1, levelH);
1472 int d = rnd.getInt(1, levelD);
1473 int x = rnd.getInt(0, levelW-w);
1474 int y = rnd.getInt(0, levelH-h);
1475 int z = rnd.getInt(0, levelD-d);
1477 Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1478 Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1479 int cellSize = rnd.getInt(2, 16);
1481 data.setSize(w, h, d);
1482 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB);
1484 glTexSubImage3D(GL_TEXTURE_3D, ndx, x, y, z, w, h, d, transferFmt.format, transferFmt.dataType, data.getAccess().getDataPtr());
1488 deUint32 m_internalFormat;
1491 // TexSubImage2D() to texture initialized with empty data
1492 class TexSubImage2DEmptyTexCase : public Texture2DSpecCase
1495 TexSubImage2DEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height)
1496 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height))
1497 , m_internalFormat (format)
1499 , m_dataType (dataType)
1503 TexSubImage2DEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height)
1504 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height))
1505 , m_internalFormat (internalFormat)
1506 , m_format (GL_NONE)
1507 , m_dataType (GL_NONE)
1509 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
1510 m_format = fmt.format;
1511 m_dataType = fmt.dataType;
1515 void createTexture (void)
1518 tcu::TextureLevel data (m_texFormat);
1519 de::Random rnd (deStringHash(getName()));
1521 glGenTextures(1, &tex);
1522 glBindTexture(GL_TEXTURE_2D, tex);
1523 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1525 // First allocate storage for each level.
1526 for (int ndx = 0; ndx < m_numLevels; ndx++)
1528 int levelW = de::max(1, m_width >> ndx);
1529 int levelH = de::max(1, m_height >> ndx);
1531 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, DE_NULL);
1534 // Specify pixel data to all levels using glTexSubImage2D()
1535 for (int ndx = 0; ndx < m_numLevels; ndx++)
1537 int levelW = de::max(1, m_width >> ndx);
1538 int levelH = de::max(1, m_height >> ndx);
1539 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1540 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1542 data.setSize(levelW, levelH);
1543 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax);
1545 glTexSubImage2D(GL_TEXTURE_2D, ndx, 0, 0, levelW, levelH, m_format, m_dataType, data.getAccess().getDataPtr());
1549 deUint32 m_internalFormat;
1551 deUint32 m_dataType;
1554 // TexSubImage2D() to empty cubemap texture
1555 class TexSubImageCubeEmptyTexCase : public TextureCubeSpecCase
1558 TexSubImageCubeEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size)
1559 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1)
1560 , m_internalFormat (format)
1562 , m_dataType (dataType)
1566 TexSubImageCubeEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size)
1567 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1)
1568 , m_internalFormat (internalFormat)
1569 , m_format (GL_NONE)
1570 , m_dataType (GL_NONE)
1572 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
1573 m_format = fmt.format;
1574 m_dataType = fmt.dataType;
1578 void createTexture (void)
1581 tcu::TextureLevel data (m_texFormat);
1582 de::Random rnd (deStringHash(getName()));
1584 glGenTextures(1, &tex);
1585 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
1586 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1588 // Specify storage for each level.
1589 for (int ndx = 0; ndx < m_numLevels; ndx++)
1591 int levelSize = de::max(1, m_size >> ndx);
1593 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
1594 glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, DE_NULL);
1597 // Specify data using glTexSubImage2D()
1598 for (int ndx = 0; ndx < m_numLevels; ndx++)
1600 int levelSize = de::max(1, m_size >> ndx);
1602 data.setSize(levelSize, levelSize);
1604 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
1606 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1607 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1609 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax);
1611 glTexSubImage2D(s_cubeMapFaces[face], ndx, 0, 0, levelSize, levelSize, m_format, m_dataType, data.getAccess().getDataPtr());
1616 deUint32 m_internalFormat;
1618 deUint32 m_dataType;
1621 // TexSubImage2D() unpack alignment with 2D texture
1622 class TexSubImage2DAlignCase : public Texture2DSpecCase
1625 TexSubImage2DAlignCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height, int subX, int subY, int subW, int subH, int alignment)
1626 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, 1)
1627 , m_internalFormat (format)
1629 , m_dataType (dataType)
1634 , m_alignment (alignment)
1638 TexSubImage2DAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int subX, int subY, int subW, int subH, int alignment)
1639 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1)
1640 , m_internalFormat (internalFormat)
1641 , m_format (GL_NONE)
1642 , m_dataType (GL_NONE)
1647 , m_alignment (alignment)
1649 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
1650 m_format = fmt.format;
1651 m_dataType = fmt.dataType;
1655 void createTexture (void)
1658 vector<deUint8> data;
1660 glGenTextures(1, &tex);
1661 glBindTexture(GL_TEXTURE_2D, tex);
1663 // Specify base level.
1664 data.resize(m_texFormat.getPixelSize()*m_width*m_height);
1665 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, &data[0]), Vec4(0.0f), Vec4(1.0f));
1667 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1668 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, m_format, m_dataType, &data[0]);
1670 // Re-specify subrectangle.
1671 int rowPitch = deAlign32(m_texFormat.getPixelSize()*m_subW, m_alignment);
1672 data.resize(rowPitch*m_subH);
1673 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0]), 4, Vec4(1.0f, 0.0f, 0.0f, 1.0f), Vec4(0.0f, 1.0f, 0.0f, 1.0f));
1675 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
1676 glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, m_format, m_dataType, &data[0]);
1679 deUint32 m_internalFormat;
1681 deUint32 m_dataType;
1689 // TexSubImage2D() unpack alignment with cubemap texture
1690 class TexSubImageCubeAlignCase : public TextureCubeSpecCase
1693 TexSubImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size, int subX, int subY, int subW, int subH, int alignment)
1694 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, 1)
1695 , m_internalFormat (format)
1697 , m_dataType (dataType)
1702 , m_alignment (alignment)
1706 TexSubImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int subX, int subY, int subW, int subH, int alignment)
1707 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1)
1708 , m_internalFormat (internalFormat)
1709 , m_format (GL_NONE)
1710 , m_dataType (GL_NONE)
1715 , m_alignment (alignment)
1717 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
1718 m_format = fmt.format;
1719 m_dataType = fmt.dataType;
1723 void createTexture (void)
1726 vector<deUint8> data;
1728 glGenTextures(1, &tex);
1729 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
1731 // Specify base level.
1732 data.resize(m_texFormat.getPixelSize()*m_size*m_size);
1733 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_size, m_size, 1, &data[0]), Vec4(0.0f), Vec4(1.0f));
1735 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1736 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
1737 glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, m_format, m_dataType, &data[0]);
1739 // Re-specify subrectangle.
1740 int rowPitch = deAlign32(m_texFormat.getPixelSize()*m_subW, m_alignment);
1741 data.resize(rowPitch*m_subH);
1742 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0]), 4, Vec4(1.0f, 0.0f, 0.0f, 1.0f), Vec4(0.0f, 1.0f, 0.0f, 1.0f));
1744 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
1745 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
1746 glTexSubImage2D(s_cubeMapFaces[face], 0, m_subX, m_subY, m_subW, m_subH, m_format, m_dataType, &data[0]);
1749 deUint32 m_internalFormat;
1751 deUint32 m_dataType;
1759 // TexSubImage3D() unpack parameters case.
1760 class TexSubImage3DParamsCase : public Texture3DSpecCase
1763 TexSubImage3DParamsCase (Context& context,
1766 deUint32 internalFormat,
1782 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
1783 , m_internalFormat (internalFormat)
1790 , m_imageHeight (imageHeight)
1791 , m_rowLength (rowLength)
1792 , m_skipImages (skipImages)
1793 , m_skipRows (skipRows)
1794 , m_skipPixels (skipPixels)
1795 , m_alignment (alignment)
1800 void createTexture (void)
1802 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
1803 int pixelSize = m_texFormat.getPixelSize();
1805 vector<deUint8> data;
1807 DE_ASSERT(m_numLevels == 1);
1809 glGenTextures(1, &tex);
1810 glBindTexture(GL_TEXTURE_3D, tex);
1812 // Fill with gradient.
1814 int rowPitch = deAlign32(pixelSize*m_width, 4);
1815 int slicePitch = rowPitch*m_height;
1817 data.resize(slicePitch*m_depth);
1818 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
1821 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]);
1823 // Fill data with grid.
1825 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
1826 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
1827 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH;
1828 int slicePitch = imageHeight*rowPitch;
1829 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
1830 Vec4 cBias = m_texFormatInfo.valueMin;
1831 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
1832 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
1834 data.resize(slicePitch*(m_depth+m_skipImages));
1835 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, m_subD, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB);
1838 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
1839 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
1840 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
1841 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
1842 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
1843 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
1844 glTexSubImage3D(GL_TEXTURE_3D, 0, m_subX, m_subY, m_subZ, m_subW, m_subH, m_subD, transferFmt.format, transferFmt.dataType, &data[0]);
1847 deUint32 m_internalFormat;
1862 // Basic CopyTexImage2D() with 2D texture usage
1863 class BasicCopyTexImage2DCase : public Texture2DSpecCase
1866 BasicCopyTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height)
1867 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(internalFormat, GL_UNSIGNED_BYTE), width, height, maxLevelCount(width, height))
1868 , m_internalFormat (internalFormat)
1873 void createTexture (void)
1875 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget();
1876 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0;
1877 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0;
1878 tcu::TextureFormat fmt = mapGLUnsizedInternalFormat(m_internalFormat);
1879 bool texHasRGB = fmt.order != tcu::TextureFormat::A;
1880 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A;
1882 de::Random rnd (deStringHash(getName()));
1883 GradientShader shader (glu::TYPE_FLOAT_VEC4);
1884 deUint32 shaderID = getCurrentContext()->createProgram(&shader);
1886 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
1887 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__);
1889 // Fill render target with gradient.
1890 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f));
1891 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f));
1893 glGenTextures(1, &tex);
1894 glBindTexture(GL_TEXTURE_2D, tex);
1896 for (int ndx = 0; ndx < m_numLevels; ndx++)
1898 int levelW = de::max(1, m_width >> ndx);
1899 int levelH = de::max(1, m_height >> ndx);
1900 int x = rnd.getInt(0, getWidth() - levelW);
1901 int y = rnd.getInt(0, getHeight() - levelH);
1903 glCopyTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, x, y, levelW, levelH, 0);
1907 deUint32 m_internalFormat;
1910 // Basic CopyTexImage2D() with cubemap usage
1911 class BasicCopyTexImageCubeCase : public TextureCubeSpecCase
1914 BasicCopyTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size)
1915 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(internalFormat, GL_UNSIGNED_BYTE), size, deLog2Floor32(size)+1)
1916 , m_internalFormat (internalFormat)
1921 void createTexture (void)
1923 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget();
1924 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0;
1925 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0;
1926 tcu::TextureFormat fmt = mapGLUnsizedInternalFormat(m_internalFormat);
1927 bool texHasRGB = fmt.order != tcu::TextureFormat::A;
1928 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A;
1930 de::Random rnd (deStringHash(getName()));
1931 GradientShader shader (glu::TYPE_FLOAT_VEC4);
1932 deUint32 shaderID = getCurrentContext()->createProgram(&shader);
1934 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
1935 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__);
1937 // Fill render target with gradient.
1938 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f));
1939 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f));
1941 glGenTextures(1, &tex);
1942 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
1944 for (int ndx = 0; ndx < m_numLevels; ndx++)
1946 int levelSize = de::max(1, m_size >> ndx);
1948 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
1950 int x = rnd.getInt(0, getWidth() - levelSize);
1951 int y = rnd.getInt(0, getHeight() - levelSize);
1953 glCopyTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, x, y, levelSize, levelSize, 0);
1958 deUint32 m_internalFormat;
1961 // Basic CopyTexSubImage2D() with 2D texture usage
1962 class BasicCopyTexSubImage2DCase : public Texture2DSpecCase
1965 BasicCopyTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height)
1966 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height))
1968 , m_dataType (dataType)
1973 void createTexture (void)
1975 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget();
1976 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0;
1977 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0;
1978 tcu::TextureFormat fmt = glu::mapGLTransferFormat(m_format, m_dataType);
1979 bool texHasRGB = fmt.order != tcu::TextureFormat::A;
1980 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A;
1982 tcu::TextureLevel data (fmt);
1983 de::Random rnd (deStringHash(getName()));
1984 GradientShader shader (glu::TYPE_FLOAT_VEC4);
1985 deUint32 shaderID = getCurrentContext()->createProgram(&shader);
1987 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
1988 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__);
1990 glGenTextures(1, &tex);
1991 glBindTexture(GL_TEXTURE_2D, tex);
1992 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1994 // First specify full texture.
1995 for (int ndx = 0; ndx < m_numLevels; ndx++)
1997 int levelW = de::max(1, m_width >> ndx);
1998 int levelH = de::max(1, m_height >> ndx);
2000 Vec4 colorA = randomVector<4>(rnd);
2001 Vec4 colorB = randomVector<4>(rnd);
2002 int cellSize = rnd.getInt(2, 16);
2004 data.setSize(levelW, levelH);
2005 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB);
2007 glTexImage2D(GL_TEXTURE_2D, ndx, m_format, levelW, levelH, 0, m_format, m_dataType, data.getAccess().getDataPtr());
2010 // Fill render target with gradient.
2011 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f));
2012 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f));
2014 // Re-specify parts of each level.
2015 for (int ndx = 0; ndx < m_numLevels; ndx++)
2017 int levelW = de::max(1, m_width >> ndx);
2018 int levelH = de::max(1, m_height >> ndx);
2020 int w = rnd.getInt(1, levelW);
2021 int h = rnd.getInt(1, levelH);
2022 int xo = rnd.getInt(0, levelW-w);
2023 int yo = rnd.getInt(0, levelH-h);
2025 int x = rnd.getInt(0, getWidth() - w);
2026 int y = rnd.getInt(0, getHeight() - h);
2028 glCopyTexSubImage2D(GL_TEXTURE_2D, ndx, xo, yo, x, y, w, h);
2033 deUint32 m_dataType;
2036 // Basic CopyTexSubImage2D() with cubemap usage
2037 class BasicCopyTexSubImageCubeCase : public TextureCubeSpecCase
2040 BasicCopyTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size)
2041 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1)
2043 , m_dataType (dataType)
2048 void createTexture (void)
2050 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget();
2051 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0;
2052 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0;
2053 tcu::TextureFormat fmt = glu::mapGLTransferFormat(m_format, m_dataType);
2054 bool texHasRGB = fmt.order != tcu::TextureFormat::A;
2055 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A;
2057 tcu::TextureLevel data (fmt);
2058 de::Random rnd (deStringHash(getName()));
2059 GradientShader shader (glu::TYPE_FLOAT_VEC4);
2060 deUint32 shaderID = getCurrentContext()->createProgram(&shader);
2062 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
2063 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__);
2065 glGenTextures(1, &tex);
2066 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
2067 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2069 for (int ndx = 0; ndx < m_numLevels; ndx++)
2071 int levelSize = de::max(1, m_size >> ndx);
2073 data.setSize(levelSize, levelSize);
2075 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
2077 Vec4 colorA = randomVector<4>(rnd);
2078 Vec4 colorB = randomVector<4>(rnd);
2079 int cellSize = rnd.getInt(2, 16);
2081 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB);
2082 glTexImage2D(s_cubeMapFaces[face], ndx, m_format, levelSize, levelSize, 0, m_format, m_dataType, data.getAccess().getDataPtr());
2086 // Fill render target with gradient.
2087 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f));
2088 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f));
2090 // Re-specify parts of each face and level.
2091 for (int ndx = 0; ndx < m_numLevels; ndx++)
2093 int levelSize = de::max(1, m_size >> ndx);
2095 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
2097 int w = rnd.getInt(1, levelSize);
2098 int h = rnd.getInt(1, levelSize);
2099 int xo = rnd.getInt(0, levelSize-w);
2100 int yo = rnd.getInt(0, levelSize-h);
2102 int x = rnd.getInt(0, getWidth() - w);
2103 int y = rnd.getInt(0, getHeight() - h);
2105 glCopyTexSubImage2D(s_cubeMapFaces[face], ndx, xo, yo, x, y, w, h);
2111 deUint32 m_dataType;
2114 // Basic glTexStorage2D() with 2D texture usage
2115 class BasicTexStorage2DCase : public Texture2DSpecCase
2118 BasicTexStorage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLevels)
2119 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLevels)
2120 , m_internalFormat (internalFormat)
2125 void createTexture (void)
2127 tcu::TextureFormat fmt = glu::mapGLInternalFormat(m_internalFormat);
2128 glu::TransferFormat transferFmt = glu::getTransferFormat(fmt);
2130 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
2131 de::Random rnd (deStringHash(getName()));
2133 glGenTextures(1, &tex);
2134 glBindTexture(GL_TEXTURE_2D, tex);
2135 glTexStorage2D(GL_TEXTURE_2D, m_numLevels, m_internalFormat, m_width, m_height);
2137 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2139 for (int ndx = 0; ndx < m_numLevels; ndx++)
2141 int levelW = de::max(1, m_width >> ndx);
2142 int levelH = de::max(1, m_height >> ndx);
2143 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2144 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2146 levelData.setSize(levelW, levelH);
2147 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
2149 glTexSubImage2D(GL_TEXTURE_2D, ndx, 0, 0, levelW, levelH, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
2153 deUint32 m_internalFormat;
2156 // Basic glTexStorage2D() with cubemap usage
2157 class BasicTexStorageCubeCase : public TextureCubeSpecCase
2160 BasicTexStorageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int numLevels)
2161 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, numLevels)
2162 , m_internalFormat (internalFormat)
2167 void createTexture (void)
2169 tcu::TextureFormat fmt = glu::mapGLInternalFormat(m_internalFormat);
2170 glu::TransferFormat transferFmt = glu::getTransferFormat(fmt);
2172 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
2173 de::Random rnd (deStringHash(getName()));
2175 glGenTextures(1, &tex);
2176 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
2177 glTexStorage2D(GL_TEXTURE_CUBE_MAP, m_numLevels, m_internalFormat, m_size, m_size);
2179 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2181 for (int ndx = 0; ndx < m_numLevels; ndx++)
2183 int levelSize = de::max(1, m_size >> ndx);
2185 levelData.setSize(levelSize, levelSize);
2187 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
2189 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2190 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2192 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
2194 glTexSubImage2D(s_cubeMapFaces[face], ndx, 0, 0, levelSize, levelSize, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
2199 deUint32 m_internalFormat;
2202 // Basic glTexStorage3D() with 2D array texture usage
2203 class BasicTexStorage2DArrayCase : public Texture2DArraySpecCase
2206 BasicTexStorage2DArrayCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLayers, int numLevels)
2207 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLayers, numLevels)
2208 , m_internalFormat (internalFormat)
2213 void createTexture (void)
2216 de::Random rnd (deStringHash(getName()));
2217 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
2218 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
2220 glGenTextures (1, &tex);
2221 glBindTexture (GL_TEXTURE_2D_ARRAY, tex);
2222 glTexStorage3D (GL_TEXTURE_2D_ARRAY, m_numLevels, m_internalFormat, m_width, m_height, m_numLayers);
2224 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
2226 for (int ndx = 0; ndx < m_numLevels; ndx++)
2228 int levelW = de::max(1, m_width >> ndx);
2229 int levelH = de::max(1, m_height >> ndx);
2230 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2231 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2233 levelData.setSize(levelW, levelH, m_numLayers);
2234 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
2236 glTexSubImage3D(GL_TEXTURE_2D_ARRAY, ndx, 0, 0, 0, levelW, levelH, m_numLayers, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
2240 deUint32 m_internalFormat;
2243 // Basic TexStorage3D() with 3D texture usage
2244 class BasicTexStorage3DCase : public Texture3DSpecCase
2247 BasicTexStorage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth, int numLevels)
2248 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, numLevels)
2249 , m_internalFormat (internalFormat)
2254 void createTexture (void)
2257 de::Random rnd (deStringHash(getName()));
2258 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
2259 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
2261 glGenTextures (1, &tex);
2262 glBindTexture (GL_TEXTURE_3D, tex);
2263 glTexStorage3D (GL_TEXTURE_3D, m_numLevels, m_internalFormat, m_width, m_height, m_depth);
2265 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
2267 for (int ndx = 0; ndx < m_numLevels; ndx++)
2269 int levelW = de::max(1, m_width >> ndx);
2270 int levelH = de::max(1, m_height >> ndx);
2271 int levelD = de::max(1, m_depth >> ndx);
2272 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2273 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2275 levelData.setSize(levelW, levelH, levelD);
2276 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
2278 glTexSubImage3D(GL_TEXTURE_3D, ndx, 0, 0, 0, levelW, levelH, levelD, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
2282 deUint32 m_internalFormat;
2285 // Pixel buffer object cases.
2287 // TexImage2D() from pixel buffer object.
2288 class TexImage2DBufferCase : public Texture2DSpecCase
2291 TexImage2DBufferCase (Context& context,
2294 deUint32 internalFormat,
2302 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1)
2303 , m_internalFormat (internalFormat)
2304 , m_rowLength (rowLength)
2305 , m_skipRows (skipRows)
2306 , m_skipPixels (skipPixels)
2307 , m_alignment (alignment)
2313 void createTexture (void)
2315 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
2316 int pixelSize = m_texFormat.getPixelSize();
2317 int rowLength = m_rowLength > 0 ? m_rowLength : m_width + m_skipPixels;
2318 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
2319 int height = m_height + m_skipRows;
2322 vector<deUint8> data;
2324 DE_ASSERT(m_numLevels == 1);
2326 // Fill data with grid.
2327 data.resize(rowPitch*height + m_offset);
2329 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
2330 Vec4 cBias = m_texFormatInfo.valueMin;
2331 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
2332 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
2334 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB);
2337 // Create buffer and upload.
2338 glGenBuffers(1, &buf);
2339 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
2340 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
2342 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
2343 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
2344 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
2345 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
2347 glGenTextures(1, &tex);
2348 glBindTexture(GL_TEXTURE_2D, tex);
2349 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset);
2352 deUint32 m_internalFormat;
2360 // TexImage2D() cubemap from pixel buffer object case
2361 class TexImageCubeBufferCase : public TextureCubeSpecCase
2364 TexImageCubeBufferCase (Context& context,
2367 deUint32 internalFormat,
2374 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1)
2375 , m_internalFormat (internalFormat)
2376 , m_rowLength (rowLength)
2377 , m_skipRows (skipRows)
2378 , m_skipPixels (skipPixels)
2379 , m_alignment (alignment)
2385 void createTexture (void)
2387 de::Random rnd (deStringHash(getName()));
2389 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
2390 const int pixelSize = m_texFormat.getPixelSize();
2391 const int rowLength = m_rowLength > 0 ? m_rowLength : m_size + m_skipPixels;
2392 const int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
2393 const int height = m_size + m_skipRows;
2394 vector<vector<deUint8> > data (DE_LENGTH_OF_ARRAY(s_cubeMapFaces));
2396 DE_ASSERT(m_numLevels == 1);
2398 glGenTextures(1, &tex);
2399 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
2400 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2402 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
2407 const Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2408 const Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2410 data[face].resize(rowPitch*height + m_offset);
2411 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_size, m_size, 1, rowPitch, 0, &data[face][0] + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), gMin, gMax);
2414 // Create buffer and upload.
2415 glGenBuffers(1, &buf);
2416 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
2417 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data[face].size(), &data[face][0], GL_STATIC_DRAW);
2419 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
2420 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
2421 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
2422 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
2424 glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, fmt.format, fmt.dataType, (const void*)(deUintptr)m_offset);
2428 deUint32 m_internalFormat;
2436 // TexImage3D() 2D array from pixel buffer object.
2437 class TexImage2DArrayBufferCase : public Texture2DArraySpecCase
2440 TexImage2DArrayBufferCase (Context& context,
2443 deUint32 internalFormat,
2454 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
2455 , m_internalFormat (internalFormat)
2456 , m_imageHeight (imageHeight)
2457 , m_rowLength (rowLength)
2458 , m_skipImages (skipImages)
2459 , m_skipRows (skipRows)
2460 , m_skipPixels (skipPixels)
2461 , m_alignment (alignment)
2467 void createTexture (void)
2469 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
2470 int pixelSize = m_texFormat.getPixelSize();
2471 int rowLength = m_rowLength > 0 ? m_rowLength : m_width;
2472 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
2473 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height;
2474 int slicePitch = imageHeight*rowPitch;
2477 vector<deUint8> data;
2479 DE_ASSERT(m_numLevels == 1);
2481 // Fill data with grid.
2482 data.resize(slicePitch*(m_numLayers+m_skipImages) + m_offset);
2484 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
2485 Vec4 cBias = m_texFormatInfo.valueMin;
2486 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
2487 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
2489 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_numLayers, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB);
2492 glGenBuffers(1, &buf);
2493 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
2494 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
2496 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
2497 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
2498 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
2499 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
2500 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
2501 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
2503 glGenTextures(1, &tex);
2504 glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
2505 glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset);
2508 deUint32 m_internalFormat;
2518 // TexImage3D() from pixel buffer object.
2519 class TexImage3DBufferCase : public Texture3DSpecCase
2522 TexImage3DBufferCase (Context& context,
2525 deUint32 internalFormat,
2536 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
2537 , m_internalFormat (internalFormat)
2538 , m_imageHeight (imageHeight)
2539 , m_rowLength (rowLength)
2540 , m_skipImages (skipImages)
2541 , m_skipRows (skipRows)
2542 , m_skipPixels (skipPixels)
2543 , m_alignment (alignment)
2549 void createTexture (void)
2551 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
2552 int pixelSize = m_texFormat.getPixelSize();
2553 int rowLength = m_rowLength > 0 ? m_rowLength : m_width;
2554 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
2555 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height;
2556 int slicePitch = imageHeight*rowPitch;
2559 vector<deUint8> data;
2561 DE_ASSERT(m_numLevels == 1);
2563 // Fill data with grid.
2564 data.resize(slicePitch*(m_depth+m_skipImages) + m_offset);
2566 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
2567 Vec4 cBias = m_texFormatInfo.valueMin;
2568 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
2569 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
2571 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB);
2574 glGenBuffers(1, &buf);
2575 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
2576 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
2578 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
2579 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
2580 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
2581 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
2582 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
2583 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
2585 glGenTextures(1, &tex);
2586 glBindTexture(GL_TEXTURE_3D, tex);
2587 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset);
2590 deUint32 m_internalFormat;
2600 // TexSubImage2D() PBO case.
2601 class TexSubImage2DBufferCase : public Texture2DSpecCase
2604 TexSubImage2DBufferCase (Context& context,
2607 deUint32 internalFormat,
2619 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1)
2620 , m_internalFormat (internalFormat)
2625 , m_rowLength (rowLength)
2626 , m_skipRows (skipRows)
2627 , m_skipPixels (skipPixels)
2628 , m_alignment (alignment)
2634 void createTexture (void)
2636 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
2637 int pixelSize = m_texFormat.getPixelSize();
2640 vector<deUint8> data;
2642 DE_ASSERT(m_numLevels == 1);
2644 glGenTextures(1, &tex);
2645 glBindTexture(GL_TEXTURE_2D, tex);
2647 // First fill texture with gradient.
2648 data.resize(deAlign32(m_width*pixelSize, 4)*m_height);
2649 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, deAlign32(m_width*pixelSize, 4), 0, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2650 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]);
2652 // Fill data with grid.
2654 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
2655 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
2656 int height = m_subH + m_skipRows;
2657 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
2658 Vec4 cBias = m_texFormatInfo.valueMin;
2659 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
2660 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
2662 data.resize(rowPitch*height + m_offset);
2663 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB);
2666 glGenBuffers(1, &buf);
2667 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
2668 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
2670 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
2671 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
2672 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
2673 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
2674 glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset);
2677 deUint32 m_internalFormat;
2689 // TexSubImage2D() cubemap PBO case.
2690 class TexSubImageCubeBufferCase : public TextureCubeSpecCase
2693 TexSubImageCubeBufferCase (Context& context,
2696 deUint32 internalFormat,
2707 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1)
2708 , m_internalFormat (internalFormat)
2713 , m_rowLength (rowLength)
2714 , m_skipRows (skipRows)
2715 , m_skipPixels (skipPixels)
2716 , m_alignment (alignment)
2722 void createTexture (void)
2724 de::Random rnd (deStringHash(getName()));
2725 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
2726 int pixelSize = m_texFormat.getPixelSize();
2729 vector<deUint8> data;
2731 DE_ASSERT(m_numLevels == 1);
2733 glGenTextures(1, &tex);
2734 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
2736 // Fill faces with different gradients.
2738 data.resize(deAlign32(m_size*pixelSize, 4)*m_size);
2739 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2741 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
2743 const Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2744 const Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2746 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_size, m_size, 1, deAlign32(m_size*pixelSize, 4), 0, &data[0]), gMin, gMax);
2748 glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, transferFmt.format, transferFmt.dataType, &data[0]);
2751 // Fill data with grid.
2753 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
2754 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
2755 int height = m_subH + m_skipRows;
2756 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
2757 Vec4 cBias = m_texFormatInfo.valueMin;
2758 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
2759 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
2761 data.resize(rowPitch*height + m_offset);
2762 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB);
2765 glGenBuffers(1, &buf);
2766 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
2767 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
2769 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
2770 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
2771 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
2772 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
2774 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
2775 glTexSubImage2D(s_cubeMapFaces[face], 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset);
2778 deUint32 m_internalFormat;
2790 // TexSubImage3D() 2D array PBO case.
2791 class TexSubImage2DArrayBufferCase : public Texture2DArraySpecCase
2794 TexSubImage2DArrayBufferCase (Context& context,
2797 deUint32 internalFormat,
2814 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
2815 , m_internalFormat (internalFormat)
2822 , m_imageHeight (imageHeight)
2823 , m_rowLength (rowLength)
2824 , m_skipImages (skipImages)
2825 , m_skipRows (skipRows)
2826 , m_skipPixels (skipPixels)
2827 , m_alignment (alignment)
2833 void createTexture (void)
2835 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
2836 int pixelSize = m_texFormat.getPixelSize();
2839 vector<deUint8> data;
2841 DE_ASSERT(m_numLevels == 1);
2843 glGenTextures(1, &tex);
2844 glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
2846 // Fill with gradient.
2848 int rowPitch = deAlign32(pixelSize*m_width, 4);
2849 int slicePitch = rowPitch*m_height;
2851 data.resize(slicePitch*m_numLayers);
2852 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_numLayers, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2855 glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, &data[0]);
2857 // Fill data with grid.
2859 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
2860 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
2861 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH;
2862 int slicePitch = imageHeight*rowPitch;
2863 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
2864 Vec4 cBias = m_texFormatInfo.valueMin;
2865 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
2866 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
2868 data.resize(slicePitch*(m_numLayers+m_skipImages) + m_offset);
2869 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, m_subD, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB);
2872 glGenBuffers(1, &buf);
2873 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
2874 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
2876 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
2877 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
2878 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
2879 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
2880 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
2881 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
2882 glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, m_subX, m_subY, m_subZ, m_subW, m_subH, m_subD, transferFmt.format, transferFmt.dataType, (const void*)(deIntptr)m_offset);
2885 deUint32 m_internalFormat;
2901 // TexSubImage3D() PBO case.
2902 class TexSubImage3DBufferCase : public Texture3DSpecCase
2905 TexSubImage3DBufferCase (Context& context,
2908 deUint32 internalFormat,
2925 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
2926 , m_internalFormat (internalFormat)
2933 , m_imageHeight (imageHeight)
2934 , m_rowLength (rowLength)
2935 , m_skipImages (skipImages)
2936 , m_skipRows (skipRows)
2937 , m_skipPixels (skipPixels)
2938 , m_alignment (alignment)
2944 void createTexture (void)
2946 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
2947 int pixelSize = m_texFormat.getPixelSize();
2950 vector<deUint8> data;
2952 DE_ASSERT(m_numLevels == 1);
2954 glGenTextures(1, &tex);
2955 glBindTexture(GL_TEXTURE_3D, tex);
2957 // Fill with gradient.
2959 int rowPitch = deAlign32(pixelSize*m_width, 4);
2960 int slicePitch = rowPitch*m_height;
2962 data.resize(slicePitch*m_depth);
2963 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
2966 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]);
2968 // Fill data with grid.
2970 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
2971 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
2972 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH;
2973 int slicePitch = imageHeight*rowPitch;
2974 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
2975 Vec4 cBias = m_texFormatInfo.valueMin;
2976 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
2977 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
2979 data.resize(slicePitch*(m_depth+m_skipImages) + m_offset);
2980 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, m_subD, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB);
2983 glGenBuffers(1, &buf);
2984 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
2985 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
2987 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
2988 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
2989 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
2990 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
2991 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
2992 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
2993 glTexSubImage3D(GL_TEXTURE_3D, 0, m_subX, m_subY, m_subZ, m_subW, m_subH, m_subD, transferFmt.format, transferFmt.dataType, (const void*)(deIntptr)m_offset);
2996 deUint32 m_internalFormat;
3012 // TexImage2D() depth case.
3013 class TexImage2DDepthCase : public Texture2DSpecCase
3016 TexImage2DDepthCase (Context& context,
3019 deUint32 internalFormat,
3022 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, maxLevelCount(imageWidth, imageHeight))
3023 , m_internalFormat (internalFormat)
3025 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
3026 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
3027 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
3030 void createTexture (void)
3032 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
3034 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType));
3036 glGenTextures(1, &tex);
3037 glBindTexture(GL_TEXTURE_2D, tex);
3038 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3041 for (int ndx = 0; ndx < m_numLevels; ndx++)
3043 const int levelW = de::max(1, m_width >> ndx);
3044 const int levelH = de::max(1, m_height >> ndx);
3045 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
3046 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
3048 levelData.setSize(levelW, levelH);
3049 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
3051 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
3055 const deUint32 m_internalFormat;
3058 // TexImage3D() depth case.
3059 class TexImage2DArrayDepthCase : public Texture2DArraySpecCase
3062 TexImage2DArrayDepthCase (Context& context,
3065 deUint32 internalFormat,
3069 : Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, maxLevelCount(imageWidth, imageHeight))
3070 , m_internalFormat (internalFormat)
3072 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
3073 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
3074 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
3077 void createTexture (void)
3079 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
3081 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType));
3083 glGenTextures(1, &tex);
3084 glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
3085 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3088 for (int ndx = 0; ndx < m_numLevels; ndx++)
3090 const int levelW = de::max(1, m_width >> ndx);
3091 const int levelH = de::max(1, m_height >> ndx);
3092 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
3093 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
3095 levelData.setSize(levelW, levelH, m_numLayers);
3096 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
3098 glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
3102 const deUint32 m_internalFormat;
3105 // TexSubImage2D() depth case.
3106 class TexSubImage2DDepthCase : public Texture2DSpecCase
3109 TexSubImage2DDepthCase (Context& context,
3112 deUint32 internalFormat,
3115 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, maxLevelCount(imageWidth, imageHeight))
3116 , m_internalFormat (internalFormat)
3118 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
3119 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
3120 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
3123 void createTexture (void)
3125 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
3126 de::Random rnd (deStringHash(getName()));
3128 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType));
3130 glGenTextures(1, &tex);
3131 glBindTexture(GL_TEXTURE_2D, tex);
3132 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3135 // First specify full texture.
3136 for (int ndx = 0; ndx < m_numLevels; ndx++)
3138 const int levelW = de::max(1, m_width >> ndx);
3139 const int levelH = de::max(1, m_height >> ndx);
3140 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
3141 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
3143 levelData.setSize(levelW, levelH);
3144 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
3146 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
3149 // Re-specify parts of each level.
3150 for (int ndx = 0; ndx < m_numLevels; ndx++)
3152 const int levelW = de::max(1, m_width >> ndx);
3153 const int levelH = de::max(1, m_height >> ndx);
3155 const int w = rnd.getInt(1, levelW);
3156 const int h = rnd.getInt(1, levelH);
3157 const int x = rnd.getInt(0, levelW-w);
3158 const int y = rnd.getInt(0, levelH-h);
3160 const Vec4 colorA = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
3161 const Vec4 colorB = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
3162 const int cellSize = rnd.getInt(2, 16);
3164 levelData.setSize(w, h);
3165 tcu::fillWithGrid(levelData.getAccess(), cellSize, colorA, colorB);
3167 glTexSubImage2D(GL_TEXTURE_2D, ndx, x, y, w, h, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
3171 const deUint32 m_internalFormat;
3174 // TexSubImage3D() depth case.
3175 class TexSubImage2DArrayDepthCase : public Texture2DArraySpecCase
3178 TexSubImage2DArrayDepthCase (Context& context,
3181 deUint32 internalFormat,
3185 : Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, maxLevelCount(imageWidth, imageHeight))
3186 , m_internalFormat (internalFormat)
3188 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
3189 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
3190 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
3193 void createTexture (void)
3195 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
3196 de::Random rnd (deStringHash(getName()));
3198 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType));
3200 glGenTextures(1, &tex);
3201 glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
3202 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3205 // First specify full texture.
3206 for (int ndx = 0; ndx < m_numLevels; ndx++)
3208 const int levelW = de::max(1, m_width >> ndx);
3209 const int levelH = de::max(1, m_height >> ndx);
3210 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
3211 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
3213 levelData.setSize(levelW, levelH, m_numLayers);
3214 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
3216 glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
3219 // Re-specify parts of each level.
3220 for (int ndx = 0; ndx < m_numLevels; ndx++)
3222 const int levelW = de::max(1, m_width >> ndx);
3223 const int levelH = de::max(1, m_height >> ndx);
3225 const int w = rnd.getInt(1, levelW);
3226 const int h = rnd.getInt(1, levelH);
3227 const int d = rnd.getInt(1, m_numLayers);
3228 const int x = rnd.getInt(0, levelW-w);
3229 const int y = rnd.getInt(0, levelH-h);
3230 const int z = rnd.getInt(0, m_numLayers-d);
3232 const Vec4 colorA = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
3233 const Vec4 colorB = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
3234 const int cellSize = rnd.getInt(2, 16);
3236 levelData.setSize(w, h, d);
3237 tcu::fillWithGrid(levelData.getAccess(), cellSize, colorA, colorB);
3239 glTexSubImage3D(GL_TEXTURE_2D_ARRAY, ndx, x, y, z, w, h, d, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
3243 const deUint32 m_internalFormat;
3246 // TexImage2D() depth case with pbo.
3247 class TexImage2DDepthBufferCase : public Texture2DSpecCase
3250 TexImage2DDepthBufferCase (Context& context,
3253 deUint32 internalFormat,
3256 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, 1)
3257 , m_internalFormat (internalFormat)
3259 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
3260 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
3261 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
3264 void createTexture (void)
3266 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
3267 int pixelSize = m_texFormat.getPixelSize();
3268 int rowLength = m_width;
3270 int rowPitch = deAlign32(rowLength*pixelSize, alignment);
3271 int height = m_height;
3274 vector<deUint8> data;
3276 DE_ASSERT(m_numLevels == 1);
3278 // Fill data with gradient
3279 data.resize(rowPitch*height);
3281 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
3282 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
3284 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, rowPitch, 0, &data[0]), gMin, gMax);
3287 // Create buffer and upload.
3288 glGenBuffers(1, &buf);
3289 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
3290 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
3292 glPixelStorei(GL_UNPACK_ROW_LENGTH, rowLength);
3293 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3294 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3295 glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
3297 glGenTextures(1, &tex);
3298 glBindTexture(GL_TEXTURE_2D, tex);
3299 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, DE_NULL);
3300 glDeleteBuffers(1, &buf);
3303 const deUint32 m_internalFormat;
3306 // TexImage3D() depth case with pbo.
3307 class TexImage2DArrayDepthBufferCase : public Texture2DArraySpecCase
3310 TexImage2DArrayDepthBufferCase (Context& context,
3313 deUint32 internalFormat,
3317 : Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, 1)
3318 , m_internalFormat (internalFormat)
3320 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
3321 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
3322 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
3325 void createTexture (void)
3327 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
3328 int pixelSize = m_texFormat.getPixelSize();
3329 int rowLength = m_width;
3331 int rowPitch = deAlign32(rowLength*pixelSize, alignment);
3332 int imageHeight = m_height;
3333 int slicePitch = imageHeight*rowPitch;
3336 vector<deUint8> data;
3338 DE_ASSERT(m_numLevels == 1);
3340 // Fill data with grid.
3341 data.resize(slicePitch*m_numLayers);
3343 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
3344 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
3346 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_numLayers, rowPitch, slicePitch, &data[0]), gMin, gMax);
3349 glGenBuffers(1, &buf);
3350 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
3351 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
3353 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, imageHeight);
3354 glPixelStorei(GL_UNPACK_ROW_LENGTH, rowLength);
3355 glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
3356 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3357 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3358 glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
3360 glGenTextures(1, &tex);
3361 glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
3362 glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, DE_NULL);
3363 glDeleteBuffers(1, &buf);
3366 const deUint32 m_internalFormat;
3369 TextureSpecificationTests::TextureSpecificationTests (Context& context)
3370 : TestCaseGroup(context, "specification", "Texture Specification Tests")
3374 TextureSpecificationTests::~TextureSpecificationTests (void)
3378 void TextureSpecificationTests::init (void)
3385 } unsizedFormats[] =
3387 { "alpha_unsigned_byte", GL_ALPHA, GL_UNSIGNED_BYTE },
3388 { "luminance_unsigned_byte", GL_LUMINANCE, GL_UNSIGNED_BYTE },
3389 { "luminance_alpha_unsigned_byte", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE },
3390 { "rgb_unsigned_short_5_6_5", GL_RGB, GL_UNSIGNED_SHORT_5_6_5 },
3391 { "rgb_unsigned_byte", GL_RGB, GL_UNSIGNED_BYTE },
3392 { "rgba_unsigned_short_4_4_4_4", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 },
3393 { "rgba_unsigned_short_5_5_5_1", GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 },
3394 { "rgba_unsigned_byte", GL_RGBA, GL_UNSIGNED_BYTE }
3400 deUint32 internalFormat;
3403 { "rgba32f", GL_RGBA32F, },
3404 { "rgba32i", GL_RGBA32I, },
3405 { "rgba32ui", GL_RGBA32UI, },
3406 { "rgba16f", GL_RGBA16F, },
3407 { "rgba16i", GL_RGBA16I, },
3408 { "rgba16ui", GL_RGBA16UI, },
3409 { "rgba8", GL_RGBA8, },
3410 { "rgba8i", GL_RGBA8I, },
3411 { "rgba8ui", GL_RGBA8UI, },
3412 { "srgb8_alpha8", GL_SRGB8_ALPHA8, },
3413 { "rgb10_a2", GL_RGB10_A2, },
3414 { "rgb10_a2ui", GL_RGB10_A2UI, },
3415 { "rgba4", GL_RGBA4, },
3416 { "rgb5_a1", GL_RGB5_A1, },
3417 { "rgba8_snorm", GL_RGBA8_SNORM, },
3418 { "rgb8", GL_RGB8, },
3419 { "rgb565", GL_RGB565, },
3420 { "r11f_g11f_b10f", GL_R11F_G11F_B10F, },
3421 { "rgb32f", GL_RGB32F, },
3422 { "rgb32i", GL_RGB32I, },
3423 { "rgb32ui", GL_RGB32UI, },
3424 { "rgb16f", GL_RGB16F, },
3425 { "rgb16i", GL_RGB16I, },
3426 { "rgb16ui", GL_RGB16UI, },
3427 { "rgb8_snorm", GL_RGB8_SNORM, },
3428 { "rgb8i", GL_RGB8I, },
3429 { "rgb8ui", GL_RGB8UI, },
3430 { "srgb8", GL_SRGB8, },
3431 { "rgb9_e5", GL_RGB9_E5, },
3432 { "rg32f", GL_RG32F, },
3433 { "rg32i", GL_RG32I, },
3434 { "rg32ui", GL_RG32UI, },
3435 { "rg16f", GL_RG16F, },
3436 { "rg16i", GL_RG16I, },
3437 { "rg16ui", GL_RG16UI, },
3439 { "rg8i", GL_RG8I, },
3440 { "rg8ui", GL_RG8UI, },
3441 { "rg8_snorm", GL_RG8_SNORM, },
3442 { "r32f", GL_R32F, },
3443 { "r32i", GL_R32I, },
3444 { "r32ui", GL_R32UI, },
3445 { "r16f", GL_R16F, },
3446 { "r16i", GL_R16I, },
3447 { "r16ui", GL_R16UI, },
3450 { "r8ui", GL_R8UI, },
3451 { "r8_snorm", GL_R8_SNORM, }
3457 deUint32 internalFormat;
3458 } depthStencilFormats[] =
3460 // Depth and stencil formats
3461 { "depth_component32f", GL_DEPTH_COMPONENT32F },
3462 { "depth_component24", GL_DEPTH_COMPONENT24 },
3463 { "depth_component16", GL_DEPTH_COMPONENT16 },
3464 { "depth32f_stencil8", GL_DEPTH32F_STENCIL8 },
3465 { "depth24_stencil8", GL_DEPTH24_STENCIL8 }
3468 // Basic TexImage2D usage.
3470 tcu::TestCaseGroup* basicTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_teximage2d", "Basic glTexImage2D() usage");
3471 addChild(basicTexImageGroup);
3472 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
3474 const char* fmtName = colorFormats[formatNdx].name;
3475 deUint32 format = colorFormats[formatNdx].internalFormat;
3476 const int tex2DWidth = 64;
3477 const int tex2DHeight = 128;
3478 const int texCubeSize = 64;
3480 basicTexImageGroup->addChild(new BasicTexImage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight));
3481 basicTexImageGroup->addChild(new BasicTexImageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, texCubeSize));
3485 // Randomized TexImage2D order.
3487 tcu::TestCaseGroup* randomTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "random_teximage2d", "Randomized glTexImage2D() usage");
3488 addChild(randomTexImageGroup);
3493 for (int ndx = 0; ndx < 10; ndx++)
3495 int formatNdx = rnd.getInt(0, DE_LENGTH_OF_ARRAY(colorFormats)-1);
3496 int width = 1 << rnd.getInt(2, 8);
3497 int height = 1 << rnd.getInt(2, 8);
3499 randomTexImageGroup->addChild(new RandomOrderTexImage2DCase(m_context, (string("2d_") + de::toString(ndx)).c_str(), "", colorFormats[formatNdx].internalFormat, width, height));
3503 for (int ndx = 0; ndx < 10; ndx++)
3505 int formatNdx = rnd.getInt(0, DE_LENGTH_OF_ARRAY(colorFormats)-1);
3506 int size = 1 << rnd.getInt(2, 8);
3508 randomTexImageGroup->addChild(new RandomOrderTexImageCubeCase(m_context, (string("cube_") + de::toString(ndx)).c_str(), "", colorFormats[formatNdx].internalFormat, size));
3512 // TexImage2D unpack alignment.
3514 tcu::TestCaseGroup* alignGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_align", "glTexImage2D() unpack alignment tests");
3515 addChild(alignGroup);
3517 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_4_8", "", GL_R8, 4, 8, 4, 8));
3518 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_1", "", GL_R8, 63, 30, 1, 1));
3519 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_2", "", GL_R8, 63, 30, 1, 2));
3520 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_4", "", GL_R8, 63, 30, 1, 4));
3521 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_8", "", GL_R8, 63, 30, 1, 8));
3522 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_1", "", GL_RGBA4, 51, 30, 1, 1));
3523 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_2", "", GL_RGBA4, 51, 30, 1, 2));
3524 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_4", "", GL_RGBA4, 51, 30, 1, 4));
3525 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_8", "", GL_RGBA4, 51, 30, 1, 8));
3526 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_1", "", GL_RGB8, 39, 43, 1, 1));
3527 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_2", "", GL_RGB8, 39, 43, 1, 2));
3528 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_4", "", GL_RGB8, 39, 43, 1, 4));
3529 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_8", "", GL_RGB8, 39, 43, 1, 8));
3530 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_1", "", GL_RGBA8, 47, 27, 1, 1));
3531 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_2", "", GL_RGBA8, 47, 27, 1, 2));
3532 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_4", "", GL_RGBA8, 47, 27, 1, 4));
3533 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_8", "", GL_RGBA8, 47, 27, 1, 8));
3535 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_4_8", "", GL_R8, 4, 3, 8));
3536 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_1", "", GL_R8, 63, 1, 1));
3537 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_2", "", GL_R8, 63, 1, 2));
3538 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_4", "", GL_R8, 63, 1, 4));
3539 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_8", "", GL_R8, 63, 1, 8));
3540 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_1", "", GL_RGBA4, 51, 1, 1));
3541 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_2", "", GL_RGBA4, 51, 1, 2));
3542 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_4", "", GL_RGBA4, 51, 1, 4));
3543 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_8", "", GL_RGBA4, 51, 1, 8));
3544 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_1", "", GL_RGB8, 39, 1, 1));
3545 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_2", "", GL_RGB8, 39, 1, 2));
3546 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_4", "", GL_RGB8, 39, 1, 4));
3547 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_8", "", GL_RGB8, 39, 1, 8));
3548 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_1", "", GL_RGBA8, 47, 1, 1));
3549 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_2", "", GL_RGBA8, 47, 1, 2));
3550 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_4", "", GL_RGBA8, 47, 1, 4));
3551 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_8", "", GL_RGBA8, 47, 1, 8));
3554 // glTexImage2D() unpack parameter cases.
3556 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_unpack_params", "glTexImage2D() pixel transfer mode cases");
3557 addChild(paramGroup);
3571 { "rgb8_alignment", GL_RGB8, 31, 30, 0, 0, 0, 2 },
3572 { "rgb8_row_length", GL_RGB8, 31, 30, 50, 0, 0, 4 },
3573 { "rgb8_skip_rows", GL_RGB8, 31, 30, 0, 3, 0, 4 },
3574 { "rgb8_skip_pixels", GL_RGB8, 31, 30, 36, 0, 5, 4 },
3575 { "r8_complex1", GL_R8, 31, 30, 64, 1, 3, 1 },
3576 { "r8_complex2", GL_R8, 31, 30, 64, 1, 3, 2 },
3577 { "r8_complex3", GL_R8, 31, 30, 64, 1, 3, 4 },
3578 { "r8_complex4", GL_R8, 31, 30, 64, 1, 3, 8 },
3579 { "rgba8_complex1", GL_RGBA8, 56, 61, 69, 0, 0, 8 },
3580 { "rgba8_complex2", GL_RGBA8, 56, 61, 69, 0, 7, 8 },
3581 { "rgba8_complex3", GL_RGBA8, 56, 61, 69, 3, 0, 8 },
3582 { "rgba8_complex4", GL_RGBA8, 56, 61, 69, 3, 7, 8 },
3583 { "rgba32f_complex", GL_RGBA32F, 19, 10, 27, 1, 7, 8 }
3586 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++)
3587 paramGroup->addChild(new TexImage2DParamsCase(m_context, cases[ndx].name, "",
3591 cases[ndx].rowLength,
3592 cases[ndx].skipRows,
3593 cases[ndx].skipPixels,
3594 cases[ndx].alignment));
3597 // glTexImage2D() pbo cases.
3599 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_pbo", "glTexImage2D() from PBO");
3614 } parameterCases[] =
3616 { "rgb8_offset", GL_RGB8, 31, 30, 0, 0, 0, 4, 67 },
3617 { "rgb8_alignment", GL_RGB8, 31, 30, 0, 0, 0, 2, 0 },
3618 { "rgb8_row_length", GL_RGB8, 31, 30, 50, 0, 0, 4, 0 },
3619 { "rgb8_skip_rows", GL_RGB8, 31, 30, 0, 3, 0, 4, 0 },
3620 { "rgb8_skip_pixels", GL_RGB8, 31, 30, 36, 0, 5, 4, 0 }
3623 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
3625 const string fmtName = colorFormats[formatNdx].name;
3626 const deUint32 format = colorFormats[formatNdx].internalFormat;
3627 const int tex2DWidth = 65;
3628 const int tex2DHeight = 37;
3629 const int texCubeSize = 64;
3631 pboGroup->addChild(new TexImage2DBufferCase (m_context, (fmtName + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight, 0, 0, 0, 4, 0));
3632 pboGroup->addChild(new TexImageCubeBufferCase (m_context, (fmtName + "_cube").c_str(), "", format, texCubeSize, 0, 0, 0, 4, 0));
3635 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(parameterCases); ndx++)
3637 pboGroup->addChild(new TexImage2DBufferCase(m_context, (string(parameterCases[ndx].name) + "_2d").c_str(), "",
3638 parameterCases[ndx].format,
3639 parameterCases[ndx].width,
3640 parameterCases[ndx].height,
3641 parameterCases[ndx].rowLength,
3642 parameterCases[ndx].skipRows,
3643 parameterCases[ndx].skipPixels,
3644 parameterCases[ndx].alignment,
3645 parameterCases[ndx].offset));
3646 pboGroup->addChild(new TexImageCubeBufferCase(m_context, (string(parameterCases[ndx].name) + "_cube").c_str(), "",
3647 parameterCases[ndx].format,
3648 parameterCases[ndx].width,
3649 parameterCases[ndx].rowLength,
3650 parameterCases[ndx].skipRows,
3651 parameterCases[ndx].skipPixels,
3652 parameterCases[ndx].alignment,
3653 parameterCases[ndx].offset));
3657 // glTexImage2D() depth cases.
3659 tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_depth", "glTexImage2D() with depth or depth/stencil format");
3660 addChild(shadow2dGroup);
3662 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
3664 const int tex2DWidth = 64;
3665 const int tex2DHeight = 128;
3667 shadow2dGroup->addChild(new TexImage2DDepthCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight));
3671 // glTexImage2D() depth cases with pbo.
3673 tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_depth_pbo", "glTexImage2D() with depth or depth/stencil format with pbo");
3674 addChild(shadow2dGroup);
3676 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
3678 const int tex2DWidth = 64;
3679 const int tex2DHeight = 128;
3681 shadow2dGroup->addChild(new TexImage2DDepthBufferCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight));
3685 // Basic TexSubImage2D usage.
3687 tcu::TestCaseGroup* basicTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_texsubimage2d", "Basic glTexSubImage2D() usage");
3688 addChild(basicTexSubImageGroup);
3689 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
3691 const char* fmtName = colorFormats[formatNdx].name;
3692 deUint32 format = colorFormats[formatNdx].internalFormat;
3693 const int tex2DWidth = 64;
3694 const int tex2DHeight = 128;
3695 const int texCubeSize = 64;
3697 basicTexSubImageGroup->addChild(new BasicTexSubImage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight));
3698 basicTexSubImageGroup->addChild(new BasicTexSubImageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, texCubeSize));
3702 // TexSubImage2D to empty texture.
3704 tcu::TestCaseGroup* texSubImageEmptyTexGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_empty_tex", "glTexSubImage2D() to texture that has storage but no data");
3705 addChild(texSubImageEmptyTexGroup);
3706 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(unsizedFormats); formatNdx++)
3708 const char* fmtName = unsizedFormats[formatNdx].name;
3709 deUint32 format = unsizedFormats[formatNdx].format;
3710 deUint32 dataType = unsizedFormats[formatNdx].dataType;
3711 const int tex2DWidth = 64;
3712 const int tex2DHeight = 32;
3713 const int texCubeSize = 32;
3715 texSubImageEmptyTexGroup->addChild(new TexSubImage2DEmptyTexCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, dataType, tex2DWidth, tex2DHeight));
3716 texSubImageEmptyTexGroup->addChild(new TexSubImageCubeEmptyTexCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, dataType, texCubeSize));
3720 // TexSubImage2D alignment cases.
3722 tcu::TestCaseGroup* alignGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_align", "glTexSubImage2D() unpack alignment tests");
3723 addChild(alignGroup);
3725 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_1", "", GL_R8, 64, 64, 13, 17, 1, 6, 1));
3726 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_2", "", GL_R8, 64, 64, 13, 17, 1, 6, 2));
3727 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_4", "", GL_R8, 64, 64, 13, 17, 1, 6, 4));
3728 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_8", "", GL_R8, 64, 64, 13, 17, 1, 6, 8));
3729 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_1", "", GL_R8, 64, 64, 1, 9, 63, 30, 1));
3730 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_2", "", GL_R8, 64, 64, 1, 9, 63, 30, 2));
3731 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_4", "", GL_R8, 64, 64, 1, 9, 63, 30, 4));
3732 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_8", "", GL_R8, 64, 64, 1, 9, 63, 30, 8));
3733 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_1", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 1));
3734 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_2", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 2));
3735 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_4", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 4));
3736 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_8", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 8));
3737 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_1", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 1));
3738 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_2", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 2));
3739 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_4", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 4));
3740 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_8", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 8));
3741 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_1", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 1));
3742 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_2", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 2));
3743 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_4", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 4));
3744 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_8", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 8));
3746 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_1", "", GL_R8, 64, 13, 17, 1, 6, 1));
3747 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_2", "", GL_R8, 64, 13, 17, 1, 6, 2));
3748 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_4", "", GL_R8, 64, 13, 17, 1, 6, 4));
3749 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_8", "", GL_R8, 64, 13, 17, 1, 6, 8));
3750 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_1", "", GL_R8, 64, 1, 9, 63, 30, 1));
3751 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_2", "", GL_R8, 64, 1, 9, 63, 30, 2));
3752 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_4", "", GL_R8, 64, 1, 9, 63, 30, 4));
3753 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_8", "", GL_R8, 64, 1, 9, 63, 30, 8));
3754 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_1", "", GL_RGBA4, 64, 7, 29, 51, 30, 1));
3755 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_2", "", GL_RGBA4, 64, 7, 29, 51, 30, 2));
3756 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_4", "", GL_RGBA4, 64, 7, 29, 51, 30, 4));
3757 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_8", "", GL_RGBA4, 64, 7, 29, 51, 30, 8));
3758 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_1", "", GL_RGB8, 64, 11, 8, 39, 43, 1));
3759 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_2", "", GL_RGB8, 64, 11, 8, 39, 43, 2));
3760 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_4", "", GL_RGB8, 64, 11, 8, 39, 43, 4));
3761 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_8", "", GL_RGB8, 64, 11, 8, 39, 43, 8));
3762 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_1", "", GL_RGBA8, 64, 10, 1, 47, 27, 1));
3763 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_2", "", GL_RGBA8, 64, 10, 1, 47, 27, 2));
3764 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_4", "", GL_RGBA8, 64, 10, 1, 47, 27, 4));
3765 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_8", "", GL_RGBA8, 64, 10, 1, 47, 27, 8));
3768 // glTexSubImage2D() pixel transfer mode cases.
3770 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_unpack_params", "glTexSubImage2D() pixel transfer mode cases");
3771 addChild(paramGroup);
3789 { "rgb8_alignment", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 2 },
3790 { "rgb8_row_length", GL_RGB8, 54, 60, 11, 7, 31, 30, 50, 0, 0, 4 },
3791 { "rgb8_skip_rows", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 3, 0, 4 },
3792 { "rgb8_skip_pixels", GL_RGB8, 54, 60, 11, 7, 31, 30, 36, 0, 5, 4 },
3793 { "r8_complex1", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 1 },
3794 { "r8_complex2", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 2 },
3795 { "r8_complex3", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 4 },
3796 { "r8_complex4", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 8 },
3797 { "rgba8_complex1", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 0, 0, 8 },
3798 { "rgba8_complex2", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 0, 7, 8 },
3799 { "rgba8_complex3", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 3, 0, 8 },
3800 { "rgba8_complex4", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 3, 7, 8 },
3801 { "rgba32f_complex", GL_RGBA32F, 92, 84, 13, 19, 56, 61, 69, 3, 7, 8 }
3804 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++)
3805 paramGroup->addChild(new TexSubImage2DParamsCase(m_context, cases[ndx].name, "",
3813 cases[ndx].rowLength,
3814 cases[ndx].skipRows,
3815 cases[ndx].skipPixels,
3816 cases[ndx].alignment));
3819 // glTexSubImage2D() PBO cases.
3821 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_pbo", "glTexSubImage2D() pixel buffer object tests");
3841 { "rgb8_offset", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 4, 67 },
3842 { "rgb8_alignment", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 2, 0 },
3843 { "rgb8_row_length", GL_RGB8, 54, 60, 11, 7, 31, 30, 50, 0, 0, 4, 0 },
3844 { "rgb8_skip_rows", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 3, 0, 4, 0 },
3845 { "rgb8_skip_pixels", GL_RGB8, 54, 60, 11, 7, 31, 30, 36, 0, 5, 4, 0 }
3848 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorFormats); ndx++)
3850 pboGroup->addChild(new TexSubImage2DBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_2d").c_str(), "",
3851 colorFormats[ndx].internalFormat,
3863 pboGroup->addChild(new TexSubImageCubeBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_cube").c_str(), "",
3864 colorFormats[ndx].internalFormat,
3877 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(paramCases); ndx++)
3879 pboGroup->addChild(new TexSubImage2DBufferCase(m_context, (std::string(paramCases[ndx].name) + "_2d").c_str(), "",
3880 paramCases[ndx].format,
3881 paramCases[ndx].width,
3882 paramCases[ndx].height,
3883 paramCases[ndx].subX,
3884 paramCases[ndx].subY,
3885 paramCases[ndx].subW,
3886 paramCases[ndx].subH,
3887 paramCases[ndx].rowLength,
3888 paramCases[ndx].skipRows,
3889 paramCases[ndx].skipPixels,
3890 paramCases[ndx].alignment,
3891 paramCases[ndx].offset));
3892 pboGroup->addChild(new TexSubImageCubeBufferCase(m_context, (std::string(paramCases[ndx].name) + "_cube").c_str(), "",
3893 paramCases[ndx].format,
3894 paramCases[ndx].width,
3895 paramCases[ndx].subX,
3896 paramCases[ndx].subY,
3897 paramCases[ndx].subW,
3898 paramCases[ndx].subH,
3899 paramCases[ndx].rowLength,
3900 paramCases[ndx].skipRows,
3901 paramCases[ndx].skipPixels,
3902 paramCases[ndx].alignment,
3903 paramCases[ndx].offset));
3907 // glTexSubImage2D() depth cases.
3909 tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_depth", "glTexSubImage2D() with depth or depth/stencil format");
3910 addChild(shadow2dGroup);
3912 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
3914 const int tex2DWidth = 64;
3915 const int tex2DHeight = 32;
3917 shadow2dGroup->addChild(new TexSubImage2DDepthCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight));
3921 // Basic glCopyTexImage2D() cases
3923 tcu::TestCaseGroup* copyTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_copyteximage2d", "Basic glCopyTexImage2D() usage");
3924 addChild(copyTexImageGroup);
3926 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_alpha", "", GL_ALPHA, 128, 64));
3927 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_luminance", "", GL_LUMINANCE, 128, 64));
3928 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_luminance_alpha", "", GL_LUMINANCE_ALPHA, 128, 64));
3929 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_rgb", "", GL_RGB, 128, 64));
3930 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_rgba", "", GL_RGBA, 128, 64));
3932 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_alpha", "", GL_ALPHA, 64));
3933 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_luminance", "", GL_LUMINANCE, 64));
3934 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_luminance_alpha", "", GL_LUMINANCE_ALPHA, 64));
3935 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_rgb", "", GL_RGB, 64));
3936 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_rgba", "", GL_RGBA, 64));
3939 // Basic glCopyTexSubImage2D() cases
3941 tcu::TestCaseGroup* copyTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_copytexsubimage2d", "Basic glCopyTexSubImage2D() usage");
3942 addChild(copyTexSubImageGroup);
3944 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_alpha", "", GL_ALPHA, GL_UNSIGNED_BYTE, 128, 64));
3945 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_luminance", "", GL_LUMINANCE, GL_UNSIGNED_BYTE, 128, 64));
3946 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_luminance_alpha", "", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 128, 64));
3947 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_rgb", "", GL_RGB, GL_UNSIGNED_BYTE, 128, 64));
3948 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_rgba", "", GL_RGBA, GL_UNSIGNED_BYTE, 128, 64));
3950 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_alpha", "", GL_ALPHA, GL_UNSIGNED_BYTE, 64));
3951 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_luminance", "", GL_LUMINANCE, GL_UNSIGNED_BYTE, 64));
3952 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_luminance_alpha", "", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 64));
3953 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_rgb", "", GL_RGB, GL_UNSIGNED_BYTE, 64));
3954 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_rgba", "", GL_RGBA, GL_UNSIGNED_BYTE, 64));
3957 // Basic TexImage3D usage.
3959 tcu::TestCaseGroup* basicTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_teximage3d", "Basic glTexImage3D() usage");
3960 addChild(basicTexImageGroup);
3961 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
3963 const char* fmtName = colorFormats[formatNdx].name;
3964 deUint32 format = colorFormats[formatNdx].internalFormat;
3965 const int tex2DArrayWidth = 57;
3966 const int tex2DArrayHeight = 44;
3967 const int tex2DArrayLevels = 5;
3968 const int tex3DWidth = 63;
3969 const int tex3DHeight = 29;
3970 const int tex3DDepth = 11;
3972 basicTexImageGroup->addChild(new BasicTexImage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", format, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLevels));
3973 basicTexImageGroup->addChild(new BasicTexImage3DCase (m_context, (string(fmtName) + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth));
3977 // glTexImage3D() unpack params cases.
3979 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_unpack_params", "glTexImage3D() unpack parameters");
3980 addChild(paramGroup);
3997 { "rgb8_image_height", GL_RGB8, 23, 19, 8, 26, 0, 0, 0, 0, 4 },
3998 { "rgb8_row_length", GL_RGB8, 23, 19, 8, 0, 27, 0, 0, 0, 4 },
3999 { "rgb8_skip_images", GL_RGB8, 23, 19, 8, 0, 0, 3, 0, 0, 4 },
4000 { "rgb8_skip_rows", GL_RGB8, 23, 19, 8, 22, 0, 0, 3, 0, 4 },
4001 { "rgb8_skip_pixels", GL_RGB8, 23, 19, 8, 0, 25, 0, 0, 2, 4 },
4002 { "r8_complex1", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 1 },
4003 { "r8_complex2", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 2 },
4004 { "r8_complex3", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 4 },
4005 { "r8_complex4", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 8 },
4006 { "rgba8_complex1", GL_RGBA8, 11, 20, 8, 25, 14, 0, 0, 0, 8 },
4007 { "rgba8_complex2", GL_RGBA8, 11, 20, 8, 25, 14, 0, 2, 0, 8 },
4008 { "rgba8_complex3", GL_RGBA8, 11, 20, 8, 25, 14, 0, 0, 3, 8 },
4009 { "rgba8_complex4", GL_RGBA8, 11, 20, 8, 25, 14, 0, 2, 3, 8 },
4010 { "rgba32f_complex", GL_RGBA32F, 11, 20, 8, 25, 14, 0, 2, 3, 8 }
4013 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++)
4014 paramGroup->addChild(new TexImage3DParamsCase(m_context, cases[ndx].name, "",
4019 cases[ndx].imageHeight,
4020 cases[ndx].rowLength,
4021 cases[ndx].skipImages,
4022 cases[ndx].skipRows,
4023 cases[ndx].skipPixels,
4024 cases[ndx].alignment));
4027 // glTexImage3D() pbo cases.
4029 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_pbo", "glTexImage3D() from PBO");
4047 } parameterCases[] =
4049 { "rgb8_offset", GL_RGB8, 23, 19, 8, 0, 0, 0, 0, 0, 1, 67 },
4050 { "rgb8_alignment", GL_RGB8, 23, 19, 8, 0, 0, 0, 0, 0, 2, 0 },
4051 { "rgb8_image_height", GL_RGB8, 23, 19, 8, 26, 0, 0, 0, 0, 4, 0 },
4052 { "rgb8_row_length", GL_RGB8, 23, 19, 8, 0, 27, 0, 0, 0, 4, 0 },
4053 { "rgb8_skip_images", GL_RGB8, 23, 19, 8, 0, 0, 3, 0, 0, 4, 0 },
4054 { "rgb8_skip_rows", GL_RGB8, 23, 19, 8, 22, 0, 0, 3, 0, 4, 0 },
4055 { "rgb8_skip_pixels", GL_RGB8, 23, 19, 8, 0, 25, 0, 0, 2, 4, 0 }
4058 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
4060 const string fmtName = colorFormats[formatNdx].name;
4061 const deUint32 format = colorFormats[formatNdx].internalFormat;
4062 const int tex3DWidth = 11;
4063 const int tex3DHeight = 20;
4064 const int tex3DDepth = 8;
4066 pboGroup->addChild(new TexImage2DArrayBufferCase (m_context, (fmtName + "_2d_array").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth, 0, 0, 0, 0, 0, 4, 0));
4067 pboGroup->addChild(new TexImage3DBufferCase (m_context, (fmtName + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth, 0, 0, 0, 0, 0, 4, 0));
4070 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(parameterCases); ndx++)
4072 pboGroup->addChild(new TexImage2DArrayBufferCase(m_context, (string(parameterCases[ndx].name) + "_2d_array").c_str(), "",
4073 parameterCases[ndx].format,
4074 parameterCases[ndx].width,
4075 parameterCases[ndx].depth,
4076 parameterCases[ndx].height,
4077 parameterCases[ndx].imageHeight,
4078 parameterCases[ndx].rowLength,
4079 parameterCases[ndx].skipImages,
4080 parameterCases[ndx].skipRows,
4081 parameterCases[ndx].skipPixels,
4082 parameterCases[ndx].alignment,
4083 parameterCases[ndx].offset));
4084 pboGroup->addChild(new TexImage3DBufferCase(m_context, (string(parameterCases[ndx].name) + "_3d").c_str(), "",
4085 parameterCases[ndx].format,
4086 parameterCases[ndx].width,
4087 parameterCases[ndx].depth,
4088 parameterCases[ndx].height,
4089 parameterCases[ndx].imageHeight,
4090 parameterCases[ndx].rowLength,
4091 parameterCases[ndx].skipImages,
4092 parameterCases[ndx].skipRows,
4093 parameterCases[ndx].skipPixels,
4094 parameterCases[ndx].alignment,
4095 parameterCases[ndx].offset));
4099 // glTexImage3D() depth cases.
4101 tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_depth", "glTexImage3D() with depth or depth/stencil format");
4102 addChild(shadow3dGroup);
4104 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
4106 const int tex3DWidth = 32;
4107 const int tex3DHeight = 64;
4108 const int tex3DDepth = 8;
4110 shadow3dGroup->addChild(new TexImage2DArrayDepthCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex3DWidth, tex3DHeight, tex3DDepth));
4114 // glTexImage3D() depth cases with pbo.
4116 tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_depth_pbo", "glTexImage3D() with depth or depth/stencil format with pbo");
4117 addChild(shadow3dGroup);
4119 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
4121 const int tex3DWidth = 32;
4122 const int tex3DHeight = 64;
4123 const int tex3DDepth = 8;
4125 shadow3dGroup->addChild(new TexImage2DArrayDepthBufferCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex3DWidth, tex3DHeight, tex3DDepth));
4129 // Basic TexSubImage3D usage.
4131 tcu::TestCaseGroup* basicTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_texsubimage3d", "Basic glTexSubImage3D() usage");
4132 addChild(basicTexSubImageGroup);
4133 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
4135 const char* fmtName = colorFormats[formatNdx].name;
4136 deUint32 format = colorFormats[formatNdx].internalFormat;
4137 const int tex3DWidth = 32;
4138 const int tex3DHeight = 64;
4139 const int tex3DDepth = 8;
4141 basicTexSubImageGroup->addChild(new BasicTexSubImage3DCase(m_context, (string(fmtName) + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth));
4145 // glTexSubImage3D() unpack params cases.
4147 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_unpack_params", "glTexSubImage3D() unpack parameters");
4148 addChild(paramGroup);
4171 { "rgb8_image_height", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 26, 0, 0, 0, 0, 4 },
4172 { "rgb8_row_length", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 27, 0, 0, 0, 4 },
4173 { "rgb8_skip_images", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 3, 0, 0, 4 },
4174 { "rgb8_skip_rows", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 22, 0, 0, 3, 0, 4 },
4175 { "rgb8_skip_pixels", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 25, 0, 0, 2, 4 },
4176 { "r8_complex1", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 1 },
4177 { "r8_complex2", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 2 },
4178 { "r8_complex3", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 4 },
4179 { "r8_complex4", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 8 },
4180 { "rgba8_complex1", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 0, 0, 8 },
4181 { "rgba8_complex2", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 0, 8 },
4182 { "rgba8_complex3", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 0, 3, 8 },
4183 { "rgba8_complex4", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 3, 8 },
4184 { "rgba32f_complex", GL_RGBA32F, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 3, 8 }
4187 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++)
4188 paramGroup->addChild(new TexSubImage3DParamsCase(m_context, cases[ndx].name, "",
4199 cases[ndx].imageHeight,
4200 cases[ndx].rowLength,
4201 cases[ndx].skipImages,
4202 cases[ndx].skipRows,
4203 cases[ndx].skipPixels,
4204 cases[ndx].alignment));
4207 // glTexSubImage3D() PBO cases.
4209 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_pbo", "glTexSubImage3D() pixel buffer object tests");
4234 { "rgb8_offset", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 0, 0, 0, 4, 67 },
4235 { "rgb8_image_height", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 26, 0, 0, 0, 0, 4, 0 },
4236 { "rgb8_row_length", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 27, 0, 0, 0, 4, 0 },
4237 { "rgb8_skip_images", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 3, 0, 0, 4, 0 },
4238 { "rgb8_skip_rows", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 22, 0, 0, 3, 0, 4, 0 },
4239 { "rgb8_skip_pixels", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 25, 0, 0, 2, 4, 0 }
4242 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorFormats); ndx++)
4244 pboGroup->addChild(new TexSubImage2DArrayBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_2d_array").c_str(), "",
4245 colorFormats[ndx].internalFormat,
4262 pboGroup->addChild(new TexSubImage3DBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_3d").c_str(), "",
4263 colorFormats[ndx].internalFormat,
4282 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(paramCases); ndx++)
4284 pboGroup->addChild(new TexSubImage2DArrayBufferCase(m_context, (std::string(paramCases[ndx].name) + "_2d_array").c_str(), "",
4285 paramCases[ndx].format,
4286 paramCases[ndx].width,
4287 paramCases[ndx].height,
4288 paramCases[ndx].depth,
4289 paramCases[ndx].subX,
4290 paramCases[ndx].subY,
4291 paramCases[ndx].subZ,
4292 paramCases[ndx].subW,
4293 paramCases[ndx].subH,
4294 paramCases[ndx].subD,
4295 paramCases[ndx].imageHeight,
4296 paramCases[ndx].rowLength,
4297 paramCases[ndx].skipImages,
4298 paramCases[ndx].skipRows,
4299 paramCases[ndx].skipPixels,
4300 paramCases[ndx].alignment,
4301 paramCases[ndx].offset));
4302 pboGroup->addChild(new TexSubImage3DBufferCase(m_context, (std::string(paramCases[ndx].name) + "_3d").c_str(), "",
4303 paramCases[ndx].format,
4304 paramCases[ndx].width,
4305 paramCases[ndx].height,
4306 paramCases[ndx].depth,
4307 paramCases[ndx].subX,
4308 paramCases[ndx].subY,
4309 paramCases[ndx].subZ,
4310 paramCases[ndx].subW,
4311 paramCases[ndx].subH,
4312 paramCases[ndx].subD,
4313 paramCases[ndx].imageHeight,
4314 paramCases[ndx].rowLength,
4315 paramCases[ndx].skipImages,
4316 paramCases[ndx].skipRows,
4317 paramCases[ndx].skipPixels,
4318 paramCases[ndx].alignment,
4319 paramCases[ndx].offset));
4323 // glTexSubImage3D() depth cases.
4325 tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_depth", "glTexSubImage3D() with depth or depth/stencil format");
4326 addChild(shadow3dGroup);
4328 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
4330 const int tex2DArrayWidth = 57;
4331 const int tex2DArrayHeight = 44;
4332 const int tex2DArrayLevels = 5;
4334 shadow3dGroup->addChild(new TexSubImage2DArrayDepthCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLevels));
4338 // glTexStorage2D() cases.
4340 tcu::TestCaseGroup* texStorageGroup = new tcu::TestCaseGroup(m_testCtx, "texstorage2d", "Basic glTexStorage2D() usage");
4341 addChild(texStorageGroup);
4344 tcu::TestCaseGroup* formatGroup = new tcu::TestCaseGroup(m_testCtx, "format", "glTexStorage2D() with all formats");
4345 texStorageGroup->addChild(formatGroup);
4348 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
4350 const char* fmtName = colorFormats[formatNdx].name;
4351 deUint32 internalFormat = colorFormats[formatNdx].internalFormat;
4352 const int tex2DWidth = 117;
4353 const int tex2DHeight = 97;
4354 int tex2DLevels = maxLevelCount(tex2DWidth, tex2DHeight);
4355 const int cubeSize = 57;
4356 int cubeLevels = maxLevelCount(cubeSize, cubeSize);
4358 formatGroup->addChild(new BasicTexStorage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", internalFormat, tex2DWidth, tex2DHeight, tex2DLevels));
4359 formatGroup->addChild(new BasicTexStorageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", internalFormat, cubeSize, cubeLevels));
4362 // Depth / stencil formats.
4363 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthStencilFormats); formatNdx++)
4365 const char* fmtName = depthStencilFormats[formatNdx].name;
4366 deUint32 internalFormat = depthStencilFormats[formatNdx].internalFormat;
4367 const int tex2DWidth = 117;
4368 const int tex2DHeight = 97;
4369 int tex2DLevels = maxLevelCount(tex2DWidth, tex2DHeight);
4370 const int cubeSize = 57;
4371 int cubeLevels = maxLevelCount(cubeSize, cubeSize);
4373 formatGroup->addChild(new BasicTexStorage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", internalFormat, tex2DWidth, tex2DHeight, tex2DLevels));
4374 formatGroup->addChild(new BasicTexStorageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", internalFormat, cubeSize, cubeLevels));
4410 tcu::TestCaseGroup* sizeGroup = new tcu::TestCaseGroup(m_testCtx, "size", "glTexStorage2D() with various sizes");
4411 texStorageGroup->addChild(sizeGroup);
4413 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex2DSizes); ndx++)
4415 const deUint32 format = GL_RGBA8;
4416 int width = tex2DSizes[ndx].width;
4417 int height = tex2DSizes[ndx].height;
4418 int levels = tex2DSizes[ndx].levels;
4419 string name = string("2d_") + de::toString(width) + "x" + de::toString(height) + "_" + de::toString(levels) + "_levels";
4421 sizeGroup->addChild(new BasicTexStorage2DCase(m_context, name.c_str(), "", format, width, height, levels));
4424 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cubeSizes); ndx++)
4426 const deUint32 format = GL_RGBA8;
4427 int size = cubeSizes[ndx].size;
4428 int levels = cubeSizes[ndx].levels;
4429 string name = string("cube_") + de::toString(size) + "x" + de::toString(size) + "_" + de::toString(levels) + "_levels";
4431 sizeGroup->addChild(new BasicTexStorageCubeCase(m_context, name.c_str(), "", format, size, levels));
4435 // glTexStorage3D() cases.
4437 tcu::TestCaseGroup* texStorageGroup = new tcu::TestCaseGroup(m_testCtx, "texstorage3d", "Basic glTexStorage3D() usage");
4438 addChild(texStorageGroup);
4441 tcu::TestCaseGroup* formatGroup = new tcu::TestCaseGroup(m_testCtx, "format", "glTexStorage3D() with all formats");
4442 texStorageGroup->addChild(formatGroup);
4445 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
4447 const char* fmtName = colorFormats[formatNdx].name;
4448 deUint32 internalFormat = colorFormats[formatNdx].internalFormat;
4449 const int tex2DArrayWidth = 57;
4450 const int tex2DArrayHeight = 13;
4451 const int tex2DArrayLayers = 7;
4452 int tex2DArrayLevels = maxLevelCount(tex2DArrayWidth, tex2DArrayHeight);
4453 const int tex3DWidth = 59;
4454 const int tex3DHeight = 37;
4455 const int tex3DDepth = 11;
4456 int tex3DLevels = maxLevelCount(tex3DWidth, tex3DHeight, tex3DDepth);
4458 formatGroup->addChild(new BasicTexStorage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels));
4459 formatGroup->addChild(new BasicTexStorage3DCase (m_context, (string(fmtName) + "_3d").c_str(), "", internalFormat, tex3DWidth, tex3DHeight, tex3DDepth, tex3DLevels));
4462 // Depth/stencil formats (only 2D texture array is supported).
4463 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthStencilFormats); formatNdx++)
4465 const char* fmtName = depthStencilFormats[formatNdx].name;
4466 deUint32 internalFormat = depthStencilFormats[formatNdx].internalFormat;
4467 const int tex2DArrayWidth = 57;
4468 const int tex2DArrayHeight = 13;
4469 const int tex2DArrayLayers = 7;
4470 int tex2DArrayLevels = maxLevelCount(tex2DArrayWidth, tex2DArrayHeight);
4472 formatGroup->addChild(new BasicTexStorage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels));
4482 } tex2DArraySizes[] =
4512 tcu::TestCaseGroup* sizeGroup = new tcu::TestCaseGroup(m_testCtx, "size", "glTexStorage2D() with various sizes");
4513 texStorageGroup->addChild(sizeGroup);
4515 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex2DArraySizes); ndx++)
4517 const deUint32 format = GL_RGBA8;
4518 int width = tex2DArraySizes[ndx].width;
4519 int height = tex2DArraySizes[ndx].height;
4520 int layers = tex2DArraySizes[ndx].layers;
4521 int levels = tex2DArraySizes[ndx].levels;
4522 string name = string("2d_array_") + de::toString(width) + "x" + de::toString(height) + "x" + de::toString(layers) + "_" + de::toString(levels) + "_levels";
4524 sizeGroup->addChild(new BasicTexStorage2DArrayCase(m_context, name.c_str(), "", format, width, height, layers, levels));
4527 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex3DSizes); ndx++)
4529 const deUint32 format = GL_RGBA8;
4530 int width = tex3DSizes[ndx].width;
4531 int height = tex3DSizes[ndx].height;
4532 int depth = tex3DSizes[ndx].depth;
4533 int levels = tex3DSizes[ndx].levels;
4534 string name = string("3d_") + de::toString(width) + "x" + de::toString(height) + "x" + de::toString(depth) + "_" + de::toString(levels) + "_levels";
4536 sizeGroup->addChild(new BasicTexStorage3DCase(m_context, name.c_str(), "", format, width, height, depth, levels));