/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL (ES) 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 buffer test case
*//*--------------------------------------------------------------------*/
#include "glsTextureBufferCase.hpp"
#include "tcuFormatUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuStringTemplate.hpp"
#include "tcuSurface.hpp"
#include "tcuTestLog.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuResultCollector.hpp"
#include "rrRenderer.hpp"
#include "rrShaders.hpp"
#include "gluObjectWrapper.hpp"
#include "gluPixelTransfer.hpp"
#include "gluShaderProgram.hpp"
#include "gluShaderUtil.hpp"
#include "gluStrUtil.hpp"
#include "gluTexture.hpp"
#include "gluTextureUtil.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "deRandom.hpp"
#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
#include "deMemory.h"
#include "deString.h"
#include "deMath.h"
#include <sstream>
#include <string>
#include <vector>
using tcu::TestLog;
using std::map;
using std::string;
using std::vector;
using namespace deqp::gls::TextureBufferCaseUtil;
namespace deqp
{
namespace gls
{
namespace
{
enum
{
MAX_VIEWPORT_WIDTH = 256,
MAX_VIEWPORT_HEIGHT = 256,
MIN_VIEWPORT_WIDTH = 64,
MIN_VIEWPORT_HEIGHT = 64,
};
deUint8 extend2BitsToByte (deUint8 bits)
{
DE_ASSERT((bits & (~0x03u)) == 0);
return (deUint8)(bits | (bits << 2) | (bits << 4) | (bits << 6));
}
void genRandomCoords (de::Random rng, vector<deUint8>& coords, size_t offset, size_t size)
{
const deUint8 bits = 2;
const deUint8 bitMask = deUint8((0x1u << bits) - 1);
coords.resize(size);
for (int i = 0; i < (int)size; i++)
{
const deUint8 xBits = deUint8(rng.getUint32() & bitMask);
coords[i] = extend2BitsToByte(xBits);
}
// Fill indices with nice quad
{
const deUint8 indices[] =
{
extend2BitsToByte(0x0u),
extend2BitsToByte(0x1u),
extend2BitsToByte(0x2u),
extend2BitsToByte(0x3u)
};
for (int i = 0; i < DE_LENGTH_OF_ARRAY(indices); i++)
{
const deUint8 index = indices[i];
const size_t posX = (size_t(index) * 2) + 0;
const size_t posY = (size_t(index) * 2) + 1;
if (posX >= offset && posX < offset+size)
coords[posX - offset] = ((i % 2) == 0 ? extend2BitsToByte(0x0u) : extend2BitsToByte(0x3u));
if (posY >= offset && posY < offset+size)
coords[posY - offset] = ((i / 2) == 1 ? extend2BitsToByte(0x3u) : extend2BitsToByte(0x0u));
}
}
// Fill beginning of buffer
{
const deUint8 indices[] =
{
extend2BitsToByte(0x0u),
extend2BitsToByte(0x3u),
extend2BitsToByte(0x1u),
extend2BitsToByte(0x1u),
extend2BitsToByte(0x2u),
extend2BitsToByte(0x0u),
extend2BitsToByte(0x0u),
extend2BitsToByte(0x2u),
extend2BitsToByte(0x1u),
extend2BitsToByte(0x1u),
extend2BitsToByte(0x3u),
extend2BitsToByte(0x0u)
};
for (int i = (int)offset; i < DE_LENGTH_OF_ARRAY(indices) && i < (int)(offset + size); i++)
coords[i-offset] = indices[i];
}
}
class CoordVertexShader : public rr::VertexShader
{
public:
CoordVertexShader (void)
: rr::VertexShader(1, 1)
{
m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
}
void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
{
rr::VertexPacket* const packet = packets[packetNdx];
tcu::Vec4 position;
readVertexAttrib(position, inputs[0], packet->instanceNdx, packet->vertexNdx);
packet->outputs[0] = tcu::Vec4(1.0f);
packet->position = tcu::Vec4(2.0f * (position.x() - 0.5f), 2.0f * (position.y() - 0.5f), 0.0f, 1.0f);
}
}
};
class TextureVertexShader : public rr::VertexShader
{
public:
TextureVertexShader (const tcu::ConstPixelBufferAccess& texture)
: rr::VertexShader (1, 1)
, m_texture (texture)
{
m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
}
void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
{
rr::VertexPacket* const packet = packets[packetNdx];
tcu::Vec4 position;
tcu::Vec4 texelValue;
readVertexAttrib(position, inputs[0], packet->instanceNdx, packet->vertexNdx);
texelValue = tcu::Vec4(m_texture.getPixel(de::clamp<int>((deRoundFloatToInt32(position.x() * 4) + 4) * (deRoundFloatToInt32(position.y() * 4) + 4), 0, m_texture.getWidth()-1), 0));
packet->outputs[0] = texelValue;
packet->position = tcu::Vec4(2.0f * (position.x() - 0.5f), 2.0f * (position.y() - 0.5f), 0.0f, 1.0f);
}
}
private:
const tcu::ConstPixelBufferAccess m_texture;
};
class CoordFragmentShader : public rr::FragmentShader
{
public:
CoordFragmentShader (void)
: rr::FragmentShader (1, 1)
{
m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
}
void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
{
rr::FragmentPacket& packet = packets[packetNdx];
const tcu::Vec4 vtxColor0 = rr::readVarying<float>(packet, context, 0, 0);
const tcu::Vec4 vtxColor1 = rr::readVarying<float>(packet, context, 0, 1);
const tcu::Vec4 vtxColor2 = rr::readVarying<float>(packet, context, 0, 2);
const tcu::Vec4 vtxColor3 = rr::readVarying<float>(packet, context, 0, 3);
const tcu::Vec4 color0 = vtxColor0;
const tcu::Vec4 color1 = vtxColor1;
const tcu::Vec4 color2 = vtxColor2;
const tcu::Vec4 color3 = vtxColor3;
rr::writeFragmentOutput(context, packetNdx, 0, 0, tcu::Vec4(color0.x() * color0.w(), color0.y() * color0.w(), color0.z() * color0.w(), 1.0f));
rr::writeFragmentOutput(context, packetNdx, 1, 0, tcu::Vec4(color1.x() * color1.w(), color1.y() * color1.w(), color1.z() * color1.w(), 1.0f));
rr::writeFragmentOutput(context, packetNdx, 2, 0, tcu::Vec4(color2.x() * color2.w(), color2.y() * color2.w(), color2.z() * color2.w(), 1.0f));
rr::writeFragmentOutput(context, packetNdx, 3, 0, tcu::Vec4(color3.x() * color3.w(), color3.y() * color3.w(), color3.z() * color3.w(), 1.0f));
}
}
};
class TextureFragmentShader : public rr::FragmentShader
{
public:
TextureFragmentShader (const tcu::ConstPixelBufferAccess& texture)
: rr::FragmentShader (1, 1)
, m_texture (texture)
{
m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
}
void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
{
rr::FragmentPacket& packet = packets[packetNdx];
const tcu::IVec2 position0 = packet.position + tcu::IVec2(0, 0);
const tcu::IVec2 position1 = packet.position + tcu::IVec2(1, 0);
const tcu::IVec2 position2 = packet.position + tcu::IVec2(0, 1);
const tcu::IVec2 position3 = packet.position + tcu::IVec2(1, 1);
const tcu::Vec4 texColor0 = m_texture.getPixel(de::clamp((position0.x() * position0.y()), 0, m_texture.getWidth()-1), 0);
const tcu::Vec4 texColor1 = m_texture.getPixel(de::clamp((position1.x() * position1.y()), 0, m_texture.getWidth()-1), 0);
const tcu::Vec4 texColor2 = m_texture.getPixel(de::clamp((position2.x() * position2.y()), 0, m_texture.getWidth()-1), 0);
const tcu::Vec4 texColor3 = m_texture.getPixel(de::clamp((position3.x() * position3.y()), 0, m_texture.getWidth()-1), 0);
const tcu::Vec4 vtxColor0 = rr::readVarying<float>(packet, context, 0, 0);
const tcu::Vec4 vtxColor1 = rr::readVarying<float>(packet, context, 0, 1);
const tcu::Vec4 vtxColor2 = rr::readVarying<float>(packet, context, 0, 2);
const tcu::Vec4 vtxColor3 = rr::readVarying<float>(packet, context, 0, 3);
const tcu::Vec4 color0 = 0.5f * (vtxColor0 + texColor0);
const tcu::Vec4 color1 = 0.5f * (vtxColor1 + texColor1);
const tcu::Vec4 color2 = 0.5f * (vtxColor2 + texColor2);
const tcu::Vec4 color3 = 0.5f * (vtxColor3 + texColor3);
rr::writeFragmentOutput(context, packetNdx, 0, 0, tcu::Vec4(color0.x() * color0.w(), color0.y() * color0.w(), color0.z() * color0.w(), 1.0f));
rr::writeFragmentOutput(context, packetNdx, 1, 0, tcu::Vec4(color1.x() * color1.w(), color1.y() * color1.w(), color1.z() * color1.w(), 1.0f));
rr::writeFragmentOutput(context, packetNdx, 2, 0, tcu::Vec4(color2.x() * color2.w(), color2.y() * color2.w(), color2.z() * color2.w(), 1.0f));
rr::writeFragmentOutput(context, packetNdx, 3, 0, tcu::Vec4(color3.x() * color3.w(), color3.y() * color3.w(), color3.z() * color3.w(), 1.0f));
}
}
private:
const tcu::ConstPixelBufferAccess m_texture;
};
string generateVertexShaderTemplate (RenderBits renderBits)
{
std::ostringstream stream;
stream <<
"${VERSION_HEADER}\n";
if (renderBits & RENDERBITS_AS_VERTEX_TEXTURE)
stream << "${TEXTURE_BUFFER_EXT}";
stream <<
"${VTX_INPUT} layout(location = 0) ${HIGHP} vec2 i_coord;\n"
"${VTX_OUTPUT} ${HIGHP} vec4 v_color;\n";
if (renderBits & RENDERBITS_AS_VERTEX_TEXTURE)
{
stream <<
"uniform ${HIGHP} samplerBuffer u_vtxSampler;\n";
}
stream <<
"\n"
"void main (void)\n"
"{\n";
if (renderBits & RENDERBITS_AS_VERTEX_TEXTURE)
stream << "\tv_color = texelFetch(u_vtxSampler, clamp((int(round(i_coord.x * 4.0)) + 4) * (int(round(i_coord.y * 4.0)) + 4), 0, textureSize(u_vtxSampler)-1));\n";
else
stream << "\tv_color = vec4(1.0);\n";
stream <<
"\tgl_Position = vec4(2.0 * (i_coord - vec2(0.5)), 0.0, 1.0);\n"
"}\n";
return stream.str();
}
string generateFragmentShaderTemplate (RenderBits renderBits)
{
std::ostringstream stream;
stream <<
"${VERSION_HEADER}\n";
if (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE)
stream << "${TEXTURE_BUFFER_EXT}";
stream <<
"${FRAG_OUTPUT} layout(location = 0) ${HIGHP} vec4 dEQP_FragColor;\n"
"${FRAG_INPUT} ${HIGHP} vec4 v_color;\n";
if (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE)
stream << "uniform ${HIGHP} samplerBuffer u_fragSampler;\n";
stream <<
"\n"
"void main (void)\n"
"{\n";
if (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE)
stream << "\t${HIGHP} vec4 color = 0.5 * (v_color + texelFetch(u_fragSampler, clamp(int(gl_FragCoord.x) * int(gl_FragCoord.y), 0, textureSize(u_fragSampler)-1)));\n";
else
stream << "\t${HIGHP} vec4 color = v_color;\n";
stream <<
"\tdEQP_FragColor = vec4(color.xyz * color.w, 1.0);\n"
"}\n";
return stream.str();
}
string specializeShader (const string& shaderTemplateString, glu::GLSLVersion glslVersion)
{
const tcu::StringTemplate shaderTemplate(shaderTemplateString);
map<string, string> parameters;
parameters["VERSION_HEADER"] = glu::getGLSLVersionDeclaration(glslVersion);
parameters["VTX_OUTPUT"] = "out";
parameters["VTX_INPUT"] = "in";
parameters["FRAG_INPUT"] = "in";
parameters["FRAG_OUTPUT"] = "out";
parameters["HIGHP"] = (glslVersion == glu::GLSL_VERSION_330 ? "" : "highp");
parameters["TEXTURE_BUFFER_EXT"] = (glslVersion == glu::GLSL_VERSION_330 ? "" : "#extension GL_EXT_texture_buffer : enable\n");
return shaderTemplate.specialize(parameters);
}
glu::ShaderProgram* createRenderProgram (glu::RenderContext& renderContext,
RenderBits renderBits)
{
const string vertexShaderTemplate = generateVertexShaderTemplate(renderBits);
const string fragmentShaderTemplate = generateFragmentShaderTemplate(renderBits);
const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(renderContext.getType());
const string vertexShaderSource = specializeShader(vertexShaderTemplate, glslVersion);
const string fragmentShaderSource = specializeShader(fragmentShaderTemplate, glslVersion);
glu::ShaderProgram* const program = new glu::ShaderProgram(renderContext, glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
return program;
}
void logModifications (TestLog& log, ModifyBits modifyBits)
{
tcu::ScopedLogSection section(log, "Modify Operations", "Modify Operations");
const struct
{
ModifyBits bit;
const char* str;
} bitInfos[] =
{
{ MODIFYBITS_BUFFERDATA, "Recreate buffer data with glBufferData()." },
{ MODIFYBITS_BUFFERSUBDATA, "Modify texture buffer with glBufferSubData()." },
{ MODIFYBITS_MAPBUFFER_WRITE, "Map buffer write-only and rewrite data." },
{ MODIFYBITS_MAPBUFFER_READWRITE, "Map buffer readw-write check and rewrite data." }
};
DE_ASSERT(modifyBits != 0);
for (int infoNdx = 0; infoNdx < DE_LENGTH_OF_ARRAY(bitInfos); infoNdx++)
{
if (modifyBits & bitInfos[infoNdx].bit)
log << TestLog::Message << bitInfos[infoNdx].str << TestLog::EndMessage;
}
}
void modifyBufferData (TestLog& log,
de::Random& rng,
glu::TextureBuffer& texture)
{
vector<deUint8> data;
genRandomCoords(rng, data, 0, texture.getBufferSize());
log << TestLog::Message << "BufferData, Size: " << data.size() << TestLog::EndMessage;
{
// replace getRefBuffer with a new buffer
de::ArrayBuffer<deUint8> buffer(&(data[0]), data.size());
texture.getRefBuffer().swap(buffer);
}
texture.upload();
}
void modifyBufferSubData (TestLog& log,
de::Random& rng,
const glw::Functions& gl,
glu::TextureBuffer& texture)
{
const size_t minSize = 4*16;
const size_t size = de::max<size_t>(minSize, size_t((float)(texture.getSize() != 0 ? texture.getSize() : texture.getBufferSize()) * (0.7f + 0.3f * rng.getFloat())));
const size_t minOffset = texture.getOffset();
const size_t offset = minOffset + (rng.getUint32() % (texture.getBufferSize() - (size + minOffset)));
vector<deUint8> data;
genRandomCoords(rng, data, offset, size);
log << TestLog::Message << "BufferSubData, Offset: " << offset << ", Size: " << size << TestLog::EndMessage;
gl.bindBuffer(GL_TEXTURE_BUFFER, texture.getGLBuffer());
gl.bufferSubData(GL_TEXTURE_BUFFER, (glw::GLsizei)offset, (glw::GLsizei)data.size(), &(data[0]));
gl.bindBuffer(GL_TEXTURE_BUFFER, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to update data with glBufferSubData()");
deMemcpy((deUint8*)texture.getRefBuffer().getPtr() + offset, &(data[0]), int(data.size()));
}
void modifyMapWrite (TestLog& log,
de::Random& rng,
const glw::Functions& gl,
glu::TextureBuffer& texture)
{
const size_t minSize = 4*16;
const size_t size = de::max<size_t>(minSize, size_t((float)(texture.getSize() != 0 ? texture.getSize() : texture.getBufferSize()) * (0.7f + 0.3f * rng.getFloat())));
const size_t minOffset = texture.getOffset();
const size_t offset = minOffset + (rng.getUint32() % (texture.getBufferSize() - (size + minOffset)));
vector<deUint8> data;
genRandomCoords(rng, data, offset, size);
log << TestLog::Message << "glMapBufferRange, Write Only, Offset: " << offset << ", Size: " << size << TestLog::EndMessage;
gl.bindBuffer(GL_TEXTURE_BUFFER, texture.getGLBuffer());
{
deUint8* ptr = (deUint8*)gl.mapBufferRange(GL_TEXTURE_BUFFER, (glw::GLsizei)offset, (glw::GLsizei)size, GL_MAP_WRITE_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()");
TCU_CHECK(ptr);
for (int i = 0; i < (int)data.size(); i++)
ptr[i] = data[i];
TCU_CHECK(gl.unmapBuffer(GL_TEXTURE_BUFFER));
}
gl.bindBuffer(GL_TEXTURE_BUFFER, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to update data with glMapBufferRange()");
deMemcpy((deUint8*)texture.getRefBuffer().getPtr()+offset, &(data[0]), int(data.size()));
}
void modifyMapReadWrite (TestLog& log,
tcu::ResultCollector& resultCollector,
de::Random& rng,
const glw::Functions& gl,
glu::TextureBuffer& texture)
{
const size_t minSize = 4*16;
const size_t size = de::max<size_t>(minSize, size_t((float)(texture.getSize() != 0 ? texture.getSize() : texture.getBufferSize()) * (0.7f + 0.3f * rng.getFloat())));
const size_t minOffset = texture.getOffset();
const size_t offset = minOffset + (rng.getUint32() % (texture.getBufferSize() - (size + minOffset)));
deUint8* const refPtr = (deUint8*)texture.getRefBuffer().getPtr() + offset;
vector<deUint8> data;
genRandomCoords(rng, data, offset, size);
log << TestLog::Message << "glMapBufferRange, Read Write, Offset: " << offset << ", Size: " << size << TestLog::EndMessage;
gl.bindBuffer(GL_TEXTURE_BUFFER, texture.getGLBuffer());
{
size_t invalidBytes = 0;
deUint8* const ptr = (deUint8*)gl.mapBufferRange(GL_TEXTURE_BUFFER, (glw::GLsizei)offset, (glw::GLsizei)size, GL_MAP_WRITE_BIT|GL_MAP_READ_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()");
TCU_CHECK(ptr);
for (int i = 0; i < (int)data.size(); i++)
{
if (ptr[i] != refPtr[i])
{
if (invalidBytes < 24)
log << TestLog::Message << "Invalid byte in mapped buffer. " << tcu::Format::Hex<2>(data[i]).toString() << " at " << i << ", expected " << tcu::Format::Hex<2>(refPtr[i]).toString() << TestLog::EndMessage;
invalidBytes++;
}
ptr[i] = data[i];
}
TCU_CHECK(gl.unmapBuffer(GL_TEXTURE_BUFFER));
if (invalidBytes > 0)
{
log << TestLog::Message << "Total of " << invalidBytes << " invalid bytes." << TestLog::EndMessage;
resultCollector.fail("Invalid data in mapped buffer");
}
}
gl.bindBuffer(GL_TEXTURE_BUFFER, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to update data with glMapBufferRange()");
for (int i = 0; i < (int)data.size(); i++)
refPtr[i] = data[i];
}
void modify (TestLog& log,
tcu::ResultCollector& resultCollector,
glu::RenderContext& renderContext,
ModifyBits modifyBits,
de::Random& rng,
glu::TextureBuffer& texture)
{
const tcu::ScopedLogSection modifySection(log, "Modifying Texture buffer", "Modifying Texture Buffer");
logModifications(log, modifyBits);
if (modifyBits & MODIFYBITS_BUFFERDATA)
modifyBufferData(log, rng, texture);
if (modifyBits & MODIFYBITS_BUFFERSUBDATA)
modifyBufferSubData(log, rng, renderContext.getFunctions(), texture);
if (modifyBits & MODIFYBITS_MAPBUFFER_WRITE)
modifyMapWrite(log, rng, renderContext.getFunctions(), texture);
if (modifyBits & MODIFYBITS_MAPBUFFER_READWRITE)
modifyMapReadWrite(log, resultCollector, rng, renderContext.getFunctions(), texture);
}
void renderGL (glu::RenderContext& renderContext,
RenderBits renderBits,
deUint32 coordSeed,
int triangleCount,
glu::ShaderProgram& program,
glu::TextureBuffer& texture)
{
const glw::Functions& gl = renderContext.getFunctions();
const glu::VertexArray vao (renderContext);
const glu::Buffer coordBuffer (renderContext);
gl.useProgram(program.getProgram());
gl.bindVertexArray(*vao);
gl.enableVertexAttribArray(0);
if (renderBits & RENDERBITS_AS_VERTEX_ARRAY)
{
gl.bindBuffer(GL_ARRAY_BUFFER, texture.getGLBuffer());
gl.vertexAttribPointer(0, 2, GL_UNSIGNED_BYTE, true, 0, DE_NULL);
}
else
{
de::Random rng(coordSeed);
vector<deUint8> coords;
genRandomCoords(rng, coords, 0, 256*2);
gl.bindBuffer(GL_ARRAY_BUFFER, *coordBuffer);
gl.bufferData(GL_ARRAY_BUFFER, (glw::GLsizei)coords.size(), &(coords[0]), GL_STREAM_DRAW);
gl.vertexAttribPointer(0, 2, GL_UNSIGNED_BYTE, true, 0, DE_NULL);
}
if (renderBits & RENDERBITS_AS_VERTEX_TEXTURE)
{
const deInt32 location = gl.getUniformLocation(program.getProgram(), "u_vtxSampler");
gl.activeTexture(GL_TEXTURE0);
gl.bindTexture(GL_TEXTURE_BUFFER, texture.getGLTexture());
gl.uniform1i(location, 0);
}
if (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE)
{
const deInt32 location = gl.getUniformLocation(program.getProgram(), "u_fragSampler");
gl.activeTexture(GL_TEXTURE1);
gl.bindTexture(GL_TEXTURE_BUFFER, texture.getGLTexture());
gl.uniform1i(location, 1);
gl.activeTexture(GL_TEXTURE0);
}
if (renderBits & RENDERBITS_AS_INDEX_ARRAY)
{
gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, texture.getGLBuffer());
gl.drawElements(GL_TRIANGLES, triangleCount * 3, GL_UNSIGNED_BYTE, DE_NULL);
gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
else
gl.drawArrays(GL_TRIANGLES, 0, triangleCount * 3);
if (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE)
{
gl.activeTexture(GL_TEXTURE1);
gl.bindTexture(GL_TEXTURE_BUFFER, 0);
}
if (renderBits & RENDERBITS_AS_VERTEX_TEXTURE)
{
gl.activeTexture(GL_TEXTURE0);
gl.bindTexture(GL_TEXTURE_BUFFER, 0);
}
gl.bindBuffer(GL_ARRAY_BUFFER, 0);
gl.disableVertexAttribArray(0);
gl.bindVertexArray(0);
gl.useProgram(0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Rendering failed");
}
void renderReference (RenderBits renderBits,
deUint32 coordSeed,
int triangleCount,
const glu::TextureBuffer& texture,
int maxTextureBufferSize,
const tcu::PixelBufferAccess& target)
{
const tcu::ConstPixelBufferAccess effectiveAccess = glu::getTextureBufferEffectiveRefTexture(texture, maxTextureBufferSize);
const CoordVertexShader coordVertexShader;
const TextureVertexShader textureVertexShader (effectiveAccess);
const rr::VertexShader* const vertexShader = (renderBits & RENDERBITS_AS_VERTEX_TEXTURE ? static_cast<const rr::VertexShader*>(&textureVertexShader) : &coordVertexShader);
const CoordFragmentShader coordFragmmentShader;
const TextureFragmentShader textureFragmentShader (effectiveAccess);
const rr::FragmentShader* const fragmentShader = (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE ? static_cast<const rr::FragmentShader*>(&textureFragmentShader) : &coordFragmmentShader);
const rr::Renderer renderer;
const rr::RenderState renderState(rr::ViewportState(rr::WindowRectangle(0, 0, target.getWidth(), target.getHeight())));
const rr::RenderTarget renderTarget(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(target));
const rr::Program program(vertexShader, fragmentShader);
rr::VertexAttrib vertexAttribs[1];
vector<deUint8> coords;
if (renderBits & RENDERBITS_AS_VERTEX_ARRAY)
{
vertexAttribs[0].type = rr::VERTEXATTRIBTYPE_NONPURE_UNORM8;
vertexAttribs[0].size = 2;
vertexAttribs[0].pointer = texture.getRefBuffer().getPtr();
}
else
{
de::Random rng(coordSeed);
genRandomCoords(rng, coords, 0, 256*2);
vertexAttribs[0].type = rr::VERTEXATTRIBTYPE_NONPURE_UNORM8;
vertexAttribs[0].size = 2;
vertexAttribs[0].pointer = &(coords[0]);
}
if (renderBits & RENDERBITS_AS_INDEX_ARRAY)
{
const rr::PrimitiveList primitives(rr::PRIMITIVETYPE_TRIANGLES, triangleCount * 3, rr::DrawIndices(texture.getRefBuffer().getPtr(), rr::INDEXTYPE_UINT8));
const rr::DrawCommand cmd(renderState, renderTarget, program, 1, vertexAttribs, primitives);
renderer.draw(cmd);
}
else
{
const rr::PrimitiveList primitives(rr::PRIMITIVETYPE_TRIANGLES, triangleCount * 3, 0);
const rr::DrawCommand cmd(renderState, renderTarget, program, 1, vertexAttribs, primitives);
renderer.draw(cmd);
}
}
void logRendering (TestLog& log, RenderBits renderBits)
{
const struct
{
RenderBits bit;
const char* str;
} bitInfos[] =
{
{ RENDERBITS_AS_VERTEX_ARRAY, "vertex array" },
{ RENDERBITS_AS_INDEX_ARRAY, "index array" },
{ RENDERBITS_AS_VERTEX_TEXTURE, "vertex texture" },
{ RENDERBITS_AS_FRAGMENT_TEXTURE, "fragment texture" }
};
std::ostringstream stream;
vector<const char*> usedAs;
DE_ASSERT(renderBits != 0);
for (int infoNdx = 0; infoNdx < DE_LENGTH_OF_ARRAY(bitInfos); infoNdx++)
{
if (renderBits & bitInfos[infoNdx].bit)
usedAs.push_back(bitInfos[infoNdx].str);
}
stream << "Render using texture buffer as ";
for (int asNdx = 0; asNdx < (int)usedAs.size(); asNdx++)
{
if (asNdx+1 == (int)usedAs.size() && (int)usedAs.size() > 1)
stream << " and ";
else if (asNdx > 0)
stream << ", ";
stream << usedAs[asNdx];
}
stream << ".";
log << TestLog::Message << stream.str() << TestLog::EndMessage;
}
void render (TestLog& log,
glu::RenderContext& renderContext,
RenderBits renderBits,
de::Random& rng,
glu::ShaderProgram& program,
glu::TextureBuffer& texture,
const tcu::PixelBufferAccess& target)
{
const tcu::ScopedLogSection renderSection (log, "Render Texture buffer", "Render Texture Buffer");
const int triangleCount = 8;
const deUint32 coordSeed = rng.getUint32();
int maxTextureBufferSize = 0;
renderContext.getFunctions().getIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &maxTextureBufferSize);
GLU_EXPECT_NO_ERROR(renderContext.getFunctions().getError(), "query GL_MAX_TEXTURE_BUFFER_SIZE");
DE_ASSERT(maxTextureBufferSize > 0); // checked in init()
logRendering(log, renderBits);
renderGL(renderContext, renderBits, coordSeed, triangleCount, program, texture);
renderReference(renderBits, coordSeed, triangleCount, texture, maxTextureBufferSize, target);
}
void verifyScreen (TestLog& log,
tcu::ResultCollector& resultCollector,
glu::RenderContext& renderContext,
const tcu::ConstPixelBufferAccess& referenceTarget)
{
const tcu::ScopedLogSection verifySection (log, "Verify screen contents", "Verify screen contents");
tcu::Surface screen (referenceTarget.getWidth(), referenceTarget.getHeight());
glu::readPixels(renderContext, 0, 0, screen.getAccess());
if (!tcu::fuzzyCompare(log, "Result of rendering", "Result of rendering", referenceTarget, screen.getAccess(), 0.05f, tcu::COMPARE_LOG_RESULT))
resultCollector.fail("Rendering failed");
}
void logImplementationInfo (TestLog& log, glu::RenderContext& renderContext)
{
const tcu::ScopedLogSection section (log, "Implementation Values", "Implementation Values");
de::UniquePtr<glu::ContextInfo> info (glu::ContextInfo::create(renderContext));
const glw::Functions& gl = renderContext.getFunctions();
if (glu::contextSupports(renderContext.getType(), glu::ApiType(3, 3, glu::PROFILE_CORE)))
{
deInt32 maxTextureSize = 0;
gl.getIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &maxTextureSize);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE)");
log << TestLog::Message << "GL_MAX_TEXTURE_BUFFER_SIZE : " << maxTextureSize << TestLog::EndMessage;
}
else if (glu::contextSupports(renderContext.getType(), glu::ApiType(3, 1, glu::PROFILE_ES)) && info->isExtensionSupported("GL_EXT_texture_buffer"))
{
{
deInt32 maxTextureSize = 0;
gl.getIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &maxTextureSize);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE_EXT)");
log << TestLog::Message << "GL_MAX_TEXTURE_BUFFER_SIZE_EXT : " << maxTextureSize << TestLog::EndMessage;
}
{
deInt32 textureBufferAlignment = 0;
gl.getIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, &textureBufferAlignment);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT)");
log << TestLog::Message << "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT : " << textureBufferAlignment << TestLog::EndMessage;
}
}
else
DE_ASSERT(DE_FALSE);
}
void logTextureInfo (TestLog& log,
deUint32 format,
size_t bufferSize,
size_t offset,
size_t size)
{
const tcu::ScopedLogSection section(log, "Texture Info", "Texture Info");
log << TestLog::Message << "Texture format : " << glu::getTextureFormatStr(format) << TestLog::EndMessage;
log << TestLog::Message << "Buffer size : " << bufferSize << TestLog::EndMessage;
if (offset != 0 || size != 0)
{
log << TestLog::Message << "Buffer range offset: " << offset << TestLog::EndMessage;
log << TestLog::Message << "Buffer range size: " << size << TestLog::EndMessage;
}
}
void runTests (tcu::TestContext& testCtx,
glu::RenderContext& renderContext,
de::Random& rng,
deUint32 format,
size_t bufferSize,
size_t offset,
size_t size,
RenderBits preRender,
glu::ShaderProgram* preRenderProgram,
ModifyBits modifyType,
RenderBits postRender,
glu::ShaderProgram* postRenderProgram)
{
const tcu::RenderTarget renderTarget (renderContext.getRenderTarget());
const glw::Functions& gl = renderContext.getFunctions();
const int width = de::min<int>(renderTarget.getWidth(), MAX_VIEWPORT_WIDTH);
const int height = de::min<int>(renderTarget.getHeight(), MAX_VIEWPORT_HEIGHT);
const tcu::Vec4 clearColor (0.25f, 0.5f, 0.75f, 1.0f);
TestLog& log = testCtx.getLog();
tcu::ResultCollector resultCollector (log);
logImplementationInfo(log, renderContext);
logTextureInfo(log, format, bufferSize, offset, size);
{
tcu::Surface referenceTarget (width, height);
vector<deUint8> bufferData;
genRandomCoords(rng, bufferData, 0, bufferSize);
for (deUint8 i = 0; i < 4; i++)
{
const deUint8 val = extend2BitsToByte(i);
if (val >= offset && val < offset + size)
{
bufferData[val*2 + 0] = (i / 2 == 0 ? extend2BitsToByte(0x2u) : extend2BitsToByte(0x01u));
bufferData[val*2 + 1] = (i % 2 == 0 ? extend2BitsToByte(0x2u) : extend2BitsToByte(0x01u));
}
}
{
glu::TextureBuffer texture (renderContext, format, bufferSize, offset, size, &(bufferData[0]));
TCU_CHECK_MSG(width >= MIN_VIEWPORT_WIDTH || height >= MIN_VIEWPORT_HEIGHT, "Too small viewport");
DE_ASSERT(preRender == 0 || preRenderProgram);
DE_ASSERT(postRender == 0 || postRenderProgram);
gl.viewport(0, 0, width, height);
gl.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "Screen setup failed");
tcu::clear(referenceTarget.getAccess(), clearColor);
texture.upload();
if (preRender != 0)
render(log, renderContext, preRender, rng, *preRenderProgram, texture, referenceTarget.getAccess());
if (modifyType != 0)
modify(log, resultCollector, renderContext, modifyType, rng, texture);
if (postRender != 0)
render(log, renderContext, postRender, rng, *postRenderProgram, texture, referenceTarget.getAccess());
}
verifyScreen(log, resultCollector, renderContext, referenceTarget.getAccess());
resultCollector.setTestContextResult(testCtx);
}
}
} // anonymous
TextureBufferCase::TextureBufferCase (tcu::TestContext& testCtx,
glu::RenderContext& renderCtx,
deUint32 format,
size_t bufferSize,
size_t offset,
size_t size,
RenderBits preRender,
ModifyBits modify,
RenderBits postRender,
const char* name,
const char* description)
: tcu::TestCase (testCtx, name, description)
, m_renderCtx (renderCtx)
, m_format (format)
, m_bufferSize (bufferSize)
, m_offset (offset)
, m_size (size)
, m_preRender (preRender)
, m_modify (modify)
, m_postRender (postRender)
, m_preRenderProgram (DE_NULL)
, m_postRenderProgram (DE_NULL)
{
}
TextureBufferCase::~TextureBufferCase (void)
{
TextureBufferCase::deinit();
}
void TextureBufferCase::init (void)
{
de::UniquePtr<glu::ContextInfo> info (glu::ContextInfo::create(m_renderCtx));
if (!glu::contextSupports(m_renderCtx.getType(), glu::ApiType(3, 3, glu::PROFILE_CORE))
&& !(glu::contextSupports(m_renderCtx.getType(), glu::ApiType(3, 1, glu::PROFILE_ES)) && info->isExtensionSupported("GL_EXT_texture_buffer")))
throw tcu::NotSupportedError("Texture buffers not supported", "", __FILE__, __LINE__);
{
const int maxTextureBufferSize = info->getInt(GL_MAX_TEXTURE_BUFFER_SIZE);
if (maxTextureBufferSize <= 0)
TCU_THROW(NotSupportedError, "GL_MAX_TEXTURE_BUFFER_SIZE > 0 required");
}
if (m_preRender != 0)
{
TestLog& log = m_testCtx.getLog();
const char* const sectionName = (m_postRender != 0 ? "Primary render program" : "Render program");
const tcu::ScopedLogSection section (log, sectionName, sectionName);
m_preRenderProgram = createRenderProgram(m_renderCtx, m_preRender);
m_testCtx.getLog() << (*m_preRenderProgram);
TCU_CHECK(m_preRenderProgram->isOk());
}
if (m_postRender != 0)
{
// Reusing program
if (m_preRender == m_postRender)
{
m_postRenderProgram = m_preRenderProgram;
}
else
{
TestLog& log = m_testCtx.getLog();
const char* const sectionName = (m_preRender!= 0 ? "Secondary render program" : "Render program");
const tcu::ScopedLogSection section (log, sectionName, sectionName);
m_postRenderProgram = createRenderProgram(m_renderCtx, m_postRender);
m_testCtx.getLog() << (*m_postRenderProgram);
TCU_CHECK(m_postRenderProgram->isOk());
}
}
}
void TextureBufferCase::deinit (void)
{
if (m_preRenderProgram == m_postRenderProgram)
m_postRenderProgram = DE_NULL;
delete m_preRenderProgram;
m_preRenderProgram = DE_NULL;
delete m_postRenderProgram;
m_postRenderProgram = DE_NULL;
}
tcu::TestCase::IterateResult TextureBufferCase::iterate (void)
{
de::Random rng (deInt32Hash(deStringHash(getName())));
size_t offset;
if (m_offset != 0)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
deInt32 alignment = 0;
gl.getIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, &alignment);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT)");
offset = m_offset * alignment;
}
else
offset = 0;
runTests(m_testCtx, m_renderCtx, rng, m_format, m_bufferSize, offset, m_size, m_preRender, m_preRenderProgram, m_modify, m_postRender, m_postRenderProgram);
return STOP;
}
} // gls
} // deqp