OgreShaderFunctionAtom.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org
6 
7 Copyright (c) 2000-2013 Torus Knot Software Ltd
8 Permission is hereby granted, free of charge, to any person obtaining a copy
9 of this software and associated documentation files (the "Software"), to deal
10 in the Software without restriction, including without limitation the rights
11 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 copies of the Software, and to permit persons to whom the Software is
13 furnished to do so, subject to the following conditions:
14 
15 The above copyright notice and this permission notice shall be included in
16 all copies or substantial portions of the Software.
17 
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 THE SOFTWARE.
25 -----------------------------------------------------------------------------
26 */
27 #ifndef _ShaderFunctionAtom_
28 #define _ShaderFunctionAtom_
29 
31 #include "OgreGpuProgram.h"
32 #include "OgreSingleton.h"
33 #include "OgreShaderParameter.h"
34 #include "OgreStringVector.h"
35 
36 namespace Ogre {
37 namespace RTShader {
38 
49 {
50 // Interface.
51 public:
54 
56  virtual ~FunctionAtom() {}
57 
60 
63 
65  virtual void writeSourceCode(std::ostream& os, const String& targetLanguage) const = 0;
66 
68  virtual const String& getFunctionAtomType() = 0;
69 
70 // Attributes.
71 protected:
72  // The owner group execution order.
74  // The execution order within the group.
76 };
77 
81 {
82 public:
83 
84  // InOut semantic
86  {
92  OPS_INOUT
93  };
94 
95  // Used field mask
96  enum OpMask
97  {
98  OPM_ALL = 0x0001,
99  OPM_X = 0x0002,
100  OPM_Y = 0x0004,
101  OPM_Z = 0x0008,
102  OPM_W = 0x0010,
103  OPM_XY = OPM_X | OPM_Y,
104  OPM_XZ = OPM_X | OPM_Z,
105  OPM_XW = OPM_X | OPM_W,
106  OPM_YZ = OPM_Y | OPM_Z,
107  OPM_YW = OPM_Y | OPM_W,
108  OPM_ZW = OPM_Z | OPM_W,
109  OPM_XYZ = OPM_X | OPM_Y | OPM_Z,
110  OPM_XYW = OPM_X | OPM_Y | OPM_W,
111  OPM_XZW = OPM_X | OPM_Z | OPM_W,
112  OPM_YZW = OPM_Y | OPM_Z | OPM_W,
113  OPM_XYZW = OPM_X | OPM_Y | OPM_Z | OPM_W
114  };
115 
121  Operand(ParameterPtr parameter, Operand::OpSemantic opSemantic, int opMask = Operand::OPM_ALL, ushort indirectionLevel = 0);
122 
124  Operand(const Operand& rhs);
125 
129  Operand& operator= (const Operand & rhs);
130 
133 
135  const ParameterPtr& getParameter() const { return mParameter; }
136 
138  bool hasFreeFields() const { return ((mMask & ~OPM_ALL) && ((mMask & ~OPM_X) || (mMask & ~OPM_Y) || (mMask & ~OPM_Z) || (mMask & ~OPM_W))); }
139 
141  int getMask() const { return mMask; }
142 
144  OpSemantic getSemantic() const { return mSemantic; }
145 
151  ushort getIndirectionLevel() const { return mIndirectionLevel; }
152 
154  String toString() const;
155 
157  static String getMaskAsString(int mask);
158 
160  static int getFloatCount(int mask);
161 
164 
165 protected:
171  int mMask;
174 };
175 
179 {
180  // Interface.
181 public:
183 
190  FunctionInvocation(const String& functionName, int groupOrder, int internalOrder, String returnType = "void");
191 
194 
198  virtual void writeSourceCode(std::ostream& os, const String& targetLanguage) const;
199 
203  virtual const String& getFunctionAtomType() { return Type; }
204 
206  OperandVector& getOperandList() { return mOperands; }
207 
214  void pushOperand(ParameterPtr parameter, Operand::OpSemantic opSemantic, int opMask = Operand::OPM_ALL, int indirectionLevel = 0);
215 
217  const String& getFunctionName() const { return mFunctionName; }
218 
220  const String& getReturnType() const { return mReturnType; }
221 
223  bool operator == ( const FunctionInvocation& rhs ) const;
224 
226  bool operator != ( const FunctionInvocation& rhs ) const;
227 
229  bool operator < ( const FunctionInvocation& rhs ) const;
230 
235  {
236  bool operator()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const;
237  };
238 
243  {
244  bool operator()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const;
245  };
246 
248  static String Type;
249 
250  // Attributes.
251 protected:
255 };
256 
258 typedef FunctionAtomInstanceList::iterator FunctionAtomInstanceIterator;
259 typedef FunctionAtomInstanceList::const_iterator FunctionAtomInstanceConstIterator;
260 
264 }
265 }
266 
267 #endif
#define _OgreRTSSExport
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
A class that represents an atomic code section of shader based program function.
virtual void writeSourceCode(std::ostream &os, const String &targetLanguage) const =0
Abstract method that writes a source code to the given output stream in the target shader language.
FunctionAtom()
Class default constructor.
virtual const String & getFunctionAtomType()=0
Return the type of this atom instance implementation.
int getInternalExecutionOrder() const
Get an internal execution order within a group of this function atom.
int getGroupExecutionOrder() const
Get the group execution order of this function atom.
virtual ~FunctionAtom()
Class default destructor.
A class that represents function invocation code from shader based program function.
const String & getReturnType() const
Return the return type.
virtual void writeSourceCode(std::ostream &os, const String &targetLanguage) const
FunctionInvocation(const String &functionName, int groupOrder, int internalOrder, String returnType="void")
Class constructor.
virtual const String & getFunctionAtomType()
OperandVector & getOperandList()
Get a list of parameters this function invocation will use in the function call as arguments.
static String Type
The type of this class.
FunctionInvocation(const FunctionInvocation &rhs)
Copy constructor.
const String & getFunctionName() const
Return the function name.
void pushOperand(ParameterPtr parameter, Operand::OpSemantic opSemantic, int opMask=Operand::OPM_ALL, int indirectionLevel=0)
Push a new operand (on the end) to the function.
A class that represents a function operand (its the combination of a parameter the in/out semantic an...
~Operand()
Class destructor.
static GpuConstantType getGpuConstantType(int mask)
Return the gpu constant type of the given mask.
static int getFloatCount(int mask)
Return the float count of the given mask.
ushort mIndirectionLevel
The level of indirection.
OpSemantic mSemantic
Tells if the parameter is of type input,output or both.
const ParameterPtr & getParameter() const
Returns the parameter object as weak reference.
int getMask() const
Returns the mask bitfield.
@ OPS_IN
The parameter is a input parameter.
@ OPS_OUT
The parameter is a output parameter.
OpSemantic getSemantic() const
Returns the operand semantic (do we read/write or both with the parameter).
ushort getIndirectionLevel() const
Returns the level of indirection.
Operand(const Operand &rhs)
Copy constructor.
bool hasFreeFields() const
Returns true if not all fields used.
String toString() const
Returns the parameter name and the usage mask like this 'color.xyz'.
Operand(ParameterPtr parameter, Operand::OpSemantic opSemantic, int opMask=Operand::OPM_ALL, ushort indirectionLevel=0)
Class constructor.
int mMask
Which part of the parameter should be passed (x,y,z,w)
ParameterPtr mParameter
The parameter being carried by the operand.
static String getMaskAsString(int mask)
Returns the given mask as string representation.
bool operator<(SharedPtr< T > const &a, SharedPtr< U > const &b)
GpuConstantType
Enumeration of the types of constant we may encounter in programs.
bool operator!=(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator,...
bool operator==(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator,...
vector< FunctionAtom * >::type FunctionAtomInstanceList
FunctionAtomInstanceList::iterator FunctionAtomInstanceIterator
FunctionAtomInstanceList::const_iterator FunctionAtomInstanceConstIterator
_StringBase String
unsigned short ushort
bool operator()(FunctionInvocation const &lhs, FunctionInvocation const &rhs) const
bool operator()(FunctionInvocation const &lhs, FunctionInvocation const &rhs) const

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.