Revert "Fix T68826 Eevee: Multi-Mat not working if switching from Solid shading"
[blender.git] / source / blender / collada / collada_internal.cpp
index 02c4b4de499f28639e8d50a34f477d16accdc3a9..a97b5e0eca1f9505f05207a2e4798b6773607055 100644 (file)
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-/** \file \ingroup collada
+/** \file
+ * \ingroup collada
  */
 
-
 /* COLLADABU_ASSERT, may be able to remove later */
 #include "COLLADABUPlatform.h"
 #include "collada_utils.h"
 
 UnitConverter::UnitConverter() : unit(), up_axis(COLLADAFW::FileInfo::Z_UP)
 {
-       axis_angle_to_mat4_single(x_up_mat4, 'Y', -0.5 * M_PI);
-       axis_angle_to_mat4_single(y_up_mat4, 'X', 0.5 * M_PI);
+  axis_angle_to_mat4_single(x_up_mat4, 'Y', -0.5 * M_PI);
+  axis_angle_to_mat4_single(y_up_mat4, 'X', 0.5 * M_PI);
 
-       unit_m4(z_up_mat4);
-       unit_m4(scale_mat4);
+  unit_m4(z_up_mat4);
+  unit_m4(scale_mat4);
 }
 
 void UnitConverter::read_asset(const COLLADAFW::FileInfo *asset)
 {
-       unit = asset->getUnit();
-       up_axis = asset->getUpAxisType();
+  unit = asset->getUnit();
+  up_axis = asset->getUpAxisType();
 }
 
 UnitConverter::UnitSystem UnitConverter::isMetricSystem()
 {
-       switch (unit.getLinearUnitUnit()) {
-               case COLLADAFW::FileInfo::Unit::MILLIMETER:
-               case COLLADAFW::FileInfo::Unit::CENTIMETER:
-               case COLLADAFW::FileInfo::Unit::DECIMETER:
-               case COLLADAFW::FileInfo::Unit::METER:
-               case COLLADAFW::FileInfo::Unit::KILOMETER:
-                       return UnitConverter::Metric;
-               case COLLADAFW::FileInfo::Unit::INCH:
-               case COLLADAFW::FileInfo::Unit::FOOT:
-               case COLLADAFW::FileInfo::Unit::YARD:
-                       return UnitConverter::Imperial;
-               default:
-                       return UnitConverter::None;
-       }
+  switch (unit.getLinearUnitUnit()) {
+    case COLLADAFW::FileInfo::Unit::MILLIMETER:
+    case COLLADAFW::FileInfo::Unit::CENTIMETER:
+    case COLLADAFW::FileInfo::Unit::DECIMETER:
+    case COLLADAFW::FileInfo::Unit::METER:
+    case COLLADAFW::FileInfo::Unit::KILOMETER:
+      return UnitConverter::Metric;
+    case COLLADAFW::FileInfo::Unit::INCH:
+    case COLLADAFW::FileInfo::Unit::FOOT:
+    case COLLADAFW::FileInfo::Unit::YARD:
+      return UnitConverter::Imperial;
+    default:
+      return UnitConverter::None;
+  }
 }
 
 float UnitConverter::getLinearMeter()
 {
-       return (float)unit.getLinearUnitMeter();
+  return (float)unit.getLinearUnitMeter();
 }
 
 void UnitConverter::convertVector3(COLLADABU::Math::Vector3 &vec, float *v)
 {
-       v[0] = vec.x;
-       v[1] = vec.y;
-       v[2] = vec.z;
+  v[0] = vec.x;
+  v[1] = vec.y;
+  v[2] = vec.z;
 }
 
 // TODO need also for angle conversion, time conversion...
 
