Cleanup: convert camelCase naming to snake_case in Compositor

To convert old code to the current convention and
use a single code style.

1 files changed, 15 insertions, 14 deletions

diff --git a/source/blender/compositor/intern/COM_MetaData.cc b/source/blender/compositor/intern/COM_MetaData.cc
index 5775a7eab65..530634a6e41 100644
--- a/source/blender/compositor/intern/COM_MetaData.cc
+++ b/source/blender/compositor/intern/COM_MetaData.cc
@@ -29,9 +29,9 @@ void MetaData::add(const blender::StringRef key, const blender::StringRef value)
   entries_.add(key, value);
 }
 
-void MetaData::addCryptomatteEntry(const blender::StringRef layer_name,
-                                   const blender::StringRefNull key,
-                                   const blender::StringRef value)
+void MetaData::add_cryptomatte_entry(const blender::StringRef layer_name,
+                                     const blender::StringRefNull key,
+                                     const blender::StringRef value)
 {
   add(blender::bke::cryptomatte::BKE_cryptomatte_meta_data_key(layer_name, key), value);
 }
@@ -40,7 +40,7 @@ void MetaData::addCryptomatteEntry(const blender::StringRef layer_name,
  *
  * When a conversion happens it will also add the cryptomatte name key with the given
  * `layer_name`. */
-void MetaData::replaceHashNeutralCryptomatteKeys(const blender::StringRef layer_name)
+void MetaData::replace_hash_neutral_cryptomatte_keys(const blender::StringRef layer_name)
 {
   std::string cryptomatte_hash = entries_.pop_default(META_DATA_KEY_CRYPTOMATTE_HASH, "");
   std::string cryptomatte_conversion = entries_.pop_default(META_DATA_KEY_CRYPTOMATTE_CONVERSION,
@@ -49,27 +49,28 @@ void MetaData::replaceHashNeutralCryptomatteKeys(const blender::StringRef layer_
 
   if (cryptomatte_hash.length() || cryptomatte_conversion.length() ||
       cryptomatte_manifest.length()) {
-    addCryptomatteEntry(layer_name, "name", layer_name);
+    add_cryptomatte_entry(layer_name, "name", layer_name);
   }
   if (cryptomatte_hash.length()) {
-    addCryptomatteEntry(layer_name, "hash", cryptomatte_hash);
+    add_cryptomatte_entry(layer_name, "hash", cryptomatte_hash);
   }
   if (cryptomatte_conversion.length()) {
-    addCryptomatteEntry(layer_name, "conversion", cryptomatte_conversion);
+    add_cryptomatte_entry(layer_name, "conversion", cryptomatte_conversion);
   }
   if (cryptomatte_manifest.length()) {
-    addCryptomatteEntry(layer_name, "manifest", cryptomatte_manifest);
+    add_cryptomatte_entry(layer_name, "manifest", cryptomatte_manifest);
   }
 }
 
-void MetaData::addToRenderResult(RenderResult *render_result) const
+void MetaData::add_to_render_result(RenderResult *render_result) const
 {
   for (Map<std::string, std::string>::Item entry : entries_.items()) {
     BKE_render_result_stamp_data(render_result, entry.key.c_str(), entry.value.c_str());
   }
 }
 
-void MetaDataExtractCallbackData::addMetaData(blender::StringRef key, blender::StringRefNull value)
+void MetaDataExtractCallbackData::add_meta_data(blender::StringRef key,
+                                                blender::StringRefNull value)
 {
   if (!meta_data) {
     meta_data = std::make_unique<MetaData>();
@@ -77,7 +78,7 @@ void MetaDataExtractCallbackData::addMetaData(blender::StringRef key, blender::S
   meta_data->add(key, value);
 }
 
-void MetaDataExtractCallbackData::setCryptomatteKeys(blender::StringRef cryptomatte_layer_name)
+void MetaDataExtractCallbackData::set_cryptomatte_keys(blender::StringRef cryptomatte_layer_name)
 {
   manifest_key = blender::bke::cryptomatte::BKE_cryptomatte_meta_data_key(cryptomatte_layer_name,
                                                                           "manifest");
@@ -95,13 +96,13 @@ void MetaDataExtractCallbackData::extract_cryptomatte_meta_data(void *_data,
   MetaDataExtractCallbackData *data = static_cast<MetaDataExtractCallbackData *>(_data);
   blender::StringRefNull key(propname);
   if (key == data->hash_key) {
-    data->addMetaData(META_DATA_KEY_CRYPTOMATTE_HASH, propvalue);
+    data->add_meta_data(META_DATA_KEY_CRYPTOMATTE_HASH, propvalue);
   }
   else if (key == data->conversion_key) {
-    data->addMetaData(META_DATA_KEY_CRYPTOMATTE_CONVERSION, propvalue);
+    data->add_meta_data(META_DATA_KEY_CRYPTOMATTE_CONVERSION, propvalue);
   }
   else if (key == data->manifest_key) {
-    data->addMetaData(META_DATA_KEY_CRYPTOMATTE_MANIFEST, propvalue);
+    data->add_meta_data(META_DATA_KEY_CRYPTOMATTE_MANIFEST, propvalue);
   }
 }