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.
722 lines
25 KiB
722 lines
25 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 Instanced rendering tests.
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "es3fInstancedRenderingTests.hpp"
|
|
#include "gluPixelTransfer.hpp"
|
|
#include "gluShaderProgram.hpp"
|
|
#include "gluShaderUtil.hpp"
|
|
#include "tcuTestLog.hpp"
|
|
#include "tcuSurface.hpp"
|
|
#include "tcuImageCompare.hpp"
|
|
#include "tcuVector.hpp"
|
|
#include "tcuRenderTarget.hpp"
|
|
#include "deRandom.hpp"
|
|
#include "deStringUtil.hpp"
|
|
#include "deString.h"
|
|
|
|
#include "glw.h"
|
|
|
|
using std::vector;
|
|
using std::string;
|
|
|
|
namespace deqp
|
|
{
|
|
namespace gles3
|
|
{
|
|
namespace Functional
|
|
{
|
|
|
|
static const int MAX_RENDER_WIDTH = 128;
|
|
static const int MAX_RENDER_HEIGHT = 128;
|
|
|
|
static const int QUAD_GRID_SIZE = 127;
|
|
|
|
// Attribute divisors for the attributes defining the color's RGB components.
|
|
static const int ATTRIB_DIVISOR_R = 3;
|
|
static const int ATTRIB_DIVISOR_G = 2;
|
|
static const int ATTRIB_DIVISOR_B = 1;
|
|
|
|
static const int OFFSET_COMPONENTS = 3; // \note Affects whether a float or a vecN is used in shader, but only first component is non-zero.
|
|
|
|
// Scale and bias values when converting float to integer, when attribute is of integer type.
|
|
static const float FLOAT_INT_SCALE = 100.0f;
|
|
static const float FLOAT_INT_BIAS = -50.0f;
|
|
static const float FLOAT_UINT_SCALE = 100.0f;
|
|
static const float FLOAT_UINT_BIAS = 0.0f;
|
|
|
|
// \note Non-anonymous namespace needed; VarComp is used as a template parameter.
|
|
namespace vcns
|
|
{
|
|
|
|
union VarComp
|
|
{
|
|
float f32;
|
|
deUint32 u32;
|
|
deInt32 i32;
|
|
|
|
VarComp(float v) : f32(v) {}
|
|
VarComp(deUint32 v) : u32(v) {}
|
|
VarComp(deInt32 v) : i32(v) {}
|
|
};
|
|
DE_STATIC_ASSERT(sizeof(VarComp) == sizeof(deUint32));
|
|
|
|
} // vcns
|
|
|
|
using namespace vcns;
|
|
|
|
class InstancedRenderingCase : public TestCase
|
|
{
|
|
public:
|
|
enum DrawFunction
|
|
{
|
|
FUNCTION_DRAW_ARRAYS_INSTANCED = 0,
|
|
FUNCTION_DRAW_ELEMENTS_INSTANCED,
|
|
|
|
FUNCTION_LAST
|
|
};
|
|
|
|
enum InstancingType
|
|
{
|
|
TYPE_INSTANCE_ID = 0,
|
|
TYPE_ATTRIB_DIVISOR,
|
|
TYPE_MIXED,
|
|
|
|
TYPE_LAST
|
|
};
|
|
|
|
InstancedRenderingCase (Context& context, const char* name, const char* description, DrawFunction function, InstancingType instancingType, glu::DataType rgbAttrType, int numInstances);
|
|
~InstancedRenderingCase (void);
|
|
|
|
void init (void);
|
|
void deinit (void);
|
|
IterateResult iterate (void);
|
|
|
|
private:
|
|
InstancedRenderingCase (const InstancedRenderingCase& other);
|
|
InstancedRenderingCase& operator= (const InstancedRenderingCase& other);
|
|
|
|
void pushVarCompAttrib (vector<VarComp>& vec, float val);
|
|
|
|
void setupVarAttribPointer (const void* attrPtr, int startLocation, int divisor);
|
|
void setupAndRender (void);
|
|
void computeReference (tcu::Surface& dst);
|
|
|
|
DrawFunction m_function;
|
|
InstancingType m_instancingType;
|
|
glu::DataType m_rgbAttrType; // \note Instance attribute types, color components only. Position offset attribute is always float/vecN.
|
|
int m_numInstances;
|
|
|
|
vector<float> m_gridVertexPositions; // X and Y components per vertex.
|
|
vector<deUint16> m_gridIndices; // \note Only used if m_function is FUNCTION_DRAW_ELEMENTS_INSTANCED.
|
|
|
|
// \note Some or all of the following instance attribute parameters may be unused with TYPE_INSTANCE_ID or TYPE_MIXED.
|
|
vector<float> m_instanceOffsets; // Position offsets. OFFSET_COMPONENTS components per offset.
|
|
// Attribute data for float, int or uint (or respective vector types) color components.
|
|
vector<VarComp> m_instanceColorR;
|
|
vector<VarComp> m_instanceColorG;
|
|
vector<VarComp> m_instanceColorB;
|
|
|
|
glu::ShaderProgram* m_program;
|
|
};
|
|
|
|
InstancedRenderingCase::InstancedRenderingCase (Context& context, const char* name, const char* description, DrawFunction function, InstancingType instancingType, glu::DataType rgbAttrType, int numInstances)
|
|
: TestCase (context, name, description)
|
|
, m_function (function)
|
|
, m_instancingType (instancingType)
|
|
, m_rgbAttrType (rgbAttrType)
|
|
, m_numInstances (numInstances)
|
|
, m_program (DE_NULL)
|
|
{
|
|
}
|
|
|
|
InstancedRenderingCase::~InstancedRenderingCase (void)
|
|
{
|
|
InstancedRenderingCase::deinit();
|
|
}
|
|
|
|
// Helper function that does biasing and scaling when converting float to integer.
|
|
void InstancedRenderingCase::pushVarCompAttrib (vector<VarComp>& vec, float val)
|
|
{
|
|
bool isFloatCase = glu::isDataTypeFloatOrVec(m_rgbAttrType);
|
|
bool isIntCase = glu::isDataTypeIntOrIVec(m_rgbAttrType);
|
|
bool isUintCase = glu::isDataTypeUintOrUVec(m_rgbAttrType);
|
|
bool isMatCase = glu::isDataTypeMatrix(m_rgbAttrType);
|
|
|
|
if (isFloatCase || isMatCase)
|
|
vec.push_back(VarComp(val));
|
|
else if (isIntCase)
|
|
vec.push_back(VarComp((deInt32)(val*FLOAT_INT_SCALE + FLOAT_INT_BIAS)));
|
|
else if (isUintCase)
|
|
vec.push_back(VarComp((deUint32)(val*FLOAT_UINT_SCALE + FLOAT_UINT_BIAS)));
|
|
else
|
|
DE_ASSERT(DE_FALSE);
|
|
}
|
|
|
|
void InstancedRenderingCase::init (void)
|
|
{
|
|
bool isFloatCase = glu::isDataTypeFloatOrVec(m_rgbAttrType);
|
|
bool isIntCase = glu::isDataTypeIntOrIVec(m_rgbAttrType);
|
|
bool isUintCase = glu::isDataTypeUintOrUVec(m_rgbAttrType);
|
|
bool isMatCase = glu::isDataTypeMatrix(m_rgbAttrType);
|
|
int typeSize = glu::getDataTypeScalarSize(m_rgbAttrType);
|
|
bool isScalarCase = typeSize == 1;
|
|
string swizzleFirst = isScalarCase ? "" : ".x";
|
|
string typeName = glu::getDataTypeName(m_rgbAttrType);
|
|
|
|
string floatIntScaleStr = "(" + de::floatToString(FLOAT_INT_SCALE, 3) + ")";
|
|
string floatIntBiasStr = "(" + de::floatToString(FLOAT_INT_BIAS, 3) + ")";
|
|
string floatUintScaleStr = "(" + de::floatToString(FLOAT_UINT_SCALE, 3) + ")";
|
|
string floatUintBiasStr = "(" + de::floatToString(FLOAT_UINT_BIAS, 3) + ")";
|
|
|
|
DE_ASSERT(isFloatCase || isIntCase || isUintCase || isMatCase);
|
|
|
|
// Generate shader.
|
|
// \note For case TYPE_MIXED, vertex position offset and color red component get their values from instance id, while green and blue get their values from instanced attributes.
|
|
|
|
string numInstancesStr = de::toString(m_numInstances) + ".0";
|
|
|
|
string instanceAttribs;
|
|
string posExpression;
|
|
string colorRExpression;
|
|
string colorGExpression;
|
|
string colorBExpression;
|
|
|
|
if (m_instancingType == TYPE_INSTANCE_ID || m_instancingType == TYPE_MIXED)
|
|
{
|
|
posExpression = "a_position + vec4(float(gl_InstanceID) * 2.0 / " + numInstancesStr + ", 0.0, 0.0, 0.0)";
|
|
colorRExpression = "float(gl_InstanceID)/" + numInstancesStr;
|
|
|
|
if (m_instancingType == TYPE_INSTANCE_ID)
|
|
{
|
|
colorGExpression = "float(gl_InstanceID)*2.0/" + numInstancesStr;
|
|
colorBExpression = "1.0 - float(gl_InstanceID)/" + numInstancesStr;
|
|
}
|
|
}
|
|
|
|
if (m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED)
|
|
{
|
|
if (m_instancingType == TYPE_ATTRIB_DIVISOR)
|
|
{
|
|
posExpression = "a_position + vec4(a_instanceOffset";
|
|
|
|
DE_STATIC_ASSERT(OFFSET_COMPONENTS >= 1 && OFFSET_COMPONENTS <= 4);
|
|
|
|
for (int i = 0; i < 4-OFFSET_COMPONENTS; i++)
|
|
posExpression += ", 0.0";
|
|
posExpression += ")";
|
|
|
|
if (isFloatCase)
|
|
colorRExpression = "a_instanceR" + swizzleFirst;
|
|
else if (isIntCase)
|
|
colorRExpression = "(float(a_instanceR" + swizzleFirst + ") - " + floatIntBiasStr + ") / " + floatIntScaleStr;
|
|
else if (isUintCase)
|
|
colorRExpression = "(float(a_instanceR" + swizzleFirst + ") - " + floatUintBiasStr + ") / " + floatUintScaleStr;
|
|
else if (isMatCase)
|
|
colorRExpression = "a_instanceR[0][0]";
|
|
else
|
|
DE_ASSERT(DE_FALSE);
|
|
|
|
instanceAttribs += "in highp " + (OFFSET_COMPONENTS == 1 ? string("float") : "vec" + de::toString(OFFSET_COMPONENTS)) + " a_instanceOffset;\n";
|
|
instanceAttribs += "in mediump " + typeName + " a_instanceR;\n";
|
|
}
|
|
|
|
if (isFloatCase)
|
|
{
|
|
colorGExpression = "a_instanceG" + swizzleFirst;
|
|
colorBExpression = "a_instanceB" + swizzleFirst;
|
|
}
|
|
else if (isIntCase)
|
|
{
|
|
colorGExpression = "(float(a_instanceG" + swizzleFirst + ") - " + floatIntBiasStr + ") / " + floatIntScaleStr;
|
|
colorBExpression = "(float(a_instanceB" + swizzleFirst + ") - " + floatIntBiasStr + ") / " + floatIntScaleStr;
|
|
}
|
|
else if (isUintCase)
|
|
{
|
|
colorGExpression = "(float(a_instanceG" + swizzleFirst + ") - " + floatUintBiasStr + ") / " + floatUintScaleStr;
|
|
colorBExpression = "(float(a_instanceB" + swizzleFirst + ") - " + floatUintBiasStr + ") / " + floatUintScaleStr;
|
|
}
|
|
else if (isMatCase)
|
|
{
|
|
colorGExpression = "a_instanceG[0][0]";
|
|
colorBExpression = "a_instanceB[0][0]";
|
|
}
|
|
else
|
|
DE_ASSERT(DE_FALSE);
|
|
|
|
instanceAttribs += "in mediump " + typeName + " a_instanceG;\n";
|
|
instanceAttribs += "in mediump " + typeName + " a_instanceB;\n";
|
|
}
|
|
|
|
DE_ASSERT(!posExpression.empty());
|
|
DE_ASSERT(!colorRExpression.empty());
|
|
DE_ASSERT(!colorGExpression.empty());
|
|
DE_ASSERT(!colorBExpression.empty());
|
|
|
|
std::string vertShaderSourceStr =
|
|
"#version 300 es\n"
|
|
"in highp vec4 a_position;\n" +
|
|
instanceAttribs +
|
|
"out mediump vec4 v_color;\n"
|
|
"\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" gl_Position = " + posExpression + ";\n"
|
|
" v_color.r = " + colorRExpression + ";\n"
|
|
" v_color.g = " + colorGExpression + ";\n"
|
|
" v_color.b = " + colorBExpression + ";\n"
|
|
" v_color.a = 1.0;\n"
|
|
"}\n";
|
|
|
|
static const char* fragShaderSource =
|
|
"#version 300 es\n"
|
|
"layout(location = 0) out mediump vec4 o_color;\n"
|
|
"in mediump vec4 v_color;\n"
|
|
"\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" o_color = v_color;\n"
|
|
"}\n";
|
|
|
|
// Create shader program and log it.
|
|
|
|
DE_ASSERT(!m_program);
|
|
m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(vertShaderSourceStr, fragShaderSource));
|
|
|
|
tcu::TestLog& log = m_testCtx.getLog();
|
|
|
|
log << *m_program;
|
|
|
|
if(!m_program->isOk())
|
|
TCU_FAIL("Failed to compile shader");
|
|
|
|
// Vertex shader attributes.
|
|
|
|
if (m_function == FUNCTION_DRAW_ELEMENTS_INSTANCED)
|
|
{
|
|
// Vertex positions. Positions form a vertical bar of width <screen width>/<number of instances>.
|
|
|
|
for (int y = 0; y < QUAD_GRID_SIZE + 1; y++)
|
|
for (int x = 0; x < QUAD_GRID_SIZE + 1; x++)
|
|
{
|
|
float fx = -1.0f + (float)x / (float)QUAD_GRID_SIZE * 2.0f / (float)m_numInstances;
|
|
float fy = -1.0f + (float)y / (float)QUAD_GRID_SIZE * 2.0f;
|
|
|
|
m_gridVertexPositions.push_back(fx);
|
|
m_gridVertexPositions.push_back(fy);
|
|
}
|
|
|
|
// Indices.
|
|
|
|
for (int y = 0; y < QUAD_GRID_SIZE; y++)
|
|
for (int x = 0; x < QUAD_GRID_SIZE; x++)
|
|
{
|
|
int ndx00 = y*(QUAD_GRID_SIZE + 1) + x;
|
|
int ndx10 = y*(QUAD_GRID_SIZE + 1) + x + 1;
|
|
int ndx01 = (y + 1)*(QUAD_GRID_SIZE + 1) + x;
|
|
int ndx11 = (y + 1)*(QUAD_GRID_SIZE + 1) + x + 1;
|
|
|
|
// Lower-left triangle of a quad.
|
|
m_gridIndices.push_back((deUint16)ndx00);
|
|
m_gridIndices.push_back((deUint16)ndx10);
|
|
m_gridIndices.push_back((deUint16)ndx01);
|
|
|
|
// Upper-right triangle of a quad.
|
|
m_gridIndices.push_back((deUint16)ndx11);
|
|
m_gridIndices.push_back((deUint16)ndx01);
|
|
m_gridIndices.push_back((deUint16)ndx10);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DE_ASSERT(m_function == FUNCTION_DRAW_ARRAYS_INSTANCED);
|
|
|
|
// Vertex positions. Positions form a vertical bar of width <screen width>/<number of instances>.
|
|
|
|
for (int y = 0; y < QUAD_GRID_SIZE; y++)
|
|
for (int x = 0; x < QUAD_GRID_SIZE; x++)
|
|
{
|
|
float fx0 = -1.0f + (float)(x+0) / (float)QUAD_GRID_SIZE * 2.0f / (float)m_numInstances;
|
|
float fx1 = -1.0f + (float)(x+1) / (float)QUAD_GRID_SIZE * 2.0f / (float)m_numInstances;
|
|
float fy0 = -1.0f + (float)(y+0) / (float)QUAD_GRID_SIZE * 2.0f;
|
|
float fy1 = -1.0f + (float)(y+1) / (float)QUAD_GRID_SIZE * 2.0f;
|
|
|
|
// Vertices of a quad's lower-left triangle: (fx0, fy0), (fx1, fy0) and (fx0, fy1)
|
|
m_gridVertexPositions.push_back(fx0);
|
|
m_gridVertexPositions.push_back(fy0);
|
|
m_gridVertexPositions.push_back(fx1);
|
|
m_gridVertexPositions.push_back(fy0);
|
|
m_gridVertexPositions.push_back(fx0);
|
|
m_gridVertexPositions.push_back(fy1);
|
|
|
|
// Vertices of a quad's upper-right triangle: (fx1, fy1), (fx0, fy1) and (fx1, fy0)
|
|
m_gridVertexPositions.push_back(fx1);
|
|
m_gridVertexPositions.push_back(fy1);
|
|
m_gridVertexPositions.push_back(fx0);
|
|
m_gridVertexPositions.push_back(fy1);
|
|
m_gridVertexPositions.push_back(fx1);
|
|
m_gridVertexPositions.push_back(fy0);
|
|
}
|
|
}
|
|
|
|
// Instanced attributes: position offset and color RGB components.
|
|
|
|
if (m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED)
|
|
{
|
|
if (m_instancingType == TYPE_ATTRIB_DIVISOR)
|
|
{
|
|
// Offsets are such that the vertical bars are drawn next to each other.
|
|
for (int i = 0; i < m_numInstances; i++)
|
|
{
|
|
m_instanceOffsets.push_back((float)i * 2.0f / (float)m_numInstances);
|
|
|
|
DE_STATIC_ASSERT(OFFSET_COMPONENTS >= 1 && OFFSET_COMPONENTS <= 4);
|
|
|
|
for (int j = 0; j < OFFSET_COMPONENTS-1; j++)
|
|
m_instanceOffsets.push_back(0.0f);
|
|
}
|
|
|
|
int rInstances = m_numInstances / ATTRIB_DIVISOR_R + (m_numInstances % ATTRIB_DIVISOR_R == 0 ? 0 : 1);
|
|
for (int i = 0; i < rInstances; i++)
|
|
{
|
|
pushVarCompAttrib(m_instanceColorR, (float)i / (float)rInstances);
|
|
|
|
for (int j = 0; j < typeSize - 1; j++)
|
|
pushVarCompAttrib(m_instanceColorR, 0.0f);
|
|
}
|
|
}
|
|
|
|
int gInstances = m_numInstances / ATTRIB_DIVISOR_G + (m_numInstances % ATTRIB_DIVISOR_G == 0 ? 0 : 1);
|
|
for (int i = 0; i < gInstances; i++)
|
|
{
|
|
pushVarCompAttrib(m_instanceColorG, (float)i*2.0f / (float)gInstances);
|
|
|
|
for (int j = 0; j < typeSize - 1; j++)
|
|
pushVarCompAttrib(m_instanceColorG, 0.0f);
|
|
}
|
|
|
|
int bInstances = m_numInstances / ATTRIB_DIVISOR_B + (m_numInstances % ATTRIB_DIVISOR_B == 0 ? 0 : 1);
|
|
for (int i = 0; i < bInstances; i++)
|
|
{
|
|
pushVarCompAttrib(m_instanceColorB, 1.0f - (float)i / (float)bInstances);
|
|
|
|
for (int j = 0; j < typeSize - 1; j++)
|
|
pushVarCompAttrib(m_instanceColorB, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
void InstancedRenderingCase::deinit (void)
|
|
{
|
|
delete m_program;
|
|
m_program = DE_NULL;
|
|
}
|
|
|
|
InstancedRenderingCase::IterateResult InstancedRenderingCase::iterate (void)
|
|
{
|
|
int width = deMin32(m_context.getRenderTarget().getWidth(), MAX_RENDER_WIDTH);
|
|
int height = deMin32(m_context.getRenderTarget().getHeight(), MAX_RENDER_HEIGHT);
|
|
|
|
int xOffsetMax = m_context.getRenderTarget().getWidth() - width;
|
|
int yOffsetMax = m_context.getRenderTarget().getHeight() - height;
|
|
|
|
de::Random rnd (deStringHash(getName()));
|
|
|
|
int xOffset = rnd.getInt(0, xOffsetMax);
|
|
int yOffset = rnd.getInt(0, yOffsetMax);
|
|
tcu::Surface referenceImg (width, height);
|
|
tcu::Surface resultImg (width, height);
|
|
|
|
// Draw result.
|
|
|
|
glViewport(xOffset, yOffset, width, height);
|
|
|
|
setupAndRender();
|
|
|
|
glu::readPixels(m_context.getRenderContext(), xOffset, yOffset, resultImg.getAccess());
|
|
|
|
// Compute reference.
|
|
|
|
computeReference(referenceImg);
|
|
|
|
// Compare.
|
|
|
|
bool testOk = tcu::fuzzyCompare(m_testCtx.getLog(), "ComparisonResult", "Image comparison result", referenceImg, resultImg, 0.05f, tcu::COMPARE_LOG_RESULT);
|
|
|
|
m_testCtx.setTestResult(testOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
|
|
testOk ? "Pass" : "Fail");
|
|
|
|
return STOP;
|
|
}
|
|
|
|
void InstancedRenderingCase::setupVarAttribPointer (const void* attrPtr, int location, int divisor)
|
|
{
|
|
bool isFloatCase = glu::isDataTypeFloatOrVec(m_rgbAttrType);
|
|
bool isIntCase = glu::isDataTypeIntOrIVec(m_rgbAttrType);
|
|
bool isUintCase = glu::isDataTypeUintOrUVec(m_rgbAttrType);
|
|
bool isMatCase = glu::isDataTypeMatrix(m_rgbAttrType);
|
|
int typeSize = glu::getDataTypeScalarSize(m_rgbAttrType);
|
|
int numSlots = isMatCase ? glu::getDataTypeMatrixNumColumns(m_rgbAttrType) : 1; // Matrix uses as many attribute slots as it has columns.
|
|
|
|
for (int slotNdx = 0; slotNdx < numSlots; slotNdx++)
|
|
{
|
|
int curLoc = location + slotNdx;
|
|
|
|
glEnableVertexAttribArray(curLoc);
|
|
glVertexAttribDivisor(curLoc, divisor);
|
|
|
|
if (isFloatCase)
|
|
glVertexAttribPointer(curLoc, typeSize, GL_FLOAT, GL_FALSE, 0, attrPtr);
|
|
else if (isIntCase)
|
|
glVertexAttribIPointer(curLoc, typeSize, GL_INT, 0, attrPtr);
|
|
else if (isUintCase)
|
|
glVertexAttribIPointer(curLoc, typeSize, GL_UNSIGNED_INT, 0, attrPtr);
|
|
else if (isMatCase)
|
|
{
|
|
int numRows = glu::getDataTypeMatrixNumRows(m_rgbAttrType);
|
|
int numCols = glu::getDataTypeMatrixNumColumns(m_rgbAttrType);
|
|
|
|
glVertexAttribPointer(curLoc, numRows, GL_FLOAT, GL_FALSE, numCols*numRows*(int)sizeof(float), attrPtr);
|
|
}
|
|
else
|
|
DE_ASSERT(DE_FALSE);
|
|
}
|
|
}
|
|
|
|
void InstancedRenderingCase::setupAndRender (void)
|
|
{
|
|
deUint32 program = m_program->getProgram();
|
|
|
|
glUseProgram(program);
|
|
|
|
{
|
|
// Setup attributes.
|
|
|
|
// Position attribute is non-instanced.
|
|
int positionLoc = glGetAttribLocation(program, "a_position");
|
|
glEnableVertexAttribArray(positionLoc);
|
|
glVertexAttribPointer(positionLoc, 2, GL_FLOAT, GL_FALSE, 0, &m_gridVertexPositions[0]);
|
|
|
|
if (m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED)
|
|
{
|
|
if (m_instancingType == TYPE_ATTRIB_DIVISOR)
|
|
{
|
|
// Position offset attribute is instanced with separate offset for every instance.
|
|
int offsetLoc = glGetAttribLocation(program, "a_instanceOffset");
|
|
glEnableVertexAttribArray(offsetLoc);
|
|
glVertexAttribDivisor(offsetLoc, 1);
|
|
glVertexAttribPointer(offsetLoc, OFFSET_COMPONENTS, GL_FLOAT, GL_FALSE, 0, &m_instanceOffsets[0]);
|
|
|
|
int rLoc = glGetAttribLocation(program, "a_instanceR");
|
|
setupVarAttribPointer((void*)&m_instanceColorR[0].u32, rLoc, ATTRIB_DIVISOR_R);
|
|
}
|
|
|
|
int gLoc = glGetAttribLocation(program, "a_instanceG");
|
|
setupVarAttribPointer((void*)&m_instanceColorG[0].u32, gLoc, ATTRIB_DIVISOR_G);
|
|
|
|
int bLoc = glGetAttribLocation(program, "a_instanceB");
|
|
setupVarAttribPointer((void*)&m_instanceColorB[0].u32, bLoc, ATTRIB_DIVISOR_B);
|
|
}
|
|
}
|
|
|
|
// Draw using appropriate function.
|
|
|
|
if (m_function == FUNCTION_DRAW_ARRAYS_INSTANCED)
|
|
{
|
|
const int numPositionComponents = 2;
|
|
glDrawArraysInstanced(GL_TRIANGLES, 0, ((int)m_gridVertexPositions.size() / numPositionComponents), m_numInstances);
|
|
}
|
|
else
|
|
glDrawElementsInstanced(GL_TRIANGLES, (int)m_gridIndices.size(), GL_UNSIGNED_SHORT, &m_gridIndices[0], m_numInstances);
|
|
|
|
glUseProgram(0);
|
|
}
|
|
|
|
void InstancedRenderingCase::computeReference (tcu::Surface& dst)
|
|
{
|
|
int wid = dst.getWidth();
|
|
int hei = dst.getHeight();
|
|
|
|
// Draw a rectangle (vertical bar) for each instance.
|
|
|
|
for (int instanceNdx = 0; instanceNdx < m_numInstances; instanceNdx++)
|
|
{
|
|
int xStart = instanceNdx * wid / m_numInstances;
|
|
int xEnd = (instanceNdx + 1) * wid / m_numInstances;
|
|
|
|
// Emulate attribute divisors if that is the case.
|
|
|
|
int clrNdxR = m_instancingType == TYPE_ATTRIB_DIVISOR ? instanceNdx / ATTRIB_DIVISOR_R : instanceNdx;
|
|
int clrNdxG = m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED ? instanceNdx / ATTRIB_DIVISOR_G : instanceNdx;
|
|
int clrNdxB = m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED ? instanceNdx / ATTRIB_DIVISOR_B : instanceNdx;
|
|
|
|
int rInstances = m_instancingType == TYPE_ATTRIB_DIVISOR ? m_numInstances / ATTRIB_DIVISOR_R + (m_numInstances % ATTRIB_DIVISOR_R == 0 ? 0 : 1) : m_numInstances;
|
|
int gInstances = m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED ? m_numInstances / ATTRIB_DIVISOR_G + (m_numInstances % ATTRIB_DIVISOR_G == 0 ? 0 : 1) : m_numInstances;
|
|
int bInstances = m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED ? m_numInstances / ATTRIB_DIVISOR_B + (m_numInstances % ATTRIB_DIVISOR_B == 0 ? 0 : 1) : m_numInstances;
|
|
|
|
// Calculate colors.
|
|
|
|
float r = (float)clrNdxR / (float)rInstances;
|
|
float g = (float)clrNdxG * 2.0f / (float)gInstances;
|
|
float b = 1.0f - (float)clrNdxB / (float)bInstances;
|
|
|
|
// Convert to integer and back if shader inputs are integers.
|
|
|
|
if (glu::isDataTypeIntOrIVec(m_rgbAttrType))
|
|
{
|
|
deInt32 intR = (deInt32)(r*FLOAT_INT_SCALE + FLOAT_INT_BIAS);
|
|
deInt32 intG = (deInt32)(g*FLOAT_INT_SCALE + FLOAT_INT_BIAS);
|
|
deInt32 intB = (deInt32)(b*FLOAT_INT_SCALE + FLOAT_INT_BIAS);
|
|
r = ((float)intR - FLOAT_INT_BIAS) / FLOAT_INT_SCALE;
|
|
g = ((float)intG - FLOAT_INT_BIAS) / FLOAT_INT_SCALE;
|
|
b = ((float)intB - FLOAT_INT_BIAS) / FLOAT_INT_SCALE;
|
|
}
|
|
else if(glu::isDataTypeUintOrUVec(m_rgbAttrType))
|
|
{
|
|
deUint32 uintR = (deInt32)(r*FLOAT_UINT_SCALE + FLOAT_UINT_BIAS);
|
|
deUint32 uintG = (deInt32)(g*FLOAT_UINT_SCALE + FLOAT_UINT_BIAS);
|
|
deUint32 uintB = (deInt32)(b*FLOAT_UINT_SCALE + FLOAT_UINT_BIAS);
|
|
r = ((float)uintR - FLOAT_UINT_BIAS) / FLOAT_UINT_SCALE;
|
|
g = ((float)uintG - FLOAT_UINT_BIAS) / FLOAT_UINT_SCALE;
|
|
b = ((float)uintB - FLOAT_UINT_BIAS) / FLOAT_UINT_SCALE;
|
|
}
|
|
|
|
// Draw rectangle.
|
|
|
|
for (int y = 0; y < hei; y++)
|
|
for (int x = xStart; x < xEnd; x++)
|
|
dst.setPixel(x, y, tcu::RGBA(tcu::Vec4(r, g, b, 1.0f)));
|
|
}
|
|
}
|
|
|
|
InstancedRenderingTests::InstancedRenderingTests (Context& context)
|
|
: TestCaseGroup(context, "instanced", "Instanced rendering tests")
|
|
{
|
|
}
|
|
|
|
InstancedRenderingTests::~InstancedRenderingTests (void)
|
|
{
|
|
}
|
|
|
|
void InstancedRenderingTests::init (void)
|
|
{
|
|
// Cases testing function, instancing method and instance count.
|
|
|
|
static const int instanceCounts[] = { 1, 2, 4, 20 };
|
|
|
|
for (int function = 0; function < (int)InstancedRenderingCase::FUNCTION_LAST; function++)
|
|
{
|
|
const char* functionName = function == (int)InstancedRenderingCase::FUNCTION_DRAW_ARRAYS_INSTANCED ? "draw_arrays_instanced"
|
|
: function == (int)InstancedRenderingCase::FUNCTION_DRAW_ELEMENTS_INSTANCED ? "draw_elements_instanced"
|
|
: DE_NULL;
|
|
|
|
const char* functionDesc = function == (int)InstancedRenderingCase::FUNCTION_DRAW_ARRAYS_INSTANCED ? "Use glDrawArraysInstanced()"
|
|
: function == (int)InstancedRenderingCase::FUNCTION_DRAW_ELEMENTS_INSTANCED ? "Use glDrawElementsInstanced()"
|
|
: DE_NULL;
|
|
|
|
DE_ASSERT(functionName != DE_NULL);
|
|
DE_ASSERT(functionDesc != DE_NULL);
|
|
|
|
TestCaseGroup* functionGroup = new TestCaseGroup(m_context, functionName, functionDesc);
|
|
addChild(functionGroup);
|
|
|
|
for (int instancingType = 0; instancingType < (int)InstancedRenderingCase::TYPE_LAST; instancingType++)
|
|
{
|
|
const char* instancingTypeName = instancingType == (int)InstancedRenderingCase::TYPE_INSTANCE_ID ? "instance_id"
|
|
: instancingType == (int)InstancedRenderingCase::TYPE_ATTRIB_DIVISOR ? "attribute_divisor"
|
|
: instancingType == (int)InstancedRenderingCase::TYPE_MIXED ? "mixed"
|
|
: DE_NULL;
|
|
|
|
const char* instancingTypeDesc = instancingType == (int)InstancedRenderingCase::TYPE_INSTANCE_ID ? "Use gl_InstanceID for instancing"
|
|
: instancingType == (int)InstancedRenderingCase::TYPE_ATTRIB_DIVISOR ? "Use vertex attribute divisors for instancing"
|
|
: instancingType == (int)InstancedRenderingCase::TYPE_MIXED ? "Use both gl_InstanceID and vertex attribute divisors for instancing"
|
|
: DE_NULL;
|
|
|
|
DE_ASSERT(instancingTypeName != DE_NULL);
|
|
DE_ASSERT(instancingTypeDesc != DE_NULL);
|
|
|
|
TestCaseGroup* instancingTypeGroup = new TestCaseGroup(m_context, instancingTypeName, instancingTypeDesc);
|
|
functionGroup->addChild(instancingTypeGroup);
|
|
|
|
for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(instanceCounts); countNdx++)
|
|
{
|
|
std::string countName = de::toString(instanceCounts[countNdx]) + "_instances";
|
|
|
|
instancingTypeGroup->addChild(new InstancedRenderingCase(m_context, countName.c_str(), "",
|
|
(InstancedRenderingCase::DrawFunction)function,
|
|
(InstancedRenderingCase::InstancingType)instancingType,
|
|
glu::TYPE_FLOAT,
|
|
instanceCounts[countNdx]));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Data type specific cases.
|
|
|
|
static const glu::DataType s_testTypes[] =
|
|
{
|
|
glu::TYPE_FLOAT,
|
|
glu::TYPE_FLOAT_VEC2,
|
|
glu::TYPE_FLOAT_VEC3,
|
|
glu::TYPE_FLOAT_VEC4,
|
|
glu::TYPE_FLOAT_MAT2,
|
|
glu::TYPE_FLOAT_MAT2X3,
|
|
glu::TYPE_FLOAT_MAT2X4,
|
|
glu::TYPE_FLOAT_MAT3X2,
|
|
glu::TYPE_FLOAT_MAT3,
|
|
glu::TYPE_FLOAT_MAT3X4,
|
|
glu::TYPE_FLOAT_MAT4X2,
|
|
glu::TYPE_FLOAT_MAT4X3,
|
|
glu::TYPE_FLOAT_MAT4,
|
|
|
|
glu::TYPE_INT,
|
|
glu::TYPE_INT_VEC2,
|
|
glu::TYPE_INT_VEC3,
|
|
glu::TYPE_INT_VEC4,
|
|
|
|
glu::TYPE_UINT,
|
|
glu::TYPE_UINT_VEC2,
|
|
glu::TYPE_UINT_VEC3,
|
|
glu::TYPE_UINT_VEC4
|
|
};
|
|
|
|
const int typeTestNumInstances = 4;
|
|
|
|
TestCaseGroup* typesGroup = new TestCaseGroup(m_context, "types", "Tests for instanced attributes of particular data types");
|
|
addChild(typesGroup);
|
|
|
|
for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_testTypes); typeNdx++)
|
|
{
|
|
glu::DataType type = s_testTypes[typeNdx];
|
|
|
|
typesGroup->addChild(new InstancedRenderingCase(m_context, glu::getDataTypeName(type), "",
|
|
InstancedRenderingCase::FUNCTION_DRAW_ARRAYS_INSTANCED,
|
|
InstancedRenderingCase::TYPE_ATTRIB_DIVISOR,
|
|
type,
|
|
typeTestNumInstances));
|
|
}
|
|
}
|
|
|
|
} // Functional
|
|
} // gles3
|
|
} // deqp
|