diff --git a/source/blender/blenkernel/BKE_key.hh b/source/blender/blenkernel/BKE_key.hh index bc658157f39..cad8f52147d 100644 --- a/source/blender/blenkernel/BKE_key.hh +++ b/source/blender/blenkernel/BKE_key.hh @@ -19,15 +19,15 @@ struct Object; /** * Free (or release) any data used by this shape-key (does not free the key itself). */ -void BKE_key_free_data(struct Key *key); -void BKE_key_free_nolib(struct Key *key); -struct Key *BKE_key_add(struct Main *bmain, struct ID *id); +void BKE_key_free_data(Key *key); +void BKE_key_free_nolib(Key *key); +Key *BKE_key_add(Main *bmain, ID *id); /** * Sort shape keys after a change. * This assumes that at most one key was moved, * which is a valid assumption for the places it's currently being called. */ -void BKE_key_sort(struct Key *key); +void BKE_key_sort(Key *key); void key_curve_position_weights(float t, float data[4], int type); /** @@ -45,34 +45,34 @@ void key_curve_normal_weights(float t, float data[4], int type); * \param obdata: if given, also update that geometry with the result of the shape keys evaluation. */ float *BKE_key_evaluate_object_ex( - struct Object *ob, int *r_totelem, float *arr, size_t arr_size, struct ID *obdata); -float *BKE_key_evaluate_object(struct Object *ob, int *r_totelem); + Object *ob, int *r_totelem, float *arr, size_t arr_size, ID *obdata); +float *BKE_key_evaluate_object(Object *ob, int *r_totelem); /** * \param shape_index: The index to use or all (when -1). */ -int BKE_keyblock_element_count_from_shape(const struct Key *key, int shape_index); -int BKE_keyblock_element_count(const struct Key *key); +int BKE_keyblock_element_count_from_shape(const Key *key, int shape_index); +int BKE_keyblock_element_count(const Key *key); /** * \param shape_index: The index to use or all (when -1). */ -size_t BKE_keyblock_element_calc_size_from_shape(const struct Key *key, int shape_index); -size_t BKE_keyblock_element_calc_size(const struct Key *key); +size_t BKE_keyblock_element_calc_size_from_shape(const Key *key, int shape_index); +size_t BKE_keyblock_element_calc_size(const Key *key); bool BKE_key_idtype_support(short id_type); -struct Key **BKE_key_from_id_p(struct ID *id); -struct Key *BKE_key_from_id(struct ID *id); -struct Key **BKE_key_from_object_p(struct Object *ob); -struct Key *BKE_key_from_object(struct Object *ob); +Key **BKE_key_from_id_p(ID *id); +Key *BKE_key_from_id(ID *id); +Key **BKE_key_from_object_p(Object *ob); +Key *BKE_key_from_object(Object *ob); /** * Only the active key-block. */ -struct KeyBlock *BKE_keyblock_from_object(struct Object *ob); -struct KeyBlock *BKE_keyblock_from_object_reference(struct Object *ob); +KeyBlock *BKE_keyblock_from_object(Object *ob); +KeyBlock *BKE_keyblock_from_object_reference(Object *ob); -struct KeyBlock *BKE_keyblock_add(struct Key *key, const char *name); +KeyBlock *BKE_keyblock_add(Key *key, const char *name); /** * \note sorting is a problematic side effect in some cases, * better only do this explicitly by having its own function, @@ -81,55 +81,47 @@ struct KeyBlock *BKE_keyblock_add(struct Key *key, const char *name); * \param name: Optional name for the new keyblock. * \param do_force: always use ctime even for relative keys. */ -struct KeyBlock *BKE_keyblock_add_ctime(struct Key *key, const char *name, bool do_force); +KeyBlock *BKE_keyblock_add_ctime(Key *key, const char *name, bool do_force); /** * Get the appropriate #KeyBlock given an index (0 refers to the basis key). Key may be null. */ -struct KeyBlock *BKE_keyblock_find_by_index(struct Key *key, int index); +KeyBlock *BKE_keyblock_find_by_index(Key *key, int index); /** * Get the appropriate #KeyBlock given a name to search for. */ -struct KeyBlock *BKE_keyblock_find_name(struct Key *key, const char name[]); +KeyBlock *BKE_keyblock_find_name(Key *key, const char name[]); -struct KeyBlock *BKE_keyblock_find_uid(struct Key *key, int uid); +KeyBlock *BKE_keyblock_find_uid(Key *key, int uid); /** * \brief copy shape-key attributes, but not key data or name/UID. */ -void BKE_keyblock_copy_settings(struct KeyBlock *kb_dst, const struct KeyBlock *kb_src); +void BKE_keyblock_copy_settings(KeyBlock *kb_dst, const KeyBlock *kb_src); /** * Get RNA-Path for 'value' setting of the given shape-key. * \note the user needs to free the returned string once they're finished with it. */ -char *BKE_keyblock_curval_rnapath_get(const struct Key *key, const struct KeyBlock *kb); +char *BKE_keyblock_curval_rnapath_get(const Key *key, const KeyBlock *kb); /* conversion functions */ /* NOTE: 'update_from' versions do not (re)allocate mem in kb, while 'convert_from' do. */ -void BKE_keyblock_update_from_lattice(const struct Lattice *lt, struct KeyBlock *kb); -void BKE_keyblock_convert_from_lattice(const struct Lattice *lt, struct KeyBlock *kb); -void BKE_keyblock_convert_to_lattice(const struct KeyBlock *kb, struct Lattice *lt); +void BKE_keyblock_update_from_lattice(const Lattice *lt, KeyBlock *kb); +void BKE_keyblock_convert_from_lattice(const Lattice *lt, KeyBlock *kb); +void BKE_keyblock_convert_to_lattice(const KeyBlock *kb, Lattice *lt); -int BKE_keyblock_curve_element_count(const struct ListBase *nurb); -void BKE_keyblock_curve_data_transform(const struct ListBase *nurb, +int BKE_keyblock_curve_element_count(const ListBase *nurb); +void BKE_keyblock_curve_data_transform(const ListBase *nurb, const float mat[4][4], const void *src, void *dst); -void BKE_keyblock_update_from_curve(const struct Curve *cu, - struct KeyBlock *kb, - const struct ListBase *nurb); -void BKE_keyblock_convert_from_curve(const struct Curve *cu, - struct KeyBlock *kb, - const struct ListBase *nurb); -void BKE_keyblock_convert_to_curve(struct KeyBlock *kb, struct Curve *cu, struct ListBase *nurb); +void BKE_keyblock_update_from_curve(const Curve *cu, KeyBlock *kb, const ListBase *nurb); +void BKE_keyblock_convert_from_curve(const Curve *cu, KeyBlock *kb, const ListBase *nurb); +void BKE_keyblock_convert_to_curve(KeyBlock *kb, Curve *cu, ListBase *nurb); -void BKE_keyblock_update_from_mesh(const struct Mesh *mesh, struct KeyBlock *kb); -void BKE_keyblock_convert_from_mesh(const struct Mesh *mesh, - const struct Key *key, - struct KeyBlock *kb); -void BKE_keyblock_convert_to_mesh(const struct KeyBlock *kb, - float (*vert_positions)[3], - int totvert); +void BKE_keyblock_update_from_mesh(const Mesh *mesh, KeyBlock *kb); +void BKE_keyblock_convert_from_mesh(const Mesh *mesh, const Key *key, KeyBlock *kb); +void BKE_keyblock_convert_to_mesh(const KeyBlock *kb, float (*vert_positions)[3], int totvert); /** * Computes normals (vertices, faces and/or loops ones) of given mesh for given shape key. @@ -140,24 +132,18 @@ void BKE_keyblock_convert_to_mesh(const struct KeyBlock *kb, * \param r_face_normals: if non-NULL, an array of vectors, same length as number of faces. * \param r_loop_normals: if non-NULL, an array of vectors, same length as number of loops. */ -void BKE_keyblock_mesh_calc_normals(const struct KeyBlock *kb, - struct Mesh *mesh, +void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb, + Mesh *mesh, float (*r_vert_normals)[3], float (*r_face_normals)[3], float (*r_loop_normals)[3]); -void BKE_keyblock_update_from_vertcos(const struct Object *ob, - struct KeyBlock *kb, - const float (*vertCos)[3]); -void BKE_keyblock_convert_from_vertcos(const struct Object *ob, - struct KeyBlock *kb, - const float (*vertCos)[3]); -float (*BKE_keyblock_convert_to_vertcos(const struct Object *ob, const struct KeyBlock *kb))[3]; +void BKE_keyblock_update_from_vertcos(const Object *ob, KeyBlock *kb, const float (*vertCos)[3]); +void BKE_keyblock_convert_from_vertcos(const Object *ob, KeyBlock *kb, const float (*vertCos)[3]); +float (*BKE_keyblock_convert_to_vertcos(const Object *ob, const KeyBlock *kb))[3]; /** RAW coordinates offsets. */ -void BKE_keyblock_update_from_offset(const struct Object *ob, - struct KeyBlock *kb, - const float (*ofs)[3]); +void BKE_keyblock_update_from_offset(const Object *ob, KeyBlock *kb, const float (*ofs)[3]); /* other management */ @@ -170,18 +156,18 @@ void BKE_keyblock_update_from_offset(const struct Object *ob, * \param org_index: if < 0, current object's active shape will be used as shape-key to move. * \return true if something was done, else false. */ -bool BKE_keyblock_move(struct Object *ob, int org_index, int new_index); +bool BKE_keyblock_move(Object *ob, int org_index, int new_index); /** * Check if given key-block (as index) is used as basis by others in given key. */ -bool BKE_keyblock_is_basis(const struct Key *key, int index); +bool BKE_keyblock_is_basis(const Key *key, int index); /** * Returns a newly allocated array containing true for every key that has this one as basis. * If none are found, returns null. */ -bool *BKE_keyblock_get_dependent_keys(const struct Key *key, int index); +bool *BKE_keyblock_get_dependent_keys(const Key *key, int index); /* -------------------------------------------------------------------- */ /** \name Key-Block Data Access @@ -190,13 +176,13 @@ bool *BKE_keyblock_get_dependent_keys(const struct Key *key, int index); /** * \param shape_index: The index to use or all (when -1). */ -void BKE_keyblock_data_get_from_shape(const struct Key *key, float (*arr)[3], int shape_index); -void BKE_keyblock_data_get(const struct Key *key, float (*arr)[3]); +void BKE_keyblock_data_get_from_shape(const Key *key, float (*arr)[3], int shape_index); +void BKE_keyblock_data_get(const Key *key, float (*arr)[3]); /** * Set the data to all key-blocks (or shape_index if != -1). */ -void BKE_keyblock_data_set_with_mat4(struct Key *key, +void BKE_keyblock_data_set_with_mat4(Key *key, int shape_index, const float (*coords)[3], const float mat[4][4]); @@ -204,14 +190,11 @@ void BKE_keyblock_data_set_with_mat4(struct Key *key, * Set the data for all key-blocks (or shape_index if != -1), * transforming by \a mat. */ -void BKE_keyblock_curve_data_set_with_mat4(struct Key *key, - const struct ListBase *nurb, - int shape_index, - const void *data, - const float mat[4][4]); +void BKE_keyblock_curve_data_set_with_mat4( + Key *key, const ListBase *nurb, int shape_index, const void *data, const float mat[4][4]); /** * Set the data for all key-blocks (or shape_index if != -1). */ -void BKE_keyblock_data_set(struct Key *key, int shape_index, const void *data); +void BKE_keyblock_data_set(Key *key, int shape_index, const void *data); /** \} */ diff --git a/source/blender/blenkernel/BKE_lib_query.hh b/source/blender/blenkernel/BKE_lib_query.hh index b9a0227a35a..74a286b3dd8 100644 --- a/source/blender/blenkernel/BKE_lib_query.hh +++ b/source/blender/blenkernel/BKE_lib_query.hh @@ -23,6 +23,7 @@ struct ID; struct IDProperty; +struct LibraryForeachIDData; struct Main; /* Tips for the callback for cases it's gonna to modify the pointer. */ @@ -201,8 +202,6 @@ enum { IDWALK_DO_DEPRECATED_POINTERS = (1 << 11), }; -typedef struct LibraryForeachIDData LibraryForeachIDData; - /** * Check whether current iteration over ID usages should be stopped or not. * \return true if the iteration should be stopped, false otherwise. diff --git a/source/blender/blenkernel/BKE_main.hh b/source/blender/blenkernel/BKE_main.hh index f7a25b9e7c5..522d92c5ef1 100644 --- a/source/blender/blenkernel/BKE_main.hh +++ b/source/blender/blenkernel/BKE_main.hh @@ -29,6 +29,7 @@ struct BLI_mempool; struct BlendThumbnail; struct GHash; struct GSet; +struct ID; struct IDNameLib_Map; struct ImBuf; struct Library; @@ -47,13 +48,13 @@ struct BlendThumbnail { /** Structs caching relations between data-blocks in a given Main. */ struct MainIDRelationsEntryItem { - struct MainIDRelationsEntryItem *next; + MainIDRelationsEntryItem *next; union { /* For `from_ids` list, a user of the hashed ID. */ - struct ID *from; + ID *from; /* For `to_ids` list, an ID used by the hashed ID. */ - struct ID **to; + ID **to; } id_pointer; /* Session uid of the `id_pointer`. */ uint session_uid; @@ -63,9 +64,9 @@ struct MainIDRelationsEntryItem { struct MainIDRelationsEntry { /* Linked list of IDs using that ID. */ - struct MainIDRelationsEntryItem *from_ids; + MainIDRelationsEntryItem *from_ids; /* Linked list of IDs used by that ID. */ - struct MainIDRelationsEntryItem *to_ids; + MainIDRelationsEntryItem *to_ids; /* Session uid of the ID matching that entry. */ uint session_uid; @@ -104,13 +105,13 @@ enum eMainIDRelationsEntryTags { struct MainIDRelations { /* Mapping from an ID pointer to all of its parents (IDs using it) and children (IDs it uses). * Values are `MainIDRelationsEntry` pointers. */ - struct GHash *relations_from_pointers; + GHash *relations_from_pointers; /* NOTE: we could add more mappings when needed (e.g. from session uid?). */ short flag; /* Private... */ - struct BLI_mempool *entry_items_pool; + BLI_mempool *entry_items_pool; }; enum { diff --git a/source/blender/blenkernel/BKE_pointcloud.hh b/source/blender/blenkernel/BKE_pointcloud.hh index 9bc093e96d5..7ee442f9b0a 100644 --- a/source/blender/blenkernel/BKE_pointcloud.hh +++ b/source/blender/blenkernel/BKE_pointcloud.hh @@ -42,21 +42,18 @@ struct PointCloudRuntime { } // namespace blender::bke -void *BKE_pointcloud_add(struct Main *bmain, const char *name); -void *BKE_pointcloud_add_default(struct Main *bmain, const char *name); -struct PointCloud *BKE_pointcloud_new_nomain(int totpoint); -void BKE_pointcloud_nomain_to_pointcloud(struct PointCloud *pointcloud_src, - struct PointCloud *pointcloud_dst); +void *BKE_pointcloud_add(Main *bmain, const char *name); +void *BKE_pointcloud_add_default(Main *bmain, const char *name); +PointCloud *BKE_pointcloud_new_nomain(int totpoint); +void BKE_pointcloud_nomain_to_pointcloud(PointCloud *pointcloud_src, PointCloud *pointcloud_dst); -bool BKE_pointcloud_attribute_required(const struct PointCloud *pointcloud, const char *name); +bool BKE_pointcloud_attribute_required(const PointCloud *pointcloud, const char *name); /* Dependency Graph */ -struct PointCloud *BKE_pointcloud_copy_for_eval(const struct PointCloud *pointcloud_src); +PointCloud *BKE_pointcloud_copy_for_eval(const PointCloud *pointcloud_src); -void BKE_pointcloud_data_update(struct Depsgraph *depsgraph, - struct Scene *scene, - struct Object *object); +void BKE_pointcloud_data_update(Depsgraph *depsgraph, Scene *scene, Object *object); /* Draw Cache */ @@ -64,8 +61,8 @@ enum { BKE_POINTCLOUD_BATCH_DIRTY_ALL = 0, }; -void BKE_pointcloud_batch_cache_dirty_tag(struct PointCloud *pointcloud, int mode); -void BKE_pointcloud_batch_cache_free(struct PointCloud *pointcloud); +void BKE_pointcloud_batch_cache_dirty_tag(PointCloud *pointcloud, int mode); +void BKE_pointcloud_batch_cache_free(PointCloud *pointcloud); -extern void (*BKE_pointcloud_batch_cache_dirty_tag_cb)(struct PointCloud *pointcloud, int mode); -extern void (*BKE_pointcloud_batch_cache_free_cb)(struct PointCloud *pointcloud); +extern void (*BKE_pointcloud_batch_cache_dirty_tag_cb)(PointCloud *pointcloud, int mode); +extern void (*BKE_pointcloud_batch_cache_free_cb)(PointCloud *pointcloud); diff --git a/source/blender/compositor/COM_compositor.hh b/source/blender/compositor/COM_compositor.hh index 3f4e58e78ef..896da42a0c7 100644 --- a/source/blender/compositor/COM_compositor.hh +++ b/source/blender/compositor/COM_compositor.hh @@ -296,17 +296,13 @@ struct Render; * It can be executed during editing (`blenkernel/node.cc`) or rendering * (`renderer/pipeline.cc`). * - * \param render: [struct Render] - * Render instance for GPU context. + * \param render: Render instance for GPU context. * - * \param render_data: [struct RenderData] - * Render data for this composite, this won't always belong to a scene. + * \param render_data: Render data for this composite, this won't always belong to a scene. * - * \param node_tree: [struct bNodeTree] - * reference to the compositor editing tree + * \param node_tree: Reference to the compositor editing tree * - * \param rendering: [true false] - * This parameter determines whether the function is called from rendering + * \param rendering: This parameter determines whether the function is called from rendering * (true) or editing (false). * based on this setting the system will work differently: * - during rendering only Composite & the File output node will be calculated diff --git a/source/blender/editors/include/ED_render.hh b/source/blender/editors/include/ED_render.hh index 8ff4020db39..28999305803 100644 --- a/source/blender/editors/include/ED_render.hh +++ b/source/blender/editors/include/ED_render.hh @@ -83,11 +83,11 @@ void ED_preview_set_visibility(Main *pr_main, ViewLayer *view_layer, ePreviewType pr_type, ePreviewRenderMethod pr_method); -struct World *ED_preview_prepare_world(Main *pr_main, - const Scene *scene, - const World *world, - ID_Type id_type, - ePreviewRenderMethod pr_method); +World *ED_preview_prepare_world(Main *pr_main, + const Scene *scene, + const World *world, + ID_Type id_type, + ePreviewRenderMethod pr_method); void ED_preview_shader_job(const bContext *C, void *owner,