Cleanup: replace attrib w/ attr
[blender.git] / source / blender / draw / intern / DRW_render.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  * Copyright 2016, Blender Foundation.
19  * Contributor(s): Blender Institute
20  *
21  * ***** END GPL LICENSE BLOCK *****
22  *
23  */
24
25 /** \file DRW_render.h
26  *  \ingroup draw
27  */
28
29 /* This is the Render Functions used by Realtime engines to draw with OpenGL */
30
31 #ifndef __DRW_RENDER_H__
32 #define __DRW_RENDER_H__
33
34 #include "BLI_listbase.h"
35 #include "BLI_math_matrix.h"
36 #include "BLI_math_vector.h"
37 #include "BLI_string.h"
38
39 #include "BKE_context.h"
40 #include "BKE_layer.h"
41 #include "BKE_material.h"
42 #include "BKE_scene.h"
43
44 #include "BLT_translation.h"
45
46 #include "DNA_object_types.h"
47 #include "DNA_lamp_types.h"
48 #include "DNA_material_types.h"
49 #include "DNA_scene_types.h"
50 #include "DNA_world_types.h"
51
52 #include "GPU_framebuffer.h"
53 #include "GPU_texture.h"
54 #include "GPU_shader.h"
55
56 #include "draw_common.h"
57 #include "draw_cache.h"
58 #include "draw_view.h"
59
60 #include "draw_manager_profiling.h"
61 #include "draw_debug.h"
62
63 #include "MEM_guardedalloc.h"
64
65 #include "RE_engine.h"
66
67 #include "DEG_depsgraph.h"
68
69 struct DRWTextStore;
70 struct DefaultFramebufferList;
71 struct DefaultTextureList;
72 struct GPUBatch;
73 struct GPUFrameBuffer;
74 struct GPUMaterial;
75 struct GPUShader;
76 struct GPUTexture;
77 struct GPUUniformBuffer;
78 struct LampEngineData;
79 struct Object;
80 struct ParticleSystem;
81 struct RenderEngineType;
82 struct ViewportEngineData;
83 struct ViewportEngineData_Info;
84 struct bContext;
85 struct rcti;
86
87 typedef struct DRWInterface DRWInterface;
88 typedef struct DRWPass DRWPass;
89 typedef struct DRWShadingGroup DRWShadingGroup;
90 typedef struct DRWUniform DRWUniform;
91
92 /* TODO Put it somewhere else? */
93 typedef struct BoundSphere {
94         float center[3], radius;
95 } BoundSphere;
96
97 /* declare members as empty (unused) */
98 typedef char DRWViewportEmptyList;
99
100 #define DRW_VIEWPORT_LIST_SIZE(list) \
101         (sizeof(list) == sizeof(DRWViewportEmptyList) ? 0 : ((sizeof(list)) / sizeof(void *)))
102
103 /* Unused members must be either pass list or 'char *' when not usd. */
104 #define DRW_VIEWPORT_DATA_SIZE(ty) { \
105         DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->fbl)), \
106         DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->txl)), \
107         DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->psl)), \
108         DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->stl)) \
109 }
110
111 /* Use of multisample framebuffers. */
112 #define MULTISAMPLE_SYNC_ENABLE(dfbl, dtxl) { \
113         if (dfbl->multisample_fb != NULL) { \
114                 DRW_stats_query_start("Multisample Blit"); \
115                 GPU_framebuffer_bind(dfbl->multisample_fb); \
116                 /* TODO clear only depth but need to do alpha to coverage for transparencies. */ \
117                 GPU_framebuffer_clear_color_depth(dfbl->multisample_fb, (const float[4]){0.0f}, 1.0f); \
118                 DRW_stats_query_end(); \
119         } \
120 } ((void)0)
121
122 #define MULTISAMPLE_SYNC_DISABLE(dfbl, dtxl) { \
123         if (dfbl->multisample_fb != NULL) { \
124                 DRW_stats_query_start("Multisample Resolve"); \
125                 GPU_framebuffer_bind(dfbl->default_fb); \
126                 DRW_multisamples_resolve(dtxl->multisample_depth, dtxl->multisample_color, true); \
127                 DRW_stats_query_end(); \
128         } \
129 }
130
131 #define MULTISAMPLE_SYNC_DISABLE_NO_DEPTH(dfbl, dtxl) { \
132         if (dfbl->multisample_fb != NULL) { \
133                 DRW_stats_query_start("Multisample Resolve"); \
134                 GPU_framebuffer_bind(dfbl->default_fb); \
135                 DRW_multisamples_resolve(dtxl->multisample_depth, dtxl->multisample_color, false); \
136                 DRW_stats_query_end(); \
137         } \
138 }
139
140
141
142
143 typedef struct DrawEngineDataSize {
144         int fbl_len;
145         int txl_len;
146         int psl_len;
147         int stl_len;
148 } DrawEngineDataSize;
149
150 typedef struct DrawEngineType {
151         struct DrawEngineType *next, *prev;
152
153         char idname[32];
154
155         const DrawEngineDataSize *vedata_size;
156
157         void (*engine_init)(void *vedata);
158         void (*engine_free)(void);
159
160         void (*cache_init)(void *vedata);
161         void (*cache_populate)(void *vedata, struct Object *ob);
162         void (*cache_finish)(void *vedata);
163
164         void (*draw_background)(void *vedata);
165         void (*draw_scene)(void *vedata);
166
167         void (*view_update)(void *vedata);
168         void (*id_update)(void *vedata, struct ID *id);
169
170         void (*render_to_image)(
171                 void *vedata, struct RenderEngine *engine,
172                 struct RenderLayer *layer, const struct rcti *rect);
173 } DrawEngineType;
174
175 #ifndef __DRW_ENGINE_H__
176 /* Buffer and textures used by the viewport by default */
177 typedef struct DefaultFramebufferList {
178         struct GPUFrameBuffer *default_fb;
179         struct GPUFrameBuffer *color_only_fb;
180         struct GPUFrameBuffer *depth_only_fb;
181         struct GPUFrameBuffer *multisample_fb;
182 } DefaultFramebufferList;
183
184 typedef struct DefaultTextureList {
185         struct GPUTexture *color;
186         struct GPUTexture *depth;
187         struct GPUTexture *multisample_color;
188         struct GPUTexture *multisample_depth;
189 } DefaultTextureList;
190 #endif
191
192 /* Textures */
193 typedef enum {
194         DRW_TEX_FILTER = (1 << 0),
195         DRW_TEX_WRAP = (1 << 1),
196         DRW_TEX_COMPARE = (1 << 2),
197         DRW_TEX_MIPMAP = (1 << 3),
198 } DRWTextureFlag;
199
200 /* Textures from DRW_texture_pool_query_* have the options
201  * DRW_TEX_FILTER for color float textures, and no options
202  * for depth textures and integer textures. */
203 struct GPUTexture *DRW_texture_pool_query_2D(int w, int h, eGPUTextureFormat format, DrawEngineType *engine_type);
204
205 struct GPUTexture *DRW_texture_create_1D(
206         int w, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
207 struct GPUTexture *DRW_texture_create_2D(
208         int w, int h, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
209 struct GPUTexture *DRW_texture_create_2D_array(
210         int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
211 struct GPUTexture *DRW_texture_create_3D(
212         int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
213 struct GPUTexture *DRW_texture_create_cube(
214         int w, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
215
216 void DRW_texture_ensure_fullscreen_2D(
217         struct GPUTexture **tex, eGPUTextureFormat format, DRWTextureFlag flags);
218 void DRW_texture_ensure_2D(
219         struct GPUTexture **tex, int w, int h, eGPUTextureFormat format, DRWTextureFlag flags);
220
221 void DRW_texture_generate_mipmaps(struct GPUTexture *tex);
222 void DRW_texture_free(struct GPUTexture *tex);
223 #define DRW_TEXTURE_FREE_SAFE(tex) do { \
224         if (tex != NULL) { \
225                 DRW_texture_free(tex); \
226                 tex = NULL; \
227         } \
228 } while (0)
229
230 /* UBOs */
231 struct GPUUniformBuffer *DRW_uniformbuffer_create(int size, const void *data);
232 void DRW_uniformbuffer_update(struct GPUUniformBuffer *ubo, const void *data);
233 void DRW_uniformbuffer_free(struct GPUUniformBuffer *ubo);
234 #define DRW_UBO_FREE_SAFE(ubo) do { \
235         if (ubo != NULL) { \
236                 DRW_uniformbuffer_free(ubo); \
237                 ubo = NULL; \
238         } \
239 } while (0)
240
241 void DRW_transform_to_display(struct GPUTexture *tex, bool use_view_settings);
242 void DRW_transform_none(struct GPUTexture *tex);
243 void DRW_multisamples_resolve(
244         struct GPUTexture *src_depth, struct GPUTexture *src_color, bool use_depth);
245
246 /* Shaders */
247 struct GPUShader *DRW_shader_create(
248         const char *vert, const char *geom, const char *frag, const char *defines);
249 struct DRW_ShaderCreateFromArray_Params { const char **vert, **geom, **frag, **defs; };
250 struct GPUShader *DRW_shader_create_from_arrays_impl(
251         const struct DRW_ShaderCreateFromArray_Params *params);
252 #define DRW_shader_create_from_arrays(...) \
253         DRW_shader_create_from_arrays_impl(&(const struct DRW_ShaderCreateFromArray_Params)__VA_ARGS__)
254 struct GPUShader *DRW_shader_create_with_lib(
255         const char *vert, const char *geom, const char *frag, const char *lib, const char *defines);
256 struct GPUShader *DRW_shader_create_with_transform_feedback(
257         const char *vert, const char *geom, const char *defines,
258         const eGPUShaderTFBType prim_type, const char **varying_names, const int varying_count);
259 struct GPUShader *DRW_shader_create_2D(const char *frag, const char *defines);
260 struct GPUShader *DRW_shader_create_3D(const char *frag, const char *defines);
261 struct GPUShader *DRW_shader_create_fullscreen(const char *frag, const char *defines);
262 struct GPUShader *DRW_shader_create_3D_depth_only(eDRW_ShaderSlot slot);
263 struct GPUMaterial *DRW_shader_find_from_world(struct World *wo, const void *engine_type, int options, bool deferred);
264 struct GPUMaterial *DRW_shader_find_from_material(struct Material *ma, const void *engine_type, int options, bool deferred);
265 struct GPUMaterial *DRW_shader_create_from_world(
266         struct Scene *scene, struct World *wo, const void *engine_type, int options,
267         const char *vert, const char *geom, const char *frag_lib, const char *defines, bool deferred);
268 struct GPUMaterial *DRW_shader_create_from_material(
269         struct Scene *scene, struct Material *ma, const void *engine_type, int options,
270         const char *vert, const char *geom, const char *frag_lib, const char *defines, bool deferred);
271 void DRW_shader_free(struct GPUShader *shader);
272 #define DRW_SHADER_FREE_SAFE(shader) do { \
273         if (shader != NULL) { \
274                 DRW_shader_free(shader); \
275                 shader = NULL; \
276         } \
277 } while (0)
278
279 /* Batches */
280
281 typedef enum {
282         DRW_STATE_WRITE_DEPTH   = (1 << 0),
283         DRW_STATE_WRITE_COLOR   = (1 << 1),
284         DRW_STATE_DEPTH_ALWAYS  = (1 << 2),
285         DRW_STATE_DEPTH_LESS    = (1 << 3),
286         DRW_STATE_DEPTH_LESS_EQUAL = (1 << 4),
287         DRW_STATE_DEPTH_EQUAL   = (1 << 5),
288         DRW_STATE_DEPTH_GREATER = (1 << 6),
289         DRW_STATE_DEPTH_GREATER_EQUAL = (1 << 7),
290         DRW_STATE_CULL_BACK     = (1 << 8),
291         DRW_STATE_CULL_FRONT    = (1 << 9),
292         DRW_STATE_WIRE          = (1 << 10),
293         DRW_STATE_POINT         = (1 << 11),
294         /** Polygon offset. Does not work with lines and points. */
295         DRW_STATE_OFFSET_POSITIVE = (1 << 12),
296         /** Polygon offset. Does not work with lines and points. */
297         DRW_STATE_OFFSET_NEGATIVE = (1 << 13),
298         /* DRW_STATE_STIPPLE_4     = (1 << 14), */ /* Not used */
299         DRW_STATE_BLEND         = (1 << 15),
300         DRW_STATE_ADDITIVE      = (1 << 16),
301         DRW_STATE_MULTIPLY      = (1 << 17),
302         /* DRW_STATE_TRANSMISSION  = (1 << 18), */ /* Not used */
303         DRW_STATE_CLIP_PLANES   = (1 << 19),
304         /** Same as DRW_STATE_ADDITIVE but let alpha accumulate without premult. */
305         DRW_STATE_ADDITIVE_FULL = (1 << 20),
306         /** Use that if color is already premult by alpha. */
307         DRW_STATE_BLEND_PREMUL  = (1 << 21),
308         DRW_STATE_WIRE_SMOOTH   = (1 << 22),
309         DRW_STATE_TRANS_FEEDBACK = (1 << 23),
310         DRW_STATE_BLEND_OIT     = (1 << 24),
311         DRW_STATE_FIRST_VERTEX_CONVENTION = (1 << 25),
312
313         DRW_STATE_WRITE_STENCIL          = (1 << 27),
314         DRW_STATE_WRITE_STENCIL_SHADOW_PASS   = (1 << 28),
315         DRW_STATE_WRITE_STENCIL_SHADOW_FAIL   = (1 << 29),
316         DRW_STATE_STENCIL_EQUAL          = (1 << 30),
317         DRW_STATE_STENCIL_NEQUAL         = (1 << 31),
318 } DRWState;
319 #define DRW_STATE_DEFAULT (DRW_STATE_WRITE_DEPTH | DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL)
320
321 typedef enum {
322         DRW_ATTR_INT,
323         DRW_ATTR_FLOAT,
324 } eDRWAttrType;
325
326 typedef struct DRWInstanceAttrFormat {
327         char name[32];
328         eDRWAttrType type;
329         int components;
330 } DRWInstanceAttrFormat;
331
332 struct GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttrFormat attrs[], int arraysize);
333 #define DRW_shgroup_instance_format(format, ...) do { \
334         if (format == NULL) { \
335                 DRWInstanceAttrFormat drw_format[] = __VA_ARGS__;\
336                 format = DRW_shgroup_instance_format_array(drw_format, (sizeof(drw_format) / sizeof(DRWInstanceAttrFormat))); \
337         } \
338 } while (0)
339
340 DRWShadingGroup *DRW_shgroup_create(struct GPUShader *shader, DRWPass *pass);
341 DRWShadingGroup *DRW_shgroup_create_sub(DRWShadingGroup *shgroup);
342 DRWShadingGroup *DRW_shgroup_material_create(struct GPUMaterial *material, DRWPass *pass);
343 DRWShadingGroup *DRW_shgroup_material_instance_create(
344         struct GPUMaterial *material, DRWPass *pass, struct GPUBatch *geom, struct Object *ob,
345         struct GPUVertFormat *format);
346 DRWShadingGroup *DRW_shgroup_material_empty_tri_batch_create(struct GPUMaterial *material, DRWPass *pass, int size);
347 DRWShadingGroup *DRW_shgroup_instance_create(
348         struct GPUShader *shader, DRWPass *pass, struct GPUBatch *geom, struct GPUVertFormat *format);
349 DRWShadingGroup *DRW_shgroup_point_batch_create(struct GPUShader *shader, DRWPass *pass);
350 DRWShadingGroup *DRW_shgroup_line_batch_create_with_format(
351         struct GPUShader *shader, DRWPass *pass, struct GPUVertFormat *format);
352 DRWShadingGroup *DRW_shgroup_line_batch_create(
353         struct GPUShader *shader, DRWPass *pass);
354 DRWShadingGroup *DRW_shgroup_empty_tri_batch_create(
355         struct GPUShader *shader, DRWPass *pass, int size);
356 DRWShadingGroup *DRW_shgroup_transform_feedback_create(
357         struct GPUShader *shader, DRWPass *pass, struct GPUVertBuf *tf_target);
358
359
360 typedef void (DRWCallGenerateFn)(
361         DRWShadingGroup *shgroup,
362         void (*draw_fn)(DRWShadingGroup *shgroup, struct GPUBatch *geom),
363         void *user_data);
364
365 /* return final visibility */
366 typedef bool (DRWCallVisibilityFn)(
367         bool vis_in,
368         void *user_data);
369
370 void DRW_shgroup_instance_batch(DRWShadingGroup *shgroup, struct GPUBatch *batch);
371
372 void DRW_shgroup_call_add(DRWShadingGroup *shgroup, struct GPUBatch *geom, float (*obmat)[4]);
373 void DRW_shgroup_call_range_add(
374         DRWShadingGroup *shgroup, struct GPUBatch *geom, float (*obmat)[4], uint v_sta, uint v_count);
375 void DRW_shgroup_call_procedural_points_add(DRWShadingGroup *shgroup, uint point_len, float (*obmat)[4]);
376 void DRW_shgroup_call_procedural_lines_add(DRWShadingGroup *shgroup, uint line_count, float (*obmat)[4]);
377 void DRW_shgroup_call_procedural_triangles_add(DRWShadingGroup *shgroup, uint tria_count, float (*obmat)[4]);
378 void DRW_shgroup_call_object_procedural_triangles_culled_add(DRWShadingGroup *shgroup, uint tria_count, struct Object *ob);
379 void DRW_shgroup_call_object_add_ex(
380         DRWShadingGroup *shgroup, struct GPUBatch *geom, struct Object *ob, struct Material *ma, bool bypass_culling);
381 #define DRW_shgroup_call_object_add(shgroup, geom, ob) DRW_shgroup_call_object_add_ex(shgroup, geom, ob, NULL, false)
382 #define DRW_shgroup_call_object_add_no_cull(shgroup, geom, ob) DRW_shgroup_call_object_add_ex(shgroup, geom, ob, NULL, true)
383 void DRW_shgroup_call_object_add_with_callback(
384         DRWShadingGroup *shgroup, struct GPUBatch *geom, struct Object *ob, struct Material *ma,
385         DRWCallVisibilityFn *callback, void *user_data);
386 /* Used for drawing a batch with instancing without instance attributes. */
387 void DRW_shgroup_call_instances_add(
388         DRWShadingGroup *shgroup, struct GPUBatch *geom, float (*obmat)[4], uint *count);
389 void DRW_shgroup_call_object_instances_add(
390         DRWShadingGroup *shgroup, struct GPUBatch *geom, struct Object *ob, uint *count);
391 void DRW_shgroup_call_sculpt_add(DRWShadingGroup *shgroup, struct Object *ob, float (*obmat)[4]);
392 void DRW_shgroup_call_generate_add(
393         DRWShadingGroup *shgroup, DRWCallGenerateFn *geometry_fn, void *user_data, float (*obmat)[4]);
394 void DRW_shgroup_call_dynamic_add_array(DRWShadingGroup *shgroup, const void *attr[], uint attr_len);
395 #define DRW_shgroup_call_dynamic_add(shgroup, ...) do { \
396         const void *array[] = {__VA_ARGS__}; \
397         DRW_shgroup_call_dynamic_add_array(shgroup, array, (sizeof(array) / sizeof(*array))); \
398 } while (0)
399
400 uint DRW_shgroup_get_instance_count(const DRWShadingGroup *shgroup);
401
402 void DRW_shgroup_state_enable(DRWShadingGroup *shgroup, DRWState state);
403 void DRW_shgroup_state_disable(DRWShadingGroup *shgroup, DRWState state);
404 void DRW_shgroup_stencil_mask(DRWShadingGroup *shgroup, uint mask);
405
406 void DRW_shgroup_uniform_texture(DRWShadingGroup *shgroup, const char *name, const struct GPUTexture *tex);
407 void DRW_shgroup_uniform_texture_persistent(DRWShadingGroup *shgroup, const char *name, const struct GPUTexture *tex);
408 void DRW_shgroup_uniform_block(DRWShadingGroup *shgroup, const char *name, const struct GPUUniformBuffer *ubo);
409 void DRW_shgroup_uniform_block_persistent(DRWShadingGroup *shgroup, const char *name, const struct GPUUniformBuffer *ubo);
410 void DRW_shgroup_uniform_texture_ref(DRWShadingGroup *shgroup, const char *name, struct GPUTexture **tex);
411 void DRW_shgroup_uniform_float(DRWShadingGroup *shgroup, const char *name, const float *value, int arraysize);
412 void DRW_shgroup_uniform_vec2(DRWShadingGroup *shgroup, const char *name, const float *value, int arraysize);
413 void DRW_shgroup_uniform_vec3(DRWShadingGroup *shgroup, const char *name, const float *value, int arraysize);
414 void DRW_shgroup_uniform_vec4(DRWShadingGroup *shgroup, const char *name, const float *value, int arraysize);
415 void DRW_shgroup_uniform_short_to_int(DRWShadingGroup *shgroup, const char *name, const short *value, int arraysize);
416 void DRW_shgroup_uniform_short_to_float(DRWShadingGroup *shgroup, const char *name, const short *value, int arraysize);
417 /* Boolean are expected to be 4bytes longs for opengl! */
418 void DRW_shgroup_uniform_bool(DRWShadingGroup *shgroup, const char *name, const int *value, int arraysize);
419 void DRW_shgroup_uniform_int(DRWShadingGroup *shgroup, const char *name, const int *value, int arraysize);
420 void DRW_shgroup_uniform_ivec2(DRWShadingGroup *shgroup, const char *name, const int *value, int arraysize);
421 void DRW_shgroup_uniform_ivec3(DRWShadingGroup *shgroup, const char *name, const int *value, int arraysize);
422 void DRW_shgroup_uniform_ivec4(DRWShadingGroup *shgroup, const char *name, const int *value, int arraysize);
423 void DRW_shgroup_uniform_mat3(DRWShadingGroup *shgroup, const char *name, const float (*value)[3]);
424 void DRW_shgroup_uniform_mat4(DRWShadingGroup *shgroup, const char *name, const float (*value)[4]);
425 /* Store value instead of referencing it. */
426 void DRW_shgroup_uniform_int_copy(DRWShadingGroup *shgroup, const char *name, const int value);
427 void DRW_shgroup_uniform_bool_copy(DRWShadingGroup *shgroup, const char *name, const bool value);
428 void DRW_shgroup_uniform_float_copy(DRWShadingGroup *shgroup, const char *name, const float value);
429
430 bool DRW_shgroup_is_empty(DRWShadingGroup *shgroup);
431
432 /* Passes */
433 DRWPass *DRW_pass_create(const char *name, DRWState state);
434 void DRW_pass_state_set(DRWPass *pass, DRWState state);
435 void DRW_pass_state_add(DRWPass *pass, DRWState state);
436 void DRW_pass_state_remove(DRWPass *pass, DRWState state);
437 void DRW_pass_foreach_shgroup(DRWPass *pass, void (*callback)(void *userData, DRWShadingGroup *shgrp), void *userData);
438 void DRW_pass_sort_shgroup_z(DRWPass *pass);
439
440 bool DRW_pass_is_empty(DRWPass *pass);
441
442 /* Viewport */
443 typedef enum {
444         /* keep in sync with the union struct DRWMatrixState. */
445         DRW_MAT_PERS = 0,
446         DRW_MAT_PERSINV,
447         DRW_MAT_VIEW,
448         DRW_MAT_VIEWINV,
449         DRW_MAT_WIN,
450         DRW_MAT_WININV,
451
452         DRW_MAT_COUNT, // Don't use this.
453 } DRWViewportMatrixType;
454
455 typedef struct DRWMatrixState {
456         union {
457                 float mat[DRW_MAT_COUNT][4][4];
458                 struct {
459                         /* keep in sync with the enum DRWViewportMatrixType. */
460                         float persmat[4][4];
461                         float persinv[4][4];
462                         float viewmat[4][4];
463                         float viewinv[4][4];
464                         float winmat[4][4];
465                         float wininv[4][4];
466                 };
467         };
468 } DRWMatrixState;
469
470 void DRW_viewport_matrix_get(float mat[4][4], DRWViewportMatrixType type);
471 void DRW_viewport_matrix_get_all(DRWMatrixState *state);
472 void DRW_viewport_matrix_override_set(const float mat[4][4], DRWViewportMatrixType type);
473 void DRW_viewport_matrix_override_set_all(DRWMatrixState *state);
474 void DRW_viewport_matrix_override_unset(DRWViewportMatrixType type);
475 void DRW_viewport_matrix_override_unset_all(void);
476
477 /* These are in view-space so negative if in perspective.
478  * Extract near and far clip distance from the projection matrix. */
479 float DRW_viewport_near_distance_get(void);
480 float DRW_viewport_far_distance_get(void);
481
482 const float *DRW_viewport_size_get(void);
483 const float *DRW_viewport_invert_size_get(void);
484 const float *DRW_viewport_screenvecs_get(void);
485 const float *DRW_viewport_pixelsize_get(void);
486 bool DRW_viewport_is_persp_get(void);
487
488 struct DefaultFramebufferList *DRW_viewport_framebuffer_list_get(void);
489 struct DefaultTextureList     *DRW_viewport_texture_list_get(void);
490
491 void DRW_viewport_request_redraw(void);
492
493 void DRW_render_to_image(struct RenderEngine *engine, struct Depsgraph *depsgraph);
494 void DRW_render_object_iter(
495         void *vedata, struct RenderEngine *engine, struct Depsgraph *depsgraph,
496         void (*callback)(void *vedata, struct Object *ob, struct RenderEngine *engine, struct Depsgraph *depsgraph));
497 void DRW_render_instance_buffer_finish(void);
498 void DRW_render_viewport_size_set(int size[2]);
499
500 void DRW_custom_pipeline(
501         DrawEngineType *draw_engine_type,
502         struct Depsgraph *depsgraph,
503         void (*callback)(void *vedata, void *user_data),
504         void *user_data);
505
506 /* ViewLayers */
507 void *DRW_view_layer_engine_data_get(DrawEngineType *engine_type);
508 void **DRW_view_layer_engine_data_ensure_ex(
509         struct ViewLayer *view_layer, DrawEngineType *engine_type, void (*callback)(void *storage));
510 void **DRW_view_layer_engine_data_ensure(
511         DrawEngineType *engine_type, void (*callback)(void *storage));
512
513 /* DrawData */
514 DrawData *DRW_drawdata_get(ID *ib, DrawEngineType *engine_type);
515 DrawData *DRW_drawdata_ensure(
516         ID *id,
517         DrawEngineType *engine_type,
518         size_t size,
519         DrawDataInitCb init_cb,
520         DrawDataFreeCb free_cb);
521
522 /* Settings */
523 bool DRW_object_is_renderable(const struct Object *ob);
524 int DRW_object_visibility_in_active_context(const struct Object *ob);
525 bool DRW_object_is_flat_normal(const struct Object *ob);
526 bool DRW_object_use_hide_faces(const struct Object *ob);
527
528 bool DRW_object_is_visible_psys_in_active_context(const struct Object *object, const struct ParticleSystem *psys);
529
530 struct Object *DRW_object_get_dupli_parent(const struct Object *ob);
531 struct DupliObject *DRW_object_get_dupli(const struct Object *ob);
532
533 /* Draw commands */
534 void DRW_draw_pass(DRWPass *pass);
535 void DRW_draw_pass_subset(DRWPass *pass, DRWShadingGroup *start_group, DRWShadingGroup *end_group);
536
537 void DRW_draw_callbacks_pre_scene(void);
538 void DRW_draw_callbacks_post_scene(void);
539
540 void DRW_state_reset_ex(DRWState state);
541 void DRW_state_reset(void);
542 void DRW_state_lock(DRWState state);
543
544 void DRW_state_invert_facing(void);
545
546 void DRW_state_clip_planes_len_set(uint plane_len);
547 void DRW_state_clip_planes_reset(void);
548 void DRW_state_clip_planes_set_from_rv3d(struct RegionView3D *rv3d);
549
550 /* Culling, return true if object is inside view frustum. */
551 bool DRW_culling_sphere_test(BoundSphere *bsphere);
552 bool DRW_culling_box_test(BoundBox *bbox);
553 bool DRW_culling_plane_test(float plane[4]);
554
555 void DRW_culling_frustum_corners_get(BoundBox *corners);
556 void DRW_culling_frustum_planes_get(float planes[6][4]);
557
558 /* Selection */
559 void DRW_select_load_id(uint id);
560
561 /* Draw State */
562 void DRW_state_dfdy_factors_get(float dfdyfac[2]);
563 bool DRW_state_is_fbo(void);
564 bool DRW_state_is_select(void);
565 bool DRW_state_is_depth(void);
566 bool DRW_state_is_image_render(void);
567 bool DRW_state_is_scene_render(void);
568 bool DRW_state_is_opengl_render(void);
569 bool DRW_state_is_playback(void);
570 bool DRW_state_show_text(void);
571 bool DRW_state_draw_support(void);
572 bool DRW_state_draw_background(void);
573
574 /* Avoid too many lookups while drawing */
575 typedef struct DRWContextState {
576
577         struct ARegion *ar;         /* 'CTX_wm_region(C)' */
578         struct RegionView3D *rv3d;  /* 'CTX_wm_region_view3d(C)' */
579         struct View3D *v3d;     /* 'CTX_wm_view3d(C)' */
580
581         struct Scene *scene;    /* 'CTX_data_scene(C)' */
582         struct ViewLayer *view_layer;  /* 'CTX_data_view_layer(C)' */
583
584         /* Use 'object_edit' for edit-mode */
585         struct Object *obact;   /* 'OBACT' */
586
587         struct RenderEngineType *engine_type;
588
589         struct Depsgraph *depsgraph;
590
591         eObjectMode object_mode;
592
593         eDRW_ShaderSlot shader_slot;
594
595         /** Last resort (some functions take this as an arg so we can't easily avoid).
596          * May be NULL when used for selection or depth buffer. */
597         const struct bContext *evil_C;
598
599         /* ---- */
600
601         /* Cache: initialized by 'drw_context_state_init'. */
602         struct Object *object_pose;
603         struct Object *object_edit;
604
605 } DRWContextState;
606
607 const DRWContextState *DRW_context_state_get(void);
608
609 #define XRAY_ALPHA(v3d)   (((v3d)->shading.type == OB_WIRE) ? (v3d)->shading.xray_alpha_wire : (v3d)->shading.xray_alpha)
610 #define XRAY_FLAG(v3d)    (((v3d)->shading.type == OB_WIRE) ? V3D_SHADING_XRAY_BONE : V3D_SHADING_XRAY)
611 #define XRAY_ENABLED(v3d) ((((v3d)->shading.flag & XRAY_FLAG(v3d)) != 0) && (XRAY_ALPHA(v3d) < 1.0f))
612
613 #endif /* __DRW_RENDER_H__ */