From d02d6ec4e5485427e80918d523dff6539860b0b3 Mon Sep 17 00:00:00 2001 From: Hans Goudey Date: Wed, 24 Jan 2024 11:46:28 -0500 Subject: [PATCH] Cleanup: Remove unnecessary keywords in C++ headers --- source/blender/blenkernel/BKE_mball.hh | 50 +- .../blenkernel/BKE_mball_tessellate.hh | 6 +- source/blender/blenkernel/BKE_undo_system.hh | 9 +- source/blender/bmesh/tools/bmesh_boolean.hh | 4 +- source/blender/bmesh/tools/bmesh_path.hh | 39 +- source/blender/bmesh/tools/bmesh_path_uv.hh | 36 +- source/blender/draw/DRW_engine.hh | 154 +++--- source/blender/draw/intern/DRW_render.hh | 451 +++++++++--------- source/blender/draw/intern/draw_cache.hh | 288 ++++++----- .../blender/draw/intern/draw_subdivision.hh | 4 +- .../editors/armature/armature_intern.hh | 293 +++++------- .../editors/interface/interface_intern.hh | 2 +- source/blender/imbuf/intern/IMB_filetype.hh | 193 ++++---- source/blender/imbuf/intern/IMB_filter.hh | 4 +- source/blender/imbuf/intern/IMB_indexer.hh | 40 +- 15 files changed, 758 insertions(+), 815 deletions(-) diff --git a/source/blender/blenkernel/BKE_mball.hh b/source/blender/blenkernel/BKE_mball.hh index 14b65b2fc22..a92e71245d5 100644 --- a/source/blender/blenkernel/BKE_mball.hh +++ b/source/blender/blenkernel/BKE_mball.hh @@ -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); diff --git a/source/blender/blenkernel/BKE_mball_tessellate.hh b/source/blender/blenkernel/BKE_mball_tessellate.hh index 73d1692c2e0..6cdd920649c 100644 --- a/source/blender/blenkernel/BKE_mball_tessellate.hh +++ b/source/blender/blenkernel/BKE_mball_tessellate.hh @@ -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(); diff --git a/source/blender/blenkernel/BKE_undo_system.hh b/source/blender/blenkernel/BKE_undo_system.hh index a107d4b48e4..c194bbb2549 100644 --- a/source/blender/blenkernel/BKE_undo_system.hh +++ b/source/blender/blenkernel/BKE_undo_system.hh @@ -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, diff --git a/source/blender/bmesh/tools/bmesh_boolean.hh b/source/blender/bmesh/tools/bmesh_boolean.hh index e52bf6c0611..51a05a5b581 100644 --- a/source/blender/bmesh/tools/bmesh_boolean.hh +++ b/source/blender/bmesh/tools/bmesh_boolean.hh @@ -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, diff --git a/source/blender/bmesh/tools/bmesh_path.hh b/source/blender/bmesh/tools/bmesh_path.hh index 1e138845197..c5d3bb9e48b 100644 --- a/source/blender/bmesh/tools/bmesh_path.hh +++ b/source/blender/bmesh/tools/bmesh_path.hh @@ -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); diff --git a/source/blender/bmesh/tools/bmesh_path_uv.hh b/source/blender/bmesh/tools/bmesh_path_uv.hh index 49e83d69e90..720d3c264c2 100644 --- a/source/blender/bmesh/tools/bmesh_path_uv.hh +++ b/source/blender/bmesh/tools/bmesh_path_uv.hh @@ -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); diff --git a/source/blender/draw/DRW_engine.hh b/source/blender/draw/DRW_engine.hh index b35883dde47..ea1d53ceaf8 100644 --- a/source/blender/draw/DRW_engine.hh +++ b/source/blender/draw/DRW_engine.hh @@ -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, diff --git a/source/blender/draw/intern/DRW_render.hh b/source/blender/draw/intern/DRW_render.hh index 0e39f69fb2e..80baf02abf5 100644 --- a/source/blender/draw/intern/DRW_render.hh +++ b/source/blender/draw/intern/DRW_render.hh @@ -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); diff --git a/source/blender/draw/intern/draw_cache.hh b/source/blender/draw/intern/draw_cache.hh index af2023fba34..920dbbe886e 100644 --- a/source/blender/draw/intern/draw_cache.hh +++ b/source/blender/draw/intern/draw_cache.hh @@ -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 diff --git a/source/blender/draw/intern/draw_subdivision.hh b/source/blender/draw/intern/draw_subdivision.hh index 7d5c8686959..a82beef848b 100644 --- a/source/blender/draw/intern/draw_subdivision.hh +++ b/source/blender/draw/intern/draw_subdivision.hh @@ -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; diff --git a/source/blender/editors/armature/armature_intern.hh b/source/blender/editors/armature/armature_intern.hh index 5f37870b0b4..bdc3ca62bcf 100644 --- a/source/blender/editors/armature/armature_intern.hh +++ b/source/blender/editors/armature/armature_intern.hh @@ -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 *)); /** \} */ diff --git a/source/blender/editors/interface/interface_intern.hh b/source/blender/editors/interface/interface_intern.hh index 713d36d2d07..57fff52c0bf 100644 --- a/source/blender/editors/interface/interface_intern.hh +++ b/source/blender/editors/interface/interface_intern.hh @@ -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 */ diff --git a/source/blender/imbuf/intern/IMB_filetype.hh b/source/blender/imbuf/intern/IMB_filetype.hh index 4d3cc2d4074..d485ad9d9eb 100644 --- a/source/blender/imbuf/intern/IMB_filetype.hh +++ b/source/blender/imbuf/intern/IMB_filetype.hh @@ -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); /** \} */ diff --git a/source/blender/imbuf/intern/IMB_filter.hh b/source/blender/imbuf/intern/IMB_filter.hh index c18dbb8300c..963f89a1af3 100644 --- a/source/blender/imbuf/intern/IMB_filter.hh +++ b/source/blender/imbuf/intern/IMB_filter.hh @@ -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); diff --git a/source/blender/imbuf/intern/IMB_indexer.hh b/source/blender/imbuf/intern/IMB_indexer.hh index 367765f1a36..8e0ad70eaf0 100644 --- a/source/blender/imbuf/intern/IMB_indexer.hh +++ b/source/blender/imbuf/intern/IMB_indexer.hh @@ -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);