dillongoostudios/goo-engine
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup: Remove unnecessary keywords in C++ headers

Browse Source
This commit is contained in:
Hans Goudey
2024-01-30 14:53:41 -05:00
parent 19e2b13cec
commit 69d2dd0731
6 changed files with 78 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/blender/blenkernel/BKE_key.hh
+49 -66
View File
@@ -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);
/** \} */
source/blender/blenkernel/BKE_lib_query.hh
+1 -2
View File
@@ -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.
source/blender/blenkernel/BKE_main.hh
+8 -7
View File
@@ -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 {
source/blender/blenkernel/BKE_pointcloud.hh
+11 -14
View File
@@ -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);
source/blender/compositor/COM_compositor.hh
+4 -8
View File
@@ -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
source/blender/editors/include/ED_render.hh
+5 -5
View File
@@ -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,