Cleanup: replace UNUSED macro with commented args in C++ code

This is the conventional way of dealing with unused arguments in C++,
since it works on all compilers.

Regex find and replace: `UNUSED\((\w+)\)` -> `/*$1*/`
This commit is contained in:
Hans Goudey 2022-10-03 17:37:25 -05:00
parent ed7f5713f8
commit 97746129d5
601 changed files with 2305 additions and 2443 deletions

View File

@ -122,11 +122,11 @@ class AbstractTileData {
*/
class NoTileData : AbstractTileData {
public:
NoTileData(Image *UNUSED(image), ImageUser *UNUSED(image_user))
NoTileData(Image * /*image*/, ImageUser * /*image_user*/)
{
}
void init_data(TileNumber UNUSED(new_tile_number)) override
void init_data(TileNumber /*new_tile_number*/) override
{
}

View File

@ -143,7 +143,7 @@ IDProperty *BKE_asset_metadata_idprop_find(const AssetMetaData *asset_data, cons
/* Queries -------------------------------------------- */
PreviewImage *BKE_asset_metadata_preview_get_from_id(const AssetMetaData *UNUSED(asset_data),
PreviewImage *BKE_asset_metadata_preview_get_from_id(const AssetMetaData * /*asset_data*/,
const ID *id)
{
return BKE_previewimg_id_get(id);

View File

@ -334,7 +334,7 @@ class ComponentAttributeProviders {
namespace attribute_accessor_functions {
template<const ComponentAttributeProviders &providers>
inline bool is_builtin(const void *UNUSED(owner), const AttributeIDRef &attribute_id)
inline bool is_builtin(const void * /*owner*/, const AttributeIDRef &attribute_id)
{
if (!attribute_id.is_named()) {
return false;

View File

@ -56,7 +56,7 @@ static void brush_init_data(ID *id)
BKE_brush_curve_preset(brush, CURVE_PRESET_SMOOTH);
}
static void brush_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
static void brush_copy_data(Main * /*bmain*/, ID *id_dst, const ID *id_src, const int flag)
{
Brush *brush_dst = (Brush *)id_dst;
const Brush *brush_src = (const Brush *)id_src;

View File

@ -178,7 +178,7 @@ static void bvhtree_balance(BVHTree *tree, const bool isolate)
/* Math stuff for ray casting on mesh faces and for nearest surface */
float bvhtree_ray_tri_intersection(const BVHTreeRay *ray,
const float UNUSED(m_dist),
const float /*m_dist*/,
const float v0[3],
const float v1[3],
const float v2[3])
@ -1136,7 +1136,7 @@ BVHTree *bvhtree_from_mesh_looptri_ex(BVHTreeFromMesh *data,
static BLI_bitmap *loose_verts_map_get(const MEdge *medge,
int edges_num,
const MVert *UNUSED(mvert),
const MVert * /*mvert*/,
int verts_num,
int *r_loose_vert_num)
{

View File

@ -580,7 +580,7 @@ blender::StringRef CryptomatteStampDataCallbackData::extract_layer_hash(blender:
void CryptomatteStampDataCallbackData::extract_layer_names(void *_data,
const char *propname,
char *propvalue,
int UNUSED(len))
int /*len*/)
{
CryptomatteStampDataCallbackData *data = static_cast<CryptomatteStampDataCallbackData *>(_data);
@ -598,7 +598,7 @@ void CryptomatteStampDataCallbackData::extract_layer_names(void *_data,
void CryptomatteStampDataCallbackData::extract_layer_manifest(void *_data,
const char *propname,
char *propvalue,
int UNUSED(len))
int /*len*/)
{
CryptomatteStampDataCallbackData *data = static_cast<CryptomatteStampDataCallbackData *>(_data);

View File

@ -88,10 +88,10 @@ TEST(cryptomatte, extract_layer_hash_from_metadata_key)
"cryptomatte/"));
}
static void validate_cryptomatte_session_from_stamp_data(void *UNUSED(data),
static void validate_cryptomatte_session_from_stamp_data(void * /*data*/,
const char *propname,
char *propvalue,
int UNUSED(len))
int /*len*/)
{
blender::StringRefNull prop_name(propname);
if (!prop_name.startswith("cryptomatte/")) {

View File

@ -1056,7 +1056,7 @@ BPoint *BKE_nurb_bpoint_get_prev(Nurb *nu, BPoint *bp)
return bp_prev;
}
void BKE_nurb_bezt_calc_normal(struct Nurb *UNUSED(nu), BezTriple *bezt, float r_normal[3])
void BKE_nurb_bezt_calc_normal(struct Nurb * /*nu*/, BezTriple *bezt, float r_normal[3])
{
/* calculate the axis matrix from the spline */
float dir_prev[3], dir_next[3];

View File

@ -63,7 +63,7 @@ static void curves_init_data(ID *id)
new (&curves->geometry) blender::bke::CurvesGeometry();
}
static void curves_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
static void curves_copy_data(Main * /*bmain*/, ID *id_dst, const ID *id_src, const int flag)
{
using namespace blender;
@ -263,7 +263,7 @@ BoundBox *BKE_curves_boundbox_get(Object *ob)
return ob->runtime.bb;
}
bool BKE_curves_attribute_required(const Curves *UNUSED(curves), const char *name)
bool BKE_curves_attribute_required(const Curves * /*curves*/, const char *name)
{
return STREQ(name, ATTR_POSITION);
}

View File

@ -232,7 +232,7 @@ static void layerFree_mdeformvert(void *data, const int count, const int size)
static void layerInterp_mdeformvert(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
const int count,
void *dest)
{
@ -331,7 +331,7 @@ static void layerConstruct_mdeformvert(void *data, const int count)
static void layerInterp_normal(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
const int count,
void *dest)
{
@ -472,7 +472,7 @@ static void layerCopy_propFloat(const void *source, void *dest, const int count)
static void layerInterp_propFloat(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
const int count,
void *dest)
{
@ -510,7 +510,7 @@ static bool layerValidate_propFloat(void *data, const uint totitems, const bool
static void layerInterp_propInt(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
const int count,
void *dest)
{
@ -659,7 +659,7 @@ static void layerCopy_mdisps(const void *source, void *dest, const int count)
}
}
static void layerFree_mdisps(void *data, const int count, const int UNUSED(size))
static void layerFree_mdisps(void *data, const int count, const int /*size*/)
{
MDisps *d = static_cast<MDisps *>(data);
@ -714,7 +714,7 @@ static bool layerWrite_mdisps(CDataFile *cdf, const void *data, const int count)
return true;
}
static size_t layerFilesize_mdisps(CDataFile *UNUSED(cdf), const void *data, const int count)
static size_t layerFilesize_mdisps(CDataFile * /*cdf*/, const void *data, const int count)
{
const MDisps *d = static_cast<const MDisps *>(data);
size_t size = 0;
@ -733,7 +733,7 @@ static size_t layerFilesize_mdisps(CDataFile *UNUSED(cdf), const void *data, con
* \{ */
/* copy just zeros in this case */
static void layerCopy_bmesh_elem_py_ptr(const void *UNUSED(source), void *dest, const int count)
static void layerCopy_bmesh_elem_py_ptr(const void * /*source*/, void *dest, const int count)
{
const int size = sizeof(void *);
@ -744,7 +744,7 @@ static void layerCopy_bmesh_elem_py_ptr(const void *UNUSED(source), void *dest,
}
#ifndef WITH_PYTHON
void bpy_bm_generic_invalidate(struct BPy_BMGeneric *UNUSED(self))
void bpy_bm_generic_invalidate(struct BPy_BMGeneric * /*self*/)
{
/* dummy */
}
@ -768,7 +768,7 @@ static void layerFree_bmesh_elem_py_ptr(void *data, const int count, const int s
static void layerInterp_paint_mask(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -804,7 +804,7 @@ static void layerCopy_grid_paint_mask(const void *source, void *dest, const int
}
}
static void layerFree_grid_paint_mask(void *data, const int count, const int UNUSED(size))
static void layerFree_grid_paint_mask(void *data, const int count, const int /*size*/)
{
GridPaintMask *gpm = static_cast<GridPaintMask *>(data);
@ -977,7 +977,7 @@ static void layerDefault_mloopcol(void *data, const int count)
static void layerInterp_mloopcol(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -1075,7 +1075,7 @@ static void layerAdd_mloopuv(void *data1, const void *data2)
static void layerInterp_mloopuv(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -1118,8 +1118,8 @@ static bool layerValidate_mloopuv(void *data, const uint totitems, const bool do
/* origspace is almost exact copy of mloopuv's, keep in sync */
static void layerCopyValue_mloop_origspace(const void *source,
void *dest,
const int UNUSED(mixmode),
const float UNUSED(mixfactor))
const int /*mixmode*/,
const float /*mixfactor*/)
{
const OrigSpaceLoop *luv1 = static_cast<const OrigSpaceLoop *>(source);
OrigSpaceLoop *luv2 = static_cast<OrigSpaceLoop *>(dest);
@ -1169,7 +1169,7 @@ static void layerAdd_mloop_origspace(void *data1, const void *data2)
static void layerInterp_mloop_origspace(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -1267,7 +1267,7 @@ static void layerDefault_origindex(void *data, const int count)
static void layerInterp_bweight(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -1290,7 +1290,7 @@ static void layerInterp_bweight(const void **sources,
static void layerInterp_shapekey(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -1335,7 +1335,7 @@ static void layerCopy_mvert_skin(const void *source, void *dest, const int count
static void layerInterp_mvert_skin(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -1498,7 +1498,7 @@ static void layerDefault_propcol(void *data, const int count)
static void layerInterp_propcol(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -1520,7 +1520,7 @@ static void layerInterp_propcol(const void **sources,
static void layerInterp_propfloat3(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -1573,7 +1573,7 @@ static bool layerValidate_propfloat3(void *data, const uint totitems, const bool
static void layerInterp_propfloat2(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -1624,7 +1624,7 @@ static bool layerValidate_propfloat2(void *data, const uint totitems, const bool
static void layerInterp_propbool(const void **sources,
const float *weights,
const float *UNUSED(sub_weights),
const float * /*sub_weights*/,
int count,
void *dest)
{
@ -3163,7 +3163,7 @@ void *CustomData_duplicate_referenced_layer_named(CustomData *data,
}
void *CustomData_duplicate_referenced_layer_anonymous(CustomData *data,
const int UNUSED(type),
const int /*type*/,
const AnonymousAttributeID *anonymous_id,
const int totelem)
{
@ -4594,10 +4594,7 @@ static void customdata_external_filename(char filepath[FILE_MAX],
BLI_path_abs(filepath, ID_BLEND_PATH_FROM_GLOBAL(id));
}
void CustomData_external_reload(CustomData *data,
ID *UNUSED(id),
eCustomDataMask mask,
int totelem)
void CustomData_external_reload(CustomData *data, ID * /*id*/, eCustomDataMask mask, int totelem)
{
for (int i = 0; i < data->totlayer; i++) {
CustomDataLayer *layer = &data->layers[i];
@ -4791,11 +4788,8 @@ void CustomData_external_write(
cdf_free(cdf);
}
void CustomData_external_add(CustomData *data,
ID *UNUSED(id),
const int type,
const int UNUSED(totelem),
const char *filepath)
void CustomData_external_add(
CustomData *data, ID * /*id*/, const int type, const int /*totelem*/, const char *filepath)
{
CustomDataExternal *external = data->external;

View File

@ -290,7 +290,7 @@ void BKE_editmesh_ensure_autosmooth(BMEditMesh *em, Mesh *me)
}
}
BoundBox *BKE_editmesh_cage_boundbox_get(Object *object, BMEditMesh *UNUSED(em))
BoundBox *BKE_editmesh_cage_boundbox_get(Object *object, BMEditMesh * /*em*/)
{
if (object->runtime.editmesh_bb_cage == nullptr) {
float min[3], max[3];

View File

@ -147,7 +147,7 @@ struct SGLSLEditMeshToTangent {
#endif
};
static void emDM_calc_loop_tangents_thread(TaskPool *__restrict UNUSED(pool), void *taskdata)
static void emDM_calc_loop_tangents_thread(TaskPool *__restrict /*pool*/, void *taskdata)
{
SGLSLEditMeshToTangent *mesh_data = static_cast<SGLSLEditMeshToTangent *>(taskdata);

View File

@ -266,7 +266,7 @@ CurveLengthFieldInput::CurveLengthFieldInput()
GVArray CurveLengthFieldInput::get_varray_for_context(const CurvesGeometry &curves,
const eAttrDomain domain,
IndexMask UNUSED(mask)) const
const IndexMask /*mask*/) const
{
return construct_curve_length_gvarray(curves, domain);
}
@ -617,7 +617,7 @@ static AttributeAccessorFunctions get_curves_accessor_functions()
return 0;
}
};
fn.domain_supported = [](const void *UNUSED(owner), const eAttrDomain domain) {
fn.domain_supported = [](const void * /*owner*/, const eAttrDomain domain) {
return ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE);
};
fn.adapt_domain = [](const void *owner,

View File

@ -413,17 +413,17 @@ class InstancePositionAttributeProvider final : public BuiltinAttributeProvider
domain_};
}
bool try_delete(void *UNUSED(owner)) const final
bool try_delete(void * /*owner*/) const final
{
return false;
}
bool try_create(void *UNUSED(owner), const AttributeInit &UNUSED(initializer)) const final
bool try_create(void * /*owner*/, const AttributeInit & /*initializer*/) const final
{
return false;
}
bool exists(const void *UNUSED(owner)) const final
bool exists(const void * /*owner*/) const final
{
return true;
}
@ -487,10 +487,10 @@ static AttributeAccessorFunctions get_instances_accessor_functions()
return 0;
}
};
fn.domain_supported = [](const void *UNUSED(owner), const eAttrDomain domain) {
fn.domain_supported = [](const void * /*owner*/, const eAttrDomain domain) {
return domain == ATTR_DOMAIN_INSTANCE;
};
fn.adapt_domain = [](const void *UNUSED(owner),
fn.adapt_domain = [](const void * /*owner*/,
const blender::GVArray &varray,
const eAttrDomain from_domain,
const eAttrDomain to_domain) {

View File

@ -1132,17 +1132,17 @@ class NormalAttributeProvider final : public BuiltinAttributeProvider {
return VArray<float3>::ForSpan({(float3 *)BKE_mesh_poly_normals_ensure(mesh), mesh->totpoly});
}
GAttributeWriter try_get_for_write(void *UNUSED(owner)) const final
GAttributeWriter try_get_for_write(void * /*owner*/) const final
{
return {};
}
bool try_delete(void *UNUSED(owner)) const final
bool try_delete(void * /*owner*/) const final
{
return false;
}
bool try_create(void *UNUSED(owner), const AttributeInit &UNUSED(initializer)) const final
bool try_create(void * /*owner*/, const AttributeInit & /*initializer*/) const final
{
return false;
}
@ -1312,7 +1312,7 @@ static AttributeAccessorFunctions get_mesh_accessor_functions()
return 0;
}
};
fn.domain_supported = [](const void *UNUSED(owner), const eAttrDomain domain) {
fn.domain_supported = [](const void * /*owner*/, const eAttrDomain domain) {
return ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_EDGE, ATTR_DOMAIN_FACE, ATTR_DOMAIN_CORNER);
};
fn.adapt_domain = [](const void *owner,

View File

@ -180,10 +180,10 @@ static AttributeAccessorFunctions get_pointcloud_accessor_functions()
return 0;
}
};
fn.domain_supported = [](const void *UNUSED(owner), const eAttrDomain domain) {
fn.domain_supported = [](const void * /*owner*/, const eAttrDomain domain) {
return domain == ATTR_DOMAIN_POINT;
};
fn.adapt_domain = [](const void *UNUSED(owner),
fn.adapt_domain = [](const void * /*owner*/,
const blender::GVArray &varray,
const eAttrDomain from_domain,
const eAttrDomain to_domain) {

View File

@ -242,7 +242,7 @@ GVArray InstancesFieldInput::get_varray_for_context(const fn::FieldContext &cont
}
GVArray AttributeFieldInput::get_varray_for_context(const GeometryFieldContext &context,
IndexMask UNUSED(mask)) const
const IndexMask /*mask*/) const
{
const eCustomDataType data_type = cpp_type_to_custom_data_type(*type_);
if (auto attributes = context.attributes()) {

View File

@ -665,7 +665,7 @@ class IDPUnknownSerializer : public IDPropertySerializer {
}
std::shared_ptr<DictionaryValue> idprop_to_dictionary(
const struct IDProperty *UNUSED(id_property)) const override
const struct IDProperty * /*id_property*/) const override
{
BLI_assert_unreachable();
return nullptr;
@ -677,7 +677,7 @@ class IDPUnknownSerializer : public IDPropertySerializer {
}
std::unique_ptr<IDProperty, IDPropertyDeleter> entry_to_idprop(
DictionaryEntryParser &UNUSED(entry_reader)) const override
DictionaryEntryParser & /*entry_reader*/) const override
{
return nullptr;
}

View File

@ -153,7 +153,7 @@ static void image_init_data(ID *id)
}
}
static void image_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
static void image_copy_data(Main * /*bmain*/, ID *id_dst, const ID *id_src, const int flag)
{
Image *image_dst = (Image *)id_dst;
const Image *image_src = (const Image *)id_src;
@ -410,7 +410,7 @@ static void image_blend_read_data(BlendDataReader *reader, ID *id)
image_runtime_reset(ima);
}
static void image_blend_read_lib(BlendLibReader *UNUSED(reader), ID *id)
static void image_blend_read_lib(BlendLibReader * /*reader*/, ID *id)
{
Image *ima = (Image *)id;
/* Images have some kind of 'main' cache, when null we should also clear all others. */
@ -1546,7 +1546,7 @@ void BKE_image_print_memlist(Main *bmain)
}
}
static bool imagecache_check_dirty(ImBuf *ibuf, void *UNUSED(userkey), void *UNUSED(userdata))
static bool imagecache_check_dirty(ImBuf *ibuf, void * /*userkey*/, void * /*userdata*/)
{
if (ibuf == nullptr) {
return false;
@ -1595,7 +1595,7 @@ void BKE_image_free_all_textures(Main *bmain)
#endif
}
static bool imagecache_check_free_anim(ImBuf *ibuf, void *UNUSED(userkey), void *userdata)
static bool imagecache_check_free_anim(ImBuf *ibuf, void * /*userkey*/, void *userdata)
{
if (ibuf == nullptr) {
return true;
@ -2470,7 +2470,7 @@ void BKE_stamp_data_free(StampData *stamp_data)
}
/* wrap for callback only */
static void metadata_set_field(void *data, const char *propname, char *propvalue, int UNUSED(len))
static void metadata_set_field(void *data, const char *propname, char *propvalue, int /*len*/)
{
/* We know it is an ImBuf* because that's what we pass to BKE_stamp_info_callback. */
ImBuf *imbuf = static_cast<ImBuf *>(data);
@ -3876,7 +3876,7 @@ static void image_create_multilayer(Image *ima, ImBuf *ibuf, int framenr)
#endif /* WITH_OPENEXR */
/** Common stuff to do with images after loading. */
static void image_init_after_load(Image *ima, ImageUser *iuser, ImBuf *UNUSED(ibuf))
static void image_init_after_load(Image *ima, ImageUser *iuser, ImBuf * /*ibuf*/)
{
/* Preview is null when it has never been used as an icon before.
* Never handle previews/icons outside of main thread. */
@ -5024,7 +5024,7 @@ void BKE_image_user_frame_calc(Image *ima, ImageUser *iuser, int cfra)
/* goes over all ImageUsers, and sets frame numbers if auto-refresh is set */
static void image_editors_update_frame(Image *ima,
ID *UNUSED(iuser_id),
ID * /*iuser_id*/,
ImageUser *iuser,
void *customdata)
{
@ -5046,8 +5046,8 @@ void BKE_image_editors_update_frame(const Main *bmain, int cfra)
}
static void image_user_id_has_animation(Image *ima,
ID *UNUSED(iuser_id),
ImageUser *UNUSED(iuser),
ID * /*iuser_id*/,
ImageUser * /*iuser*/,
void *customdata)
{
if (ima && BKE_image_is_animated(ima)) {
@ -5066,7 +5066,7 @@ bool BKE_image_user_id_has_animation(ID *id)
}
static void image_user_id_eval_animation(Image *ima,
ID *UNUSED(iduser_id),
ID * /*iduser_id*/,
ImageUser *iuser,
void *customdata)
{
@ -5330,7 +5330,7 @@ bool BKE_image_is_dirty(Image *image)
return BKE_image_is_dirty_writable(image, nullptr);
}
void BKE_image_mark_dirty(Image *UNUSED(image), ImBuf *ibuf)
void BKE_image_mark_dirty(Image * /*image*/, ImBuf *ibuf)
{
ibuf->userflags |= IB_BITMAPDIRTY;
}

View File

@ -221,7 +221,7 @@ const char *BKE_id_remapper_result_string(const IDRemapperApplyResult result)
return "";
}
static void id_remapper_print_item_cb(ID *old_id, ID *new_id, void *UNUSED(user_data))
static void id_remapper_print_item_cb(ID *old_id, ID *new_id, void * /*user_data*/)
{
if (old_id != nullptr && new_id != nullptr) {
printf("Remap %s(%p) to %s(%p)\n", old_id->name, old_id, new_id->name, new_id);

View File

@ -3131,7 +3131,7 @@ bool BKE_lib_override_library_property_operation_operands_validate(
return true;
}
void BKE_lib_override_library_validate(Main *UNUSED(bmain), ID *id, ReportList *reports)
void BKE_lib_override_library_validate(Main * /*bmain*/, ID *id, ReportList *reports)
{
if (id->override_library == nullptr) {
return;
@ -3938,8 +3938,8 @@ ID *BKE_lib_override_library_operations_store_start(Main *bmain,
return storage_id;
}
void BKE_lib_override_library_operations_store_end(
OverrideLibraryStorage *UNUSED(override_storage), ID *local)
void BKE_lib_override_library_operations_store_end(OverrideLibraryStorage * /*override_storage*/,
ID *local)
{
BLI_assert(ID_IS_OVERRIDE_LIBRARY_REAL(local));

View File

@ -65,10 +65,7 @@ static void metaball_init_data(ID *id)
MEMCPY_STRUCT_AFTER(metaball, DNA_struct_default_get(MetaBall), id);
}
static void metaball_copy_data(Main *UNUSED(bmain),
ID *id_dst,
const ID *id_src,
const int UNUSED(flag))
static void metaball_copy_data(Main * /*bmain*/, ID *id_dst, const ID *id_src, const int /*flag*/)
{
MetaBall *metaball_dst = (MetaBall *)id_dst;
const MetaBall *metaball_src = (const MetaBall *)id_src;

View File

@ -604,7 +604,7 @@ void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int ed
}
}
void BKE_mesh_to_curve(Main *bmain, Depsgraph *depsgraph, Scene *UNUSED(scene), Object *ob)
void BKE_mesh_to_curve(Main *bmain, Depsgraph *depsgraph, Scene * /*scene*/, Object *ob)
{
/* make new mesh data from the original copy */
Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
@ -654,7 +654,7 @@ void BKE_pointcloud_from_mesh(Mesh *me, PointCloud *pointcloud)
point_positions.finish();
}
void BKE_mesh_to_pointcloud(Main *bmain, Depsgraph *depsgraph, Scene *UNUSED(scene), Object *ob)
void BKE_mesh_to_pointcloud(Main *bmain, Depsgraph *depsgraph, Scene * /*scene*/, Object *ob)
{
BLI_assert(ob->type == OB_MESH);
@ -710,7 +710,7 @@ void BKE_mesh_edges_set_draw_render(Mesh *mesh)
}
}
void BKE_pointcloud_to_mesh(Main *bmain, Depsgraph *depsgraph, Scene *UNUSED(scene), Object *ob)
void BKE_pointcloud_to_mesh(Main *bmain, Depsgraph *depsgraph, Scene * /*scene*/, Object *ob)
{
BLI_assert(ob->type == OB_POINTCLOUD);

View File

@ -528,7 +528,7 @@ bool BKE_mesh_center_of_volume(const Mesh *me, float r_cent[3])
* \{ */
static bool mesh_calc_center_centroid_ex(const MVert *mverts,
int UNUSED(mverts_num),
int /*mverts_num*/,
const MLoopTri *looptri,
int looptri_num,
const MLoop *mloop,

View File

@ -440,7 +440,7 @@ class VoronoiVertexWeight : public VertexWeight {
class UniformLoopWeight : public LoopWeight {
public:
float weight_at_index(const int UNUSED(index)) override
float weight_at_index(const int /*index*/) override
{
return 1.0f;
}

View File

@ -262,12 +262,12 @@ void BKE_mesh_vert_loop_map_create(MeshElemMap **r_map,
void BKE_mesh_vert_looptri_map_create(MeshElemMap **r_map,
int **r_mem,
const MVert *UNUSED(mvert),
const MVert * /*mvert*/,
const int totvert,
const MLoopTri *mlooptri,
const int totlooptri,
const MLoop *mloop,
const int UNUSED(totloop))
const int /*totloop*/)
{
MeshElemMap *map = MEM_cnew_array<MeshElemMap>(size_t(totvert), __func__);
int *indices = static_cast<int *>(MEM_mallocN(sizeof(int) * size_t(totlooptri) * 3, __func__));
@ -384,7 +384,7 @@ void BKE_mesh_vert_edge_vert_map_create(
void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
int **r_mem,
const MEdge *UNUSED(medge),
const MEdge * /*medge*/,
const int totedge,
const MPoly *mpoly,
const int totpoly,
@ -437,7 +437,7 @@ void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
void BKE_mesh_edge_poly_map_create(MeshElemMap **r_map,
int **r_mem,
const MEdge *UNUSED(medge),
const MEdge * /*medge*/,
const int totedge,
const MPoly *mpoly,
const int totpoly,
@ -802,12 +802,12 @@ static void poly_edge_loop_islands_calc(const MEdge *medge,
}
static bool poly_is_island_boundary_smooth_cb(const MPoly *mp,
const MLoop *UNUSED(ml),
const MLoop * /*ml*/,
const MEdge *me,
const int edge_user_count,
const MPoly *mpoly_array,
const MeshElemMap *edge_poly_map,
void *UNUSED(user_data))
void * /*user_data*/)
{
/* Edge is sharp if one of its polys is flat, or edge itself is sharp,
* or edge is not used by exactly two polygons. */
@ -977,12 +977,12 @@ struct MeshCheckIslandBoundaryUv {
const MeshElemMap *edge_loop_map;
};
static bool mesh_check_island_boundary_uv(const MPoly *UNUSED(mp),
static bool mesh_check_island_boundary_uv(const MPoly * /*mp*/,
const MLoop *ml,
const MEdge *me,
const int UNUSED(edge_user_count),
const MPoly *UNUSED(mpoly_array),
const MeshElemMap *UNUSED(edge_poly_map),
const int /*edge_user_count*/,
const MPoly * /*mpoly_array*/,
const MeshElemMap * /*edge_poly_map*/,
void *user_data)
{
if (user_data) {
@ -1021,8 +1021,8 @@ static bool mesh_check_island_boundary_uv(const MPoly *UNUSED(mp),
return (me->flag & ME_SEAM) != 0;
}
static bool mesh_calc_islands_loop_poly_uv(const MVert *UNUSED(verts),
const int UNUSED(totvert),
static bool mesh_calc_islands_loop_poly_uv(const MVert * /*verts*/,
const int /*totvert*/,
const MEdge *edges,
const int totedge,
const MPoly *polys,

View File

@ -181,7 +181,7 @@ struct MeshCalcNormalsData_Poly {
static void mesh_calc_normals_poly_fn(void *__restrict userdata,
const int pidx,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
const MeshCalcNormalsData_Poly *data = (MeshCalcNormalsData_Poly *)userdata;
const MPoly *mp = &data->mpoly[pidx];
@ -189,9 +189,9 @@ static void mesh_calc_normals_poly_fn(void *__restrict userdata,
}
void BKE_mesh_calc_normals_poly(const MVert *mvert,
int UNUSED(mvert_len),
int /*mvert_len*/,
const MLoop *mloop,
int UNUSED(mloop_len),
int /*mloop_len*/,
const MPoly *mpoly,
int mpoly_len,
float (*r_poly_normals)[3])
@ -231,8 +231,9 @@ struct MeshCalcNormalsData_PolyAndVertex {
float (*vnors)[3];
};
static void mesh_calc_normals_poly_and_vertex_accum_fn(
void *__restrict userdata, const int pidx, const TaskParallelTLS *__restrict UNUSED(tls))
static void mesh_calc_normals_poly_and_vertex_accum_fn(void *__restrict userdata,
const int pidx,
const TaskParallelTLS *__restrict /*tls*/)
{
const MeshCalcNormalsData_PolyAndVertex *data = (MeshCalcNormalsData_PolyAndVertex *)userdata;
const MPoly *mp = &data->mpoly[pidx];
@ -294,7 +295,7 @@ static void mesh_calc_normals_poly_and_vertex_accum_fn(
}
static void mesh_calc_normals_poly_and_vertex_finalize_fn(
void *__restrict userdata, const int vidx, const TaskParallelTLS *__restrict UNUSED(tls))
void *__restrict userdata, const int vidx, const TaskParallelTLS *__restrict /*tls*/)
{
MeshCalcNormalsData_PolyAndVertex *data = (MeshCalcNormalsData_PolyAndVertex *)userdata;
@ -310,7 +311,7 @@ static void mesh_calc_normals_poly_and_vertex_finalize_fn(
void BKE_mesh_calc_normals_poly_and_vertex(const MVert *mvert,
const int mvert_len,
const MLoop *mloop,
const int UNUSED(mloop_len),
const int /*mloop_len*/,
const MPoly *mpoly,
const int mpoly_len,
float (*r_poly_normals)[3],
@ -945,7 +946,7 @@ static void mesh_edges_sharp_tag(LoopSplitTaskDataCommon *data,
}
void BKE_edges_sharp_from_angle_set(const struct MVert *mverts,
const int UNUSED(numVerts),
const int /*numVerts*/,
struct MEdge *medges,
const int numEdges,
const struct MLoop *mloops,
@ -1606,7 +1607,7 @@ static void loop_split_generator(TaskPool *pool, LoopSplitTaskDataCommon *common
void BKE_mesh_normals_loop_split(const MVert *mverts,
const float (*vert_normals)[3],
const int UNUSED(numVerts),
const int /*numVerts*/,
const MEdge *medges,
const int numEdges,
const MLoop *mloops,

View File

@ -78,7 +78,7 @@ void BKE_mesh_runtime_free_data(Mesh *mesh)
mesh_runtime_free_mutexes(mesh);
}
void BKE_mesh_runtime_reset_on_copy(Mesh *mesh, const int UNUSED(flag))
void BKE_mesh_runtime_reset_on_copy(Mesh *mesh, const int /*flag*/)
{
Mesh_Runtime *runtime = &mesh->runtime;

View File

@ -77,12 +77,12 @@ struct BKEMeshToTangent {
};
void BKE_mesh_calc_loop_tangent_single_ex(const MVert *mverts,
const int UNUSED(numVerts),
const int /*numVerts*/,
const MLoop *mloops,
float (*r_looptangent)[4],
const float (*loopnors)[3],
const MLoopUV *loopuvs,
const int UNUSED(numLoops),
const int /*numLoops*/,
const MPoly *mpolys,
const int numPolys,
ReportList *reports)
@ -298,7 +298,7 @@ struct SGLSLMeshToTangent {
#endif
};
static void DM_calc_loop_tangents_thread(TaskPool *__restrict UNUSED(pool), void *taskdata)
static void DM_calc_loop_tangents_thread(TaskPool *__restrict /*pool*/, void *taskdata)
{
SGLSLMeshToTangent *mesh_data = static_cast<SGLSLMeshToTangent *>(taskdata);

View File

@ -263,7 +263,7 @@ static void mesh_calc_tessellation_for_face_with_normal_fn(void *__restrict user
data->poly_normals[index]);
}
static void mesh_calc_tessellation_for_face_free_fn(const void *__restrict UNUSED(userdata),
static void mesh_calc_tessellation_for_face_free_fn(const void *__restrict /*userdata*/,
void *__restrict tls_v)
{
TessellationUserTLS *tls_data = static_cast<TessellationUserTLS *>(tls_v);
@ -275,7 +275,7 @@ static void mesh_calc_tessellation_for_face_free_fn(const void *__restrict UNUSE
static void mesh_recalc_looptri__multi_threaded(const MLoop *mloop,
const MPoly *mpoly,
const MVert *mvert,
int UNUSED(totloop),
int /*totloop*/,
int totpoly,
MLoopTri *mlooptri,
const float (*poly_normals)[3])

View File

@ -1361,13 +1361,13 @@ static int vergedgesort(const void *v1, const void *v2)
/* Create edges based on known verts and faces,
* this function is only used when loading very old blend files */
static void mesh_calc_edges_mdata(const MVert *UNUSED(allvert),
static void mesh_calc_edges_mdata(const MVert * /*allvert*/,
const MFace *allface,
MLoop *allloop,
const MPoly *allpoly,
int UNUSED(totvert),
int /*totvert*/,
int totface,
int UNUSED(totloop),
int /*totloop*/,
int totpoly,
const bool use_old,
MEdge **r_medge,

View File

@ -165,8 +165,8 @@ ModifierData *BKE_modifier_new(int type)
return md;
}
static void modifier_free_data_id_us_cb(void *UNUSED(userData),
Object *UNUSED(ob),
static void modifier_free_data_id_us_cb(void * /*userData*/,
Object * /*ob*/,
ID **idpoin,
int cb_flag)
{
@ -336,7 +336,7 @@ ModifierData *BKE_modifier_copy_ex(const ModifierData *md, int flag)
void BKE_modifier_copydata_generic(const ModifierData *md_src,
ModifierData *md_dst,
const int UNUSED(flag))
const int /*flag*/)
{
const ModifierTypeInfo *mti = BKE_modifier_get_info(ModifierType(md_src->type));
@ -356,8 +356,8 @@ void BKE_modifier_copydata_generic(const ModifierData *md_src,
md_dst->runtime = nullptr;
}
static void modifier_copy_data_id_us_cb(void *UNUSED(userData),
Object *UNUSED(ob),
static void modifier_copy_data_id_us_cb(void * /*userData*/,
Object * /*ob*/,
ID **idpoin,
int cb_flag)
{

View File

@ -118,7 +118,7 @@ static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo);
static void node_socket_copy(bNodeSocket *sock_dst, const bNodeSocket *sock_src, const int flag);
static void free_localized_node_groups(bNodeTree *ntree);
static void node_free_node(bNodeTree *ntree, bNode *node);
static void node_socket_interface_free(bNodeTree *UNUSED(ntree),
static void node_socket_interface_free(bNodeTree * /*ntree*/,
bNodeSocket *sock,
const bool do_id_user);
@ -129,7 +129,7 @@ static void ntree_init_data(ID *id)
ntree_set_typeinfo(ntree, nullptr);
}
static void ntree_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
static void ntree_copy_data(Main * /*bmain*/, ID *id_dst, const ID *id_src, const int flag)
{
bNodeTree *ntree_dst = (bNodeTree *)id_dst;
const bNodeTree *ntree_src = (const bNodeTree *)id_src;
@ -1533,7 +1533,7 @@ static bool unique_identifier_check(void *arg, const char *identifier)
}
static bNodeSocket *make_socket(bNodeTree *ntree,
bNode *UNUSED(node),
bNode * /*node*/,
int in_out,
ListBase *lb,
const char *idname,
@ -1676,7 +1676,7 @@ static bool socket_id_user_decrement(bNodeSocket *sock)
}
void nodeModifySocketType(bNodeTree *ntree,
bNode *UNUSED(node),
bNode * /*node*/,
bNodeSocket *sock,
const char *idname)
{
@ -1895,7 +1895,7 @@ const char *nodeStaticSocketInterfaceType(int type, int subtype)
return nullptr;
}
const char *nodeStaticSocketLabel(int type, int UNUSED(subtype))
const char *nodeStaticSocketLabel(int type, int /*subtype*/)
{
switch (type) {
case SOCK_FLOAT:
@ -2652,7 +2652,7 @@ bNodeTree *ntreeAddTree(Main *bmain, const char *name, const char *idname)
return ntreeAddTree_do(bmain, nullptr, false, name, idname);
}
bNodeTree *ntreeAddTreeEmbedded(Main *UNUSED(bmain),
bNodeTree *ntreeAddTreeEmbedded(Main * /*bmain*/,
ID *owner_id,
const char *name,
const char *idname)
@ -3034,7 +3034,7 @@ void nodeRemoveNode(Main *bmain, bNodeTree *ntree, bNode *node, bool do_id_user)
node_free_node(ntree, node);
}
static void node_socket_interface_free(bNodeTree *UNUSED(ntree),
static void node_socket_interface_free(bNodeTree * /*ntree*/,
bNodeSocket *sock,
const bool do_id_user)
{
@ -3405,7 +3405,7 @@ static void ntree_interface_identifier_base(bNodeTree *ntree, char *base)
}
/* check if the identifier is already in use */
static bool ntree_interface_unique_identifier_check(void *UNUSED(data), const char *identifier)
static bool ntree_interface_unique_identifier_check(void * /*data*/, const char *identifier)
{
return (RNA_struct_find(identifier) != nullptr);
}
@ -3679,7 +3679,7 @@ void nodeSocketDeclarationsUpdate(bNode *node)
update_socket_declarations(&node->outputs, node->runtime->declaration->outputs());
}
bool nodeDeclarationEnsureOnOutdatedNode(bNodeTree *UNUSED(ntree), bNode *node)
bool nodeDeclarationEnsureOnOutdatedNode(bNodeTree * /*ntree*/, bNode *node)
{
if (node->runtime->declaration != nullptr) {
return false;
@ -3978,7 +3978,7 @@ void BKE_node_instance_hash_clear_tags(bNodeInstanceHash *hash)
}
}
void BKE_node_instance_hash_tag(bNodeInstanceHash *UNUSED(hash), void *value)
void BKE_node_instance_hash_tag(bNodeInstanceHash * /*hash*/, void *value)
{
bNodeInstanceHashEntry *entry = (bNodeInstanceHashEntry *)value;
entry->tag = 1;
@ -4184,9 +4184,9 @@ static void node_type_base_defaults(bNodeType *ntype)
}
/* allow this node for any tree type */
static bool node_poll_default(bNodeType *UNUSED(ntype),
bNodeTree *UNUSED(ntree),
const char **UNUSED(disabled_hint))
static bool node_poll_default(bNodeType * /*ntype*/,
bNodeTree * /*ntree*/,
const char ** /*disabled_hint*/)
{
return true;
}
@ -4392,9 +4392,9 @@ void node_type_gpu(struct bNodeType *ntype, NodeGPUExecFunction gpu_fn)
/* callbacks for undefined types */
static bool node_undefined_poll(bNodeType *UNUSED(ntype),
bNodeTree *UNUSED(nodetree),
const char **UNUSED(r_disabled_hint))
static bool node_undefined_poll(bNodeType * /*ntype*/,
bNodeTree * /*nodetree*/,
const char ** /*r_disabled_hint*/)
{
/* this type can not be added deliberately, it's just a placeholder */
return false;

View File

@ -1679,12 +1679,12 @@ void BKE_ntree_update_tag_link_removed(bNodeTree *ntree)
add_tree_tag(ntree, NTREE_CHANGED_LINK);
}
void BKE_ntree_update_tag_link_added(bNodeTree *ntree, bNodeLink *UNUSED(link))
void BKE_ntree_update_tag_link_added(bNodeTree *ntree, bNodeLink * /*link*/)
{
add_tree_tag(ntree, NTREE_CHANGED_LINK);
}
void BKE_ntree_update_tag_link_mute(bNodeTree *ntree, bNodeLink *UNUSED(link))
void BKE_ntree_update_tag_link_mute(bNodeTree *ntree, bNodeLink * /*link*/)
{
add_tree_tag(ntree, NTREE_CHANGED_LINK);
}
@ -1717,7 +1717,7 @@ void BKE_ntree_update_tag_id_changed(Main *bmain, ID *id)
FOREACH_NODETREE_END;
}
void BKE_ntree_update_tag_image_user_changed(bNodeTree *ntree, ImageUser *UNUSED(iuser))
void BKE_ntree_update_tag_image_user_changed(bNodeTree *ntree, ImageUser * /*iuser*/)
{
/* Would have to search for the node that uses the image user for a more detailed tag. */
add_tree_tag(ntree, NTREE_CHANGED_ANY);

View File

@ -321,7 +321,7 @@ static void object_free_data(ID *id)
}
static void library_foreach_modifiersForeachIDLink(void *user_data,
Object *UNUSED(object),
Object * /*object*/,
ID **id_pointer,
int cb_flag)
{
@ -331,7 +331,7 @@ static void library_foreach_modifiersForeachIDLink(void *user_data,
}
static void library_foreach_gpencil_modifiersForeachIDLink(void *user_data,
Object *UNUSED(object),
Object * /*object*/,
ID **id_pointer,
int cb_flag)
{
@ -341,7 +341,7 @@ static void library_foreach_gpencil_modifiersForeachIDLink(void *user_data,
}
static void library_foreach_shaderfxForeachIDLink(void *user_data,
Object *UNUSED(object),
Object * /*object*/,
ID **id_pointer,
int cb_flag)
{
@ -350,7 +350,7 @@ static void library_foreach_shaderfxForeachIDLink(void *user_data,
data, BKE_lib_query_foreachid_process(data, id_pointer, cb_flag));
}
static void library_foreach_constraintObjectLooper(bConstraint *UNUSED(con),
static void library_foreach_constraintObjectLooper(bConstraint * /*con*/,
ID **id_pointer,
bool is_reference,
void *user_data)
@ -361,7 +361,7 @@ static void library_foreach_constraintObjectLooper(bConstraint *UNUSED(con),
data, BKE_lib_query_foreachid_process(data, id_pointer, cb_flag));
}
static void library_foreach_particlesystemsObjectLooper(ParticleSystem *UNUSED(psys),
static void library_foreach_particlesystemsObjectLooper(ParticleSystem * /*psys*/,
ID **id_pointer,
void *user_data,
int cb_flag)
@ -1017,9 +1017,9 @@ static void expand_constraint_channels(BlendExpander *expander, ListBase *chanba
}
static void expand_object_expandModifiers(void *userData,
Object *UNUSED(ob),
Object * /*ob*/,
ID **idpoin,
int UNUSED(cb_flag))
int /*cb_flag*/)
{
BlendExpander *expander = (BlendExpander *)userData;
BLO_expand(expander, *idpoin);
@ -4126,8 +4126,8 @@ struct GPencilStrokePointIterData {
void *user_data;
};
static void foreach_display_point_gpencil_stroke_fn(bGPDlayer *UNUSED(layer),
bGPDframe *UNUSED(frame),
static void foreach_display_point_gpencil_stroke_fn(bGPDlayer * /*layer*/,
bGPDframe * /*frame*/,
bGPDstroke *stroke,
void *thunk)
{
@ -5098,7 +5098,7 @@ void BKE_object_runtime_reset(Object *object)
memset(&object->runtime, 0, sizeof(object->runtime));
}
void BKE_object_runtime_reset_on_copy(Object *object, const int UNUSED(flag))
void BKE_object_runtime_reset_on_copy(Object *object, const int /*flag*/)
{
Object_Runtime *runtime = &object->runtime;
runtime->data_eval = nullptr;

View File

@ -278,7 +278,7 @@ void BKE_object_sync_to_original(Depsgraph *depsgraph, Object *object)
object_sync_boundbox_to_original(object_orig, object);
}
void BKE_object_eval_uber_transform(Depsgraph *UNUSED(depsgraph), Object *UNUSED(object))
void BKE_object_eval_uber_transform(Depsgraph * /*depsgraph*/, Object * /*object*/)
{
}

View File

@ -89,10 +89,7 @@ static void palette_init_data(ID *id)
id_fake_user_set(&palette->id);
}
static void palette_copy_data(Main *UNUSED(bmain),
ID *id_dst,
const ID *id_src,
const int UNUSED(flag))
static void palette_copy_data(Main * /*bmain*/, ID *id_dst, const ID *id_src, const int /*flag*/)
{
Palette *palette_dst = (Palette *)id_dst;
const Palette *palette_src = (const Palette *)id_src;
@ -123,7 +120,7 @@ static void palette_blend_read_data(BlendDataReader *reader, ID *id)
BLO_read_list(reader, &palette->colors);
}
static void palette_undo_preserve(BlendLibReader *UNUSED(reader), ID *id_new, ID *id_old)
static void palette_undo_preserve(BlendLibReader * /*reader*/, ID *id_new, ID *id_old)
{
/* Whole Palette is preserved across undo-steps, and it has no extra pointer, simple. */
/* NOTE: We do not care about potential internal references to self here, Palette has none. */
@ -163,10 +160,10 @@ IDTypeInfo IDType_ID_PAL = {
/* lib_override_apply_post */ nullptr,
};
static void paint_curve_copy_data(Main *UNUSED(bmain),
static void paint_curve_copy_data(Main * /*bmain*/,
ID *id_dst,
const ID *id_src,
const int UNUSED(flag))
const int /*flag*/)
{
PaintCurve *paint_curve_dst = (PaintCurve *)id_dst;
const PaintCurve *paint_curve_src = (const PaintCurve *)id_src;
@ -2306,7 +2303,7 @@ void BKE_sculpt_bvh_update_from_ccg(PBVH *pbvh, SubdivCCG *subdiv_ccg)
subdiv_ccg->grid_hidden);
}
bool BKE_sculptsession_use_pbvh_draw(const Object *ob, const View3D *UNUSED(v3d))
bool BKE_sculptsession_use_pbvh_draw(const Object *ob, const View3D * /*v3d*/)
{
SculptSession *ss = ob->sculpt;
if (ss == nullptr || ss->pbvh == nullptr || ss->mode_type != OB_MODE_SCULPT) {

View File

@ -114,7 +114,7 @@ struct EncodePixelsUserData {
static void do_encode_pixels(void *__restrict userdata,
const int n,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
EncodePixelsUserData *data = static_cast<EncodePixelsUserData *>(userdata);
Image *image = data->image;

View File

@ -70,7 +70,7 @@ static void pointcloud_init_data(ID *id)
POINTCLOUD_ATTR_POSITION);
}
static void pointcloud_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
static void pointcloud_copy_data(Main * /*bmain*/, ID *id_dst, const ID *id_src, const int flag)
{
PointCloud *pointcloud_dst = (PointCloud *)id_dst;
const PointCloud *pointcloud_src = (const PointCloud *)id_src;
@ -339,7 +339,7 @@ BoundBox *BKE_pointcloud_boundbox_get(Object *ob)
return ob->runtime.bb;
}
bool BKE_pointcloud_attribute_required(const PointCloud *UNUSED(pointcloud), const char *name)
bool BKE_pointcloud_attribute_required(const PointCloud * /*pointcloud*/, const char *name)
{
return STREQ(name, POINTCLOUD_ATTR_POSITION);
}

View File

@ -457,7 +457,7 @@ static void scene_free_data(ID *id)
BLI_assert(scene->layer_properties == nullptr);
}
static void scene_foreach_rigidbodyworldSceneLooper(struct RigidBodyWorld *UNUSED(rbw),
static void scene_foreach_rigidbodyworldSceneLooper(struct RigidBodyWorld * /*rbw*/,
ID **id_pointer,
void *user_data,
int cb_flag)
@ -1691,7 +1691,7 @@ static void scene_undo_preserve(BlendLibReader *reader, ID *id_new, ID *id_old)
}
}
static void scene_lib_override_apply_post(ID *id_dst, ID *UNUSED(id_src))
static void scene_lib_override_apply_post(ID *id_dst, ID * /*id_src*/)
{
Scene *scene = (Scene *)id_dst;
@ -2637,7 +2637,7 @@ void BKE_scene_update_sound(Depsgraph *depsgraph, Main *bmain)
BKE_sound_update_scene(depsgraph, scene);
}
void BKE_scene_update_tag_audio_volume(Depsgraph *UNUSED(depsgraph), Scene *scene)
void BKE_scene_update_tag_audio_volume(Depsgraph * /*depsgraph*/, Scene *scene)
{
BLI_assert(DEG_is_evaluated_id(&scene->id));
/* The volume is actually updated in BKE_scene_update_sound(), from either

View File

@ -167,8 +167,8 @@ void *BKE_simulation_add(Main *bmain, const char *name)
return simulation;
}
void BKE_simulation_data_update(Depsgraph *UNUSED(depsgraph),
Scene *UNUSED(scene),
Simulation *UNUSED(simulation))
void BKE_simulation_data_update(Depsgraph * /*depsgraph*/,
Scene * /*scene*/,
Simulation * /*simulation*/)
{
}

View File

@ -514,7 +514,7 @@ static bool subdiv_mesh_topology_info(const SubdivForeachContext *foreach_contex
const int num_edges,
const int num_loops,
const int num_polygons,
const int *UNUSED(subdiv_polygon_offset))
const int * /*subdiv_polygon_offset*/)
{
/* Multi-resolution grid data will be applied or become invalid after subdivision,
* so don't try to preserve it and use memory. Crease values should also not be interpolated. */
@ -626,7 +626,7 @@ static void evaluate_vertex_and_apply_displacement_interpolate(
static void subdiv_mesh_vertex_displacement_every_corner_or_edge(
const SubdivForeachContext *foreach_context,
void *UNUSED(tls),
void * /*tls*/,
const int ptex_face_index,
const float u,
const float v,
@ -643,9 +643,9 @@ static void subdiv_mesh_vertex_displacement_every_corner(
const int ptex_face_index,
const float u,
const float v,
const int UNUSED(coarse_vertex_index),
const int UNUSED(coarse_poly_index),
const int UNUSED(coarse_corner),
const int /*coarse_vertex_index*/,
const int /*coarse_poly_index*/,
const int /*coarse_corner*/,
const int subdiv_vertex_index)
{
subdiv_mesh_vertex_displacement_every_corner_or_edge(
@ -657,9 +657,9 @@ static void subdiv_mesh_vertex_displacement_every_edge(const SubdivForeachContex
const int ptex_face_index,
const float u,
const float v,
const int UNUSED(coarse_edge_index),
const int UNUSED(coarse_poly_index),
const int UNUSED(coarse_corner),
const int /*coarse_edge_index*/,
const int /*coarse_poly_index*/,
const int /*coarse_corner*/,
const int subdiv_vertex_index)
{
subdiv_mesh_vertex_displacement_every_corner_or_edge(
@ -667,13 +667,13 @@ static void subdiv_mesh_vertex_displacement_every_edge(const SubdivForeachContex
}
static void subdiv_mesh_vertex_corner(const SubdivForeachContext *foreach_context,
void *UNUSED(tls),
void * /*tls*/,
const int ptex_face_index,
const float u,
const float v,
const int coarse_vertex_index,
const int UNUSED(coarse_poly_index),
const int UNUSED(coarse_corner),
const int /*coarse_poly_index*/,
const int /*coarse_corner*/,
const int subdiv_vertex_index)
{
BLI_assert(coarse_vertex_index != ORIGINDEX_NONE);
@ -717,7 +717,7 @@ static void subdiv_mesh_vertex_edge(const SubdivForeachContext *foreach_context,
const int ptex_face_index,
const float u,
const float v,
const int UNUSED(coarse_edge_index),
const int /*coarse_edge_index*/,
const int coarse_poly_index,
const int coarse_corner,
const int subdiv_vertex_index)
@ -808,10 +808,10 @@ static void subdiv_copy_edge_data(SubdivMeshContext *ctx,
}
static void subdiv_mesh_edge(const SubdivForeachContext *foreach_context,
void *UNUSED(tls),
void * /*tls*/,
const int coarse_edge_index,
const int subdiv_edge_index,
const bool UNUSED(is_loose),
const bool /*is_loose*/,
const int subdiv_v1,
const int subdiv_v2)
{
@ -902,7 +902,7 @@ static void subdiv_mesh_loop(const SubdivForeachContext *foreach_context,
const int ptex_face_index,
const float u,
const float v,
const int UNUSED(coarse_loop_index),
const int /*coarse_loop_index*/,
const int coarse_poly_index,
const int coarse_corner,
const int subdiv_loop_index,
@ -938,7 +938,7 @@ static void subdiv_copy_poly_data(const SubdivMeshContext *ctx,
}
static void subdiv_mesh_poly(const SubdivForeachContext *foreach_context,
void *UNUSED(tls),
void * /*tls*/,
const int coarse_poly_index,
const int subdiv_poly_index,
const int start_loop_index,
@ -960,7 +960,7 @@ static void subdiv_mesh_poly(const SubdivForeachContext *foreach_context,
* \{ */
static void subdiv_mesh_vertex_loose(const SubdivForeachContext *foreach_context,
void *UNUSED(tls),
void * /*tls*/,
const int coarse_vertex_index,
const int subdiv_vertex_index)
{
@ -1098,7 +1098,7 @@ static void subdiv_mesh_vertex_of_loose_edge_interpolate(SubdivMeshContext *ctx,
}
static void subdiv_mesh_vertex_of_loose_edge(const SubdivForeachContext *foreach_context,
void *UNUSED(tls),
void * /*tls*/,
const int coarse_edge_index,
const float u,
const int subdiv_vertex_index)

View File

@ -363,7 +363,7 @@ struct VolumeGrid {
is_loaded = false;
}
void clear_reference(const char *UNUSED(volume_name))
void clear_reference(const char * /*volume_name*/)
{
/* Clear any reference to a grid in the file cache. */
local_grid = grid()->copyGridWithNewTree();
@ -515,10 +515,7 @@ static void volume_init_data(ID *id)
BLI_strncpy(volume->velocity_grid, "velocity", sizeof(volume->velocity_grid));
}
static void volume_copy_data(Main *UNUSED(bmain),
ID *id_dst,
const ID *id_src,
const int UNUSED(flag))
static void volume_copy_data(Main * /*bmain*/, ID *id_dst, const ID *id_src, const int /*flag*/)
{
Volume *volume_dst = (Volume *)id_dst;
const Volume *volume_src = (const Volume *)id_src;

View File

@ -63,7 +63,7 @@ class RawAllocator {
};
public:
void *allocate(size_t size, size_t alignment, const char *UNUSED(name))
void *allocate(size_t size, size_t alignment, const char * /*name*/)
{
BLI_assert(is_power_of_2_i(int(alignment)));
void *ptr = malloc(size + alignment + sizeof(MemHead));

View File

@ -78,7 +78,7 @@ class GVMutableArrayImpl : public GVArrayImpl {
namespace detail {
struct GVArrayAnyExtraInfo {
const GVArrayImpl *(*get_varray)(const void *buffer) =
[](const void *UNUSED(buffer)) -> const GVArrayImpl * { return nullptr; };
[](const void * /*buffer*/) -> const GVArrayImpl * { return nullptr; };
template<typename StorageT> static constexpr GVArrayAnyExtraInfo get();
};

View File

@ -133,8 +133,8 @@ class GVVectorArray_For_SingleGSpan : public GVVectorArray {
}
protected:
int64_t get_vector_size_impl(int64_t UNUSED(index)) const override;
void get_vector_element_impl(int64_t UNUSED(index),
int64_t get_vector_size_impl(int64_t /*index*/) const override;
void get_vector_element_impl(int64_t /*index*/,
int64_t index_in_vector,
void *r_value) const override;

View File

@ -1332,7 +1332,7 @@ template<typename Key, typename Value> class StdUnorderedMapWrapper {
map_.clear();
}
void print_stats(StringRef UNUSED(name) = "") const
void print_stats(StringRef /*name*/ = "") const
{
}
};

View File

@ -169,7 +169,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
* key. The hash can be used by other slot implementations to determine inequality faster.
*/
template<typename ForwardKey, typename IsEqual>
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint64_t UNUSED(hash)) const
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint64_t /*hash*/) const
{
if (state_ == Occupied) {
return is_equal(key, *key_buffer_);
@ -194,7 +194,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
* Change the state of this slot from empty/removed to occupied. The value is assumed to be
* constructed already.
*/
template<typename ForwardKey> void occupy_no_value(ForwardKey &&key, uint64_t UNUSED(hash))
template<typename ForwardKey> void occupy_no_value(ForwardKey &&key, uint64_t /*hash*/)
{
BLI_assert(!this->is_occupied());
try {
@ -295,7 +295,7 @@ template<typename Key, typename Value, typename KeyInfo> class IntrusiveMapSlot
}
template<typename ForwardKey, typename IsEqual>
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint64_t UNUSED(hash)) const
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint64_t /*hash*/) const
{
BLI_assert(KeyInfo::is_not_empty_or_removed(key));
return is_equal(key, key_);
@ -310,7 +310,7 @@ template<typename Key, typename Value, typename KeyInfo> class IntrusiveMapSlot
this->occupy_no_value(std::forward<ForwardKey>(key), hash);
}
template<typename ForwardKey> void occupy_no_value(ForwardKey &&key, uint64_t UNUSED(hash))
template<typename ForwardKey> void occupy_no_value(ForwardKey &&key, uint64_t /*hash*/)
{
BLI_assert(!this->is_occupied());
BLI_assert(KeyInfo::is_not_empty_or_removed(key));

View File

@ -129,7 +129,7 @@ template<typename Key> class SimpleSetSlot {
* key. The hash is used by other slot implementations to determine inequality faster.
*/
template<typename ForwardKey, typename IsEqual>
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint64_t UNUSED(hash)) const
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint64_t /*hash*/) const
{
if (state_ == Occupied) {
return is_equal(key, *key_buffer_);
@ -141,7 +141,7 @@ template<typename Key> class SimpleSetSlot {
* Change the state of this slot from empty/removed to occupied. The key has to be constructed
* by calling the constructor with the given key as parameter.
*/
template<typename ForwardKey> void occupy(ForwardKey &&key, uint64_t UNUSED(hash))
template<typename ForwardKey> void occupy(ForwardKey &&key, uint64_t /*hash*/)
{
BLI_assert(!this->is_occupied());
new (&key_buffer_) Key(std::forward<ForwardKey>(key));
@ -226,7 +226,7 @@ template<typename Key> class HashedSetSlot {
return state_ == Empty;
}
template<typename Hash> uint64_t get_hash(const Hash &UNUSED(hash)) const
template<typename Hash> uint64_t get_hash(const Hash & /*hash*/) const
{
BLI_assert(this->is_occupied());
return hash_;
@ -306,13 +306,13 @@ template<typename Key, typename KeyInfo> class IntrusiveSetSlot {
}
template<typename ForwardKey, typename IsEqual>
bool contains(const ForwardKey &key, const IsEqual &is_equal, const uint64_t UNUSED(hash)) const
bool contains(const ForwardKey &key, const IsEqual &is_equal, const uint64_t /*hash*/) const
{
BLI_assert(KeyInfo::is_not_empty_or_removed(key));
return is_equal(key_, key);
}
template<typename ForwardKey> void occupy(ForwardKey &&key, const uint64_t UNUSED(hash))
template<typename ForwardKey> void occupy(ForwardKey &&key, const uint64_t /*hash*/)
{
BLI_assert(!this->is_occupied());
BLI_assert(KeyInfo::is_not_empty_or_removed(key));

View File

@ -73,7 +73,7 @@ template<typename Key> class SimpleVectorSetSlot {
template<typename ForwardKey, typename IsEqual>
bool contains(const ForwardKey &key,
const IsEqual &is_equal,
uint64_t UNUSED(hash),
uint64_t /*hash*/,
const Key *keys) const
{
if (state_ >= 0) {
@ -86,7 +86,7 @@ template<typename Key> class SimpleVectorSetSlot {
* Change the state of this slot from empty/removed to occupied. The hash can be used by other
* slot implementations.
*/
void occupy(int64_t index, uint64_t UNUSED(hash))
void occupy(int64_t index, uint64_t /*hash*/)
{
BLI_assert(!this->is_occupied());
state_ = index;

View File

@ -155,7 +155,7 @@ template<typename T> class VArrayImpl {
* arrays in all cases.
* Return true when the virtual array was assigned and false when nothing was done.
*/
virtual bool try_assign_GVArray(GVArray &UNUSED(varray)) const
virtual bool try_assign_GVArray(GVArray & /*varray*/) const
{
return false;
}
@ -164,7 +164,7 @@ template<typename T> class VArrayImpl {
* Return true when the other virtual array should be considered to be the same, e.g. because it
* shares the same underlying memory.
*/
virtual bool is_same(const VArrayImpl<T> &UNUSED(other)) const
virtual bool is_same(const VArrayImpl<T> & /*other*/) const
{
return false;
}
@ -201,7 +201,7 @@ template<typename T> class VMutableArrayImpl : public VArrayImpl<T> {
/**
* Similar to #VArrayImpl::try_assign_GVArray but for mutable virtual arrays.
*/
virtual bool try_assign_GVMutableArray(GVMutableArray &UNUSED(varray)) const
virtual bool try_assign_GVMutableArray(GVMutableArray & /*varray*/) const
{
return false;
}
@ -346,7 +346,7 @@ template<typename T> class VArrayImpl_For_Single final : public VArrayImpl<T> {
}
protected:
T get(const int64_t UNUSED(index)) const override
T get(const int64_t /*index*/) const override
{
return value_;
}

View File

@ -45,7 +45,7 @@ template<> double math_abs<double>(const double v)
return fabs(v);
}
template<typename T> double math_to_double(const T UNUSED(v))
template<typename T> double math_to_double(const T /*v*/)
{
BLI_assert(false); /* Need implementation for other type. */
return 0.0;
@ -2645,7 +2645,7 @@ void prepare_cdt_for_output(CDT_state<T> *cdt_state, const CDT_output_type outpu
template<typename T>
CDT_result<T> get_cdt_output(CDT_state<T> *cdt_state,
const CDT_input<T> UNUSED(input),
const CDT_input<T> /*input*/,
CDT_output_type output_type)
{
CDT_output_type oty = output_type;

View File

@ -51,7 +51,7 @@ CommonVArrayInfo GVArrayImpl::common_info() const
return {};
}
bool GVArrayImpl::try_assign_VArray(void *UNUSED(varray)) const
bool GVArrayImpl::try_assign_VArray(void * /*varray*/) const
{
return false;
}
@ -102,7 +102,7 @@ void GVMutableArray::fill(const void *value)
}
}
bool GVMutableArrayImpl::try_assign_VMutableArray(void *UNUSED(varray)) const
bool GVMutableArrayImpl::try_assign_VMutableArray(void * /*varray*/) const
{
return false;
}
@ -172,11 +172,11 @@ void GVArrayImpl_For_GSpan::materialize_compressed_to_uninitialized(const IndexM
/* Generic virtual array where each element has the same value. The value is not owned. */
void GVArrayImpl_For_SingleValueRef::get(const int64_t UNUSED(index), void *r_value) const
void GVArrayImpl_For_SingleValueRef::get(const int64_t /*index*/, void *r_value) const
{
type_->copy_assign(value_, r_value);
}
void GVArrayImpl_For_SingleValueRef::get_to_uninitialized(const int64_t UNUSED(index),
void GVArrayImpl_For_SingleValueRef::get_to_uninitialized(const int64_t /*index*/,
void *r_value) const
{
type_->copy_construct(value_, r_value);
@ -261,11 +261,11 @@ template<int BufferSize> class GVArrayImpl_For_SmallTrivialSingleValue : public
}
private:
void get(const int64_t UNUSED(index), void *r_value) const override
void get(const int64_t /*index*/, void *r_value) const override
{
this->copy_value_to(r_value);
}
void get_to_uninitialized(const int64_t UNUSED(index), void *r_value) const override
void get_to_uninitialized(const int64_t /*index*/, void *r_value) const override
{
this->copy_value_to(r_value);
}

View File

@ -16,12 +16,12 @@ void GVArray_For_GVVectorArrayIndex::get_to_uninitialized(const int64_t index_in
vector_array_.get_vector_element(index_, index_in_vector, r_value);
}
int64_t GVVectorArray_For_SingleGVArray::get_vector_size_impl(const int64_t UNUSED(index)) const
int64_t GVVectorArray_For_SingleGVArray::get_vector_size_impl(const int64_t /*index*/) const
{
return varray_.size();
}
void GVVectorArray_For_SingleGVArray::get_vector_element_impl(const int64_t UNUSED(index),
void GVVectorArray_For_SingleGVArray::get_vector_element_impl(const int64_t /*index*/,
const int64_t index_in_vector,
void *r_value) const
{
@ -33,12 +33,12 @@ bool GVVectorArray_For_SingleGVArray::is_single_vector_impl() const
return true;
}
int64_t GVVectorArray_For_SingleGSpan::get_vector_size_impl(const int64_t UNUSED(index)) const
int64_t GVVectorArray_For_SingleGSpan::get_vector_size_impl(const int64_t /*index*/) const
{
return span_.size();
}
void GVVectorArray_For_SingleGSpan::get_vector_element_impl(const int64_t UNUSED(index),
void GVVectorArray_For_SingleGSpan::get_vector_element_impl(const int64_t /*index*/,
const int64_t index_in_vector,
void *r_value) const
{

View File

@ -2527,7 +2527,7 @@ class InsideShapeTestData {
static void inside_shape_callback(void *userdata,
int index,
const BVHTreeRay *ray,
BVHTreeRayHit *UNUSED(hit))
BVHTreeRayHit * /*hit*/)
{
const int dbg_level = 0;
if (dbg_level > 0) {

View File

@ -829,13 +829,13 @@ struct BBPadData {
static void pad_face_bb_range_func(void *__restrict userdata,
const int iter,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
BBPadData *pad_data = static_cast<BBPadData *>(userdata);
(*pad_data->face_bounding_box)[iter].expand(pad_data->pad);
}
static void calc_face_bb_reduce(const void *__restrict UNUSED(userdata),
static void calc_face_bb_reduce(const void *__restrict /*userdata*/,
void *__restrict chunk_join,
void *__restrict chunk)
{
@ -2451,7 +2451,7 @@ class TriOverlaps {
}
private:
static bool only_different_shapes(void *userdata, int index_a, int index_b, int UNUSED(thread))
static bool only_different_shapes(void *userdata, int index_a, int index_b, int /*thread*/)
{
CBData *cbdata = static_cast<CBData *>(userdata);
return cbdata->tm.face(index_a)->orig != cbdata->tm.face(index_b)->orig;
@ -2487,7 +2487,7 @@ static std::pair<int, int> canon_int_pair(int a, int b)
static void calc_overlap_itts_range_func(void *__restrict userdata,
const int iter,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
constexpr int dbg_level = 0;
OverlapIttsData *data = static_cast<OverlapIttsData *>(userdata);
@ -2682,7 +2682,7 @@ static CDT_data calc_cluster_subdivided(const CoplanarClusterInfo &clinfo,
const IMesh &tm,
const TriOverlaps &ov,
const Map<std::pair<int, int>, ITT_value> &itt_map,
IMeshArena *UNUSED(arena))
IMeshArena * /*arena*/)
{
constexpr int dbg_level = 0;
BLI_assert(c < clinfo.tot_cluster());
@ -2889,7 +2889,7 @@ static void degenerate_range_func(void *__restrict userdata,
chunk_data->has_degenerate_tri |= is_degenerate;
}
static void degenerate_reduce(const void *__restrict UNUSED(userdata),
static void degenerate_reduce(const void *__restrict /*userdata*/,
void *__restrict chunk_join,
void *__restrict chunk)
{
@ -2931,7 +2931,7 @@ static IMesh remove_degenerate_tris(const IMesh &tm_in)
IMesh trimesh_self_intersect(const IMesh &tm_in, IMeshArena *arena)
{
return trimesh_nary_intersect(
tm_in, 1, [](int UNUSED(t)) { return 0; }, true, arena);
tm_in, 1, [](int /*t*/) { return 0; }, true, arena);
}
IMesh trimesh_nary_intersect(const IMesh &tm_in,

View File

@ -75,7 +75,7 @@ struct TaskNode {
}
#ifdef WITH_TBB
tbb::flow::continue_msg run(const tbb::flow::continue_msg UNUSED(input))
tbb::flow::continue_msg run(const tbb::flow::continue_msg /*input*/)
{
run_func(task_data);
return tbb::flow::continue_msg();

View File

@ -132,7 +132,7 @@ void BLI_task_parallel_range(const int start,
}
}
int BLI_task_parallel_thread_id(const TaskParallelTLS *UNUSED(tls))
int BLI_task_parallel_thread_id(const TaskParallelTLS * /*tls*/)
{
#ifdef WITH_TBB
/* Get a unique thread ID for texture nodes. In the future we should get rid

View File

@ -63,7 +63,7 @@ struct TestType {
return stream;
}
friend bool operator==(const TestType &UNUSED(a), const TestType &UNUSED(b))
friend bool operator==(const TestType & /*a*/, const TestType & /*b*/)
{
return false;
}

View File

@ -110,7 +110,7 @@ static int get_orig_index(const Array<Vector<int>> &out_to_orig, int orig_index)
return -1;
}
template<typename T> static double math_to_double(const T UNUSED(v))
template<typename T> static double math_to_double(const T /*v*/)
{
BLI_assert(false); /* Need implementation for other type. */
return 0.0;

View File

@ -560,8 +560,8 @@ TEST(map, PopExceptions)
TEST(map, AddOrModifyExceptions)
{
Map<ExceptionThrower, ExceptionThrower> map;
auto create_fn = [](ExceptionThrower *UNUSED(v)) { throw std::runtime_error(""); };
auto modify_fn = [](ExceptionThrower *UNUSED(v)) {};
auto create_fn = [](ExceptionThrower * /*v*/) { throw std::runtime_error(""); };
auto modify_fn = [](ExceptionThrower * /*v*/) {};
EXPECT_ANY_THROW({ map.add_or_modify(3, create_fn, modify_fn); });
}

View File

@ -20,7 +20,7 @@ struct MyValue {
alive++;
}
MyValue(const MyValue &UNUSED(other))
MyValue(const MyValue & /*other*/)
{
if (alive == 15) {
throw std::exception();

View File

@ -106,7 +106,7 @@ class IMeshBuilder {
}
};
static int all_shape_zero(int UNUSED(t))
static int all_shape_zero(int /*t*/)
{
return 0;
}

View File

@ -27,7 +27,7 @@ static void task_range_iter_func(void *userdata, int index, const TaskParallelTL
// printf("%d, %d, %d\n", index, data[index], *((int *)tls->userdata_chunk));
}
static void task_range_iter_reduce_func(const void *__restrict UNUSED(userdata),
static void task_range_iter_reduce_func(const void *__restrict /*userdata*/,
void *__restrict join_v,
void *__restrict userdata_chunk)
{
@ -71,7 +71,7 @@ TEST(task, RangeIter)
static void task_mempool_iter_func(void *userdata,
MempoolIterData *item,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
int *data = (int *)item;
int *count = (int *)userdata;
@ -147,7 +147,7 @@ using TaskMemPool_Chunk = struct TaskMemPool_Chunk {
ListBase *accumulate_items;
};
static void task_mempool_iter_tls_func(void *UNUSED(userdata),
static void task_mempool_iter_tls_func(void * /*userdata*/,
MempoolIterData *item,
const TaskParallelTLS *__restrict tls)
{
@ -165,7 +165,7 @@ static void task_mempool_iter_tls_func(void *UNUSED(userdata),
BLI_addtail(task_data->accumulate_items, BLI_genericNodeN(data));
}
static void task_mempool_iter_tls_reduce(const void *__restrict UNUSED(userdata),
static void task_mempool_iter_tls_reduce(const void *__restrict /*userdata*/,
void *__restrict chunk_join,
void *__restrict chunk)
{
@ -180,8 +180,7 @@ static void task_mempool_iter_tls_reduce(const void *__restrict UNUSED(userdata)
}
}
static void task_mempool_iter_tls_free(const void *UNUSED(userdata),
void *__restrict userdata_chunk)
static void task_mempool_iter_tls_free(const void * /*userdata*/, void *__restrict userdata_chunk)
{
TaskMemPool_Chunk *task_data = (TaskMemPool_Chunk *)userdata_chunk;
MEM_freeN(task_data->accumulate_items);
@ -240,7 +239,7 @@ TEST(task, MempoolIterTLS)
static void task_listbase_iter_func(void *userdata,
void *item,
int index,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
LinkData *data = (LinkData *)item;
int *count = (int *)userdata;

View File

@ -506,11 +506,11 @@ class TypeConstructMock {
{
}
TypeConstructMock(const TypeConstructMock &UNUSED(other)) : copy_constructed(true)
TypeConstructMock(const TypeConstructMock & /*other*/) : copy_constructed(true)
{
}
TypeConstructMock(TypeConstructMock &&UNUSED(other)) noexcept : move_constructed(true)
TypeConstructMock(TypeConstructMock && /*other*/) noexcept : move_constructed(true)
{
}

View File

@ -36,10 +36,10 @@ static uint gen_pseudo_random_number(uint num)
/* *** Parallel iterations over double-linked list items. *** */
static void task_listbase_light_iter_func(void *UNUSED(userdata),
static void task_listbase_light_iter_func(void * /*userdata*/,
void *item,
int index,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
LinkData *data = (LinkData *)item;
@ -50,7 +50,7 @@ static void task_listbase_light_iter_func(void *UNUSED(userdata),
static void task_listbase_light_membarrier_iter_func(void *userdata,
void *item,
int index,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
LinkData *data = (LinkData *)item;
@ -60,10 +60,10 @@ static void task_listbase_light_membarrier_iter_func(void *userdata,
atomic_sub_and_fetch_uint32((uint32_t *)count, 1);
}
static void task_listbase_heavy_iter_func(void *UNUSED(userdata),
static void task_listbase_heavy_iter_func(void * /*userdata*/,
void *item,
int index,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
LinkData *data = (LinkData *)item;
@ -79,7 +79,7 @@ static void task_listbase_heavy_iter_func(void *UNUSED(userdata),
static void task_listbase_heavy_membarrier_iter_func(void *userdata,
void *item,
int index,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
LinkData *data = (LinkData *)item;

View File

@ -921,7 +921,7 @@ BHead *blo_bhead_first(FileData *fd)
return bhead;
}
BHead *blo_bhead_prev(FileData *UNUSED(fd), BHead *thisblock)
BHead *blo_bhead_prev(FileData * /*fd*/, BHead *thisblock)
{
BHeadN *bheadn = BHEADN_FROM_BHEAD(thisblock);
BHeadN *prev = bheadn->prev;
@ -1711,7 +1711,7 @@ typedef struct BLOCacheStorageValue {
/** Register a cache data entry to be preserved when reading some undo memfile. */
static void blo_cache_storage_entry_register(
ID *id, const IDCacheKey *key, void **cache_p, uint UNUSED(flags), void *cache_storage_v)
ID *id, const IDCacheKey *key, void **cache_p, uint /*flags*/, void *cache_storage_v)
{
BLI_assert(key->id_session_uuid == id->session_uuid);
UNUSED_VARS_NDEBUG(id);
@ -1731,7 +1731,7 @@ static void blo_cache_storage_entry_register(
/** Restore a cache data entry from old ID into new one, when reading some undo memfile. */
static void blo_cache_storage_entry_restore_in_new(
ID *UNUSED(id), const IDCacheKey *key, void **cache_p, uint flags, void *cache_storage_v)
ID * /*id*/, const IDCacheKey *key, void **cache_p, uint flags, void *cache_storage_v)
{
BLOCacheStorage *cache_storage = static_cast<BLOCacheStorage *>(cache_storage_v);
@ -1756,11 +1756,8 @@ static void blo_cache_storage_entry_restore_in_new(
}
/** Clear as needed a cache data entry from old ID, when reading some undo memfile. */
static void blo_cache_storage_entry_clear_in_old(ID *UNUSED(id),
const IDCacheKey *key,
void **cache_p,
uint UNUSED(flags),
void *cache_storage_v)
static void blo_cache_storage_entry_clear_in_old(
ID * /*id*/, const IDCacheKey *key, void **cache_p, uint /*flags*/, void *cache_storage_v)
{
BLOCacheStorage *cache_storage = static_cast<BLOCacheStorage *>(cache_storage_v);
@ -2887,7 +2884,7 @@ static void direct_link_library(FileData *fd, Library *lib, Main *main)
id_us_ensure_real(&lib->id);
}
static void lib_link_library(BlendLibReader *UNUSED(reader), Library *UNUSED(lib))
static void lib_link_library(BlendLibReader * /*reader*/, Library * /*lib*/)
{
}
@ -3230,7 +3227,7 @@ static bool read_libblock_undo_restore_linked(FileData *fd, Main *main, const ID
/* For undo, restore unchanged datablock from old main. */
static void read_libblock_undo_restore_identical(
FileData *fd, Main *main, const ID *UNUSED(id), ID *id_old, const int tag)
FileData *fd, Main *main, const ID * /*id*/, ID *id_old, const int tag)
{
BLI_assert((fd->skip_flags & BLO_READ_SKIP_UNDO_OLD_MAIN) == 0);
BLI_assert(id_old != nullptr);
@ -3597,7 +3594,7 @@ static void link_global(FileData *fd, BlendFileData *bfd)
/** \name Versioning
* \{ */
static void do_versions_userdef(FileData *UNUSED(fd), BlendFileData *bfd)
static void do_versions_userdef(FileData * /*fd*/, BlendFileData *bfd)
{
UserDef *user = bfd->user;
@ -5121,7 +5118,7 @@ static void convert_pointer_array_64_to_32(BlendDataReader *reader,
}
}
static void convert_pointer_array_32_to_64(BlendDataReader *UNUSED(reader),
static void convert_pointer_array_32_to_64(BlendDataReader * /*reader*/,
uint array_size,
const uint32_t *src,
uint64_t *dst)

View File

@ -465,13 +465,13 @@ static void do_versions_sequencer_speed_effect_recursive(Scene *scene, const Lis
#undef SEQ_SPEED_COMPRESS_IPO_Y
}
static bool do_versions_sequencer_color_tags(Sequence *seq, void *UNUSED(user_data))
static bool do_versions_sequencer_color_tags(Sequence *seq, void * /*user_data*/)
{
seq->color_tag = SEQUENCE_COLOR_NONE;
return true;
}
static bool do_versions_sequencer_color_balance_sop(Sequence *seq, void *UNUSED(user_data))
static bool do_versions_sequencer_color_balance_sop(Sequence *seq, void * /*user_data*/)
{
LISTBASE_FOREACH (SequenceModifierData *, smd, &seq->modifiers) {
if (smd->type == seqModifierType_ColorBalance) {
@ -670,7 +670,7 @@ static bool seq_speed_factor_set(Sequence *seq, void *user_data)
return true;
}
void do_versions_after_linking_300(Main *bmain, ReportList *UNUSED(reports))
void do_versions_after_linking_300(Main *bmain, ReportList * /*reports*/)
{
if (MAIN_VERSION_ATLEAST(bmain, 300, 0) && !MAIN_VERSION_ATLEAST(bmain, 300, 1)) {
/* Set zero user text objects to have a fake user. */
@ -1028,9 +1028,9 @@ static void do_version_bbone_len_scale_fcurve_fix(FCurve *fcu)
replace_bbone_len_scale_rnapath(&fcu->rna_path, &fcu->array_index);
}
static void do_version_bbone_len_scale_animdata_cb(ID *UNUSED(id),
static void do_version_bbone_len_scale_animdata_cb(ID * /*id*/,
AnimData *adt,
void *UNUSED(wrapper_data))
void * /*wrapper_data*/)
{
LISTBASE_FOREACH_MUTABLE (FCurve *, fcu, &adt->drivers) {
do_version_bbone_len_scale_fcurve_fix(fcu);
@ -1078,7 +1078,7 @@ static bNodeSocket *do_version_replace_float_size_with_vector(bNodeTree *ntree,
return new_socket;
}
static bool seq_transform_origin_set(Sequence *seq, void *UNUSED(user_data))
static bool seq_transform_origin_set(Sequence *seq, void * /*user_data*/)
{
StripTransform *transform = seq->strip->transform;
if (seq->strip->transform != nullptr) {
@ -1087,7 +1087,7 @@ static bool seq_transform_origin_set(Sequence *seq, void *UNUSED(user_data))
return true;
}
static bool seq_transform_filter_set(Sequence *seq, void *UNUSED(user_data))
static bool seq_transform_filter_set(Sequence *seq, void * /*user_data*/)
{
StripTransform *transform = seq->strip->transform;
if (seq->strip->transform != nullptr) {
@ -1096,7 +1096,7 @@ static bool seq_transform_filter_set(Sequence *seq, void *UNUSED(user_data))
return true;
}
static bool seq_meta_channels_ensure(Sequence *seq, void *UNUSED(user_data))
static bool seq_meta_channels_ensure(Sequence *seq, void * /*user_data*/)
{
if (seq->type == SEQ_TYPE_META) {
SEQ_channels_ensure(&seq->channels);
@ -1341,7 +1341,7 @@ static bool version_fix_seq_meta_range(Sequence *seq, void *user_data)
return true;
}
static bool version_merge_still_offsets(Sequence *seq, void *UNUSED(user_data))
static bool version_merge_still_offsets(Sequence *seq, void * /*user_data*/)
{
seq->startofs -= seq->startstill;
seq->endofs -= seq->endstill;
@ -1933,7 +1933,7 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt
}
/* NOLINTNEXTLINE: readability-function-size */
void blo_do_versions_300(FileData *fd, Library *UNUSED(lib), Main *bmain)
void blo_do_versions_300(FileData *fd, Library * /*lib*/, Main *bmain)
{
/* The #SCE_SNAP_SEQ flag has been removed in favor of the #SCE_SNAP which can be used for each
* snap_flag member individually. */

View File

@ -643,7 +643,7 @@ static void mywrite_id_begin(WriteData *wd, ID *id)
*
* Only does something when storing an undo step.
*/
static void mywrite_id_end(WriteData *wd, ID *UNUSED(id))
static void mywrite_id_end(WriteData *wd, ID * /*id*/)
{
if (wd->use_memfile) {
/* Very important to do it after every ID write now, otherwise we cannot know whether a

View File

@ -269,7 +269,7 @@ void BM_mesh_free(BMesh *bm)
MEM_freeN(bm);
}
void bmesh_edit_begin(BMesh *UNUSED(bm), BMOpTypeFlag UNUSED(type_flag))
void bmesh_edit_begin(BMesh * /*bm*/, BMOpTypeFlag /*type_flag*/)
{
/* Most operators seem to be using BMO_OPTYPE_FLAG_UNTAN_MULTIRES to change the MDisps to
* absolute space during mesh edits. With this enabled, changes to the topology

View File

@ -466,16 +466,16 @@ bool BM_mesh_boolean_knife(BMesh *bm,
blender::meshintersect::BoolOpType::None);
}
#else
bool BM_mesh_boolean(BMesh *UNUSED(bm),
bool BM_mesh_boolean(BMesh * /*bm*/,
struct BMLoop *(*looptris)[3],
const int UNUSED(looptris_tot),
const int /*looptris_tot*/,
int (*test_fn)(BMFace *, void *),
void *UNUSED(user_data),
const int UNUSED(nshapes),
const bool UNUSED(use_self),
const bool UNUSED(keep_hidden),
const bool UNUSED(hole_tolerant),
const int UNUSED(boolean_mode))
void * /*user_data*/,
const int /*nshapes*/,
const bool /*use_self*/,
const bool /*keep_hidden*/,
const bool /*hole_tolerant*/,
const int /*boolean_mode*/)
{
UNUSED_VARS(looptris, test_fn);
return false;
@ -489,16 +489,16 @@ bool BM_mesh_boolean(BMesh *UNUSED(bm),
* TODO: need to ensure that "selected/non-selected" flag of original faces gets propagated
* to the intersection result faces.
*/
bool BM_mesh_boolean_knife(BMesh *UNUSED(bm),
bool BM_mesh_boolean_knife(BMesh * /*bm*/,
struct BMLoop *(*looptris)[3],
const int UNUSED(looptris_tot),
const int /*looptris_tot*/,
int (*test_fn)(BMFace *, void *),
void *UNUSED(user_data),
const int UNUSED(nshapes),
const bool UNUSED(use_self),
const bool UNUSED(use_separate_all),
const bool UNUSED(hole_tolerant),
const bool UNUSED(keep_hidden))
void * /*user_data*/,
const int /*nshapes*/,
const bool /*use_self*/,
const bool /*use_separate_all*/,
const bool /*hole_tolerant*/,
const bool /*keep_hidden*/)
{
UNUSED_VARS(looptris, test_fn);
return false;

View File

@ -72,7 +72,7 @@ void MetaDataExtractCallbackData::set_cryptomatte_keys(blender::StringRef crypto
void MetaDataExtractCallbackData::extract_cryptomatte_meta_data(void *_data,
const char *propname,
char *propvalue,
int UNUSED(len))
int /*len*/)
{
MetaDataExtractCallbackData *data = static_cast<MetaDataExtractCallbackData *>(_data);
blender::StringRefNull key(propname);

View File

@ -24,9 +24,9 @@ class MultiThreadedOperation : public NodeOperation {
/**
* Called before an update memory buffer pass is executed. Single-threaded calls.
*/
virtual void update_memory_buffer_started(MemoryBuffer *UNUSED(output),
const rcti &UNUSED(area),
Span<MemoryBuffer *> UNUSED(inputs))
virtual void update_memory_buffer_started(MemoryBuffer * /*output*/,
const rcti & /*area*/,
Span<MemoryBuffer *> /*inputs*/)
{
}
@ -40,9 +40,9 @@ class MultiThreadedOperation : public NodeOperation {
/**
* Called after an update memory buffer pass is executed. Single-threaded calls.
*/
virtual void update_memory_buffer_finished(MemoryBuffer *UNUSED(output),
const rcti &UNUSED(area),
Span<MemoryBuffer *> UNUSED(inputs))
virtual void update_memory_buffer_finished(MemoryBuffer * /*output*/,
const rcti & /*area*/,
Span<MemoryBuffer *> /*inputs*/)
{
}

View File

@ -628,9 +628,9 @@ class NodeOperation {
/**
* Executes operation updating output memory buffer. Single-threaded calls.
*/
virtual void update_memory_buffer(MemoryBuffer *UNUSED(output),
const rcti &UNUSED(area),
Span<MemoryBuffer *> UNUSED(inputs))
virtual void update_memory_buffer(MemoryBuffer * /*output*/,
const rcti & /*area*/,
Span<MemoryBuffer *> /*inputs*/)
{
}

View File

@ -377,7 +377,7 @@ static void threading_model_queue_deinitialize()
/** \name Task Scheduling
* \{ */
static void threading_model_task_execute(TaskPool *__restrict UNUSED(pool), void *task_data)
static void threading_model_task_execute(TaskPool *__restrict /*pool*/, void *task_data)
{
WorkPackage *package = static_cast<WorkPackage *>(task_data);
CPUDevice device(BLI_task_parallel_thread_id(nullptr));

View File

@ -12,7 +12,7 @@ CombineColorNode::CombineColorNode(bNode *editor_node) : Node(editor_node)
}
void CombineColorNode::convert_to_operations(NodeConverter &converter,
const CompositorContext &UNUSED(context)) const
const CompositorContext & /*context*/) const
{
NodeInput *input_rsocket = this->get_input_socket(0);
NodeInput *input_gsocket = this->get_input_socket(1);

View File

@ -12,7 +12,7 @@ CombineXYZNode::CombineXYZNode(bNode *editor_node) : Node(editor_node)
}
void CombineXYZNode::convert_to_operations(NodeConverter &converter,
const CompositorContext &UNUSED(context)) const
const CompositorContext & /*context*/) const
{
NodeInput *input_x_socket = this->get_input_socket(0);
NodeInput *input_y_socket = this->get_input_socket(1);

View File

@ -25,7 +25,7 @@ ConvertColorSpaceNode::ConvertColorSpaceNode(bNode *editorNode) : Node(editorNod
}
void ConvertColorSpaceNode::convert_to_operations(NodeConverter &converter,
const CompositorContext &UNUSED(context)) const
const CompositorContext & /*context*/) const
{
const bNode *b_node = get_bnode();

View File

@ -240,8 +240,8 @@ CryptomatteOperation *CryptomatteNode::create_cryptomatte_operation(
CryptomatteOperation *CryptomatteLegacyNode::create_cryptomatte_operation(
NodeConverter &converter,
const CompositorContext &UNUSED(context),
const bNode &UNUSED(node),
const CompositorContext & /*context*/,
const bNode & /*node*/,
const NodeCryptomatte *cryptomatte_settings) const
{
const int num_inputs = inputs_.size() - 1;

View File

@ -12,7 +12,7 @@ SeparateColorNode::SeparateColorNode(bNode *editor_node) : Node(editor_node)
}
void SeparateColorNode::convert_to_operations(NodeConverter &converter,
const CompositorContext &UNUSED(context)) const
const CompositorContext & /*context*/) const
{
NodeInput *image_socket = this->get_input_socket(0);
NodeOutput *output_rsocket = this->get_output_socket(0);

View File

@ -13,7 +13,7 @@ SeparateXYZNode::SeparateXYZNode(bNode *editor_node) : Node(editor_node)
}
void SeparateXYZNode::convert_to_operations(NodeConverter &converter,
const CompositorContext &UNUSED(context)) const
const CompositorContext & /*context*/) const
{
NodeInput *vector_socket = this->get_input_socket(0);
NodeOutput *output_x_socket = this->get_output_socket(0);

View File

@ -95,7 +95,7 @@ bool BilateralBlurOperation::determine_depending_area_of_interest(
return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output);
}
void BilateralBlurOperation::get_area_of_interest(const int UNUSED(input_idx),
void BilateralBlurOperation::get_area_of_interest(const int /*input_idx*/,
const rcti &output_area,
rcti &r_input_area)
{

View File

@ -96,7 +96,7 @@ void BokehImageOperation::execute_pixel_sampled(float output[4],
void BokehImageOperation::update_memory_buffer_partial(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> UNUSED(inputs))
Span<MemoryBuffer *> /*inputs*/)
{
const float shift = data_->lensshift;
const float shift2 = shift / 2.0f;

View File

@ -144,15 +144,15 @@ void CalculateMeanOperation::set_setting(int setting)
}
void CalculateMeanOperation::get_area_of_interest(int input_idx,
const rcti &UNUSED(output_area),
const rcti & /*output_area*/,
rcti &r_input_area)
{
BLI_assert(input_idx == 0);
r_input_area = get_input_operation(input_idx)->get_canvas();
}
void CalculateMeanOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(output),
const rcti &UNUSED(area),
void CalculateMeanOperation::update_memory_buffer_started(MemoryBuffer * /*output*/,
const rcti & /*area*/,
Span<MemoryBuffer *> inputs)
{
if (!iscalculated_) {
@ -164,7 +164,7 @@ void CalculateMeanOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(o
void CalculateMeanOperation::update_memory_buffer_partial(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> UNUSED(inputs))
Span<MemoryBuffer *> /*inputs*/)
{
output->fill(area, &result_);
}

View File

@ -81,8 +81,9 @@ void *CalculateStandardDeviationOperation::initialize_tile_data(rcti *rect)
return nullptr;
}
void CalculateStandardDeviationOperation::update_memory_buffer_started(
MemoryBuffer *UNUSED(output), const rcti &UNUSED(area), Span<MemoryBuffer *> inputs)
void CalculateStandardDeviationOperation::update_memory_buffer_started(MemoryBuffer * /*output*/,
const rcti & /*area*/,
Span<MemoryBuffer *> inputs)
{
if (!iscalculated_) {
const MemoryBuffer *input = inputs[0];
@ -104,7 +105,7 @@ void CalculateStandardDeviationOperation::update_memory_buffer_started(
}
void CalculateStandardDeviationOperation::update_memory_buffer_partial(
MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs))
MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> /*inputs*/)
{
output->fill(area, &standard_deviation_);
}

View File

@ -197,7 +197,7 @@ void CompositorOperation::execute_region(rcti *rect, uint /*tile_number*/)
}
}
void CompositorOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(output),
void CompositorOperation::update_memory_buffer_partial(MemoryBuffer * /*output*/,
const rcti &area,
Span<MemoryBuffer *> inputs)
{
@ -213,7 +213,7 @@ void CompositorOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(outp
depth_buf.copy_from(inputs[2], area);
}
void CompositorOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti &r_area)
void CompositorOperation::determine_canvas(const rcti & /*preferred_area*/, rcti &r_area)
{
int width, height;
BKE_render_resolution(rd_, false, &width, &height);

View File

@ -19,7 +19,7 @@ bool ConstantOperation::can_get_constant_elem() const
void ConstantOperation::update_memory_buffer(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> UNUSED(inputs))
Span<MemoryBuffer *> /*inputs*/)
{
BLI_assert(output->is_a_single_elem());
const float *constant = get_constant_elem();

View File

@ -89,7 +89,7 @@ class DenoiseFilter {
}
#else
void init_and_lock_denoiser(MemoryBuffer *UNUSED(output))
void init_and_lock_denoiser(MemoryBuffer * /*output*/)
{
}
@ -97,11 +97,11 @@ class DenoiseFilter {
{
}
void set_image(const StringRef UNUSED(name), MemoryBuffer *UNUSED(buffer))
void set_image(const StringRef /*name*/, MemoryBuffer * /*buffer*/)
{
}
template<typename T> void set(const StringRef UNUSED(option_name), T UNUSED(value))
template<typename T> void set(const StringRef /*option_name*/, T /*value*/)
{
}
@ -132,8 +132,8 @@ bool DenoiseBaseOperation::determine_depending_area_of_interest(
return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output);
}
void DenoiseBaseOperation::get_area_of_interest(const int UNUSED(input_idx),
const rcti &UNUSED(output_area),
void DenoiseBaseOperation::get_area_of_interest(const int /*input_idx*/,
const rcti & /*output_area*/,
rcti &r_input_area)
{
r_input_area = this->get_canvas();
@ -251,7 +251,7 @@ void DenoiseOperation::generate_denoise(MemoryBuffer *output,
}
void DenoiseOperation::update_memory_buffer(MemoryBuffer *output,
const rcti &UNUSED(area),
const rcti & /*area*/,
Span<MemoryBuffer *> inputs)
{
if (!output_rendered_) {
@ -304,7 +304,7 @@ void DenoisePrefilterOperation::generate_denoise(MemoryBuffer *output, MemoryBuf
}
void DenoisePrefilterOperation::update_memory_buffer(MemoryBuffer *output,
const rcti &UNUSED(area),
const rcti & /*area*/,
Span<MemoryBuffer *> inputs)
{
if (!output_rendered_) {

View File

@ -128,7 +128,7 @@ bool DirectionalBlurOperation::determine_depending_area_of_interest(
}
void DirectionalBlurOperation::get_area_of_interest(const int input_idx,
const rcti &UNUSED(output_area),
const rcti & /*output_area*/,
rcti &r_input_area)
{
BLI_assert(input_idx == 0);

View File

@ -209,8 +209,8 @@ void DisplaceOperation::get_area_of_interest(const int input_idx,
}
}
void DisplaceOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(output),
const rcti &UNUSED(area),
void DisplaceOperation::update_memory_buffer_started(MemoryBuffer * /*output*/,
const rcti & /*area*/,
Span<MemoryBuffer *> inputs)
{
MemoryBuffer *vector = inputs[1];

View File

@ -1354,15 +1354,15 @@ void DoubleEdgeMaskOperation::deinit_execution()
}
}
void DoubleEdgeMaskOperation::get_area_of_interest(int UNUSED(input_idx),
const rcti &UNUSED(output_area),
void DoubleEdgeMaskOperation::get_area_of_interest(int /*input_idx*/,
const rcti & /*output_area*/,
rcti &r_input_area)
{
r_input_area = this->get_canvas();
}
void DoubleEdgeMaskOperation::update_memory_buffer(MemoryBuffer *output,
const rcti &UNUSED(area),
const rcti & /*area*/,
Span<MemoryBuffer *> inputs)
{
if (!is_output_rendered_) {

View File

@ -384,15 +384,15 @@ void *FastGaussianBlurValueOperation::initialize_tile_data(rcti *rect)
return iirgaus_;
}
void FastGaussianBlurValueOperation::get_area_of_interest(const int UNUSED(input_idx),
const rcti &UNUSED(output_area),
void FastGaussianBlurValueOperation::get_area_of_interest(const int /*input_idx*/,
const rcti & /*output_area*/,
rcti &r_input_area)
{
r_input_area = this->get_canvas();
}
void FastGaussianBlurValueOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(output),
const rcti &UNUSED(area),
void FastGaussianBlurValueOperation::update_memory_buffer_started(MemoryBuffer * /*output*/,
const rcti & /*area*/,
Span<MemoryBuffer *> inputs)
{
if (iirgaus_ == nullptr) {

View File

@ -31,9 +31,9 @@ class FastGaussianBlurOperation : public BlurBaseOperation {
void update_memory_buffer_started(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> inputs) override;
void update_memory_buffer_partial(MemoryBuffer *UNUSED(output),
const rcti &UNUSED(area),
Span<MemoryBuffer *> UNUSED(inputs)) override
void update_memory_buffer_partial(MemoryBuffer * /*output*/,
const rcti & /*area*/,
Span<MemoryBuffer *> /*inputs*/) override
{
}
};

View File

@ -56,7 +56,7 @@ bool GlareBaseOperation::determine_depending_area_of_interest(rcti * /*input*/,
}
void GlareBaseOperation::get_area_of_interest(const int input_idx,
const rcti &UNUSED(output_area),
const rcti & /*output_area*/,
rcti &r_input_area)
{
BLI_assert(input_idx == 0);
@ -68,7 +68,7 @@ void GlareBaseOperation::get_area_of_interest(const int input_idx,
}
void GlareBaseOperation::update_memory_buffer(MemoryBuffer *output,
const rcti &UNUSED(area),
const rcti & /*area*/,
Span<MemoryBuffer *> inputs)
{
if (!is_output_rendered_) {

View File

@ -90,7 +90,7 @@ void BaseImageOperation::deinit_execution()
}
}
void BaseImageOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti &r_area)
void BaseImageOperation::determine_canvas(const rcti & /*preferred_area*/, rcti &r_area)
{
ImBuf *stackbuf = get_im_buf();
@ -155,7 +155,7 @@ void ImageOperation::execute_pixel_sampled(float output[4], float x, float y, Pi
void ImageOperation::update_memory_buffer_partial(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> UNUSED(inputs))
Span<MemoryBuffer *> /*inputs*/)
{
output->copy_from(buffer_, area, true);
}
@ -179,7 +179,7 @@ void ImageAlphaOperation::execute_pixel_sampled(float output[4],
void ImageAlphaOperation::update_memory_buffer_partial(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> UNUSED(inputs))
Span<MemoryBuffer *> /*inputs*/)
{
output->copy_from(buffer_, area, 3, COM_DATA_TYPE_VALUE_CHANNELS, 0);
}
@ -205,7 +205,7 @@ void ImageDepthOperation::execute_pixel_sampled(float output[4],
void ImageDepthOperation::update_memory_buffer_partial(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> UNUSED(inputs))
Span<MemoryBuffer *> /*inputs*/)
{
if (depth_buffer_) {
output->copy_from(depth_buffer_, area);

View File

@ -267,7 +267,7 @@ bool InpaintSimpleOperation::determine_depending_area_of_interest(
}
void InpaintSimpleOperation::get_area_of_interest(const int input_idx,
const rcti &UNUSED(output_area),
const rcti & /*output_area*/,
rcti &r_input_area)
{
BLI_assert(input_idx == 0);

View File

@ -75,7 +75,7 @@ bool KeyingBlurOperation::determine_depending_area_of_interest(rcti *input,
return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output);
}
void KeyingBlurOperation::get_area_of_interest(const int UNUSED(input_idx),
void KeyingBlurOperation::get_area_of_interest(const int /*input_idx*/,
const rcti &output_area,
rcti &r_input_area)
{

View File

@ -201,8 +201,8 @@ void MapUVOperation::get_area_of_interest(const int input_idx,
}
}
void MapUVOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(output),
const rcti &UNUSED(area),
void MapUVOperation::update_memory_buffer_started(MemoryBuffer * /*output*/,
const rcti & /*area*/,
Span<MemoryBuffer *> inputs)
{
const MemoryBuffer *uv_input = inputs[UV_INPUT_INDEX];

View File

@ -131,7 +131,7 @@ void MaskOperation::execute_pixel_sampled(float output[4],
void MaskOperation::update_memory_buffer_partial(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> UNUSED(inputs))
Span<MemoryBuffer *> /*inputs*/)
{
Vector<MaskRasterHandle *> handles = get_non_null_handles();
if (handles.size() == 0) {

View File

@ -53,7 +53,7 @@ void MovieClipBaseOperation::deinit_execution()
}
}
void MovieClipBaseOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti &r_area)
void MovieClipBaseOperation::determine_canvas(const rcti & /*preferred_area*/, rcti &r_area)
{
r_area = COM_AREA_NONE;
if (movie_clip_) {
@ -94,7 +94,7 @@ void MovieClipBaseOperation::execute_pixel_sampled(float output[4],
void MovieClipBaseOperation::update_memory_buffer_partial(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> UNUSED(inputs))
Span<MemoryBuffer *> /*inputs*/)
{
if (movie_clip_buffer_) {
output->copy_from(movie_clip_buffer_, area);
@ -126,7 +126,7 @@ void MovieClipAlphaOperation::execute_pixel_sampled(float output[4],
void MovieClipAlphaOperation::update_memory_buffer_partial(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> UNUSED(inputs))
Span<MemoryBuffer *> /*inputs*/)
{
if (movie_clip_buffer_) {
output->copy_from(movie_clip_buffer_, area, 3, COM_DATA_TYPE_VALUE_CHANNELS, 0);

Some files were not shown because too many files have changed in this diff Show More