tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: Remove unnecessary keywords in C++ headers

This commit is contained in:
Hans Goudey 2024-01-24 11:46:28 -05:00
parent 500f09b88a
commit d02d6ec4e5
15 changed files with 758 additions and 815 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
source/blender/blenkernel/BKE_mball.hh
View File

@ -15,30 +15,30 @@ struct MetaElem;
struct Object;
struct Scene;
struct MetaBall *BKE_mball_add(struct Main *bmain, const char *name);
MetaBall *BKE_mball_add(Main *bmain, const char *name);
bool BKE_mball_is_any_selected(const struct MetaBall *mb);
bool BKE_mball_is_any_selected_multi(struct Base **bases, int bases_len);
bool BKE_mball_is_any_unselected(const struct MetaBall *mb);
bool BKE_mball_is_any_selected(const MetaBall *mb);
bool BKE_mball_is_any_selected_multi(Base **bases, int bases_len);
bool BKE_mball_is_any_unselected(const MetaBall *mb);
/**
* Return `true` if `ob1` and `ob2` are part of the same metaBall group.
*
* \note Currently checks whether their two base names (without numerical suffix) is the same.
*/
bool BKE_mball_is_same_group(const struct Object *ob1, const struct Object *ob2);
bool BKE_mball_is_same_group(const Object *ob1, const Object *ob2);
/**
* Return `true` if `ob1` and `ob2` are part of the same metaBall group, and `ob1` is its
* basis.
*/
bool BKE_mball_is_basis_for(const struct Object *ob1, const struct Object *ob2);
bool BKE_mball_is_basis_for(const Object *ob1, const Object *ob2);
/**
* Test, if \a ob is a basis meta-ball.
*
* It test last character of Object ID name.
* If last character is digit it return 0, else it return 1.
*/
bool BKE_mball_is_basis(const struct Object *ob);
bool BKE_mball_is_basis(const Object *ob);
/**
* This function finds the basis meta-ball.
*
@ -48,7 +48,7 @@ bool BKE_mball_is_basis(const struct Object *ob);
*
* \warning #BKE_mball_is_basis() can fail on returned object, see function docs for details.
*/
struct Object *BKE_mball_basis_find(struct Scene *scene, struct Object *ob);
Object *BKE_mball_basis_find(Scene *scene, Object *ob);
/**
* Copy some properties from a meta-ball obdata to all other meta-ball obdata belonging to the same
@ -59,37 +59,37 @@ struct Object *BKE_mball_basis_find(struct Scene *scene, struct Object *ob);
* `MBall`, `MBall.001`, `MBall.002`, etc). The most important is to copy properties to the base
* meta-ball, because this meta-ball influences polygonization of meta-balls.
*/
void BKE_mball_properties_copy(struct Main *bmain, struct MetaBall *metaball_src);
void BKE_mball_properties_copy(Main *bmain, MetaBall *metaball_src);
bool BKE_mball_minmax_ex(
const struct MetaBall *mb, float min[3], float max[3], const float obmat[4][4], short flag);
const MetaBall *mb, float min[3], float max[3], const float obmat[4][4], short flag);
/* Basic vertex data functions. */
bool BKE_mball_minmax(const struct MetaBall *mb, float min[3], float max[3]);
bool BKE_mball_center_median(const struct MetaBall *mb, float r_cent[3]);
bool BKE_mball_center_bounds(const struct MetaBall *mb, float r_cent[3]);
void BKE_mball_transform(struct MetaBall *mb, const float mat[4][4], bool do_props);
void BKE_mball_translate(struct MetaBall *mb, const float offset[3]);
bool BKE_mball_minmax(const MetaBall *mb, float min[3], float max[3]);
bool BKE_mball_center_median(const MetaBall *mb, float r_cent[3]);
bool BKE_mball_center_bounds(const MetaBall *mb, float r_cent[3]);
void BKE_mball_transform(MetaBall *mb, const float mat[4][4], bool do_props);
void BKE_mball_translate(MetaBall *mb, const float offset[3]);
/**
* Most simple meta-element adding function.
*
* \note don't do context manipulation here (rna uses).
*/
struct MetaElem *BKE_mball_element_add(struct MetaBall *mb, int type);
MetaElem *BKE_mball_element_add(MetaBall *mb, int type);
/* *** Select functions *** */
int BKE_mball_select_count(const struct MetaBall *mb);
int BKE_mball_select_count_multi(struct Base **bases, int bases_len);
bool BKE_mball_select_all(struct MetaBall *mb);
bool BKE_mball_select_all_multi_ex(struct Base **bases, int bases_len);
bool BKE_mball_deselect_all(struct MetaBall *mb);
bool BKE_mball_deselect_all_multi_ex(struct Base **bases, int bases_len);
bool BKE_mball_select_swap(struct MetaBall *mb);
bool BKE_mball_select_swap_multi_ex(struct Base **bases, int bases_len);
int BKE_mball_select_count(const MetaBall *mb);
int BKE_mball_select_count_multi(Base **bases, int bases_len);
bool BKE_mball_select_all(MetaBall *mb);
bool BKE_mball_select_all_multi_ex(Base **bases, int bases_len);
bool BKE_mball_deselect_all(MetaBall *mb);
bool BKE_mball_deselect_all_multi_ex(Base **bases, int bases_len);
bool BKE_mball_select_swap(MetaBall *mb);
bool BKE_mball_select_swap_multi_ex(Base **bases, int bases_len);
/* **** Depsgraph evaluation **** */
void BKE_mball_data_update(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob);
void BKE_mball_data_update(Depsgraph *depsgraph, Scene *scene, Object *ob);

6
source/blender/blenkernel/BKE_mball_tessellate.hh
View File

@ -12,8 +12,6 @@ struct Object;
struct Scene;
struct Mesh;
struct Mesh *BKE_mball_polygonize(struct Depsgraph *depsgraph,
struct Scene *scene,
struct Object *ob);
Mesh *BKE_mball_polygonize(Depsgraph *depsgraph, Scene *scene, Object *ob);
void BKE_mball_cubeTable_free(void);
void BKE_mball_cubeTable_free();

9
source/blender/blenkernel/BKE_undo_system.hh
View File