-void UnitConverter::dae_matrix_to_mat4_(float out[4][4], const COLLADABU::Math::Matrix4in)
+void UnitConverter::dae_matrix_to_mat4_(float out[4][4], const COLLADABU::Math::Matrix4 &in)
 {
-       // in DAE, matrices use columns vectors, (see comments in COLLADABUMathMatrix4.h)
-       // so here, to make a blender matrix, we swap columns and rows
-       for (int i = 0; i < 4; i++) {
-               for (int j = 0; j < 4; j++) {
-                       out[i][j] = in[j][i];
-               }
-       }
+  // in DAE, matrices use columns vectors, (see comments in COLLADABUMathMatrix4.h)
+  // so here, to make a blender matrix, we swap columns and rows
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      out[i][j] = in[j][i];
+    }
+  }
 }
 
 void UnitConverter::mat4_to_dae(float out[4][4], float in[4][4])
 {
-       transpose_m4_m4(out, in);
+  transpose_m4_m4(out, in);
 }
 
 void UnitConverter::mat4_to_dae_double(double out[4][4], float in[4][4])
 {
-       float mat[4][4];
+  float mat[4][4];
 
-       mat4_to_dae(mat, in);
+  mat4_to_dae(mat, in);
 
-       for (int i = 0; i < 4; i++)
-               for (int j = 0; j < 4; j++)
-                       out[i][j] = mat[i][j];
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      out[i][j] = mat[i][j];
+    }
+  }
 }
 
-float(&UnitConverter::get_rotation())[4][4]
+float (&UnitConverter::get_rotation())[4][4]
 {
-       switch (up_axis) {
-               case COLLADAFW::FileInfo::X_UP:
-                       return x_up_mat4;
-                       break;
-               case COLLADAFW::FileInfo::Y_UP:
-                       return y_up_mat4;
-                       break;
-               default:
-                       return z_up_mat4;
-                       break;
-       }
+  switch (up_axis) {
+    case COLLADAFW::FileInfo::X_UP:
+      return x_up_mat4;
+      break;
+    case COLLADAFW::FileInfo::Y_UP:
+      return y_up_mat4;
+      break;
+    default:
+      return z_up_mat4;
+      break;
+  }
 }
 
