Cleanup: comments (long lines) in gpu
[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 struct GPU_ShaderCreateFromArray_Params {
62   const char **vert, **geom, **frag, **defs;
63 };
64 struct GPUShader *GPU_shader_create_from_arrays_impl(
65     const struct GPU_ShaderCreateFromArray_Params *params);
66 #define GPU_shader_create_from_arrays(...) \
67   GPU_shader_create_from_arrays_impl(&(const struct GPU_ShaderCreateFromArray_Params)__VA_ARGS__)
68
69 void GPU_shader_free(GPUShader *shader);
70
71 void GPU_shader_bind(GPUShader *shader);
72 void GPU_shader_unbind(void);
73
74 /* Returns true if transform feedback was successfully enabled. */
75 bool GPU_shader_transform_feedback_enable(GPUShader *shader, unsigned int vbo_id);
76 void GPU_shader_transform_feedback_disable(GPUShader *shader);
77
78 int GPU_shader_get_program(GPUShader *shader);
79
80 void *GPU_shader_get_interface(GPUShader *shader);
81
82 int GPU_shader_get_uniform(GPUShader *shader, const char *name);
83 int GPU_shader_get_uniform_ensure(GPUShader *shader, const char *name);
84 int GPU_shader_get_builtin_uniform(GPUShader *shader, int builtin);
85 int GPU_shader_get_uniform_block(GPUShader *shader, const char *name);
86 void GPU_shader_uniform_vector(
87     GPUShader *shader, int location, int length, int arraysize, const float *value);
88 void GPU_shader_uniform_vector_int(
89     GPUShader *shader, int location, int length, int arraysize, const int *value);
90
91 void GPU_shader_uniform_buffer(GPUShader *shader, int location, struct GPUUniformBuffer *ubo);
92 void GPU_shader_uniform_texture(GPUShader *shader, int location, struct GPUTexture *tex);
93 void GPU_shader_uniform_float(GPUShader *shader, int location, float value);
94 void GPU_shader_uniform_int(GPUShader *shader, int location, int value);
95
96 int GPU_shader_get_attribute(GPUShader *shader, const char *name);
97
98 /* Builtin/Non-generated shaders */
99 typedef enum eGPUBuiltinShader {
100   /* specialized drawing */
101   GPU_SHADER_TEXT,
102   GPU_SHADER_TEXT_SIMPLE,
103   GPU_SHADER_EDGES_FRONT_BACK_PERSP,
104   GPU_SHADER_EDGES_FRONT_BACK_ORTHO,
105   GPU_SHADER_EDGES_OVERLAY_SIMPLE,
106   GPU_SHADER_EDGES_OVERLAY,
107   GPU_SHADER_KEYFRAME_DIAMOND,
108   GPU_SHADER_SIMPLE_LIGHTING,
109   GPU_SHADER_SIMPLE_LIGHTING_FLAT_COLOR,
110   GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR,
111   GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR_ALPHA,
112
113   /* for simple 2D drawing */
114   /**
115    * Take a single color for all the vertices and a 2D position for each vertex.
116    *
117    * \param color: uniform vec4
118    * \param pos: in vec2
119    */
120   GPU_SHADER_2D_UNIFORM_COLOR,
121   /**
122    * Take a 2D position and color for each vertex without color interpolation.
123    *
124    * \param color: in vec4
125    * \param pos: in vec2
126    */
127   GPU_SHADER_2D_FLAT_COLOR,
128   /**
129    * Take a 2D position and color for each vertex with linear interpolation in window space.
130    *
131    * \param color: in vec4
132    * \param pos: in vec2
133    */
134   GPU_SHADER_2D_SMOOTH_COLOR,
135   GPU_SHADER_2D_SMOOTH_COLOR_DITHER,
136   GPU_SHADER_2D_IMAGE,
137   GPU_SHADER_2D_IMAGE_COLOR,
138   GPU_SHADER_2D_IMAGE_DESATURATE_COLOR,
139   GPU_SHADER_2D_IMAGE_ALPHA_COLOR,
140   GPU_SHADER_2D_IMAGE_ALPHA,
141   GPU_SHADER_2D_IMAGE_RECT_COLOR,
142   GPU_SHADER_2D_IMAGE_MULTI_RECT_COLOR,
143   GPU_SHADER_2D_IMAGE_MULTISAMPLE_2,
144   GPU_SHADER_2D_IMAGE_MULTISAMPLE_4,
145   GPU_SHADER_2D_IMAGE_MULTISAMPLE_8,
146   GPU_SHADER_2D_IMAGE_MULTISAMPLE_16,
147   GPU_SHADER_2D_IMAGE_MULTISAMPLE_2_DEPTH_TEST,
148   GPU_SHADER_2D_IMAGE_MULTISAMPLE_4_DEPTH_TEST,
149   GPU_SHADER_2D_IMAGE_MULTISAMPLE_8_DEPTH_TEST,
150   GPU_SHADER_2D_IMAGE_MULTISAMPLE_16_DEPTH_TEST,
151   GPU_SHADER_2D_CHECKER,
152   GPU_SHADER_2D_DIAG_STRIPES,
153   /* for simple 3D drawing */
154   /**
155    * Take a single color for all the vertices and a 3D position for each vertex.
156    *
157    * \param color: uniform vec4
158    * \param pos: in vec3
159    */
160   GPU_SHADER_3D_UNIFORM_COLOR,
161   /* Sets Z-depth to 1.0 (draw onto background). */
162   GPU_SHADER_3D_UNIFORM_COLOR_BACKGROUND,
163   GPU_SHADER_3D_UNIFORM_COLOR_INSTANCE,
164   /**
165    * Take a 3D position and color for each vertex without color interpolation.
166    *
167    * \param color: in vec4
168    * \param pos: in vec3
169    */
170   GPU_SHADER_3D_FLAT_COLOR,
171   /**
172    * Take a 3D position and color for each vertex with perspective correct interpolation.
173    *
174    * \param color: in vec4
175    * \param pos: in vec3
176    */
177   GPU_SHADER_3D_SMOOTH_COLOR,
178   /**
179    * Take a 3D position for each vertex and output only depth.
180    *
181    * \param pos: in vec3
182    */
183   GPU_SHADER_3D_DEPTH_ONLY,
184   GPU_SHADER_3D_CLIPPED_UNIFORM_COLOR,
185   /* basic image drawing */
186   GPU_SHADER_2D_IMAGE_LINEAR_TO_SRGB,
187   GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR,
188   GPU_SHADER_2D_IMAGE_MASK_UNIFORM_COLOR,
189   /**
190    * Draw texture with alpha. Take a 3D position and a 2D texture coordinate for each vertex.
191    *
192    * \param alpha: uniform float
193    * \param image: uniform sampler2D
194    * \param texCoord: in vec2
195    * \param pos: in vec3
196    */
197   GPU_SHADER_3D_IMAGE_MODULATE_ALPHA,
198   /**
199    * Draw linearized depth texture relate to near and far distances.
200    * Take a 3D position and a 2D texture coordinate for each vertex.
201    *
202    * \param znear: uniform float
203    * \param zfar: uniform float
204    * \param image: uniform sampler2D
205    * \param texCoord: in vec2
206    * \param pos: in vec3
207    */
208   GPU_SHADER_3D_IMAGE_DEPTH,
209   GPU_SHADER_3D_IMAGE_DEPTH_COPY,
210   /* stereo 3d */
211   GPU_SHADER_2D_IMAGE_INTERLACE,
212   /* points */
213   /**
214    * Draw round points with a hardcoded size.
215    * Take a single color for all the vertices and a 2D position for each vertex.
216    *
217    * \param color: uniform vec4
218    * \param pos: in vec2
219    */
220   GPU_SHADER_2D_POINT_FIXED_SIZE_UNIFORM_COLOR,
221   /**
222    * Draw round points with a constant size.
223    * Take a single color for all the vertices and a 2D position for each vertex.
224    *
225    * \param size: uniform float
226    * \param color: uniform vec4
227    * \param pos: in vec2
228    */
229   GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA,
230   /**
231    * Draw round points with a constant size and an outline.
232    * Take a single color for all the vertices and a 2D position for each vertex.
233    *
234    * \param size: uniform float
235    * \param outlineWidth: uniform float
236    * \param color: uniform vec4
237    * \param outlineColor: uniform vec4
238    * \param pos: in vec2
239    */
240   GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA,
241   /**
242    * Draw round points with a constant size and an outline.
243    * 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.
254    * 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.
308    * Take a 3D position and a color for each vertex.
309    *
310    * \param size: in float
311    * \param color: in vec4
312    * \param pos: in vec3
313    */
314   GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR,
315   /* lines */
316   GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR,
317   GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR,
318   /* light drawing */
319   GPU_SHADER_3D_GROUNDPOINT,
320   GPU_SHADER_3D_GROUNDLINE,
321   GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR,
322   /* bone drawing */
323   GPU_SHADER_3D_OBJECTSPACE_VARIYING_COLOR,
324   GPU_SHADER_3D_OBJECTSPACE_SIMPLE_LIGHTING_VARIYING_COLOR,
325   /* camera drawing */
326   GPU_SHADER_CAMERA,
327   /* distance in front of objects */
328   GPU_SHADER_DISTANCE_LINES,
329   /* axis name */
330   GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED_AXIS,
331   GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED,
332   /* instance */
333   GPU_SHADER_INSTANCE_UNIFORM_COLOR,
334   GPU_SHADER_INSTANCE_VARIYING_ID_VARIYING_SIZE,    /* Uniformly scaled */
335   GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, /* Uniformly scaled */
336   GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE,
337   GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR,
338   /* grease pencil drawing */
339   GPU_SHADER_GPENCIL_STROKE,
340   GPU_SHADER_GPENCIL_FILL,
341   /* specialized for widget drawing */
342   GPU_SHADER_2D_AREA_EDGES,
343   GPU_SHADER_2D_WIDGET_BASE,
344   GPU_SHADER_2D_WIDGET_BASE_INST,
345   GPU_SHADER_2D_WIDGET_SHADOW,
346   GPU_SHADER_2D_NODELINK,
347   GPU_SHADER_2D_NODELINK_INST,
348   /* specialized for edituv drawing */
349   GPU_SHADER_2D_UV_UNIFORM_COLOR,
350   GPU_SHADER_2D_UV_VERTS,
351   GPU_SHADER_2D_UV_FACEDOTS,
352   GPU_SHADER_2D_UV_EDGES,
353   GPU_SHADER_2D_UV_EDGES_SMOOTH,
354   GPU_SHADER_2D_UV_FACES,
355   GPU_SHADER_2D_UV_FACES_STRETCH_AREA,
356   GPU_SHADER_2D_UV_FACES_STRETCH_ANGLE,
357   /* Selection */
358   GPU_SHADER_3D_FLAT_SELECT_ID,
359   GPU_SHADER_3D_UNIFORM_SELECT_ID,
360 } eGPUBuiltinShader;
361 #define GPU_SHADER_BUILTIN_LEN (GPU_SHADER_3D_UNIFORM_SELECT_ID + 1)
362
363 /** Support multiple configurations. */
364 typedef enum eGPUShaderConfig {
365   GPU_SHADER_CFG_DEFAULT = 0,
366   GPU_SHADER_CFG_CLIPPED = 1,
367 } eGPUShaderConfig;
368 #define GPU_SHADER_CFG_LEN (GPU_SHADER_CFG_CLIPPED + 1)
369
370 typedef struct GPUShaderConfigData {
371   const char *lib;
372   const char *def;
373 } GPUShaderConfigData;
374 /* gpu_shader.c */
375 extern const GPUShaderConfigData GPU_shader_cfg_data[GPU_SHADER_CFG_LEN];
376
377 /** Keep these in sync with:
378  * - `gpu_shader_image_interlace_frag.glsl`
379  * - `gpu_shader_image_rect_interlace_frag.glsl`
380  */
381 typedef enum eGPUInterlaceShader {
382   GPU_SHADER_INTERLACE_ROW = 0,
383   GPU_SHADER_INTERLACE_COLUMN = 1,
384   GPU_SHADER_INTERLACE_CHECKER = 2,
385 } eGPUInterlaceShader;
386
387 GPUShader *GPU_shader_get_builtin_shader_with_config(eGPUBuiltinShader shader,
388                                                      eGPUShaderConfig sh_cfg);
389 GPUShader *GPU_shader_get_builtin_shader(eGPUBuiltinShader shader);
390
391 void GPU_shader_get_builtin_shader_code(eGPUBuiltinShader shader,
392                                         const char **r_vert,
393                                         const char **r_frag,
394                                         const char **r_geom,
395                                         const char **r_defines);
396
397 void GPU_shader_free_builtin_shaders(void);
398
399 /* Vertex attributes for shaders */
400
401 #define GPU_MAX_ATTR 32
402
403 typedef struct GPUVertAttrLayers {
404   struct {
405     int type;
406     int glindex;
407     int glinfoindoex;
408     int gltexco;
409     int attr_id;
410     char name[64]; /* MAX_CUSTOMDATA_LAYER_NAME */
411   } layer[GPU_MAX_ATTR];
412
413   int totlayer;
414 } GPUVertAttrLayers;
415
416 #ifdef __cplusplus
417 }
418 #endif
419
420 #endif /* __GPU_SHADER_H__ */