@ -95,7 +95,7 @@ enum eUndoPushReturn {
};
ENUM_OPERATORS(eUndoPushReturn, UNDO_PUSH_RET_OVERRIDE_CHANGED)
using UndoTypeForEachIDRefFn = void (*)(void *user_data, struct UndoRefID *id_ref);
using UndoTypeForEachIDRefFn = void (*)(void *user_data, UndoRefID *id_ref);
struct UndoType {
UndoType *next, *prev;
@ -116,11 +116,10 @@ struct UndoType {
* Note that 'step_encode_init' is optional,
* some undo types need to perform operations before undo push finishes.
*/
void (*step_encode_init)(struct bContext *C, UndoStep *us);
void (*step_encode_init)(bContext *C, UndoStep *us);
bool (*step_encode)(struct bContext *C, struct Main *bmain, UndoStep *us);
void (*step_decode)(
struct bContext *C, struct Main *bmain, UndoStep *us, eUndoStepDir dir, bool is_final);
bool (*step_encode)(bContext *C, Main *bmain, UndoStep *us);
void (*step_decode)(bContext *C, Main *bmain, UndoStep *us, eUndoStepDir dir, bool is_final);
/**
* \note When freeing all steps,

4
source/blender/bmesh/tools/bmesh_boolean.hh
View File

@ -9,7 +9,7 @@
*/
bool BM_mesh_boolean(BMesh *bm,
struct BMLoop *(*looptris)[3],
BMLoop *(*looptris)[3],
int looptris_tot,
int (*test_fn)(BMFace *f, void *user_data),
void *user_data,
@ -30,7 +30,7 @@ bool BM_mesh_boolean(BMesh *bm,
* to the intersection result faces.
*/
bool BM_mesh_boolean_knife(BMesh *bm,
struct BMLoop *(*looptris)[3],
BMLoop *(*looptris)[3],
int looptris_tot,
int (*test_fn)(BMFace *f, void *user_data),
void *user_data,

39
source/blender/bmesh/tools/bmesh_path.hh
View File

@ -13,26 +13,23 @@ struct BMCalcPathParams {
uint use_step_face : 1;
};
struct LinkNode *BM_mesh_calc_path_vert(BMesh *bm,
BMVert *v_src,
BMVert *v_dst,
const struct BMCalcPathParams *params,
bool (*filter_fn)(BMVert *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT
ATTR_NONNULL(1, 2, 3, 5);
LinkNode *BM_mesh_calc_path_vert(BMesh *bm,
BMVert *v_src,
BMVert *v_dst,
const BMCalcPathParams *params,
bool (*filter_fn)(BMVert *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2, 3, 5);
struct LinkNode *BM_mesh_calc_path_edge(BMesh *bm,
BMEdge *e_src,
BMEdge *e_dst,
const struct BMCalcPathParams *params,
bool (*filter_fn)(BMEdge *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT
ATTR_NONNULL(1, 2, 3, 5);
LinkNode *BM_mesh_calc_path_edge(BMesh *bm,
BMEdge *e_src,
BMEdge *e_dst,
const BMCalcPathParams *params,
bool (*filter_fn)(BMEdge *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2, 3, 5);
struct LinkNode *BM_mesh_calc_path_face(BMesh *bm,
BMFace *f_src,
BMFace *f_dst,
const struct BMCalcPathParams *params,
bool (*filter_fn)(BMFace *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT
ATTR_NONNULL(1, 2, 3, 5);
LinkNode *BM_mesh_calc_path_face(BMesh *bm,
BMFace *f_src,
BMFace *f_dst,
const BMCalcPathParams *params,
bool (*filter_fn)(BMFace *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2, 3, 5);

36
source/blender/bmesh/tools/bmesh_path_uv.hh
View File

@ -15,26 +15,26 @@ struct BMCalcPathUVParams {
float aspect_y;
};
struct LinkNode *BM_mesh_calc_path_uv_vert(BMesh *bm,
BMLoop *l_src,
BMLoop *l_dst,
const struct BMCalcPathUVParams *params,
bool (*filter_fn)(BMLoop *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT
LinkNode *BM_mesh_calc_path_uv_vert(BMesh *bm,
BMLoop *l_src,
BMLoop *l_dst,
const BMCalcPathUVParams *params,
bool (*filter_fn)(BMLoop *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT
ATTR_NONNULL(1, 2, 3, 5);
struct LinkNode *BM_mesh_calc_path_uv_edge(BMesh *bm,
BMLoop *l_src,
BMLoop *l_dst,
const struct BMCalcPathUVParams *params,
bool (*filter_fn)(BMLoop *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT
LinkNode *BM_mesh_calc_path_uv_edge(BMesh *bm,
BMLoop *l_src,
BMLoop *l_dst,
const BMCalcPathUVParams *params,
bool (*filter_fn)(BMLoop *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT
ATTR_NONNULL(1, 2, 3, 5);
struct LinkNode *BM_mesh_calc_path_uv_face(BMesh *bm,
BMFace *f_src,
BMFace *f_dst,
const struct BMCalcPathUVParams *params,
bool (*filter_fn)(BMFace *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT
LinkNode *BM_mesh_calc_path_uv_face(BMesh *bm,
BMFace *f_src,
BMFace *f_dst,
const BMCalcPathUVParams *params,
bool (*filter_fn)(BMFace *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT
ATTR_NONNULL(1, 2, 3, 5);

154
source/blender/draw/DRW_engine.hh
View File

@ -16,6 +16,7 @@ struct ARegion;
struct DRWData;
struct DRWInstanceDataList;
struct Depsgraph;
struct DrawDataList;
struct DrawEngineType;
struct GHash;
struct GPUMaterial;
@ -37,23 +38,23 @@ struct ViewLayer;
struct bContext;
struct rcti;
void DRW_engines_register(void);
void DRW_engines_free(void);
void DRW_engines_register();
void DRW_engines_free();
bool DRW_engine_render_support(struct DrawEngineType *draw_engine_type);
void DRW_engine_register(struct DrawEngineType *draw_engine_type);
bool DRW_engine_render_support(DrawEngineType *draw_engine_type);
void DRW_engine_register(DrawEngineType *draw_engine_type);
void DRW_engine_external_free(struct RegionView3D *rv3d);
void DRW_engine_external_free(RegionView3D *rv3d);
typedef struct DRWUpdateContext {
struct Main *bmain;
struct Depsgraph *depsgraph;
struct Scene *scene;
struct ViewLayer *view_layer;
struct ARegion *region;
struct View3D *v3d;
struct RenderEngineType *engine_type;
} DRWUpdateContext;
struct DRWUpdateContext {
Main *bmain;
Depsgraph *depsgraph;
Scene *scene;
ViewLayer *view_layer;
ARegion *region;
View3D *v3d;
RenderEngineType *engine_type;
};
void DRW_notify_view_update(const DRWUpdateContext *update_ctx);
typedef enum eDRWSelectStage {
@ -61,14 +62,14 @@ typedef enum eDRWSelectStage {
DRW_SELECT_PASS_POST,
} eDRWSelectStage;
typedef bool (*DRW_SelectPassFn)(eDRWSelectStage stage, void *user_data);
typedef bool (*DRW_ObjectFilterFn)(struct Object *ob, void *user_data);
typedef bool (*DRW_ObjectFilterFn)(Object *ob, void *user_data);
/**
* Everything starts here.
* This function takes care of calling all cache and rendering functions
* for each relevant engine / mode engine.
*/
void DRW_draw_view(const struct bContext *C);
void DRW_draw_view(const bContext *C);
/**
* Draw render engine info.
*/
@ -78,43 +79,43 @@ void DRW_draw_region_engine_info(int xoffset, int *yoffset, int line_height);
* Used for both regular and off-screen drawing.
* Need to reset DST before calling this function
*/
void DRW_draw_render_loop_ex(struct Depsgraph *depsgraph,
struct RenderEngineType *engine_type,
struct ARegion *region,
struct View3D *v3d,
struct GPUViewport *viewport,
const struct bContext *evil_C);
void DRW_draw_render_loop(struct Depsgraph *depsgraph,
struct ARegion *region,
struct View3D *v3d,
struct GPUViewport *viewport);
void DRW_draw_render_loop_ex(Depsgraph *depsgraph,
RenderEngineType *engine_type,
ARegion *region,
View3D *v3d,
GPUViewport *viewport,
const bContext *evil_C);
void DRW_draw_render_loop(Depsgraph *depsgraph,
ARegion *region,
View3D *v3d,
GPUViewport *viewport);
/**
* \param viewport: can be NULL, in this case we create one.
*/
void DRW_draw_render_loop_offscreen(struct Depsgraph *depsgraph,
struct RenderEngineType *engine_type,
struct ARegion *region,
struct View3D *v3d,
void DRW_draw_render_loop_offscreen(Depsgraph *depsgraph,
RenderEngineType *engine_type,
ARegion *region,
View3D *v3d,
bool is_image_render,
bool draw_background,
bool do_color_management,
struct GPUOffScreen *ofs,
struct GPUViewport *viewport);
void DRW_draw_render_loop_2d_ex(struct Depsgraph *depsgraph,
struct ARegion *region,
struct GPUViewport *viewport,
const struct bContext *evil_C);
GPUOffScreen *ofs,
GPUViewport *viewport);
void DRW_draw_render_loop_2d_ex(Depsgraph *depsgraph,
ARegion *region,
GPUViewport *viewport,
const bContext *evil_C);
/**
* object mode select-loop, see: #ED_view3d_draw_select_loop (legacy drawing).
*/
void DRW_draw_select_loop(struct Depsgraph *depsgraph,
struct ARegion *region,
struct View3D *v3d,
void DRW_draw_select_loop(Depsgraph *depsgraph,
ARegion *region,
View3D *v3d,
bool use_obedit_skip,
bool draw_surface,
bool use_nearest,
bool do_material_sub_selection,
const struct rcti *rect,
const rcti *rect,
DRW_SelectPassFn select_pass_fn,
void *select_pass_user_data,
DRW_ObjectFilterFn object_filter_fn,
@ -122,63 +123,60 @@ void DRW_draw_select_loop(struct Depsgraph *depsgraph,
/**
* Object mode select-loop, see: #ED_view3d_draw_depth_loop (legacy drawing).
*/
void DRW_draw_depth_loop(struct Depsgraph *depsgraph,
struct ARegion *region,
struct View3D *v3d,
struct GPUViewport *viewport,
void DRW_draw_depth_loop(Depsgraph *depsgraph,
ARegion *region,
View3D *v3d,
GPUViewport *viewport,
const bool use_gpencil,
const bool use_basic,
const bool use_overlay);
/**
* Clears the Depth Buffer and draws only the specified object.
*/
void DRW_draw_depth_object(struct Scene *scene,
struct ARegion *region,
struct View3D *v3d,
struct GPUViewport *viewport,
struct Object *object);
void DRW_draw_select_id(struct Depsgraph *depsgraph, struct ARegion *region, struct View3D *v3d);
void DRW_draw_depth_object(
Scene *scene, ARegion *region, View3D *v3d, GPUViewport *viewport, Object *object);
void DRW_draw_select_id(Depsgraph *depsgraph, ARegion *region, View3D *v3d);
/* Grease pencil render. */
/**
* Helper to check if exit object type to render.
*/
bool DRW_render_check_grease_pencil(struct Depsgraph *depsgraph);
void DRW_render_gpencil(struct RenderEngine *engine, struct Depsgraph *depsgraph);
bool DRW_render_check_grease_pencil(Depsgraph *depsgraph);
void DRW_render_gpencil(RenderEngine *engine, Depsgraph *depsgraph);
/**
* This is here because #GPUViewport needs it.
*/
struct DRWInstanceDataList *DRW_instance_data_list_create(void);
void DRW_instance_data_list_free(struct DRWInstanceDataList *idatalist);
void DRW_uniform_attrs_pool_free(struct GHash *table);
DRWInstanceDataList *DRW_instance_data_list_create();
void DRW_instance_data_list_free(DRWInstanceDataList *idatalist);
void DRW_uniform_attrs_pool_free(GHash *table);
void DRW_render_context_enable(struct Render *render);
void DRW_render_context_disable(struct Render *render);
void DRW_render_context_enable(Render *render);
void DRW_render_context_disable(Render *render);
void DRW_gpu_context_create(void);
void DRW_gpu_context_destroy(void);
void DRW_gpu_context_enable(void);
void DRW_gpu_context_disable(void);
void DRW_gpu_context_create();
void DRW_gpu_context_destroy();
void DRW_gpu_context_enable();
void DRW_gpu_context_disable();
#ifdef WITH_XR_OPENXR
/* XXX: see comment on #DRW_system_gpu_context_get() */
void *DRW_system_gpu_context_get(void);
void *DRW_xr_blender_gpu_context_get(void);
void DRW_xr_drawing_begin(void);
void DRW_xr_drawing_end(void);
void *DRW_system_gpu_context_get();
void *DRW_xr_blender_gpu_context_get();
void DRW_xr_drawing_begin();
void DRW_xr_drawing_end();
#endif
/* For garbage collection */
void DRW_cache_free_old_batches(struct Main *bmain);
void DRW_cache_free_old_batches(Main *bmain);
namespace blender::draw {
void DRW_cache_free_old_subdiv(void);
void DRW_cache_free_old_subdiv();
/* For the OpenGL evaluators and garbage collected subdivision data. */
void DRW_subdiv_free(void);
void DRW_subdiv_free();
} // namespace blender::draw
@ -194,29 +192,29 @@ void DRW_system_gpu_render_context_disable(void *re_system_gpu_context);
void DRW_blender_gpu_render_context_enable(void *re_gpu_context);
void DRW_blender_gpu_render_context_disable(void *re_gpu_context);
void DRW_deferred_shader_remove(struct GPUMaterial *mat);
void DRW_deferred_shader_optimize_remove(struct GPUMaterial *mat);
void DRW_deferred_shader_remove(GPUMaterial *mat);
void DRW_deferred_shader_optimize_remove(GPUMaterial *mat);
/**
* Get DrawData from the given ID-block. In order for this to work, we assume that
* the DrawData pointer is stored in the struct in the same fashion as in #IdDdtTemplate.
* the DrawData pointer is stored in the in the same fashion as in #IdDdtTemplate.
*/
struct DrawDataList *DRW_drawdatalist_from_id(struct ID *id);
void DRW_drawdata_free(struct ID *id);
DrawDataList *DRW_drawdatalist_from_id(ID *id);
void DRW_drawdata_free(ID *id);
struct DRWData *DRW_viewport_data_create(void);
void DRW_viewport_data_free(struct DRWData *drw_data);
DRWData *DRW_viewport_data_create();
void DRW_viewport_data_free(DRWData *drw_data);
bool DRW_gpu_context_release(void);
bool DRW_gpu_context_release();
void DRW_gpu_context_activate(bool drw_state);
/**
* We may want to move this into a more general location.
* \note This doesn't require the draw context to be in use.
*/
void DRW_draw_cursor_2d_ex(const struct ARegion *region, const float cursor[2]);
void DRW_draw_cursor_2d_ex(const ARegion *region, const float cursor[2]);
void DRW_cdlayer_attr_aliases_add(struct GPUVertFormat *format,
void DRW_cdlayer_attr_aliases_add(GPUVertFormat *format,
const char *base_name,
int data_type,
const char *layer_name,

451
source/blender/draw/intern/DRW_render.hh
View File

@ -71,6 +71,7 @@ struct ParticleSystem;
struct RenderEngineType;
struct bContext;
struct rcti;
struct TaskGraph;
namespace blender::draw {
struct DRW_Attributes;
struct DRW_MeshCDMask;
@ -85,9 +86,9 @@ typedef struct DRWUniform DRWUniform;
typedef struct DRWView DRWView;
/* TODO: Put it somewhere else? */
typedef struct BoundSphere {
struct BoundSphere {
float center[3], radius;
} BoundSphere;
};
/* declare members as empty (unused) */
typedef char DRWViewportEmptyList;
@ -103,141 +104,141 @@ typedef char DRWViewportEmptyList;
DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->stl)), \
}
typedef struct DrawEngineDataSize {
struct DrawEngineDataSize {
int fbl_len;
int txl_len;
int psl_len;
int stl_len;
} DrawEngineDataSize;
};
typedef struct DrawEngineType {
struct DrawEngineType *next, *prev;
struct DrawEngineType {
DrawEngineType *next, *prev;
char idname[32];
const DrawEngineDataSize *vedata_size;
void (*engine_init)(void *vedata);
void (*engine_free)(void);
void (*engine_free)();
void (*instance_free)(void *instance_data);
void (*cache_init)(void *vedata);
void (*cache_populate)(void *vedata, struct Object *ob);
void (*cache_populate)(void *vedata, Object *ob);
void (*cache_finish)(void *vedata);
void (*draw_scene)(void *vedata);
void (*view_update)(void *vedata);
void (*id_update)(void *vedata, struct ID *id);
void (*id_update)(void *vedata, ID *id);
void (*render_to_image)(void *vedata,
struct RenderEngine *engine,
struct RenderLayer *layer,
const struct rcti *rect);
void (*store_metadata)(void *vedata, struct RenderResult *render_result);
} DrawEngineType;
RenderEngine *engine,
RenderLayer *layer,
const rcti *rect);
void (*store_metadata)(void *vedata, RenderResult *render_result);
};
/* Textures */
typedef enum {
enum DRWTextureFlag {
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,
eGPUTextureFormat format,
DrawEngineType *engine_type);
struct GPUTexture *DRW_texture_pool_query_fullscreen(eGPUTextureFormat format,
DrawEngineType *engine_type);
GPUTexture *DRW_texture_pool_query_2d(int w,
int h,
eGPUTextureFormat format,
DrawEngineType *engine_type);
GPUTexture *DRW_texture_pool_query_fullscreen(eGPUTextureFormat format,
DrawEngineType *engine_type);
struct GPUTexture *DRW_texture_create_1d(int w,
eGPUTextureFormat format,
DRWTextureFlag flags,
const float *fpixels);
struct GPUTexture *DRW_texture_create_2d(
GPUTexture *DRW_texture_create_1d(int w,
eGPUTextureFormat format,
DRWTextureFlag flags,
const float *fpixels);
GPUTexture *DRW_texture_create_2d(
int w, int h, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
struct GPUTexture *DRW_texture_create_2d_array(
GPUTexture *DRW_texture_create_2d_array(
int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
struct GPUTexture *DRW_texture_create_3d(
GPUTexture *DRW_texture_create_3d(
int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
struct GPUTexture *DRW_texture_create_cube(int w,
eGPUTextureFormat format,
DRWTextureFlag flags,
const float *fpixels);
struct GPUTexture *DRW_texture_create_cube_array(
GPUTexture *DRW_texture_create_cube(int w,
eGPUTextureFormat format,
DRWTextureFlag flags,
const float *fpixels);
GPUTexture *DRW_texture_create_cube_array(
int w, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
void DRW_texture_ensure_fullscreen_2d(struct GPUTexture **tex,
void DRW_texture_ensure_fullscreen_2d(GPUTexture **tex,
eGPUTextureFormat format,
DRWTextureFlag flags);
void DRW_texture_ensure_2d(
struct GPUTexture **tex, int w, int h, eGPUTextureFormat format, DRWTextureFlag flags);
GPUTexture **tex, int w, int h, eGPUTextureFormat format, DRWTextureFlag flags);
/* Explicit parameter variants. */
struct GPUTexture *DRW_texture_pool_query_2d_ex(
GPUTexture *DRW_texture_pool_query_2d_ex(
int w, int h, eGPUTextureFormat format, eGPUTextureUsage usage, DrawEngineType *engine_type);
struct GPUTexture *DRW_texture_pool_query_fullscreen_ex(eGPUTextureFormat format,
eGPUTextureUsage usage,
DrawEngineType *engine_type);
GPUTexture *DRW_texture_pool_query_fullscreen_ex(eGPUTextureFormat format,
eGPUTextureUsage usage,
DrawEngineType *engine_type);
struct GPUTexture *DRW_texture_create_1d_ex(int w,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
struct GPUTexture *DRW_texture_create_2d_ex(int w,
int h,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
struct GPUTexture *DRW_texture_create_2d_array_ex(int w,
int h,
int d,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
struct GPUTexture *DRW_texture_create_3d_ex(int w,
int h,
int d,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
struct GPUTexture *DRW_texture_create_cube_ex(int w,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
struct GPUTexture *DRW_texture_create_cube_array_ex(int w,
int d,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
GPUTexture *DRW_texture_create_1d_ex(int w,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
GPUTexture *DRW_texture_create_2d_ex(int w,
int h,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
GPUTexture *DRW_texture_create_2d_array_ex(int w,
int h,
int d,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
GPUTexture *DRW_texture_create_3d_ex(int w,
int h,
int d,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
GPUTexture *DRW_texture_create_cube_ex(int w,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
GPUTexture *DRW_texture_create_cube_array_ex(int w,
int d,
eGPUTextureFormat format,
eGPUTextureUsage usage_flags,
DRWTextureFlag flags,
const float *fpixels);
void DRW_texture_ensure_fullscreen_2d_ex(struct GPUTexture **tex,
void DRW_texture_ensure_fullscreen_2d_ex(GPUTexture **tex,
eGPUTextureFormat format,
eGPUTextureUsage usage,
DRWTextureFlag flags);
void DRW_texture_ensure_2d_ex(struct GPUTexture **tex,
void DRW_texture_ensure_2d_ex(GPUTexture **tex,
int w,
int h,
eGPUTextureFormat format,
eGPUTextureUsage usage,
DRWTextureFlag flags);
void DRW_texture_generate_mipmaps(struct GPUTexture *tex);
void DRW_texture_free(struct GPUTexture *tex);
void DRW_texture_generate_mipmaps(GPUTexture *tex);
void DRW_texture_free(GPUTexture *tex);
#define DRW_TEXTURE_FREE_SAFE(tex) \
do { \
if (tex != NULL) { \
@ -255,34 +256,34 @@ void DRW_texture_free(struct GPUTexture *tex);
} while (0)
/* Shaders */
struct GPUShader *DRW_shader_create_from_info_name(const char *info_name);
struct GPUShader *DRW_shader_create_ex(
GPUShader *DRW_shader_create_from_info_name(const char *info_name);
GPUShader *DRW_shader_create_ex(
const char *vert, const char *geom, const char *frag, const char *defines, const char *name);
struct GPUShader *DRW_shader_create_with_lib_ex(const char *vert,
const char *geom,
const char *frag,
const char *lib,
const char *defines,
const char *name);
struct GPUShader *DRW_shader_create_with_shaderlib_ex(const char *vert,
const char *geom,
const char *frag,
const DRWShaderLibrary *lib,
const char *defines,
const char *name);
struct GPUShader *DRW_shader_create_with_transform_feedback(const char *vert,
const char *geom,
const char *defines,
eGPUShaderTFBType prim_type,
const char **varying_names,
int varying_count);
struct GPUShader *DRW_shader_create_fullscreen_ex(const char *frag,
const char *defines,
const char *name);
struct GPUShader *DRW_shader_create_fullscreen_with_shaderlib_ex(const char *frag,
const DRWShaderLibrary *lib,
const char *defines,
const char *name);
GPUShader *DRW_shader_create_with_lib_ex(const char *vert,
const char *geom,
const char *frag,
const char *lib,
const char *defines,
const char *name);
GPUShader *DRW_shader_create_with_shaderlib_ex(const char *vert,
const char *geom,
const char *frag,
const DRWShaderLibrary *lib,
const char *defines,
const char *name);
GPUShader *DRW_shader_create_with_transform_feedback(const char *vert,
const char *geom,
const char *defines,
eGPUShaderTFBType prim_type,
const char **varying_names,
int varying_count);
GPUShader *DRW_shader_create_fullscreen_ex(const char *frag,
const char *defines,
const char *name);
GPUShader *DRW_shader_create_fullscreen_with_shaderlib_ex(const char *frag,
const DRWShaderLibrary *lib,
const char *defines,
const char *name);
#define DRW_shader_create(vert, geom, frag, defines) \
DRW_shader_create_ex(vert, geom, frag, defines, __func__)
#define DRW_shader_create_with_lib(vert, geom, frag, lib, defines) \
@ -294,24 +295,24 @@ struct GPUShader *DRW_shader_create_fullscreen_with_shaderlib_ex(const char *fra
#define DRW_shader_create_fullscreen_with_shaderlib(frag, lib, defines) \
DRW_shader_create_fullscreen_with_shaderlib_ex(frag, lib, defines, __func__)
struct GPUMaterial *DRW_shader_from_world(struct World *wo,
struct bNodeTree *ntree,
eGPUMaterialEngine engine,
const uint64_t shader_id,
const bool is_volume_shader,
bool deferred,
GPUCodegenCallbackFn callback,
void *thunk);
struct GPUMaterial *DRW_shader_from_material(struct Material *ma,
struct bNodeTree *ntree,
eGPUMaterialEngine engine,
const uint64_t shader_id,
const bool is_volume_shader,
bool deferred,
GPUCodegenCallbackFn callback,
void *thunk);
void DRW_shader_queue_optimize_material(struct GPUMaterial *mat);
void DRW_shader_free(struct GPUShader *shader);
GPUMaterial *DRW_shader_from_world(World *wo,
bNodeTree *ntree,
eGPUMaterialEngine engine,
const uint64_t shader_id,
const bool is_volume_shader,
bool deferred,
GPUCodegenCallbackFn callback,
void *thunk);
GPUMaterial *DRW_shader_from_material(Material *ma,
bNodeTree *ntree,
eGPUMaterialEngine engine,
const uint64_t shader_id,
const bool is_volume_shader,
bool deferred,
GPUCodegenCallbackFn callback,
void *thunk);
void DRW_shader_queue_optimize_material(GPUMaterial *mat);
void DRW_shader_free(GPUShader *shader);
#define DRW_SHADER_FREE_SAFE(shader) \
do { \
if (shader != NULL) { \
@ -320,7 +321,7 @@ void DRW_shader_free(struct GPUShader *shader);
} \
} while (0)
DRWShaderLibrary *DRW_shader_library_create(void);
DRWShaderLibrary *DRW_shader_library_create();
/**
* \warning Each library must be added after all its dependencies.
@ -352,19 +353,19 @@ void DRW_shader_library_free(DRWShaderLibrary *lib);
/* Batches */
typedef enum {
enum eDRWAttrType {
DRW_ATTR_INT,
DRW_ATTR_FLOAT,
} eDRWAttrType;
};
typedef struct DRWInstanceAttrFormat {
struct DRWInstanceAttrFormat {
char name[32];
eDRWAttrType type;
int components;
} DRWInstanceAttrFormat;
};
struct GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttrFormat attrs[],
int arraysize);
GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttrFormat attrs[],
int arraysize);
#define DRW_shgroup_instance_format(format, ...) \
do { \
if (format == NULL) { \
@ -374,14 +375,14 @@ struct GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttrFor
} \
} while (0)
DRWShadingGroup *DRW_shgroup_create(struct GPUShader *shader, DRWPass *pass);
DRWShadingGroup *DRW_shgroup_create(GPUShader *shader, DRWPass *pass);
DRWShadingGroup *DRW_shgroup_create_sub(DRWShadingGroup *shgroup);
DRWShadingGroup *DRW_shgroup_material_create(struct GPUMaterial *material, DRWPass *pass);
DRWShadingGroup *DRW_shgroup_transform_feedback_create(struct GPUShader *shader,
DRWShadingGroup *DRW_shgroup_material_create(GPUMaterial *material, DRWPass *pass);
DRWShadingGroup *DRW_shgroup_transform_feedback_create(GPUShader *shader,
DRWPass *pass,
struct GPUVertBuf *tf_target);
GPUVertBuf *tf_target);
void DRW_shgroup_add_material_resources(DRWShadingGroup *grp, struct GPUMaterial *material);
void DRW_shgroup_add_material_resources(DRWShadingGroup *grp, GPUMaterial *material);
/**
* Return final visibility.
@ -391,7 +392,7 @@ typedef bool(DRWCallVisibilityFn)(bool vis_in, void *user_data);
void DRW_shgroup_call_ex(DRWShadingGroup *shgroup,
const Object *ob,
const float (*obmat)[4],
struct GPUBatch *geom,
GPUBatch *geom,
bool bypass_culling,
void *user_data);
@ -419,12 +420,12 @@ void DRW_shgroup_call_ex(DRWShadingGroup *shgroup,
DRW_shgroup_call_ex(shgroup, ob, NULL, geom, true, NULL)
void DRW_shgroup_call_range(
DRWShadingGroup *shgroup, const Object *ob, struct GPUBatch *geom, uint v_sta, uint v_num);
DRWShadingGroup *shgroup, const Object *ob, GPUBatch *geom, uint v_sta, uint v_num);
/**
* A count of 0 instance will use the default number of instance in the batch.
*/
void DRW_shgroup_call_instance_range(
DRWShadingGroup *shgroup, const Object *ob, struct GPUBatch *geom, uint i_sta, uint i_num);
DRWShadingGroup *shgroup, const Object *ob, GPUBatch *geom, uint i_sta, uint i_num);
void DRW_shgroup_call_compute(DRWShadingGroup *shgroup,
int groups_x_len,
@ -451,15 +452,15 @@ void DRW_shgroup_call_procedural_indirect(DRWShadingGroup *shgroup,
*/
void DRW_shgroup_call_instances(DRWShadingGroup *shgroup,
const Object *ob,
struct GPUBatch *geom,
GPUBatch *geom,
uint count);
/**
* \warning Only use with Shaders that have INSTANCED_ATTR defined.
*/
void DRW_shgroup_call_instances_with_attrs(DRWShadingGroup *shgroup,
const Object *ob,
struct GPUBatch *geom,
struct GPUBatch *inst_attributes);
GPUBatch *geom,
GPUBatch *inst_attributes);
void DRW_shgroup_call_sculpt(DRWShadingGroup *shgroup,
Object *ob,
@ -470,16 +471,16 @@ void DRW_shgroup_call_sculpt(DRWShadingGroup *shgroup,
bool use_uv);
void DRW_shgroup_call_sculpt_with_materials(DRWShadingGroup **shgroups,
struct GPUMaterial **gpumats,
GPUMaterial **gpumats,
int num_shgroups,
const Object *ob);
DRWCallBuffer *DRW_shgroup_call_buffer(DRWShadingGroup *shgroup,
struct GPUVertFormat *format,
GPUVertFormat *format,
GPUPrimType prim_type);
DRWCallBuffer *DRW_shgroup_call_buffer_instance(DRWShadingGroup *shgroup,
struct GPUVertFormat *format,
struct GPUBatch *geom);
GPUVertFormat *format,
GPUBatch *geom);
void DRW_buffer_add_entry_struct(DRWCallBuffer *callbuf, const void *data);
void DRW_buffer_add_entry_array(DRWCallBuffer *callbuf, const void *attr[], uint attr_len);
@ -536,7 +537,7 @@ void DRW_shgroup_clear_framebuffer(DRWShadingGroup *shgroup,
void DRW_shgroup_uniform_texture_ex(DRWShadingGroup *shgroup,
const char *name,
const struct GPUTexture *tex,
const GPUTexture *tex,
GPUSamplerState sampler_state);
void DRW_shgroup_uniform_texture_ref_ex(DRWShadingGroup *shgroup,
const char *name,
@ -544,22 +545,20 @@ void DRW_shgroup_uniform_texture_ref_ex(DRWShadingGroup *shgroup,
GPUSamplerState sampler_state);
void DRW_shgroup_uniform_texture(DRWShadingGroup *shgroup,
const char *name,
const struct GPUTexture *tex);
void DRW_shgroup_uniform_texture_ref(DRWShadingGroup *shgroup,
const char *name,
struct GPUTexture **tex);
const GPUTexture *tex);
void DRW_shgroup_uniform_texture_ref(DRWShadingGroup *shgroup, const char *name, GPUTexture **tex);
void DRW_shgroup_uniform_block_ex(DRWShadingGroup *shgroup,
const char *name,
const struct GPUUniformBuf *ubo DRW_DEBUG_FILE_LINE_ARGS);
const GPUUniformBuf *ubo DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_uniform_block_ref_ex(DRWShadingGroup *shgroup,
const char *name,
struct GPUUniformBuf **ubo DRW_DEBUG_FILE_LINE_ARGS);
GPUUniformBuf **ubo DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_storage_block_ex(DRWShadingGroup *shgroup,
const char *name,
const struct GPUStorageBuf *ssbo DRW_DEBUG_FILE_LINE_ARGS);
const GPUStorageBuf *ssbo DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_storage_block_ref_ex(DRWShadingGroup *shgroup,
const char *name,
struct GPUStorageBuf **ssbo DRW_DEBUG_FILE_LINE_ARGS);
GPUStorageBuf **ssbo DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_uniform_float(DRWShadingGroup *shgroup,
const char *name,
const float *value,
@ -620,16 +619,16 @@ void DRW_shgroup_uniform_mat4_copy(DRWShadingGroup *shgroup,
const float (*value)[4]);
void DRW_shgroup_vertex_buffer_ex(DRWShadingGroup *shgroup,
const char *name,
struct GPUVertBuf *vertex_buffer DRW_DEBUG_FILE_LINE_ARGS);
GPUVertBuf *vertex_buffer DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_vertex_buffer_ref_ex(DRWShadingGroup *shgroup,
const char *name,
struct GPUVertBuf **vertex_buffer DRW_DEBUG_FILE_LINE_ARGS);
GPUVertBuf **vertex_buffer DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_buffer_texture(DRWShadingGroup *shgroup,
const char *name,
struct GPUVertBuf *vertex_buffer);
GPUVertBuf *vertex_buffer);
void DRW_shgroup_buffer_texture_ref(DRWShadingGroup *shgroup,
const char *name,
struct GPUVertBuf **vertex_buffer);
GPUVertBuf **vertex_buffer);
#ifdef DRW_UNUSED_RESOURCE_TRACKING
# define DRW_shgroup_vertex_buffer(shgroup, name, vert) \
@ -725,7 +724,7 @@ void DRW_view_update_sub(DRWView *view, const float viewmat[4][4], const float w
/**
* \return default view if it is a viewport render.
*/
const DRWView *DRW_view_default_get(void);
const DRWView *DRW_view_default_get();
/**
* MUST only be called once per render and only in render mode. Sets default view.
*/
@ -733,12 +732,12 @@ void DRW_view_default_set(const DRWView *view);
/**
* \warning Only use in render AND only if you are going to set view_default again.
*/
void DRW_view_reset(void);
void DRW_view_reset();
/**
* Set active view for rendering.
*/
void DRW_view_set_active(const DRWView *view);
const DRWView *DRW_view_get_active(void);
const DRWView *DRW_view_get_active();
/**
* This only works if DRWPasses have been tagged with DRW_STATE_CLIP_PLANES,
@ -799,34 +798,29 @@ void DRW_culling_frustum_planes_get(const DRWView *view, float planes[6][4]);
/* Viewport. */
const float *DRW_viewport_size_get(void);
const float *DRW_viewport_invert_size_get(void);
const float *DRW_viewport_pixelsize_get(void);
const float *DRW_viewport_size_get();
const float *DRW_viewport_invert_size_get();
const float *DRW_viewport_pixelsize_get();
struct DefaultFramebufferList *DRW_viewport_framebuffer_list_get(void);
struct DefaultTextureList *DRW_viewport_texture_list_get(void);
DefaultFramebufferList *DRW_viewport_framebuffer_list_get();
DefaultTextureList *DRW_viewport_texture_list_get();
void DRW_viewport_request_redraw(void);
void DRW_viewport_request_redraw();
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_to_image(RenderEngine *engine, Depsgraph *depsgraph);
void DRW_render_object_iter(
void *vedata,
RenderEngine *engine,
Depsgraph *depsgraph,
void (*callback)(void *vedata, Object *ob, RenderEngine *engine, Depsgraph *depsgraph));
/**
* Must run after all instance datas have been added.
*/
void DRW_render_instance_buffer_finish(void);
void DRW_render_instance_buffer_finish();
/**
* \warning Changing frame might free the #ViewLayerEngineData.
*/
void DRW_render_set_time(struct RenderEngine *engine,
struct Depsgraph *depsgraph,
int frame,
float subframe);
void DRW_render_set_time(RenderEngine *engine, Depsgraph *depsgraph, int frame, float subframe);
/**
* \warning only use for custom pipeline. 99% of the time, you don't want to use this.
*/
@ -838,24 +832,24 @@ void DRW_render_viewport_size_set(const int size[2]);
* \warning similar to DRW_render_to_image you cannot use default lists (`dfbl` & `dtxl`).
*/
void DRW_custom_pipeline(DrawEngineType *draw_engine_type,
struct Depsgraph *depsgraph,
Depsgraph *depsgraph,
void (*callback)(void *vedata, void *user_data),
void *user_data);
/**
* Same as `DRW_custom_pipeline` but allow better code-flow than a callback.
*/
void DRW_custom_pipeline_begin(DrawEngineType *draw_engine_type, struct Depsgraph *depsgraph);
void DRW_custom_pipeline_end(void);
void DRW_custom_pipeline_begin(DrawEngineType *draw_engine_type, Depsgraph *depsgraph);
void DRW_custom_pipeline_end();
/**
* Used when the render engine want to redo another cache populate inside the same render frame.
*/
void DRW_cache_restart(void);
void DRW_cache_restart();
/* ViewLayers */
void *DRW_view_layer_engine_data_get(DrawEngineType *engine_type);
void **DRW_view_layer_engine_data_ensure_ex(struct ViewLayer *view_layer,
void **DRW_view_layer_engine_data_ensure_ex(ViewLayer *view_layer,
DrawEngineType *engine_type,
void (*callback)(void *storage));
void **DRW_view_layer_engine_data_ensure(DrawEngineType *engine_type,
@ -876,7 +870,7 @@ void **DRW_duplidata_get(void *vedata);
/* Settings. */
bool DRW_object_is_renderable(const struct Object *ob);
bool DRW_object_is_renderable(const Object *ob);
/**
* Does `ob` needs to be rendered in edit mode.
*
@ -884,19 +878,19 @@ bool DRW_object_is_renderable(const struct Object *ob);
* it is in edit mode, when another object with the same mesh is in edit mode.
* This will not be the case when one of the objects are influenced by modifiers.
*/
bool DRW_object_is_in_edit_mode(const struct Object *ob);
bool DRW_object_is_in_edit_mode(const Object *ob);
/**
* Return whether this object is visible depending if
* we are rendering or drawing in the viewport.
*/
int DRW_object_visibility_in_active_context(const struct Object *ob);
bool DRW_object_use_hide_faces(const struct Object *ob);
int DRW_object_visibility_in_active_context(const Object *ob);
bool DRW_object_use_hide_faces(const Object *ob);
bool DRW_object_is_visible_psys_in_active_context(const struct Object *object,
const struct ParticleSystem *psys);
bool DRW_object_is_visible_psys_in_active_context(const Object *object,
const ParticleSystem *psys);
struct Object *DRW_object_get_dupli_parent(const struct Object *ob);
struct DupliObject *DRW_object_get_dupli(const struct Object *ob);
Object *DRW_object_get_dupli_parent(const Object *ob);
DupliObject *DRW_object_get_dupli(const Object *ob);
/* Draw commands */
@ -906,14 +900,14 @@ void DRW_draw_pass(DRWPass *pass);
*/
void DRW_draw_pass_subset(DRWPass *pass, DRWShadingGroup *start_group, DRWShadingGroup *end_group);
void DRW_draw_callbacks_pre_scene(void);
void DRW_draw_callbacks_post_scene(void);
void DRW_draw_callbacks_pre_scene();
void DRW_draw_callbacks_post_scene();
/**
* Reset state to not interfere with other UI draw-call.
*/
void DRW_state_reset_ex(DRWState state);
void DRW_state_reset(void);
void DRW_state_reset();
/**
* Use with care, intended so selection code can override passes depth settings,
* which is important for selection to work properly.
@ -932,64 +926,64 @@ void DRW_select_load_id(uint id);
* When false, drawing doesn't output to a pixel buffer
* eg: Occlusion queries, or when we have setup a context to draw in already.
*/
bool DRW_state_is_fbo(void);
bool DRW_state_is_fbo();
/**
* For when engines need to know if this is drawing for selection or not.
*/
bool DRW_state_is_select(void);
bool DRW_state_is_material_select(void);
bool DRW_state_is_depth(void);
bool DRW_state_is_select();
bool DRW_state_is_material_select();
bool DRW_state_is_depth();
/**
* Whether we are rendering for an image
*/
bool DRW_state_is_image_render(void);
bool DRW_state_is_image_render();
/**
* Whether we are rendering only the render engine,
* or if we should also render the mode engines.
*/
bool DRW_state_is_scene_render(void);
bool DRW_state_is_scene_render();
/**
* Whether we are rendering simple opengl render
*/
bool DRW_state_is_viewport_image_render(void);
bool DRW_state_is_playback(void);
bool DRW_state_is_viewport_image_render();
bool DRW_state_is_playback();
/**
* Is the user navigating the region.
*/
bool DRW_state_is_navigating(void);
bool DRW_state_is_navigating();
/**
* Should text draw in this mode?
*/
bool DRW_state_show_text(void);
bool DRW_state_show_text();
/**
* Should draw support elements
* Objects center, selection outline, probe data, ...
*/
bool DRW_state_draw_support(void);
bool DRW_state_draw_support();
/**
* Whether we should render the background
*/
bool DRW_state_draw_background(void);
bool DRW_state_draw_background();
/* Avoid too many lookups while drawing */
typedef struct DRWContextState {
struct DRWContextState {
struct ARegion *region; /* 'CTX_wm_region(C)' */
struct RegionView3D *rv3d; /* 'CTX_wm_region_view3d(C)' */
struct View3D *v3d; /* 'CTX_wm_view3d(C)' */
struct SpaceLink *space_data; /* 'CTX_wm_space_data(C)' */
ARegion *region; /* 'CTX_wm_region(C)' */
RegionView3D *rv3d; /* 'CTX_wm_region_view3d(C)' */
View3D *v3d; /* 'CTX_wm_view3d(C)' */
SpaceLink *space_data; /* 'CTX_wm_space_data(C)' */
struct Scene *scene; /* 'CTX_data_scene(C)' */
struct ViewLayer *view_layer; /* 'CTX_data_view_layer(C)' */
Scene *scene; /* 'CTX_data_scene(C)' */
ViewLayer *view_layer; /* 'CTX_data_view_layer(C)' */
/* Use 'object_edit' for edit-mode */
struct Object *obact;
Object *obact;
struct RenderEngineType *engine_type;
RenderEngineType *engine_type;
struct Depsgraph *depsgraph;
Depsgraph *depsgraph;
struct TaskGraph *task_graph;
TaskGraph *task_graph;
eObjectMode object_mode;
@ -997,20 +991,19 @@ typedef struct DRWContextState {
/** 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;
const bContext *evil_C;
/* ---- */
/* Cache: initialized by 'drw_context_state_init'. */
struct Object *object_pose;
struct Object *object_edit;
Object *object_pose;
Object *object_edit;
};
} DRWContextState;
const DRWContextState *DRW_context_state_get();
const DRWContextState *DRW_context_state_get(void);
void DRW_mesh_batch_cache_get_attributes(struct Object *object,
struct Mesh *mesh,
void DRW_mesh_batch_cache_get_attributes(Object *object,
Mesh *mesh,
blender::draw::DRW_Attributes **r_attrs,
blender::draw::DRW_MeshCDMask **r_cd_needed);

288
source/blender/draw/intern/draw_cache.hh
View File

@ -33,210 +33,208 @@ typedef enum eDRWLevelOfDetail {
DRW_LOD_MAX, /* Max number of level of detail */
} eDRWLevelOfDetail;
void DRW_shape_cache_free(void);
void DRW_shape_cache_free();
/* 3D cursor */
struct GPUBatch *DRW_cache_cursor_get(bool crosshair_lines);
GPUBatch *DRW_cache_cursor_get(bool crosshair_lines);
/* Common Shapes */
struct GPUBatch *DRW_cache_groundline_get(void);
GPUBatch *DRW_cache_groundline_get();
/* Grid */
struct GPUBatch *DRW_cache_grid_get(void);
GPUBatch *DRW_cache_grid_get();
/**
* Use this one for rendering full-screen passes. For 3D objects use #DRW_cache_quad_get().
*/
struct GPUBatch *DRW_cache_fullscreen_quad_get(void);
GPUBatch *DRW_cache_fullscreen_quad_get();
/* Just a regular quad with 4 vertices. */
struct GPUBatch *DRW_cache_quad_get(void);
GPUBatch *DRW_cache_quad_get();
/* Just a regular quad with 4 vertices - wires. */
struct GPUBatch *DRW_cache_quad_wires_get(void);
struct GPUBatch *DRW_cache_cube_get(void);
struct GPUBatch *DRW_cache_normal_arrow_get(void);
GPUBatch *DRW_cache_quad_wires_get();
GPUBatch *DRW_cache_cube_get();
GPUBatch *DRW_cache_normal_arrow_get();
struct GPUBatch *DRW_cache_sphere_get(eDRWLevelOfDetail level_of_detail);
GPUBatch *DRW_cache_sphere_get(eDRWLevelOfDetail level_of_detail);
/* Dummy VBOs */
struct GPUBatch *DRW_gpencil_dummy_buffer_get(void);
GPUBatch *DRW_gpencil_dummy_buffer_get();
/* Common Object */
struct GPUBatch *DRW_cache_object_all_edges_get(struct Object *ob);
struct GPUBatch *DRW_cache_object_edge_detection_get(struct Object *ob, bool *r_is_manifold);
struct GPUBatch *DRW_cache_object_surface_get(struct Object *ob);
struct GPUBatch *DRW_cache_object_loose_edges_get(struct Object *ob);
struct GPUBatch **DRW_cache_object_surface_material_get(struct Object *ob,
struct GPUMaterial **gpumat_array,
uint gpumat_array_len);
struct GPUBatch *DRW_cache_object_face_wireframe_get(struct Object *ob);
int DRW_cache_object_material_count_get(const struct Object *ob);
GPUBatch *DRW_cache_object_all_edges_get(Object *ob);
GPUBatch *DRW_cache_object_edge_detection_get(Object *ob, bool *r_is_manifold);
GPUBatch *DRW_cache_object_surface_get(Object *ob);
GPUBatch *DRW_cache_object_loose_edges_get(Object *ob);
GPUBatch **DRW_cache_object_surface_material_get(Object *ob,
GPUMaterial **gpumat_array,
uint gpumat_array_len);
GPUBatch *DRW_cache_object_face_wireframe_get(Object *ob);
int DRW_cache_object_material_count_get(const Object *ob);
/**
* Returns the vertbuf used by shaded surface batch.
*/
struct GPUVertBuf *DRW_cache_object_pos_vertbuf_get(struct Object *ob);
GPUVertBuf *DRW_cache_object_pos_vertbuf_get(Object *ob);
/* Empties */
struct GPUBatch *DRW_cache_plain_axes_get(void);
struct GPUBatch *DRW_cache_single_arrow_get(void);
struct GPUBatch *DRW_cache_empty_cube_get(void);
struct GPUBatch *DRW_cache_circle_get(void);
struct GPUBatch *DRW_cache_empty_sphere_get(void);
struct GPUBatch *DRW_cache_empty_cylinder_get(void);
struct GPUBatch *DRW_cache_empty_cone_get(void);
struct GPUBatch *DRW_cache_empty_capsule_cap_get(void);
struct GPUBatch *DRW_cache_empty_capsule_body_get(void);
GPUBatch *DRW_cache_plain_axes_get();
GPUBatch *DRW_cache_single_arrow_get();
GPUBatch *DRW_cache_empty_cube_get();
GPUBatch *DRW_cache_circle_get();
GPUBatch *DRW_cache_empty_sphere_get();
GPUBatch *DRW_cache_empty_cylinder_get();
GPUBatch *DRW_cache_empty_cone_get();
GPUBatch *DRW_cache_empty_capsule_cap_get();
GPUBatch *DRW_cache_empty_capsule_body_get();
/* Force Field */
struct GPUBatch *DRW_cache_field_wind_get(void);
struct GPUBatch *DRW_cache_field_force_get(void);
struct GPUBatch *DRW_cache_field_vortex_get(void);
GPUBatch *DRW_cache_field_wind_get();
GPUBatch *DRW_cache_field_force_get();
GPUBatch *DRW_cache_field_vortex_get();
/* Screen-aligned circle. */
struct GPUBatch *DRW_cache_field_curve_get(void);
struct GPUBatch *DRW_cache_field_tube_limit_get(void);
struct GPUBatch *DRW_cache_field_cone_limit_get(void);
GPUBatch *DRW_cache_field_curve_get();
GPUBatch *DRW_cache_field_tube_limit_get();
GPUBatch *DRW_cache_field_cone_limit_get();
/* Screen-aligned dashed circle */
struct GPUBatch *DRW_cache_field_sphere_limit_get(void);
GPUBatch *DRW_cache_field_sphere_limit_get();
/* Lights */
struct GPUBatch *DRW_cache_light_icon_inner_lines_get(void);
struct GPUBatch *DRW_cache_light_icon_outer_lines_get(void);
struct GPUBatch *DRW_cache_light_icon_sun_rays_get(void);
struct GPUBatch *DRW_cache_light_point_lines_get(void);
struct GPUBatch *DRW_cache_light_sun_lines_get(void);
struct GPUBatch *DRW_cache_light_spot_lines_get(void);
struct GPUBatch *DRW_cache_light_area_disk_lines_get(void);
struct GPUBatch *DRW_cache_light_area_square_lines_get(void);
struct GPUBatch *DRW_cache_light_spot_volume_get(void);
GPUBatch *DRW_cache_light_icon_inner_lines_get();
GPUBatch *DRW_cache_light_icon_outer_lines_get();
GPUBatch *DRW_cache_light_icon_sun_rays_get();
GPUBatch *DRW_cache_light_point_lines_get();
GPUBatch *DRW_cache_light_sun_lines_get();
GPUBatch *DRW_cache_light_spot_lines_get();
GPUBatch *DRW_cache_light_area_disk_lines_get();
GPUBatch *DRW_cache_light_area_square_lines_get();
GPUBatch *DRW_cache_light_spot_volume_get();
/* Camera */
struct GPUBatch *DRW_cache_camera_frame_get(void);
struct GPUBatch *DRW_cache_camera_volume_get(void);
struct GPUBatch *DRW_cache_camera_volume_wire_get(void);
struct GPUBatch *DRW_cache_camera_tria_wire_get(void);
struct GPUBatch *DRW_cache_camera_tria_get(void);
struct GPUBatch *DRW_cache_camera_distances_get(void);
GPUBatch *DRW_cache_camera_frame_get();
GPUBatch *DRW_cache_camera_volume_get();
GPUBatch *DRW_cache_camera_volume_wire_get();
GPUBatch *DRW_cache_camera_tria_wire_get();
GPUBatch *DRW_cache_camera_tria_get();
GPUBatch *DRW_cache_camera_distances_get();
/* Speaker */
struct GPUBatch *DRW_cache_speaker_get(void);
GPUBatch *DRW_cache_speaker_get();
/* Probe */
struct GPUBatch *DRW_cache_lightprobe_cube_get(void);
struct GPUBatch *DRW_cache_lightprobe_grid_get(void);
struct GPUBatch *DRW_cache_lightprobe_planar_get(void);
GPUBatch *DRW_cache_lightprobe_cube_get();
GPUBatch *DRW_cache_lightprobe_grid_get();
GPUBatch *DRW_cache_lightprobe_planar_get();
/* Bones */
struct GPUBatch *DRW_cache_bone_octahedral_get(void);
struct GPUBatch *DRW_cache_bone_octahedral_wire_get(void);
struct GPUBatch *DRW_cache_bone_box_get(void);
struct GPUBatch *DRW_cache_bone_box_wire_get(void);
struct GPUBatch *DRW_cache_bone_envelope_solid_get(void);
struct GPUBatch *DRW_cache_bone_envelope_outline_get(void);
struct GPUBatch *DRW_cache_bone_point_get(void);
struct GPUBatch *DRW_cache_bone_point_wire_outline_get(void);
struct GPUBatch *DRW_cache_bone_stick_get(void);
struct GPUBatch *DRW_cache_bone_arrows_get(void);
struct GPUBatch *DRW_cache_bone_dof_sphere_get(void);
struct GPUBatch *DRW_cache_bone_dof_lines_get(void);
GPUBatch *DRW_cache_bone_octahedral_get();
GPUBatch *DRW_cache_bone_octahedral_wire_get();
GPUBatch *DRW_cache_bone_box_get();
GPUBatch *DRW_cache_bone_box_wire_get();
GPUBatch *DRW_cache_bone_envelope_solid_get();
GPUBatch *DRW_cache_bone_envelope_outline_get();
GPUBatch *DRW_cache_bone_point_get();
GPUBatch *DRW_cache_bone_point_wire_outline_get();
GPUBatch *DRW_cache_bone_stick_get();
GPUBatch *DRW_cache_bone_arrows_get();
GPUBatch *DRW_cache_bone_dof_sphere_get();
GPUBatch *DRW_cache_bone_dof_lines_get();
/* Meshes */
struct GPUBatch *DRW_cache_mesh_all_verts_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_all_edges_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_loose_edges_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_edge_detection_get(struct Object *ob, bool *r_is_manifold);
struct GPUBatch *DRW_cache_mesh_surface_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_edges_get(struct Object *ob);
GPUBatch *DRW_cache_mesh_all_verts_get(Object *ob);
GPUBatch *DRW_cache_mesh_all_edges_get(Object *ob);
GPUBatch *DRW_cache_mesh_loose_edges_get(Object *ob);
GPUBatch *DRW_cache_mesh_edge_detection_get(Object *ob, bool *r_is_manifold);
GPUBatch *DRW_cache_mesh_surface_get(Object *ob);
GPUBatch *DRW_cache_mesh_surface_edges_get(Object *ob);
/**
* Return list of batches with length equal to `max(1, totcol)`.
*/
struct GPUBatch **DRW_cache_mesh_surface_shaded_get(struct Object *ob,
struct GPUMaterial **gpumat_array,
uint gpumat_array_len);
GPUBatch **DRW_cache_mesh_surface_shaded_get(Object *ob,
GPUMaterial **gpumat_array,
uint gpumat_array_len);
/**
* Return list of batches with length equal to `max(1, totcol)`.
*/
struct GPUBatch **DRW_cache_mesh_surface_texpaint_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_texpaint_single_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_vertpaint_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_sculptcolors_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_weights_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_mesh_analysis_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_face_wireframe_get(struct Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_viewer_attribute_get(struct Object *ob);
GPUBatch **DRW_cache_mesh_surface_texpaint_get(Object *ob);
GPUBatch *DRW_cache_mesh_surface_texpaint_single_get(Object *ob);
GPUBatch *DRW_cache_mesh_surface_vertpaint_get(Object *ob);
GPUBatch *DRW_cache_mesh_surface_sculptcolors_get(Object *ob);
GPUBatch *DRW_cache_mesh_surface_weights_get(Object *ob);
GPUBatch *DRW_cache_mesh_surface_mesh_analysis_get(Object *ob);
GPUBatch *DRW_cache_mesh_face_wireframe_get(Object *ob);
GPUBatch *DRW_cache_mesh_surface_viewer_attribute_get(Object *ob);
/* Curve */
struct GPUBatch *DRW_cache_curve_edge_wire_get(struct Object *ob);
struct GPUBatch *DRW_cache_curve_edge_wire_viewer_attribute_get(struct Object *ob);
GPUBatch *DRW_cache_curve_edge_wire_get(Object *ob);
GPUBatch *DRW_cache_curve_edge_wire_viewer_attribute_get(Object *ob);
/* edit-mode */
struct GPUBatch *DRW_cache_curve_edge_normal_get(struct Object *ob);
struct GPUBatch *DRW_cache_curve_edge_overlay_get(struct Object *ob);
struct GPUBatch *DRW_cache_curve_vert_overlay_get(struct Object *ob);
GPUBatch *DRW_cache_curve_edge_normal_get(Object *ob);
GPUBatch *DRW_cache_curve_edge_overlay_get(Object *ob);
GPUBatch *DRW_cache_curve_vert_overlay_get(Object *ob);
/* Font */
struct GPUBatch *DRW_cache_text_edge_wire_get(struct Object *ob);
GPUBatch *DRW_cache_text_edge_wire_get(Object *ob);
/* Surface */
struct GPUBatch *DRW_cache_surf_edge_wire_get(struct Object *ob);
GPUBatch *DRW_cache_surf_edge_wire_get(Object *ob);
/* Lattice */
struct GPUBatch *DRW_cache_lattice_verts_get(struct Object *ob);
struct GPUBatch *DRW_cache_lattice_wire_get(struct Object *ob, bool use_weight);
struct GPUBatch *DRW_cache_lattice_vert_overlay_get(struct Object *ob);
GPUBatch *DRW_cache_lattice_verts_get(Object *ob);
GPUBatch *DRW_cache_lattice_wire_get(Object *ob, bool use_weight);
GPUBatch *DRW_cache_lattice_vert_overlay_get(Object *ob);
/* Particles */
struct GPUBatch *DRW_cache_particles_get_hair(struct Object *object,
struct ParticleSystem *psys,
struct ModifierData *md);
struct GPUBatch *DRW_cache_particles_get_dots(struct Object *object, struct ParticleSystem *psys);
struct GPUBatch *DRW_cache_particles_get_edit_strands(struct Object *object,
struct ParticleSystem *psys,
struct PTCacheEdit *edit,
bool use_weight);
struct GPUBatch *DRW_cache_particles_get_edit_inner_points(struct Object *object,
struct ParticleSystem *psys,
struct PTCacheEdit *edit);
struct GPUBatch *DRW_cache_particles_get_edit_tip_points(struct Object *object,
struct ParticleSystem *psys,
struct PTCacheEdit *edit);
struct GPUBatch *DRW_cache_particles_get_prim(int type);
GPUBatch *DRW_cache_particles_get_hair(Object *object, ParticleSystem *psys, ModifierData *md);
GPUBatch *DRW_cache_particles_get_dots(Object *object, ParticleSystem *psys);
GPUBatch *DRW_cache_particles_get_edit_strands(Object *object,
ParticleSystem *psys,
PTCacheEdit *edit,
bool use_weight);
GPUBatch *DRW_cache_particles_get_edit_inner_points(Object *object,
ParticleSystem *psys,
PTCacheEdit *edit);
GPUBatch *DRW_cache_particles_get_edit_tip_points(Object *object,
ParticleSystem *psys,
PTCacheEdit *edit);
GPUBatch *DRW_cache_particles_get_prim(int type);
/* Curves */
struct GPUBatch *DRW_cache_curves_surface_get(struct Object *ob);
struct GPUBatch **DRW_cache_curves_surface_shaded_get(struct Object *ob,
struct GPUMaterial **gpumat_array,
uint gpumat_array_len);
struct GPUBatch *DRW_cache_curves_face_wireframe_get(struct Object *ob);
struct GPUBatch *DRW_cache_curves_edge_detection_get(struct Object *ob, bool *r_is_manifold);
GPUBatch *DRW_cache_curves_surface_get(Object *ob);
GPUBatch **DRW_cache_curves_surface_shaded_get(Object *ob,
GPUMaterial **gpumat_array,
uint gpumat_array_len);
GPUBatch *DRW_cache_curves_face_wireframe_get(Object *ob);
GPUBatch *DRW_cache_curves_edge_detection_get(Object *ob, bool *r_is_manifold);
/* Volume */
typedef struct DRWVolumeGrid {
struct DRWVolumeGrid *next, *prev;
struct DRWVolumeGrid {
DRWVolumeGrid *next, *prev;
/* Grid name. */
char *name;
/* 3D texture. */
struct GPUTexture *texture;
GPUTexture *texture;
/* Transform between 0..1 texture space and object space. */
float texture_to_object[4][4];
@ -245,47 +243,41 @@ typedef struct DRWVolumeGrid {
/* Transform from bounds to texture space. */
float object_to_bounds[4][4];
float bounds_to_texture[4][4];
} DRWVolumeGrid;
};
namespace blender::draw {
DRWVolumeGrid *DRW_volume_batch_cache_get_grid(struct Volume *volume,
const bke::VolumeGridData *grid);
struct GPUBatch *DRW_cache_volume_face_wireframe_get(struct Object *ob);
struct GPUBatch *DRW_cache_volume_selection_surface_get(struct Object *ob);
DRWVolumeGrid *DRW_volume_batch_cache_get_grid(Volume *volume, const bke::VolumeGridData *grid);
GPUBatch *DRW_cache_volume_face_wireframe_get(Object *ob);
GPUBatch *DRW_cache_volume_selection_surface_get(Object *ob);
/* GPencil (legacy) */
struct GPUBatch *DRW_cache_gpencil_get(struct Object *ob, int cfra);
struct GPUVertBuf *DRW_cache_gpencil_position_buffer_get(struct Object *ob, int cfra);
struct GPUVertBuf *DRW_cache_gpencil_color_buffer_get(struct Object *ob, int cfra);
struct GPUBatch *DRW_cache_gpencil_edit_lines_get(struct Object *ob, int cfra);
struct GPUBatch *DRW_cache_gpencil_edit_points_get(struct Object *ob, int cfra);
struct GPUBatch *DRW_cache_gpencil_edit_curve_handles_get(struct Object *ob, int cfra);
struct GPUBatch *DRW_cache_gpencil_edit_curve_points_get(struct Object *ob, int cfra);
struct GPUBatch *DRW_cache_gpencil_sbuffer_get(struct Object *ob, bool show_fill);
struct GPUVertBuf *DRW_cache_gpencil_sbuffer_position_buffer_get(struct Object *ob,
bool show_fill);
struct GPUVertBuf *DRW_cache_gpencil_sbuffer_color_buffer_get(struct Object *ob, bool show_fill);
int DRW_gpencil_material_count_get(const struct bGPdata *gpd);
GPUBatch *DRW_cache_gpencil_get(Object *ob, int cfra);
GPUVertBuf *DRW_cache_gpencil_position_buffer_get(Object *ob, int cfra);
GPUVertBuf *DRW_cache_gpencil_color_buffer_get(Object *ob, int cfra);
GPUBatch *DRW_cache_gpencil_edit_lines_get(Object *ob, int cfra);
GPUBatch *DRW_cache_gpencil_edit_points_get(Object *ob, int cfra);
GPUBatch *DRW_cache_gpencil_edit_curve_handles_get(Object *ob, int cfra);
GPUBatch *DRW_cache_gpencil_edit_curve_points_get(Object *ob, int cfra);
GPUBatch *DRW_cache_gpencil_sbuffer_get(Object *ob, bool show_fill);
GPUVertBuf *DRW_cache_gpencil_sbuffer_position_buffer_get(Object *ob, bool show_fill);
GPUVertBuf *DRW_cache_gpencil_sbuffer_color_buffer_get(Object *ob, bool show_fill);
int DRW_gpencil_material_count_get(const bGPdata *gpd);
struct GPUBatch *DRW_cache_gpencil_face_wireframe_get(struct Object *ob);
GPUBatch *DRW_cache_gpencil_face_wireframe_get(Object *ob);
struct bGPDstroke *DRW_cache_gpencil_sbuffer_stroke_data_get(struct Object *ob);
bGPDstroke *DRW_cache_gpencil_sbuffer_stroke_data_get(Object *ob);
/**
* Sbuffer batches are temporary. We need to clear it after drawing.
*/
void DRW_cache_gpencil_sbuffer_clear(struct Object *ob);
void DRW_cache_gpencil_sbuffer_clear(Object *ob);
/* Grease Pencil */
struct GPUBatch *DRW_cache_grease_pencil_get(const struct Scene *scene, struct Object *ob);
struct GPUBatch *DRW_cache_grease_pencil_edit_points_get(const struct Scene *scene,
struct Object *ob);
struct GPUBatch *DRW_cache_grease_pencil_edit_lines_get(const struct Scene *scene,
struct Object *ob);
struct GPUVertBuf *DRW_cache_grease_pencil_position_buffer_get(const struct Scene *scene,
struct Object *ob);
struct GPUVertBuf *DRW_cache_grease_pencil_color_buffer_get(const struct Scene *scene,
struct Object *ob);
GPUBatch *DRW_cache_grease_pencil_get(const Scene *scene, Object *ob);
GPUBatch *DRW_cache_grease_pencil_edit_points_get(const Scene *scene, Object *ob);
GPUBatch *DRW_cache_grease_pencil_edit_lines_get(const Scene *scene, Object *ob);
GPUVertBuf *DRW_cache_grease_pencil_position_buffer_get(const Scene *scene, Object *ob);
GPUVertBuf *DRW_cache_grease_pencil_color_buffer_get(const Scene *scene, Object *ob);
} // namespace blender::draw

4
source/blender/draw/intern/draw_subdivision.hh
View File

@ -31,8 +31,8 @@ struct MeshRenderData;
* \{ */
struct DRWPatchMap {
struct GPUVertBuf *patch_map_handles;
struct GPUVertBuf *patch_map_quadtree;
GPUVertBuf *patch_map_handles;
GPUVertBuf *patch_map_quadtree;
int min_patch_face;
int max_patch_face;
int max_depth;

293
source/blender/editors/armature/armature_intern.hh
View File

@ -8,76 +8,72 @@
#pragma once
/* internal exports only */
struct wmOperatorType;
struct Base;
struct GPUSelectResult;
struct Object;
struct Scene;
struct bContext;
struct bPoseChannel;
struct Bone;
struct EditBone;
struct bArmature;
struct Base;
struct bContext;
struct Bone;
struct bPoseChannel;
struct EditBone;
struct GPUSelectResult;
struct LinkData;
struct ListBase;
struct Object;
struct Scene;
struct wmOperatorType;
/* -------------------------------------------------------------------- */
/** \name Armature EditMode Operators
* \{ */
void ARMATURE_OT_bone_primitive_add(struct wmOperatorType *ot);
void ARMATURE_OT_bone_primitive_add(wmOperatorType *ot);
void ARMATURE_OT_align(struct wmOperatorType *ot);
void ARMATURE_OT_calculate_roll(struct wmOperatorType *ot);
void ARMATURE_OT_roll_clear(struct wmOperatorType *ot);
void ARMATURE_OT_switch_direction(struct wmOperatorType *ot);
void ARMATURE_OT_align(wmOperatorType *ot);
void ARMATURE_OT_calculate_roll(wmOperatorType *ot);
void ARMATURE_OT_roll_clear(wmOperatorType *ot);
void ARMATURE_OT_switch_direction(wmOperatorType *ot);
void ARMATURE_OT_subdivide(struct wmOperatorType *ot);
void ARMATURE_OT_subdivide(wmOperatorType *ot);
void ARMATURE_OT_parent_set(struct wmOperatorType *ot);
void ARMATURE_OT_parent_clear(struct wmOperatorType *ot);
void ARMATURE_OT_parent_set(wmOperatorType *ot);
void ARMATURE_OT_parent_clear(wmOperatorType *ot);
void ARMATURE_OT_select_all(struct wmOperatorType *ot);
void ARMATURE_OT_select_mirror(struct wmOperatorType *ot);
void ARMATURE_OT_select_more(struct wmOperatorType *ot);
void ARMATURE_OT_select_less(struct wmOperatorType *ot);
void ARMATURE_OT_select_hierarchy(struct wmOperatorType *ot);
void ARMATURE_OT_select_linked_pick(struct wmOperatorType *ot);
void ARMATURE_OT_select_linked(struct wmOperatorType *ot);
void ARMATURE_OT_select_similar(struct wmOperatorType *ot);
void ARMATURE_OT_shortest_path_pick(struct wmOperatorType *ot);
void ARMATURE_OT_select_all(wmOperatorType *ot);
void ARMATURE_OT_select_mirror(wmOperatorType *ot);
void ARMATURE_OT_select_more(wmOperatorType *ot);
void ARMATURE_OT_select_less(wmOperatorType *ot);
void ARMATURE_OT_select_hierarchy(wmOperatorType *ot);
void ARMATURE_OT_select_linked_pick(wmOperatorType *ot);
void ARMATURE_OT_select_linked(wmOperatorType *ot);
void ARMATURE_OT_select_similar(wmOperatorType *ot);
void ARMATURE_OT_shortest_path_pick(wmOperatorType *ot);
void ARMATURE_OT_delete(struct wmOperatorType *ot);
void ARMATURE_OT_dissolve(struct wmOperatorType *ot);
void ARMATURE_OT_duplicate(struct wmOperatorType *ot);
void ARMATURE_OT_symmetrize(struct wmOperatorType *ot);
void ARMATURE_OT_extrude(struct wmOperatorType *ot);
void ARMATURE_OT_hide(struct wmOperatorType *ot);
void ARMATURE_OT_reveal(struct wmOperatorType *ot);
void ARMATURE_OT_click_extrude(struct wmOperatorType *ot);
void ARMATURE_OT_fill(struct wmOperatorType *ot);
void ARMATURE_OT_separate(struct wmOperatorType *ot);
void ARMATURE_OT_split(struct wmOperatorType *ot);
void ARMATURE_OT_delete(wmOperatorType *ot);
void ARMATURE_OT_dissolve(wmOperatorType *ot);
void ARMATURE_OT_duplicate(wmOperatorType *ot);
void ARMATURE_OT_symmetrize(wmOperatorType *ot);
void ARMATURE_OT_extrude(wmOperatorType *ot);
void ARMATURE_OT_hide(wmOperatorType *ot);
void ARMATURE_OT_reveal(wmOperatorType *ot);
void ARMATURE_OT_click_extrude(wmOperatorType *ot);
void ARMATURE_OT_fill(wmOperatorType *ot);
void ARMATURE_OT_separate(wmOperatorType *ot);
void ARMATURE_OT_split(wmOperatorType *ot);
void ARMATURE_OT_autoside_names(struct wmOperatorType *ot);
void ARMATURE_OT_flip_names(struct wmOperatorType *ot);
void ARMATURE_OT_autoside_names(wmOperatorType *ot);
void ARMATURE_OT_flip_names(wmOperatorType *ot);
void ARMATURE_OT_collection_add(struct wmOperatorType *ot);
void ARMATURE_OT_collection_remove(struct wmOperatorType *ot);
void ARMATURE_OT_collection_move(struct wmOperatorType *ot);
void ARMATURE_OT_collection_assign(struct wmOperatorType *ot);
void ARMATURE_OT_collection_create_and_assign(struct wmOperatorType *ot);
void ARMATURE_OT_collection_unassign(struct wmOperatorType *ot);
void ARMATURE_OT_collection_unassign_named(struct wmOperatorType *ot);
void ARMATURE_OT_collection_select(struct wmOperatorType *ot);
void ARMATURE_OT_collection_deselect(struct wmOperatorType *ot);
void ARMATURE_OT_collection_add(wmOperatorType *ot);
void ARMATURE_OT_collection_remove(wmOperatorType *ot);
void ARMATURE_OT_collection_move(wmOperatorType *ot);
void ARMATURE_OT_collection_assign(wmOperatorType *ot);
void ARMATURE_OT_collection_create_and_assign(wmOperatorType *ot);
void ARMATURE_OT_collection_unassign(wmOperatorType *ot);
void ARMATURE_OT_collection_unassign_named(wmOperatorType *ot);
void ARMATURE_OT_collection_select(wmOperatorType *ot);
void ARMATURE_OT_collection_deselect(wmOperatorType *ot);
void ARMATURE_OT_move_to_collection(struct wmOperatorType *ot);
void ARMATURE_OT_assign_to_collection(struct wmOperatorType *ot);
void ARMATURE_OT_move_to_collection(wmOperatorType *ot);
void ARMATURE_OT_assign_to_collection(wmOperatorType *ot);
/** \} */
@ -85,41 +81,41 @@ void ARMATURE_OT_assign_to_collection(struct wmOperatorType *ot);
/** \name Pose-Mode Operators
* \{ */
void POSE_OT_hide(struct wmOperatorType *ot);
void POSE_OT_reveal(struct wmOperatorType *ot);
void POSE_OT_hide(wmOperatorType *ot);
void POSE_OT_reveal(wmOperatorType *ot);
void POSE_OT_armature_apply(struct wmOperatorType *ot);
void POSE_OT_visual_transform_apply(struct wmOperatorType *ot);
void POSE_OT_armature_apply(wmOperatorType *ot);
void POSE_OT_visual_transform_apply(wmOperatorType *ot);
void POSE_OT_rot_clear(struct wmOperatorType *ot);
void POSE_OT_loc_clear(struct wmOperatorType *ot);
void POSE_OT_scale_clear(struct wmOperatorType *ot);
void POSE_OT_transforms_clear(struct wmOperatorType *ot);
void POSE_OT_user_transforms_clear(struct wmOperatorType *ot);
void POSE_OT_rot_clear(wmOperatorType *ot);
void POSE_OT_loc_clear(wmOperatorType *ot);
void POSE_OT_scale_clear(wmOperatorType *ot);
void POSE_OT_transforms_clear(wmOperatorType *ot);
void POSE_OT_user_transforms_clear(wmOperatorType *ot);
void POSE_OT_copy(struct wmOperatorType *ot);
void POSE_OT_paste(struct wmOperatorType *ot);
void POSE_OT_copy(wmOperatorType *ot);
void POSE_OT_paste(wmOperatorType *ot);
void POSE_OT_select_all(struct wmOperatorType *ot);
void POSE_OT_select_parent(struct wmOperatorType *ot);
void POSE_OT_select_hierarchy(struct wmOperatorType *ot);
void POSE_OT_select_linked(struct wmOperatorType *ot);
void POSE_OT_select_linked_pick(struct wmOperatorType *ot);
void POSE_OT_select_constraint_target(struct wmOperatorType *ot);
void POSE_OT_select_grouped(struct wmOperatorType *ot);
void POSE_OT_select_mirror(struct wmOperatorType *ot);
void POSE_OT_select_all(wmOperatorType *ot);
void POSE_OT_select_parent(wmOperatorType *ot);
void POSE_OT_select_hierarchy(wmOperatorType *ot);
void POSE_OT_select_linked(wmOperatorType *ot);
void POSE_OT_select_linked_pick(wmOperatorType *ot);
void POSE_OT_select_constraint_target(wmOperatorType *ot);
void POSE_OT_select_grouped(wmOperatorType *ot);
void POSE_OT_select_mirror(wmOperatorType *ot);
void POSE_OT_paths_calculate(struct wmOperatorType *ot);
void POSE_OT_paths_update(struct wmOperatorType *ot);
void POSE_OT_paths_clear(struct wmOperatorType *ot);
void POSE_OT_paths_range_update(struct wmOperatorType *ot);
void POSE_OT_paths_calculate(wmOperatorType *ot);
void POSE_OT_paths_update(wmOperatorType *ot);
void POSE_OT_paths_clear(wmOperatorType *ot);
void POSE_OT_paths_range_update(wmOperatorType *ot);
void POSE_OT_autoside_names(struct wmOperatorType *ot);
void POSE_OT_flip_names(struct wmOperatorType *ot);
void POSE_OT_autoside_names(wmOperatorType *ot);
void POSE_OT_flip_names(wmOperatorType *ot);
void POSE_OT_rotation_mode_set(struct wmOperatorType *ot);
void POSE_OT_rotation_mode_set(wmOperatorType *ot);
void POSE_OT_quaternions_flip(struct wmOperatorType *ot);
void POSE_OT_quaternions_flip(wmOperatorType *ot);
/** \} */
@ -130,16 +126,16 @@ void POSE_OT_quaternions_flip(struct wmOperatorType *ot);
/* `pose_utils.cc` */
/* Temporary data linking PoseChannels with the F-Curves they affect */
typedef struct tPChanFCurveLink {
struct tPChanFCurveLink *next, *prev;
struct tPChanFCurveLink {
tPChanFCurveLink *next, *prev;
/** Object this Pose Channel belongs to. */
struct Object *ob;
Object *ob;
/** F-Curves for this PoseChannel (wrapped with LinkData) */
ListBase fcurves;
/** Pose Channel which data is attached to */
struct bPoseChannel *pchan;
bPoseChannel *pchan;
/** RNA Path to this Pose Channel (needs to be freed when we're done) */
char *pchan_path;
@ -162,31 +158,28 @@ typedef struct tPChanFCurveLink {
float scale_out[3];
/** copy of custom properties at start of operator (to be restored before each modal step) */
struct IDProperty *oldprops;
} tPChanFCurveLink;
IDProperty *oldprops;
};
/* ----------- */
/** Returns a valid pose armature for this object, else returns NULL. */
struct Object *poseAnim_object_get(struct Object *ob_);
Object *poseAnim_object_get(Object *ob_);
/** Get sets of F-Curves providing transforms for the bones in the Pose. */
void poseAnim_mapping_get(struct bContext *C, ListBase *pfLinks);
void poseAnim_mapping_get(bContext *C, ListBase *pfLinks);
/** Free F-Curve <-> PoseChannel links. */
void poseAnim_mapping_free(ListBase *pfLinks);
/**
* Helper for apply() / reset() - refresh the data.
*/
void poseAnim_mapping_refresh(struct bContext *C, struct Scene *scene, struct Object *ob);
void poseAnim_mapping_refresh(bContext *C, Scene *scene, Object *ob);
/**
* Reset changes made to current pose.
*/
void poseAnim_mapping_reset(ListBase *pfLinks);
/** Perform auto-key-framing after changes were made + confirmed. */
void poseAnim_mapping_autoKeyframe(struct bContext *C,
struct Scene *scene,
ListBase *pfLinks,
float cframe);
void poseAnim_mapping_autoKeyframe(bContext *C, Scene *scene, ListBase *pfLinks, float cframe);
/**
* Find the next F-Curve for a PoseChannel with matching path.
@ -203,8 +196,8 @@ LinkData *poseAnim_mapping_getNextFCurve(ListBase *fcuLinks, LinkData *prev, con
/* `pose_lib_2.cc` */
void POSELIB_OT_apply_pose_asset(struct wmOperatorType *ot);
void POSELIB_OT_blend_pose_asset(struct wmOperatorType *ot);
void POSELIB_OT_apply_pose_asset(wmOperatorType *ot);
void POSELIB_OT_blend_pose_asset(wmOperatorType *ot);
/** \} */
@ -214,13 +207,13 @@ void POSELIB_OT_blend_pose_asset(struct wmOperatorType *ot);
/* `pose_slide.cc` */
void POSE_OT_push(struct wmOperatorType *ot);
void POSE_OT_relax(struct wmOperatorType *ot);
void POSE_OT_blend_with_rest(struct wmOperatorType *ot);
void POSE_OT_breakdown(struct wmOperatorType *ot);
void POSE_OT_blend_to_neighbors(struct wmOperatorType *ot);
void POSE_OT_push(wmOperatorType *ot);
void POSE_OT_relax(wmOperatorType *ot);
void POSE_OT_blend_with_rest(wmOperatorType *ot);
void POSE_OT_breakdown(wmOperatorType *ot);
void POSE_OT_blend_to_neighbors(wmOperatorType *ot);
void POSE_OT_propagate(struct wmOperatorType *ot);
void POSE_OT_propagate(wmOperatorType *ot);
/** \} */
@ -233,44 +226,36 @@ void POSE_OT_propagate(struct wmOperatorType *ot);
* but some tools still have a bit of overlap which makes things messy -- Feb 2013
*/
struct EditBone *make_boneList(struct ListBase *edbo,
struct ListBase *bones,
struct Bone *actBone);
EditBone *make_boneList(ListBase *edbo, ListBase *bones, Bone *actBone);
/* Duplicate method. */
/** Call this before doing any duplications. */
void preEditBoneDuplicate(struct ListBase *editbones);
void postEditBoneDuplicate(struct ListBase *editbones, struct Object *ob);
struct EditBone *duplicateEditBone(struct EditBone *cur_bone,
const char *name,
struct ListBase *editbones,
struct Object *ob);
void preEditBoneDuplicate(ListBase *editbones);
void postEditBoneDuplicate(ListBase *editbones, Object *ob);
EditBone *duplicateEditBone(EditBone *cur_bone, const char *name, ListBase *editbones, Object *ob);
/* Duplicate method (cross objects). */
/**
* \param editbones: The target list.
*/
struct EditBone *duplicateEditBoneObjects(struct EditBone *cur_bone,
const char *name,
struct ListBase *editbones,
struct Object *src_ob,
struct Object *dst_ob);
EditBone *duplicateEditBoneObjects(
EditBone *cur_bone, const char *name, ListBase *editbones, Object *src_ob, Object *dst_ob);
/** Adds an EditBone between the nominated locations (should be in the right space). */
struct EditBone *add_points_bone(struct Object *obedit, float head[3], float tail[3]);
void bone_free(struct bArmature *arm, struct EditBone *bone);
EditBone *add_points_bone(Object *obedit, float head[3], float tail[3]);
void bone_free(bArmature *arm, EditBone *bone);
void armature_tag_select_mirrored(struct bArmature *arm);
void armature_tag_select_mirrored(bArmature *arm);
/**
* Helper function for tools to work on mirrored parts.
* it leaves mirrored bones selected then too, which is a good indication of what happened.
*/
void armature_select_mirrored_ex(struct bArmature *arm, int flag);
void armature_select_mirrored(struct bArmature *arm);
void armature_select_mirrored_ex(bArmature *arm, int flag);
void armature_select_mirrored(bArmature *arm);
/** Only works when tagged. */
void armature_tag_unselect(struct bArmature *arm);
void armature_tag_unselect(bArmature *arm);
/** \} */
@ -278,42 +263,31 @@ void armature_tag_unselect(struct bArmature *arm);
/** \name Selection Picking
* \{ */
struct EditBone *ED_armature_pick_ebone(struct bContext *C,
const int xy[2],
bool findunsel,
struct Base **r_base);
struct bPoseChannel *ED_armature_pick_pchan(struct bContext *C,
const int xy[2],
bool findunsel,
struct Base **r_base);
struct Bone *ED_armature_pick_bone(struct bContext *C,
const int xy[2],
bool findunsel,
struct Base **r_base);
EditBone *ED_armature_pick_ebone(bContext *C, const int xy[2], bool findunsel, Base **r_base);
bPoseChannel *ED_armature_pick_pchan(bContext *C, const int xy[2], bool findunsel, Base **r_base);
Bone *ED_armature_pick_bone(bContext *C, const int xy[2], bool findunsel, Base **r_base);
struct EditBone *ED_armature_pick_ebone_from_selectbuffer(
struct Base **bases,
uint bases_len,
const struct GPUSelectResult *hit_results,
int hits,
bool findunsel,
bool do_nearest,
struct Base **r_base);
struct bPoseChannel *ED_armature_pick_pchan_from_selectbuffer(
struct Base **bases,
uint bases_len,
const struct GPUSelectResult *hit_results,
int hits,
bool findunsel,
bool do_nearest,
struct Base **r_base);
struct Bone *ED_armature_pick_bone_from_selectbuffer(struct Base **bases,
uint bases_len,
const struct GPUSelectResult *hit_results,
int hits,
bool findunsel,
bool do_nearest,
struct Base **r_base);
EditBone *ED_armature_pick_ebone_from_selectbuffer(Base **bases,
uint bases_len,
const GPUSelectResult *hit_results,
int hits,
bool findunsel,
bool do_nearest,
Base **r_base);
bPoseChannel *ED_armature_pick_pchan_from_selectbuffer(Base **bases,
uint bases_len,
const GPUSelectResult *hit_results,
int hits,
bool findunsel,
bool do_nearest,
Base **r_base);
Bone *ED_armature_pick_bone_from_selectbuffer(Base **bases,
uint bases_len,
const GPUSelectResult *hit_results,
int hits,
bool findunsel,
bool do_nearest,
Base **r_base);
/** \} */
@ -325,9 +299,6 @@ struct Bone *ED_armature_pick_bone_from_selectbuffer(struct Base **bases,
* XXX: bone_looper is only to be used when we want to access settings
* (i.e. editability/visibility/selected) that context doesn't offer.
*/
int bone_looper(struct Object *ob,
struct Bone *bone,
void *data,
int (*bone_func)(struct Object *, struct Bone *, void *));
int bone_looper(Object *ob, Bone *bone, void *data, int (*bone_func)(Object *, Bone *, void *));
/** \} */

2
source/blender/editors/interface/interface_intern.hh
View File

@ -333,7 +333,7 @@ struct uiButColor : public uiBut {
/** Derived struct for #UI_BTYPE_TAB */
struct uiButTab : public uiBut {
struct MenuType *menu = nullptr;
MenuType *menu = nullptr;
};
/** Derived struct for #UI_BTYPE_SEARCH_MENU */

193
source/blender/imbuf/intern/IMB_filetype.hh
View File

@ -22,7 +22,7 @@ struct ImBuf;
#define IM_FTYPE_FLOAT 1
typedef struct ImFileType {
struct ImFileType {
/** Optional, called once when initializing. */
void (*init)(void);
/** Optional, called once when exiting. */
@ -36,25 +36,22 @@ typedef struct ImFileType {
bool (*is_a)(const unsigned char *buf, size_t size);
/** Load an image from memory. */
struct ImBuf *(*load)(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
ImBuf *(*load)(const unsigned char *mem, size_t size, int flags, char colorspace[IM_MAX_SPACE]);
/** Load an image from a file. */
struct ImBuf *(*load_filepath)(const char *filepath, int flags, char colorspace[IM_MAX_SPACE]);
ImBuf *(*load_filepath)(const char *filepath, int flags, char colorspace[IM_MAX_SPACE]);
/**
* Load/Create a thumbnail image from a filepath. `max_thumb_size` is maximum size of either
* dimension, so can return less on either or both. Should, if possible and performant, return
* dimensions of the full-size image in r_width & r_height.
*/
struct ImBuf *(*load_filepath_thumbnail)(const char *filepath,
int flags,
size_t max_thumb_size,
char colorspace[IM_MAX_SPACE],
size_t *r_width,
size_t *r_height);
ImBuf *(*load_filepath_thumbnail)(const char *filepath,
int flags,
size_t max_thumb_size,
char colorspace[IM_MAX_SPACE],
size_t *r_width,
size_t *r_height);
/** Save to a file (or memory if #IB_mem is set in `flags` and the format supports it). */
bool (*save)(struct ImBuf *ibuf, const char *filepath, int flags);
bool (*save)(ImBuf *ibuf, const char *filepath, int flags);
int flag;
@ -62,13 +59,13 @@ typedef struct ImFileType {
int filetype;
int default_save_role;
} ImFileType;
};
extern const ImFileType IMB_FILE_TYPES[];
extern const ImFileType *IMB_FILE_TYPES_LAST;
const ImFileType *IMB_file_type_from_ftype(int ftype);
const ImFileType *IMB_file_type_from_ibuf(const struct ImBuf *ibuf);
const ImFileType *IMB_file_type_from_ibuf(const ImBuf *ibuf);
void imb_filetypes_init(void);
void imb_filetypes_exit(void);
@ -82,11 +79,11 @@ void imb_filetypes_exit(void);
* \{ */
bool imb_is_a_png(const unsigned char *mem, size_t size);
struct ImBuf *imb_load_png(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_save_png(struct ImBuf *ibuf, const char *filepath, int flags);
ImBuf *imb_load_png(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_save_png(ImBuf *ibuf, const char *filepath, int flags);
/** \} */
@ -95,11 +92,11 @@ bool imb_save_png(struct ImBuf *ibuf, const char *filepath, int flags);
* \{ */
bool imb_is_a_tga(const unsigned char *mem, size_t size);
struct ImBuf *imb_load_tga(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_save_tga(struct ImBuf *ibuf, const char *filepath, int flags);
ImBuf *imb_load_tga(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_save_tga(ImBuf *ibuf, const char *filepath, int flags);
/** \} */
@ -111,11 +108,11 @@ bool imb_is_a_iris(const unsigned char *mem, size_t size);
/**
* Read in a B/W RGB or RGBA iris image file and return an image buffer.
*/
struct ImBuf *imb_loadiris(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_saveiris(struct ImBuf *ibuf, const char *filepath, int flags);
ImBuf *imb_loadiris(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_saveiris(ImBuf *ibuf, const char *filepath, int flags);
/** \} */
@ -124,14 +121,12 @@ bool imb_saveiris(struct ImBuf *ibuf, const char *filepath, int flags);
* \{ */
bool imb_is_a_jp2(const unsigned char *buf, size_t size);
struct ImBuf *imb_load_jp2(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
struct ImBuf *imb_load_jp2_filepath(const char *filepath,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_save_jp2(struct ImBuf *ibuf, const char *filepath, int flags);
ImBuf *imb_load_jp2(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
ImBuf *imb_load_jp2_filepath(const char *filepath, int flags, char colorspace[IM_MAX_SPACE]);
bool imb_save_jp2(ImBuf *ibuf, const char *filepath, int flags);
/** \} */
@ -140,17 +135,17 @@ bool imb_save_jp2(struct ImBuf *ibuf, const char *filepath, int flags);
* \{ */
bool imb_is_a_jpeg(const unsigned char *mem, size_t size);
bool imb_savejpeg(struct ImBuf *ibuf, const char *filepath, int flags);
struct ImBuf *imb_load_jpeg(const unsigned char *buffer,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
struct ImBuf *imb_thumbnail_jpeg(const char *filepath,
int flags,
size_t max_thumb_size,
char colorspace[IM_MAX_SPACE],
size_t *r_width,
size_t *r_height);
bool imb_savejpeg(ImBuf *ibuf, const char *filepath, int flags);
ImBuf *imb_load_jpeg(const unsigned char *buffer,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
ImBuf *imb_thumbnail_jpeg(const char *filepath,
int flags,
size_t max_thumb_size,
char colorspace[IM_MAX_SPACE],
size_t *r_width,
size_t *r_height);
/** \} */
@ -159,12 +154,12 @@ struct ImBuf *imb_thumbnail_jpeg(const char *filepath,
* \{ */
bool imb_is_a_bmp(const unsigned char *buf, size_t size);
struct ImBuf *imb_load_bmp(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
ImBuf *imb_load_bmp(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
/* Found write info at http://users.ece.gatech.edu/~slabaugh/personal/c/bitmapUnix.c */
bool imb_save_bmp(struct ImBuf *ibuf, const char *filepath, int flags);
bool imb_save_bmp(ImBuf *ibuf, const char *filepath, int flags);
/** \} */
@ -173,11 +168,11 @@ bool imb_save_bmp(struct ImBuf *ibuf, const char *filepath, int flags);
* \{ */
bool imb_is_a_cineon(const unsigned char *buf, size_t size);
bool imb_save_cineon(struct ImBuf *buf, const char *filepath, int flags);
struct ImBuf *imb_load_cineon(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_save_cineon(ImBuf *buf, const char *filepath, int flags);
ImBuf *imb_load_cineon(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
/** \} */
@ -186,11 +181,11 @@ struct ImBuf *imb_load_cineon(const unsigned char *mem,
* \{ */
bool imb_is_a_dpx(const unsigned char *buf, size_t size);
bool imb_save_dpx(struct ImBuf *ibuf, const char *filepath, int flags);
struct ImBuf *imb_load_dpx(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_save_dpx(ImBuf *ibuf, const char *filepath, int flags);
ImBuf *imb_load_dpx(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
/** \} */
@ -199,11 +194,11 @@ struct ImBuf *imb_load_dpx(const unsigned char *mem,
* \{ */
bool imb_is_a_hdr(const unsigned char *buf, size_t size);
struct ImBuf *imb_load_hdr(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_save_hdr(struct ImBuf *ibuf, const char *filepath, int flags);
ImBuf *imb_load_hdr(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
bool imb_save_hdr(ImBuf *ibuf, const char *filepath, int flags);
/** \} */
@ -221,10 +216,10 @@ bool imb_is_a_tiff(const unsigned char *buf, size_t size);
*
* \return A newly allocated #ImBuf structure if successful, otherwise NULL.
*/
struct ImBuf *imb_load_tiff(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
ImBuf *imb_load_tiff(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
/**
* Saves a TIFF file.
*
@ -239,7 +234,7 @@ struct ImBuf *imb_load_tiff(const unsigned char *mem,
*
* \return 1 if the function is successful, 0 on failure.
*/
bool imb_save_tiff(struct ImBuf *ibuf, const char *filepath, int flags);
bool imb_save_tiff(ImBuf *ibuf, const char *filepath, int flags);
/** \} */
@ -248,17 +243,17 @@ bool imb_save_tiff(struct ImBuf *ibuf, const char *filepath, int flags);
* \{ */
bool imb_is_a_webp(const unsigned char *buf, size_t size);
struct ImBuf *imb_loadwebp(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
struct ImBuf *imb_load_filepath_thumbnail_webp(const char *filepath,
const int flags,
const size_t max_thumb_size,
char colorspace[],
size_t *r_width,
size_t *r_height);
bool imb_savewebp(struct ImBuf *ibuf, const char *filepath, int flags);
ImBuf *imb_loadwebp(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
ImBuf *imb_load_filepath_thumbnail_webp(const char *filepath,
const int flags,
const size_t max_thumb_size,
char colorspace[],
size_t *r_width,
size_t *r_height);
bool imb_savewebp(ImBuf *ibuf, const char *filepath, int flags);
/** \} */
@ -270,10 +265,10 @@ void imb_init_dds();
bool imb_is_a_dds(const unsigned char *buf, size_t size);
struct ImBuf *imb_load_dds(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
ImBuf *imb_load_dds(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
/** \} */
@ -283,10 +278,10 @@ struct ImBuf *imb_load_dds(const unsigned char *mem,
bool imb_is_a_psd(const unsigned char *buf, size_t size);
struct ImBuf *imb_load_psd(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
ImBuf *imb_load_psd(const unsigned char *mem,
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
/** \} */
@ -294,12 +289,12 @@ struct ImBuf *imb_load_psd(const unsigned char *mem,
/** \name Format: SVG - Only for thumbnails.
* \{ */
struct ImBuf *imb_load_filepath_thumbnail_svg(const char *filepath,
const int flags,
const size_t max_thumb_size,
char colorspace[],
size_t *r_width,
size_t *r_height);
ImBuf *imb_load_filepath_thumbnail_svg(const char *filepath,
const int flags,
const size_t max_thumb_size,
char colorspace[],
size_t *r_width,
size_t *r_height);
/** \} */

4
source/blender/imbuf/intern/IMB_filter.hh
View File

@ -13,7 +13,7 @@
struct ImBuf;
void imb_filterx(struct ImBuf *ibuf);
void imb_filterx(ImBuf *ibuf);
void IMB_premultiply_rect(uint8_t *rect, char planes, int w, int h);
void IMB_premultiply_rect_float(float *rect_float, int channels, int w, int h);
@ -24,4 +24,4 @@ void IMB_unpremultiply_rect_float(float *rect_float, int channels, int w, int h)
/**
* Result in ibuf2, scaling should be done correctly.
*/
void imb_onehalf_no_alloc(struct ImBuf *ibuf2, struct ImBuf *ibuf1);
void imb_onehalf_no_alloc(ImBuf *ibuf2, ImBuf *ibuf1);

40
source/blender/imbuf/intern/IMB_indexer.hh
View File

@ -34,36 +34,36 @@
* the BL_proxy directory structure for later reuse in different blender files.
*/
typedef struct anim_index_entry {
struct anim_index_entry {
int frameno;
uint64_t seek_pos;
uint64_t seek_pos_pts;
uint64_t seek_pos_dts;
uint64_t pts;
} anim_index_entry;
};
struct ImBufAnimIndex {
char filepath[1024];
int num_entries;
struct anim_index_entry *entries;
anim_index_entry *entries;
};
struct anim_index_builder;
typedef struct anim_index_builder {
struct anim_index_builder {
FILE *fp;
char filepath[FILE_MAX];
char filepath_temp[FILE_MAX];
void *private_data;
void (*delete_priv_data)(struct anim_index_builder *idx);
void (*proc_frame)(struct anim_index_builder *idx,
void (*delete_priv_data)(anim_index_builder *idx);
void (*proc_frame)(anim_index_builder *idx,
unsigned char *buffer,
int data_size,
struct anim_index_entry *entry);
} anim_index_builder;
anim_index_entry *entry);
};
anim_index_builder *IMB_index_builder_create(const char *filepath);
void IMB_index_builder_add_entry(anim_index_builder *fp,
@ -84,23 +84,23 @@ void IMB_index_builder_proc_frame(anim_index_builder *fp,
void IMB_index_builder_finish(anim_index_builder *fp, int rollback);
struct ImBufAnimIndex *IMB_indexer_open(const char *name);
uint64_t IMB_indexer_get_seek_pos(struct ImBufAnimIndex *idx, int frame_index);
uint64_t IMB_indexer_get_seek_pos_pts(struct ImBufAnimIndex *idx, int frame_index);
uint64_t IMB_indexer_get_seek_pos_dts(struct ImBufAnimIndex *idx, int frame_index);
ImBufAnimIndex *IMB_indexer_open(const char *name);
uint64_t IMB_indexer_get_seek_pos(ImBufAnimIndex *idx, int frame_index);
uint64_t IMB_indexer_get_seek_pos_pts(ImBufAnimIndex *idx, int frame_index);
uint64_t IMB_indexer_get_seek_pos_dts(ImBufAnimIndex *idx, int frame_index);
int IMB_indexer_get_frame_index(struct ImBufAnimIndex *idx, int frameno);
uint64_t IMB_indexer_get_pts(struct ImBufAnimIndex *idx, int frame_index);
int IMB_indexer_get_duration(struct ImBufAnimIndex *idx);
int IMB_indexer_get_frame_index(ImBufAnimIndex *idx, int frameno);
uint64_t IMB_indexer_get_pts(ImBufAnimIndex *idx, int frame_index);
int IMB_indexer_get_duration(ImBufAnimIndex *idx);
int IMB_indexer_can_scan(struct ImBufAnimIndex *idx, int old_frame_index, int new_frame_index);
int IMB_indexer_can_scan(ImBufAnimIndex *idx, int old_frame_index, int new_frame_index);
void IMB_indexer_close(struct ImBufAnimIndex *idx);
void IMB_indexer_close(ImBufAnimIndex *idx);
void IMB_free_indices(struct ImBufAnim *anim);
void IMB_free_indices(ImBufAnim *anim);
struct ImBufAnim *IMB_anim_open_proxy(struct ImBufAnim *anim, IMB_Proxy_Size preview_size);
struct ImBufAnimIndex *IMB_anim_open_index(struct ImBufAnim *anim, IMB_Timecode_Type tc);
ImBufAnim *IMB_anim_open_proxy(ImBufAnim *anim, IMB_Proxy_Size preview_size);
ImBufAnimIndex *IMB_anim_open_index(ImBufAnim *anim, IMB_Timecode_Type tc);
int IMB_proxy_size_to_array_index(IMB_Proxy_Size pr_size);
int IMB_timecode_to_array_index(IMB_Timecode_Type tc);