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