GPU: Rename GPU_shader_get_uniform to GPU_shader_get_uniform_ensure
[blender.git] / source / blender / gpu / GPU_shader.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2005 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Brecht Van Lommel.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file GPU_shader.h
29  *  \ingroup gpu
30  */
31
32 #ifndef __GPU_SHADER_H__
33 #define __GPU_SHADER_H__
34
35 #ifdef __cplusplus
36 extern "C" {
37 #endif
38
39 typedef struct GPUShader GPUShader;
40 struct GPUTexture;
41 struct GPUUniformBuffer;
42
43 /* GPU Shader
44  * - only for fragment shaders now
45  * - must call texture bind before setting a texture as uniform! */
46
47 typedef enum GPUShaderTFBType {
48         GPU_SHADER_TFB_NONE         = 0, /* Transform feedback unsupported. */
49         GPU_SHADER_TFB_POINTS       = 1,
50         GPU_SHADER_TFB_LINES        = 2,
51         GPU_SHADER_TFB_TRIANGLES    = 3,
52 } GPUShaderTFBType;
53
54 GPUShader *GPU_shader_create(
55         const char *vertexcode,
56         const char *fragcode,
57         const char *geocode,
58         const char *libcode,
59         const char *defines,
60         const char *shader_name);
61 GPUShader *GPU_shader_create_ex(
62         const char *vertexcode,
63         const char *fragcode,
64         const char *geocode,
65         const char *libcode,
66         const char *defines,
67         const GPUShaderTFBType tf_type,
68         const char **tf_names,
69         const int tf_count,
70         const char *shader_name);
71 void GPU_shader_free(GPUShader *shader);
72
73 void GPU_shader_bind(GPUShader *shader);
74 void GPU_shader_unbind(void);
75
76 /* Returns true if transform feedback was successfully enabled. */
77 bool GPU_shader_transform_feedback_enable(GPUShader *shader, unsigned int vbo_id);
78 void GPU_shader_transform_feedback_disable(GPUShader *shader);
79
80 int GPU_shader_get_program(GPUShader *shader);
81
82 void *GPU_shader_get_interface(GPUShader *shader);
83
84 int GPU_shader_get_uniform(GPUShader *shader, const char *name);
85 int GPU_shader_get_uniform_ensure(GPUShader *shader, const char *name);
86 int GPU_shader_get_builtin_uniform(GPUShader *shader, int builtin);
87 int GPU_shader_get_uniform_block(GPUShader *shader, const char *name);
88 void GPU_shader_uniform_vector(
89         GPUShader *shader, int location, int length,
90         int arraysize, const float *value);
91 void GPU_shader_uniform_vector_int(
92         GPUShader *shader, int location, int length,
93         int arraysize, const int *value);
94
95 void GPU_shader_uniform_buffer(GPUShader *shader, int location, struct GPUUniformBuffer *ubo);
96 void GPU_shader_uniform_texture(GPUShader *shader, int location, struct GPUTexture *tex);
97 void GPU_shader_uniform_float(GPUShader *shader, int location, float value);
98 void GPU_shader_uniform_int(GPUShader *shader, int location, int value);
99
100 int GPU_shader_get_attribute(GPUShader *shader, const char *name);
101
102 /* Builtin/Non-generated shaders */
103 typedef enum GPUBuiltinShader {
104         /* specialized drawing */
105         GPU_SHADER_TEXT,
106         GPU_SHADER_TEXT_SIMPLE,
107         GPU_SHADER_EDGES_FRONT_BACK_PERSP,
108         GPU_SHADER_EDGES_FRONT_BACK_ORTHO,
109         GPU_SHADER_EDGES_OVERLAY_SIMPLE,
110         GPU_SHADER_EDGES_OVERLAY,
111         GPU_SHADER_KEYFRAME_DIAMOND,
112         GPU_SHADER_SIMPLE_LIGHTING,
113         GPU_SHADER_SIMPLE_LIGHTING_FLAT_COLOR,
114         GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR,
115         GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR_ALPHA,
116
117         /* for simple 2D drawing */
118         /**
119          * Take a single color for all the vertices and a 2D position for each vertex.
120          *
121          * \param color: uniform vec4
122          * \param pos: in vec2
123          */
124         GPU_SHADER_2D_UNIFORM_COLOR,
125         /**
126          * Take a 2D position and color for each vertex without color interpolation.
127          *
128          * \param color: in vec4
129          * \param pos: in vec2
130          */
131         GPU_SHADER_2D_FLAT_COLOR,
132         /**
133          * Take a 2D position and color for each vertex with linear interpolation in window space.
134          *
135          * \param color: in vec4
136          * \param pos: in vec2
137          */
138         GPU_SHADER_2D_SMOOTH_COLOR,
139         GPU_SHADER_2D_SMOOTH_COLOR_DITHER,
140         GPU_SHADER_2D_IMAGE,
141         GPU_SHADER_2D_IMAGE_COLOR,
142         GPU_SHADER_2D_IMAGE_DESATURATE_COLOR,
143         GPU_SHADER_2D_IMAGE_ALPHA_COLOR,
144         GPU_SHADER_2D_IMAGE_ALPHA,
145         GPU_SHADER_2D_IMAGE_RECT_COLOR,
146         GPU_SHADER_2D_IMAGE_MULTI_RECT_COLOR,
147         GPU_SHADER_2D_IMAGE_MULTISAMPLE_2,
148         GPU_SHADER_2D_IMAGE_MULTISAMPLE_4,
149         GPU_SHADER_2D_IMAGE_MULTISAMPLE_8,
150         GPU_SHADER_2D_IMAGE_MULTISAMPLE_16,
151         GPU_SHADER_2D_IMAGE_MULTISAMPLE_2_DEPTH_TEST,
152         GPU_SHADER_2D_IMAGE_MULTISAMPLE_4_DEPTH_TEST,
153         GPU_SHADER_2D_IMAGE_MULTISAMPLE_8_DEPTH_TEST,
154         GPU_SHADER_2D_IMAGE_MULTISAMPLE_16_DEPTH_TEST,
155         GPU_SHADER_2D_CHECKER,
156         GPU_SHADER_2D_DIAG_STRIPES,
157         /* for simple 3D drawing */
158         /**
159          * Take a single color for all the vertices and a 3D position for each vertex.
160          *
161          * \param color: uniform vec4
162          * \param pos: in vec3
163          */
164         GPU_SHADER_3D_UNIFORM_COLOR,
165         GPU_SHADER_3D_UNIFORM_COLOR_INSTANCE,
166         /**
167          * Take a 3D position and color for each vertex without color interpolation.
168          *
169          * \param color: in vec4
170          * \param pos: in vec3
171          */
172         GPU_SHADER_3D_FLAT_COLOR,
173         /**
174          * Take a 3D position and color for each vertex with perspective correct interpolation.
175          *
176          * \param color: in vec4
177          * \param pos: in vec3
178          */
179         GPU_SHADER_3D_SMOOTH_COLOR,
180         /**
181          * Take a 3D position for each vertex and output only depth.
182          *
183          * \param pos: in vec3
184          */
185         GPU_SHADER_3D_DEPTH_ONLY,
186         GPU_SHADER_3D_CLIPPED_UNIFORM_COLOR,
187         /* basic image drawing */
188         GPU_SHADER_2D_IMAGE_LINEAR_TO_SRGB,
189         GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR,
190         GPU_SHADER_2D_IMAGE_MASK_UNIFORM_COLOR,
191         /**
192          * Draw texture with alpha. Take a 3D position and a 2D texture coordinate for each vertex.
193          *
194          * \param alpha: uniform float
195          * \param image: uniform sampler2D
196          * \param texCoord: in vec2
197          * \param pos: in vec3
198          */
199         GPU_SHADER_3D_IMAGE_MODULATE_ALPHA,
200         /**
201          * Draw linearized depth texture relate to near and far distances.
202          * Take a 3D position and a 2D texture coordinate for each vertex.
203          *
204          * \param znear: uniform float
205          * \param zfar: uniform float
206          * \param image: uniform sampler2D
207          * \param texCoord: in vec2
208          * \param pos: in vec3
209          */
210         GPU_SHADER_3D_IMAGE_DEPTH,
211         GPU_SHADER_3D_IMAGE_DEPTH_COPY,
212         /* stereo 3d */
213         GPU_SHADER_2D_IMAGE_INTERLACE,
214         /* points */
215         /**
216          * Draw round points with a hardcoded size.
217          * Take a single color for all the vertices and a 2D position for each vertex.
218          *
219          * \param color: uniform vec4
220          * \param pos: in vec2
221          */
222         GPU_SHADER_2D_POINT_FIXED_SIZE_UNIFORM_COLOR,
223         /**
224          * Draw round points with a constant size.
225          * Take a single color for all the vertices and a 2D position for each vertex.
226          *
227          * \param size: uniform float
228          * \param color: uniform vec4
229          * \param pos: in vec2
230          */
231         GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA,
232         /**
233          * Draw round points with a constant size and an outline.
234          * Take a single color for all the vertices and a 2D position for each vertex.
235          *
236          * \param size: uniform float
237          * \param outlineWidth: uniform float
238          * \param color: uniform vec4
239          * \param outlineColor: uniform vec4
240          * \param pos: in vec2
241          */
242         GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA,
243         /**
244          * Draw round points with a constant size and an outline. Take a 2D position and a color for each vertex.
245          *
246          * \param size: uniform float
247          * \param outlineWidth: uniform float
248          * \param outlineColor: uniform vec4
249          * \param color: in vec4
250          * \param pos: in vec2
251          */
252         GPU_SHADER_2D_POINT_UNIFORM_SIZE_VARYING_COLOR_OUTLINE_AA,
253         /**
254          * Draw round points with a constant size and an outline. Take a 2D position and a color for each vertex.
255          *
256          * \param size: in float
257          * \param color: in vec4
258          * \param pos: in vec2
259          */
260         GPU_SHADER_2D_POINT_VARYING_SIZE_VARYING_COLOR,
261         /**
262          * Draw round points with a hardcoded size.
263          * Take a single color for all the vertices and a 3D position for each vertex.
264          *
265          * \param color: uniform vec4
266          * \param pos: in vec3
267          */
268         GPU_SHADER_3D_POINT_FIXED_SIZE_UNIFORM_COLOR,
269         /**
270          * Draw round points with a hardcoded size.
271          * Take a single color for all the vertices and a 3D position for each vertex.
272          *
273          * \param color: uniform vec4
274          * \param pos: in vec3
275          */
276         GPU_SHADER_3D_POINT_FIXED_SIZE_VARYING_COLOR,
277         /**
278          * Draw round points with a constant size.
279          * Take a single color for all the vertices and a 3D position for each vertex.
280          *
281          * \param size: uniform float
282          * \param color: uniform vec4
283          * \param pos: in vec3
284          */
285         GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA,
286         /**
287          * Draw round points with a constant size and an outline.
288          * Take a single color for all the vertices and a 3D position for each vertex.
289          *
290          * \param size: uniform float
291          * \param outlineWidth: uniform float
292          * \param color: uniform vec4
293          * \param outlineColor: uniform vec4
294          * \param pos: in vec3
295          */
296         GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA,
297         /**
298          * Draw round points with a constant size and an outline.
299          * Take a single color for all the vertices and a 3D position for each vertex.
300          *
301          * \param color: uniform vec4
302          * \param size: in float
303          * \param pos: in vec3
304          */
305         GPU_SHADER_3D_POINT_VARYING_SIZE_UNIFORM_COLOR,
306         /**
307          * Draw round points with a constant size and an outline. Take a 3D position and a color for each vertex.
308          *
309          * \param size: in float
310          * \param color: in vec4
311          * \param pos: in vec3
312          */
313         GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR,
314         /* lines */
315         GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR,
316         GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR,
317         /* lamp drawing */
318         GPU_SHADER_3D_GROUNDPOINT,
319         GPU_SHADER_3D_GROUNDLINE,
320         GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR,
321         /* bone drawing */
322         GPU_SHADER_3D_OBJECTSPACE_VARIYING_COLOR,
323         GPU_SHADER_3D_OBJECTSPACE_SIMPLE_LIGHTING_VARIYING_COLOR,
324         /* camera drawing */
325         GPU_SHADER_CAMERA,
326         /* distance in front of objects */
327         GPU_SHADER_DISTANCE_LINES,
328         /* axis name */
329         GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED_AXIS,
330         GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED,
331         /* instance */
332         GPU_SHADER_INSTANCE_UNIFORM_COLOR,
333         GPU_SHADER_INSTANCE_VARIYING_ID_VARIYING_SIZE, /* Uniformly scaled */
334         GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, /* Uniformly scaled */
335         GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE,
336         GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR,
337         /* grease pencil drawing */
338         GPU_SHADER_GPENCIL_STROKE,
339         GPU_SHADER_GPENCIL_FILL,
340         /* specialized for widget drawing */
341         GPU_SHADER_2D_AREA_EDGES,
342         GPU_SHADER_2D_WIDGET_BASE,
343         GPU_SHADER_2D_WIDGET_BASE_INST,
344         GPU_SHADER_2D_WIDGET_SHADOW,
345         GPU_SHADER_2D_NODELINK,
346         GPU_SHADER_2D_NODELINK_INST,
347         /* specialized for edituv drawing */
348         GPU_SHADER_2D_UV_UNIFORM_COLOR,
349         GPU_SHADER_2D_UV_VERTS,
350         GPU_SHADER_2D_UV_FACEDOTS,
351         GPU_SHADER_2D_UV_EDGES,
352         GPU_SHADER_2D_UV_EDGES_SMOOTH,
353         GPU_SHADER_2D_UV_FACES,
354         GPU_SHADER_2D_UV_FACES_STRETCH_AREA,
355         GPU_SHADER_2D_UV_FACES_STRETCH_ANGLE,
356         /* Selection */
357         GPU_SHADER_3D_FLAT_SELECT_ID,
358         GPU_SHADER_3D_UNIFORM_SELECT_ID,
359
360         GPU_NUM_BUILTIN_SHADERS /* (not an actual shader) */
361 } GPUBuiltinShader;
362
363 /** Keep these in sync with:
364  * - `gpu_shader_image_interlace_frag.glsl`
365  * - `gpu_shader_image_rect_interlace_frag.glsl`
366  */
367 typedef enum GPUInterlaceShader {
368         GPU_SHADER_INTERLACE_ROW               = 0,
369         GPU_SHADER_INTERLACE_COLUMN            = 1,
370         GPU_SHADER_INTERLACE_CHECKER           = 2,
371 } GPUInterlaceShader;
372
373 GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader);
374
375 void GPU_shader_get_builtin_shader_code(
376         GPUBuiltinShader shader,
377         const char **r_vert, const char **r_frag,
378         const char **r_geom, const char **r_defines);
379
380 void GPU_shader_free_builtin_shaders(void);
381
382 /* Vertex attributes for shaders */
383
384 #define GPU_MAX_ATTRIB 32
385
386 typedef struct GPUVertexAttribs {
387         struct {
388                 int type;
389                 int glindex;
390                 int glinfoindoex;
391                 int gltexco;
392                 int attribid;
393                 char name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
394         } layer[GPU_MAX_ATTRIB];
395
396         int totlayer;
397 } GPUVertexAttribs;
398
399 #ifdef __cplusplus
400 }
401 #endif
402
403 #endif  /* __GPU_SHADER_H__ */