You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4544 lines
166 KiB
4544 lines
166 KiB
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES 3.0 Module
|
|
* -------------------------------------------------
|
|
*
|
|
* Copyright 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*//*!
|
|
* \file
|
|
* \brief Texture specification tests.
|
|
*
|
|
* \todo [pyry] Following tests are missing:
|
|
* - Specify mipmap incomplete texture, use without mipmaps, re-specify
|
|
* as complete and render.
|
|
* - Randomly re-specify levels to eventually reach mipmap-complete texture.
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "es3fTextureSpecificationTests.hpp"
|
|
#include "tcuTestLog.hpp"
|
|
#include "tcuImageCompare.hpp"
|
|
#include "tcuTextureUtil.hpp"
|
|
#include "tcuVectorUtil.hpp"
|
|
#include "gluStrUtil.hpp"
|
|
#include "gluTexture.hpp"
|
|
#include "gluTextureUtil.hpp"
|
|
#include "sglrContextUtil.hpp"
|
|
#include "sglrContextWrapper.hpp"
|
|
#include "sglrGLContext.hpp"
|
|
#include "sglrReferenceContext.hpp"
|
|
#include "glsTextureTestUtil.hpp"
|
|
#include "deRandom.hpp"
|
|
#include "deStringUtil.hpp"
|
|
|
|
// \todo [2012-04-29 pyry] Should be named SglrUtil
|
|
#include "es3fFboTestUtil.hpp"
|
|
|
|
#include "glwEnums.hpp"
|
|
|
|
namespace deqp
|
|
{
|
|
namespace gles3
|
|
{
|
|
namespace Functional
|
|
{
|
|
|
|
using std::string;
|
|
using std::vector;
|
|
using std::pair;
|
|
using tcu::TestLog;
|
|
using tcu::Vec4;
|
|
using tcu::IVec4;
|
|
using tcu::UVec4;
|
|
using namespace FboTestUtil;
|
|
|
|
tcu::TextureFormat mapGLUnsizedInternalFormat (deUint32 internalFormat)
|
|
{
|
|
using tcu::TextureFormat;
|
|
switch (internalFormat)
|
|
{
|
|
case GL_ALPHA: return TextureFormat(TextureFormat::A, TextureFormat::UNORM_INT8);
|
|
case GL_LUMINANCE: return TextureFormat(TextureFormat::L, TextureFormat::UNORM_INT8);
|
|
case GL_LUMINANCE_ALPHA: return TextureFormat(TextureFormat::LA, TextureFormat::UNORM_INT8);
|
|
case GL_RGB: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8);
|
|
case GL_RGBA: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
|
|
default:
|
|
throw tcu::InternalError(string("Can't map GL unsized internal format (") + tcu::toHex(internalFormat).toString() + ") to texture format");
|
|
}
|
|
}
|
|
|
|
enum
|
|
{
|
|
VIEWPORT_WIDTH = 256,
|
|
VIEWPORT_HEIGHT = 256
|
|
};
|
|
|
|
static inline int maxLevelCount (int width, int height)
|
|
{
|
|
return (int)deLog2Floor32(de::max(width, height))+1;
|
|
}
|
|
|
|
static inline int maxLevelCount (int width, int height, int depth)
|
|
{
|
|
return (int)deLog2Floor32(de::max(width, de::max(height, depth)))+1;
|
|
}
|
|
|
|
template <int Size>
|
|
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))
|
|
{
|
|
tcu::Vector<float, Size> res;
|
|
for (int ndx = 0; ndx < Size; ndx++)
|
|
res[ndx] = rnd.getFloat(minVal[ndx], maxVal[ndx]);
|
|
return res;
|
|
}
|
|
|
|
static const deUint32 s_cubeMapFaces[] =
|
|
{
|
|
GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
|
|
GL_TEXTURE_CUBE_MAP_POSITIVE_X,
|
|
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
|
|
GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
|
|
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
|
|
GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
|
|
};
|
|
|
|
static tcu::IVec4 getPixelFormatCompareDepth (const tcu::PixelFormat& pixelFormat, tcu::TextureFormat textureFormat)
|
|
{
|
|
switch (textureFormat.order)
|
|
{
|
|
case tcu::TextureFormat::L:
|
|
case tcu::TextureFormat::LA:
|
|
return tcu::IVec4(pixelFormat.redBits, pixelFormat.redBits, pixelFormat.redBits, pixelFormat.alphaBits);
|
|
default:
|
|
return tcu::IVec4(pixelFormat.redBits, pixelFormat.greenBits, pixelFormat.blueBits, pixelFormat.alphaBits);
|
|
}
|
|
}
|
|
|
|
static IVec4 getEffectiveTextureFormatBitDepth (tcu::TextureFormat textureFormat)
|
|
{
|
|
if (textureFormat.order == tcu::TextureFormat::DS)
|
|
{
|
|
// When sampling depth-stencil texture, we actually sample just
|
|
// the depth component.
|
|
return tcu::getTextureFormatBitDepth(tcu::getEffectiveDepthStencilTextureFormat(textureFormat, tcu::Sampler::MODE_DEPTH));
|
|
}
|
|
else
|
|
return tcu::getTextureFormatBitDepth(textureFormat);
|
|
}
|
|
|
|
static tcu::UVec4 computeCompareThreshold (const tcu::PixelFormat& pixelFormat, tcu::TextureFormat textureFormat)
|
|
{
|
|
const IVec4 texFormatBits = getEffectiveTextureFormatBitDepth(textureFormat);
|
|
const IVec4 pixelFormatBits = getPixelFormatCompareDepth(pixelFormat, textureFormat);
|
|
const IVec4 accurateFmtBits = min(pixelFormatBits, texFormatBits);
|
|
const IVec4 compareBits = select(accurateFmtBits, IVec4(8), greaterThan(accurateFmtBits, IVec4(0))) - 1;
|
|
|
|
return (IVec4(1) << (8-compareBits)).asUint();
|
|
}
|
|
|
|
class TextureSpecCase : public TestCase, public sglr::ContextWrapper
|
|
{
|
|
public:
|
|
TextureSpecCase (Context& context, const char* name, const char* desc);
|
|
~TextureSpecCase (void);
|
|
|
|
IterateResult iterate (void);
|
|
|
|
protected:
|
|
virtual void createTexture (void) = DE_NULL;
|
|
virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext) = DE_NULL;
|
|
|
|
// Utilities.
|
|
void renderTex (tcu::Surface& dst, deUint32 program, int width, int height);
|
|
void readPixels (tcu::Surface& dst, int x, int y, int width, int height);
|
|
|
|
private:
|
|
TextureSpecCase (const TextureSpecCase& other);
|
|
TextureSpecCase& operator= (const TextureSpecCase& other);
|
|
};
|
|
|
|
TextureSpecCase::TextureSpecCase (Context& context, const char* name, const char* desc)
|
|
: TestCase(context, name, desc)
|
|
{
|
|
}
|
|
|
|
TextureSpecCase::~TextureSpecCase (void)
|
|
{
|
|
}
|
|
|
|
TextureSpecCase::IterateResult TextureSpecCase::iterate (void)
|
|
{
|
|
glu::RenderContext& renderCtx = TestCase::m_context.getRenderContext();
|
|
const tcu::RenderTarget& renderTarget = renderCtx.getRenderTarget();
|
|
tcu::TestLog& log = m_testCtx.getLog();
|
|
|
|
if (renderTarget.getWidth() < VIEWPORT_WIDTH || renderTarget.getHeight() < VIEWPORT_HEIGHT)
|
|
throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__);
|
|
|
|
// Context size, and viewport for GLES3
|
|
de::Random rnd (deStringHash(getName()));
|
|
int width = deMin32(renderTarget.getWidth(), VIEWPORT_WIDTH);
|
|
int height = deMin32(renderTarget.getHeight(), VIEWPORT_HEIGHT);
|
|
int x = rnd.getInt(0, renderTarget.getWidth() - width);
|
|
int y = rnd.getInt(0, renderTarget.getHeight() - height);
|
|
|
|
// Contexts.
|
|
sglr::GLContext gles3Context (renderCtx, log, sglr::GLCONTEXT_LOG_CALLS, tcu::IVec4(x, y, width, height));
|
|
sglr::ReferenceContextBuffers refBuffers (tcu::PixelFormat(8,8,8,renderTarget.getPixelFormat().alphaBits?8:0), 0 /* depth */, 0 /* stencil */, width, height);
|
|
sglr::ReferenceContext refContext (sglr::ReferenceContextLimits(renderCtx), refBuffers.getColorbuffer(), refBuffers.getDepthbuffer(), refBuffers.getStencilbuffer());
|
|
|
|
// Clear color buffer.
|
|
for (int ndx = 0; ndx < 2; ndx++)
|
|
{
|
|
setContext(ndx ? (sglr::Context*)&refContext : (sglr::Context*)&gles3Context);
|
|
glClearColor(0.125f, 0.25f, 0.5f, 1.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
|
|
}
|
|
|
|
// Construct texture using both GLES3 and reference contexts.
|
|
for (int ndx = 0; ndx < 2; ndx++)
|
|
{
|
|
setContext(ndx ? (sglr::Context*)&refContext : (sglr::Context*)&gles3Context);
|
|
createTexture();
|
|
TCU_CHECK(glGetError() == GL_NO_ERROR);
|
|
}
|
|
|
|
// Initialize case result to pass.
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
|
|
|
|
// Disable logging.
|
|
gles3Context.enableLogging(0);
|
|
|
|
// Verify results.
|
|
verifyTexture(gles3Context, refContext);
|
|
|
|
return STOP;
|
|
}
|
|
|
|
void TextureSpecCase::renderTex (tcu::Surface& dst, deUint32 program, int width, int height)
|
|
{
|
|
int targetW = getWidth();
|
|
int targetH = getHeight();
|
|
|
|
float w = (float)width / (float)targetW;
|
|
float h = (float)height / (float)targetH;
|
|
|
|
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));
|
|
|
|
// Read pixels back.
|
|
readPixels(dst, 0, 0, width, height);
|
|
}
|
|
|
|
void TextureSpecCase::readPixels (tcu::Surface& dst, int x, int y, int width, int height)
|
|
{
|
|
dst.setSize(width, height);
|
|
glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, dst.getAccess().getDataPtr());
|
|
}
|
|
|
|
class Texture2DSpecCase : public TextureSpecCase
|
|
{
|
|
public:
|
|
Texture2DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLevels);
|
|
~Texture2DSpecCase (void);
|
|
|
|
protected:
|
|
virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext);
|
|
|
|
tcu::TextureFormat m_texFormat;
|
|
tcu::TextureFormatInfo m_texFormatInfo;
|
|
int m_width;
|
|
int m_height;
|
|
int m_numLevels;
|
|
};
|
|
|
|
Texture2DSpecCase::Texture2DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLevels)
|
|
: TextureSpecCase (context, name, desc)
|
|
, m_texFormat (format)
|
|
, m_texFormatInfo (tcu::getTextureFormatInfo(format))
|
|
, m_width (width)
|
|
, m_height (height)
|
|
, m_numLevels (numLevels)
|
|
{
|
|
}
|
|
|
|
Texture2DSpecCase::~Texture2DSpecCase (void)
|
|
{
|
|
}
|
|
|
|
void Texture2DSpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext)
|
|
{
|
|
Texture2DShader shader (DataTypes() << glu::getSampler2DType(m_texFormat), glu::TYPE_FLOAT_VEC4);
|
|
deUint32 shaderIDgles = gles3Context.createProgram(&shader);
|
|
deUint32 shaderIDRef = refContext.createProgram(&shader);
|
|
|
|
shader.setTexScaleBias(0, m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias);
|
|
|
|
// Set state.
|
|
for (int ndx = 0; ndx < 2; ndx++)
|
|
{
|
|
sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
|
|
|
|
setContext(ctx);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, m_numLevels-1);
|
|
}
|
|
|
|
for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> levelNdx);
|
|
int levelH = de::max(1, m_height >> levelNdx);
|
|
tcu::Surface reference;
|
|
tcu::Surface result;
|
|
|
|
for (int ndx = 0; ndx < 2; ndx++)
|
|
{
|
|
tcu::Surface& dst = ndx ? reference : result;
|
|
sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
|
|
deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles;
|
|
|
|
setContext(ctx);
|
|
shader.setUniforms(*ctx, shaderID);
|
|
renderTex(dst, shaderID, levelW, levelH);
|
|
}
|
|
|
|
UVec4 threshold = computeCompareThreshold(m_context.getRenderTarget().getPixelFormat(), m_texFormat);
|
|
string levelStr = de::toString(levelNdx);
|
|
string name = string("Level") + levelStr;
|
|
string desc = string("Level ") + levelStr;
|
|
bool isOk = tcu::intThresholdCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference.getAccess(), result.getAccess(), threshold,
|
|
levelNdx == 0 ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR);
|
|
|
|
if (!isOk)
|
|
{
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
class TextureCubeSpecCase : public TextureSpecCase
|
|
{
|
|
public:
|
|
TextureCubeSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int size, int numLevels);
|
|
~TextureCubeSpecCase (void);
|
|
|
|
protected:
|
|
virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext);
|
|
|
|
tcu::TextureFormat m_texFormat;
|
|
tcu::TextureFormatInfo m_texFormatInfo;
|
|
int m_size;
|
|
int m_numLevels;
|
|
};
|
|
|
|
TextureCubeSpecCase::TextureCubeSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int size, int numLevels)
|
|
: TextureSpecCase (context, name, desc)
|
|
, m_texFormat (format)
|
|
, m_texFormatInfo (tcu::getTextureFormatInfo(format))
|
|
, m_size (size)
|
|
, m_numLevels (numLevels)
|
|
{
|
|
}
|
|
|
|
TextureCubeSpecCase::~TextureCubeSpecCase (void)
|
|
{
|
|
}
|
|
|
|
void TextureCubeSpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext)
|
|
{
|
|
TextureCubeShader shader (glu::getSamplerCubeType(m_texFormat), glu::TYPE_FLOAT_VEC4);
|
|
deUint32 shaderIDgles = gles3Context.createProgram(&shader);
|
|
deUint32 shaderIDRef = refContext.createProgram(&shader);
|
|
|
|
shader.setTexScaleBias(m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias);
|
|
|
|
// Set state.
|
|
for (int ndx = 0; ndx < 2; ndx++)
|
|
{
|
|
sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
|
|
|
|
setContext(ctx);
|
|
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, m_numLevels-1);
|
|
}
|
|
|
|
for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> levelNdx);
|
|
bool isOk = true;
|
|
|
|
for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
|
|
{
|
|
tcu::Surface reference;
|
|
tcu::Surface result;
|
|
|
|
if (levelSize <= 2)
|
|
continue; // Fuzzy compare doesn't work for images this small.
|
|
|
|
shader.setFace((tcu::CubeFace)face);
|
|
|
|
for (int ndx = 0; ndx < 2; ndx++)
|
|
{
|
|
tcu::Surface& dst = ndx ? reference : result;
|
|
sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
|
|
deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles;
|
|
|
|
setContext(ctx);
|
|
shader.setUniforms(*ctx, shaderID);
|
|
renderTex(dst, shaderID, levelSize, levelSize);
|
|
}
|
|
|
|
const float threshold = 0.02f;
|
|
string faceStr = de::toString((tcu::CubeFace)face);
|
|
string levelStr = de::toString(levelNdx);
|
|
string name = string("Level") + levelStr;
|
|
string desc = string("Level ") + levelStr + ", face " + faceStr;
|
|
bool isFaceOk = tcu::fuzzyCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference, result, threshold,
|
|
levelNdx == 0 ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR);
|
|
|
|
if (!isFaceOk)
|
|
{
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
|
|
isOk = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!isOk)
|
|
break;
|
|
}
|
|
}
|
|
|
|
class Texture2DArraySpecCase : public TextureSpecCase
|
|
{
|
|
public:
|
|
Texture2DArraySpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLayers, int numLevels);
|
|
~Texture2DArraySpecCase (void);
|
|
|
|
protected:
|
|
virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext);
|
|
|
|
tcu::TextureFormat m_texFormat;
|
|
tcu::TextureFormatInfo m_texFormatInfo;
|
|
int m_width;
|
|
int m_height;
|
|
int m_numLayers;
|
|
int m_numLevels;
|
|
};
|
|
|
|
Texture2DArraySpecCase::Texture2DArraySpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLayers, int numLevels)
|
|
: TextureSpecCase (context, name, desc)
|
|
, m_texFormat (format)
|
|
, m_texFormatInfo (tcu::getTextureFormatInfo(format))
|
|
, m_width (width)
|
|
, m_height (height)
|
|
, m_numLayers (numLayers)
|
|
, m_numLevels (numLevels)
|
|
{
|
|
}
|
|
|
|
Texture2DArraySpecCase::~Texture2DArraySpecCase (void)
|
|
{
|
|
}
|
|
|
|
void Texture2DArraySpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext)
|
|
{
|
|
Texture2DArrayShader shader (glu::getSampler2DArrayType(m_texFormat), glu::TYPE_FLOAT_VEC4);
|
|
deUint32 shaderIDgles = gles3Context.createProgram(&shader);
|
|
deUint32 shaderIDRef = refContext.createProgram(&shader);
|
|
|
|
shader.setTexScaleBias(m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias);
|
|
|
|
// Set state.
|
|
for (int ndx = 0; ndx < 2; ndx++)
|
|
{
|
|
sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
|
|
|
|
setContext(ctx);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, m_numLevels-1);
|
|
}
|
|
|
|
for (int layerNdx = 0; layerNdx < m_numLayers; layerNdx++)
|
|
{
|
|
bool layerOk = true;
|
|
|
|
shader.setLayer(layerNdx);
|
|
|
|
for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> levelNdx);
|
|
int levelH = de::max(1, m_height >> levelNdx);
|
|
tcu::Surface reference;
|
|
tcu::Surface result;
|
|
|
|
for (int ndx = 0; ndx < 2; ndx++)
|
|
{
|
|
tcu::Surface& dst = ndx ? reference : result;
|
|
sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
|
|
deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles;
|
|
|
|
setContext(ctx);
|
|
shader.setUniforms(*ctx, shaderID);
|
|
renderTex(dst, shaderID, levelW, levelH);
|
|
}
|
|
|
|
UVec4 threshold = computeCompareThreshold(m_context.getRenderTarget().getPixelFormat(), m_texFormat);
|
|
string levelStr = de::toString(levelNdx);
|
|
string layerStr = de::toString(layerNdx);
|
|
string name = string("Layer") + layerStr + "Level" + levelStr;
|
|
string desc = string("Layer ") + layerStr + ", Level " + levelStr;
|
|
bool depthOk = tcu::intThresholdCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference.getAccess(), result.getAccess(), threshold,
|
|
(levelNdx == 0 && layerNdx == 0) ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR);
|
|
|
|
if (!depthOk)
|
|
{
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
|
|
layerOk = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!layerOk)
|
|
break;
|
|
}
|
|
}
|
|
|
|
class Texture3DSpecCase : public TextureSpecCase
|
|
{
|
|
public:
|
|
Texture3DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int depth, int numLevels);
|
|
~Texture3DSpecCase (void);
|
|
|
|
protected:
|
|
virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext);
|
|
|
|
tcu::TextureFormat m_texFormat;
|
|
tcu::TextureFormatInfo m_texFormatInfo;
|
|
int m_width;
|
|
int m_height;
|
|
int m_depth;
|
|
int m_numLevels;
|
|
};
|
|
|
|
Texture3DSpecCase::Texture3DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int depth, int numLevels)
|
|
: TextureSpecCase (context, name, desc)
|
|
, m_texFormat (format)
|
|
, m_texFormatInfo (tcu::getTextureFormatInfo(format))
|
|
, m_width (width)
|
|
, m_height (height)
|
|
, m_depth (depth)
|
|
, m_numLevels (numLevels)
|
|
{
|
|
}
|
|
|
|
Texture3DSpecCase::~Texture3DSpecCase (void)
|
|
{
|
|
}
|
|
|
|
void Texture3DSpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext)
|
|
{
|
|
Texture3DShader shader (glu::getSampler3DType(m_texFormat), glu::TYPE_FLOAT_VEC4);
|
|
deUint32 shaderIDgles = gles3Context.createProgram(&shader);
|
|
deUint32 shaderIDRef = refContext.createProgram(&shader);
|
|
|
|
shader.setTexScaleBias(m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias);
|
|
|
|
// Set state.
|
|
for (int ndx = 0; ndx < 2; ndx++)
|
|
{
|
|
sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
|
|
|
|
setContext(ctx);
|
|
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, m_numLevels-1);
|
|
}
|
|
|
|
for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> levelNdx);
|
|
int levelH = de::max(1, m_height >> levelNdx);
|
|
int levelD = de::max(1, m_depth >> levelNdx);
|
|
bool levelOk = true;
|
|
|
|
for (int depth = 0; depth < levelD; depth++)
|
|
{
|
|
tcu::Surface reference;
|
|
tcu::Surface result;
|
|
|
|
shader.setDepth(((float)depth + 0.5f) / (float)levelD);
|
|
|
|
for (int ndx = 0; ndx < 2; ndx++)
|
|
{
|
|
tcu::Surface& dst = ndx ? reference : result;
|
|
sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context);
|
|
deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles;
|
|
|
|
setContext(ctx);
|
|
shader.setUniforms(*ctx, shaderID);
|
|
renderTex(dst, shaderID, levelW, levelH);
|
|
}
|
|
|
|
UVec4 threshold = computeCompareThreshold(m_context.getRenderTarget().getPixelFormat(), m_texFormat);
|
|
string levelStr = de::toString(levelNdx);
|
|
string sliceStr = de::toString(depth);
|
|
string name = string("Level") + levelStr + "Slice" + sliceStr;
|
|
string desc = string("Level ") + levelStr + ", Slice " + sliceStr;
|
|
bool depthOk = tcu::intThresholdCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference.getAccess(), result.getAccess(), threshold,
|
|
(levelNdx == 0 && depth == 0) ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR);
|
|
|
|
if (!depthOk)
|
|
{
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
|
|
levelOk = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!levelOk)
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Basic TexImage2D() with 2D texture usage
|
|
class BasicTexImage2DCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
// Unsized internal format.
|
|
BasicTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height))
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
{
|
|
}
|
|
|
|
// Sized internal format.
|
|
BasicTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height))
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType));
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
levelData.setSize(levelW, levelH);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
};
|
|
|
|
// Basic TexImage2D() with cubemap usage
|
|
class BasicTexImageCubeCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
// Unsized formats.
|
|
BasicTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1)
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
{
|
|
}
|
|
|
|
// Sized internal formats.
|
|
BasicTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType));
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> ndx);
|
|
|
|
levelData.setSize(levelSize, levelSize);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
{
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
};
|
|
|
|
// Basic TexImage3D() with 2D array texture usage
|
|
class BasicTexImage2DArrayCase : public Texture2DArraySpecCase
|
|
{
|
|
public:
|
|
BasicTexImage2DArrayCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLayers)
|
|
: Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLayers, maxLevelCount(width, height))
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
de::Random rnd (deStringHash(getName()));
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
levelData.setSize(levelW, levelH, m_numLayers);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
};
|
|
|
|
// Basic TexImage3D() with 3D texture usage
|
|
class BasicTexImage3DCase : public Texture3DSpecCase
|
|
{
|
|
public:
|
|
BasicTexImage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth)
|
|
: Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, maxLevelCount(width, height, depth))
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
de::Random rnd (deStringHash(getName()));
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_3D, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
int levelD = de::max(1, m_depth >> ndx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
levelData.setSize(levelW, levelH, levelD);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexImage3D(GL_TEXTURE_3D, ndx, m_internalFormat, levelW, levelH, levelD, 0, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
};
|
|
|
|
// Randomized 2D texture specification using TexImage2D
|
|
class RandomOrderTexImage2DCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
RandomOrderTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height))
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
{
|
|
}
|
|
|
|
RandomOrderTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height))
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType));
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
vector<int> levels (m_numLevels);
|
|
|
|
for (int i = 0; i < m_numLevels; i++)
|
|
levels[i] = i;
|
|
rnd.shuffle(levels.begin(), levels.end());
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelNdx = levels[ndx];
|
|
int levelW = de::max(1, m_width >> levelNdx);
|
|
int levelH = de::max(1, m_height >> levelNdx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
levelData.setSize(levelW, levelH);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, levelNdx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
};
|
|
|
|
// Randomized cubemap texture specification using TexImage2D
|
|
class RandomOrderTexImageCubeCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
RandomOrderTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1)
|
|
, m_internalFormat (GL_NONE)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
{
|
|
}
|
|
|
|
RandomOrderTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType));
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
// Level-face pairs.
|
|
vector<pair<int, tcu::CubeFace> > images (m_numLevels*6);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
|
|
images[ndx*6 + face] = std::make_pair(ndx, (tcu::CubeFace)face);
|
|
|
|
rnd.shuffle(images.begin(), images.end());
|
|
|
|
for (int ndx = 0; ndx < (int)images.size(); ndx++)
|
|
{
|
|
int levelNdx = images[ndx].first;
|
|
tcu::CubeFace face = images[ndx].second;
|
|
int levelSize = de::max(1, m_size >> levelNdx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
levelData.setSize(levelSize, levelSize);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexImage2D(s_cubeMapFaces[face], levelNdx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
};
|
|
|
|
// TexImage2D() unpack alignment case.
|
|
class TexImage2DAlignCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
TexImage2DAlignCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height, int numLevels, int alignment)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, numLevels)
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
, m_alignment (alignment)
|
|
{
|
|
}
|
|
|
|
TexImage2DAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLevels, int alignment)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLevels)
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
, m_alignment (alignment)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
vector<deUint8> data;
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin;
|
|
int rowPitch = deAlign32(levelW*m_texFormat.getPixelSize(), m_alignment);
|
|
int cellSize = de::max(1, de::min(levelW >> 2, levelH >> 2));
|
|
|
|
data.resize(rowPitch*levelH);
|
|
tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, levelW, levelH, 1, rowPitch, 0, &data[0]), cellSize, colorA, colorB);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, &data[0]);
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
int m_alignment;
|
|
};
|
|
|
|
// TexImage2D() unpack alignment case.
|
|
class TexImageCubeAlignCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
TexImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size, int numLevels, int alignment)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, numLevels)
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
, m_alignment (alignment)
|
|
{
|
|
}
|
|
|
|
TexImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int numLevels, int alignment)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, numLevels)
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
, m_alignment (alignment)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
vector<deUint8> data;
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> ndx);
|
|
int rowPitch = deAlign32(m_texFormat.getPixelSize()*levelSize, m_alignment);
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin;
|
|
int cellSize = de::max(1, levelSize >> 2);
|
|
|
|
data.resize(rowPitch*levelSize);
|
|
tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, levelSize, levelSize, 1, rowPitch, 0, &data[0]), cellSize, colorA, colorB);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, &data[0]);
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
int m_alignment;
|
|
};
|
|
|
|
// TexImage2D() unpack parameters case.
|
|
class TexImage2DParamsCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
TexImage2DParamsCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int rowLength, int skipRows, int skipPixels, int alignment)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_rowLength (rowLength)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_width;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
deUint32 tex = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
// Fill data with grid.
|
|
data.resize(pixelSize * m_skipPixels + rowPitch * (m_height + m_skipRows));
|
|
{
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB);
|
|
}
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_rowLength;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
};
|
|
|
|
// TexImage3D() unpack parameters case.
|
|
class TexImage3DParamsCase : public Texture3DSpecCase
|
|
{
|
|
public:
|
|
TexImage3DParamsCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int width,
|
|
int height,
|
|
int depth,
|
|
int imageHeight,
|
|
int rowLength,
|
|
int skipImages,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment)
|
|
: Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_imageHeight (imageHeight)
|
|
, m_rowLength (rowLength)
|
|
, m_skipImages (skipImages)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_width;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height;
|
|
int slicePitch = imageHeight*rowPitch;
|
|
deUint32 tex = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
// Fill data with grid.
|
|
data.resize(pixelSize * m_skipPixels + rowPitch * m_skipRows + slicePitch * (m_skipImages + m_depth));
|
|
{
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
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);
|
|
}
|
|
|
|
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_3D, tex);
|
|
glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_imageHeight;
|
|
int m_rowLength;
|
|
int m_skipImages;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
};
|
|
|
|
// Basic TexSubImage2D() with 2D texture usage
|
|
class BasicTexSubImage2DCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
BasicTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height))
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
{
|
|
}
|
|
|
|
BasicTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height))
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel data (m_texFormat);
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
// First specify full texture.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
data.setSize(levelW, levelH);
|
|
tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, data.getAccess().getDataPtr());
|
|
}
|
|
|
|
// Re-specify parts of each level.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
|
|
int w = rnd.getInt(1, levelW);
|
|
int h = rnd.getInt(1, levelH);
|
|
int x = rnd.getInt(0, levelW-w);
|
|
int y = rnd.getInt(0, levelH-h);
|
|
|
|
Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
int cellSize = rnd.getInt(2, 16);
|
|
|
|
data.setSize(w, h);
|
|
tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB);
|
|
|
|
glTexSubImage2D(GL_TEXTURE_2D, ndx, x, y, w, h, m_format, m_dataType, data.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
};
|
|
|
|
// Basic TexSubImage2D() with cubemap usage
|
|
class BasicTexSubImageCubeCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
BasicTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1)
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
{
|
|
}
|
|
|
|
BasicTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel data (m_texFormat);
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> ndx);
|
|
|
|
data.setSize(levelSize, levelSize);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
{
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax);
|
|
|
|
glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, data.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
// Re-specify parts of each face and level.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> ndx);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
{
|
|
int w = rnd.getInt(1, levelSize);
|
|
int h = rnd.getInt(1, levelSize);
|
|
int x = rnd.getInt(0, levelSize-w);
|
|
int y = rnd.getInt(0, levelSize-h);
|
|
|
|
Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
int cellSize = rnd.getInt(2, 16);
|
|
|
|
data.setSize(w, h);
|
|
tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB);
|
|
|
|
glTexSubImage2D(s_cubeMapFaces[face], ndx, x, y, w, h, m_format, m_dataType, data.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
};
|
|
|
|
// TexSubImage2D() unpack parameters case.
|
|
class TexSubImage2DParamsCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
TexSubImage2DParamsCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int width,
|
|
int height,
|
|
int subX,
|
|
int subY,
|
|
int subW,
|
|
int subH,
|
|
int rowLength,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_subX (subX)
|
|
, m_subY (subY)
|
|
, m_subW (subW)
|
|
, m_subH (subH)
|
|
, m_rowLength (rowLength)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
deUint32 tex = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
|
|
// First fill texture with gradient.
|
|
data.resize(deAlign32(m_width*pixelSize, 4)*m_height);
|
|
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);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]);
|
|
|
|
// Fill data with grid.
|
|
{
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
int height = m_subH + m_skipRows;
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
data.resize(rowPitch*height);
|
|
tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB);
|
|
}
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, &data[0]);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_subX;
|
|
int m_subY;
|
|
int m_subW;
|
|
int m_subH;
|
|
int m_rowLength;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
};
|
|
|
|
// Basic TexSubImage3D() with 3D texture usage
|
|
class BasicTexSubImage3DCase : public Texture3DSpecCase
|
|
{
|
|
public:
|
|
BasicTexSubImage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth)
|
|
: Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, maxLevelCount(width, height, depth))
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel data (m_texFormat);
|
|
de::Random rnd (deStringHash(getName()));
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_3D, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
// First specify full texture.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
int levelD = de::max(1, m_depth >> ndx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
data.setSize(levelW, levelH, levelD);
|
|
tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax);
|
|
|
|
glTexImage3D(GL_TEXTURE_3D, ndx, m_internalFormat, levelW, levelH, levelD, 0, transferFmt.format, transferFmt.dataType, data.getAccess().getDataPtr());
|
|
}
|
|
|
|
// Re-specify parts of each level.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
int levelD = de::max(1, m_depth >> ndx);
|
|
|
|
int w = rnd.getInt(1, levelW);
|
|
int h = rnd.getInt(1, levelH);
|
|
int d = rnd.getInt(1, levelD);
|
|
int x = rnd.getInt(0, levelW-w);
|
|
int y = rnd.getInt(0, levelH-h);
|
|
int z = rnd.getInt(0, levelD-d);
|
|
|
|
Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
int cellSize = rnd.getInt(2, 16);
|
|
|
|
data.setSize(w, h, d);
|
|
tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB);
|
|
|
|
glTexSubImage3D(GL_TEXTURE_3D, ndx, x, y, z, w, h, d, transferFmt.format, transferFmt.dataType, data.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
};
|
|
|
|
// TexSubImage2D() to texture initialized with empty data
|
|
class TexSubImage2DEmptyTexCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
TexSubImage2DEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height))
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
{
|
|
}
|
|
|
|
TexSubImage2DEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height))
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel data (m_texFormat);
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
// First allocate storage for each level.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, DE_NULL);
|
|
}
|
|
|
|
// Specify pixel data to all levels using glTexSubImage2D()
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
data.setSize(levelW, levelH);
|
|
tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax);
|
|
|
|
glTexSubImage2D(GL_TEXTURE_2D, ndx, 0, 0, levelW, levelH, m_format, m_dataType, data.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
};
|
|
|
|
// TexSubImage2D() to empty cubemap texture
|
|
class TexSubImageCubeEmptyTexCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
TexSubImageCubeEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1)
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
{
|
|
}
|
|
|
|
TexSubImageCubeEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel data (m_texFormat);
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
// Specify storage for each level.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> ndx);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, DE_NULL);
|
|
}
|
|
|
|
// Specify data using glTexSubImage2D()
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> ndx);
|
|
|
|
data.setSize(levelSize, levelSize);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
{
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax);
|
|
|
|
glTexSubImage2D(s_cubeMapFaces[face], ndx, 0, 0, levelSize, levelSize, m_format, m_dataType, data.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
};
|
|
|
|
// TexSubImage2D() unpack alignment with 2D texture
|
|
class TexSubImage2DAlignCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
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)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, 1)
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
, m_subX (subX)
|
|
, m_subY (subY)
|
|
, m_subW (subW)
|
|
, m_subH (subH)
|
|
, m_alignment (alignment)
|
|
{
|
|
}
|
|
|
|
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)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
, m_subX (subX)
|
|
, m_subY (subY)
|
|
, m_subW (subW)
|
|
, m_subH (subH)
|
|
, m_alignment (alignment)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
vector<deUint8> data;
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
|
|
// Specify base level.
|
|
data.resize(m_texFormat.getPixelSize()*m_width*m_height);
|
|
tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, &data[0]), Vec4(0.0f), Vec4(1.0f));
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, m_format, m_dataType, &data[0]);
|
|
|
|
// Re-specify subrectangle.
|
|
int rowPitch = deAlign32(m_texFormat.getPixelSize()*m_subW, m_alignment);
|
|
data.resize(rowPitch*m_subH);
|
|
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));
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, m_format, m_dataType, &data[0]);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
int m_subX;
|
|
int m_subY;
|
|
int m_subW;
|
|
int m_subH;
|
|
int m_alignment;
|
|
};
|
|
|
|
// TexSubImage2D() unpack alignment with cubemap texture
|
|
class TexSubImageCubeAlignCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
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)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, 1)
|
|
, m_internalFormat (format)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
, m_subX (subX)
|
|
, m_subY (subY)
|
|
, m_subW (subW)
|
|
, m_subH (subH)
|
|
, m_alignment (alignment)
|
|
{
|
|
}
|
|
|
|
TexSubImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int subX, int subY, int subW, int subH, int alignment)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_format (GL_NONE)
|
|
, m_dataType (GL_NONE)
|
|
, m_subX (subX)
|
|
, m_subY (subY)
|
|
, m_subW (subW)
|
|
, m_subH (subH)
|
|
, m_alignment (alignment)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
m_format = fmt.format;
|
|
m_dataType = fmt.dataType;
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
vector<deUint8> data;
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
|
|
// Specify base level.
|
|
data.resize(m_texFormat.getPixelSize()*m_size*m_size);
|
|
tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_size, m_size, 1, &data[0]), Vec4(0.0f), Vec4(1.0f));
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
|
|
glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, m_format, m_dataType, &data[0]);
|
|
|
|
// Re-specify subrectangle.
|
|
int rowPitch = deAlign32(m_texFormat.getPixelSize()*m_subW, m_alignment);
|
|
data.resize(rowPitch*m_subH);
|
|
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));
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
|
|
glTexSubImage2D(s_cubeMapFaces[face], 0, m_subX, m_subY, m_subW, m_subH, m_format, m_dataType, &data[0]);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
int m_subX;
|
|
int m_subY;
|
|
int m_subW;
|
|
int m_subH;
|
|
int m_alignment;
|
|
};
|
|
|
|
// TexSubImage3D() unpack parameters case.
|
|
class TexSubImage3DParamsCase : public Texture3DSpecCase
|
|
{
|
|
public:
|
|
TexSubImage3DParamsCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int width,
|
|
int height,
|
|
int depth,
|
|
int subX,
|
|
int subY,
|
|
int subZ,
|
|
int subW,
|
|
int subH,
|
|
int subD,
|
|
int imageHeight,
|
|
int rowLength,
|
|
int skipImages,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment)
|
|
: Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_subX (subX)
|
|
, m_subY (subY)
|
|
, m_subZ (subZ)
|
|
, m_subW (subW)
|
|
, m_subH (subH)
|
|
, m_subD (subD)
|
|
, m_imageHeight (imageHeight)
|
|
, m_rowLength (rowLength)
|
|
, m_skipImages (skipImages)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
deUint32 tex = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_3D, tex);
|
|
|
|
// Fill with gradient.
|
|
{
|
|
int rowPitch = deAlign32(pixelSize*m_width, 4);
|
|
int slicePitch = rowPitch*m_height;
|
|
|
|
data.resize(slicePitch*m_depth);
|
|
tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
}
|
|
|
|
glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]);
|
|
|
|
// Fill data with grid.
|
|
{
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH;
|
|
int slicePitch = imageHeight*rowPitch;
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
data.resize(slicePitch*(m_depth+m_skipImages));
|
|
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);
|
|
}
|
|
|
|
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
glTexSubImage3D(GL_TEXTURE_3D, 0, m_subX, m_subY, m_subZ, m_subW, m_subH, m_subD, transferFmt.format, transferFmt.dataType, &data[0]);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_subX;
|
|
int m_subY;
|
|
int m_subZ;
|
|
int m_subW;
|
|
int m_subH;
|
|
int m_subD;
|
|
int m_imageHeight;
|
|
int m_rowLength;
|
|
int m_skipImages;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
};
|
|
|
|
// Basic CopyTexImage2D() with 2D texture usage
|
|
class BasicCopyTexImage2DCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
BasicCopyTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(internalFormat, GL_UNSIGNED_BYTE), width, height, maxLevelCount(width, height))
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget();
|
|
bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0;
|
|
bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0;
|
|
tcu::TextureFormat fmt = mapGLUnsizedInternalFormat(m_internalFormat);
|
|
bool texHasRGB = fmt.order != tcu::TextureFormat::A;
|
|
bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A;
|
|
deUint32 tex = 0;
|
|
de::Random rnd (deStringHash(getName()));
|
|
GradientShader shader (glu::TYPE_FLOAT_VEC4);
|
|
deUint32 shaderID = getCurrentContext()->createProgram(&shader);
|
|
|
|
if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
|
|
throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__);
|
|
|
|
// Fill render target with gradient.
|
|
shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f));
|
|
sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
int x = rnd.getInt(0, getWidth() - levelW);
|
|
int y = rnd.getInt(0, getHeight() - levelH);
|
|
|
|
glCopyTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, x, y, levelW, levelH, 0);
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
};
|
|
|
|
// Basic CopyTexImage2D() with cubemap usage
|
|
class BasicCopyTexImageCubeCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
BasicCopyTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(internalFormat, GL_UNSIGNED_BYTE), size, deLog2Floor32(size)+1)
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget();
|
|
bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0;
|
|
bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0;
|
|
tcu::TextureFormat fmt = mapGLUnsizedInternalFormat(m_internalFormat);
|
|
bool texHasRGB = fmt.order != tcu::TextureFormat::A;
|
|
bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A;
|
|
deUint32 tex = 0;
|
|
de::Random rnd (deStringHash(getName()));
|
|
GradientShader shader (glu::TYPE_FLOAT_VEC4);
|
|
deUint32 shaderID = getCurrentContext()->createProgram(&shader);
|
|
|
|
if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
|
|
throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__);
|
|
|
|
// Fill render target with gradient.
|
|
shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f));
|
|
sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> ndx);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
{
|
|
int x = rnd.getInt(0, getWidth() - levelSize);
|
|
int y = rnd.getInt(0, getHeight() - levelSize);
|
|
|
|
glCopyTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, x, y, levelSize, levelSize, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
};
|
|
|
|
// Basic CopyTexSubImage2D() with 2D texture usage
|
|
class BasicCopyTexSubImage2DCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
BasicCopyTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height))
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget();
|
|
bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0;
|
|
bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0;
|
|
tcu::TextureFormat fmt = glu::mapGLTransferFormat(m_format, m_dataType);
|
|
bool texHasRGB = fmt.order != tcu::TextureFormat::A;
|
|
bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A;
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel data (fmt);
|
|
de::Random rnd (deStringHash(getName()));
|
|
GradientShader shader (glu::TYPE_FLOAT_VEC4);
|
|
deUint32 shaderID = getCurrentContext()->createProgram(&shader);
|
|
|
|
if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
|
|
throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
// First specify full texture.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
|
|
Vec4 colorA = randomVector<4>(rnd);
|
|
Vec4 colorB = randomVector<4>(rnd);
|
|
int cellSize = rnd.getInt(2, 16);
|
|
|
|
data.setSize(levelW, levelH);
|
|
tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, ndx, m_format, levelW, levelH, 0, m_format, m_dataType, data.getAccess().getDataPtr());
|
|
}
|
|
|
|
// Fill render target with gradient.
|
|
shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f));
|
|
sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f));
|
|
|
|
// Re-specify parts of each level.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
|
|
int w = rnd.getInt(1, levelW);
|
|
int h = rnd.getInt(1, levelH);
|
|
int xo = rnd.getInt(0, levelW-w);
|
|
int yo = rnd.getInt(0, levelH-h);
|
|
|
|
int x = rnd.getInt(0, getWidth() - w);
|
|
int y = rnd.getInt(0, getHeight() - h);
|
|
|
|
glCopyTexSubImage2D(GL_TEXTURE_2D, ndx, xo, yo, x, y, w, h);
|
|
}
|
|
}
|
|
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
};
|
|
|
|
// Basic CopyTexSubImage2D() with cubemap usage
|
|
class BasicCopyTexSubImageCubeCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
BasicCopyTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1)
|
|
, m_format (format)
|
|
, m_dataType (dataType)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget();
|
|
bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0;
|
|
bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0;
|
|
tcu::TextureFormat fmt = glu::mapGLTransferFormat(m_format, m_dataType);
|
|
bool texHasRGB = fmt.order != tcu::TextureFormat::A;
|
|
bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A;
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel data (fmt);
|
|
de::Random rnd (deStringHash(getName()));
|
|
GradientShader shader (glu::TYPE_FLOAT_VEC4);
|
|
deUint32 shaderID = getCurrentContext()->createProgram(&shader);
|
|
|
|
if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
|
|
throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> ndx);
|
|
|
|
data.setSize(levelSize, levelSize);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
{
|
|
Vec4 colorA = randomVector<4>(rnd);
|
|
Vec4 colorB = randomVector<4>(rnd);
|
|
int cellSize = rnd.getInt(2, 16);
|
|
|
|
tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB);
|
|
glTexImage2D(s_cubeMapFaces[face], ndx, m_format, levelSize, levelSize, 0, m_format, m_dataType, data.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
// Fill render target with gradient.
|
|
shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f));
|
|
sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f));
|
|
|
|
// Re-specify parts of each face and level.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> ndx);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
{
|
|
int w = rnd.getInt(1, levelSize);
|
|
int h = rnd.getInt(1, levelSize);
|
|
int xo = rnd.getInt(0, levelSize-w);
|
|
int yo = rnd.getInt(0, levelSize-h);
|
|
|
|
int x = rnd.getInt(0, getWidth() - w);
|
|
int y = rnd.getInt(0, getHeight() - h);
|
|
|
|
glCopyTexSubImage2D(s_cubeMapFaces[face], ndx, xo, yo, x, y, w, h);
|
|
}
|
|
}
|
|
}
|
|
|
|
deUint32 m_format;
|
|
deUint32 m_dataType;
|
|
};
|
|
|
|
// Basic glTexStorage2D() with 2D texture usage
|
|
class BasicTexStorage2DCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
BasicTexStorage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLevels)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLevels)
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
tcu::TextureFormat fmt = glu::mapGLInternalFormat(m_internalFormat);
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(fmt);
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glTexStorage2D(GL_TEXTURE_2D, m_numLevels, m_internalFormat, m_width, m_height);
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
levelData.setSize(levelW, levelH);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexSubImage2D(GL_TEXTURE_2D, ndx, 0, 0, levelW, levelH, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
};
|
|
|
|
// Basic glTexStorage2D() with cubemap usage
|
|
class BasicTexStorageCubeCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
BasicTexStorageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int numLevels)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, numLevels)
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
tcu::TextureFormat fmt = glu::mapGLInternalFormat(m_internalFormat);
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(fmt);
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
glTexStorage2D(GL_TEXTURE_CUBE_MAP, m_numLevels, m_internalFormat, m_size, m_size);
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelSize = de::max(1, m_size >> ndx);
|
|
|
|
levelData.setSize(levelSize, levelSize);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
{
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexSubImage2D(s_cubeMapFaces[face], ndx, 0, 0, levelSize, levelSize, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
};
|
|
|
|
// Basic glTexStorage3D() with 2D array texture usage
|
|
class BasicTexStorage2DArrayCase : public Texture2DArraySpecCase
|
|
{
|
|
public:
|
|
BasicTexStorage2DArrayCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLayers, int numLevels)
|
|
: Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLayers, numLevels)
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
de::Random rnd (deStringHash(getName()));
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
|
|
|
|
glGenTextures (1, &tex);
|
|
glBindTexture (GL_TEXTURE_2D_ARRAY, tex);
|
|
glTexStorage3D (GL_TEXTURE_2D_ARRAY, m_numLevels, m_internalFormat, m_width, m_height, m_numLayers);
|
|
|
|
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
levelData.setSize(levelW, levelH, m_numLayers);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexSubImage3D(GL_TEXTURE_2D_ARRAY, ndx, 0, 0, 0, levelW, levelH, m_numLayers, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
};
|
|
|
|
// Basic TexStorage3D() with 3D texture usage
|
|
class BasicTexStorage3DCase : public Texture3DSpecCase
|
|
{
|
|
public:
|
|
BasicTexStorage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth, int numLevels)
|
|
: Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, numLevels)
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
deUint32 tex = 0;
|
|
de::Random rnd (deStringHash(getName()));
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType));
|
|
|
|
glGenTextures (1, &tex);
|
|
glBindTexture (GL_TEXTURE_3D, tex);
|
|
glTexStorage3D (GL_TEXTURE_3D, m_numLevels, m_internalFormat, m_width, m_height, m_depth);
|
|
|
|
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
int levelW = de::max(1, m_width >> ndx);
|
|
int levelH = de::max(1, m_height >> ndx);
|
|
int levelD = de::max(1, m_depth >> ndx);
|
|
Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
levelData.setSize(levelW, levelH, levelD);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexSubImage3D(GL_TEXTURE_3D, ndx, 0, 0, 0, levelW, levelH, levelD, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
};
|
|
|
|
// Pixel buffer object cases.
|
|
|
|
// TexImage2D() from pixel buffer object.
|
|
class TexImage2DBufferCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
TexImage2DBufferCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int width,
|
|
int height,
|
|
int rowLength,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment,
|
|
int offset)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_rowLength (rowLength)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
, m_offset (offset)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_width + m_skipPixels;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
int height = m_height + m_skipRows;
|
|
deUint32 buf = 0;
|
|
deUint32 tex = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
// Fill data with grid.
|
|
data.resize(rowPitch*height + m_offset);
|
|
{
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
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);
|
|
}
|
|
|
|
// Create buffer and upload.
|
|
glGenBuffers(1, &buf);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_rowLength;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
int m_offset;
|
|
};
|
|
|
|
// TexImage2D() cubemap from pixel buffer object case
|
|
class TexImageCubeBufferCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
TexImageCubeBufferCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int size,
|
|
int rowLength,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment,
|
|
int offset)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_rowLength (rowLength)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
, m_offset (offset)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
de::Random rnd (deStringHash(getName()));
|
|
deUint32 tex = 0;
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
const int pixelSize = m_texFormat.getPixelSize();
|
|
const int rowLength = m_rowLength > 0 ? m_rowLength : m_size + m_skipPixels;
|
|
const int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
const int height = m_size + m_skipRows;
|
|
vector<vector<deUint8> > data (DE_LENGTH_OF_ARRAY(s_cubeMapFaces));
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
{
|
|
deUint32 buf = 0;
|
|
|
|
{
|
|
const Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
const Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
data[face].resize(rowPitch*height + m_offset);
|
|
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);
|
|
}
|
|
|
|
// Create buffer and upload.
|
|
glGenBuffers(1, &buf);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data[face].size(), &data[face][0], GL_STATIC_DRAW);
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
|
|
glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, fmt.format, fmt.dataType, (const void*)(deUintptr)m_offset);
|
|
}
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_rowLength;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
int m_offset;
|
|
};
|
|
|
|
// TexImage3D() 2D array from pixel buffer object.
|
|
class TexImage2DArrayBufferCase : public Texture2DArraySpecCase
|
|
{
|
|
public:
|
|
TexImage2DArrayBufferCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int width,
|
|
int height,
|
|
int depth,
|
|
int imageHeight,
|
|
int rowLength,
|
|
int skipImages,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment,
|
|
int offset)
|
|
: Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_imageHeight (imageHeight)
|
|
, m_rowLength (rowLength)
|
|
, m_skipImages (skipImages)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
, m_offset (offset)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_width;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height;
|
|
int slicePitch = imageHeight*rowPitch;
|
|
deUint32 tex = 0;
|
|
deUint32 buf = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
// Fill data with grid.
|
|
data.resize(slicePitch*(m_numLayers+m_skipImages) + m_offset);
|
|
{
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
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);
|
|
}
|
|
|
|
glGenBuffers(1, &buf);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
|
|
|
|
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
|
|
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_imageHeight;
|
|
int m_rowLength;
|
|
int m_skipImages;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
int m_offset;
|
|
};
|
|
|
|
// TexImage3D() from pixel buffer object.
|
|
class TexImage3DBufferCase : public Texture3DSpecCase
|
|
{
|
|
public:
|
|
TexImage3DBufferCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int width,
|
|
int height,
|
|
int depth,
|
|
int imageHeight,
|
|
int rowLength,
|
|
int skipImages,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment,
|
|
int offset)
|
|
: Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_imageHeight (imageHeight)
|
|
, m_rowLength (rowLength)
|
|
, m_skipImages (skipImages)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
, m_offset (offset)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_width;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height;
|
|
int slicePitch = imageHeight*rowPitch;
|
|
deUint32 tex = 0;
|
|
deUint32 buf = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
// Fill data with grid.
|
|
data.resize(slicePitch*(m_depth+m_skipImages) + m_offset);
|
|
{
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
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);
|
|
}
|
|
|
|
glGenBuffers(1, &buf);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
|
|
|
|
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_3D, tex);
|
|
glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_imageHeight;
|
|
int m_rowLength;
|
|
int m_skipImages;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
int m_offset;
|
|
};
|
|
|
|
// TexSubImage2D() PBO case.
|
|
class TexSubImage2DBufferCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
TexSubImage2DBufferCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int width,
|
|
int height,
|
|
int subX,
|
|
int subY,
|
|
int subW,
|
|
int subH,
|
|
int rowLength,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment,
|
|
int offset)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_subX (subX)
|
|
, m_subY (subY)
|
|
, m_subW (subW)
|
|
, m_subH (subH)
|
|
, m_rowLength (rowLength)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
, m_offset (offset)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
deUint32 tex = 0;
|
|
deUint32 buf = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
|
|
// First fill texture with gradient.
|
|
data.resize(deAlign32(m_width*pixelSize, 4)*m_height);
|
|
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);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]);
|
|
|
|
// Fill data with grid.
|
|
{
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
int height = m_subH + m_skipRows;
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
data.resize(rowPitch*height + m_offset);
|
|
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);
|
|
}
|
|
|
|
glGenBuffers(1, &buf);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_subX;
|
|
int m_subY;
|
|
int m_subW;
|
|
int m_subH;
|
|
int m_rowLength;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
int m_offset;
|
|
};
|
|
|
|
// TexSubImage2D() cubemap PBO case.
|
|
class TexSubImageCubeBufferCase : public TextureCubeSpecCase
|
|
{
|
|
public:
|
|
TexSubImageCubeBufferCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int size,
|
|
int subX,
|
|
int subY,
|
|
int subW,
|
|
int subH,
|
|
int rowLength,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment,
|
|
int offset)
|
|
: TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_subX (subX)
|
|
, m_subY (subY)
|
|
, m_subW (subW)
|
|
, m_subH (subH)
|
|
, m_rowLength (rowLength)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
, m_offset (offset)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
de::Random rnd (deStringHash(getName()));
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
deUint32 tex = 0;
|
|
deUint32 buf = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
|
|
|
|
// Fill faces with different gradients.
|
|
|
|
data.resize(deAlign32(m_size*pixelSize, 4)*m_size);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++)
|
|
{
|
|
const Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
const Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
|
|
tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_size, m_size, 1, deAlign32(m_size*pixelSize, 4), 0, &data[0]), gMin, gMax);
|
|
|
|
glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, transferFmt.format, transferFmt.dataType, &data[0]);
|
|
}
|
|
|
|
// Fill data with grid.
|
|
{
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
int height = m_subH + m_skipRows;
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
data.resize(rowPitch*height + m_offset);
|
|
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);
|
|
}
|
|
|
|
glGenBuffers(1, &buf);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
|
|
for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
|
|
glTexSubImage2D(s_cubeMapFaces[face], 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_subX;
|
|
int m_subY;
|
|
int m_subW;
|
|
int m_subH;
|
|
int m_rowLength;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
int m_offset;
|
|
};
|
|
|
|
// TexSubImage3D() 2D array PBO case.
|
|
class TexSubImage2DArrayBufferCase : public Texture2DArraySpecCase
|
|
{
|
|
public:
|
|
TexSubImage2DArrayBufferCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int width,
|
|
int height,
|
|
int depth,
|
|
int subX,
|
|
int subY,
|
|
int subZ,
|
|
int subW,
|
|
int subH,
|
|
int subD,
|
|
int imageHeight,
|
|
int rowLength,
|
|
int skipImages,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment,
|
|
int offset)
|
|
: Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_subX (subX)
|
|
, m_subY (subY)
|
|
, m_subZ (subZ)
|
|
, m_subW (subW)
|
|
, m_subH (subH)
|
|
, m_subD (subD)
|
|
, m_imageHeight (imageHeight)
|
|
, m_rowLength (rowLength)
|
|
, m_skipImages (skipImages)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
, m_offset (offset)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
deUint32 tex = 0;
|
|
deUint32 buf = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
|
|
|
|
// Fill with gradient.
|
|
{
|
|
int rowPitch = deAlign32(pixelSize*m_width, 4);
|
|
int slicePitch = rowPitch*m_height;
|
|
|
|
data.resize(slicePitch*m_numLayers);
|
|
tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_numLayers, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
}
|
|
|
|
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, &data[0]);
|
|
|
|
// Fill data with grid.
|
|
{
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH;
|
|
int slicePitch = imageHeight*rowPitch;
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
data.resize(slicePitch*(m_numLayers+m_skipImages) + m_offset);
|
|
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);
|
|
}
|
|
|
|
glGenBuffers(1, &buf);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
|
|
|
|
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
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);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_subX;
|
|
int m_subY;
|
|
int m_subZ;
|
|
int m_subW;
|
|
int m_subH;
|
|
int m_subD;
|
|
int m_imageHeight;
|
|
int m_rowLength;
|
|
int m_skipImages;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
int m_offset;
|
|
};
|
|
|
|
// TexSubImage3D() PBO case.
|
|
class TexSubImage3DBufferCase : public Texture3DSpecCase
|
|
{
|
|
public:
|
|
TexSubImage3DBufferCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int width,
|
|
int height,
|
|
int depth,
|
|
int subX,
|
|
int subY,
|
|
int subZ,
|
|
int subW,
|
|
int subH,
|
|
int subD,
|
|
int imageHeight,
|
|
int rowLength,
|
|
int skipImages,
|
|
int skipRows,
|
|
int skipPixels,
|
|
int alignment,
|
|
int offset)
|
|
: Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1)
|
|
, m_internalFormat (internalFormat)
|
|
, m_subX (subX)
|
|
, m_subY (subY)
|
|
, m_subZ (subZ)
|
|
, m_subW (subW)
|
|
, m_subH (subH)
|
|
, m_subD (subD)
|
|
, m_imageHeight (imageHeight)
|
|
, m_rowLength (rowLength)
|
|
, m_skipImages (skipImages)
|
|
, m_skipRows (skipRows)
|
|
, m_skipPixels (skipPixels)
|
|
, m_alignment (alignment)
|
|
, m_offset (offset)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
deUint32 tex = 0;
|
|
deUint32 buf = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_3D, tex);
|
|
|
|
// Fill with gradient.
|
|
{
|
|
int rowPitch = deAlign32(pixelSize*m_width, 4);
|
|
int slicePitch = rowPitch*m_height;
|
|
|
|
data.resize(slicePitch*m_depth);
|
|
tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax);
|
|
}
|
|
|
|
glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]);
|
|
|
|
// Fill data with grid.
|
|
{
|
|
int rowLength = m_rowLength > 0 ? m_rowLength : m_subW;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, m_alignment);
|
|
int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH;
|
|
int slicePitch = imageHeight*rowPitch;
|
|
Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin;
|
|
Vec4 cBias = m_texFormatInfo.valueMin;
|
|
Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias;
|
|
|
|
data.resize(slicePitch*(m_depth+m_skipImages) + m_offset);
|
|
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);
|
|
}
|
|
|
|
glGenBuffers(1, &buf);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
|
|
|
|
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment);
|
|
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);
|
|
}
|
|
|
|
deUint32 m_internalFormat;
|
|
int m_subX;
|
|
int m_subY;
|
|
int m_subZ;
|
|
int m_subW;
|
|
int m_subH;
|
|
int m_subD;
|
|
int m_imageHeight;
|
|
int m_rowLength;
|
|
int m_skipImages;
|
|
int m_skipRows;
|
|
int m_skipPixels;
|
|
int m_alignment;
|
|
int m_offset;
|
|
};
|
|
|
|
// TexImage2D() depth case.
|
|
class TexImage2DDepthCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
TexImage2DDepthCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int imageWidth,
|
|
int imageHeight)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, maxLevelCount(imageWidth, imageHeight))
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
// we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
|
|
m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
|
|
m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
|
|
}
|
|
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
GLU_CHECK();
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
const int levelW = de::max(1, m_width >> ndx);
|
|
const int levelH = de::max(1, m_height >> ndx);
|
|
const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
|
|
const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
|
|
|
|
levelData.setSize(levelW, levelH);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
const deUint32 m_internalFormat;
|
|
};
|
|
|
|
// TexImage3D() depth case.
|
|
class TexImage2DArrayDepthCase : public Texture2DArraySpecCase
|
|
{
|
|
public:
|
|
TexImage2DArrayDepthCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int imageWidth,
|
|
int imageHeight,
|
|
int numLayers)
|
|
: Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, maxLevelCount(imageWidth, imageHeight))
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
// we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
|
|
m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
|
|
m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
|
|
}
|
|
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
GLU_CHECK();
|
|
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
const int levelW = de::max(1, m_width >> ndx);
|
|
const int levelH = de::max(1, m_height >> ndx);
|
|
const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
|
|
const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
|
|
|
|
levelData.setSize(levelW, levelH, m_numLayers);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
const deUint32 m_internalFormat;
|
|
};
|
|
|
|
// TexSubImage2D() depth case.
|
|
class TexSubImage2DDepthCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
TexSubImage2DDepthCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int imageWidth,
|
|
int imageHeight)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, maxLevelCount(imageWidth, imageHeight))
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
// we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
|
|
m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
|
|
m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
|
|
}
|
|
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
de::Random rnd (deStringHash(getName()));
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
GLU_CHECK();
|
|
|
|
// First specify full texture.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
const int levelW = de::max(1, m_width >> ndx);
|
|
const int levelH = de::max(1, m_height >> ndx);
|
|
const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
|
|
const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
|
|
|
|
levelData.setSize(levelW, levelH);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
|
|
// Re-specify parts of each level.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
const int levelW = de::max(1, m_width >> ndx);
|
|
const int levelH = de::max(1, m_height >> ndx);
|
|
|
|
const int w = rnd.getInt(1, levelW);
|
|
const int h = rnd.getInt(1, levelH);
|
|
const int x = rnd.getInt(0, levelW-w);
|
|
const int y = rnd.getInt(0, levelH-h);
|
|
|
|
const Vec4 colorA = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
|
|
const Vec4 colorB = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
|
|
const int cellSize = rnd.getInt(2, 16);
|
|
|
|
levelData.setSize(w, h);
|
|
tcu::fillWithGrid(levelData.getAccess(), cellSize, colorA, colorB);
|
|
|
|
glTexSubImage2D(GL_TEXTURE_2D, ndx, x, y, w, h, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
const deUint32 m_internalFormat;
|
|
};
|
|
|
|
// TexSubImage3D() depth case.
|
|
class TexSubImage2DArrayDepthCase : public Texture2DArraySpecCase
|
|
{
|
|
public:
|
|
TexSubImage2DArrayDepthCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int imageWidth,
|
|
int imageHeight,
|
|
int numLayers)
|
|
: Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, maxLevelCount(imageWidth, imageHeight))
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
// we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
|
|
m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
|
|
m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
|
|
}
|
|
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat);
|
|
de::Random rnd (deStringHash(getName()));
|
|
deUint32 tex = 0;
|
|
tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType));
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
GLU_CHECK();
|
|
|
|
// First specify full texture.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
const int levelW = de::max(1, m_width >> ndx);
|
|
const int levelH = de::max(1, m_height >> ndx);
|
|
const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
|
|
const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
|
|
|
|
levelData.setSize(levelW, levelH, m_numLayers);
|
|
tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax);
|
|
|
|
glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
|
|
// Re-specify parts of each level.
|
|
for (int ndx = 0; ndx < m_numLevels; ndx++)
|
|
{
|
|
const int levelW = de::max(1, m_width >> ndx);
|
|
const int levelH = de::max(1, m_height >> ndx);
|
|
|
|
const int w = rnd.getInt(1, levelW);
|
|
const int h = rnd.getInt(1, levelH);
|
|
const int d = rnd.getInt(1, m_numLayers);
|
|
const int x = rnd.getInt(0, levelW-w);
|
|
const int y = rnd.getInt(0, levelH-h);
|
|
const int z = rnd.getInt(0, m_numLayers-d);
|
|
|
|
const Vec4 colorA = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
|
|
const Vec4 colorB = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
|
|
const int cellSize = rnd.getInt(2, 16);
|
|
|
|
levelData.setSize(w, h, d);
|
|
tcu::fillWithGrid(levelData.getAccess(), cellSize, colorA, colorB);
|
|
|
|
glTexSubImage3D(GL_TEXTURE_2D_ARRAY, ndx, x, y, z, w, h, d, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr());
|
|
}
|
|
}
|
|
|
|
const deUint32 m_internalFormat;
|
|
};
|
|
|
|
// TexImage2D() depth case with pbo.
|
|
class TexImage2DDepthBufferCase : public Texture2DSpecCase
|
|
{
|
|
public:
|
|
TexImage2DDepthBufferCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int imageWidth,
|
|
int imageHeight)
|
|
: Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, 1)
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
// we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
|
|
m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
|
|
m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
|
|
}
|
|
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
int rowLength = m_width;
|
|
int alignment = 4;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, alignment);
|
|
int height = m_height;
|
|
deUint32 buf = 0;
|
|
deUint32 tex = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
// Fill data with gradient
|
|
data.resize(rowPitch*height);
|
|
{
|
|
const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
|
|
const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
|
|
|
|
tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, rowPitch, 0, &data[0]), gMin, gMax);
|
|
}
|
|
|
|
// Create buffer and upload.
|
|
glGenBuffers(1, &buf);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, DE_NULL);
|
|
glDeleteBuffers(1, &buf);
|
|
}
|
|
|
|
const deUint32 m_internalFormat;
|
|
};
|
|
|
|
// TexImage3D() depth case with pbo.
|
|
class TexImage2DArrayDepthBufferCase : public Texture2DArraySpecCase
|
|
{
|
|
public:
|
|
TexImage2DArrayDepthBufferCase (Context& context,
|
|
const char* name,
|
|
const char* desc,
|
|
deUint32 internalFormat,
|
|
int imageWidth,
|
|
int imageHeight,
|
|
int numLayers)
|
|
: Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, 1)
|
|
, m_internalFormat (internalFormat)
|
|
{
|
|
// we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
|
|
m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f);
|
|
m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f);
|
|
}
|
|
|
|
void createTexture (void)
|
|
{
|
|
glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat);
|
|
int pixelSize = m_texFormat.getPixelSize();
|
|
int rowLength = m_width;
|
|
int alignment = 4;
|
|
int rowPitch = deAlign32(rowLength*pixelSize, alignment);
|
|
int imageHeight = m_height;
|
|
int slicePitch = imageHeight*rowPitch;
|
|
deUint32 tex = 0;
|
|
deUint32 buf = 0;
|
|
vector<deUint8> data;
|
|
|
|
DE_ASSERT(m_numLevels == 1);
|
|
|
|
// Fill data with grid.
|
|
data.resize(slicePitch*m_numLayers);
|
|
{
|
|
const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f);
|
|
const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f);
|
|
|
|
tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_numLayers, rowPitch, slicePitch, &data[0]), gMin, gMax);
|
|
}
|
|
|
|
glGenBuffers(1, &buf);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW);
|
|
|
|
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, imageHeight);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowLength);
|
|
glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
|
|
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
|
|
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
|
|
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, DE_NULL);
|
|
glDeleteBuffers(1, &buf);
|
|
}
|
|
|
|
const deUint32 m_internalFormat;
|
|
};
|
|
|
|
TextureSpecificationTests::TextureSpecificationTests (Context& context)
|
|
: TestCaseGroup(context, "specification", "Texture Specification Tests")
|
|
{
|
|
}
|
|
|
|
TextureSpecificationTests::~TextureSpecificationTests (void)
|
|
{
|
|
}
|
|
|
|
void TextureSpecificationTests::init (void)
|
|
{
|
|
struct
|
|
{
|
|
const char* name;
|
|
deUint32 format;
|
|
deUint32 dataType;
|
|
} unsizedFormats[] =
|
|
{
|
|
{ "alpha_unsigned_byte", GL_ALPHA, GL_UNSIGNED_BYTE },
|
|
{ "luminance_unsigned_byte", GL_LUMINANCE, GL_UNSIGNED_BYTE },
|
|
{ "luminance_alpha_unsigned_byte", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE },
|
|
{ "rgb_unsigned_short_5_6_5", GL_RGB, GL_UNSIGNED_SHORT_5_6_5 },
|
|
{ "rgb_unsigned_byte", GL_RGB, GL_UNSIGNED_BYTE },
|
|
{ "rgba_unsigned_short_4_4_4_4", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 },
|
|
{ "rgba_unsigned_short_5_5_5_1", GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 },
|
|
{ "rgba_unsigned_byte", GL_RGBA, GL_UNSIGNED_BYTE }
|
|
};
|
|
|
|
struct
|
|
{
|
|
const char* name;
|
|
deUint32 internalFormat;
|
|
} colorFormats[] =
|
|
{
|
|
{ "rgba32f", GL_RGBA32F, },
|
|
{ "rgba32i", GL_RGBA32I, },
|
|
{ "rgba32ui", GL_RGBA32UI, },
|
|
{ "rgba16f", GL_RGBA16F, },
|
|
{ "rgba16i", GL_RGBA16I, },
|
|
{ "rgba16ui", GL_RGBA16UI, },
|
|
{ "rgba8", GL_RGBA8, },
|
|
{ "rgba8i", GL_RGBA8I, },
|
|
{ "rgba8ui", GL_RGBA8UI, },
|
|
{ "srgb8_alpha8", GL_SRGB8_ALPHA8, },
|
|
{ "rgb10_a2", GL_RGB10_A2, },
|
|
{ "rgb10_a2ui", GL_RGB10_A2UI, },
|
|
{ "rgba4", GL_RGBA4, },
|
|
{ "rgb5_a1", GL_RGB5_A1, },
|
|
{ "rgba8_snorm", GL_RGBA8_SNORM, },
|
|
{ "rgb8", GL_RGB8, },
|
|
{ "rgb565", GL_RGB565, },
|
|
{ "r11f_g11f_b10f", GL_R11F_G11F_B10F, },
|
|
{ "rgb32f", GL_RGB32F, },
|
|
{ "rgb32i", GL_RGB32I, },
|
|
{ "rgb32ui", GL_RGB32UI, },
|
|
{ "rgb16f", GL_RGB16F, },
|
|
{ "rgb16i", GL_RGB16I, },
|
|
{ "rgb16ui", GL_RGB16UI, },
|
|
{ "rgb8_snorm", GL_RGB8_SNORM, },
|
|
{ "rgb8i", GL_RGB8I, },
|
|
{ "rgb8ui", GL_RGB8UI, },
|
|
{ "srgb8", GL_SRGB8, },
|
|
{ "rgb9_e5", GL_RGB9_E5, },
|
|
{ "rg32f", GL_RG32F, },
|
|
{ "rg32i", GL_RG32I, },
|
|
{ "rg32ui", GL_RG32UI, },
|
|
{ "rg16f", GL_RG16F, },
|
|
{ "rg16i", GL_RG16I, },
|
|
{ "rg16ui", GL_RG16UI, },
|
|
{ "rg8", GL_RG8, },
|
|
{ "rg8i", GL_RG8I, },
|
|
{ "rg8ui", GL_RG8UI, },
|
|
{ "rg8_snorm", GL_RG8_SNORM, },
|
|
{ "r32f", GL_R32F, },
|
|
{ "r32i", GL_R32I, },
|
|
{ "r32ui", GL_R32UI, },
|
|
{ "r16f", GL_R16F, },
|
|
{ "r16i", GL_R16I, },
|
|
{ "r16ui", GL_R16UI, },
|
|
{ "r8", GL_R8, },
|
|
{ "r8i", GL_R8I, },
|
|
{ "r8ui", GL_R8UI, },
|
|
{ "r8_snorm", GL_R8_SNORM, }
|
|
};
|
|
|
|
static const struct
|
|
{
|
|
const char* name;
|
|
deUint32 internalFormat;
|
|
} depthStencilFormats[] =
|
|
{
|
|
// Depth and stencil formats
|
|
{ "depth_component32f", GL_DEPTH_COMPONENT32F },
|
|
{ "depth_component24", GL_DEPTH_COMPONENT24 },
|
|
{ "depth_component16", GL_DEPTH_COMPONENT16 },
|
|
{ "depth32f_stencil8", GL_DEPTH32F_STENCIL8 },
|
|
{ "depth24_stencil8", GL_DEPTH24_STENCIL8 }
|
|
};
|
|
|
|
// Basic TexImage2D usage.
|
|
{
|
|
tcu::TestCaseGroup* basicTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_teximage2d", "Basic glTexImage2D() usage");
|
|
addChild(basicTexImageGroup);
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
|
|
{
|
|
const char* fmtName = colorFormats[formatNdx].name;
|
|
deUint32 format = colorFormats[formatNdx].internalFormat;
|
|
const int tex2DWidth = 64;
|
|
const int tex2DHeight = 128;
|
|
const int texCubeSize = 64;
|
|
|
|
basicTexImageGroup->addChild(new BasicTexImage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight));
|
|
basicTexImageGroup->addChild(new BasicTexImageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, texCubeSize));
|
|
}
|
|
}
|
|
|
|
// Randomized TexImage2D order.
|
|
{
|
|
tcu::TestCaseGroup* randomTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "random_teximage2d", "Randomized glTexImage2D() usage");
|
|
addChild(randomTexImageGroup);
|
|
|
|
de::Random rnd(9);
|
|
|
|
// 2D cases.
|
|
for (int ndx = 0; ndx < 10; ndx++)
|
|
{
|
|
int formatNdx = rnd.getInt(0, DE_LENGTH_OF_ARRAY(colorFormats)-1);
|
|
int width = 1 << rnd.getInt(2, 8);
|
|
int height = 1 << rnd.getInt(2, 8);
|
|
|
|
randomTexImageGroup->addChild(new RandomOrderTexImage2DCase(m_context, (string("2d_") + de::toString(ndx)).c_str(), "", colorFormats[formatNdx].internalFormat, width, height));
|
|
}
|
|
|
|
// Cubemap cases.
|
|
for (int ndx = 0; ndx < 10; ndx++)
|
|
{
|
|
int formatNdx = rnd.getInt(0, DE_LENGTH_OF_ARRAY(colorFormats)-1);
|
|
int size = 1 << rnd.getInt(2, 8);
|
|
|
|
randomTexImageGroup->addChild(new RandomOrderTexImageCubeCase(m_context, (string("cube_") + de::toString(ndx)).c_str(), "", colorFormats[formatNdx].internalFormat, size));
|
|
}
|
|
}
|
|
|
|
// TexImage2D unpack alignment.
|
|
{
|
|
tcu::TestCaseGroup* alignGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_align", "glTexImage2D() unpack alignment tests");
|
|
addChild(alignGroup);
|
|
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_4_8", "", GL_R8, 4, 8, 4, 8));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_1", "", GL_R8, 63, 30, 1, 1));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_2", "", GL_R8, 63, 30, 1, 2));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_4", "", GL_R8, 63, 30, 1, 4));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_8", "", GL_R8, 63, 30, 1, 8));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_1", "", GL_RGBA4, 51, 30, 1, 1));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_2", "", GL_RGBA4, 51, 30, 1, 2));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_4", "", GL_RGBA4, 51, 30, 1, 4));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_8", "", GL_RGBA4, 51, 30, 1, 8));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_1", "", GL_RGB8, 39, 43, 1, 1));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_2", "", GL_RGB8, 39, 43, 1, 2));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_4", "", GL_RGB8, 39, 43, 1, 4));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_8", "", GL_RGB8, 39, 43, 1, 8));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_1", "", GL_RGBA8, 47, 27, 1, 1));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_2", "", GL_RGBA8, 47, 27, 1, 2));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_4", "", GL_RGBA8, 47, 27, 1, 4));
|
|
alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_8", "", GL_RGBA8, 47, 27, 1, 8));
|
|
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_4_8", "", GL_R8, 4, 3, 8));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_1", "", GL_R8, 63, 1, 1));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_2", "", GL_R8, 63, 1, 2));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_4", "", GL_R8, 63, 1, 4));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_8", "", GL_R8, 63, 1, 8));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_1", "", GL_RGBA4, 51, 1, 1));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_2", "", GL_RGBA4, 51, 1, 2));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_4", "", GL_RGBA4, 51, 1, 4));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_8", "", GL_RGBA4, 51, 1, 8));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_1", "", GL_RGB8, 39, 1, 1));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_2", "", GL_RGB8, 39, 1, 2));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_4", "", GL_RGB8, 39, 1, 4));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_8", "", GL_RGB8, 39, 1, 8));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_1", "", GL_RGBA8, 47, 1, 1));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_2", "", GL_RGBA8, 47, 1, 2));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_4", "", GL_RGBA8, 47, 1, 4));
|
|
alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_8", "", GL_RGBA8, 47, 1, 8));
|
|
}
|
|
|
|
// glTexImage2D() unpack parameter cases.
|
|
{
|
|
tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_unpack_params", "glTexImage2D() pixel transfer mode cases");
|
|
addChild(paramGroup);
|
|
|
|
static const struct
|
|
{
|
|
const char* name;
|
|
deUint32 format;
|
|
int width;
|
|
int height;
|
|
int rowLength;
|
|
int skipRows;
|
|
int skipPixels;
|
|
int alignment;
|
|
} cases[] =
|
|
{
|
|
{ "rgb8_alignment", GL_RGB8, 31, 30, 0, 0, 0, 2 },
|
|
{ "rgb8_row_length", GL_RGB8, 31, 30, 50, 0, 0, 4 },
|
|
{ "rgb8_skip_rows", GL_RGB8, 31, 30, 0, 3, 0, 4 },
|
|
{ "rgb8_skip_pixels", GL_RGB8, 31, 30, 36, 0, 5, 4 },
|
|
{ "r8_complex1", GL_R8, 31, 30, 64, 1, 3, 1 },
|
|
{ "r8_complex2", GL_R8, 31, 30, 64, 1, 3, 2 },
|
|
{ "r8_complex3", GL_R8, 31, 30, 64, 1, 3, 4 },
|
|
{ "r8_complex4", GL_R8, 31, 30, 64, 1, 3, 8 },
|
|
{ "rgba8_complex1", GL_RGBA8, 56, 61, 69, 0, 0, 8 },
|
|
{ "rgba8_complex2", GL_RGBA8, 56, 61, 69, 0, 7, 8 },
|
|
{ "rgba8_complex3", GL_RGBA8, 56, 61, 69, 3, 0, 8 },
|
|
{ "rgba8_complex4", GL_RGBA8, 56, 61, 69, 3, 7, 8 },
|
|
{ "rgba32f_complex", GL_RGBA32F, 19, 10, 27, 1, 7, 8 }
|
|
};
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++)
|
|
paramGroup->addChild(new TexImage2DParamsCase(m_context, cases[ndx].name, "",
|
|
cases[ndx].format,
|
|
cases[ndx].width,
|
|
cases[ndx].height,
|
|
cases[ndx].rowLength,
|
|
cases[ndx].skipRows,
|
|
cases[ndx].skipPixels,
|
|
cases[ndx].alignment));
|
|
}
|
|
|
|
// glTexImage2D() pbo cases.
|
|
{
|
|
tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_pbo", "glTexImage2D() from PBO");
|
|
addChild(pboGroup);
|
|
|
|
// Parameter cases
|
|
static const struct
|
|
{
|
|
const char* name;
|
|
deUint32 format;
|
|
int width;
|
|
int height;
|
|
int rowLength;
|
|
int skipRows;
|
|
int skipPixels;
|
|
int alignment;
|
|
int offset;
|
|
} parameterCases[] =
|
|
{
|
|
{ "rgb8_offset", GL_RGB8, 31, 30, 0, 0, 0, 4, 67 },
|
|
{ "rgb8_alignment", GL_RGB8, 31, 30, 0, 0, 0, 2, 0 },
|
|
{ "rgb8_row_length", GL_RGB8, 31, 30, 50, 0, 0, 4, 0 },
|
|
{ "rgb8_skip_rows", GL_RGB8, 31, 30, 0, 3, 0, 4, 0 },
|
|
{ "rgb8_skip_pixels", GL_RGB8, 31, 30, 36, 0, 5, 4, 0 }
|
|
};
|
|
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
|
|
{
|
|
const string fmtName = colorFormats[formatNdx].name;
|
|
const deUint32 format = colorFormats[formatNdx].internalFormat;
|
|
const int tex2DWidth = 65;
|
|
const int tex2DHeight = 37;
|
|
const int texCubeSize = 64;
|
|
|
|
pboGroup->addChild(new TexImage2DBufferCase (m_context, (fmtName + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight, 0, 0, 0, 4, 0));
|
|
pboGroup->addChild(new TexImageCubeBufferCase (m_context, (fmtName + "_cube").c_str(), "", format, texCubeSize, 0, 0, 0, 4, 0));
|
|
}
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(parameterCases); ndx++)
|
|
{
|
|
pboGroup->addChild(new TexImage2DBufferCase(m_context, (string(parameterCases[ndx].name) + "_2d").c_str(), "",
|
|
parameterCases[ndx].format,
|
|
parameterCases[ndx].width,
|
|
parameterCases[ndx].height,
|
|
parameterCases[ndx].rowLength,
|
|
parameterCases[ndx].skipRows,
|
|
parameterCases[ndx].skipPixels,
|
|
parameterCases[ndx].alignment,
|
|
parameterCases[ndx].offset));
|
|
pboGroup->addChild(new TexImageCubeBufferCase(m_context, (string(parameterCases[ndx].name) + "_cube").c_str(), "",
|
|
parameterCases[ndx].format,
|
|
parameterCases[ndx].width,
|
|
parameterCases[ndx].rowLength,
|
|
parameterCases[ndx].skipRows,
|
|
parameterCases[ndx].skipPixels,
|
|
parameterCases[ndx].alignment,
|
|
parameterCases[ndx].offset));
|
|
}
|
|
}
|
|
|
|
// glTexImage2D() depth cases.
|
|
{
|
|
tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_depth", "glTexImage2D() with depth or depth/stencil format");
|
|
addChild(shadow2dGroup);
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
|
|
{
|
|
const int tex2DWidth = 64;
|
|
const int tex2DHeight = 128;
|
|
|
|
shadow2dGroup->addChild(new TexImage2DDepthCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight));
|
|
}
|
|
}
|
|
|
|
// glTexImage2D() depth cases with pbo.
|
|
{
|
|
tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_depth_pbo", "glTexImage2D() with depth or depth/stencil format with pbo");
|
|
addChild(shadow2dGroup);
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
|
|
{
|
|
const int tex2DWidth = 64;
|
|
const int tex2DHeight = 128;
|
|
|
|
shadow2dGroup->addChild(new TexImage2DDepthBufferCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight));
|
|
}
|
|
}
|
|
|
|
// Basic TexSubImage2D usage.
|
|
{
|
|
tcu::TestCaseGroup* basicTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_texsubimage2d", "Basic glTexSubImage2D() usage");
|
|
addChild(basicTexSubImageGroup);
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
|
|
{
|
|
const char* fmtName = colorFormats[formatNdx].name;
|
|
deUint32 format = colorFormats[formatNdx].internalFormat;
|
|
const int tex2DWidth = 64;
|
|
const int tex2DHeight = 128;
|
|
const int texCubeSize = 64;
|
|
|
|
basicTexSubImageGroup->addChild(new BasicTexSubImage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight));
|
|
basicTexSubImageGroup->addChild(new BasicTexSubImageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, texCubeSize));
|
|
}
|
|
}
|
|
|
|
// TexSubImage2D to empty texture.
|
|
{
|
|
tcu::TestCaseGroup* texSubImageEmptyTexGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_empty_tex", "glTexSubImage2D() to texture that has storage but no data");
|
|
addChild(texSubImageEmptyTexGroup);
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(unsizedFormats); formatNdx++)
|
|
{
|
|
const char* fmtName = unsizedFormats[formatNdx].name;
|
|
deUint32 format = unsizedFormats[formatNdx].format;
|
|
deUint32 dataType = unsizedFormats[formatNdx].dataType;
|
|
const int tex2DWidth = 64;
|
|
const int tex2DHeight = 32;
|
|
const int texCubeSize = 32;
|
|
|
|
texSubImageEmptyTexGroup->addChild(new TexSubImage2DEmptyTexCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, dataType, tex2DWidth, tex2DHeight));
|
|
texSubImageEmptyTexGroup->addChild(new TexSubImageCubeEmptyTexCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, dataType, texCubeSize));
|
|
}
|
|
}
|
|
|
|
// TexSubImage2D alignment cases.
|
|
{
|
|
tcu::TestCaseGroup* alignGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_align", "glTexSubImage2D() unpack alignment tests");
|
|
addChild(alignGroup);
|
|
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_1", "", GL_R8, 64, 64, 13, 17, 1, 6, 1));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_2", "", GL_R8, 64, 64, 13, 17, 1, 6, 2));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_4", "", GL_R8, 64, 64, 13, 17, 1, 6, 4));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_8", "", GL_R8, 64, 64, 13, 17, 1, 6, 8));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_1", "", GL_R8, 64, 64, 1, 9, 63, 30, 1));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_2", "", GL_R8, 64, 64, 1, 9, 63, 30, 2));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_4", "", GL_R8, 64, 64, 1, 9, 63, 30, 4));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_8", "", GL_R8, 64, 64, 1, 9, 63, 30, 8));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_1", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 1));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_2", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 2));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_4", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 4));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_8", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 8));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_1", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 1));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_2", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 2));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_4", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 4));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_8", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 8));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_1", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 1));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_2", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 2));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_4", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 4));
|
|
alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_8", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 8));
|
|
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_1", "", GL_R8, 64, 13, 17, 1, 6, 1));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_2", "", GL_R8, 64, 13, 17, 1, 6, 2));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_4", "", GL_R8, 64, 13, 17, 1, 6, 4));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_8", "", GL_R8, 64, 13, 17, 1, 6, 8));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_1", "", GL_R8, 64, 1, 9, 63, 30, 1));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_2", "", GL_R8, 64, 1, 9, 63, 30, 2));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_4", "", GL_R8, 64, 1, 9, 63, 30, 4));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_8", "", GL_R8, 64, 1, 9, 63, 30, 8));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_1", "", GL_RGBA4, 64, 7, 29, 51, 30, 1));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_2", "", GL_RGBA4, 64, 7, 29, 51, 30, 2));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_4", "", GL_RGBA4, 64, 7, 29, 51, 30, 4));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_8", "", GL_RGBA4, 64, 7, 29, 51, 30, 8));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_1", "", GL_RGB8, 64, 11, 8, 39, 43, 1));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_2", "", GL_RGB8, 64, 11, 8, 39, 43, 2));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_4", "", GL_RGB8, 64, 11, 8, 39, 43, 4));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_8", "", GL_RGB8, 64, 11, 8, 39, 43, 8));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_1", "", GL_RGBA8, 64, 10, 1, 47, 27, 1));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_2", "", GL_RGBA8, 64, 10, 1, 47, 27, 2));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_4", "", GL_RGBA8, 64, 10, 1, 47, 27, 4));
|
|
alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_8", "", GL_RGBA8, 64, 10, 1, 47, 27, 8));
|
|
}
|
|
|
|
// glTexSubImage2D() pixel transfer mode cases.
|
|
{
|
|
tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_unpack_params", "glTexSubImage2D() pixel transfer mode cases");
|
|
addChild(paramGroup);
|
|
|
|
static const struct
|
|
{
|
|
const char* name;
|
|
deUint32 format;
|
|
int width;
|
|
int height;
|
|
int subX;
|
|
int subY;
|
|
int subW;
|
|
int subH;
|
|
int rowLength;
|
|
int skipRows;
|
|
int skipPixels;
|
|
int alignment;
|
|
} cases[] =
|
|
{
|
|
{ "rgb8_alignment", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 2 },
|
|
{ "rgb8_row_length", GL_RGB8, 54, 60, 11, 7, 31, 30, 50, 0, 0, 4 },
|
|
{ "rgb8_skip_rows", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 3, 0, 4 },
|
|
{ "rgb8_skip_pixels", GL_RGB8, 54, 60, 11, 7, 31, 30, 36, 0, 5, 4 },
|
|
{ "r8_complex1", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 1 },
|
|
{ "r8_complex2", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 2 },
|
|
{ "r8_complex3", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 4 },
|
|
{ "r8_complex4", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 8 },
|
|
{ "rgba8_complex1", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 0, 0, 8 },
|
|
{ "rgba8_complex2", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 0, 7, 8 },
|
|
{ "rgba8_complex3", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 3, 0, 8 },
|
|
{ "rgba8_complex4", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 3, 7, 8 },
|
|
{ "rgba32f_complex", GL_RGBA32F, 92, 84, 13, 19, 56, 61, 69, 3, 7, 8 }
|
|
};
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++)
|
|
paramGroup->addChild(new TexSubImage2DParamsCase(m_context, cases[ndx].name, "",
|
|
cases[ndx].format,
|
|
cases[ndx].width,
|
|
cases[ndx].height,
|
|
cases[ndx].subX,
|
|
cases[ndx].subY,
|
|
cases[ndx].subW,
|
|
cases[ndx].subH,
|
|
cases[ndx].rowLength,
|
|
cases[ndx].skipRows,
|
|
cases[ndx].skipPixels,
|
|
cases[ndx].alignment));
|
|
}
|
|
|
|
// glTexSubImage2D() PBO cases.
|
|
{
|
|
tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_pbo", "glTexSubImage2D() pixel buffer object tests");
|
|
addChild(pboGroup);
|
|
|
|
static const struct
|
|
{
|
|
const char* name;
|
|
deUint32 format;
|
|
int width;
|
|
int height;
|
|
int subX;
|
|
int subY;
|
|
int subW;
|
|
int subH;
|
|
int rowLength;
|
|
int skipRows;
|
|
int skipPixels;
|
|
int alignment;
|
|
int offset;
|
|
} paramCases[] =
|
|
{
|
|
{ "rgb8_offset", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 4, 67 },
|
|
{ "rgb8_alignment", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 2, 0 },
|
|
{ "rgb8_row_length", GL_RGB8, 54, 60, 11, 7, 31, 30, 50, 0, 0, 4, 0 },
|
|
{ "rgb8_skip_rows", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 3, 0, 4, 0 },
|
|
{ "rgb8_skip_pixels", GL_RGB8, 54, 60, 11, 7, 31, 30, 36, 0, 5, 4, 0 }
|
|
};
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorFormats); ndx++)
|
|
{
|
|
pboGroup->addChild(new TexSubImage2DBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_2d").c_str(), "",
|
|
colorFormats[ndx].internalFormat,
|
|
54, // Width
|
|
60, // Height
|
|
11, // Sub X
|
|
7, // Sub Y
|
|
31, // Sub W
|
|
30, // Sub H
|
|
0, // Row len
|
|
0, // Skip rows
|
|
0, // Skip pixels
|
|
4, // Alignment
|
|
0 /* offset */));
|
|
pboGroup->addChild(new TexSubImageCubeBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_cube").c_str(), "",
|
|
colorFormats[ndx].internalFormat,
|
|
64, // Size
|
|
11, // Sub X
|
|
7, // Sub Y
|
|
31, // Sub W
|
|
30, // Sub H
|
|
0, // Row len
|
|
0, // Skip rows
|
|
0, // Skip pixels
|
|
4, // Alignment
|
|
0 /* offset */));
|
|
}
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(paramCases); ndx++)
|
|
{
|
|
pboGroup->addChild(new TexSubImage2DBufferCase(m_context, (std::string(paramCases[ndx].name) + "_2d").c_str(), "",
|
|
paramCases[ndx].format,
|
|
paramCases[ndx].width,
|
|
paramCases[ndx].height,
|
|
paramCases[ndx].subX,
|
|
paramCases[ndx].subY,
|
|
paramCases[ndx].subW,
|
|
paramCases[ndx].subH,
|
|
paramCases[ndx].rowLength,
|
|
paramCases[ndx].skipRows,
|
|
paramCases[ndx].skipPixels,
|
|
paramCases[ndx].alignment,
|
|
paramCases[ndx].offset));
|
|
pboGroup->addChild(new TexSubImageCubeBufferCase(m_context, (std::string(paramCases[ndx].name) + "_cube").c_str(), "",
|
|
paramCases[ndx].format,
|
|
paramCases[ndx].width,
|
|
paramCases[ndx].subX,
|
|
paramCases[ndx].subY,
|
|
paramCases[ndx].subW,
|
|
paramCases[ndx].subH,
|
|
paramCases[ndx].rowLength,
|
|
paramCases[ndx].skipRows,
|
|
paramCases[ndx].skipPixels,
|
|
paramCases[ndx].alignment,
|
|
paramCases[ndx].offset));
|
|
}
|
|
}
|
|
|
|
// glTexSubImage2D() depth cases.
|
|
{
|
|
tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_depth", "glTexSubImage2D() with depth or depth/stencil format");
|
|
addChild(shadow2dGroup);
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
|
|
{
|
|
const int tex2DWidth = 64;
|
|
const int tex2DHeight = 32;
|
|
|
|
shadow2dGroup->addChild(new TexSubImage2DDepthCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight));
|
|
}
|
|
}
|
|
|
|
// Basic glCopyTexImage2D() cases
|
|
{
|
|
tcu::TestCaseGroup* copyTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_copyteximage2d", "Basic glCopyTexImage2D() usage");
|
|
addChild(copyTexImageGroup);
|
|
|
|
copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_alpha", "", GL_ALPHA, 128, 64));
|
|
copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_luminance", "", GL_LUMINANCE, 128, 64));
|
|
copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_luminance_alpha", "", GL_LUMINANCE_ALPHA, 128, 64));
|
|
copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_rgb", "", GL_RGB, 128, 64));
|
|
copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_rgba", "", GL_RGBA, 128, 64));
|
|
|
|
copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_alpha", "", GL_ALPHA, 64));
|
|
copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_luminance", "", GL_LUMINANCE, 64));
|
|
copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_luminance_alpha", "", GL_LUMINANCE_ALPHA, 64));
|
|
copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_rgb", "", GL_RGB, 64));
|
|
copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_rgba", "", GL_RGBA, 64));
|
|
}
|
|
|
|
// Basic glCopyTexSubImage2D() cases
|
|
{
|
|
tcu::TestCaseGroup* copyTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_copytexsubimage2d", "Basic glCopyTexSubImage2D() usage");
|
|
addChild(copyTexSubImageGroup);
|
|
|
|
copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_alpha", "", GL_ALPHA, GL_UNSIGNED_BYTE, 128, 64));
|
|
copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_luminance", "", GL_LUMINANCE, GL_UNSIGNED_BYTE, 128, 64));
|
|
copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_luminance_alpha", "", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 128, 64));
|
|
copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_rgb", "", GL_RGB, GL_UNSIGNED_BYTE, 128, 64));
|
|
copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_rgba", "", GL_RGBA, GL_UNSIGNED_BYTE, 128, 64));
|
|
|
|
copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_alpha", "", GL_ALPHA, GL_UNSIGNED_BYTE, 64));
|
|
copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_luminance", "", GL_LUMINANCE, GL_UNSIGNED_BYTE, 64));
|
|
copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_luminance_alpha", "", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 64));
|
|
copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_rgb", "", GL_RGB, GL_UNSIGNED_BYTE, 64));
|
|
copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_rgba", "", GL_RGBA, GL_UNSIGNED_BYTE, 64));
|
|
}
|
|
|
|
// Basic TexImage3D usage.
|
|
{
|
|
tcu::TestCaseGroup* basicTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_teximage3d", "Basic glTexImage3D() usage");
|
|
addChild(basicTexImageGroup);
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
|
|
{
|
|
const char* fmtName = colorFormats[formatNdx].name;
|
|
deUint32 format = colorFormats[formatNdx].internalFormat;
|
|
const int tex2DArrayWidth = 57;
|
|
const int tex2DArrayHeight = 44;
|
|
const int tex2DArrayLevels = 5;
|
|
const int tex3DWidth = 63;
|
|
const int tex3DHeight = 29;
|
|
const int tex3DDepth = 11;
|
|
|
|
basicTexImageGroup->addChild(new BasicTexImage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", format, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLevels));
|
|
basicTexImageGroup->addChild(new BasicTexImage3DCase (m_context, (string(fmtName) + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth));
|
|
}
|
|
}
|
|
|
|
// glTexImage3D() unpack params cases.
|
|
{
|
|
tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_unpack_params", "glTexImage3D() unpack parameters");
|
|
addChild(paramGroup);
|
|
|
|
static const struct
|
|
{
|
|
const char* name;
|
|
deUint32 format;
|
|
int width;
|
|
int height;
|
|
int depth;
|
|
int imageHeight;
|
|
int rowLength;
|
|
int skipImages;
|
|
int skipRows;
|
|
int skipPixels;
|
|
int alignment;
|
|
} cases[] =
|
|
{
|
|
{ "rgb8_image_height", GL_RGB8, 23, 19, 8, 26, 0, 0, 0, 0, 4 },
|
|
{ "rgb8_row_length", GL_RGB8, 23, 19, 8, 0, 27, 0, 0, 0, 4 },
|
|
{ "rgb8_skip_images", GL_RGB8, 23, 19, 8, 0, 0, 3, 0, 0, 4 },
|
|
{ "rgb8_skip_rows", GL_RGB8, 23, 19, 8, 22, 0, 0, 3, 0, 4 },
|
|
{ "rgb8_skip_pixels", GL_RGB8, 23, 19, 8, 0, 25, 0, 0, 2, 4 },
|
|
{ "r8_complex1", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 1 },
|
|
{ "r8_complex2", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 2 },
|
|
{ "r8_complex3", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 4 },
|
|
{ "r8_complex4", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 8 },
|
|
{ "rgba8_complex1", GL_RGBA8, 11, 20, 8, 25, 14, 0, 0, 0, 8 },
|
|
{ "rgba8_complex2", GL_RGBA8, 11, 20, 8, 25, 14, 0, 2, 0, 8 },
|
|
{ "rgba8_complex3", GL_RGBA8, 11, 20, 8, 25, 14, 0, 0, 3, 8 },
|
|
{ "rgba8_complex4", GL_RGBA8, 11, 20, 8, 25, 14, 0, 2, 3, 8 },
|
|
{ "rgba32f_complex", GL_RGBA32F, 11, 20, 8, 25, 14, 0, 2, 3, 8 }
|
|
};
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++)
|
|
paramGroup->addChild(new TexImage3DParamsCase(m_context, cases[ndx].name, "",
|
|
cases[ndx].format,
|
|
cases[ndx].width,
|
|
cases[ndx].height,
|
|
cases[ndx].depth,
|
|
cases[ndx].imageHeight,
|
|
cases[ndx].rowLength,
|
|
cases[ndx].skipImages,
|
|
cases[ndx].skipRows,
|
|
cases[ndx].skipPixels,
|
|
cases[ndx].alignment));
|
|
}
|
|
|
|
// glTexImage3D() pbo cases.
|
|
{
|
|
tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_pbo", "glTexImage3D() from PBO");
|
|
addChild(pboGroup);
|
|
|
|
// Parameter cases
|
|
static const struct
|
|
{
|
|
const char* name;
|
|
deUint32 format;
|
|
int width;
|
|
int height;
|
|
int depth;
|
|
int imageHeight;
|
|
int rowLength;
|
|
int skipImages;
|
|
int skipRows;
|
|
int skipPixels;
|
|
int alignment;
|
|
int offset;
|
|
} parameterCases[] =
|
|
{
|
|
{ "rgb8_offset", GL_RGB8, 23, 19, 8, 0, 0, 0, 0, 0, 1, 67 },
|
|
{ "rgb8_alignment", GL_RGB8, 23, 19, 8, 0, 0, 0, 0, 0, 2, 0 },
|
|
{ "rgb8_image_height", GL_RGB8, 23, 19, 8, 26, 0, 0, 0, 0, 4, 0 },
|
|
{ "rgb8_row_length", GL_RGB8, 23, 19, 8, 0, 27, 0, 0, 0, 4, 0 },
|
|
{ "rgb8_skip_images", GL_RGB8, 23, 19, 8, 0, 0, 3, 0, 0, 4, 0 },
|
|
{ "rgb8_skip_rows", GL_RGB8, 23, 19, 8, 22, 0, 0, 3, 0, 4, 0 },
|
|
{ "rgb8_skip_pixels", GL_RGB8, 23, 19, 8, 0, 25, 0, 0, 2, 4, 0 }
|
|
};
|
|
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
|
|
{
|
|
const string fmtName = colorFormats[formatNdx].name;
|
|
const deUint32 format = colorFormats[formatNdx].internalFormat;
|
|
const int tex3DWidth = 11;
|
|
const int tex3DHeight = 20;
|
|
const int tex3DDepth = 8;
|
|
|
|
pboGroup->addChild(new TexImage2DArrayBufferCase (m_context, (fmtName + "_2d_array").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth, 0, 0, 0, 0, 0, 4, 0));
|
|
pboGroup->addChild(new TexImage3DBufferCase (m_context, (fmtName + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth, 0, 0, 0, 0, 0, 4, 0));
|
|
}
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(parameterCases); ndx++)
|
|
{
|
|
pboGroup->addChild(new TexImage2DArrayBufferCase(m_context, (string(parameterCases[ndx].name) + "_2d_array").c_str(), "",
|
|
parameterCases[ndx].format,
|
|
parameterCases[ndx].width,
|
|
parameterCases[ndx].depth,
|
|
parameterCases[ndx].height,
|
|
parameterCases[ndx].imageHeight,
|
|
parameterCases[ndx].rowLength,
|
|
parameterCases[ndx].skipImages,
|
|
parameterCases[ndx].skipRows,
|
|
parameterCases[ndx].skipPixels,
|
|
parameterCases[ndx].alignment,
|
|
parameterCases[ndx].offset));
|
|
pboGroup->addChild(new TexImage3DBufferCase(m_context, (string(parameterCases[ndx].name) + "_3d").c_str(), "",
|
|
parameterCases[ndx].format,
|
|
parameterCases[ndx].width,
|
|
parameterCases[ndx].depth,
|
|
parameterCases[ndx].height,
|
|
parameterCases[ndx].imageHeight,
|
|
parameterCases[ndx].rowLength,
|
|
parameterCases[ndx].skipImages,
|
|
parameterCases[ndx].skipRows,
|
|
parameterCases[ndx].skipPixels,
|
|
parameterCases[ndx].alignment,
|
|
parameterCases[ndx].offset));
|
|
}
|
|
}
|
|
|
|
// glTexImage3D() depth cases.
|
|
{
|
|
tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_depth", "glTexImage3D() with depth or depth/stencil format");
|
|
addChild(shadow3dGroup);
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
|
|
{
|
|
const int tex3DWidth = 32;
|
|
const int tex3DHeight = 64;
|
|
const int tex3DDepth = 8;
|
|
|
|
shadow3dGroup->addChild(new TexImage2DArrayDepthCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex3DWidth, tex3DHeight, tex3DDepth));
|
|
}
|
|
}
|
|
|
|
// glTexImage3D() depth cases with pbo.
|
|
{
|
|
tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_depth_pbo", "glTexImage3D() with depth or depth/stencil format with pbo");
|
|
addChild(shadow3dGroup);
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
|
|
{
|
|
const int tex3DWidth = 32;
|
|
const int tex3DHeight = 64;
|
|
const int tex3DDepth = 8;
|
|
|
|
shadow3dGroup->addChild(new TexImage2DArrayDepthBufferCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex3DWidth, tex3DHeight, tex3DDepth));
|
|
}
|
|
}
|
|
|
|
// Basic TexSubImage3D usage.
|
|
{
|
|
tcu::TestCaseGroup* basicTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_texsubimage3d", "Basic glTexSubImage3D() usage");
|
|
addChild(basicTexSubImageGroup);
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
|
|
{
|
|
const char* fmtName = colorFormats[formatNdx].name;
|
|
deUint32 format = colorFormats[formatNdx].internalFormat;
|
|
const int tex3DWidth = 32;
|
|
const int tex3DHeight = 64;
|
|
const int tex3DDepth = 8;
|
|
|
|
basicTexSubImageGroup->addChild(new BasicTexSubImage3DCase(m_context, (string(fmtName) + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth));
|
|
}
|
|
}
|
|
|
|
// glTexSubImage3D() unpack params cases.
|
|
{
|
|
tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_unpack_params", "glTexSubImage3D() unpack parameters");
|
|
addChild(paramGroup);
|
|
|
|
static const struct
|
|
{
|
|
const char* name;
|
|
deUint32 format;
|
|
int width;
|
|
int height;
|
|
int depth;
|
|
int subX;
|
|
int subY;
|
|
int subZ;
|
|
int subW;
|
|
int subH;
|
|
int subD;
|
|
int imageHeight;
|
|
int rowLength;
|
|
int skipImages;
|
|
int skipRows;
|
|
int skipPixels;
|
|
int alignment;
|
|
} cases[] =
|
|
{
|
|
{ "rgb8_image_height", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 26, 0, 0, 0, 0, 4 },
|
|
{ "rgb8_row_length", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 27, 0, 0, 0, 4 },
|
|
{ "rgb8_skip_images", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 3, 0, 0, 4 },
|
|
{ "rgb8_skip_rows", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 22, 0, 0, 3, 0, 4 },
|
|
{ "rgb8_skip_pixels", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 25, 0, 0, 2, 4 },
|
|
{ "r8_complex1", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 1 },
|
|
{ "r8_complex2", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 2 },
|
|
{ "r8_complex3", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 4 },
|
|
{ "r8_complex4", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 8 },
|
|
{ "rgba8_complex1", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 0, 0, 8 },
|
|
{ "rgba8_complex2", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 0, 8 },
|
|
{ "rgba8_complex3", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 0, 3, 8 },
|
|
{ "rgba8_complex4", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 3, 8 },
|
|
{ "rgba32f_complex", GL_RGBA32F, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 3, 8 }
|
|
};
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++)
|
|
paramGroup->addChild(new TexSubImage3DParamsCase(m_context, cases[ndx].name, "",
|
|
cases[ndx].format,
|
|
cases[ndx].width,
|
|
cases[ndx].height,
|
|
cases[ndx].depth,
|
|
cases[ndx].subX,
|
|
cases[ndx].subY,
|
|
cases[ndx].subZ,
|
|
cases[ndx].subW,
|
|
cases[ndx].subH,
|
|
cases[ndx].subD,
|
|
cases[ndx].imageHeight,
|
|
cases[ndx].rowLength,
|
|
cases[ndx].skipImages,
|
|
cases[ndx].skipRows,
|
|
cases[ndx].skipPixels,
|
|
cases[ndx].alignment));
|
|
}
|
|
|
|
// glTexSubImage3D() PBO cases.
|
|
{
|
|
tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_pbo", "glTexSubImage3D() pixel buffer object tests");
|
|
addChild(pboGroup);
|
|
|
|
static const struct
|
|
{
|
|
const char* name;
|
|
deUint32 format;
|
|
int width;
|
|
int height;
|
|
int depth;
|
|
int subX;
|
|
int subY;
|
|
int subZ;
|
|
int subW;
|
|
int subH;
|
|
int subD;
|
|
int imageHeight;
|
|
int rowLength;
|
|
int skipImages;
|
|
int skipRows;
|
|
int skipPixels;
|
|
int alignment;
|
|
int offset;
|
|
} paramCases[] =
|
|
{
|
|
{ "rgb8_offset", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 0, 0, 0, 4, 67 },
|
|
{ "rgb8_image_height", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 26, 0, 0, 0, 0, 4, 0 },
|
|
{ "rgb8_row_length", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 27, 0, 0, 0, 4, 0 },
|
|
{ "rgb8_skip_images", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 3, 0, 0, 4, 0 },
|
|
{ "rgb8_skip_rows", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 22, 0, 0, 3, 0, 4, 0 },
|
|
{ "rgb8_skip_pixels", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 25, 0, 0, 2, 4, 0 }
|
|
};
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorFormats); ndx++)
|
|
{
|
|
pboGroup->addChild(new TexSubImage2DArrayBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_2d_array").c_str(), "",
|
|
colorFormats[ndx].internalFormat,
|
|
26, // Width
|
|
25, // Height
|
|
10, // Depth
|
|
1, // Sub X
|
|
2, // Sub Y
|
|
0, // Sub Z
|
|
23, // Sub W
|
|
19, // Sub H
|
|
8, // Sub D
|
|
0, // Image height
|
|
0, // Row length
|
|
0, // Skip images
|
|
0, // Skip rows
|
|
0, // Skip pixels
|
|
4, // Alignment
|
|
0 /* offset */));
|
|
pboGroup->addChild(new TexSubImage3DBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_3d").c_str(), "",
|
|
colorFormats[ndx].internalFormat,
|
|
26, // Width
|
|
25, // Height
|
|
10, // Depth
|
|
1, // Sub X
|
|
2, // Sub Y
|
|
0, // Sub Z
|
|
23, // Sub W
|
|
19, // Sub H
|
|
8, // Sub D
|
|
0, // Image height
|
|
0, // Row length
|
|
0, // Skip images
|
|
0, // Skip rows
|
|
0, // Skip pixels
|
|
4, // Alignment
|
|
0 /* offset */));
|
|
}
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(paramCases); ndx++)
|
|
{
|
|
pboGroup->addChild(new TexSubImage2DArrayBufferCase(m_context, (std::string(paramCases[ndx].name) + "_2d_array").c_str(), "",
|
|
paramCases[ndx].format,
|
|
paramCases[ndx].width,
|
|
paramCases[ndx].height,
|
|
paramCases[ndx].depth,
|
|
paramCases[ndx].subX,
|
|
paramCases[ndx].subY,
|
|
paramCases[ndx].subZ,
|
|
paramCases[ndx].subW,
|
|
paramCases[ndx].subH,
|
|
paramCases[ndx].subD,
|
|
paramCases[ndx].imageHeight,
|
|
paramCases[ndx].rowLength,
|
|
paramCases[ndx].skipImages,
|
|
paramCases[ndx].skipRows,
|
|
paramCases[ndx].skipPixels,
|
|
paramCases[ndx].alignment,
|
|
paramCases[ndx].offset));
|
|
pboGroup->addChild(new TexSubImage3DBufferCase(m_context, (std::string(paramCases[ndx].name) + "_3d").c_str(), "",
|
|
paramCases[ndx].format,
|
|
paramCases[ndx].width,
|
|
paramCases[ndx].height,
|
|
paramCases[ndx].depth,
|
|
paramCases[ndx].subX,
|
|
paramCases[ndx].subY,
|
|
paramCases[ndx].subZ,
|
|
paramCases[ndx].subW,
|
|
paramCases[ndx].subH,
|
|
paramCases[ndx].subD,
|
|
paramCases[ndx].imageHeight,
|
|
paramCases[ndx].rowLength,
|
|
paramCases[ndx].skipImages,
|
|
paramCases[ndx].skipRows,
|
|
paramCases[ndx].skipPixels,
|
|
paramCases[ndx].alignment,
|
|
paramCases[ndx].offset));
|
|
}
|
|
}
|
|
|
|
// glTexSubImage3D() depth cases.
|
|
{
|
|
tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_depth", "glTexSubImage3D() with depth or depth/stencil format");
|
|
addChild(shadow3dGroup);
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++)
|
|
{
|
|
const int tex2DArrayWidth = 57;
|
|
const int tex2DArrayHeight = 44;
|
|
const int tex2DArrayLevels = 5;
|
|
|
|
shadow3dGroup->addChild(new TexSubImage2DArrayDepthCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLevels));
|
|
}
|
|
}
|
|
|
|
// glTexStorage2D() cases.
|
|
{
|
|
tcu::TestCaseGroup* texStorageGroup = new tcu::TestCaseGroup(m_testCtx, "texstorage2d", "Basic glTexStorage2D() usage");
|
|
addChild(texStorageGroup);
|
|
|
|
// All formats.
|
|
tcu::TestCaseGroup* formatGroup = new tcu::TestCaseGroup(m_testCtx, "format", "glTexStorage2D() with all formats");
|
|
texStorageGroup->addChild(formatGroup);
|
|
|
|
// Color formats.
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
|
|
{
|
|
const char* fmtName = colorFormats[formatNdx].name;
|
|
deUint32 internalFormat = colorFormats[formatNdx].internalFormat;
|
|
const int tex2DWidth = 117;
|
|
const int tex2DHeight = 97;
|
|
int tex2DLevels = maxLevelCount(tex2DWidth, tex2DHeight);
|
|
const int cubeSize = 57;
|
|
int cubeLevels = maxLevelCount(cubeSize, cubeSize);
|
|
|
|
formatGroup->addChild(new BasicTexStorage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", internalFormat, tex2DWidth, tex2DHeight, tex2DLevels));
|
|
formatGroup->addChild(new BasicTexStorageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", internalFormat, cubeSize, cubeLevels));
|
|
}
|
|
|
|
// Depth / stencil formats.
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthStencilFormats); formatNdx++)
|
|
{
|
|
const char* fmtName = depthStencilFormats[formatNdx].name;
|
|
deUint32 internalFormat = depthStencilFormats[formatNdx].internalFormat;
|
|
const int tex2DWidth = 117;
|
|
const int tex2DHeight = 97;
|
|
int tex2DLevels = maxLevelCount(tex2DWidth, tex2DHeight);
|
|
const int cubeSize = 57;
|
|
int cubeLevels = maxLevelCount(cubeSize, cubeSize);
|
|
|
|
formatGroup->addChild(new BasicTexStorage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", internalFormat, tex2DWidth, tex2DHeight, tex2DLevels));
|
|
formatGroup->addChild(new BasicTexStorageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", internalFormat, cubeSize, cubeLevels));
|
|
}
|
|
|
|
// Sizes.
|
|
static const struct
|
|
{
|
|
int width;
|
|
int height;
|
|
int levels;
|
|
} tex2DSizes[] =
|
|
{
|
|
// W H L
|
|
{ 1, 1, 1 },
|
|
{ 2, 2, 2 },
|
|
{ 64, 32, 7 },
|
|
{ 32, 64, 4 },
|
|
{ 57, 63, 1 },
|
|
{ 57, 63, 2 },
|
|
{ 57, 63, 6 }
|
|
};
|
|
static const struct
|
|
{
|
|
int size;
|
|
int levels;
|
|
} cubeSizes[] =
|
|
{
|
|
// S L
|
|
{ 1, 1 },
|
|
{ 2, 2 },
|
|
{ 57, 1 },
|
|
{ 57, 2 },
|
|
{ 57, 6 },
|
|
{ 64, 4 },
|
|
{ 64, 7 },
|
|
};
|
|
|
|
tcu::TestCaseGroup* sizeGroup = new tcu::TestCaseGroup(m_testCtx, "size", "glTexStorage2D() with various sizes");
|
|
texStorageGroup->addChild(sizeGroup);
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex2DSizes); ndx++)
|
|
{
|
|
const deUint32 format = GL_RGBA8;
|
|
int width = tex2DSizes[ndx].width;
|
|
int height = tex2DSizes[ndx].height;
|
|
int levels = tex2DSizes[ndx].levels;
|
|
string name = string("2d_") + de::toString(width) + "x" + de::toString(height) + "_" + de::toString(levels) + "_levels";
|
|
|
|
sizeGroup->addChild(new BasicTexStorage2DCase(m_context, name.c_str(), "", format, width, height, levels));
|
|
}
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cubeSizes); ndx++)
|
|
{
|
|
const deUint32 format = GL_RGBA8;
|
|
int size = cubeSizes[ndx].size;
|
|
int levels = cubeSizes[ndx].levels;
|
|
string name = string("cube_") + de::toString(size) + "x" + de::toString(size) + "_" + de::toString(levels) + "_levels";
|
|
|
|
sizeGroup->addChild(new BasicTexStorageCubeCase(m_context, name.c_str(), "", format, size, levels));
|
|
}
|
|
}
|
|
|
|
// glTexStorage3D() cases.
|
|
{
|
|
tcu::TestCaseGroup* texStorageGroup = new tcu::TestCaseGroup(m_testCtx, "texstorage3d", "Basic glTexStorage3D() usage");
|
|
addChild(texStorageGroup);
|
|
|
|
// All formats.
|
|
tcu::TestCaseGroup* formatGroup = new tcu::TestCaseGroup(m_testCtx, "format", "glTexStorage3D() with all formats");
|
|
texStorageGroup->addChild(formatGroup);
|
|
|
|
// Color formats.
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++)
|
|
{
|
|
const char* fmtName = colorFormats[formatNdx].name;
|
|
deUint32 internalFormat = colorFormats[formatNdx].internalFormat;
|
|
const int tex2DArrayWidth = 57;
|
|
const int tex2DArrayHeight = 13;
|
|
const int tex2DArrayLayers = 7;
|
|
int tex2DArrayLevels = maxLevelCount(tex2DArrayWidth, tex2DArrayHeight);
|
|
const int tex3DWidth = 59;
|
|
const int tex3DHeight = 37;
|
|
const int tex3DDepth = 11;
|
|
int tex3DLevels = maxLevelCount(tex3DWidth, tex3DHeight, tex3DDepth);
|
|
|
|
formatGroup->addChild(new BasicTexStorage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels));
|
|
formatGroup->addChild(new BasicTexStorage3DCase (m_context, (string(fmtName) + "_3d").c_str(), "", internalFormat, tex3DWidth, tex3DHeight, tex3DDepth, tex3DLevels));
|
|
}
|
|
|
|
// Depth/stencil formats (only 2D texture array is supported).
|
|
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthStencilFormats); formatNdx++)
|
|
{
|
|
const char* fmtName = depthStencilFormats[formatNdx].name;
|
|
deUint32 internalFormat = depthStencilFormats[formatNdx].internalFormat;
|
|
const int tex2DArrayWidth = 57;
|
|
const int tex2DArrayHeight = 13;
|
|
const int tex2DArrayLayers = 7;
|
|
int tex2DArrayLevels = maxLevelCount(tex2DArrayWidth, tex2DArrayHeight);
|
|
|
|
formatGroup->addChild(new BasicTexStorage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels));
|
|
}
|
|
|
|
// Sizes.
|
|
static const struct
|
|
{
|
|
int width;
|
|
int height;
|
|
int layers;
|
|
int levels;
|
|
} tex2DArraySizes[] =
|
|
{
|
|
// W H La Le
|
|
{ 1, 1, 1, 1 },
|
|
{ 2, 2, 2, 2 },
|
|
{ 64, 32, 3, 7 },
|
|
{ 32, 64, 3, 4 },
|
|
{ 57, 63, 5, 1 },
|
|
{ 57, 63, 5, 2 },
|
|
{ 57, 63, 5, 6 }
|
|
};
|
|
static const struct
|
|
{
|
|
int width;
|
|
int height;
|
|
int depth;
|
|
int levels;
|
|
} tex3DSizes[] =
|
|
{
|
|
// W H D L
|
|
{ 1, 1, 1, 1 },
|
|
{ 2, 2, 2, 2 },
|
|
{ 64, 32, 16, 7 },
|
|
{ 32, 64, 16, 4 },
|
|
{ 32, 16, 64, 4 },
|
|
{ 57, 63, 11, 1 },
|
|
{ 57, 63, 11, 2 },
|
|
{ 57, 63, 11, 6 }
|
|
};
|
|
|
|
tcu::TestCaseGroup* sizeGroup = new tcu::TestCaseGroup(m_testCtx, "size", "glTexStorage2D() with various sizes");
|
|
texStorageGroup->addChild(sizeGroup);
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex2DArraySizes); ndx++)
|
|
{
|
|
const deUint32 format = GL_RGBA8;
|
|
int width = tex2DArraySizes[ndx].width;
|
|
int height = tex2DArraySizes[ndx].height;
|
|
int layers = tex2DArraySizes[ndx].layers;
|
|
int levels = tex2DArraySizes[ndx].levels;
|
|
string name = string("2d_array_") + de::toString(width) + "x" + de::toString(height) + "x" + de::toString(layers) + "_" + de::toString(levels) + "_levels";
|
|
|
|
sizeGroup->addChild(new BasicTexStorage2DArrayCase(m_context, name.c_str(), "", format, width, height, layers, levels));
|
|
}
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex3DSizes); ndx++)
|
|
{
|
|
const deUint32 format = GL_RGBA8;
|
|
int width = tex3DSizes[ndx].width;
|
|
int height = tex3DSizes[ndx].height;
|
|
int depth = tex3DSizes[ndx].depth;
|
|
int levels = tex3DSizes[ndx].levels;
|
|
string name = string("3d_") + de::toString(width) + "x" + de::toString(height) + "x" + de::toString(depth) + "_" + de::toString(levels) + "_levels";
|
|
|
|
sizeGroup->addChild(new BasicTexStorage3DCase(m_context, name.c_str(), "", format, width, height, depth, levels));
|
|
}
|
|
}
|
|
}
|
|
|
|
} // Functional
|
|
} // gles3
|
|
} // deqp
|