Fix T67459: Dope Editor, muting channels with shortcut doesn't work
[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
21  * \ingroup gpu
22  */
23
24 #ifndef __GPU_SHADER_H__
25 #define __GPU_SHADER_H__
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 typedef struct GPUShader GPUShader;
32 struct GPUTexture;
33 struct GPUUniformBuffer;
34
35 /* GPU Shader
36  * - only for fragment shaders now
37  * - must call texture bind before setting a texture as uniform! */
38
39 typedef enum eGPUShaderTFBType {
40   GPU_SHADER_TFB_NONE = 0, /* Transform feedback unsupported. */
41   GPU_SHADER_TFB_POINTS = 1,
42   GPU_SHADER_TFB_LINES = 2,
43   GPU_SHADER_TFB_TRIANGLES = 3,
44 } eGPUShaderTFBType;
45
46 GPUShader *GPU_shader_create(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(const char *vertexcode,
53                                 const char *fragcode,
54                                 const char *geocode,
55                                 const char *libcode,
56                                 const char *defines,
57                                 const eGPUShaderTFBType tf_type,
58                                 const char **tf_names,
59                                 const int tf_count,
60                                 const char *shader_name);
61 GPUShader *GPU_shader_load_from_binary(const char *binary,
62                                        const int binary_format,
63                                        const int binary_len,
64                                        const char *shname);
65 struct GPU_ShaderCreateFromArray_Params {
66   const char **vert, **geom, **frag, **defs;
67 };
68 struct GPUShader *GPU_shader_create_from_arrays_impl(
69     const struct GPU_ShaderCreateFromArray_Params *params);
70 #define GPU_shader_create_from_arrays(...) \
71   GPU_shader_create_from_arrays_impl(&(const struct GPU_ShaderCreateFromArray_Params)__VA_ARGS__)
72
73 void GPU_shader_free(GPUShader *shader);
74
75 void GPU_shader_bind(GPUShader *shader);
76 void GPU_shader_unbind(void);
77
78 /* Returns true if transform feedback was successfully enabled. */
79 bool GPU_shader_transform_feedback_enable(GPUShader *shader, unsigned int vbo_id);
80 void GPU_shader_transform_feedback_disable(GPUShader *shader);
81
82 int GPU_shader_get_program(GPUShader *shader);
83
84 void *GPU_shader_get_interface(GPUShader *shader);
85
86 int GPU_shader_get_uniform(GPUShader *shader, const char *name);
87 int GPU_shader_get_uniform_ensure(GPUShader *shader, const char *name);
88 int GPU_shader_get_builtin_uniform(GPUShader *shader, int builtin);
89 int GPU_shader_get_uniform_block(GPUShader *shader, const char *name);
90 void GPU_shader_uniform_vector(
91     GPUShader *shader, int location, int length, int arraysize, const float *value);
92 void GPU_shader_uniform_vector_int(
93     GPUShader *shader, int location, int length, 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 char *GPU_shader_get_binary(GPUShader *shader, uint *r_binary_format, int *r_binary_len);
103
104 /* Builtin/Non-generated shaders */
105 typedef enum eGPUBuiltinShader {
106   /* specialized drawing */
107   GPU_SHADER_TEXT,
108   GPU_SHADER_TEXT_SIMPLE,
109   GPU_SHADER_KEYFRAME_DIAMOND,
110   GPU_SHADER_SIMPLE_LIGHTING,
111   GPU_SHADER_SIMPLE_LIGHTING_FLAT_COLOR,
112   GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR,
113   GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR_ALPHA,
114
115   /* for simple 2D drawing */
116   /**
117    * Take a single color for all the vertices and a 2D position for each vertex.
118    *
119    * \param color: uniform vec4
120    * \param pos: in vec2
121    */
122   GPU_SHADER_2D_UNIFORM_COLOR,
123   /**
124    * Take a 2D position and color for each vertex without color interpolation.
125    *
126    * \param color: in vec4
127    * \param pos: in vec2
128    */
129   GPU_SHADER_2D_FLAT_COLOR,
130   /**
131    * Take a 2D position and color for each vertex with linear interpolation in window space.
132    *
133    * \param color: in vec4
134    * \param pos: in vec2
135    */
136   GPU_SHADER_2D_SMOOTH_COLOR,
137   GPU_SHADER_2D_SMOOTH_COLOR_DITHER,
138   GPU_SHADER_2D_IMAGE,
139   GPU_SHADER_2D_IMAGE_COLOR,
140   GPU_SHADER_2D_IMAGE_DESATURATE_COLOR,
141   GPU_SHADER_2D_IMAGE_ALPHA_COLOR,
142   GPU_SHADER_2D_IMAGE_ALPHA,
143   GPU_SHADER_2D_IMAGE_RECT_COLOR,
144   GPU_SHADER_2D_IMAGE_MULTI_RECT_COLOR,
145   GPU_SHADER_2D_IMAGE_MULTISAMPLE_2,
146   GPU_SHADER_2D_IMAGE_MULTISAMPLE_4,
147   GPU_SHADER_2D_IMAGE_MULTISAMPLE_8,
148   GPU_SHADER_2D_IMAGE_MULTISAMPLE_16,
149   GPU_SHADER_2D_IMAGE_MULTISAMPLE_2_DEPTH_TEST,
150   GPU_SHADER_2D_IMAGE_MULTISAMPLE_4_DEPTH_TEST,
151   GPU_SHADER_2D_IMAGE_MULTISAMPLE_8_DEPTH_TEST,
152   GPU_SHADER_2D_IMAGE_MULTISAMPLE_16_DEPTH_TEST,
153   GPU_SHADER_2D_CHECKER,
154   GPU_SHADER_2D_DIAG_STRIPES,
155   /* for simple 3D drawing */
156   /**
157    * Take a single color for all the vertices and a 3D position for each vertex.
158    *
159    * \param color: uniform vec4
160    * \param pos: in vec3
161    */
162   GPU_SHADER_3D_UNIFORM_COLOR,
163   /* Sets Z-depth to 1.0 (draw onto background). */
164   GPU_SHADER_3D_UNIFORM_COLOR_BACKGROUND,
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.
244    * 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.
255    * Take a 2D position and a color for each vertex.
256    *
257    * \param size: in float
258    * \param color: in vec4
259    * \param pos: in vec2
260    */
261   GPU_SHADER_2D_POINT_VARYING_SIZE_VARYING_COLOR,
262   /**
263    * Draw round points with a hardcoded size.
264    * Take a single color for all the vertices and a 3D position for each vertex.
265    *
266    * \param color: uniform vec4
267    * \param pos: in vec3
268    */
269   GPU_SHADER_3D_POINT_FIXED_SIZE_UNIFORM_COLOR,
270   /**
271    * Draw round points with a hardcoded size.
272    * Take a single color for all the vertices and a 3D position for each vertex.
273    *
274    * \param color: uniform vec4
275    * \param pos: in vec3
276    */
277   GPU_SHADER_3D_POINT_FIXED_SIZE_VARYING_COLOR,
278   /**
279    * Draw round points with a constant size.
280    * Take a single color for all the vertices and a 3D position for each vertex.
281    *
282    * \param size: uniform float
283    * \param color: uniform vec4
284    * \param pos: in vec3
285    */
286   GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA,
287   /**
288    * Draw round points with a constant size and an outline.
289    * Take a single color for all the vertices and a 3D position for each vertex.
290    *
291    * \param size: uniform float
292    * \param outlineWidth: uniform float
293    * \param color: uniform vec4
294    * \param outlineColor: uniform vec4
295    * \param pos: in vec3
296    */
297   GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA,
298   /**
299    * Draw round points with a constant size and an outline.
300    * Take a single color for all the vertices and a 3D position for each vertex.
301    *
302    * \param color: uniform vec4
303    * \param size: in float
304    * \param pos: in vec3
305    */
306   GPU_SHADER_3D_POINT_VARYING_SIZE_UNIFORM_COLOR,
307   /**
308    * Draw round points with a constant size and an outline.
309    * Take a 3D position and a color for each vertex.
310    *
311    * \param size: in float
312    * \param color: in vec4
313    * \param pos: in vec3
314    */
315   GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR,
316   /* lines */
317   GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR,
318   GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR,
319   /* light drawing */
320   GPU_SHADER_3D_GROUNDPOINT,
321   GPU_SHADER_3D_GROUNDLINE,
322   GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR,
323   /* bone drawing */
324   GPU_SHADER_3D_OBJECTSPACE_VARIYING_COLOR,
325   GPU_SHADER_3D_OBJECTSPACE_SIMPLE_LIGHTING_VARIYING_COLOR,
326   /* camera drawing */
327   GPU_SHADER_CAMERA,
328   /* distance in front of objects */
329   GPU_SHADER_DISTANCE_LINES,
330   /* axis name */
331   GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED_AXIS,
332   GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED,
333   /* instance */
334   GPU_SHADER_INSTANCE_UNIFORM_COLOR,
335   GPU_SHADER_INSTANCE_VARIYING_ID_VARIYING_SIZE,    /* Uniformly scaled */
336   GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, /* Uniformly scaled */
337   GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE,
338   GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR,
339   /* grease pencil drawing */
340   GPU_SHADER_GPENCIL_STROKE,
341   GPU_SHADER_GPENCIL_FILL,
342   /* specialized for widget drawing */
343   GPU_SHADER_2D_AREA_EDGES,
344   GPU_SHADER_2D_WIDGET_BASE,
345   GPU_SHADER_2D_WIDGET_BASE_INST,
346   GPU_SHADER_2D_WIDGET_SHADOW,
347   GPU_SHADER_2D_NODELINK,
348   GPU_SHADER_2D_NODELINK_INST,
349   /* specialized for edituv drawing */
350   GPU_SHADER_2D_UV_UNIFORM_COLOR,
351   GPU_SHADER_2D_UV_VERTS,
352   GPU_SHADER_2D_UV_FACEDOTS,
353   GPU_SHADER_2D_UV_EDGES,
354   GPU_SHADER_2D_UV_EDGES_SMOOTH,
355   GPU_SHADER_2D_UV_FACES,
356   GPU_SHADER_2D_UV_FACES_STRETCH_AREA,
357   GPU_SHADER_2D_UV_FACES_STRETCH_ANGLE,
358   /* Selection */
359   GPU_SHADER_3D_FLAT_SELECT_ID,
360   GPU_SHADER_3D_UNIFORM_SELECT_ID,
361 } eGPUBuiltinShader;
362 #define GPU_SHADER_BUILTIN_LEN (GPU_SHADER_3D_UNIFORM_SELECT_ID + 1)
363
364 /** Support multiple configurations. */
365 typedef enum eGPUShaderConfig {
366   GPU_SHADER_CFG_DEFAULT = 0,
367   GPU_SHADER_CFG_CLIPPED = 1,
368 } eGPUShaderConfig;
369 #define GPU_SHADER_CFG_LEN (GPU_SHADER_CFG_CLIPPED + 1)
370
371 typedef struct GPUShaderConfigData {
372   const char *lib;
373   const char *def;
374 } GPUShaderConfigData;
375 /* gpu_shader.c */
376 extern const GPUShaderConfigData GPU_shader_cfg_data[GPU_SHADER_CFG_LEN];
377
378 /** Keep these in sync with:
379  * - `gpu_shader_image_interlace_frag.glsl`
380  * - `gpu_shader_image_rect_interlace_frag.glsl`
381  */
382 typedef enum eGPUInterlaceShader {
383   GPU_SHADER_INTERLACE_ROW = 0,
384   GPU_SHADER_INTERLACE_COLUMN = 1,
385   GPU_SHADER_INTERLACE_CHECKER = 2,
386 } eGPUInterlaceShader;
387
388 GPUShader *GPU_shader_get_builtin_shader_with_config(eGPUBuiltinShader shader,
389                                                      eGPUShaderConfig sh_cfg);
390 GPUShader *GPU_shader_get_builtin_shader(eGPUBuiltinShader shader);
391
392 void GPU_shader_get_builtin_shader_code(eGPUBuiltinShader shader,
393                                         const char **r_vert,
394                                         const char **r_frag,
395                                         const char **r_geom,
396                                         const char **r_defines);
397
398 void GPU_shader_free_builtin_shaders(void);
399
400 /* Vertex attributes for shaders */
401
402 #define GPU_MAX_ATTR 32
403
404 typedef struct GPUVertAttrLayers {
405   struct {
406     int type; /* CustomDataType */
407     int attr_id;
408     char name[64]; /* MAX_CUSTOMDATA_LAYER_NAME */
409   } layer[GPU_MAX_ATTR];
410
411   int totlayer;
412 } GPUVertAttrLayers;
413
414 #ifdef __cplusplus
415 }
416 #endif
417
418 #endif /* __GPU_SHADER_H__ */