Add UniformNameCache to keep track of unique uniform ids to avoid calculating hash...
[platform/core/uifw/dali-core.git] / dali / internal / render / shaders / program.h
1 #ifndef __DALI_INTERNAL_PROGRAM_H__
2 #define __DALI_INTERNAL_PROGRAM_H__
3
4 /*
5  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  */
20
21 // EXTERNAL INCLUDES
22 #include <string>
23
24 // INTERNAL INCLUDES
25 #include <dali/public-api/common/vector-wrapper.h>
26 #include <dali/public-api/object/ref-object.h>
27 #include <dali/integration-api/gl-abstraction.h>
28 #include <dali/internal/common/shader-data.h>
29
30 namespace Dali
31 {
32
33 class Matrix;
34
35 namespace Integration
36 {
37 class GlAbstraction;
38 class ShaderData;
39 }
40
41 namespace Internal
42 {
43
44 class ProgramCache;
45
46 /*
47  * A program contains a vertex & fragment shader.
48  *
49  * A program will contain vertex attributes and uniform variables.
50  *
51  * uColor is set to the value specified by Actor::SetColor and is
52  * animatable through the property Actor::COLOR
53  */
54 class Program
55 {
56 public:
57
58   /**
59    * Size of the uniform cache per program
60    * GLES specification states that minimum uniform count for fragment shader
61    * is 16 and for vertex shader 128. We're caching the 16 common ones for now
62    */
63   static const int MAX_UNIFORM_CACHE_SIZE = 16;
64
65   /**
66    * Constant for uniform / attribute not found
67    */
68   static const int NOT_FOUND = -1;
69
70   /**
71    * Vertex attributes
72    */
73   enum AttribType
74   {
75     ATTRIB_UNKNOWN = -1,
76     ATTRIB_POSITION,
77     ATTRIB_TEXCOORD,
78     ATTRIB_TYPE_LAST
79   };
80
81   /**
82    * Common shader uniform names
83    */
84   enum UniformType
85   {
86     UNIFORM_NOT_QUERIED = -2,
87     UNIFORM_UNKNOWN = -1,
88     UNIFORM_MVP_MATRIX,
89     UNIFORM_MODELVIEW_MATRIX,
90     UNIFORM_PROJECTION_MATRIX,
91     UNIFORM_MODEL_MATRIX,
92     UNIFORM_VIEW_MATRIX,
93     UNIFORM_NORMAL_MATRIX,
94     UNIFORM_COLOR,
95     UNIFORM_SAMPLER,
96     UNIFORM_SAMPLER_RECT,
97     UNIFORM_EFFECT_SAMPLER,
98
99     UNIFORM_SIZE,
100     UNIFORM_TYPE_LAST
101   };
102
103   /**
104    * Creates a new program, or returns a copy of an existing program in the program cache
105    * @param[in] cache where the programs are stored
106    * @param[in] shaderData  A pointer to a data structure containing the program source
107    *                        and optionally precompiled binary. If the binary is empty the program bytecode
108    *                        is copied into it after compilation and linking)
109    * @param[in] modifiesGeometry True if the shader modifies geometry
110    * @return pointer to the program
111    */
112   static Program* New( ProgramCache& cache, Internal::ShaderDataPtr shaderData, bool modifiesGeometry );
113
114   /**
115    * Takes this program into use
116    */
117   void Use();
118
119   /**
120    * @return true if this program is used currently
121    */
122   bool IsUsed();
123
124   /**
125    * @param [in] type of the attribute
126    * @return the index of the attribute
127    */
128   GLint GetAttribLocation( AttribType type );
129
130   /**
131    * Register an attribute name in our local cache
132    * @param [in] name attribute name
133    * @return the index of the attribute name in local cache
134    */
135   unsigned int RegisterCustomAttribute( const std::string& name );
136
137   /**
138    * Gets the location of a pre-registered attribute.
139    * @param [in] attributeIndex of the attribute in local cache
140    * @return the index of the attribute in the GL program
141    */
142   GLint GetCustomAttributeLocation( unsigned int attributeIndex );
143
144   /**
145    * Register a uniform name in our local cache
146    * @param [in] name uniform name
147    * @return the index of the uniform name in local cache
148    */
149   unsigned int RegisterUniform( const std::string& name );
150
151   /**
152    * Gets the location of a pre-registered uniform.
153    * Uniforms in list UniformType are always registered and in the order of the enumeration
154    * @param [in] uniformIndex of the uniform in local cache
155    * @return the index of the uniform in the GL program
156    */
157   GLint GetUniformLocation( unsigned int uniformIndex );
158
159   /**
160    * Gets the uniform location for a sampler
161    * @param [in] uniqueIndex of the sampler uniform in local cache
162    * @return the index of the uniform in the GL program
163    */
164   GLint GetSamplerUniformLocation( int32_t uniqueIndex, const std::string& samplerName );
165
166   /**
167    * Sets the uniform value
168    * @param [in] location of uniform
169    * @param [in] value0 as int
170    */
171   void SetUniform1i( GLint location, GLint value0 );
172
173   /**
174    * Sets the uniform value
175    * @param [in] location of uniform
176    * @param [in] value0 as int
177    * @param [in] value1 as int
178    * @param [in] value2 as int
179    * @param [in] value3 as int
180    */
181   void SetUniform4i( GLint location, GLint value0, GLint value1, GLint value2, GLint value3 );
182
183   /**
184    * Sets the uniform value
185    * @param [in] location of uniform
186    * @param [in] value0 as float
187    */
188   void SetUniform1f( GLint location, GLfloat value0 );
189
190   /**
191    * Sets the uniform value
192    * @param [in] location of uniform
193    * @param [in] value0 as float
194    * @param [in] value1 as float
195    */
196   void SetUniform2f( GLint location, GLfloat value0, GLfloat value1 );
197
198   /**
199    * Special handling for size as we're using uniform geometry so size is passed on to most programs
200    * but it rarely changes so we can cache it
201    * @param [in] location of uniform
202    * @param [in] value0 as float
203    * @param [in] value1 as float
204    * @param [in] value2 as float
205    */
206   void SetSizeUniform3f( GLint location, GLfloat value0, GLfloat value1, GLfloat value2 );
207
208   /**
209    * Sets the uniform value
210    * @param [in] location of uniform
211    * @param [in] value0 as float
212    * @param [in] value1 as float
213    * @param [in] value2 as float
214    */
215   void SetUniform3f( GLint location, GLfloat value0, GLfloat value1, GLfloat value2 );
216
217   /**
218    * Sets the uniform value
219    * @param [in] location of uniform
220    * @param [in] value0 as float
221    * @param [in] value1 as float
222    * @param [in] value2 as float
223    * @param [in] value3 as float
224    */
225   void SetUniform4f( GLint location, GLfloat value0, GLfloat value1, GLfloat value2, GLfloat value3 );
226
227   /**
228    * Sets the uniform value as matrix. NOTE! we never want GPU to transpose
229    * so make sure your matrix is in correct order for GL.
230    * @param [in] location Location of uniform
231    * @param [in] count Count of matrices
232    * @param [in] value values as float pointers
233    */
234   void SetUniformMatrix4fv( GLint location, GLsizei count, const GLfloat* value );
235
236   /**
237    * Sets the uniform value as matrix. NOTE! we never want GPU to transpose
238    * so make sure your matrix is in correct order for GL.
239    * @param [in] location Location of uniform
240    * @param [in] count Count of matrices
241    * @param [in] value values as float pointers
242    */
243   void SetUniformMatrix3fv( GLint location, GLsizei count, const GLfloat* value );
244
245   /**
246    * Needs to be called when GL context is (re)created
247    */
248   void GlContextCreated();
249
250   /**
251    * Needs to be called when GL context is destroyed
252    */
253   void GlContextDestroyed();
254
255   /**
256    * @return true if this program modifies geometry
257    */
258   bool ModifiesGeometry();
259
260   /**
261    * Set the projection matrix that has currently been sent
262    * @param matrix to set
263    */
264   void SetProjectionMatrix( const Matrix* matrix )
265   {
266     mProjectionMatrix = matrix;
267   }
268
269   /**
270    * Get the projection matrix that has currently been sent
271    * @return the matrix that is set
272    */
273   const Matrix* GetProjectionMatrix()
274   {
275     return mProjectionMatrix;
276   }
277
278   /**
279    * Set the projection matrix that has currently been sent
280    * @param matrix to set
281    */
282   void SetViewMatrix( const Matrix* matrix )
283   {
284     mViewMatrix = matrix;
285   }
286
287   /**
288    * Get the projection matrix that has currently been sent
289    * @return the matrix that is set
290    */
291   const Matrix* GetViewMatrix()
292   {
293     return mViewMatrix;
294   }
295
296 private: // Implementation
297
298   /**
299    * Constructor, private so no direct instantiation
300    * @param[in] cache where the programs are stored
301    * @param[in] shaderData A smart pointer to a data structure containing the program source and binary
302    * @param[in] modifiesGeometry True if the vertex shader changes geometry
303    */
304   Program( ProgramCache& cache, Internal::ShaderDataPtr shaderData, bool modifiesGeometry );
305
306 public:
307
308   /**
309    * Destructor, non virtual as no virtual methods or inheritance
310    */
311   ~Program();
312
313 private:
314
315   // default constructor, not defined
316   Program();
317   // assignment operator, not defined
318   Program& operator=( const Program& );
319
320   /**
321    * Load the shader, from a precompiled binary if available, else from source code
322    */
323   void Load();
324
325   /**
326    * Unload the shader
327    */
328   void Unload();
329
330   /**
331    * Compile the shader
332    * @param shaderType vertex or fragment shader
333    * @param shaderId of the shader, returned
334    * @param src of the shader
335    * @return true if the compilation succeeded
336    */
337   bool CompileShader(GLenum shaderType, GLuint& shaderId, const char* src);
338
339   /**
340    * Links the shaders together to create program
341    */
342   void Link();
343
344   /**
345    * Frees the shader programs
346    */
347   void FreeShaders();
348
349   /**
350    * Resets caches
351    */
352   void ResetAttribsUniformCache();
353
354 private:  // Data
355
356   ProgramCache& mCache;                       ///< The program cache
357   Integration::GlAbstraction& mGlAbstraction; ///< The OpenGL Abstraction layer
358   const Matrix* mProjectionMatrix;            ///< currently set projection matrix
359   const Matrix* mViewMatrix;                  ///< currently set view matrix
360   bool mLinked;                               ///< whether the program is linked
361   GLuint mVertexShaderId;                     ///< GL identifier for vertex shader
362   GLuint mFragmentShaderId;                   ///< GL identifier for fragment shader
363   GLuint mProgramId;                          ///< GL identifier for program
364   Internal::ShaderDataPtr mProgramData;    ///< Shader program source and binary (when compiled & linked or loaded)
365
366   // location caches
367   std::vector< std::pair< std::string, GLint > > mAttributeLocations; ///< attribute location cache
368   std::vector< std::pair< std::string, GLint > > mUniformLocations; ///< uniform location cache
369   Dali::Vector< GLint > mSamplerUniformLocations; ///< sampler uniform location cache
370
371   // uniform value caching
372   GLint mUniformCacheInt[ MAX_UNIFORM_CACHE_SIZE ];         ///< Value cache for uniforms of single int
373   GLfloat mUniformCacheFloat[ MAX_UNIFORM_CACHE_SIZE ];     ///< Value cache for uniforms of single float
374   GLfloat mUniformCacheFloat2[ MAX_UNIFORM_CACHE_SIZE ][2]; ///< Value cache for uniforms of two floats
375   GLfloat mUniformCacheFloat4[ MAX_UNIFORM_CACHE_SIZE ][4]; ///< Value cache for uniforms of four floats
376   Vector3 mSizeUniformCache;                                ///< Cache value for size uniform
377   bool mModifiesGeometry;  ///< True if the program changes geometry
378
379 };
380
381 } // namespace Internal
382
383 } // namespace Dali
384
385 #endif // __DALI_INTERNAL_PROGRAM_H__