/*-------------------------------------------------------------------------
* drawElements Quality Program Random Shader Generator
* ----------------------------------------------------
*
* 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 Program Executor.
*//*--------------------------------------------------------------------*/
#include "rsgProgramExecutor.hpp"
#include "rsgExecutionContext.hpp"
#include "rsgVariableValue.hpp"
#include "rsgUtils.hpp"
#include "tcuSurface.hpp"
#include "deMath.h"
#include "deString.h"
#include <set>
#include <string>
#include <map>
using std::set;
using std::string;
using std::vector;
using std::map;
namespace rsg
{
class VaryingStorage
{
public:
VaryingStorage (const VariableType& type, int numVertices);
~VaryingStorage (void) {}
ValueAccess getValue (const VariableType& type, int vtxNdx);
ConstValueAccess getValue (const VariableType& type, int vtxNdx) const;
private:
std::vector<Scalar> m_value;
};
VaryingStorage::VaryingStorage (const VariableType& type, int numVertices)
: m_value(type.getScalarSize()*numVertices)
{
}
ValueAccess VaryingStorage::getValue (const VariableType& type, int vtxNdx)
{
return ValueAccess(type, &m_value[type.getScalarSize()*vtxNdx]);
}
ConstValueAccess VaryingStorage::getValue (const VariableType& type, int vtxNdx) const
{
return ConstValueAccess(type, &m_value[type.getScalarSize()*vtxNdx]);
}
class VaryingStore
{
public:
VaryingStore (int numVertices);
~VaryingStore (void);
VaryingStorage* getStorage (const VariableType& type, const char* name);
private:
int m_numVertices;
std::map<std::string, VaryingStorage*> m_values;
};
VaryingStore::VaryingStore (int numVertices)
: m_numVertices(numVertices)
{
}
VaryingStore::~VaryingStore (void)
{
for (map<string, VaryingStorage*>::iterator i = m_values.begin(); i != m_values.end(); i++)
delete i->second;
m_values.clear();
}
VaryingStorage* VaryingStore::getStorage (const VariableType& type, const char* name)
{
VaryingStorage* storage = m_values[name];
if (!storage)
{
storage = new VaryingStorage(type, m_numVertices);
m_values[name] = storage;
}
return storage;
}
inline float interpolateVertexQuad (const tcu::Vec4& quad, float x, float y)
{
float w00 = (1.0f-x)*(1.0f-y);
float w01 = (1.0f-x)*y;
float w10 = x*(1.0f-y);
float w11 = x*y;
return quad.x()*w00 + quad.y()*w10 + quad.z()*w01 + quad.w()*w11;
}
inline float interpolateVertex (float x0y0, float x1y1, float x, float y)
{
return interpolateVertexQuad(tcu::Vec4(x0y0, (x0y0+x1y1)*0.5f, (x0y0+x1y1)*0.5f, x1y1), x, y);
}
inline float interpolateTri (float v0, float v1, float v2, float x, float y)
{
return v0 + (v1-v0)*x + (v2-v0)*y;
}
inline float interpolateFragment (const tcu::Vec4& quad, float x, float y)
{
if (x + y < 1.0f)
return interpolateTri(quad.x(), quad.y(), quad.z(), x, y);
else
return interpolateTri(quad.w(), quad.z(), quad.y(), 1.0f-x, 1.0f-y);
}
template <int Stride>
void interpolateVertexInput (StridedValueAccess<Stride> dst, int dstComp, const ConstValueRangeAccess valueRange, float x, float y)
{
TCU_CHECK(valueRange.getType().getBaseType() == VariableType::TYPE_FLOAT);
int numElements = valueRange.getType().getNumElements();
for (int elementNdx = 0; elementNdx < numElements; elementNdx++)
{
float xd, yd;
getVertexInterpolationCoords(xd, yd, x, y, elementNdx);
dst.component(elementNdx).asFloat(dstComp) = interpolateVertex(valueRange.getMin().component(elementNdx).asFloat(), valueRange.getMax().component(elementNdx).asFloat(), xd, yd);
}
}
template <int Stride>
void interpolateFragmentInput (StridedValueAccess<Stride> dst, int dstComp, ConstValueAccess vtx0, ConstValueAccess vtx1, ConstValueAccess vtx2, ConstValueAccess vtx3, float x, float y)
{
TCU_CHECK(dst.getType().getBaseType() == VariableType::TYPE_FLOAT);
int numElements = dst.getType().getNumElements();
for (int ndx = 0; ndx < numElements; ndx++)
dst.component(ndx).asFloat(dstComp) = interpolateFragment(tcu::Vec4(vtx0.component(ndx).asFloat(), vtx1.component(ndx).asFloat(), vtx2.component(ndx).asFloat(), vtx3.component(ndx).asFloat()), x, y);
}
template <int Stride>
void copyVarying (ValueAccess dst, ConstStridedValueAccess<Stride> src, int compNdx)
{
TCU_CHECK(dst.getType().getBaseType() == VariableType::TYPE_FLOAT);
for (int elemNdx = 0; elemNdx < dst.getType().getNumElements(); elemNdx++)
dst.component(elemNdx).asFloat() = src.component(elemNdx).asFloat(compNdx);
}
ProgramExecutor::ProgramExecutor (const tcu::PixelBufferAccess& dst, int gridWidth, int gridHeight)
: m_dst (dst)
, m_gridWidth (gridWidth)
, m_gridHeight (gridHeight)
{
}
ProgramExecutor::~ProgramExecutor (void)
{
}
void ProgramExecutor::setTexture (int samplerNdx, const tcu::Texture2D* texture, const tcu::Sampler& sampler)
{
m_samplers2D[samplerNdx] = Sampler2D(texture, sampler);
}
void ProgramExecutor::setTexture (int samplerNdx, const tcu::TextureCube* texture, const tcu::Sampler& sampler)
{
m_samplersCube[samplerNdx] = SamplerCube(texture, sampler);
}
inline tcu::IVec4 computeVertexIndices (float cellWidth, float cellHeight, int gridVtxWidth, int gridVtxHeight, int x, int y)
{
DE_UNREF(gridVtxHeight);
int x0 = (int)deFloatFloor((float)x / cellWidth);
int y0 = (int)deFloatFloor((float)y / cellHeight);
return tcu::IVec4(y0*gridVtxWidth + x0, y0*gridVtxWidth + x0 + 1, (y0+1)*gridVtxWidth + x0, (y0+1)*gridVtxWidth + x0 + 1);
}
inline tcu::Vec2 computeGridCellWeights (float cellWidth, float cellHeight, int x, int y)
{
float gx = ((float)x + 0.5f) / cellWidth;
float gy = ((float)y + 0.5f) / cellHeight;
return tcu::Vec2(deFloatFrac(gx), deFloatFrac(gy));
}
inline tcu::RGBA toColor (tcu::Vec4 rgba)
{
return tcu::RGBA(deClamp32(deRoundFloatToInt32(rgba.x()*255), 0, 255),
deClamp32(deRoundFloatToInt32(rgba.y()*255), 0, 255),
deClamp32(deRoundFloatToInt32(rgba.z()*255), 0, 255),
deClamp32(deRoundFloatToInt32(rgba.w()*255), 0, 255));
}
void ProgramExecutor::execute (const Shader& vertexShader, const Shader& fragmentShader, const vector<VariableValue>& uniformValues)
{
int gridVtxWidth = m_gridWidth+1;
int gridVtxHeight = m_gridHeight+1;
int numVertices = gridVtxWidth*gridVtxHeight;
VaryingStore varyingStore(numVertices);
// Execute vertex shader
{
ExecutionContext execCtx(m_samplers2D, m_samplersCube);
int numPackets = numVertices + ((numVertices%EXEC_VEC_WIDTH) ? 1 : 0);
const vector<ShaderInput*>& inputs = vertexShader.getInputs();
vector<const Variable*> outputs;
vertexShader.getOutputs(outputs);
// Set uniform values
for (vector<VariableValue>::const_iterator uniformIter = uniformValues.begin(); uniformIter != uniformValues.end(); uniformIter++)
execCtx.getValue(uniformIter->getVariable()) = uniformIter->getValue().value();
for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
{
int packetStart = packetNdx*EXEC_VEC_WIDTH;
int packetEnd = deMin32((packetNdx+1)*EXEC_VEC_WIDTH, numVertices);
// Compute values for vertex shader inputs
for (vector<ShaderInput*>::const_iterator i = inputs.begin(); i != inputs.end(); i++)
{
const ShaderInput* input = *i;
ExecValueAccess access = execCtx.getValue(input->getVariable());
for (int vtxNdx = packetStart; vtxNdx < packetEnd; vtxNdx++)
{
int y = (vtxNdx/gridVtxWidth);
int x = vtxNdx - y*gridVtxWidth;
float xf = (float)x / (float)(gridVtxWidth-1);
float yf = (float)y / (float)(gridVtxHeight-1);
interpolateVertexInput(access, vtxNdx-packetStart, input->getValueRange(), xf, yf);
}
}
// Execute vertex shader for packet
vertexShader.execute(execCtx);
// Store output values
for (vector<const Variable*>::const_iterator i = outputs.begin(); i != outputs.end(); i++)
{
const Variable* output = *i;
if (deStringEqual(output->getName(), "gl_Position"))
continue; // Do not store position
ExecConstValueAccess access = execCtx.getValue(output);
VaryingStorage* dst = varyingStore.getStorage(output->getType(), output->getName());
for (int vtxNdx = packetStart; vtxNdx < packetEnd; vtxNdx++)
{
ValueAccess varyingAccess = dst->getValue(output->getType(), vtxNdx);
copyVarying(varyingAccess, access, vtxNdx-packetStart);
}
}
}
}
// Execute fragment shader
{
ExecutionContext execCtx(m_samplers2D, m_samplersCube);
// Assign uniform values
for (vector<VariableValue>::const_iterator i = uniformValues.begin(); i != uniformValues.end(); i++)
execCtx.getValue(i->getVariable()) = i->getValue().value();
const vector<ShaderInput*>& inputs = fragmentShader.getInputs();
const Variable* fragColorVar = DE_NULL;
vector<const Variable*> outputs;
// Find fragment shader output assigned to location 0. This is fragment color.
fragmentShader.getOutputs(outputs);
for (vector<const Variable*>::const_iterator i = outputs.begin(); i != outputs.end(); i++)
{
if ((*i)->getLayoutLocation() == 0)
{
fragColorVar = *i;
break;
}
}
TCU_CHECK(fragColorVar);
int width = m_dst.getWidth();
int height = m_dst.getHeight();
int numPackets = (width*height)/EXEC_VEC_WIDTH + (((width*height)%EXEC_VEC_WIDTH) ? 1 : 0);
float cellWidth = (float)width / (float)m_gridWidth;
float cellHeight = (float)height / (float)m_gridHeight;
for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
{
int packetStart = packetNdx*EXEC_VEC_WIDTH;
int packetEnd = deMin32((packetNdx+1)*EXEC_VEC_WIDTH, width*height);
// Interpolate varyings
for (vector<ShaderInput*>::const_iterator i = inputs.begin(); i != inputs.end(); i++)
{
const ShaderInput* input = *i;
ExecValueAccess access = execCtx.getValue(input->getVariable());
const VariableType& type = input->getVariable()->getType();
const VaryingStorage* src = varyingStore.getStorage(type, input->getVariable()->getName());
// \todo [2011-03-08 pyry] Part of this could be pre-computed...
for (int fragNdx = packetStart; fragNdx < packetEnd; fragNdx++)
{
int y = fragNdx/width;
int x = fragNdx - y*width;
tcu::IVec4 vtxIndices = computeVertexIndices(cellWidth, cellHeight, gridVtxWidth, gridVtxHeight, x, y);
tcu::Vec2 weights = computeGridCellWeights(cellWidth, cellHeight, x, y);
interpolateFragmentInput(access, fragNdx-packetStart,
src->getValue(type, vtxIndices.x()),
src->getValue(type, vtxIndices.y()),
src->getValue(type, vtxIndices.z()),
src->getValue(type, vtxIndices.w()),
weights.x(), weights.y());
}
}
// Execute fragment shader
fragmentShader.execute(execCtx);
// Write resulting color
ExecConstValueAccess colorValue = execCtx.getValue(fragColorVar);
for (int fragNdx = packetStart; fragNdx < packetEnd; fragNdx++)
{
int y = fragNdx/width;
int x = fragNdx - y*width;
int cNdx = fragNdx-packetStart;
tcu::Vec4 c = tcu::Vec4(colorValue.component(0).asFloat(cNdx),
colorValue.component(1).asFloat(cNdx),
colorValue.component(2).asFloat(cNdx),
colorValue.component(3).asFloat(cNdx));
// \todo [2012-11-13 pyry] Reverse order.
m_dst.setPixel(c, x, m_dst.getHeight()-y-1);
}
}
}
}
} // rsg