#ifndef _GLSSHADERRENDERCASE_HPP
|
#define _GLSSHADERRENDERCASE_HPP
|
/*-------------------------------------------------------------------------
|
* 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 Shader execute test.
|
*//*--------------------------------------------------------------------*/
|
|
#include "tcuDefs.hpp"
|
#include "tcuTestCase.hpp"
|
#include "tcuVector.hpp"
|
#include "tcuMatrix.hpp"
|
#include "tcuTexture.hpp"
|
#include "tcuSurface.hpp"
|
#include "gluRenderContext.hpp"
|
#include "gluContextInfo.hpp"
|
#include "gluShaderProgram.hpp"
|
|
#include <sstream>
|
#include <string>
|
|
namespace glu
|
{
|
class RenderContext;
|
class Texture2D;
|
class TextureCube;
|
class Texture2DArray;
|
class Texture3D;
|
} // glu
|
|
namespace deqp
|
{
|
namespace gls
|
{
|
|
// LineStream \todo [2011-10-17 pyry] Move to proper place!
|
|
class LineStream
|
{
|
public:
|
LineStream (int indent = 0) { m_indent = indent; }
|
~LineStream (void) {}
|
|
const char* str (void) const { m_string = m_stream.str(); return m_string.c_str(); }
|
LineStream& operator<< (const char* line) { for (int i = 0; i < m_indent; i++) { m_stream << "\t"; } m_stream << line << "\n"; return *this; }
|
|
private:
|
int m_indent;
|
std::ostringstream m_stream;
|
mutable std::string m_string;
|
};
|
|
class QuadGrid;
|
|
// TextureBinding
|
|
class TextureBinding
|
{
|
public:
|
enum Type
|
{
|
TYPE_NONE = 0,
|
TYPE_2D,
|
TYPE_CUBE_MAP,
|
TYPE_2D_ARRAY,
|
TYPE_3D,
|
|
TYPE_LAST
|
};
|
|
TextureBinding (const glu::Texture2D* tex2D, const tcu::Sampler& sampler);
|
TextureBinding (const glu::TextureCube* texCube, const tcu::Sampler& sampler);
|
TextureBinding (const glu::Texture2DArray* tex2DArray, const tcu::Sampler& sampler);
|
TextureBinding (const glu::Texture3D* tex3D, const tcu::Sampler& sampler);
|
TextureBinding (void);
|
|
void setSampler (const tcu::Sampler& sampler);
|
void setTexture (const glu::Texture2D* tex2D);
|
void setTexture (const glu::TextureCube* texCube);
|
void setTexture (const glu::Texture2DArray* tex2DArray);
|
void setTexture (const glu::Texture3D* tex3D);
|
|
Type getType (void) const { return m_type; }
|
const tcu::Sampler& getSampler (void) const { return m_sampler; }
|
const glu::Texture2D* get2D (void) const { DE_ASSERT(getType() == TYPE_2D); return m_binding.tex2D; }
|
const glu::TextureCube* getCube (void) const { DE_ASSERT(getType() == TYPE_CUBE_MAP); return m_binding.texCube; }
|
const glu::Texture2DArray* get2DArray (void) const { DE_ASSERT(getType() == TYPE_2D_ARRAY); return m_binding.tex2DArray;}
|
const glu::Texture3D* get3D (void) const { DE_ASSERT(getType() == TYPE_3D); return m_binding.tex3D; }
|
|
private:
|
Type m_type;
|
tcu::Sampler m_sampler;
|
union
|
{
|
const glu::Texture2D* tex2D;
|
const glu::TextureCube* texCube;
|
const glu::Texture2DArray* tex2DArray;
|
const glu::Texture3D* tex3D;
|
} m_binding;
|
};
|
|
// ShaderEvalContext.
|
|
class ShaderEvalContext
|
{
|
public:
|
// Limits.
|
enum
|
{
|
MAX_USER_ATTRIBS = 4,
|
MAX_TEXTURES = 4,
|
};
|
|
struct ShaderSampler
|
{
|
tcu::Sampler sampler;
|
const tcu::Texture2D* tex2D;
|
const tcu::TextureCube* texCube;
|
const tcu::Texture2DArray* tex2DArray;
|
const tcu::Texture3D* tex3D;
|
|
inline ShaderSampler (void)
|
: tex2D (DE_NULL)
|
, texCube (DE_NULL)
|
, tex2DArray(DE_NULL)
|
, tex3D (DE_NULL)
|
{
|
}
|
};
|
|
ShaderEvalContext (const QuadGrid& quadGrid);
|
~ShaderEvalContext (void);
|
|
void reset (float sx, float sy);
|
|
// Inputs.
|
tcu::Vec4 coords;
|
tcu::Vec4 unitCoords;
|
tcu::Vec4 constCoords;
|
|
tcu::Vec4 in[MAX_USER_ATTRIBS];
|
ShaderSampler textures[MAX_TEXTURES];
|
|
// Output.
|
tcu::Vec4 color;
|
bool isDiscarded;
|
|
// Functions.
|
inline void discard (void) { isDiscarded = true; }
|
tcu::Vec4 texture2D (int unitNdx, const tcu::Vec2& coords);
|
|
private:
|
const QuadGrid& quadGrid;
|
};
|
|
// ShaderEvalFunc.
|
|
typedef void (*ShaderEvalFunc) (ShaderEvalContext& c);
|
|
inline void evalCoordsPassthroughX (ShaderEvalContext& c) { c.color.x() = c.coords.x(); }
|
inline void evalCoordsPassthroughXY (ShaderEvalContext& c) { c.color.xy() = c.coords.swizzle(0,1); }
|
inline void evalCoordsPassthroughXYZ (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); }
|
inline void evalCoordsPassthrough (ShaderEvalContext& c) { c.color = c.coords; }
|
inline void evalCoordsSwizzleWZYX (ShaderEvalContext& c) { c.color = c.coords.swizzle(3,2,1,0); }
|
|
// ShaderEvaluator
|
// Either inherit a class with overridden evaluate() or just pass in an evalFunc.
|
|
class ShaderEvaluator
|
{
|
public:
|
ShaderEvaluator (void);
|
ShaderEvaluator (ShaderEvalFunc evalFunc);
|
virtual ~ShaderEvaluator (void);
|
|
virtual void evaluate (ShaderEvalContext& ctx);
|
|
private:
|
ShaderEvaluator (const ShaderEvaluator&); // not allowed!
|
ShaderEvaluator& operator= (const ShaderEvaluator&); // not allowed!
|
|
ShaderEvalFunc m_evalFunc;
|
};
|
|
// ShaderRenderCase.
|
|
class ShaderRenderCase : public tcu::TestCase
|
{
|
public:
|
ShaderRenderCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* description, bool isVertexCase, ShaderEvalFunc evalFunc);
|
ShaderRenderCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* description, bool isVertexCase, ShaderEvaluator& evaluator);
|
virtual ~ShaderRenderCase (void);
|
|
void init (void);
|
void deinit (void);
|
|
IterateResult iterate (void);
|
|
protected:
|
virtual void setupShaderData (void);
|
virtual void setup (int programID);
|
virtual void setupUniforms (int programID, const tcu::Vec4& constCoords);
|
|
tcu::IVec2 getViewportSize (void) const;
|
|
class CompileFailed : public tcu::TestError
|
{
|
public:
|
inline CompileFailed (const char* file, int line) : tcu::TestError("Failed to compile shader program", DE_NULL, file, line) {}
|
};
|
|
private:
|
ShaderRenderCase (const ShaderRenderCase&); // not allowed!
|
ShaderRenderCase& operator= (const ShaderRenderCase&); // not allowed!
|
|
void setupDefaultInputs (int programID);
|
|
void render (tcu::Surface& result, int programID, const QuadGrid& quadGrid);
|
void computeVertexReference (tcu::Surface& result, const QuadGrid& quadGrid);
|
void computeFragmentReference(tcu::Surface& result, const QuadGrid& quadGrid);
|
bool compareImages (const tcu::Surface& resImage, const tcu::Surface& refImage, float errorThreshold);
|
|
protected:
|
glu::RenderContext& m_renderCtx;
|
const glu::ContextInfo& m_ctxInfo;
|
|
bool m_isVertexCase;
|
ShaderEvaluator m_defaultEvaluator;
|
ShaderEvaluator& m_evaluator;
|
std::string m_vertShaderSource;
|
std::string m_fragShaderSource;
|
tcu::Vec4 m_clearColor;
|
|
std::vector<tcu::Mat4> m_userAttribTransforms;
|
std::vector<TextureBinding> m_textures;
|
|
glu::ShaderProgram* m_program;
|
};
|
|
// Helpers.
|
// \todo [2012-04-10 pyry] Move these to separate utility?
|
|
const char* getIntUniformName (int number);
|
const char* getFloatUniformName (int number);
|
const char* getFloatFractionUniformName (int number);
|
|
void setupDefaultUniforms (const glu::RenderContext& context, deUint32 programID);
|
|
} // gls
|
} // deqp
|
|
#endif // _GLSSHADERRENDERCASE_HPP
|
