Code/Sandbox/Plugins/MeshImporter/GlobalImportSettings.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2 #include "StdAfx.h"
   3 #include "GlobalImportSettings.h"
   4
   5 #include <Cry3DEngine/I3DEngine.h>
   6 #include <IEditor.h>
   7 #include <IResourceSelectorHost.h>
   8 #include <Material\Material.h>
   9 #include <Material\MaterialManager.h>
  10
  11 #include <CrySerialization/yasli/Archive.h>
  12 #include <CrySerialization/yasli/Enum.h>
  13 #include <CrySerialization/StringList.h>
  14
  15 YASLI_ENUM_BEGIN_NESTED2(FbxTool, Axes, EAxis, "Axis")
  16 YASLI_ENUM(FbxTool::Axes::EAxis::NegX, "-X", "-X");
  17 YASLI_ENUM(FbxTool::Axes::EAxis::NegY, "-Y", "-Y");
  18 YASLI_ENUM(FbxTool::Axes::EAxis::NegZ, "-Z", "-Z");
  19 YASLI_ENUM(FbxTool::Axes::EAxis::PosX, "+X", "+X");
  20 YASLI_ENUM(FbxTool::Axes::EAxis::PosY, "+Y", "+Y");
  21 YASLI_ENUM(FbxTool::Axes::EAxis::PosZ, "+Z", "+Z");
  22 YASLI_ENUM_END()
  23
  24 // If 'scale' corresponds to one of the known standard units (with some small
  25 // tolerance), the unit's symbol is returned. Otherwise, the value of 'scale'
  26 // is converted to string.
  27 static QString FormatUnitSizeInCm(double scale)
  28 {
  29         for (int i = 0; i < FbxMetaData::Units::eUnitSetting_COUNT; ++i)
  30         {
  31                 const auto unit = (FbxMetaData::Units::EUnitSetting)i;
  32                 if (FbxMetaData::Units::eUnitSetting_FromFile != unit)
  33                 {
  34                         if (IsEquivalent((float)scale, (float)FbxMetaData::Units::GetUnitSizeInCm(unit, -1.0)))
  35                         {
  36                                 return QString::fromLatin1(FbxMetaData::Units::GetSymbol(unit));
  37                         }
  38                 }
  39         }
  40         return QString::fromLatin1("%1").arg(scale);
  41 }
  42
  43 static FbxTool::Axes::EAxis GetNextAxisWrapped(FbxTool::Axes::EAxis axis)
  44 {
  45         return FbxTool::Axes::EAxis(((int)axis + 1) % (int)FbxTool::Axes::EAxis::COUNT);
  46 }
  47
  48 ////////////////////////////////////////////////////
  49
  50 CGlobalImportSettings::SConversionSettings::SConversionSettings()
  51         : unit(FbxMetaData::Units::EUnitSetting::eUnitSetting_FromFile)
  52         , scale(1.0f)
  53         , forward(FbxTool::Axes::EAxis::PosX)
  54         , up(FbxTool::Axes::EAxis::PosY)
  55         , oldForward(FbxTool::Axes::EAxis::PosX)
  56         , oldUp(FbxTool::Axes::EAxis::PosY)
  57 {}
  58
  59 void CGlobalImportSettings::SConversionSettings::Serialize(yasli::Archive& ar)
  60 {
  61         Serialization::StringList options;
  62         FbxMetaData::Units::ForallNames([&options](const char* szUnitName)
  63         {
  64                 options.push_back(szUnitName);
  65         });
  66         options[0] += string(" (") + QtUtil::ToString(fileUnitSizeInCm) + string(")");
  67
  68         Serialization::StringListValue dropDown(options, (int)unit);
  69         ar(dropDown, "unit", "Unit");
  70
  71         if (ar.isInput())
  72         {
  73                 unit = (FbxMetaData::Units::EUnitSetting)dropDown.index();
  74         }
  75
  76         ar(scale, "scale", "Scale");
  77         scale = std::max(0.0f, scale);
  78
  79         ar(forward, "forward", "Forward");
  80         ar(up, "up", "Up");
  81
  82         // Make axes selection consistent.
  83
  84         if (forward != oldForward)
  85         {
  86                 assert(!ar.isEdit() || up == oldUp);
  87                 SetForwardAxis(forward);
  88         }
  89         else if (up != oldUp)
  90         {
  91                 assert(!ar.isEdit() || forward == oldForward);
  92                 SetUpAxis(up);
  93         }
  94 }
  95
  96 void CGlobalImportSettings::SConversionSettings::SetForwardAxis(FbxTool::Axes::EAxis axis)
  97 {
  98         oldForward = axis;
  99         forward = axis;
 100         while (FbxTool::Axes::Abs(forward) == FbxTool::Axes::Abs(up))
 101         {
 102                 up = GetNextAxisWrapped(up);
 103         }
 104 }
 105
 106 void CGlobalImportSettings::SConversionSettings::SetUpAxis(FbxTool::Axes::EAxis axis)
 107 {
 108         oldUp = axis;
 109         up = axis;
 110         while (FbxTool::Axes::Abs(forward) == FbxTool::Axes::Abs(up))
 111         {
 112                 forward = GetNextAxisWrapped(forward);
 113         }
 114 }
 115
 116 ////////////////////////////////////////////////////
 117
 118 CGlobalImportSettings::SGeneralSettings::SGeneralSettings()
 119 {}
 120
 121 CGlobalImportSettings::SStaticMeshSettings::SStaticMeshSettings()
 122         : bMergeAllNodes(false)
 123         , bSceneOrigin(false)
 124         , bComputeNormals(false)
 125         , bComputeUv(false)
 126 {}
 127
 128 CGlobalImportSettings::CGlobalImportSettings()
 129         : m_bStaticMeshSettingsEnabled(true)
 130 {}
 131
 132 CGlobalImportSettings::~CGlobalImportSettings() {}
 133
 134 FbxMetaData::Units::EUnitSetting CGlobalImportSettings::GetUnit() const
 135 {
 136         return m_conversionSettings.unit;
 137 }
 138
 139 float CGlobalImportSettings::GetScale() const
 140 {
 141         return m_conversionSettings.scale;
 142 }
 143
 144 FbxTool::Axes::EAxis CGlobalImportSettings::GetUpAxis()
 145 {
 146         return m_conversionSettings.up;
 147 }
 148
 149 FbxTool::Axes::EAxis CGlobalImportSettings::GetForwardAxis()
 150 {
 151         return m_conversionSettings.forward;
 152 }
 153
 154 bool CGlobalImportSettings::IsMergeAllNodes() const
 155 {
 156         return m_staticMeshSettings.bMergeAllNodes;
 157 }
 158
 159 bool CGlobalImportSettings::IsSceneOrigin() const
 160 {
 161         return m_staticMeshSettings.bSceneOrigin;
 162 }
 163
 164 bool CGlobalImportSettings::IsComputeNormals() const
 165 {
 166         return m_staticMeshSettings.bComputeNormals;
 167 }
 168
 169 bool CGlobalImportSettings::IsComputeUv() const
 170 {
 171         return m_staticMeshSettings.bComputeUv;
 172 }
 173
 174 void CGlobalImportSettings::SetInputFilePath(const string& filePath)
 175 {
 176         m_generalSettings.inputFilePath = filePath;
 177         m_generalSettings.inputFilename = PathUtil::GetFileName(m_generalSettings.inputFilePath);
 178 }
 179
 180 void CGlobalImportSettings::SetOutputFilePath(const string& filePath)
 181 {
 182         m_generalSettings.outputFilePath = filePath;
 183         m_generalSettings.outputFilename = PathUtil::GetFileName(m_generalSettings.outputFilePath);
 184 }
 185
 186 void CGlobalImportSettings::ClearFilePaths()
 187 {
 188         m_generalSettings.inputFilePath.clear();
 189         m_generalSettings.outputFilePath.clear();
 190         m_generalSettings.inputFilename.clear();
 191         m_generalSettings.outputFilename.clear();
 192 }
 193
 194 void CGlobalImportSettings::SetFileUnitSizeInCm(double scale)
 195 {
 196         m_conversionSettings.fileUnitSizeInCm = FormatUnitSizeInCm(scale);
 197 }
 198
 199 void CGlobalImportSettings::SetUnit(FbxMetaData::Units::EUnitSetting unit)
 200 {
 201         m_conversionSettings.unit = unit;
 202 }
 203
 204 void CGlobalImportSettings::SetScale(float scale)
 205 {
 206         m_conversionSettings.scale = std::max(0.0f, scale);
 207 }
 208
 209 void CGlobalImportSettings::SetForwardAxis(FbxTool::Axes::EAxis axis)
 210 {
 211         m_conversionSettings.SetForwardAxis(axis);
 212 }
 213
 214 void CGlobalImportSettings::SetUpAxis(FbxTool::Axes::EAxis axis)
 215 {
 216         m_conversionSettings.SetUpAxis(axis);
 217 }
 218
 219 void CGlobalImportSettings::SetMergeAllNodes(bool bMergeAllNodes)
 220 {
 221         m_staticMeshSettings.bMergeAllNodes = bMergeAllNodes;
 222 }
 223
 224 void CGlobalImportSettings::SetSceneOrigin(bool bSceneOrigin)
 225 {
 226         m_staticMeshSettings.bSceneOrigin = bSceneOrigin;
 227 }
 228
 229 void CGlobalImportSettings::SetComputeNormals(bool bComputeNormals)
 230 {
 231         m_staticMeshSettings.bComputeNormals = bComputeNormals;
 232 }
 233
 234 void CGlobalImportSettings::SetComputeUv(bool bComputeUv)
 235 {
 236         m_staticMeshSettings.bComputeUv = bComputeUv;
 237 }
 238
 239 bool CGlobalImportSettings::IsVertexPositionFormatF32() const
 240 {
 241         return m_outputSettings.bVertexPositionFormatF32;
 242 }
 243
 244 void CGlobalImportSettings::SetVertexPositionFormatF32(bool bIs32Bit)
 245 {
 246         m_outputSettings.bVertexPositionFormatF32 = bIs32Bit;
 247 }
 248
 249 void CGlobalImportSettings::SGeneralSettings::Serialize(yasli::Archive& ar)
 250 {
 251         ar(inputFilename, "input_filename", "!Input filename");
 252         ar.doc(inputFilePath);
 253
 254         ar(outputFilename, "output_filename", "!Output filename");
 255         ar.doc(outputFilePath);
 256 }
 257
 258 void CGlobalImportSettings::SStaticMeshSettings::Serialize(yasli::Archive& ar)
 259 {
 260         ar(bMergeAllNodes, "merge_all_nodes", "Merge all nodes");
 261         ar(bSceneOrigin, "scene_origin", "Scene origin");
 262         ar(bComputeNormals, "compute_normals", "Compute normals");
 263         ar.doc("If true the importer computes normals,\n"
 264                 "otherwise the normals are imported from the file.\n"
 265                 "Tangents are computed in any case.");
 266         ar(bComputeUv, "compute_uv", "Compute UV's");
 267         ar.doc("If true the importer generates an automatic UV mapping,\n"
 268                 "otherwise the UV's are imported from the file.\n"
 269                 "Useful for correct calculation of tangents, if the source model does not use textured materials.");
 270 }
 271
 272 void CGlobalImportSettings::Serialize(yasli::Archive& ar)
 273 {
 274         ar(m_generalSettings, "general_settings", "General settings");
 275         if (ar.isInput() || m_bStaticMeshSettingsEnabled)
 276         {
 277                 ar(m_staticMeshSettings, "static_mesh_settings", "Static mesh settings");
 278         }
 279         ar(m_conversionSettings, "conversion_settings", "Conversion settings");
 280         ar(m_outputSettings, "output_settings", "Output settings");
 281 }
 282
 283 void CGlobalImportSettings::SetStaticMeshSettingsEnabled(bool bEnabled)
 284 {
 285         m_bStaticMeshSettingsEnabled = bEnabled;
 286 }
 287
 288 void CGlobalImportSettings::SOutputSettings::Serialize(yasli::Archive& ar)
 289 {
 290         ar(bVertexPositionFormatF32, "use_32_bit_positions", "Use 32bit precision");
 291         ar.doc("When this option is selected, the importer stores vertex positions using 32 bit per coordinate instead of 16 bit.");
 292 }