594 lines
23 KiB
C++
594 lines
23 KiB
C++
/*
|
|
* Copyright 2016, Blender Foundation.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* Contributor(s): Blender Institute
|
|
*
|
|
*/
|
|
|
|
/** \file DRW_render.h
|
|
* \ingroup draw
|
|
*/
|
|
|
|
/* This is the Render Functions used by Realtime engines to draw with OpenGL */
|
|
|
|
#ifndef __DRW_RENDER_H__
|
|
#define __DRW_RENDER_H__
|
|
|
|
#include "BLI_listbase.h"
|
|
#include "BLI_math_matrix.h"
|
|
#include "BLI_math_vector.h"
|
|
#include "BLI_string.h"
|
|
|
|
#include "BKE_context.h"
|
|
#include "BKE_layer.h"
|
|
#include "BKE_material.h"
|
|
#include "BKE_scene.h"
|
|
|
|
#include "BLT_translation.h"
|
|
|
|
#include "DNA_object_types.h"
|
|
#include "DNA_lamp_types.h"
|
|
#include "DNA_material_types.h"
|
|
#include "DNA_scene_types.h"
|
|
#include "DNA_world_types.h"
|
|
|
|
#include "GPU_framebuffer.h"
|
|
#include "GPU_texture.h"
|
|
#include "GPU_shader.h"
|
|
|
|
#include "draw_common.h"
|
|
#include "draw_cache.h"
|
|
#include "draw_view.h"
|
|
|
|
#include "draw_manager_profiling.h"
|
|
#include "draw_debug.h"
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "RE_engine.h"
|
|
|
|
#include "DEG_depsgraph.h"
|
|
|
|
struct rcti;
|
|
struct bContext;
|
|
struct GPUFrameBuffer;
|
|
struct GPUShader;
|
|
struct GPUMaterial;
|
|
struct GPUTexture;
|
|
struct GPUUniformBuffer;
|
|
struct Object;
|
|
struct GPUBatch;
|
|
struct DefaultFramebufferList;
|
|
struct DefaultTextureList;
|
|
struct DRWTextStore;
|
|
struct LampEngineData;
|
|
struct ParticleSystem;
|
|
struct RenderEngineType;
|
|
struct ViewportEngineData;
|
|
struct ViewportEngineData_Info;
|
|
|
|
typedef struct DRWUniform DRWUniform;
|
|
typedef struct DRWInterface DRWInterface;
|
|
typedef struct DRWPass DRWPass;
|
|
typedef struct DRWShadingGroup DRWShadingGroup;
|
|
|
|
/* TODO Put it somewhere else? */
|
|
typedef struct BoundSphere {
|
|
float center[3], radius;
|
|
} BoundSphere;
|
|
|
|
/* declare members as empty (unused) */
|
|
typedef char DRWViewportEmptyList;
|
|
|
|
#define DRW_VIEWPORT_LIST_SIZE(list) \
|
|
(sizeof(list) == sizeof(DRWViewportEmptyList) ? 0 : ((sizeof(list)) / sizeof(void *)))
|
|
|
|
/* Unused members must be either pass list or 'char *' when not usd. */
|
|
#define DRW_VIEWPORT_DATA_SIZE(ty) { \
|
|
DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->fbl)), \
|
|
DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->txl)), \
|
|
DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->psl)), \
|
|
DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->stl)) \
|
|
}
|
|
|
|
/* Use of multisample framebuffers. */
|
|
#define MULTISAMPLE_SYNC_ENABLE(dfbl, dtxl) { \
|
|
if (dfbl->multisample_fb != NULL) { \
|
|
DRW_stats_query_start("Multisample Blit"); \
|
|
GPU_framebuffer_bind(dfbl->multisample_fb); \
|
|
/* TODO clear only depth but need to do alpha to coverage for transparencies. */ \
|
|
GPU_framebuffer_clear_color_depth(dfbl->multisample_fb, (const float[4]){0.0f}, 1.0f); \
|
|
DRW_stats_query_end(); \
|
|
} \
|
|
}
|
|
|
|
#define MULTISAMPLE_SYNC_DISABLE(dfbl, dtxl) { \
|
|
if (dfbl->multisample_fb != NULL) { \
|
|
DRW_stats_query_start("Multisample Resolve"); \
|
|
GPU_framebuffer_bind(dfbl->default_fb); \
|
|
DRW_multisamples_resolve(dtxl->multisample_depth, dtxl->multisample_color, true); \
|
|
DRW_stats_query_end(); \
|
|
} \
|
|
}
|
|
|
|
#define MULTISAMPLE_SYNC_DISABLE_NO_DEPTH(dfbl, dtxl) { \
|
|
if (dfbl->multisample_fb != NULL) { \
|
|
DRW_stats_query_start("Multisample Resolve"); \
|
|
GPU_framebuffer_bind(dfbl->default_fb); \
|
|
DRW_multisamples_resolve(dtxl->multisample_depth, dtxl->multisample_color, false); \
|
|
DRW_stats_query_end(); \
|
|
} \
|
|
}
|
|
|
|
|
|
|
|
|
|
typedef struct DrawEngineDataSize {
|
|
int fbl_len;
|
|
int txl_len;
|
|
int psl_len;
|
|
int stl_len;
|
|
} DrawEngineDataSize;
|
|
|
|
typedef struct DrawEngineType {
|
|
struct DrawEngineType *next, *prev;
|
|
|
|
char idname[32];
|
|
|
|
const DrawEngineDataSize *vedata_size;
|
|
|
|
void (*engine_init)(void *vedata);
|
|
void (*engine_free)(void);
|
|
|
|
void (*cache_init)(void *vedata);
|
|
void (*cache_populate)(void *vedata, struct Object *ob);
|
|
void (*cache_finish)(void *vedata);
|
|
|
|
void (*draw_background)(void *vedata);
|
|
void (*draw_scene)(void *vedata);
|
|
|
|
void (*view_update)(void *vedata);
|
|
void (*id_update)(void *vedata, struct ID *id);
|
|
|
|
void (*render_to_image)(
|
|
void *vedata, struct RenderEngine *engine,
|
|
struct RenderLayer *layer, const struct rcti *rect);
|
|
} DrawEngineType;
|
|
|
|
#ifndef __DRW_ENGINE_H__
|
|
/* Buffer and textures used by the viewport by default */
|
|
typedef struct DefaultFramebufferList {
|
|
struct GPUFrameBuffer *default_fb;
|
|
struct GPUFrameBuffer *color_only_fb;
|
|
struct GPUFrameBuffer *depth_only_fb;
|
|
struct GPUFrameBuffer *multisample_fb;
|
|
} DefaultFramebufferList;
|
|
|
|
typedef struct DefaultTextureList {
|
|
struct GPUTexture *color;
|
|
struct GPUTexture *depth;
|
|
struct GPUTexture *multisample_color;
|
|
struct GPUTexture *multisample_depth;
|
|
} DefaultTextureList;
|
|
#endif
|
|
|
|
/* Textures */
|
|
typedef enum {
|
|
DRW_TEX_FILTER = (1 << 0),
|
|
DRW_TEX_WRAP = (1 << 1),
|
|
DRW_TEX_COMPARE = (1 << 2),
|
|
DRW_TEX_MIPMAP = (1 << 3),
|
|
} DRWTextureFlag;
|
|
|
|
/* Textures from DRW_texture_pool_query_* have the options
|
|
* DRW_TEX_FILTER for color float textures, and no options
|
|
* for depth textures and integer textures. */
|
|
struct GPUTexture *DRW_texture_pool_query_2D(int w, int h, GPUTextureFormat format, DrawEngineType *engine_type);
|
|
|
|
struct GPUTexture *DRW_texture_create_1D(
|
|
int w, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
|
|
struct GPUTexture *DRW_texture_create_2D(
|
|
int w, int h, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
|
|
struct GPUTexture *DRW_texture_create_2D_array(
|
|
int w, int h, int d, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
|
|
struct GPUTexture *DRW_texture_create_3D(
|
|
int w, int h, int d, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
|
|
struct GPUTexture *DRW_texture_create_cube(
|
|
int w, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
|
|
|
|
void DRW_texture_ensure_fullscreen_2D(
|
|
struct GPUTexture **tex, GPUTextureFormat format, DRWTextureFlag flags);
|
|
void DRW_texture_ensure_2D(
|
|
struct GPUTexture **tex, int w, int h, GPUTextureFormat format, DRWTextureFlag flags);
|
|
|
|
void DRW_texture_generate_mipmaps(struct GPUTexture *tex);
|
|
void DRW_texture_free(struct GPUTexture *tex);
|
|
#define DRW_TEXTURE_FREE_SAFE(tex) do { \
|
|
if (tex != NULL) { \
|
|
DRW_texture_free(tex); \
|
|
tex = NULL; \
|
|
} \
|
|
} while (0)
|
|
|
|
/* UBOs */
|
|
struct GPUUniformBuffer *DRW_uniformbuffer_create(int size, const void *data);
|
|
void DRW_uniformbuffer_update(struct GPUUniformBuffer *ubo, const void *data);
|
|
void DRW_uniformbuffer_free(struct GPUUniformBuffer *ubo);
|
|
#define DRW_UBO_FREE_SAFE(ubo) do { \
|
|
if (ubo != NULL) { \
|
|
DRW_uniformbuffer_free(ubo); \
|
|
ubo = NULL; \
|
|
} \
|
|
} while (0)
|
|
|
|
void DRW_transform_to_display(struct GPUTexture *tex, bool use_view_settings);
|
|
void DRW_transform_none(struct GPUTexture *tex);
|
|
void DRW_multisamples_resolve(
|
|
struct GPUTexture *src_depth, struct GPUTexture *src_color, bool use_depth);
|
|
|
|
/* Shaders */
|
|
struct GPUShader *DRW_shader_create(
|
|
const char *vert, const char *geom, const char *frag, const char *defines);
|
|
struct GPUShader *DRW_shader_create_with_lib(
|
|
const char *vert, const char *geom, const char *frag, const char *lib, const char *defines);
|
|
struct GPUShader *DRW_shader_create_with_transform_feedback(
|
|
const char *vert, const char *geom, const char *defines,
|
|
const GPUShaderTFBType prim_type, const char **varying_names, const int varying_count);
|
|
struct GPUShader *DRW_shader_create_2D(const char *frag, const char *defines);
|
|
struct GPUShader *DRW_shader_create_3D(const char *frag, const char *defines);
|
|
struct GPUShader *DRW_shader_create_fullscreen(const char *frag, const char *defines);
|
|
struct GPUShader *DRW_shader_create_3D_depth_only(void);
|
|
struct GPUMaterial *DRW_shader_find_from_world(struct World *wo, const void *engine_type, int options, bool deferred);
|
|
struct GPUMaterial *DRW_shader_find_from_material(struct Material *ma, const void *engine_type, int options, bool deferred);
|
|
struct GPUMaterial *DRW_shader_create_from_world(
|
|
struct Scene *scene, struct World *wo, const void *engine_type, int options,
|
|
const char *vert, const char *geom, const char *frag_lib, const char *defines, bool deferred);
|
|
struct GPUMaterial *DRW_shader_create_from_material(
|
|
struct Scene *scene, struct Material *ma, const void *engine_type, int options,
|
|
const char *vert, const char *geom, const char *frag_lib, const char *defines, bool deferred);
|
|
void DRW_shader_free(struct GPUShader *shader);
|
|
#define DRW_SHADER_FREE_SAFE(shader) do { \
|
|
if (shader != NULL) { \
|
|
DRW_shader_free(shader); \
|
|
shader = NULL; \
|
|
} \
|
|
} while (0)
|
|
|
|
/* Batches */
|
|
|
|
typedef enum {
|
|
DRW_STATE_WRITE_DEPTH = (1 << 0),
|
|
DRW_STATE_WRITE_COLOR = (1 << 1),
|
|
DRW_STATE_DEPTH_ALWAYS = (1 << 2),
|
|
DRW_STATE_DEPTH_LESS = (1 << 3),
|
|
DRW_STATE_DEPTH_LESS_EQUAL = (1 << 4),
|
|
DRW_STATE_DEPTH_EQUAL = (1 << 5),
|
|
DRW_STATE_DEPTH_GREATER = (1 << 6),
|
|
DRW_STATE_DEPTH_GREATER_EQUAL = (1 << 7),
|
|
DRW_STATE_CULL_BACK = (1 << 8),
|
|
DRW_STATE_CULL_FRONT = (1 << 9),
|
|
DRW_STATE_WIRE = (1 << 10),
|
|
DRW_STATE_POINT = (1 << 11),
|
|
DRW_STATE_STIPPLE_2 = (1 << 12),
|
|
DRW_STATE_STIPPLE_3 = (1 << 13),
|
|
DRW_STATE_STIPPLE_4 = (1 << 14),
|
|
DRW_STATE_BLEND = (1 << 15),
|
|
DRW_STATE_ADDITIVE = (1 << 16),
|
|
DRW_STATE_MULTIPLY = (1 << 17),
|
|
DRW_STATE_TRANSMISSION = (1 << 18),
|
|
DRW_STATE_CLIP_PLANES = (1 << 19),
|
|
DRW_STATE_ADDITIVE_FULL = (1 << 20), /* Same as DRW_STATE_ADDITIVE but let alpha accumulate without premult. */
|
|
DRW_STATE_BLEND_PREMUL = (1 << 21), /* Use that if color is already premult by alpha. */
|
|
DRW_STATE_WIRE_SMOOTH = (1 << 22),
|
|
DRW_STATE_TRANS_FEEDBACK = (1 << 23),
|
|
DRW_STATE_BLEND_OIT = (1 << 24),
|
|
|
|
DRW_STATE_WRITE_STENCIL = (1 << 27),
|
|
DRW_STATE_WRITE_STENCIL_SHADOW_PASS = (1 << 28),
|
|
DRW_STATE_WRITE_STENCIL_SHADOW_FAIL = (1 << 29),
|
|
DRW_STATE_STENCIL_EQUAL = (1 << 30),
|
|
DRW_STATE_STENCIL_NEQUAL = (1 << 31),
|
|
} DRWState;
|
|
#define DRW_STATE_DEFAULT (DRW_STATE_WRITE_DEPTH | DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL)
|
|
|
|
typedef enum {
|
|
DRW_ATTRIB_INT,
|
|
DRW_ATTRIB_FLOAT,
|
|
} DRWAttribType;
|
|
|
|
typedef struct DRWInstanceAttribFormat {
|
|
char name[32];
|
|
DRWAttribType type;
|
|
int components;
|
|
} DRWInstanceAttribFormat;
|
|
|
|
struct GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttribFormat attribs[], int arraysize);
|
|
#define DRW_shgroup_instance_format(format, ...) do { \
|
|
if (format == NULL) { \
|
|
DRWInstanceAttribFormat drw_format[] = __VA_ARGS__;\
|
|
format = DRW_shgroup_instance_format_array(drw_format, (sizeof(drw_format) / sizeof(DRWInstanceAttribFormat))); \
|
|
} \
|
|
} while (0)
|
|
|
|
DRWShadingGroup *DRW_shgroup_create(struct GPUShader *shader, DRWPass *pass);
|
|
DRWShadingGroup *DRW_shgroup_material_create(struct GPUMaterial *material, DRWPass *pass);
|
|
DRWShadingGroup *DRW_shgroup_material_instance_create(
|
|
struct GPUMaterial *material, DRWPass *pass, struct GPUBatch *geom, struct Object *ob,
|
|
struct GPUVertFormat *format);
|
|
DRWShadingGroup *DRW_shgroup_material_empty_tri_batch_create(struct GPUMaterial *material, DRWPass *pass, int size);
|
|
DRWShadingGroup *DRW_shgroup_instance_create(
|
|
struct GPUShader *shader, DRWPass *pass, struct GPUBatch *geom, struct GPUVertFormat *format);
|
|
DRWShadingGroup *DRW_shgroup_point_batch_create(struct GPUShader *shader, DRWPass *pass);
|
|
DRWShadingGroup *DRW_shgroup_line_batch_create_with_format(
|
|
struct GPUShader *shader, DRWPass *pass, struct GPUVertFormat *format);
|
|
DRWShadingGroup *DRW_shgroup_line_batch_create(
|
|
struct GPUShader *shader, DRWPass *pass);
|
|
DRWShadingGroup *DRW_shgroup_empty_tri_batch_create(
|
|
struct GPUShader *shader, DRWPass *pass, int size);
|
|
DRWShadingGroup *DRW_shgroup_transform_feedback_create(
|
|
struct GPUShader *shader, DRWPass *pass, struct GPUVertBuf *tf_target);
|
|
|
|
|
|
typedef void (DRWCallGenerateFn)(
|
|
DRWShadingGroup *shgroup,
|
|
void (*draw_fn)(DRWShadingGroup *shgroup, struct GPUBatch *geom),
|
|
void *user_data);
|
|
|
|
/* return final visibility */
|
|
typedef bool (DRWCallVisibilityFn)(
|
|
bool vis_in,
|
|
void *user_data);
|
|
|
|
void DRW_shgroup_instance_batch(DRWShadingGroup *shgroup, struct GPUBatch *batch);
|
|
|
|
void DRW_shgroup_free(struct DRWShadingGroup *shgroup);
|
|
void DRW_shgroup_call_add(DRWShadingGroup *shgroup, struct GPUBatch *geom, float (*obmat)[4]);
|
|
void DRW_shgroup_call_range_add(
|
|
DRWShadingGroup *shgroup, struct GPUBatch *geom, float (*obmat)[4], uint v_sta, uint v_count);
|
|
void DRW_shgroup_call_procedural_points_add(DRWShadingGroup *shgroup, uint point_len, float (*obmat)[4]);
|
|
void DRW_shgroup_call_procedural_lines_add(DRWShadingGroup *shgroup, uint line_count, float (*obmat)[4]);
|
|
void DRW_shgroup_call_procedural_triangles_add(DRWShadingGroup *shgroup, uint tria_count, float (*obmat)[4]);
|
|
void DRW_shgroup_call_object_procedural_triangles_culled_add(DRWShadingGroup *shgroup, uint tria_count, struct Object *ob);
|
|
void DRW_shgroup_call_object_add_ex(DRWShadingGroup *shgroup, struct GPUBatch *geom, struct Object *ob, bool bypass_culling);
|
|
#define DRW_shgroup_call_object_add(shgroup, geom, ob) DRW_shgroup_call_object_add_ex(shgroup, geom, ob, false)
|
|
#define DRW_shgroup_call_object_add_no_cull(shgroup, geom, ob) DRW_shgroup_call_object_add_ex(shgroup, geom, ob, true)
|
|
void DRW_shgroup_call_object_add_with_callback(
|
|
DRWShadingGroup *shgroup, struct GPUBatch *geom, struct Object *ob,
|
|
DRWCallVisibilityFn *callback, void *user_data);
|
|
/* Used for drawing a batch with instancing without instance attribs. */
|
|
void DRW_shgroup_call_instances_add(
|
|
DRWShadingGroup *shgroup, struct GPUBatch *geom, float (*obmat)[4], uint *count);
|
|
void DRW_shgroup_call_object_instances_add(
|
|
DRWShadingGroup *shgroup, struct GPUBatch *geom, struct Object *ob, uint *count);
|
|
void DRW_shgroup_call_sculpt_add(DRWShadingGroup *shgroup, struct Object *ob, float (*obmat)[4]);
|
|
void DRW_shgroup_call_generate_add(
|
|
DRWShadingGroup *shgroup, DRWCallGenerateFn *geometry_fn, void *user_data, float (*obmat)[4]);
|
|
void DRW_shgroup_call_dynamic_add_array(DRWShadingGroup *shgroup, const void *attr[], uint attr_len);
|
|
#define DRW_shgroup_call_dynamic_add(shgroup, ...) do { \
|
|
const void *array[] = {__VA_ARGS__}; \
|
|
DRW_shgroup_call_dynamic_add_array(shgroup, array, (sizeof(array) / sizeof(*array))); \
|
|
} while (0)
|
|
|
|
uint DRW_shgroup_get_instance_count(const DRWShadingGroup *shgroup);
|
|
|
|
void DRW_shgroup_state_enable(DRWShadingGroup *shgroup, DRWState state);
|
|
void DRW_shgroup_state_disable(DRWShadingGroup *shgroup, DRWState state);
|
|
void DRW_shgroup_stencil_mask(DRWShadingGroup *shgroup, uint mask);
|
|
|
|
void DRW_shgroup_uniform_texture(DRWShadingGroup *shgroup, const char *name, const struct GPUTexture *tex);
|
|
void DRW_shgroup_uniform_texture_persistent(DRWShadingGroup *shgroup, const char *name, const struct GPUTexture *tex);
|
|
void DRW_shgroup_uniform_block(DRWShadingGroup *shgroup, const char *name, const struct GPUUniformBuffer *ubo);
|
|
void DRW_shgroup_uniform_block_persistent(DRWShadingGroup *shgroup, const char *name, const struct GPUUniformBuffer *ubo);
|
|
void DRW_shgroup_uniform_texture_ref(DRWShadingGroup *shgroup, const char *name, struct GPUTexture **tex);
|
|
void DRW_shgroup_uniform_float(DRWShadingGroup *shgroup, const char *name, const float *value, int arraysize);
|
|
void DRW_shgroup_uniform_vec2(DRWShadingGroup *shgroup, const char *name, const float *value, int arraysize);
|
|
void DRW_shgroup_uniform_vec3(DRWShadingGroup *shgroup, const char *name, const float *value, int arraysize);
|
|
void DRW_shgroup_uniform_vec4(DRWShadingGroup *shgroup, const char *name, const float *value, int arraysize);
|
|
void DRW_shgroup_uniform_short_to_int(DRWShadingGroup *shgroup, const char *name, const short *value, int arraysize);
|
|
void DRW_shgroup_uniform_short_to_float(DRWShadingGroup *shgroup, const char *name, const short *value, int arraysize);
|
|
/* Boolean are expected to be 4bytes longs for opengl! */
|
|
void DRW_shgroup_uniform_bool(DRWShadingGroup *shgroup, const char *name, const int *value, int arraysize);
|
|
void DRW_shgroup_uniform_int(DRWShadingGroup *shgroup, const char *name, const int *value, int arraysize);
|
|
void DRW_shgroup_uniform_ivec2(DRWShadingGroup *shgroup, const char *name, const int *value, int arraysize);
|
|
void DRW_shgroup_uniform_ivec3(DRWShadingGroup *shgroup, const char *name, const int *value, int arraysize);
|
|
void DRW_shgroup_uniform_mat3(DRWShadingGroup *shgroup, const char *name, const float (*value)[3]);
|
|
void DRW_shgroup_uniform_mat4(DRWShadingGroup *shgroup, const char *name, const float (*value)[4]);
|
|
/* Store value instead of referencing it. */
|
|
void DRW_shgroup_uniform_int_copy(DRWShadingGroup *shgroup, const char *name, const int value);
|
|
void DRW_shgroup_uniform_bool_copy(DRWShadingGroup *shgroup, const char *name, const bool value);
|
|
void DRW_shgroup_uniform_float_copy(DRWShadingGroup *shgroup, const char *name, const float value);
|
|
|
|
bool DRW_shgroup_is_empty(DRWShadingGroup *shgroup);
|
|
|
|
/* Passes */
|
|
DRWPass *DRW_pass_create(const char *name, DRWState state);
|
|
void DRW_pass_state_set(DRWPass *pass, DRWState state);
|
|
void DRW_pass_state_add(DRWPass *pass, DRWState state);
|
|
void DRW_pass_state_remove(DRWPass *pass, DRWState state);
|
|
void DRW_pass_foreach_shgroup(DRWPass *pass, void (*callback)(void *userData, DRWShadingGroup *shgrp), void *userData);
|
|
void DRW_pass_sort_shgroup_z(DRWPass *pass);
|
|
|
|
bool DRW_pass_is_empty(DRWPass *pass);
|
|
|
|
/* Viewport */
|
|
typedef enum {
|
|
/* keep in sync with the union struct DRWMatrixState. */
|
|
DRW_MAT_PERS = 0,
|
|
DRW_MAT_PERSINV,
|
|
DRW_MAT_VIEW,
|
|
DRW_MAT_VIEWINV,
|
|
DRW_MAT_WIN,
|
|
DRW_MAT_WININV,
|
|
|
|
DRW_MAT_COUNT, // Don't use this.
|
|
} DRWViewportMatrixType;
|
|
|
|
typedef struct DRWMatrixState {
|
|
union {
|
|
float mat[DRW_MAT_COUNT][4][4];
|
|
struct {
|
|
/* keep in sync with the enum DRWViewportMatrixType. */
|
|
float persmat[4][4];
|
|
float persinv[4][4];
|
|
float viewmat[4][4];
|
|
float viewinv[4][4];
|
|
float winmat[4][4];
|
|
float wininv[4][4];
|
|
};
|
|
};
|
|
} DRWMatrixState;
|
|
|
|
void DRW_viewport_init(const bContext *C);
|
|
void DRW_viewport_matrix_get(float mat[4][4], DRWViewportMatrixType type);
|
|
void DRW_viewport_matrix_get_all(DRWMatrixState *state);
|
|
void DRW_viewport_matrix_override_set(const float mat[4][4], DRWViewportMatrixType type);
|
|
void DRW_viewport_matrix_override_set_all(DRWMatrixState *state);
|
|
void DRW_viewport_matrix_override_unset(DRWViewportMatrixType type);
|
|
void DRW_viewport_matrix_override_unset_all(void);
|
|
|
|
/* These are in view-space so negative if in perspective.
|
|
* Extract near and far clip distance from the projection matrix. */
|
|
float DRW_viewport_near_distance_get(void);
|
|
float DRW_viewport_far_distance_get(void);
|
|
|
|
const float *DRW_viewport_size_get(void);
|
|
const float *DRW_viewport_invert_size_get(void);
|
|
const float *DRW_viewport_screenvecs_get(void);
|
|
const float *DRW_viewport_pixelsize_get(void);
|
|
bool DRW_viewport_is_persp_get(void);
|
|
|
|
struct DefaultFramebufferList *DRW_viewport_framebuffer_list_get(void);
|
|
struct DefaultTextureList *DRW_viewport_texture_list_get(void);
|
|
|
|
void DRW_viewport_request_redraw(void);
|
|
|
|
void DRW_render_to_image(struct RenderEngine *engine, struct Depsgraph *depsgraph);
|
|
void DRW_render_object_iter(
|
|
void *vedata, struct RenderEngine *engine, struct Depsgraph *depsgraph,
|
|
void (*callback)(void *vedata, struct Object *ob, struct RenderEngine *engine, struct Depsgraph *depsgraph));
|
|
void DRW_render_instance_buffer_finish(void);
|
|
|
|
void DRW_custom_pipeline(
|
|
DrawEngineType *draw_engine_type,
|
|
struct Depsgraph *depsgraph,
|
|
void (*callback)(void *vedata, void *user_data),
|
|
void *user_data);
|
|
|
|
/* ViewLayers */
|
|
void *DRW_view_layer_engine_data_get(DrawEngineType *engine_type);
|
|
void **DRW_view_layer_engine_data_ensure_ex(
|
|
struct ViewLayer *view_layer, DrawEngineType *engine_type, void (*callback)(void *storage));
|
|
void **DRW_view_layer_engine_data_ensure(
|
|
DrawEngineType *engine_type, void (*callback)(void *storage));
|
|
|
|
/* DrawData */
|
|
DrawData *DRW_drawdata_get(ID *ib, DrawEngineType *engine_type);
|
|
DrawData *DRW_drawdata_ensure(
|
|
ID *id,
|
|
DrawEngineType *engine_type,
|
|
size_t size,
|
|
DrawDataInitCb init_cb,
|
|
DrawDataFreeCb free_cb);
|
|
|
|
/* Settings */
|
|
bool DRW_object_is_renderable(struct Object *ob);
|
|
bool DRW_check_object_visible_within_active_context(struct Object *ob);
|
|
bool DRW_object_is_flat_normal(const struct Object *ob);
|
|
|
|
bool DRW_check_psys_visible_within_active_context(struct Object *object, struct ParticleSystem *psys);
|
|
|
|
/* Draw commands */
|
|
void DRW_draw_pass(DRWPass *pass);
|
|
void DRW_draw_pass_subset(DRWPass *pass, DRWShadingGroup *start_group, DRWShadingGroup *end_group);
|
|
|
|
void DRW_draw_text_cache_queue(struct DRWTextStore *dt);
|
|
|
|
void DRW_draw_callbacks_pre_scene(void);
|
|
void DRW_draw_callbacks_post_scene(void);
|
|
|
|
int DRW_draw_region_engine_info_offset(void);
|
|
void DRW_draw_region_engine_info(void);
|
|
|
|
void DRW_state_reset_ex(DRWState state);
|
|
void DRW_state_reset(void);
|
|
void DRW_state_lock(DRWState state);
|
|
|
|
void DRW_state_invert_facing(void);
|
|
|
|
void DRW_state_clip_planes_count_set(uint plane_len);
|
|
void DRW_state_clip_planes_reset(void);
|
|
|
|
/* Culling, return true if object is inside view frustum. */
|
|
bool DRW_culling_sphere_test(BoundSphere *bsphere);
|
|
bool DRW_culling_box_test(BoundBox *bbox);
|
|
bool DRW_culling_plane_test(float plane[4]);
|
|
|
|
void DRW_culling_frustum_corners_get(BoundBox *corners);
|
|
void DRW_culling_frustum_planes_get(float planes[6][4]);
|
|
|
|
/* Selection */
|
|
void DRW_select_load_id(uint id);
|
|
|
|
/* Draw State */
|
|
void DRW_state_dfdy_factors_get(float dfdyfac[2]);
|
|
bool DRW_state_is_fbo(void);
|
|
bool DRW_state_is_select(void);
|
|
bool DRW_state_is_depth(void);
|
|
bool DRW_state_is_image_render(void);
|
|
bool DRW_state_is_scene_render(void);
|
|
bool DRW_state_is_opengl_render(void);
|
|
bool DRW_state_show_text(void);
|
|
bool DRW_state_draw_support(void);
|
|
bool DRW_state_draw_background(void);
|
|
|
|
struct DRWTextStore *DRW_state_text_cache_get(void);
|
|
|
|
/* Avoid too many lookups while drawing */
|
|
typedef struct DRWContextState {
|
|
|
|
struct ARegion *ar; /* 'CTX_wm_region(C)' */
|
|
struct RegionView3D *rv3d; /* 'CTX_wm_region_view3d(C)' */
|
|
struct View3D *v3d; /* 'CTX_wm_view3d(C)' */
|
|
|
|
struct Scene *scene; /* 'CTX_data_scene(C)' */
|
|
struct ViewLayer *view_layer; /* 'CTX_data_view_layer(C)' */
|
|
|
|
/* Use 'object_edit' for edit-mode */
|
|
struct Object *obact; /* 'OBACT' */
|
|
|
|
struct RenderEngineType *engine_type;
|
|
|
|
struct Depsgraph *depsgraph;
|
|
|
|
eObjectMode object_mode;
|
|
|
|
/* Last resort (some functions take this as an arg so we can't easily avoid).
|
|
* May be NULL when used for selection or depth buffer. */
|
|
const struct bContext *evil_C;
|
|
|
|
/* ---- */
|
|
|
|
/* Cache: initialized by 'drw_context_state_init'. */
|
|
struct Object *object_pose;
|
|
struct Object *object_edit;
|
|
|
|
} DRWContextState;
|
|
|
|
const DRWContextState *DRW_context_state_get(void);
|
|
|
|
#endif /* __DRW_RENDER_H__ */
|