-
-float(&UnitConverter::get_scale())[4][4]
+float (&UnitConverter::get_scale())[4][4]
 {
-       return scale_mat4;
+  return scale_mat4;
 }
 
 void UnitConverter::calculate_scale(Scene &sce)
 {
-       PointerRNA scene_ptr, unit_settings;
-       PropertyRNA *system_ptr, *scale_ptr;
-       RNA_id_pointer_create(&sce.id, &scene_ptr);
+  PointerRNA scene_ptr, unit_settings;
+  PropertyRNA *system_ptr, *scale_ptr;
+  RNA_id_pointer_create(&sce.id, &scene_ptr);
 
-       unit_settings = RNA_pointer_get(&scene_ptr, "unit_settings");
-       system_ptr    = RNA_struct_find_property(&unit_settings, "system");
-       scale_ptr     = RNA_struct_find_property(&unit_settings, "scale_length");
+  unit_settings = RNA_pointer_get(&scene_ptr, "unit_settings");
+  system_ptr = RNA_struct_find_property(&unit_settings, "system");
+  scale_ptr = RNA_struct_find_property(&unit_settings, "scale_length");
 
-       int   type    = RNA_property_enum_get(&unit_settings, system_ptr);
+  int type = RNA_property_enum_get(&unit_settings, system_ptr);
 
-       float bl_scale;
+  float bl_scale;
 
-       switch (type) {
-               case USER_UNIT_NONE:
-                       bl_scale = 1.0; // map 1 Blender unit to 1 Meter
-                       break;
+  switch (type) {
+    case USER_UNIT_NONE:
+      bl_scale = 1.0;  // map 1 Blender unit to 1 Meter
+      break;
 
-               case USER_UNIT_METRIC:
-                       bl_scale = RNA_property_float_get(&unit_settings, scale_ptr);
-                       break;
+    case USER_UNIT_METRIC:
+      bl_scale = RNA_property_float_get(&unit_settings, scale_ptr);
+      break;
 
-               default :
-                       bl_scale = RNA_property_float_get(&unit_settings, scale_ptr);
-                       // it looks like the conversion to Imperial is done implicitly.
-                       // So nothing to do here.
-                       break;
-       }
+    default:
+      bl_scale = RNA_property_float_get(&unit_settings, scale_ptr);
+      // it looks like the conversion to Imperial is done implicitly.
+      // So nothing to do here.
+      break;
+  }
 
-       float rescale[3];
-       rescale[0] = rescale[1] = rescale[2] = getLinearMeter() / bl_scale;
+  float rescale[3];
+  rescale[0] = rescale[1] = rescale[2] = getLinearMeter() / bl_scale;
 
-       size_to_mat4(scale_mat4, rescale);
+  size_to_mat4(scale_mat4, rescale);
 }
 
 /**
@@ -167,212 +168,173 @@ void UnitConverter::calculate_scale(Scene &sce)
  */
 const unsigned char translate_start_name_map[256] = {
 
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 65, 66, 67, 68, 69, 70, 71,
-       72, 73, 74, 75, 76, 77, 78, 79,
-       80, 81, 82, 83, 84, 85, 86, 87,
-       88, 89, 90, 95, 95, 95, 95, 95,
-       95, 97, 98, 99, 100, 101, 102, 103,
-       104, 105, 106, 107, 108, 109, 110, 111,
-       112, 113, 114, 115, 116, 117, 118, 119,
-       120, 121, 122, 95, 95, 95, 95, 95,
-
-       128, 129, 130, 131, 132, 133, 134, 135,
-       136, 137, 138, 139, 140, 141, 142, 143,
-       144, 145, 146, 147, 148, 149, 150, 151,
-       152, 153, 154, 155, 156, 157, 158, 159,
-       160, 161, 162, 163, 164, 165, 166, 167,
-       168, 169, 170, 171, 172, 173, 174, 175,
-       176, 177, 178, 179, 180, 181, 182, 183,
-       184, 185, 186, 187, 188, 189, 190, 191,
-       192, 193, 194, 195, 196, 197, 198, 199,
-       200, 201, 202, 203, 204, 205, 206, 207,
-       208, 209, 210, 211, 212, 213, 214, 215,
-       216, 217, 218, 219, 220, 221, 222, 223,
-       224, 225, 226, 227, 228, 229, 230, 231,
-       232, 233, 234, 235, 236, 237, 238, 239,
-       240, 241, 242, 243, 244, 245, 246, 247,
-       248, 249, 250, 251, 252, 253, 254, 255,
+    95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,
+    95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,
+    95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,
+    95,  95,  95,  95,  95,  95,  95,  95,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,
+    76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  95,  95,  95,  95,
+    95,  95,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
+    114, 115, 116, 117, 118, 119, 120, 121, 122, 95,  95,  95,  95,  95,
+
+    128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
+    147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
+    166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
+    185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
+    204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
+    223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
+    242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
 };
 
 const unsigned char translate_name_map[256] = {
 
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 95, 95, 95,
-       95, 95, 95, 95, 95, 45, 95, 95,
-       48, 49, 50, 51, 52, 53, 54, 55,
-       56, 57, 95, 95, 95, 95, 95, 95,
-       95, 65, 66, 67, 68, 69, 70, 71,
-       72, 73, 74, 75, 76, 77, 78, 79,
-       80, 81, 82, 83, 84, 85, 86, 87,
-       88, 89, 90, 95, 95, 95, 95, 95,
-       95, 97, 98, 99, 100, 101, 102, 103,
-       104, 105, 106, 107, 108, 109, 110, 111,
-       112, 113, 114, 115, 116, 117, 118, 119,
-       120, 121, 122, 95, 95, 95, 95, 95,
-
-       128, 129, 130, 131, 132, 133, 134, 135,
-       136, 137, 138, 139, 140, 141, 142, 143,
-       144, 145, 146, 147, 148, 149, 150, 151,
-       152, 153, 154, 155, 156, 157, 158, 159,
-       160, 161, 162, 163, 164, 165, 166, 167,
-       168, 169, 170, 171, 172, 173, 174, 175,
-       176, 177, 178, 179, 180, 181, 182, 183,
-       184, 185, 186, 187, 188, 189, 190, 191,
-       192, 193, 194, 195, 196, 197, 198, 199,
-       200, 201, 202, 203, 204, 205, 206, 207,
-       208, 209, 210, 211, 212, 213, 214, 215,
-       216, 217, 218, 219, 220, 221, 222, 223,
-       224, 225, 226, 227, 228, 229, 230, 231,
-       232, 233, 234, 235, 236, 237, 238, 239,
-       240, 241, 242, 243, 244, 245, 246, 247,
-       248, 249, 250, 251, 252, 253, 254, 255,
+    95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,
+    95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,  95,
+    95,  95,  95,  95,  95,  95,  95,  45,  95,  95,  48,  49,  50,  51,  52,  53,  54,  55,  56,
+    57,  95,  95,  95,  95,  95,  95,  95,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,
+    76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  95,  95,  95,  95,
+    95,  95,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
+    114, 115, 116, 117, 118, 119, 120, 121, 122, 95,  95,  95,  95,  95,
+
+    128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
+    147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
+    166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
+    185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
+    204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
+    223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
+    242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
 };
 
