1 #ifndef _SGLRSHADERPROGRAM_HPP 2 #define _SGLRSHADERPROGRAM_HPP 3 /*------------------------------------------------------------------------- 4 * drawElements Quality Program OpenGL ES Utilities 5 * ------------------------------------------------ 6 * 7 * Copyright 2014 The Android Open Source Project 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief SGLR shader program. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "tcuDefs.hpp" 27 #include "rrShaders.hpp" 28 #include "gluShaderUtil.hpp" 29 30 #include <vector> 31 #include <string> 32 33 namespace sglr 34 { 35 36 namespace rc 37 { 38 class Texture1D; 39 class Texture2D; 40 class TextureCube; 41 class Texture2DArray; 42 class Texture3D; 43 class TextureCubeArray; 44 } // rc 45 46 class ShaderProgram; 47 48 namespace pdec 49 { 50 51 enum VaryingFlags 52 { 53 VARYINGFLAG_NONE = 0, 54 VARYINGFLAG_FLATSHADE = (1 << 0), 55 }; 56 57 struct VertexAttribute 58 { 59 VertexAttribute (const std::string& name_, rr::GenericVecType type_) : name(name_), type(type_) { } 60 61 std::string name; 62 rr::GenericVecType type; 63 }; 64 65 struct VertexToFragmentVarying 66 { 67 VertexToFragmentVarying (rr::GenericVecType type_, int flags = VARYINGFLAG_NONE) : type(type_), flatshade((flags & VARYINGFLAG_FLATSHADE) != 0) { } 68 69 rr::GenericVecType type; 70 bool flatshade; 71 }; 72 73 struct VertexToGeometryVarying 74 { 75 VertexToGeometryVarying (rr::GenericVecType type_, int flags = VARYINGFLAG_NONE) : type(type_), flatshade((flags & VARYINGFLAG_FLATSHADE) != 0) { } 76 77 rr::GenericVecType type; 78 bool flatshade; 79 }; 80 81 struct GeometryToFragmentVarying 82 { 83 GeometryToFragmentVarying (rr::GenericVecType type_, int flags = VARYINGFLAG_NONE) : type(type_), flatshade((flags & VARYINGFLAG_FLATSHADE) != 0) { } 84 85 rr::GenericVecType type; 86 bool flatshade; 87 }; 88 89 struct FragmentOutput 90 { 91 FragmentOutput (rr::GenericVecType type_) : type(type_) { } 92 93 rr::GenericVecType type; 94 }; 95 96 struct Uniform 97 { 98 Uniform (const std::string& name_, glu::DataType type_) : name(name_), type(type_) { } 99 100 std::string name; 101 glu::DataType type; 102 }; 103 104 struct VertexSource 105 { 106 VertexSource (const std::string& str) : source(str) { } 107 108 std::string source; 109 }; 110 111 struct FragmentSource 112 { 113 FragmentSource (const std::string& str) : source(str) { } 114 115 std::string source; 116 }; 117 118 struct GeometrySource 119 { 120 GeometrySource (const std::string& str) : source(str) { } 121 122 std::string source; 123 }; 124 125 struct GeometryShaderDeclaration 126 { 127 GeometryShaderDeclaration (rr::GeometryShaderInputType inputType_, 128 rr::GeometryShaderOutputType outputType_, 129 size_t numOutputVertices_, 130 size_t numInvocations_ = 1) 131 : inputType (inputType_) 132 , outputType (outputType_) 133 , numOutputVertices (numOutputVertices_) 134 , numInvocations (numInvocations_) 135 { 136 } 137 138 rr::GeometryShaderInputType inputType; 139 rr::GeometryShaderOutputType outputType; 140 size_t numOutputVertices; 141 size_t numInvocations; 142 }; 143 144 class ShaderProgramDeclaration 145 { 146 public: 147 ShaderProgramDeclaration (void); 148 149 ShaderProgramDeclaration& operator<< (const VertexAttribute&); 150 ShaderProgramDeclaration& operator<< (const VertexToFragmentVarying&); 151 ShaderProgramDeclaration& operator<< (const VertexToGeometryVarying&); 152 ShaderProgramDeclaration& operator<< (const GeometryToFragmentVarying&); 153 ShaderProgramDeclaration& operator<< (const FragmentOutput&); 154 ShaderProgramDeclaration& operator<< (const Uniform&); 155 ShaderProgramDeclaration& operator<< (const VertexSource&); 156 ShaderProgramDeclaration& operator<< (const FragmentSource&); 157 ShaderProgramDeclaration& operator<< (const GeometrySource&); 158 ShaderProgramDeclaration& operator<< (const GeometryShaderDeclaration&); 159 160 private: 161 inline bool hasGeometryShader (void) const { return m_geometryShaderSet; } 162 inline size_t getVertexInputCount (void) const { return m_vertexAttributes.size(); } 163 inline size_t getVertexOutputCount (void) const { return hasGeometryShader() ? m_vertexToGeometryVaryings.size() : m_vertexToFragmentVaryings.size(); } 164 inline size_t getFragmentInputCount (void) const { return hasGeometryShader() ? m_geometryToFragmentVaryings.size() : m_vertexToFragmentVaryings.size(); } 165 inline size_t getFragmentOutputCount (void) const { return m_fragmentOutputs.size(); } 166 inline size_t getGeometryInputCount (void) const { return hasGeometryShader() ? m_vertexToGeometryVaryings.size() : 0; } 167 inline size_t getGeometryOutputCount (void) const { return hasGeometryShader() ? m_geometryToFragmentVaryings.size() : 0; } 168 169 bool valid (void) const; 170 171 std::vector<VertexAttribute> m_vertexAttributes; 172 std::vector<VertexToFragmentVarying> m_vertexToFragmentVaryings; 173 std::vector<VertexToGeometryVarying> m_vertexToGeometryVaryings; 174 std::vector<GeometryToFragmentVarying> m_geometryToFragmentVaryings; 175 std::vector<FragmentOutput> m_fragmentOutputs; 176 std::vector<Uniform> m_uniforms; 177 std::string m_vertexSource; 178 std::string m_fragmentSource; 179 std::string m_geometrySource; 180 GeometryShaderDeclaration m_geometryDecl; 181 182 bool m_vertexShaderSet; 183 bool m_fragmentShaderSet; 184 bool m_geometryShaderSet; 185 186 friend class ::sglr::ShaderProgram; 187 }; 188 189 } // pdec 190 191 struct UniformSlot 192 { 193 std::string name; 194 glu::DataType type; 195 196 union 197 { 198 deInt32 i; 199 deInt32 i4[4]; 200 float f; 201 float f4[4]; 202 float m3[3*3]; //!< row major, can be fed directly to tcu::Matrix constructor 203 float m4[4*4]; //!< row major, can be fed directly to tcu::Matrix constructor 204 } value; 205 206 union 207 { 208 const void* ptr; 209 210 const rc::Texture1D* tex1D; 211 const rc::Texture2D* tex2D; 212 const rc::TextureCube* texCube; 213 const rc::Texture2DArray* tex2DArray; 214 const rc::Texture3D* tex3D; 215 const rc::TextureCubeArray* texCubeArray; 216 } sampler; 217 218 inline UniformSlot (void) 219 : type(glu::TYPE_LAST) 220 { 221 value.i = 0; 222 sampler.ptr = DE_NULL; 223 } 224 }; 225 226 class ShaderProgram : private rr::VertexShader, private rr::GeometryShader, private rr::FragmentShader 227 { 228 public: 229 ShaderProgram (const pdec::ShaderProgramDeclaration&); 230 virtual ~ShaderProgram (void); 231 232 const UniformSlot& getUniformByName (const char* name) const; 233 234 inline const rr::VertexShader* getVertexShader (void) const { return static_cast<const rr::VertexShader*>(this); } 235 inline const rr::FragmentShader* getFragmentShader (void) const { return static_cast<const rr::FragmentShader*>(this); } 236 inline const rr::GeometryShader* getGeometryShader (void) const { return static_cast<const rr::GeometryShader*>(this); } 237 238 private: 239 virtual void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const = 0; 240 virtual void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const = 0; 241 virtual void shadePrimitives (rr::GeometryEmitter& output, int verticesIn, const rr::PrimitivePacket* packets, const int numPackets, int invocationID) const; 242 243 std::vector<std::string> m_attributeNames; 244 protected: 245 std::vector<UniformSlot> m_uniforms; 246 247 private: 248 const std::string m_vertSrc; 249 const std::string m_fragSrc; 250 const std::string m_geomSrc; 251 const bool m_hasGeometryShader; 252 253 friend class ReferenceContext; // for uniform access 254 friend class GLContext; // for source string access 255 }; 256 257 } // sglr 258 259 #endif // _SGLRSHADERPROGRAM_HPP 260
