GPU: refactor clipped drawing from DRW into 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 GPU_shader.h
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(
47         const char *vertexcode,
48         const char *fragcode,
49         const char *geocode,
50         const char *libcode,
51         const char *defines,
52         const char *shader_name);
53 GPUShader *GPU_shader_create_ex(
54         const char *vertexcode,
55         const char *fragcode,
56         const char *geocode,
57         const char *libcode,
58         const char *defines,
59         const eGPUShaderTFBType tf_type,
60         const char **tf_names,
61         const int tf_count,
62         const char *shader_name);
63 struct GPU_ShaderCreateFromArray_Params { const char **vert, **geom, **frag, **defs; };
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,
88         int arraysize, const float *value);
89 void GPU_shader_uniform_vector_int(
90         GPUShader *shader, int location, int length,
91         int arraysize, const int *value);
92
93 void GPU_shader_uniform_buffer(GPUShader *shader, int location, struct GPUUniformBuffer *ubo);
94 void GPU_shader_uniform_texture(GPUShader *shader, int location, struct GPUTexture *tex);
95 void GPU_shader_uniform_float(GPUShader *shader, int location, float value);
96 void GPU_shader_uniform_int(GPUShader *shader, int location, int value);
97
98 int GPU_shader_get_attribute(GPUShader *shader, const char *name);
99
100 /* Builtin/Non-generated shaders */
101 typedef enum eGPUBuiltinShader {
102         /* specialized drawing */
103         GPU_SHADER_TEXT,
104         GPU_SHADER_TEXT_SIMPLE,
105         GPU_SHADER_EDGES_FRONT_BACK_PERSP,
106         GPU_SHADER_EDGES_FRONT_BACK_ORTHO,
107         GPU_SHADER_EDGES_OVERLAY_SIMPLE,
108         GPU_SHADER_EDGES_OVERLAY,
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         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 } eGPUBuiltinShader;
360 #define GPU_SHADER_BUILTIN_LEN (GPU_SHADER_3D_UNIFORM_SELECT_ID + 1)
361
362 /** Support multiple configurations. */
363 typedef enum eGPUShaderConfig {
364         GPU_SHADER_CFG_DEFAULT     = 0,
365         GPU_SHADER_CFG_CLIPPED     = 1,
366 } eGPUShaderConfig;
367 #define GPU_SHADER_CFG_LEN (GPU_SHADER_CFG_CLIPPED + 1)
368
369 /** Keep these in sync with:
370  * - `gpu_shader_image_interlace_frag.glsl`
371  * - `gpu_shader_image_rect_interlace_frag.glsl`
372  */
373 typedef enum eGPUInterlaceShader {
374         GPU_SHADER_INTERLACE_ROW               = 0,
375         GPU_SHADER_INTERLACE_COLUMN            = 1,
376         GPU_SHADER_INTERLACE_CHECKER           = 2,
377 } eGPUInterlaceShader;
378
379 GPUShader *GPU_shader_get_builtin_shader_with_config(
380         eGPUBuiltinShader shader, eGPUShaderConfig shader_cfg);
381 GPUShader *GPU_shader_get_builtin_shader(
382         eGPUBuiltinShader shader);
383
384 void GPU_shader_get_builtin_shader_code(
385         eGPUBuiltinShader shader,
386         const char **r_vert, const char **r_frag,
387         const char **r_geom, const char **r_defines);
388
389 void GPU_shader_free_builtin_shaders(void);
390
391 /* Vertex attributes for shaders */
392
393 #define GPU_MAX_ATTR 32
394
395 typedef struct GPUVertAttrLayers {
396         struct {
397                 int type;
398                 int glindex;
399                 int glinfoindoex;
400                 int gltexco;
401                 int attr_id;
402                 char name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
403         } layer[GPU_MAX_ATTR];
404
405         int totlayer;
406 } GPUVertAttrLayers;
407
408 #ifdef __cplusplus
409 }
410 #endif
411
412 #endif  /* __GPU_SHADER_H__ */