Remove useless comment from Base.xcconfig
[WebKit-https.git] / Source / ThirdParty / ANGLE / include / GLSLANG / ShaderLang.h
1 //
2 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 #ifndef _COMPILER_INTERFACE_INCLUDED_
7 #define _COMPILER_INTERFACE_INCLUDED_
8
9 #if defined(COMPONENT_BUILD)
10 #if defined(_WIN32) || defined(_WIN64)
11
12 #if defined(COMPILER_IMPLEMENTATION)
13 #define COMPILER_EXPORT __declspec(dllexport)
14 #else
15 #define COMPILER_EXPORT __declspec(dllimport)
16 #endif  // defined(COMPILER_IMPLEMENTATION)
17
18 #else  // defined(WIN32)
19 #define COMPILER_EXPORT __attribute__((visibility("default")))
20 #endif
21
22 #else  // defined(COMPONENT_BUILD)
23 #define COMPILER_EXPORT
24 #endif
25
26 #include "khrplatform.h"
27
28 //
29 // This is the platform independent interface between an OGL driver
30 // and the shading language compiler.
31 //
32
33 #ifdef __cplusplus
34 extern "C" {
35 #endif
36
37 // Version number for shader translation API.
38 // It is incremented everytime the API changes.
39 #define SH_VERSION 107
40
41 //
42 // The names of the following enums have been derived by replacing GL prefix
43 // with SH. For example, SH_INFO_LOG_LENGTH is equivalent to GL_INFO_LOG_LENGTH.
44 // The enum values are also equal to the values of their GL counterpart. This
45 // is done to make it easier for applications to use the shader library.
46 //
47 typedef enum {
48   SH_FRAGMENT_SHADER = 0x8B30,
49   SH_VERTEX_SHADER   = 0x8B31
50 } ShShaderType;
51
52 typedef enum {
53   SH_GLES2_SPEC = 0x8B40,
54   SH_WEBGL_SPEC = 0x8B41,
55
56   // The CSS Shaders spec is a subset of the WebGL spec.
57   //
58   // In both CSS vertex and fragment shaders, ANGLE:
59   // (1) Reserves the "css_" prefix.
60   // (2) Renames the main function to css_main.
61   // (3) Disables the gl_MaxDrawBuffers built-in.
62   //
63   // In CSS fragment shaders, ANGLE:
64   // (1) Disables the gl_FragColor built-in.
65   // (2) Disables the gl_FragData built-in.
66   // (3) Enables the css_MixColor built-in.
67   // (4) Enables the css_ColorMatrix built-in.
68   //
69   // After passing a CSS shader through ANGLE, the browser is expected to append
70   // a new main function to it.
71   // This new main function will call the css_main function.
72   // It may also perform additional operations like varying assignment, texture
73   // access, and gl_FragColor assignment in order to implement the CSS Shaders
74   // blend modes.
75   //
76   SH_CSS_SHADERS_SPEC = 0x8B42
77 } ShShaderSpec;
78
79 typedef enum {
80   SH_ESSL_OUTPUT = 0x8B45,
81   SH_GLSL_OUTPUT = 0x8B46,
82   SH_HLSL_OUTPUT = 0x8B47
83 } ShShaderOutput;
84
85 typedef enum {
86   SH_NONE           = 0,
87   SH_INT            = 0x1404,
88   SH_FLOAT          = 0x1406,
89   SH_FLOAT_VEC2     = 0x8B50,
90   SH_FLOAT_VEC3     = 0x8B51,
91   SH_FLOAT_VEC4     = 0x8B52,
92   SH_INT_VEC2       = 0x8B53,
93   SH_INT_VEC3       = 0x8B54,
94   SH_INT_VEC4       = 0x8B55,
95   SH_BOOL           = 0x8B56,
96   SH_BOOL_VEC2      = 0x8B57,
97   SH_BOOL_VEC3      = 0x8B58,
98   SH_BOOL_VEC4      = 0x8B59,
99   SH_FLOAT_MAT2     = 0x8B5A,
100   SH_FLOAT_MAT3     = 0x8B5B,
101   SH_FLOAT_MAT4     = 0x8B5C,
102   SH_SAMPLER_2D     = 0x8B5E,
103   SH_SAMPLER_CUBE   = 0x8B60,
104   SH_SAMPLER_2D_RECT_ARB = 0x8B63,
105   SH_SAMPLER_EXTERNAL_OES = 0x8D66
106 } ShDataType;
107
108 typedef enum {
109   SH_INFO_LOG_LENGTH             =  0x8B84,
110   SH_OBJECT_CODE_LENGTH          =  0x8B88,  // GL_SHADER_SOURCE_LENGTH
111   SH_ACTIVE_UNIFORMS             =  0x8B86,
112   SH_ACTIVE_UNIFORM_MAX_LENGTH   =  0x8B87,
113   SH_ACTIVE_ATTRIBUTES           =  0x8B89,
114   SH_ACTIVE_ATTRIBUTE_MAX_LENGTH =  0x8B8A,
115   SH_MAPPED_NAME_MAX_LENGTH      =  0x6000,
116   SH_NAME_MAX_LENGTH             =  0x6001,
117   SH_HASHED_NAME_MAX_LENGTH      =  0x6002,
118   SH_HASHED_NAMES_COUNT          =  0x6003
119 } ShShaderInfo;
120
121 // Compile options.
122 typedef enum {
123   SH_VALIDATE                = 0,
124   SH_VALIDATE_LOOP_INDEXING  = 0x0001,
125   SH_INTERMEDIATE_TREE       = 0x0002,
126   SH_OBJECT_CODE             = 0x0004,
127   SH_ATTRIBUTES_UNIFORMS     = 0x0008,
128   SH_LINE_DIRECTIVES         = 0x0010,
129   SH_SOURCE_PATH             = 0x0020,
130   SH_MAP_LONG_VARIABLE_NAMES = 0x0040,
131   SH_UNROLL_FOR_LOOP_WITH_INTEGER_INDEX = 0x0080,
132
133   // This is needed only as a workaround for certain OpenGL driver bugs.
134   SH_EMULATE_BUILT_IN_FUNCTIONS = 0x0100,
135
136   // This is an experimental flag to enforce restrictions that aim to prevent 
137   // timing attacks.
138   // It generates compilation errors for shaders that could expose sensitive
139   // texture information via the timing channel.
140   // To use this flag, you must compile the shader under the WebGL spec
141   // (using the SH_WEBGL_SPEC flag).
142   SH_TIMING_RESTRICTIONS = 0x0200,
143     
144   // This flag prints the dependency graph that is used to enforce timing
145   // restrictions on fragment shaders.
146   // This flag only has an effect if all of the following are true:
147   // - The shader spec is SH_WEBGL_SPEC.
148   // - The compile options contain the SH_TIMING_RESTRICTIONS flag.
149   // - The shader type is SH_FRAGMENT_SHADER.
150   SH_DEPENDENCY_GRAPH = 0x0400,
151
152   // Enforce the GLSL 1.017 Appendix A section 7 packing restrictions.
153   SH_ENFORCE_PACKING_RESTRICTIONS = 0x0800,
154
155   // This flag ensures all indirect (expression-based) array indexing
156   // is clamped to the bounds of the array. This ensures, for example,
157   // that you cannot read off the end of a uniform, whether an array
158   // vec234, or mat234 type.
159   SH_CLAMP_INDIRECT_ARRAY_BOUNDS = 0x1000
160 } ShCompileOptions;
161
162 //
163 // Driver must call this first, once, before doing any other
164 // compiler operations.
165 // If the function succeeds, the return value is nonzero, else zero.
166 //
167 COMPILER_EXPORT int ShInitialize();
168 //
169 // Driver should call this at shutdown.
170 // If the function succeeds, the return value is nonzero, else zero.
171 //
172 COMPILER_EXPORT int ShFinalize();
173
174 // The 64 bits hash function. The first parameter is the input string; the
175 // second parameter is the string length.
176 typedef khronos_uint64_t (*ShHashFunction64)(const char*, unsigned int);
177
178 //
179 // Implementation dependent built-in resources (constants and extensions).
180 // The names for these resources has been obtained by stripping gl_/GL_.
181 //
182 typedef struct
183 {
184     // Constants.
185     int MaxVertexAttribs;
186     int MaxVertexUniformVectors;
187     int MaxVaryingVectors;
188     int MaxVertexTextureImageUnits;
189     int MaxCombinedTextureImageUnits;
190     int MaxTextureImageUnits;
191     int MaxFragmentUniformVectors;
192     int MaxDrawBuffers;
193
194     // Extensions.
195     // Set to 1 to enable the extension, else 0.
196     int OES_standard_derivatives;
197     int OES_EGL_image_external;
198     int ARB_texture_rectangle;
199
200     // Name Hashing.
201     // Set a 64 bit hash function to enable user-defined name hashing.
202     // Default is NULL.
203     ShHashFunction64 HashFunction;
204 } ShBuiltInResources;
205
206 //
207 // Initialize built-in resources with minimum expected values.
208 //
209 COMPILER_EXPORT void ShInitBuiltInResources(ShBuiltInResources* resources);
210
211 //
212 // ShHandle held by but opaque to the driver.  It is allocated,
213 // managed, and de-allocated by the compiler. It's contents 
214 // are defined by and used by the compiler.
215 //
216 // If handle creation fails, 0 will be returned.
217 //
218 typedef void* ShHandle;
219
220 //
221 // Driver calls these to create and destroy compiler objects.
222 //
223 // Returns the handle of constructed compiler, null if the requested compiler is
224 // not supported.
225 // Parameters:
226 // type: Specifies the type of shader - SH_FRAGMENT_SHADER or SH_VERTEX_SHADER.
227 // spec: Specifies the language spec the compiler must conform to -
228 //       SH_GLES2_SPEC or SH_WEBGL_SPEC.
229 // output: Specifies the output code type - SH_ESSL_OUTPUT, SH_GLSL_OUTPUT,
230 //         or SH_HLSL_OUTPUT.
231 // resources: Specifies the built-in resources.
232 COMPILER_EXPORT ShHandle ShConstructCompiler(
233     ShShaderType type,
234     ShShaderSpec spec,
235     ShShaderOutput output,
236     const ShBuiltInResources* resources);
237 COMPILER_EXPORT void ShDestruct(ShHandle handle);
238
239 //
240 // Compiles the given shader source.
241 // If the function succeeds, the return value is nonzero, else zero.
242 // Parameters:
243 // handle: Specifies the handle of compiler to be used.
244 // shaderStrings: Specifies an array of pointers to null-terminated strings
245 //                containing the shader source code.
246 // numStrings: Specifies the number of elements in shaderStrings array.
247 // compileOptions: A mask containing the following parameters:
248 // SH_VALIDATE: Validates shader to ensure that it conforms to the spec
249 //              specified during compiler construction.
250 // SH_VALIDATE_LOOP_INDEXING: Validates loop and indexing in the shader to
251 //                            ensure that they do not exceed the minimum
252 //                            functionality mandated in GLSL 1.0 spec,
253 //                            Appendix A, Section 4 and 5.
254 //                            There is no need to specify this parameter when
255 //                            compiling for WebGL - it is implied.
256 // SH_INTERMEDIATE_TREE: Writes intermediate tree to info log.
257 //                       Can be queried by calling ShGetInfoLog().
258 // SH_OBJECT_CODE: Translates intermediate tree to glsl or hlsl shader.
259 //                 Can be queried by calling ShGetObjectCode().
260 // SH_ATTRIBUTES_UNIFORMS: Extracts attributes and uniforms.
261 //                         Can be queried by calling ShGetActiveAttrib() and
262 //                         ShGetActiveUniform().
263 //
264 COMPILER_EXPORT int ShCompile(
265     const ShHandle handle,
266     const char* const shaderStrings[],
267     const int numStrings,
268     int compileOptions
269     );
270
271 // Returns a parameter from a compiled shader.
272 // Parameters:
273 // handle: Specifies the compiler
274 // pname: Specifies the parameter to query.
275 // The following parameters are defined:
276 // SH_INFO_LOG_LENGTH: the number of characters in the information log
277 //                     including the null termination character.
278 // SH_OBJECT_CODE_LENGTH: the number of characters in the object code
279 //                        including the null termination character.
280 // SH_ACTIVE_ATTRIBUTES: the number of active attribute variables.
281 // SH_ACTIVE_ATTRIBUTE_MAX_LENGTH: the length of the longest active attribute
282 //                                 variable name including the null
283 //                                 termination character.
284 // SH_ACTIVE_UNIFORMS: the number of active uniform variables.
285 // SH_ACTIVE_UNIFORM_MAX_LENGTH: the length of the longest active uniform
286 //                               variable name including the null
287 //                               termination character.
288 // SH_MAPPED_NAME_MAX_LENGTH: the length of the mapped variable name including
289 //                            the null termination character.
290 // SH_NAME_MAX_LENGTH: the max length of a user-defined name including the
291 //                     null termination character.
292 // SH_HASHED_NAME_MAX_LENGTH: the max length of a hashed name including the
293 //                            null termination character.
294 // SH_HASHED_NAMES_COUNT: the number of hashed names from the latest compile.
295 // 
296 // params: Requested parameter
297 COMPILER_EXPORT void ShGetInfo(const ShHandle handle,
298                                ShShaderInfo pname,
299                                int* params);
300
301 // Returns nul-terminated information log for a compiled shader.
302 // Parameters:
303 // handle: Specifies the compiler
304 // infoLog: Specifies an array of characters that is used to return
305 //          the information log. It is assumed that infoLog has enough memory
306 //          to accomodate the information log. The size of the buffer required
307 //          to store the returned information log can be obtained by calling
308 //          ShGetInfo with SH_INFO_LOG_LENGTH.
309 COMPILER_EXPORT void ShGetInfoLog(const ShHandle handle, char* infoLog);
310
311 // Returns null-terminated object code for a compiled shader.
312 // Parameters:
313 // handle: Specifies the compiler
314 // infoLog: Specifies an array of characters that is used to return
315 //          the object code. It is assumed that infoLog has enough memory to
316 //          accomodate the object code. The size of the buffer required to
317 //          store the returned object code can be obtained by calling
318 //          ShGetInfo with SH_OBJECT_CODE_LENGTH.
319 COMPILER_EXPORT void ShGetObjectCode(const ShHandle handle, char* objCode);
320
321 // Returns information about an active attribute variable.
322 // Parameters:
323 // handle: Specifies the compiler
324 // index: Specifies the index of the attribute variable to be queried.
325 // length: Returns the number of characters actually written in the string
326 //         indicated by name (excluding the null terminator) if a value other
327 //         than NULL is passed.
328 // size: Returns the size of the attribute variable.
329 // type: Returns the data type of the attribute variable.
330 // name: Returns a null terminated string containing the name of the
331 //       attribute variable. It is assumed that name has enough memory to
332 //       accomodate the attribute variable name. The size of the buffer
333 //       required to store the attribute variable name can be obtained by
334 //       calling ShGetInfo with SH_ACTIVE_ATTRIBUTE_MAX_LENGTH.
335 // mappedName: Returns a null terminated string containing the mapped name of
336 //             the attribute variable, It is assumed that mappedName has enough
337 //             memory (SH_MAPPED_NAME_MAX_LENGTH), or NULL if don't care
338 //             about the mapped name. If the name is not mapped, then name and
339 //             mappedName are the same.
340 COMPILER_EXPORT void ShGetActiveAttrib(const ShHandle handle,
341                                        int index,
342                                        int* length,
343                                        int* size,
344                                        ShDataType* type,
345                                        char* name,
346                                        char* mappedName);
347
348 // Returns information about an active uniform variable.
349 // Parameters:
350 // handle: Specifies the compiler
351 // index: Specifies the index of the uniform variable to be queried.
352 // length: Returns the number of characters actually written in the string
353 //         indicated by name (excluding the null terminator) if a value
354 //         other than NULL is passed.
355 // size: Returns the size of the uniform variable.
356 // type: Returns the data type of the uniform variable.
357 // name: Returns a null terminated string containing the name of the
358 //       uniform variable. It is assumed that name has enough memory to
359 //       accomodate the uniform variable name. The size of the buffer required
360 //       to store the uniform variable name can be obtained by calling
361 //       ShGetInfo with SH_ACTIVE_UNIFORMS_MAX_LENGTH.
362 // mappedName: Returns a null terminated string containing the mapped name of
363 //             the uniform variable, It is assumed that mappedName has enough
364 //             memory (SH_MAPPED_NAME_MAX_LENGTH), or NULL if don't care
365 //             about the mapped name. If the name is not mapped, then name and
366 //             mappedName are the same.
367 COMPILER_EXPORT void ShGetActiveUniform(const ShHandle handle,
368                                         int index,
369                                         int* length,
370                                         int* size,
371                                         ShDataType* type,
372                                         char* name,
373                                         char* mappedName);
374
375 // Returns information about a name hashing entry from the latest compile.
376 // Parameters:
377 // handle: Specifies the compiler
378 // index: Specifies the index of the name hashing entry to be queried.
379 // name: Returns a null terminated string containing the user defined name.
380 //       It is assumed that name has enough memory to accomodate the name.
381 //       The size of the buffer required to store the user defined name can
382 //       be obtained by calling ShGetInfo with SH_NAME_MAX_LENGTH.
383 // hashedName: Returns a null terminated string containing the hashed name of
384 //             the uniform variable, It is assumed that hashedName has enough
385 //             memory to accomodate the name. The size of the buffer required
386 //             to store the name can be obtained by calling ShGetInfo with
387 //             SH_HASHED_NAME_MAX_LENGTH.
388 COMPILER_EXPORT void ShGetNameHashingEntry(const ShHandle handle,
389                                            int index,
390                                            char* name,
391                                            char* hashedName);
392
393 #ifdef __cplusplus
394 }
395 #endif
396
397 #endif // _COMPILER_INTERFACE_INCLUDED_