-typedef std::map< std::string, std::vector<std::string> > map_string_list;
+typedef std::map<std::string, std::vector<std::string>> map_string_list;
 map_string_list global_id_map;
 
 void clear_global_id_map()
 {
-       global_id_map.clear();
+  global_id_map.clear();
 }
 
 /** Look at documentation of translate_map */
 std::string translate_id(const char *idString)
 {
-       std::string id = std::string(idString);
-       return translate_id(id);
+  std::string id = std::string(idString);
+  return translate_id(id);
 }
 
 std::string translate_id(const std::string &id)
 {
-       if (id.size() == 0) {
-               return id;
-       }
-
-       std::string id_translated = id;
-       id_translated[0] = translate_start_name_map[(unsigned int)id_translated[0]];
-       for (unsigned int i = 1; i < id_translated.size(); i++) {
-               id_translated[i] = translate_name_map[(unsigned int)id_translated[i]];
-       }
-       // It's so much workload now, the if () should speed up things.
-       if (id_translated != id) {
-               // Search duplicates
-               map_string_list::iterator iter = global_id_map.find(id_translated);
-               if (iter != global_id_map.end()) {
-                       unsigned int i = 0;
-                       bool found = false;
-                       for (i = 0; i < iter->second.size(); i++) {
-                               if (id == iter->second[i]) {
-                                       found = true;
-                                       break;
-                               }
-                       }
-                       bool convert = false;
-                       if (found) {
-                               if (i > 0) {
-                                       convert = true;
-                               }
-                       }
-                       else {
-                               convert = true;
-                               global_id_map[id_translated].push_back(id);
-                       }
-                       if (convert) {
-                               std::stringstream out;
-                               out << ++i;
-                               id_translated += out.str();
-                       }
-               }
-               else { global_id_map[id_translated].push_back(id); }
-       }
-       return id_translated;
+  if (id.size() == 0) {
+    return id;
+  }
+
+  std::string id_translated = id;
+  id_translated[0] = translate_start_name_map[(unsigned int)id_translated[0]];
+  for (unsigned int i = 1; i < id_translated.size(); i++) {
+    id_translated[i] = translate_name_map[(unsigned int)id_translated[i]];
+  }
+  // It's so much workload now, the if () should speed up things.
+  if (id_translated != id) {
+    // Search duplicates
+    map_string_list::iterator iter = global_id_map.find(id_translated);
+    if (iter != global_id_map.end()) {
+      unsigned int i = 0;
+      bool found = false;
+      for (i = 0; i < iter->second.size(); i++) {
+        if (id == iter->second[i]) {
+          found = true;
+          break;
+        }
+      }
+      bool convert = false;
+      if (found) {
+        if (i > 0) {
+          convert = true;
+        }
+      }
+      else {
+        convert = true;
+        global_id_map[id_translated].push_back(id);
+      }
+      if (convert) {
+        std::stringstream out;
+        out << ++i;
+        id_translated += out.str();
+      }
+    }
+    else {
+      global_id_map[id_translated].push_back(id);
+    }
+  }
+  return id_translated;
 }
 
 std::string id_name(void *id)
 {
-       return ((ID *)id)->name + 2;
+  return ((ID *)id)->name + 2;
 }
 
 std::string encode_xml(std::string xml)
 {
-       const std::map<char, std::string> escape {
-               {'<' , "&lt;"  },
-               {'>' , "&gt;"  },
-               {'"' , "&quot;"},
-               {'\'', "&apos;"},
-               {'&' , "&amp;" }
-       };
-
-       std::map<char, std::string>::const_iterator it;
-       std::string encoded_xml = "";
-
-       for (unsigned int i = 0; i < xml.size(); i++) {
-               char c = xml.at(i);
-               it = escape.find(c);
-
-               if (it == escape.end()) {
-                       encoded_xml += c;
-               }
-               else {
-                       encoded_xml += it->second;
-               }
-       }
-       return encoded_xml;
+  const std::map<char, std::string> escape{
+      {'<', "&lt;"}, {'>', "&gt;"}, {'"', "&quot;"}, {'\'', "&apos;"}, {'&', "&amp;"}};
+
+  std::map<char, std::string>::const_iterator it;
+  std::string encoded_xml = "";
+
+  for (unsigned int i = 0; i < xml.size(); i++) {
+    char c = xml.at(i);
+    it = escape.find(c);
+
+    if (it == escape.end()) {
+      encoded_xml += c;
+    }
+    else {
+      encoded_xml += it->second;
+    }
+  }
+  return encoded_xml;
 }
 
 std::string get_geometry_id(Object *ob)
 {
-       return translate_id(id_name(ob->data)) + "-mesh";
+  return translate_id(id_name(ob->data)) + "-mesh";
 }
 
 std::string get_geometry_id(Object *ob, bool use_instantiation)
 {
-       std::string geom_name = (use_instantiation) ? id_name(ob->data) : id_name(ob);
+  std::string geom_name = (use_instantiation) ? id_name(ob->data) : id_name(ob);
 
-       return translate_id(geom_name) + "-mesh";
+  return translate_id(geom_name) + "-mesh";
 }
 
 std::string get_light_id(Object *ob)
 {
-       return translate_id(id_name(ob)) + "-light";
+  return translate_id(id_name(ob)) + "-light";
 }
 
 std::string get_joint_sid(Bone *bone)
 {
-       return translate_id(bone->name);
+  return translate_id(bone->name);
 }
 std::string get_joint_sid(EditBone *bone)
 {
-       return translate_id(bone->name);
+  return translate_id(bone->name);
 }
 
 std::string get_camera_id(Object *ob)
 {
-       return translate_id(id_name(ob)) + "-camera";
+  return translate_id(id_name(ob)) + "-camera";
 }
 
 std::string get_effect_id(Material *mat)
 {
-       return translate_id(id_name(mat)) + "-effect";
+  return translate_id(id_name(mat)) + "-effect";
 }
 
 std::string get_material_id(Material *mat)
 {
-       return translate_id(id_name(mat)) + "-material";
+  return translate_id(id_name(mat)) + "-material";
 }
 
 std::string get_morph_id(Object *ob)
 {
-       return translate_id(id_name(ob)) + "-morph";
+  return translate_id(id_name(ob)) + "-morph";
 }