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.
260 lines
8.0 KiB
260 lines
8.0 KiB
#ifndef _SGLRSHADERPROGRAM_HPP
|
|
#define _SGLRSHADERPROGRAM_HPP
|
|
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES Utilities
|
|
* ------------------------------------------------
|
|
*
|
|
* 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 SGLR shader program.
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "tcuDefs.hpp"
|
|
#include "rrShaders.hpp"
|
|
#include "gluShaderUtil.hpp"
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
|
|
namespace sglr
|
|
{
|
|
|
|
namespace rc
|
|
{
|
|
class Texture1D;
|
|
class Texture2D;
|
|
class TextureCube;
|
|
class Texture2DArray;
|
|
class Texture3D;
|
|
class TextureCubeArray;
|
|
} // rc
|
|
|
|
class ShaderProgram;
|
|
|
|
namespace pdec
|
|
{
|
|
|
|
enum VaryingFlags
|
|
{
|
|
VARYINGFLAG_NONE = 0,
|
|
VARYINGFLAG_FLATSHADE = (1 << 0),
|
|
};
|
|
|
|
struct VertexAttribute
|
|
{
|
|
VertexAttribute (const std::string& name_, rr::GenericVecType type_) : name(name_), type(type_) { }
|
|
|
|
std::string name;
|
|
rr::GenericVecType type;
|
|
};
|
|
|
|
struct VertexToFragmentVarying
|
|
{
|
|
VertexToFragmentVarying (rr::GenericVecType type_, int flags = VARYINGFLAG_NONE) : type(type_), flatshade((flags & VARYINGFLAG_FLATSHADE) != 0) { }
|
|
|
|
rr::GenericVecType type;
|
|
bool flatshade;
|
|
};
|
|
|
|
struct VertexToGeometryVarying
|
|
{
|
|
VertexToGeometryVarying (rr::GenericVecType type_, int flags = VARYINGFLAG_NONE) : type(type_), flatshade((flags & VARYINGFLAG_FLATSHADE) != 0) { }
|
|
|
|
rr::GenericVecType type;
|
|
bool flatshade;
|
|
};
|
|
|
|
struct GeometryToFragmentVarying
|
|
{
|
|
GeometryToFragmentVarying (rr::GenericVecType type_, int flags = VARYINGFLAG_NONE) : type(type_), flatshade((flags & VARYINGFLAG_FLATSHADE) != 0) { }
|
|
|
|
rr::GenericVecType type;
|
|
bool flatshade;
|
|
};
|
|
|
|
struct FragmentOutput
|
|
{
|
|
FragmentOutput (rr::GenericVecType type_) : type(type_) { }
|
|
|
|
rr::GenericVecType type;
|
|
};
|
|
|
|
struct Uniform
|
|
{
|
|
Uniform (const std::string& name_, glu::DataType type_) : name(name_), type(type_) { }
|
|
|
|
std::string name;
|
|
glu::DataType type;
|
|
};
|
|
|
|
struct VertexSource
|
|
{
|
|
VertexSource (const std::string& str) : source(str) { }
|
|
|
|
std::string source;
|
|
};
|
|
|
|
struct FragmentSource
|
|
{
|
|
FragmentSource (const std::string& str) : source(str) { }
|
|
|
|
std::string source;
|
|
};
|
|
|
|
struct GeometrySource
|
|
{
|
|
GeometrySource (const std::string& str) : source(str) { }
|
|
|
|
std::string source;
|
|
};
|
|
|
|
struct GeometryShaderDeclaration
|
|
{
|
|
GeometryShaderDeclaration (rr::GeometryShaderInputType inputType_,
|
|
rr::GeometryShaderOutputType outputType_,
|
|
size_t numOutputVertices_,
|
|
size_t numInvocations_ = 1)
|
|
: inputType (inputType_)
|
|
, outputType (outputType_)
|
|
, numOutputVertices (numOutputVertices_)
|
|
, numInvocations (numInvocations_)
|
|
{
|
|
}
|
|
|
|
rr::GeometryShaderInputType inputType;
|
|
rr::GeometryShaderOutputType outputType;
|
|
size_t numOutputVertices;
|
|
size_t numInvocations;
|
|
};
|
|
|
|
class ShaderProgramDeclaration
|
|
{
|
|
public:
|
|
ShaderProgramDeclaration (void);
|
|
|
|
ShaderProgramDeclaration& operator<< (const VertexAttribute&);
|
|
ShaderProgramDeclaration& operator<< (const VertexToFragmentVarying&);
|
|
ShaderProgramDeclaration& operator<< (const VertexToGeometryVarying&);
|
|
ShaderProgramDeclaration& operator<< (const GeometryToFragmentVarying&);
|
|
ShaderProgramDeclaration& operator<< (const FragmentOutput&);
|
|
ShaderProgramDeclaration& operator<< (const Uniform&);
|
|
ShaderProgramDeclaration& operator<< (const VertexSource&);
|
|
ShaderProgramDeclaration& operator<< (const FragmentSource&);
|
|
ShaderProgramDeclaration& operator<< (const GeometrySource&);
|
|
ShaderProgramDeclaration& operator<< (const GeometryShaderDeclaration&);
|
|
|
|
private:
|
|
inline bool hasGeometryShader (void) const { return m_geometryShaderSet; }
|
|
inline size_t getVertexInputCount (void) const { return m_vertexAttributes.size(); }
|
|
inline size_t getVertexOutputCount (void) const { return hasGeometryShader() ? m_vertexToGeometryVaryings.size() : m_vertexToFragmentVaryings.size(); }
|
|
inline size_t getFragmentInputCount (void) const { return hasGeometryShader() ? m_geometryToFragmentVaryings.size() : m_vertexToFragmentVaryings.size(); }
|
|
inline size_t getFragmentOutputCount (void) const { return m_fragmentOutputs.size(); }
|
|
inline size_t getGeometryInputCount (void) const { return hasGeometryShader() ? m_vertexToGeometryVaryings.size() : 0; }
|
|
inline size_t getGeometryOutputCount (void) const { return hasGeometryShader() ? m_geometryToFragmentVaryings.size() : 0; }
|
|
|
|
bool valid (void) const;
|
|
|
|
std::vector<VertexAttribute> m_vertexAttributes;
|
|
std::vector<VertexToFragmentVarying> m_vertexToFragmentVaryings;
|
|
std::vector<VertexToGeometryVarying> m_vertexToGeometryVaryings;
|
|
std::vector<GeometryToFragmentVarying> m_geometryToFragmentVaryings;
|
|
std::vector<FragmentOutput> m_fragmentOutputs;
|
|
std::vector<Uniform> m_uniforms;
|
|
std::string m_vertexSource;
|
|
std::string m_fragmentSource;
|
|
std::string m_geometrySource;
|
|
GeometryShaderDeclaration m_geometryDecl;
|
|
|
|
bool m_vertexShaderSet;
|
|
bool m_fragmentShaderSet;
|
|
bool m_geometryShaderSet;
|
|
|
|
friend class ::sglr::ShaderProgram;
|
|
};
|
|
|
|
} // pdec
|
|
|
|
struct UniformSlot
|
|
{
|
|
std::string name;
|
|
glu::DataType type;
|
|
|
|
union
|
|
{
|
|
deInt32 i;
|
|
deInt32 i4[4];
|
|
float f;
|
|
float f4[4];
|
|
float m3[3*3]; //!< row major, can be fed directly to tcu::Matrix constructor
|
|
float m4[4*4]; //!< row major, can be fed directly to tcu::Matrix constructor
|
|
} value;
|
|
|
|
union
|
|
{
|
|
const void* ptr;
|
|
|
|
const rc::Texture1D* tex1D;
|
|
const rc::Texture2D* tex2D;
|
|
const rc::TextureCube* texCube;
|
|
const rc::Texture2DArray* tex2DArray;
|
|
const rc::Texture3D* tex3D;
|
|
const rc::TextureCubeArray* texCubeArray;
|
|
} sampler;
|
|
|
|
inline UniformSlot (void)
|
|
: type(glu::TYPE_LAST)
|
|
{
|
|
value.i = 0;
|
|
sampler.ptr = DE_NULL;
|
|
}
|
|
};
|
|
|
|
class ShaderProgram : private rr::VertexShader, private rr::GeometryShader, private rr::FragmentShader
|
|
{
|
|
public:
|
|
ShaderProgram (const pdec::ShaderProgramDeclaration&);
|
|
virtual ~ShaderProgram (void);
|
|
|
|
const UniformSlot& getUniformByName (const char* name) const;
|
|
|
|
inline const rr::VertexShader* getVertexShader (void) const { return static_cast<const rr::VertexShader*>(this); }
|
|
inline const rr::FragmentShader* getFragmentShader (void) const { return static_cast<const rr::FragmentShader*>(this); }
|
|
inline const rr::GeometryShader* getGeometryShader (void) const { return static_cast<const rr::GeometryShader*>(this); }
|
|
|
|
private:
|
|
virtual void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const = 0;
|
|
virtual void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const = 0;
|
|
virtual void shadePrimitives (rr::GeometryEmitter& output, int verticesIn, const rr::PrimitivePacket* packets, const int numPackets, int invocationID) const;
|
|
|
|
std::vector<std::string> m_attributeNames;
|
|
protected:
|
|
std::vector<UniformSlot> m_uniforms;
|
|
|
|
private:
|
|
const std::string m_vertSrc;
|
|
const std::string m_fragSrc;
|
|
const std::string m_geomSrc;
|
|
const bool m_hasGeometryShader;
|
|
|
|
friend class ReferenceContext; // for uniform access
|
|
friend class GLContext; // for source string access
|
|
} DE_WARN_UNUSED_TYPE;
|
|
|
|
} // sglr
|
|
|
|
#endif // _SGLRSHADERPROGRAM_HPP
|