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:
parent
ed7f5713f8
commit
97746129d5
|
@ -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
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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)
|
||||
{
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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/")) {
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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()) {
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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));
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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])
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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)
|
||||
{
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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*/)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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*/)
|
||||
{
|
||||
}
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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();
|
||||
};
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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
|
||||
{
|
||||
}
|
||||
};
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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_;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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
|
||||
{
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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); });
|
||||
}
|
||||
|
||||
|
|
|
@ -20,7 +20,7 @@ struct MyValue {
|
|||
alive++;
|
||||
}
|
||||
|
||||
MyValue(const MyValue &UNUSED(other))
|
||||
MyValue(const MyValue & /*other*/)
|
||||
{
|
||||
if (alive == 15) {
|
||||
throw std::exception();
|
||||
|
|
|
@ -106,7 +106,7 @@ class IMeshBuilder {
|
|||
}
|
||||
};
|
||||
|
||||
static int all_shape_zero(int UNUSED(t))
|
||||
static int all_shape_zero(int /*t*/)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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. */
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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*/)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -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*/)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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();
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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)
|
||||
{
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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_);
|
||||
}
|
||||
|
|
|
@ -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_);
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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_) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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_) {
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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
|
||||
{
|
||||
}
|
||||
};
|
||||
|
|
|
@ -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_) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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)
|
||||
{
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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
Loading…
Reference in New Issue