birkeh
/
o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Integrating github/Helios_RemoveFbxSdk through commit 6dc2604 (#391) (#560)

Browse Source 
Removing FBX SDK, LYN-1045. If you have an issues please reach out to the Helios team.
main
AMZN-stankowi 5 years ago committed by GitHub
parent 01976a890c
commit a7224b6379
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
140 changed files with 101 additions and 8635 deletions
Show Stats Download Patch File Download Diff File

1
Code/Sandbox/Plugins/CMakeLists.txt
Unescape Escape View File

@ -11,7 +11,6 @@
add_subdirectory(EditorCommon)
add_subdirectory(ComponentEntityEditorPlugin)
add_subdirectory(FBXPlugin)
add_subdirectory(FFMPEGPlugin)
add_subdirectory(ProjectSettingsTool)
add_subdirectory(PerforcePlugin)

48
Code/Sandbox/Plugins/FBXPlugin/CMakeLists.txt
Unescape Escape View File

@ -1,48 +0,0 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(NOT PAL_TRAIT_BUILD_HOST_TOOLS)
return()
endif()
include(Platform/${PAL_PLATFORM_NAME}/platform_${PAL_PLATFORM_NAME_LOWERCASE}.cmake)
if(NOT PAL_TRAIT_BUILD_FBX_PLUGIN_SUPPORTED)
return()
endif()
ly_get_list_relative_pal_filename(pal_dir ${CMAKE_CURRENT_LIST_DIR}/Platform/${PAL_PLATFORM_NAME})
ly_add_target(
NAME FBXPlugin MODULE
NAMESPACE Legacy
OUTPUT_SUBDIRECTORY EditorPlugins
AUTOMOC
AUTOUIC
AUTORCC
FILES_CMAKE
fbxplugin_files.cmake
${pal_dir}/platform_${PAL_PLATFORM_NAME_LOWERCASE}_files.cmake
COMPILE_DEFINITIONS
PRIVATE
PLUGIN_EXPORTS
BUILD_DEPENDENCIES
PRIVATE
3rdParty::Qt::Core
3rdParty::Qt::Gui
3rdParty::Qt::Widgets
3rdParty::FbxSdk
Legacy::CryCommon
Legacy::Editor.Headers
Legacy::EditorCore
)
ly_add_dependencies(Editor FBXPlugin)
set_property(GLOBAL APPEND PROPERTY LY_EDITOR_PLUGINS $<TARGET_FILE_NAME:Legacy::FBXPlugin>)

924
Code/Sandbox/Plugins/FBXPlugin/FBXExporter.cpp
Unescape Escape View File

@ -1,924 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "FBXPlugin_precompiled.h"
// FBX SDK Help: http://download.autodesk.com/global/docs/fbxsdk2012/en_us/index.html
#include "FBXExporter.h"
#include "FBXSettingsDlg.h"
#include "IEditor.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// constants used to convert cameras to and from Maya
static const float s_CONVERSION_BAKING_SAMPLE_RATE = 30.0f;
// IMPORT_PRE/POST_ROTATIONS determined by experimentation with fbx2015 in Maya and Max.
// We are transforming a Z-axis forward (Max/Maya) to a negative Y-axis forward camera (Editor).
// Analytically this shold involve a preRotation of -90 degrees around the x-axis.
// For Y-Up scenes, our Open 3D Engine Tools inserts an additional 180 rotation around the Y-axis when orienting .cgf files. We need to
// 'undo' for FBX anim curves. This does not apply to cameras which do not use .cgf files
static const FbxVector4 s_PRE_ROTATION_FOR_YUP_SCENES (-90.0f, .0f, .0f);
static const FbxVector4 s_POST_ROTATION_FOR_YUP_OBJECTS(-90.0f, 180.0f, .0f);
static const FbxVector4 s_POST_ROTATION_FOR_ZFORWARD_CAMERAS(-90.0f, .0f, .0f);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace {
std::string GetFilePath(const std::string& filename)
{
int pos = filename.find_last_of("/\\");
if (pos > 0)
{
return filename.substr(0, pos + 1);
}
return filename;
}
std::string GetFileName(const std::string& fullFilename)
{
int pos = fullFilename.find_last_of("/\\");
if (pos > 0)
{
return fullFilename.substr(pos + 1);
}
return fullFilename;
}
} // namespace
#ifdef DEBUG
///////////////////////////////////////////////////////////////////////
// debugging function to print all the keys in an Fbx Curve
void DebugPrintCurveKeys(FbxAnimCurve* pCurve, const QString& name)
{
if (pCurve)
{
ILog* log = GetIEditor()->GetSystem()->GetILog();
log->Log("\n%s", name);
for (int keyID = 0; keyID < pCurve->KeyGetCount(); ++keyID)
{
FbxAnimCurveKey key = pCurve->KeyGet(keyID);
log->Log("%.2g:%g, ", key.GetTime().GetSecondDouble(), key.GetValue());
}
}
}
#endif
// CFBXExporter
CFBXExporter::CFBXExporter()
: m_pFBXManager(0)
, m_pFBXScene(0)
{
m_settings.bCopyTextures = true;
m_settings.bEmbedded = false;
m_settings.bAsciiFormat = false;
m_settings.bConvertAxesForMaxMaya = false;
}
const char* CFBXExporter::GetExtension() const
{
return "fbx";
}
const char* CFBXExporter::GetShortDescription() const
{
return "FBX format";
}
bool CFBXExporter::ExportToFile(const char* filename, const Export::IData* pData)
{
if (!m_pFBXManager)
{
m_pFBXManager = FbxManager::Create();
}
bool bAnimationExport = false;
for (int objectID = 0; objectID < pData->GetObjectCount(); ++objectID)
{
Export::Object* pObject = pData->GetObject(objectID);
if (pObject->GetEntityAnimationDataCount() > 0)
{
bAnimationExport = true;
break;
}
}
// do nothing if the user cancels
if (!OpenFBXSettingsDlg(m_settings))
{
return false;
}
m_path = GetFilePath(filename);
std::string name = GetFileName(filename);
// create an IOSettings object
FbxIOSettings* pSettings = FbxIOSettings::Create(m_pFBXManager, IOSROOT);
m_pFBXManager->SetIOSettings(pSettings);
// Create a scene object
FbxScene* pFBXScene = FbxScene::Create(m_pFBXManager, "Test");
pFBXScene->GetGlobalSettings().SetAxisSystem(FbxAxisSystem::Max);
pFBXScene->GetGlobalSettings().SetOriginalUpAxis(FbxAxisSystem::Max);
// Create document info
FbxDocumentInfo* pDocInfo = FbxDocumentInfo::Create(m_pFBXManager, "DocInfo");
pDocInfo->mTitle = name.c_str();
pDocInfo->mSubject = "Exported geometry from editor application.";
pDocInfo->mAuthor = "Editor FBX exporter.";
pDocInfo->mRevision = "rev. 1.0";
pDocInfo->mKeywords = "Editor FBX export";
pDocInfo->mComment = "";
pFBXScene->SetDocumentInfo(pDocInfo);
// Create nodes from objects and add them to the scene
FbxNode* pRootNode = pFBXScene->GetRootNode();
FbxAnimStack* pAnimStack = FbxAnimStack::Create(pFBXScene, "AnimStack");
FbxAnimLayer* pAnimBaseLayer = FbxAnimLayer::Create(pFBXScene, "AnimBaseLayer");
pAnimStack->AddMember(pAnimBaseLayer);
int numObjects = pData->GetObjectCount();
m_nodes.resize(0);
m_nodes.reserve(numObjects);
for (int i = 0; i < numObjects; ++i)
{
Export::Object* pObj = pData->GetObject(i);
FbxNode* newNode = NULL;
if (!bAnimationExport)
{
newNode = CreateFBXNode(pObj);
}
else
{
newNode = CreateFBXAnimNode(pFBXScene, pAnimBaseLayer, pObj);
}
m_nodes.push_back(newNode);
}
// solve hierarchy
for (int i = 0; i < m_nodes.size() && i < numObjects; ++i)
{
const Export::Object* pObj = pData->GetObject(i);
FbxNode* pNode = m_nodes[i];
FbxNode* pParentNode = 0;
if (pObj->nParent >= 0 && pObj->nParent < m_nodes.size())
{
pParentNode = m_nodes[pObj->nParent];
}
if (pParentNode)
{
pParentNode->AddChild(pNode);
}
else
{
pRootNode->AddChild(pNode);
}
}
int nFileFormat = -1;
if (m_settings.bAsciiFormat)
{
if (nFileFormat < 0 || nFileFormat >= m_pFBXManager->GetIOPluginRegistry()->GetWriterFormatCount())
{
nFileFormat = m_pFBXManager->GetIOPluginRegistry()->GetNativeWriterFormat();
int lFormatIndex, lFormatCount = m_pFBXManager->GetIOPluginRegistry()->GetWriterFormatCount();
for (lFormatIndex = 0; lFormatIndex < lFormatCount; lFormatIndex++)
{
if (m_pFBXManager->GetIOPluginRegistry()->WriterIsFBX(lFormatIndex))
{
FbxString lDesc = m_pFBXManager->GetIOPluginRegistry()->GetWriterFormatDescription(lFormatIndex);
const char* lASCII = "ascii";
if (lDesc.Find(lASCII) >= 0)
{
nFileFormat = lFormatIndex;
break;
}
}
}
}
}
pSettings->SetBoolProp(EXP_FBX_EMBEDDED, m_settings.bEmbedded);
if (m_settings.bConvertAxesForMaxMaya)
{
// convert the scene from our Z-Up world to Maya's Y-Up World. This is stored in the FBX scene and both Max & Maya will
// import accordingly
FbxAxisSystem::MayaYUp.ConvertScene(pFBXScene);
// process all camera nodes in the scene to make them look down their negative Z-axis
convertCamerasForMaxMaya(pFBXScene->GetRootNode());
}
//Save a scene
bool bRet = false;
FbxExporter* pFBXExporter = FbxExporter::Create(m_pFBXManager, name.c_str());
// For backward compatilibity choose a widely compatible FBX version that's been out for a while:
if (pFBXExporter)
{
pFBXExporter->SetFileExportVersion(FBX_2014_00_COMPATIBLE);
if (pFBXExporter->Initialize(filename, nFileFormat, pSettings))
{
bRet = pFBXExporter->Export(pFBXScene);
}
pFBXExporter->Destroy();
}
pFBXScene->Destroy();
m_materials.clear();
m_meshMaterialIndices.clear();
m_pFBXManager->Destroy();
m_pFBXManager = 0;
if (bRet)
{
GetIEditor()->GetSystem()->GetILog()->Log("\nFBX Exporter: Exported successfully to %s.", name.c_str());
}
else
{
GetIEditor()->GetSystem()->GetILog()->LogError("\nFBX Exporter: Failed.");
}
return bRet;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This method finds all cameras (via recursion) in the node tree rooted at pNode and bakes the necessary
// transforms into any cameras it finds to take care of the conversion from Maya Z-forward to our negative-y forward cameras
void CFBXExporter::convertCamerasForMaxMaya(FbxNode* pNode) const
{
if (pNode)
{
// recurse to children to convert all cameras in the level
for (int i = 0; i < pNode->GetChildCount(); i++)
{
convertCamerasForMaxMaya(pNode->GetChild(i));
}
// process this node if it's a camera
convertCameraForMaxMaya(pNode);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Maya cameras look down the negative z-axis. Ours look down the positive-y. This method bakes the necessary transforms
// into the local transforms of the given pNode if it's a camera to take care of the conversion
void CFBXExporter::convertCameraForMaxMaya(FbxNode* pNode) const
{
// Maya puts in an extra 90 x-rotation in the "Rotate Axis" channel. Adding an extra post-rotation fixes this,
// determined experimentally
static const FbxVector4 s_EXTRA_EXPORT_POST_ROTATION_FOR_MAX_MAYA(.0f, -90.0f, .0f);
if (pNode && pNode->GetNodeAttribute() && pNode->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eCamera)
{
// bake in s_PRE/POST_ROTATION_FOR_MAYA into anim curves
pNode->SetPivotState(FbxNode::eSourcePivot, FbxNode::ePivotActive);
pNode->SetPivotState(FbxNode::eDestinationPivot, FbxNode::ePivotActive);
pNode->SetPreRotation(FbxNode::eSourcePivot, s_PRE_ROTATION_FOR_YUP_SCENES);
pNode->SetPostRotation(FbxNode::eSourcePivot, s_POST_ROTATION_FOR_ZFORWARD_CAMERAS);
pNode->ResetPivotSetAndConvertAnimation(s_CONVERSION_BAKING_SAMPLE_RATE, true); // bake postRotation in for all animStacks
// Maya puts in an extra 90 x-rotation in the "Rotate Axis" channel. Adding an extra post-rotation after the baking of transforms
// fixes this - i.e. baked transformes change the camera's local rotation channels themselves, post-bake post-transforms get
// stuffed into Maya's 'Rotate Axis' channels
pNode->SetPostRotation(FbxNode::eSourcePivot, s_EXTRA_EXPORT_POST_ROTATION_FOR_MAX_MAYA);
}
}
FbxMesh* CFBXExporter::CreateFBXMesh(const Export::Object* pObj)
{
if (!m_pFBXManager)
{
return 0;
}
int numVertices = pObj->GetVertexCount();
const Export::Vector3D* pVerts = pObj->GetVertexBuffer();
int numMeshes = pObj->GetMeshCount();
int numAllFaces = 0;
for (int j = 0; j < numMeshes; ++j)
{
const Export::Mesh* pMesh = pObj->GetMesh(j);
int numFaces = pMesh->GetFaceCount();
numAllFaces += numFaces;
}
if (numVertices == 0 || numAllFaces == 0)
{
return 0;
}
FbxMesh* pFBXMesh = FbxMesh::Create(m_pFBXManager, pObj->name);
pFBXMesh->InitControlPoints(numVertices);
FbxVector4* pControlPoints = pFBXMesh->GetControlPoints();
for (int i = 0; i < numVertices; ++i)
{
const Export::Vector3D& vertex = pVerts[i];
pControlPoints[i] = FbxVector4(vertex.x, vertex.y, vertex.z);
}
/*
// We want to have one normal for each vertex (or control point),
// so we set the mapping mode to eBY_CONTROL_POINT.
FbxGeometryElementNormal* lElementNormal= pFBXMesh->CreateElementNormal();
//FbxVector4 lNormalZPos(0, 0, 1);
lElementNormal->SetMappingMode(FbxGeometryElement::eBY_CONTROL_POINT);
// Set the normal values for every control point.
lElementNormal->SetReferenceMode(FbxGeometryElement::eDIRECT);
lElementNormal->GetDirectArray().Add(lNormalZPos);
*/
int numTexCoords = pObj->GetTexCoordCount();
const Export::UV* pTextCoords = pObj->GetTexCoordBuffer();
if (numTexCoords)
{
// Create UV for Diffuse channel.
FbxGeometryElementUV* pFBXDiffuseUV = pFBXMesh->CreateElementUV("DiffuseUV");
FBX_ASSERT(pFBXDiffuseUV != NULL);
pFBXDiffuseUV->SetMappingMode(FbxGeometryElement::eByPolygonVertex);
pFBXDiffuseUV->SetReferenceMode(FbxGeometryElement::eIndexToDirect);
for (int i = 0; i < numTexCoords; ++i)
{
const Export::UV& textCoord = pTextCoords[i];
pFBXDiffuseUV->GetDirectArray().Add(FbxVector2(textCoord.u, textCoord.v));
}
//Now we have set the UVs as eINDEX_TO_DIRECT reference and in eBY_POLYGON_VERTEX mapping mode
//we must update the size of the index array.
pFBXDiffuseUV->GetIndexArray().SetCount(numTexCoords);
}
pFBXMesh->ReservePolygonCount(numAllFaces);
pFBXMesh->ReservePolygonVertexCount(numAllFaces * 3);
// Set material mapping.
FbxGeometryElementMaterial* pMaterialElement = pFBXMesh->CreateElementMaterial();
pMaterialElement->SetMappingMode(FbxGeometryElement::eByPolygon);
pMaterialElement->SetReferenceMode(FbxGeometryElement::eIndexToDirect);
for (int j = 0; j < numMeshes; ++j)
{
const Export::Mesh* pMesh = pObj->GetMesh(j);
// Write all faces, convert the indices to one based indices
int numFaces = pMesh->GetFaceCount();
int polygonCount = pFBXMesh->GetPolygonCount();
pMaterialElement->GetIndexArray().SetCount(polygonCount + numFaces);
int materialIndex = m_meshMaterialIndices[pMesh];
const Export::Face* pFaces = pMesh->GetFaceBuffer();
for (int i = 0; i < numFaces; ++i)
{
const Export::Face& face = pFaces[i];
pFBXMesh->BeginPolygon(-1, -1, -1, false);
pFBXMesh->AddPolygon(face.idx[0], face.idx[0]);
pFBXMesh->AddPolygon(face.idx[1], face.idx[1]);
pFBXMesh->AddPolygon(face.idx[2], face.idx[2]);
//pFBXDiffuseUV->GetIndexArray().SetAt(face.idx[0], face.idx[0]);
pFBXMesh->EndPolygon();
//pPolygonGroupElement->GetIndexArray().Add(j);
pMaterialElement->GetIndexArray().SetAt(polygonCount + i, materialIndex);
}
}
return pFBXMesh;
}
FbxFileTexture* CFBXExporter::CreateFBXTexture(const char* pTypeName, const char* pName)
{
std::string filename = pName;
if (m_settings.bCopyTextures)
{
// check if file exists
QFileInfo fi(pName);
if (!fi.exists() || fi.isDir())
{
GetIEditor()->GetSystem()->GetILog()->LogError("\nFBX Exporter: Texture %s is not on the disk.", pName);
}
else
{
filename = m_path;
filename += GetFileName(pName);
if (QFile::copy(pName, filename.c_str()))
{
GetIEditor()->GetSystem()->GetILog()->Log("\nFBX Exporter: Texture %s was copied.", pName);
}
filename = GetFileName(pName); // It works for Maya, but not good for MAX
}
}
FbxFileTexture* pFBXTexture = FbxFileTexture::Create(m_pFBXManager, pTypeName);
pFBXTexture->SetFileName(filename.c_str());
pFBXTexture->SetTextureUse(FbxTexture::eStandard);
pFBXTexture->SetMappingType(FbxTexture::eUV);
pFBXTexture->SetMaterialUse(FbxFileTexture::eModelMaterial);
pFBXTexture->SetSwapUV(false);
pFBXTexture->SetTranslation(0.0, 0.0);
pFBXTexture->SetScale(1.0, 1.0);
pFBXTexture->SetRotation(0.0, 0.0);
return pFBXTexture;
}
FbxSurfaceMaterial* CFBXExporter::CreateFBXMaterial(const std::string& name, const Export::Mesh* pMesh)
{
auto it = m_materials.find(name);
if (it != m_materials.end())
{
return it->second;
}
FbxSurfacePhong* pMaterial = FbxSurfacePhong::Create(m_pFBXManager, name.c_str());
pMaterial->Diffuse.Set(FbxDouble3(pMesh->material.diffuse.r, pMesh->material.diffuse.g, pMesh->material.diffuse.b));
pMaterial->DiffuseFactor.Set(1.0);
pMaterial->Specular.Set(FbxDouble3(pMesh->material.specular.r, pMesh->material.specular.g, pMesh->material.specular.b));
pMaterial->SpecularFactor.Set(1.0);
// Opacity
pMaterial->TransparentColor.Set(FbxDouble3(1.0f, 1.0f, 1.0f)); // need explicitly setup
pMaterial->TransparencyFactor.Set(1.0f - pMesh->material.opacity);
// Glossiness
// CRC TODO: Why was this commented out?
//pMaterial->Shininess.Set(pow(2, pMesh->material.shininess * 10));
if (pMesh->material.mapDiffuse[0] != '\0')
{
FbxFileTexture* pFBXTexture = CreateFBXTexture("Diffuse", pMesh->material.mapDiffuse);
pMaterial->Diffuse.ConnectSrcObject(pFBXTexture);
}
if (pMesh->material.mapSpecular[0] != '\0')
{
FbxFileTexture* pFBXTexture = CreateFBXTexture("Specular", pMesh->material.mapSpecular);
pMaterial->Specular.ConnectSrcObject(pFBXTexture);
}
if (pMesh->material.mapOpacity[0] != '\0')
{
FbxFileTexture* pFBXTexture = CreateFBXTexture("Opacity", pMesh->material.mapOpacity);
pMaterial->TransparentColor.ConnectSrcObject(pFBXTexture);
}
// CRC TODO: Why was this commented out?
/*
if (pMesh->material.mapBump[0] != '\0')
{
FbxFileTexture* pFBXTexture = CreateFBXTexture("Bump", pMesh->material.mapBump);
pMaterial->Bump.ConnectSrcObject(pFBXTexture);
}
*/
if (pMesh->material.mapDisplacement[0] != '\0')
{
FbxFileTexture* pFBXTexture = CreateFBXTexture("Displacement", pMesh->material.mapDisplacement);
pMaterial->DisplacementColor.ConnectSrcObject(pFBXTexture);
}
m_materials[name] = pMaterial;
return pMaterial;
}
FbxNode* CFBXExporter::CreateFBXAnimNode(FbxScene* pScene, FbxAnimLayer* pAnimBaseLayer, const Export::Object* pObj)
{
FbxNode* pAnimNode = FbxNode::Create(pScene, pObj->name);
pAnimNode->LclTranslation.GetCurveNode(pAnimBaseLayer, true);
pAnimNode->LclRotation.GetCurveNode(pAnimBaseLayer, true);
pAnimNode->LclScaling.GetCurveNode(pAnimBaseLayer, true);
FbxCamera* pCamera = FbxCamera::Create(pScene, pObj->name);
if (pObj->entityType == Export::eCamera)
{
pCamera->SetApertureMode(FbxCamera::eHorizontal);
pCamera->SetFormat(FbxCamera::eCustomFormat);
pCamera->SetAspect(FbxCamera::eFixedRatio, 1.777778f, 1.0);
pAnimNode->SetNodeAttribute(pCamera);
if (pObj->cameraTargetNodeName[0])
{
for (int i = 0; i < m_nodes.size(); ++i)
{
FbxNode* pCameraTargetNode = m_nodes[i];
const char* nodeName = pCameraTargetNode->GetName();
if (strcmp(nodeName, pObj->cameraTargetNodeName) == 0)
{
FbxMarker* pMarker = FbxMarker::Create(pScene, "");
pCameraTargetNode->SetNodeAttribute(pMarker);
pAnimNode->SetTarget(pCameraTargetNode);
}
}
}
}
if (pObj->GetEntityAnimationDataCount() > 0)
{
int animDataCount = pObj->GetEntityAnimationDataCount();
for (int animDataIndex = 0; animDataIndex < animDataCount; ++animDataIndex)
{
const Export::EntityAnimData* pAnimData = pObj->GetEntityAnimationData(animDataIndex);
FbxTime time = 0;
time.SetSecondDouble(pAnimData->keyTime);
FbxAnimCurve* pCurve = NULL;
switch (pAnimData->dataType)
{
case Export::AnimParamType::PositionX:
pCurve = pAnimNode->LclTranslation.GetCurve(pAnimBaseLayer, "X", true);
break;
case Export::AnimParamType::PositionY:
pCurve = pAnimNode->LclTranslation.GetCurve(pAnimBaseLayer, "Y", true);
break;
case Export::AnimParamType::PositionZ:
pCurve = pAnimNode->LclTranslation.GetCurve(pAnimBaseLayer, "Z", true);
break;
case Export::AnimParamType::RotationX:
pCurve = pAnimNode->LclRotation.GetCurve(pAnimBaseLayer, "X", true);
break;
case Export::AnimParamType::RotationY:
pCurve = pAnimNode->LclRotation.GetCurve(pAnimBaseLayer, "Y", true);
break;
case Export::AnimParamType::RotationZ:
pCurve = pAnimNode->LclRotation.GetCurve(pAnimBaseLayer, "Z", true);
break;
case Export::AnimParamType::FOV:
{
pCurve = pCamera->FieldOfView.GetCurve(pAnimBaseLayer, "FieldOfView", true);
}
break;
default:
break;
}
if (pCurve)
{
int keyIndex = 0;
pCurve->KeyModifyBegin();
keyIndex = pCurve->KeyInsert(time);
pCurve->KeySet(keyIndex, time, pAnimData->keyValue, FbxAnimCurveDef::eInterpolationCubic, FbxAnimCurveDef::eTangentBreak, pAnimData->rightTangent, pAnimData->leftTangent, FbxAnimCurveDef::eWeightedAll, pAnimData->rightTangentWeight, pAnimData->leftTangentWeight);
pCurve->KeySetLeftDerivative(keyIndex, pAnimData->leftTangent);
pCurve->KeySetRightDerivative(keyIndex, pAnimData->rightTangent);
pCurve->KeySetLeftTangentWeight(keyIndex, pAnimData->leftTangentWeight);
pCurve->KeySetRightTangentWeight(keyIndex, pAnimData->rightTangentWeight);
FbxAnimCurveTangentInfo keyLeftInfo;
keyLeftInfo.mAuto = 0;
keyLeftInfo.mDerivative = pAnimData->leftTangent;
keyLeftInfo.mWeight = pAnimData->leftTangentWeight;
keyLeftInfo.mWeighted = true;
keyLeftInfo.mVelocity = 0.0f;
keyLeftInfo.mHasVelocity = false;
FbxAnimCurveTangentInfo keyRightInfo;
keyRightInfo.mAuto = 0;
keyRightInfo.mDerivative = pAnimData->rightTangent;
keyRightInfo.mWeight = pAnimData->rightTangentWeight;
keyRightInfo.mWeighted = true;
keyRightInfo.mVelocity = 0.0f;
keyRightInfo.mHasVelocity = false;
pCurve->KeySetLeftDerivativeInfo(keyIndex, keyLeftInfo);
pCurve->KeySetRightDerivativeInfo(keyIndex, keyRightInfo);
pCurve->KeyModifyEnd();
}
}
}
return pAnimNode;
}
FbxNode* CFBXExporter::CreateFBXNode(const Export::Object* pObj)
{
if (!m_pFBXManager)
{
return 0;
}
// create a FbxNode
FbxNode* pNode = FbxNode::Create(m_pFBXManager, pObj->name);
pNode->LclTranslation.Set(FbxVector4(pObj->pos.x, pObj->pos.y, pObj->pos.z));
// Rotation: Create Euler angels from quaternion throughout a matrix
FbxAMatrix rotMat;
rotMat.SetQ(FbxQuaternion(pObj->rot.v.x, pObj->rot.v.y, pObj->rot.v.z, pObj->rot.w));
pNode->LclRotation.Set(rotMat.GetR());
pNode->LclScaling.Set(FbxVector4(pObj->scale.x, pObj->scale.y, pObj->scale.z));
// collect materials
int materialIndex = 0;
if (pObj->GetMeshCount() != 0 && pObj->materialName[0] != '\0')
{
for (int i = 0; i < pObj->GetMeshCount(); ++i)
{
const Export::Mesh* pMesh = pObj->GetMesh(i);
if (pMesh->material.name[0] == '\0')
{
continue;
}
// find if material was created for this object
int findIndex = -1;
for (int j = 0; j < i; ++j)
{
const Export::Mesh* pTestMesh = pObj->GetMesh(j);
if (!strcmp(pTestMesh->material.name, pMesh->material.name))
{
findIndex = m_meshMaterialIndices[pTestMesh];
break;
}
}
if (findIndex != -1)
{
m_meshMaterialIndices[pMesh] = findIndex;
continue;
}
std::string materialName = pObj->materialName;
if (strcmp(pObj->materialName, pMesh->material.name))
{
materialName += ':';
materialName += pMesh->material.name;
}
FbxSurfaceMaterial* pFBXMaterial = CreateFBXMaterial(materialName, pMesh);
if (pFBXMaterial)
{
pNode->AddMaterial(pFBXMaterial);
m_meshMaterialIndices[pMesh] = materialIndex++;
}
}
}
FbxMesh* pFBXMesh = CreateFBXMesh(pObj);
if (pFBXMesh)
{
pNode->SetNodeAttribute(pFBXMesh);
pNode->SetShadingMode(FbxNode::eTextureShading);
}
return pNode;
}
void CFBXExporter::Release()
{
delete this;
}
inline f32 Maya2SandboxFOVDeg(const f32 fov, const f32 ratio) { return RAD2DEG(2.0f * atanf(tan(DEG2RAD(fov) / 2.0f) / ratio)); };
void CFBXExporter::FillAnimationData(Export::Object* pObject, FbxNode* pNode, [[maybe_unused]] FbxAnimLayer* pAnimLayer, FbxAnimCurve* pCurve, Export::AnimParamType paramType)
{
if (pCurve)
{
for (int keyID = 0; keyID < pCurve->KeyGetCount(); ++keyID)
{
Export::EntityAnimData entityData;
FbxAnimCurveKey key = pCurve->KeyGet(keyID);
entityData.keyValue = key.GetValue();
FbxTime time = key.GetTime();
entityData.keyTime = aznumeric_cast<float>(time.GetSecondDouble());
entityData.leftTangent = pCurve->KeyGetLeftDerivative(keyID);
entityData.rightTangent = pCurve->KeyGetRightDerivative(keyID);
entityData.leftTangentWeight = pCurve->KeyGetLeftTangentWeight(keyID);
entityData.rightTangentWeight = pCurve->KeyGetRightTangentWeight(keyID);
if (paramType == Export::AnimParamType::FocalLength && pNode && pNode->GetCamera())
{
// special handling for Focal Length - we convert it to FoV for use in-engine (including switching the paramType)
// We handle this because Maya 2015 doesn't save Angle of View or Field of View animation in FBX - it only uses FocalLength.
entityData.dataType = Export::AnimParamType::FOV;
// Open 3D Engine field of view is the vertical angle
pNode->GetCamera()->SetApertureMode(FbxCamera::eVertical);
entityData.keyValue = aznumeric_cast<float>(pNode->GetCamera()->ComputeFieldOfView(entityData.keyValue));
}
else
{
entityData.dataType = paramType;
}
// If the Exporter is Sandbox or Maya, convert fov, positions
QString exporterName = m_pFBXScene->GetDocumentInfo()->Original_ApplicationName.Get().Buffer();
if (!exporterName.toLower().contains("3ds"))
{
if (paramType == Export::AnimParamType::PositionX || paramType == Export::AnimParamType::PositionY || paramType == Export::AnimParamType::PositionZ)
{
entityData.rightTangent /= 100.0f;
entityData.leftTangent /= 100.0f;
entityData.keyValue /= 100.0f;
}
else if (paramType == Export::AnimParamType::FOV) // Maya 2015 uses FocalLength instead of FoV - assuming this is for legacy Sandbox or Maya?
{
const float kAspectRatio = 1.777778f;
entityData.keyValue = Maya2SandboxFOVDeg(entityData.keyValue, kAspectRatio);
}
}
pObject->SetEntityAnimationData(entityData);
}
}
}
bool CFBXExporter::ImportFromFile(const char* filename, Export::IData* pData)
{
FbxManager* pFBXManager = FbxManager::Create();
FbxScene* pFBXScene = FbxScene::Create(pFBXManager, "Test");
m_pFBXScene = pFBXScene;
pFBXScene->GetGlobalSettings().SetAxisSystem(FbxAxisSystem::Max);
pFBXScene->GetGlobalSettings().SetOriginalUpAxis(FbxAxisSystem::Max);
FbxImporter* pImporter = FbxImporter::Create(pFBXManager, "");
FbxIOSettings* pSettings = FbxIOSettings::Create(pFBXManager, IOSROOT);
pFBXManager->SetIOSettings(pSettings);
pSettings->SetBoolProp(IMP_FBX_ANIMATION, true);
const bool lImportStatus = pImporter->Initialize(filename, -1, pFBXManager->GetIOSettings());
if (!lImportStatus)
{
return false;
}
bool bLoadStatus = pImporter->Import(pFBXScene);
if (!bLoadStatus)
{
return false;
}
// record the original axis system used in the import file and then convert the file to Open 3D Engine's coord system,
// which matches Max's (Z-Up, negative Y-forward cameras)
int upSign = 1;
FbxAxisSystem importFileAxisSystem = pFBXScene->GetGlobalSettings().GetAxisSystem();
FbxAxisSystem::EUpVector importSceneUpVector = importFileAxisSystem.GetUpVector(upSign);
FbxAxisSystem::Max.ConvertScene(pFBXScene);
QString exporterName = pFBXScene->GetDocumentInfo()->Original_ApplicationName.Get().Buffer();
// const bool fromMaya = (exporterName.contains("maya", Qt::CaseInsensitive));
// const bool fromMax = (exporterName.contains("max", Qt::CaseInsensitive));
FbxNode* pRootNode = pFBXScene->GetRootNode();
if (pRootNode)
{
for (int animStackID = 0; animStackID < pFBXScene->GetSrcObjectCount<FbxAnimStack>(); ++animStackID)
{
FbxAnimStack* pAnimStack = pFBXScene->GetSrcObject<FbxAnimStack>(animStackID);
const int animLayersCount = pAnimStack->GetMemberCount<FbxAnimLayer>();
for (int layerID = 0; layerID < animLayersCount; ++layerID)
{
FbxAnimLayer* pAnimLayer = pAnimStack->GetMember<FbxAnimLayer>(layerID);
const int nodeCount = pRootNode->GetChildCount();
for (int nodeID = 0; nodeID < nodeCount; ++nodeID)
{
FbxNode* pNode = pRootNode->GetChild(nodeID);
if (pNode)
{
FbxAnimCurve* pCurve = 0;
Export::Object* pObject = pData->AddObject(pNode->GetName());
if (pObject)
{
azstrncpy(pObject->name, sizeof(pObject->name), pNode->GetName(), sizeof(pObject->name) - 1);
pObject->name[sizeof(pObject->name) - 1] = '\0';
FbxCamera* pCamera = pNode->GetCamera();
// convert animation for Y-Up scenes and for Z-forward Cameras
if (importSceneUpVector == FbxAxisSystem::eYAxis || pCamera)
{
pNode->SetPivotState(FbxNode::eSourcePivot, FbxNode::ePivotActive);
pNode->SetPivotState(FbxNode::eDestinationPivot, FbxNode::ePivotActive);
if (importSceneUpVector == FbxAxisSystem::eYAxis)
{
// Maps RY to -RZ and RZ to RY
pNode->SetPreRotation(FbxNode::eSourcePivot, s_PRE_ROTATION_FOR_YUP_SCENES);
}
if (pCamera)
{
// Converts Y-Up, -Z-forward cameras to Open 3D Engine Z-Up, Y-forward cameras
// It is needed regardless of the scene up vector
pNode->SetPostRotation(FbxNode::eSourcePivot, s_POST_ROTATION_FOR_ZFORWARD_CAMERAS);
}
else
{
// Objects from a Y-Up scene (i.e. not cameras). 'undo' the extra transform that the Open 3D Engine Tool
// bakes in to .cgf files from YUp scenes.
pNode->SetPostRotation(FbxNode::eSourcePivot, s_POST_ROTATION_FOR_YUP_OBJECTS);
}
// bake the pre/post rotations into the anim curves
pNode->ConvertPivotAnimationRecursive(pAnimStack, FbxNode::eSourcePivot, s_CONVERSION_BAKING_SAMPLE_RATE);
}
if (pCamera)
{
// extract specialized channels for cameras
pCurve = pCamera->FocalLength.GetCurve(pAnimLayer, "FocalLength");
FillAnimationData(pObject, pNode, pAnimLayer, pCurve, Export::AnimParamType::FocalLength);
pCurve = pCamera->FieldOfView.GetCurve(pAnimLayer, "FieldOfView", true);
FillAnimationData(pObject, pNode, pAnimLayer, pCurve, Export::AnimParamType::FOV);
}
pCurve = pNode->LclTranslation.GetCurve(pAnimLayer, "X");
FillAnimationData(pObject, pNode, pAnimLayer, pCurve, Export::AnimParamType::PositionX);
pCurve = pNode->LclTranslation.GetCurve(pAnimLayer, "Y");
FillAnimationData(pObject, pNode, pAnimLayer, pCurve, Export::AnimParamType::PositionY);
pCurve = pNode->LclTranslation.GetCurve(pAnimLayer, "Z");
FillAnimationData(pObject, pNode, pAnimLayer, pCurve, Export::AnimParamType::PositionZ);
pCurve = pNode->LclRotation.GetCurve(pAnimLayer, "X");
FillAnimationData(pObject, pNode, pAnimLayer, pCurve, Export::AnimParamType::RotationX);
pCurve = pNode->LclRotation.GetCurve(pAnimLayer, "Y");
FillAnimationData(pObject, pNode, pAnimLayer, pCurve, Export::AnimParamType::RotationY);
pCurve = pNode->LclRotation.GetCurve(pAnimLayer, "Z");
FillAnimationData(pObject, pNode, pAnimLayer, pCurve, Export::AnimParamType::RotationZ);
}
}
}
}
}
}
return true;
}

65
Code/Sandbox/Plugins/FBXPlugin/FBXExporter.h
Unescape Escape View File

@ -1,65 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Export geometry to FBX file format
#ifndef CRYINCLUDE_FBXPLUGIN_FBXEXPORTER_H
#define CRYINCLUDE_FBXPLUGIN_FBXEXPORTER_H
#pragma once
#include <Include/IExportManager.h>
#include "fbxsdk.h"
struct SFBXSettings
{
bool bCopyTextures;
bool bEmbedded;
bool bAsciiFormat;
bool bConvertAxesForMaxMaya;
};
class CFBXExporter
: public IExporter
{
public:
CFBXExporter();
virtual const char* GetExtension() const;
virtual const char* GetShortDescription() const;
virtual bool ExportToFile(const char* filename, const Export::IData* pData);
virtual bool ImportFromFile(const char* filename, Export::IData* pData);
virtual void Release();
private:
// recursively traverse all nodes under pNode and reset prerotations for camera nodes by calling convertCameraForMaxMaya on them
void convertCamerasForMaxMaya(FbxNode* node) const;
// reset prerotations for a specified nodes if it's a camera
void convertCameraForMaxMaya(FbxNode* pNode) const;
FbxMesh* CreateFBXMesh(const Export::Object* pObj);
FbxFileTexture* CreateFBXTexture(const char* pTypeName, const char* pName);
FbxSurfaceMaterial* CreateFBXMaterial(const std::string& name, const Export::Mesh* pMesh);
FbxNode* CreateFBXNode(const Export::Object* pObj);
FbxNode* CreateFBXAnimNode(FbxScene* pScene, FbxAnimLayer* pCameraAnimBaseLayer, const Export::Object* pObj);
void FillAnimationData(Export::Object* pObject, FbxNode* pNode, FbxAnimLayer* pAnimLayer, FbxAnimCurve* pCurve, Export::AnimParamType paramType);
FbxManager* m_pFBXManager;
SFBXSettings m_settings;
FbxScene* m_pFBXScene;
std::string m_path;
std::vector<FbxNode*> m_nodes;
std::map<std::string, FbxSurfaceMaterial*> m_materials;
std::map<const Export::Mesh*, int> m_meshMaterialIndices;
};
#endif // CRYINCLUDE_FBXPLUGIN_FBXEXPORTER_H

68
Code/Sandbox/Plugins/FBXPlugin/FBXPlugin.cpp
Unescape Escape View File

@ -1,68 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "FBXPlugin_precompiled.h"
#include "FBXPlugin.h"
namespace PluginInfo
{
const char* kName = "FBX Exporter";
const char* kGUID = "{6CD02F95-362C-4ADF-8BAE-87C6342A8027}";
const int kVersion = 1;
}
void CFBXPlugin::Release()
{
delete this;
}
void CFBXPlugin::ShowAbout()
{
}
const char* CFBXPlugin::GetPluginGUID()
{
return PluginInfo::kGUID;
}
DWORD CFBXPlugin::GetPluginVersion()
{
return PluginInfo::kVersion;
}
const char* CFBXPlugin::GetPluginName()
{
return PluginInfo::kName;
}
bool CFBXPlugin::CanExitNow()
{
return true;
}
void CFBXPlugin::Serialize([[maybe_unused]] FILE* hFile, [[maybe_unused]] bool bIsStoring)
{
}
void CFBXPlugin::ResetContent()
{
}
bool CFBXPlugin::CreateUIElements()
{
return true;
}
void CFBXPlugin::OnEditorNotify([[maybe_unused]] EEditorNotifyEvent aEventId)
{
}

43
Code/Sandbox/Plugins/FBXPlugin/FBXPlugin.h
Unescape Escape View File

@ -1,43 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#pragma once
////////////////////////////////////////////////////////////////////////////
//
// Crytek Engine Source File.
// Copyright (C), Crytek Studios, 2001-2012
// -------------------------------------------------------------------------
// Created: 24 June 2011 by Sergiy Shaykin.
// Description: Attachment to the Sandbox plug-in system
//
////////////////////////////////////////////////////////////////////////////
#ifndef CRYINCLUDE_FBXPLUGIN_FBXPLUGIN_H
#define CRYINCLUDE_FBXPLUGIN_FBXPLUGIN_H
#include <Include/IPlugin.h>
class CFBXPlugin
: public IPlugin
{
public:
void Release();
void ShowAbout();
const char* GetPluginGUID();
DWORD GetPluginVersion();
const char* GetPluginName();
bool CanExitNow();
void Serialize(FILE* hFile, bool bIsStoring);
void ResetContent();
bool CreateUIElements();
void OnEditorNotify(EEditorNotifyEvent aEventId);
};
#endif // CRYINCLUDE_FBXPLUGIN_FBXPLUGIN_H

104
Code/Sandbox/Plugins/FBXPlugin/FBXPlugin.rc
Unescape Escape View File

@ -1,104 +0,0 @@
// Microsoft Visual C++ generated resource script.
//
#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include "winres.h"
/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
// English (United States) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
#pragma code_page(1252)
#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//
1 TEXTINCLUDE
BEGIN
"resource.h\0"
END
2 TEXTINCLUDE
BEGIN
"#include ""winres.h""\r\n"
"\0"
END
3 TEXTINCLUDE
BEGIN
"\r\n"
"\0"
END
#endif // APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Dialog
//
IDD_FBX_EXPORT_SETTINGS DIALOGEX 0, 0, 202, 96
STYLE DS_SETFONT | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU
EXSTYLE WS_EX_TOOLWINDOW
CAPTION "FBX Export Settings"
FONT 8, "MS Shell Dlg", 400, 0, 0x0
BEGIN
CONTROL "Copy textures into folder with FBX file",IDC_COPY_TEXTURES,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,15,11,137,10
CONTROL "Embedded data (Put textures inside FBX file)",IDC_EMBEDDED,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,15,25,157,10
COMBOBOX IDC_FILE_FORMAT,71,53,100,30,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
PUSHBUTTON "OK",IDOK,88,75,50,14
PUSHBUTTON "Cancel",IDCANCEL,140,75,50,14
LTEXT "File Format:",IDC_STATIC,15,55,39,8
CONTROL "Convert Cameras for Max/Maya",IDC_CONVERT_CAMERAS_FOR_MAX_MAYA,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,15,39,137,10
END
/////////////////////////////////////////////////////////////////////////////
//
// DESIGNINFO
//
#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO
BEGIN
IDD_FBX_EXPORT_SETTINGS, DIALOG
BEGIN
LEFTMARGIN, 6
RIGHTMARGIN, 190
TOPMARGIN, 7
BOTTOMMARGIN, 89
END
END
#endif // APSTUDIO_INVOKED
#endif // English (United States) resources
/////////////////////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//
/////////////////////////////////////////////////////////////////////////////
#endif // not APSTUDIO_INVOKED

15
Code/Sandbox/Plugins/FBXPlugin/FBXPlugin_precompiled.cpp
Unescape Escape View File

@ -1,15 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "FBXPlugin_precompiled.h"

39
Code/Sandbox/Plugins/FBXPlugin/FBXPlugin_precompiled.h
Unescape Escape View File

@ -1,39 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#pragma once
#include <AzCore/PlatformDef.h>
#include "resource.h"
/////////////////////////////////////////////////////////////////////////////
// CRY Stuff ////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
#include <platform.h>
/////////////////////////////////////////////////////////////////////////////
// STL
/////////////////////////////////////////////////////////////////////////////
#include <vector>
#include <map>
#include <string>
/////////////////////////////////////////////////////////////////////////////
// CRY Stuff ////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
#include <ISystem.h>
#include "Util/EditorUtils.h"
#include "EditorCoreAPI.h"

45
Code/Sandbox/Plugins/FBXPlugin/FBXSettingsDlg.cpp
Unescape Escape View File

@ -1,45 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "FBXPlugin_precompiled.h"
#include "FBXSettingsDlg.h"
#include "FBXExporter.h"
#include "resource.h"
#include <IEditor.h>
#include <QMainWindow>
#include "ui_FBXSettingsDlg.h"
bool OpenFBXSettingsDlg(struct SFBXSettings& settings)
{
Ui::FBXSettingsDialog ui;
QDialog dialog(GetIEditor()->GetEditorMainWindow());
ui.setupUi(&dialog);
ui.hCopyTextures->setChecked(settings.bCopyTextures);
ui.hEmbedded->setChecked(settings.bEmbedded);
ui.hFileFormat->setCurrentIndex(settings.bAsciiFormat ? 1 : 0);
ui.hConvertAxesForMaxMaya->setChecked(settings.bConvertAxesForMaxMaya);
if (dialog.exec() != QDialog::Accepted)
return false;
settings.bCopyTextures = ui.hCopyTextures->isChecked();
settings.bEmbedded = ui.hEmbedded->isChecked();
settings.bAsciiFormat = ui.hFileFormat->currentIndex() == 1;
settings.bConvertAxesForMaxMaya = ui.hConvertAxesForMaxMaya->isChecked();
return true;
}

20
Code/Sandbox/Plugins/FBXPlugin/FBXSettingsDlg.h
Unescape Escape View File

@ -1,20 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_FBXPLUGIN_FBXSETTINGSDLG_H
#define CRYINCLUDE_FBXPLUGIN_FBXSETTINGSDLG_H
#pragma once
bool OpenFBXSettingsDlg(struct SFBXSettings& settings);
#endif // CRYINCLUDE_FBXPLUGIN_FBXSETTINGSDLG_H

109
Code/Sandbox/Plugins/FBXPlugin/FBXSettingsDlg.ui
Unescape Escape View File

@ -1,109 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>FBXSettingsDialog</class>
<widget class="QDialog" name="FBXSettingsDialog">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>313</width>
<height>149</height>
</rect>
</property>
<property name="windowTitle">
<string>FBX Export Settings</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0" colspan="2">
<widget class="QCheckBox" name="hCopyTextures">
<property name="text">
<string>Copy textures into folder with FBX file</string>
</property>
</widget>
</item>
<item row="1" column="0" colspan="2">
<widget class="QCheckBox" name="hEmbedded">
<property name="text">
<string>Embedded data (Put textures inside FBX file)</string>
</property>
</widget>
</item>
<item row="2" column="0" colspan="2">
<widget class="QCheckBox" name="hConvertAxesForMaxMaya">
<property name="text">
<string>Convert Cameras for Max/Maya</string>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>File Format:</string>
</property>
<property name="buddy">
<cstring>hFileFormat</cstring>
</property>
</widget>
</item>
<item row="3" column="1">
<widget class="QComboBox" name="hFileFormat">
<item>
<property name="text">
<string>Bin</string>
</property>
</item>
<item>
<property name="text">
<string>Ascii</string>
</property>
</item>
</widget>
</item>
<item row="4" column="0" colspan="2">
<widget class="QDialogButtonBox" name="buttonBox">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="standardButtons">
<set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections>
<connection>
<sender>buttonBox</sender>
<signal>accepted()</signal>
<receiver>FBXSettingsDialog</receiver>
<slot>accept()</slot>
<hints>
<hint type="sourcelabel">
<x>248</x>
<y>254</y>
</hint>
<hint type="destinationlabel">
<x>157</x>
<y>274</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonBox</sender>
<signal>rejected()</signal>
<receiver>FBXSettingsDialog</receiver>
<slot>reject()</slot>
<hints>
<hint type="sourcelabel">
<x>316</x>
<y>260</y>
</hint>
<hint type="destinationlabel">
<x>286</x>
<y>274</y>
</hint>
</hints>
</connection>
</connections>
</ui>

12
Code/Sandbox/Plugins/FBXPlugin/Platform/Linux/platform_linux.cmake
Unescape Escape View File

@ -1,12 +0,0 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
set(PAL_TRAIT_BUILD_FBX_PLUGIN_SUPPORTED FALSE)

10
Code/Sandbox/Plugins/FBXPlugin/Platform/Linux/platform_linux_files.cmake
Unescape Escape View File

@ -1,10 +0,0 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#

12
Code/Sandbox/Plugins/FBXPlugin/Platform/Mac/platform_mac.cmake
Unescape Escape View File

@ -1,12 +0,0 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
set(PAL_TRAIT_BUILD_FBX_PLUGIN_SUPPORTED TRUE)

10
Code/Sandbox/Plugins/FBXPlugin/Platform/Mac/platform_mac_files.cmake
Unescape Escape View File

@ -1,10 +0,0 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#

26
Code/Sandbox/Plugins/FBXPlugin/Platform/Windows/DllMain_Windows.cpp
Unescape Escape View File

@ -1,26 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/PlatformIncl.h>
HINSTANCE g_hInstance = NULL;
BOOL WINAPI DllMain(HINSTANCE hinstDLL, ULONG fdwReason, [[maybe_unused]] LPVOID lpvReserved)
{
if (fdwReason == DLL_PROCESS_ATTACH)
{
g_hInstance = hinstDLL;
//DisableThreadLibraryCalls(hInstance);
}
return(TRUE);
}

12
Code/Sandbox/Plugins/FBXPlugin/Platform/Windows/platform_windows.cmake
Unescape Escape View File

@ -1,12 +0,0 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
set(PAL_TRAIT_BUILD_FBX_PLUGIN_SUPPORTED TRUE)

14
Code/Sandbox/Plugins/FBXPlugin/Platform/Windows/platform_windows_files.cmake
Unescape Escape View File

@ -1,14 +0,0 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
set(FILES
DllMain_Windows.cpp
)

25
Code/Sandbox/Plugins/FBXPlugin/fbxplugin_files.cmake
Unescape Escape View File

@ -1,25 +0,0 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
set(FILES
FBXExporter.cpp
FBXExporter.h
FBXPlugin.cpp
FBXPlugin.h
FBXPlugin.rc
FBXSettingsDlg.cpp
FBXSettingsDlg.h
FBXSettingsDlg.ui
main.cpp
resource.h
FBXPlugin_precompiled.cpp
FBXPlugin_precompiled.h
)

41
Code/Sandbox/Plugins/FBXPlugin/main.cpp
Unescape Escape View File

@ -1,41 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Export geometry to FBX file format
#include "FBXPlugin_precompiled.h"
#include "FBXPlugin.h"
#include "FBXExporter.h"
PLUGIN_API IPlugin* CreatePluginInstance(PLUGIN_INIT_PARAM* pInitParam)
{
if (pInitParam->pluginVersion != SANDBOX_PLUGIN_SYSTEM_VERSION)
{
pInitParam->outErrorCode = IPlugin::eError_VersionMismatch;
return 0;
}
ModuleInitISystem(GetIEditor()->GetSystem(), "FBX Exporter Plugin");
IExportManager* pExportManager = GetIEditor()->GetExportManager();
if (pExportManager)
{
pExportManager->RegisterExporter(new CFBXExporter());
}
GetIEditor()->GetSystem()->GetILog()->Log("FBX plugin: CreatePluginInstance");
return new CFBXPlugin;
}

29
Code/Sandbox/Plugins/FBXPlugin/resource.h
Unescape Escape View File

@ -1,29 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#define IDD_FBX_EXPORT_SETTINGS 103
#define IDC_COPY_TEXTURES 1003
#define IDC_EMBEDDED 1004
#define IDC_FILE_FORMAT 1005
#define IDC_CONVERT_CAMERAS_FOR_MAX_MAYA 1006
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 104
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1007
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif

2
Code/Tools/SceneAPI/CMakeLists.txt
Unescape Escape View File

@ -10,7 +10,7 @@
#
add_subdirectory(FbxSceneBuilder)
add_subdirectory(FbxSDKWrapper)
add_subdirectory(SceneCore)
add_subdirectory(SceneData)
add_subdirectory(SceneUI)
add_subdirectory(SDKWrapper)

47
Code/Tools/SceneAPI/FbxSDKWrapper/FbxAnimCurveNodeWrapper.cpp
Unescape Escape View File

@ -1,47 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/std/smart_ptr/make_shared.h>
#include "FbxAnimCurveNodeWrapper.h"
#include "FbxAnimCurveWrapper.h"
#include "fbxsdk.h"
namespace AZ
{
namespace FbxSDKWrapper
{
FbxAnimCurveNodeWrapper::FbxAnimCurveNodeWrapper(FbxAnimCurveNode* fbxAnimCurveNode)
: m_fbxAnimCurveNode(fbxAnimCurveNode)
{
}
const char* FbxAnimCurveNodeWrapper::GetName() const
{
return m_fbxAnimCurveNode->GetName();
}
int FbxAnimCurveNodeWrapper::GetChannelCount() const
{
return m_fbxAnimCurveNode->GetChannelsCount();
}
int FbxAnimCurveNodeWrapper::GetCurveCount(int channelID) const
{
return m_fbxAnimCurveNode->GetCurveCount(channelID);
}
AZStd::shared_ptr<const FbxAnimCurveWrapper> FbxAnimCurveNodeWrapper::GetCurveWrapper(int channelID, int index) const
{
return AZStd::make_shared<const FbxAnimCurveWrapper>(static_cast<FbxAnimCurve*>(m_fbxAnimCurveNode->GetCurve(channelID, index)));
}
}
}

40
Code/Tools/SceneAPI/FbxSDKWrapper/FbxAnimCurveNodeWrapper.h
Unescape Escape View File

@ -1,40 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include "fbxsdk.h"
#include "FbxTimeWrapper.h"
#include <AzCore/std/smart_ptr/shared_ptr.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxAnimCurveWrapper;
class FbxAnimCurveNodeWrapper
{
public:
FbxAnimCurveNodeWrapper(FbxAnimCurveNode* fbxAnimCurveNode);
~FbxAnimCurveNodeWrapper() = default;
const char* GetName() const;
int GetChannelCount() const;
int GetCurveCount(int channelID) const;
AZStd::shared_ptr<const FbxAnimCurveWrapper> GetCurveWrapper(int channelID, int index) const;
protected:
FbxAnimCurveNode* m_fbxAnimCurveNode;
};
}
}

34
Code/Tools/SceneAPI/FbxSDKWrapper/FbxAnimCurveWrapper.cpp
Unescape Escape View File

@ -1,34 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSDKWrapper/FbxAnimCurveWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxAnimCurveWrapper::FbxAnimCurveWrapper(FbxAnimCurve* fbxAnimCurve)
: m_fbxAnimCurve(fbxAnimCurve)
{
}
const char* FbxAnimCurveWrapper::GetName() const
{
return m_fbxAnimCurve->GetName();
}
float FbxAnimCurveWrapper::Evaluate(FbxTimeWrapper& time) const
{
return m_fbxAnimCurve->Evaluate(time.m_fbxTime);
}
} // namespace FbxSDKWrapper
} // namespace AZ

34
Code/Tools/SceneAPI/FbxSDKWrapper/FbxAnimCurveWrapper.h
Unescape Escape View File

@ -1,34 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxAnimCurveWrapper
{
public:
FbxAnimCurveWrapper(FbxAnimCurve* fbxAnimCurve);
~FbxAnimCurveWrapper() = default;
const char* GetName() const;
float Evaluate(FbxTimeWrapper& time) const;
protected:
FbxAnimCurve* m_fbxAnimCurve;
};
} // namespace FbxSDKWrapper
} // namespace AZ

49
Code/Tools/SceneAPI/FbxSDKWrapper/FbxAnimLayerWrapper.cpp
Unescape Escape View File

@ -1,49 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzCore/Casting/numeric_cast.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimLayerWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimCurveNodeWrapper.h>
#include "fbxsdk.h"
namespace AZ
{
namespace FbxSDKWrapper
{
FbxAnimLayerWrapper::FbxAnimLayerWrapper(FbxAnimLayer* fbxAnimLayer)
: m_fbxAnimLayer(fbxAnimLayer)
{
}
const char* FbxAnimLayerWrapper::GetName() const
{
return m_fbxAnimLayer->GetName();
}
u32 FbxAnimLayerWrapper::GetCurveNodeCount() const
{
return static_cast<u32>(m_fbxAnimLayer->GetMemberCount());
}
FbxAnimLayer* FbxAnimLayerWrapper::GetFbxLayer() const
{
return m_fbxAnimLayer;
}
AZStd::shared_ptr<const FbxAnimCurveNodeWrapper> FbxAnimLayerWrapper::GetCurveNodeWrapper(u32 index) const
{
return AZStd::make_shared<const FbxAnimCurveNodeWrapper>(static_cast<FbxAnimCurveNode*>(m_fbxAnimLayer->GetMember(aznumeric_cast<int>(index))));
}
} // namespace FbxSDKWrapper
} // namespace AZ

39
Code/Tools/SceneAPI/FbxSDKWrapper/FbxAnimLayerWrapper.h
Unescape Escape View File

@ -1,39 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/std/smart_ptr/shared_ptr.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxAnimCurveNodeWrapper;
class FbxAnimLayerWrapper
{
friend class FbxNodeWrapper;
public:
FbxAnimLayerWrapper(FbxAnimLayer* fbxAnimLayer);
~FbxAnimLayerWrapper() = default;
const char* GetName() const;
u32 GetCurveNodeCount() const ;
FbxAnimLayer* GetFbxLayer() const;
AZStd::shared_ptr<const FbxAnimCurveNodeWrapper> GetCurveNodeWrapper(u32 index) const;
protected:
FbxAnimLayer* m_fbxAnimLayer;
};
} // namespace FbxSDKWrapper
} // namespace AZ

55
Code/Tools/SceneAPI/FbxSDKWrapper/FbxAnimStackWrapper.cpp
Unescape Escape View File

@ -1,55 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Debug/Trace.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimStackWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimLayerWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeSpanWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxAnimStackWrapper::FbxAnimStackWrapper(FbxAnimStack* fbxAnimStack)
: m_fbxAnimStack(fbxAnimStack)
{
AZ_Assert(fbxAnimStack, "Invalid FbxAnimStack input to initialize FbxAnimStackWrapper");
}
FbxAnimStackWrapper::~FbxAnimStackWrapper()
{
m_fbxAnimStack = nullptr;
}
const char* FbxAnimStackWrapper::GetName() const
{
return m_fbxAnimStack->GetName();
}
int FbxAnimStackWrapper::GetAnimationLayerCount() const
{
return m_fbxAnimStack->GetMemberCount<FbxAnimLayer>();
}
const AZStd::shared_ptr<FbxAnimLayerWrapper> FbxAnimStackWrapper::GetAnimationLayerAt(int index) const
{
AZ_Assert(index < GetAnimationLayerCount(), "Invalid animation layer index %d for layer count %d", index, GetAnimationLayerCount());
return AZStd::make_shared<FbxAnimLayerWrapper>(m_fbxAnimStack->GetMember<FbxAnimLayer>(index));
}
FbxTimeSpanWrapper FbxAnimStackWrapper::GetLocalTimeSpan() const
{
return FbxTimeSpanWrapper(m_fbxAnimStack->GetLocalTimeSpan());
}
} // namespace FbxSDKWrapper
} // namespace AZ

42
Code/Tools/SceneAPI/FbxSDKWrapper/FbxAnimStackWrapper.h
Unescape Escape View File

@ -1,42 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <AzCore/std/smart_ptr/shared_ptr.h>
#include <fbxsdk.h>
namespace AZ
{
namespace FbxSDKWrapper
{
using FbxSDKLongLong = FbxLongLong;
class FbxAnimLayerWrapper;
class FbxTimeSpanWrapper;
class FbxAnimStackWrapper
{
public:
FbxAnimStackWrapper(FbxAnimStack* fbxAnimStack);
virtual ~FbxAnimStackWrapper();
virtual const char* GetName() const;
virtual int GetAnimationLayerCount() const;
virtual const AZStd::shared_ptr<FbxAnimLayerWrapper> GetAnimationLayerAt(int index) const;
virtual FbxTimeSpanWrapper GetLocalTimeSpan() const;
protected:
FbxAnimStackWrapper() = default;
FbxAnimStack* m_fbxAnimStack;
};
} // namespace FbxSDKWrapper
} // namespace AZ

75
Code/Tools/SceneAPI/FbxSDKWrapper/FbxAxisSystemWrapper.cpp
Unescape Escape View File

@ -1,75 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Debug/Trace.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/FbxSDKWrapper/FbxAxisSystemWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxTypeConverter.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxAxisSystemWrapper::FbxAxisSystemWrapper(const FbxAxisSystem& fbxAxisSystem)
: m_fbxAxisSystem(fbxAxisSystem)
{
}
FbxAxisSystemWrapper::UpVector FbxAxisSystemWrapper::GetUpVector(int& sign) const
{
switch (m_fbxAxisSystem.GetUpVector(sign))
{
case FbxAxisSystem::eXAxis:
return X;
case FbxAxisSystem::eYAxis:
return Y;
case FbxAxisSystem::eZAxis:
return Z;
default:
AZ_TraceContext("Unknown value", m_fbxAxisSystem.GetUpVector(sign));
AZ_TracePrintf(SceneAPI::Utilities::WarningWindow, "Unrecognized axis up vector type");
return Unknown;
}
}
SceneAPI::DataTypes::MatrixType FbxAxisSystemWrapper::CalculateConversionTransform(UpVector targetUpAxis)
{
FbxAxisSystem targetSystem;
switch (targetUpAxis)
{
case Y:
// Maya YUp coordinate system (UpVector = +Y, FrontVector = +Z, CoordSystem = +X (RightHanded))
targetSystem = FbxAxisSystem::MayaYUp;
break;
case Z:
// CryTek ZUp coordinate system (UpVector = +Z, FrontVector = +Y, CoordSystem = -X (RightHanded))
targetSystem = FbxAxisSystem(FbxAxisSystem::eZAxis, FbxAxisSystem::eParityOdd, FbxAxisSystem::eRightHanded);
break;
case X:
// Default XUp coordinate system (UpVector = +X, FrontVector = +Z, CoordSystem = -Y (RightHanded))
targetSystem = FbxAxisSystem(FbxAxisSystem::eXAxis, FbxAxisSystem::eParityOdd, FbxAxisSystem::eRightHanded);
break;
default:
AZ_TraceContext("Unknown value", targetUpAxis);
AZ_TracePrintf(SceneAPI::Utilities::WarningWindow, "Unrecognized axis conversion target axis type");
return SceneAPI::DataTypes::MatrixType::CreateIdentity();
}
FbxAMatrix targetMatrix;
targetSystem.GetMatrix(targetMatrix);
FbxAMatrix currentMatrix;
m_fbxAxisSystem.GetMatrix(currentMatrix);
FbxAMatrix adjustMatrix = targetMatrix * currentMatrix.Inverse();
return FbxTypeConverter::ToTransform(adjustMatrix);
}
} // namespace FbxSDKWrapper
} // namespace AZ

44
Code/Tools/SceneAPI/FbxSDKWrapper/FbxAxisSystemWrapper.h
Unescape Escape View File

@ -1,44 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <SceneAPI/SceneCore/DataTypes/MatrixType.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxAxisSystemWrapper
{
public:
enum UpVector
{
X,
Y,
Z,
Unknown
};
FbxAxisSystemWrapper() = default;
FbxAxisSystemWrapper(const FbxAxisSystem& fbxAxisSystem);
virtual ~FbxAxisSystemWrapper() = default;
virtual UpVector GetUpVector(int& sign) const;
virtual SceneAPI::DataTypes::MatrixType CalculateConversionTransform(UpVector targetUpAxis);
protected:
FbxAxisSystem m_fbxAxisSystem;
};
} // namespace FbxSDKWrapper
} // namespace AZ

100
Code/Tools/SceneAPI/FbxSDKWrapper/FbxBlendShapeChannelWrapper.cpp
Unescape Escape View File

@ -1,100 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzCore/Debug/Trace.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/FbxSDKWrapper/FbxBlendShapeChannelWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxBlendShapeChannelWrapper::FbxBlendShapeChannelWrapper(FbxBlendShapeChannel* fbxBlendShapeChannel)
: m_fbxBlendShapeChannel(fbxBlendShapeChannel)
{
AZ_Assert(fbxBlendShapeChannel, "Invalid FbxSkin input to initialize FbxBlendShapeChannelWrapper");
}
FbxBlendShapeChannelWrapper::~FbxBlendShapeChannelWrapper()
{
m_fbxBlendShapeChannel = nullptr;
}
const char* FbxBlendShapeChannelWrapper::GetName() const
{
return m_fbxBlendShapeChannel->GetName();
}
//The engine currently only supports one target shape. If there are more than one,
//code will ultimately end up just using the max index returned by this function.
int FbxBlendShapeChannelWrapper::GetTargetShapeCount() const
{
return m_fbxBlendShapeChannel->GetTargetShapeCount();
}
//While not strictly true that the target shapes are meshes, for the purposes of the engine's
//current runtime they must be meshes.
AZStd::shared_ptr<const FbxMeshWrapper> FbxBlendShapeChannelWrapper::GetTargetShape(int index) const
{
//we need to create a duplicate FbxMesh from the base mesh and the target data
//FbxMeshWrapper needs an FbxMesh to point to so we are generating one
//by cloning the mesh data and then replacing with the morph data.
FbxShape* fbxShape = m_fbxBlendShapeChannel->GetTargetShape(index);
if (!fbxShape)
{
return nullptr;
}
FbxGeometry* fbxGeom = fbxShape->GetBaseGeometry();
if (fbxGeom && fbxGeom->GetAttributeType() == FbxNodeAttribute::EType::eMesh)
{
FbxMesh* fbxMesh = static_cast<FbxMesh*>(fbxGeom);
FbxMesh* fbxBlendMesh = FbxMesh::Create(m_fbxBlendShapeChannel->GetScene(),"");
fbxBlendMesh->Copy(*fbxMesh);
//TODO: test that mesh is managed by the sdk
const int count = fbxBlendMesh->GetControlPointsCount();
//set control points from blend shape
for (int i = 0; i < count; i++)
{
fbxBlendMesh->SetControlPointAt(fbxShape->GetControlPointAt(i), i);
}
//source data
FbxLayerElementArrayTemplate<FbxVector4>* normalsTemplate;
if (fbxShape->GetNormals(&normalsTemplate))
{
int normalCount = normalsTemplate->GetCount();
//destination data
FbxLayer* normalLayer = fbxBlendMesh->GetLayer(0, FbxLayerElement::eNormal);
if (normalLayer)
{
FbxLayerElementNormal* normals = normalLayer->GetNormals();
if (normals)
{
//set normal data from blend shape
for (int j = 0; j < normalCount; j++)
{
FbxVector4 normal = normalsTemplate->GetAt(j);
normals->GetDirectArray().SetAt(j, normal);
}
}
}
}
return AZStd::make_shared<FbxMeshWrapper>(fbxBlendMesh);
}
return nullptr;
}
}
}

43
Code/Tools/SceneAPI/FbxSDKWrapper/FbxBlendShapeChannelWrapper.h
Unescape Escape View File

@ -1,43 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/std/smart_ptr/shared_ptr.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxNodeWrapper;
class FbxMeshWrapper;
class FbxBlendShapeChannelWrapper
{
public:
FbxBlendShapeChannelWrapper(FbxBlendShapeChannel* fbxBlendShapeChannel);
virtual ~FbxBlendShapeChannelWrapper();
virtual const char* GetName() const;
virtual int GetTargetShapeCount() const;
//While not strictly true that the target shapes are meshes, for the purposes of the engine's
//current runtime they must be meshes.
virtual AZStd::shared_ptr<const FbxMeshWrapper> GetTargetShape(int index) const;
protected:
FbxBlendShapeChannelWrapper() = default;
FbxBlendShapeChannel* m_fbxBlendShapeChannel;
};
} // namespace FbxSDKWrapper
} // namespace AZ

74
Code/Tools/SceneAPI/FbxSDKWrapper/FbxBlendShapeWrapper.cpp
Unescape Escape View File

@ -1,74 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Debug/Trace.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/FbxSDKWrapper/FbxMeshWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxBlendShapeWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxBlendShapeChannelWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxBlendShapeWrapper::FbxBlendShapeWrapper(FbxBlendShape* fbxBlendShape)
: m_fbxBlendShape(fbxBlendShape)
{
AZ_Assert(fbxBlendShape, "Invalid FbxBlendShape input to initialize FbxBlendShapeWrapper");
}
FbxBlendShapeWrapper::~FbxBlendShapeWrapper()
{
m_fbxBlendShape = nullptr;
}
const char* FbxBlendShapeWrapper::GetName() const
{
return m_fbxBlendShape->GetName();
}
//Technically Fbx returns a FbxGeometry off this interface, but we only support meshes in the engine runtime.
AZStd::shared_ptr<const FbxMeshWrapper> FbxBlendShapeWrapper::GetGeometry() const
{
FbxGeometry* fbxGeom = m_fbxBlendShape->GetGeometry();
if (fbxGeom && fbxGeom->GetAttributeType() == FbxNodeAttribute::EType::eMesh )
{
return AZStd::make_shared<FbxMeshWrapper>(static_cast<FbxMesh*>(fbxGeom));
}
else
{
return nullptr;
}
}
int FbxBlendShapeWrapper::GetBlendShapeChannelCount() const
{
return m_fbxBlendShape->GetBlendShapeChannelCount();
}
AZStd::shared_ptr<const FbxBlendShapeChannelWrapper> FbxBlendShapeWrapper::GetBlendShapeChannel(int index) const
{
FbxBlendShapeChannel* fbxBlendShapeChannel = m_fbxBlendShape->GetBlendShapeChannel(index);
if (fbxBlendShapeChannel)
{
return AZStd::make_shared<FbxBlendShapeChannelWrapper>(fbxBlendShapeChannel);
}
else
{
return nullptr;
}
}
} // namespace FbxSDKWrapper
} // namespace AZ

43
Code/Tools/SceneAPI/FbxSDKWrapper/FbxBlendShapeWrapper.h
Unescape Escape View File

@ -1,43 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/std/smart_ptr/shared_ptr.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxBlendShapeChannelWrapper;
class FbxNodeWrapper;
class FbxMeshWrapper;
class FbxBlendShapeWrapper
{
public:
FbxBlendShapeWrapper(FbxBlendShape* fbxBlendShape);
virtual ~FbxBlendShapeWrapper();
virtual const char* GetName() const;
//Technically Fbx returns a FbxGeometry off this interface, but we only support meshes in the engine runtime.
virtual AZStd::shared_ptr<const FbxMeshWrapper> GetGeometry() const;
virtual int GetBlendShapeChannelCount() const;
virtual AZStd::shared_ptr<const FbxBlendShapeChannelWrapper> GetBlendShapeChannel(int index) const;
protected:
FbxBlendShapeWrapper() = default;
FbxBlendShape* m_fbxBlendShape;
};
} // namespace FbxSDKWrapper
} // namespace AZ

31
Code/Tools/SceneAPI/FbxSDKWrapper/FbxLayerElementUtilities.h
Unescape Escape View File

@ -1,31 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxLayerElementUtilities
{
public:
template <typename ValueType, typename ElementArrayType>
static void GetGeometryElement(ValueType& value, const ElementArrayType* elementArray,
int polygonIndex, int polygonVertexIndex, int controlPointIndex);
};
} // namespace FbxSDKWrapper
} // namespace AZ
#include "FbxLayerElementUtilities.inl"

74
Code/Tools/SceneAPI/FbxSDKWrapper/FbxLayerElementUtilities.inl
Unescape Escape View File

@ -1,74 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Debug/Trace.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
namespace AZ
{
namespace FbxSDKWrapper
{
template <typename ValueType, typename ElementArrayType>
void FbxLayerElementUtilities::GetGeometryElement( ValueType& value, const ElementArrayType* elementArray,
int polygonIndex, int polygonVertexIndex, int controlPointIndex)
{
if (!elementArray)
{
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Invalid ElementArrayType input");
return;
}
int fbxElementIndex;
switch (elementArray->GetMappingMode())
{
case FbxGeometryElement::eByControlPoint:
// One mapping coordinate for each surface control point/vertex.
fbxElementIndex = controlPointIndex;
break;
case FbxGeometryElement::eByPolygonVertex:
// One mapping coordinate for each vertex, for every polygon of which it is a part.
// This means that a vertex will have as many mapping coordinates as polygons of which it is a part.
fbxElementIndex = polygonVertexIndex;
break;
case FbxGeometryElement::eByPolygon:
// One mapping coordinate for the whole polygon.
fbxElementIndex = polygonIndex;
break;
default:
AZ_TraceContext("Unknown value", elementArray->GetMappingMode());
AZ_TracePrintf(AZ::SceneAPI::Utilities::ErrorWindow, "Invalid ElementArrayType mapping mode");
return;
}
if (elementArray->GetReferenceMode() == FbxGeometryElement::eIndexToDirect)
{
// Convert index from "index of value's index" to "index of value".
const FbxLayerElementArrayTemplate<int>& indices = elementArray->GetIndexArray();
AZ_Assert(fbxElementIndex < indices.GetCount(), "Invalid element index %d", fbxElementIndex);
if (fbxElementIndex >= indices.GetCount())
{
return;
}
fbxElementIndex = indices.GetAt(fbxElementIndex);
}
const FbxLayerElementArrayTemplate<ValueType>& elements = elementArray->GetDirectArray();
AZ_Assert(fbxElementIndex < elements.GetCount(), "Invalid element index %d", fbxElementIndex);
if (fbxElementIndex >= elements.GetCount())
{
return;
}
value = elements.GetAt(fbxElementIndex);
}
} // namespace FbxSDKWrapper
} // namespace AZ

185
Code/Tools/SceneAPI/FbxSDKWrapper/FbxMaterialWrapper.cpp
Unescape Escape View File

@ -1,185 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Casting/numeric_cast.h>
#include <AzCore/Debug/Trace.h>
#include <AzCore/Math/MathUtils.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/FbxSDKWrapper/FbxMaterialWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxPropertyWrapper.h>
namespace
{
const char* s_physicalisedAttributeName = "physicalize";
const char* s_proxyNoDraw = "ProxyNoDraw";
}
namespace AZ
{
namespace FbxSDKWrapper
{
FbxMaterialWrapper::FbxMaterialWrapper(FbxSurfaceMaterial* fbxMaterial)
: SDKMaterial::MaterialWrapper(fbxMaterial)
{
AZ_Assert(fbxMaterial, "Invalid FbxSurfaceMaterial input to initialize FbxMaterialWrapper");
}
AZStd::string FbxMaterialWrapper::GetName() const
{
return m_fbxMaterial->GetInitialName();
}
AZ::Vector3 FbxMaterialWrapper::GetDiffuseColor() const
{
if (m_fbxMaterial->GetClassId().Is(FbxSurfaceLambert::ClassId))
{
FbxSurfaceLambert* lambertMat = static_cast<FbxSurfaceLambert*>(m_fbxMaterial);
const FbxDouble3 fbxValue = lambertMat->Diffuse.Get();
const float power = static_cast<float>(lambertMat->DiffuseFactor.Get());
return power * AZ::Vector3(static_cast<float>(fbxValue[0]), static_cast<float>(fbxValue[1]), static_cast<float>(fbxValue[2]));
}
else if (m_fbxMaterial->GetClassId().Is(FbxSurfacePhong::ClassId))
{
FbxSurfacePhong* phongMat = static_cast<FbxSurfacePhong*>(m_fbxMaterial);
const FbxDouble3 fbxValue = phongMat->Diffuse.Get();
const float power = static_cast<float>(phongMat->DiffuseFactor.Get());
return power * AZ::Vector3(static_cast<float>(fbxValue[0]), static_cast<float>(fbxValue[1]), static_cast<float>(fbxValue[2]));
}
return AZ::Vector3::CreateOne();
}
AZ::Vector3 FbxMaterialWrapper::GetSpecularColor() const
{
if (m_fbxMaterial->GetClassId().Is(FbxSurfacePhong::ClassId))
{
FbxSurfacePhong* phongMat = static_cast<FbxSurfacePhong*>(m_fbxMaterial);
const FbxDouble3 fbxValue = phongMat->Specular.Get();
const float power = static_cast<float>(phongMat->SpecularFactor.Get());
return power * AZ::Vector3(static_cast<float>(fbxValue[0]), static_cast<float>(fbxValue[1]), static_cast<float>(fbxValue[2]));
}
return AZ::Vector3::CreateZero();
}
AZ::Vector3 FbxMaterialWrapper::GetEmissiveColor() const
{
if (m_fbxMaterial->GetClassId().Is(FbxSurfaceLambert::ClassId))
{
FbxSurfaceLambert* lambertMat = static_cast<FbxSurfaceLambert*>(m_fbxMaterial);
const FbxDouble3 fbxValue = lambertMat->Emissive.Get();
const float power = static_cast<float>(lambertMat->EmissiveFactor.Get());
return power * AZ::Vector3(static_cast<float>(fbxValue[0]), static_cast<float>(fbxValue[1]), static_cast<float>(fbxValue[2]));
}
else if (m_fbxMaterial->GetClassId().Is(FbxSurfacePhong::ClassId))
{
FbxSurfacePhong* phongMat = static_cast<FbxSurfacePhong*>(m_fbxMaterial);
const FbxDouble3 fbxValue = phongMat->Emissive.Get();
const float power = static_cast<float>(phongMat->EmissiveFactor.Get());
return power * AZ::Vector3(static_cast<float>(fbxValue[0]), static_cast<float>(fbxValue[1]), static_cast<float>(fbxValue[2]));
}
return AZ::Vector3::CreateZero();
}
float FbxMaterialWrapper::GetShininess() const
{
if (m_fbxMaterial->GetClassId().Is(FbxSurfacePhong::ClassId))
{
FbxSurfacePhong* phongMat = static_cast<FbxSurfacePhong*>(m_fbxMaterial);
return static_cast<float>(phongMat->Shininess.Get());
}
return 10.f;
}
AZ::u64 FbxMaterialWrapper::GetUniqueId() const
{
return m_fbxMaterial->GetUniqueID();
}
float FbxMaterialWrapper::GetOpacity() const
{
// FBX materials are erroneously reporting a TransparencyFactor of 1.0 (fully transparent)
// even for values that are 0.0 in Maya. It is instead storing it in the components
// for TransparentColor, so extract from there instead.
if (m_fbxMaterial->GetClassId().Is(FbxSurfaceLambert::ClassId))
{
FbxSurfaceLambert* lambertMat = static_cast<FbxSurfaceLambert*>(m_fbxMaterial);
const FbxDouble3 fbxValue = lambertMat->TransparentColor.Get();
return 1.f - AZ::GetMin<float>(AZ::GetMin<float>(static_cast<float>(fbxValue[0]), static_cast<float>(fbxValue[1])), static_cast<float>(fbxValue[2]));
}
else if (m_fbxMaterial->GetClassId().Is(FbxSurfacePhong::ClassId))
{
FbxSurfacePhong* phongMat = static_cast<FbxSurfacePhong*>(m_fbxMaterial);
const FbxDouble3 fbxValue = phongMat->TransparentColor.Get();
return 1.f - AZ::GetMin<float>(AZ::GetMin<float>(static_cast<float>(fbxValue[0]), static_cast<float>(fbxValue[1])), static_cast<float>(fbxValue[2]));
}
return 1.f;
}
AZStd::string FbxMaterialWrapper::GetTextureFileName(const char* textureType) const
{
FbxFileTexture* fileTexture = nullptr;
FbxProperty property = m_fbxMaterial->FindProperty(textureType);
FbxDataType propertyType = property.GetPropertyDataType();
/// Engine currently doesn't support multiple textures. Right now we only use first texture of first layer.
int layeredTextureCount = property.GetSrcObjectCount<FbxLayeredTexture>();
if (layeredTextureCount > 0)
{
FbxLayeredTexture* layeredTexture = FbxCast<FbxLayeredTexture>(property.GetSrcObject<FbxLayeredTexture>(0));
int textureCount = layeredTexture->GetSrcObjectCount<FbxTexture>();
if (textureCount > 0)
{
fileTexture = FbxCast<FbxFileTexture>(layeredTexture->GetSrcObject<FbxTexture>(0));
}
}
else
{
int textureCount = property.GetSrcObjectCount<FbxTexture>();
if (textureCount > 0)
{
fileTexture = FbxCast<FbxFileTexture>(property.GetSrcObject<FbxTexture>(0));
}
}
return fileTexture ? fileTexture->GetFileName() : AZStd::string();
}
AZStd::string FbxMaterialWrapper::GetTextureFileName(const AZStd::string& textureType) const
{
return GetTextureFileName(textureType.c_str());
}
AZStd::string FbxMaterialWrapper::GetTextureFileName(MaterialMapType textureType) const
{
switch (textureType)
{
case MaterialMapType::Diffuse:
return GetTextureFileName(FbxSurfaceMaterial::sDiffuse);
case MaterialMapType::Specular:
return GetTextureFileName(FbxSurfaceMaterial::sSpecular);
case MaterialMapType::Bump:
return GetTextureFileName(FbxSurfaceMaterial::sBump);
case MaterialMapType::Normal:
return GetTextureFileName(FbxSurfaceMaterial::sNormalMap);
default:
AZ_TraceContext("Unknown value", aznumeric_cast<int>(textureType));
AZ_TracePrintf(SceneAPI::Utilities::WarningWindow, "Unrecognized MaterialMapType retrieved");
return AZStd::string();
}
}
} // namespace FbxSDKWrapper
} // namespace AZ

44
Code/Tools/SceneAPI/FbxSDKWrapper/FbxMaterialWrapper.h
Unescape Escape View File

@ -1,44 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/std/string/string.h>
#include <SceneAPI/SDKWrapper/MaterialWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxMaterialWrapper : public SDKMaterial::MaterialWrapper
{
public:
AZ_RTTI(FbxMaterialWrapper, "{227582F6-93BC-4E44-823E-FB1D631443A7}", SDKMaterial::MaterialWrapper);
FbxMaterialWrapper(FbxSurfaceMaterial* fbxMaterial);
~FbxMaterialWrapper() override = default;
AZStd::string GetName() const override;
virtual AZStd::string GetTextureFileName(const char* textureType) const;
virtual AZStd::string GetTextureFileName(const AZStd::string& textureType) const;
AZStd::string GetTextureFileName(MaterialMapType textureType) const override;
AZ::Vector3 GetDiffuseColor() const override;
AZ::Vector3 GetSpecularColor() const override;
AZ::Vector3 GetEmissiveColor() const override;
float GetOpacity() const override;
float GetShininess() const override;
AZ::u64 GetUniqueId() const override;
};
} // namespace FbxSDKWrapper
} // namespace AZ

154
Code/Tools/SceneAPI/FbxSDKWrapper/FbxMeshWrapper.cpp
Unescape Escape View File

@ -1,154 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Casting/numeric_cast.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <SceneAPI/FbxSDKWrapper/FbxMeshWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxSkinWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxVertexTangentWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxVertexBitangentWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxBlendShapeWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxTypeConverter.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxMeshWrapper::FbxMeshWrapper(FbxMesh* fbxMesh)
: m_fbxMesh(fbxMesh)
{
AZ_Assert(fbxMesh, "Invalid FbxMesh input to initialize FbxMeshWrapper");
}
FbxMeshWrapper::~FbxMeshWrapper()
{
m_fbxMesh = nullptr;
}
const char* FbxMeshWrapper::GetName() const
{
return m_fbxMesh->GetName();
}
int FbxMeshWrapper::GetDeformerCount() const
{
return m_fbxMesh->GetDeformerCount();
}
int FbxMeshWrapper::GetDeformerCount(int type) const
{
return m_fbxMesh->GetDeformerCount(static_cast<FbxDeformer::EDeformerType>(type));
}
int FbxMeshWrapper::GetControlPointsCount() const
{
return m_fbxMesh->GetControlPointsCount();
}
AZStd::vector<Vector3> FbxMeshWrapper::GetControlPoints() const
{
FbxVector4* controlPoints = m_fbxMesh->GetControlPoints();
AZStd::vector<Vector3> azControlPoints;
azControlPoints.reserve(aznumeric_caster(GetControlPointsCount()));
for (int i = 0; i < GetControlPointsCount(); ++i)
{
azControlPoints.push_back(FbxTypeConverter::ToVector3(controlPoints[i]));
}
return azControlPoints;
}
AZStd::shared_ptr<const FbxSkinWrapper> FbxMeshWrapper::GetSkin(int index) const
{
FbxSkin* skin = static_cast<FbxSkin*>(m_fbxMesh->GetDeformer(index, FbxDeformer::eSkin));
return skin ? AZStd::make_shared<const FbxSkinWrapper>(skin) : nullptr;
}
AZStd::shared_ptr<const FbxBlendShapeWrapper> FbxMeshWrapper::GetBlendShape(int index) const
{
FbxBlendShape* blendShape = static_cast<FbxBlendShape*>(m_fbxMesh->GetDeformer(index, FbxDeformer::eBlendShape));
return blendShape ? AZStd::make_shared<const FbxBlendShapeWrapper>(blendShape) : nullptr;
}
int FbxMeshWrapper::GetPolygonCount() const
{
return m_fbxMesh->GetPolygonCount();
}
int FbxMeshWrapper::GetPolygonSize(int polygonIndex) const
{
return m_fbxMesh->GetPolygonSize(polygonIndex);
}
int* FbxMeshWrapper::GetPolygonVertices() const
{
return m_fbxMesh->GetPolygonVertices();
}
int FbxMeshWrapper::GetPolygonVertexIndex(int polygonIndex) const
{
return m_fbxMesh->GetPolygonVertexIndex(polygonIndex);
}
bool FbxMeshWrapper::GetMaterialIndices(FbxLayerElementArrayTemplate<int>** lockableArray) const
{
return m_fbxMesh->GetMaterialIndices(lockableArray);
}
FbxUVWrapper FbxMeshWrapper::GetElementUV(int index)
{
return FbxUVWrapper(m_fbxMesh->GetElementUV(index));
}
FbxVertexTangentWrapper FbxMeshWrapper::GetElementTangent(int index)
{
return FbxVertexTangentWrapper(m_fbxMesh->GetElementTangent(index));
}
FbxVertexBitangentWrapper FbxMeshWrapper::GetElementBitangent(int index)
{
return FbxVertexBitangentWrapper(m_fbxMesh->GetElementBinormal(index));
}
int FbxMeshWrapper::GetElementUVCount() const
{
return m_fbxMesh->GetElementUVCount();
}
int FbxMeshWrapper::GetElementTangentCount() const
{
return m_fbxMesh->GetElementTangentCount();
}
int FbxMeshWrapper::GetElementBitangentCount() const
{
return m_fbxMesh->GetElementBinormalCount();
}
FbxVertexColorWrapper FbxMeshWrapper::GetElementVertexColor(int index)
{
return FbxVertexColorWrapper(m_fbxMesh->GetElementVertexColor(index));
}
int FbxMeshWrapper::GetElementVertexColorCount() const
{
return m_fbxMesh->GetElementVertexColorCount();
}
bool FbxMeshWrapper::GetPolygonVertexNormal(int polyIndex, int vertexIndex, Vector3& normal) const
{
FbxVector4 fbxNormal;
bool hasVertexNormal = m_fbxMesh->GetPolygonVertexNormal(polyIndex, vertexIndex, fbxNormal);
normal = FbxTypeConverter::ToVector3(fbxNormal);
return hasVertexNormal;
}
} // namespace FbxSDKWrapper
} // namespace AZ

89
Code/Tools/SceneAPI/FbxSDKWrapper/FbxMeshWrapper.h
Unescape Escape View File

@ -1,89 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/Math/Vector3.h>
#include <AzCore/std/containers/vector.h>
#include <AzCore/std/smart_ptr/shared_ptr.h>
#include <SceneAPI/FbxSDKWrapper/FbxVertexColorWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxUVWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxSkinWrapper;
class FbxBlendShapeWrapper;
class FbxVertexTangentWrapper;
class FbxVertexBitangentWrapper;
class FbxMeshWrapper
{
public:
FbxMeshWrapper(FbxMesh* fbxMesh);
virtual ~FbxMeshWrapper();
virtual const char* GetName() const;
virtual int GetDeformerCount() const;
virtual int GetDeformerCount(int type) const;
virtual AZStd::shared_ptr<const FbxSkinWrapper> GetSkin(int index) const;
virtual AZStd::shared_ptr<const FbxBlendShapeWrapper> GetBlendShape(int index) const;
virtual bool GetMaterialIndices(FbxLayerElementArrayTemplate<int>** lockableArray) const;
// Vertex positions access
// Get the control points number
virtual int GetControlPointsCount() const;
// Get the array of control points
virtual AZStd::vector<Vector3> GetControlPoints() const;
// Polygon data accesses
// Get the polygon count of this mesh
virtual int GetPolygonCount() const;
// Get the number of polygon vertices in a polygon
virtual int GetPolygonSize(int polygonIndex) const;
// Get the array of polygon vertices (i.e: indices to the control points)
virtual int* GetPolygonVertices() const;
// Gets the start index into the array returned by GetPolygonVertices() for the given polygon
virtual int GetPolygonVertexIndex(int polygonIndex) const;
// Vertex colors and UV textures accesses
// Returns this geometry's UV element
virtual FbxUVWrapper GetElementUV(int index = 0);
virtual int GetElementUVCount() const;
virtual int GetElementTangentCount() const;
virtual int GetElementBitangentCount() const;
virtual FbxVertexTangentWrapper GetElementTangent(int index = 0);
virtual FbxVertexBitangentWrapper GetElementBitangent(int index = 0);
// Returns this geometry's vertex color element
virtual FbxVertexColorWrapper GetElementVertexColor(int index = 0);
virtual int GetElementVertexColorCount() const;
// Get the normal associated with the specified polygon vertex
virtual bool GetPolygonVertexNormal(int polyIndex, int vertexIndex, Vector3& normal) const;
protected:
FbxMeshWrapper() = default;
FbxMesh* m_fbxMesh;
};
} // namespace FbxSDKWrapper
} // namespace AZ

220
Code/Tools/SceneAPI/FbxSDKWrapper/FbxNodeWrapper.cpp
Unescape Escape View File

@ -1,220 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/std/smart_ptr/make_shared.h>
#include <SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxMaterialWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxTypeConverter.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimLayerWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimCurveWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxNodeWrapper::FbxNodeWrapper(FbxNode* fbxNode)
: NodeWrapper(fbxNode)
{
AZ_Assert(fbxNode, "Invalid FbxNode to initialize FbxNodeWrapper");
}
FbxNodeWrapper::~FbxNodeWrapper()
{
}
int FbxNodeWrapper::GetMaterialCount() const
{
return m_fbxNode->GetMaterialCount();
}
const char* FbxNodeWrapper::GetMaterialName(int index) const
{
if (index < GetMaterialCount())
{
return m_fbxNode->GetMaterial(index)->GetName();
}
AZ_Assert(index < GetMaterialCount(), "Invalid material index %d", index);
return nullptr;
}
const std::shared_ptr<FbxMeshWrapper> FbxNodeWrapper::GetMesh() const
{
FbxMesh* mesh = m_fbxNode->GetMesh();
return mesh ? std::shared_ptr<FbxMeshWrapper>(new FbxMeshWrapper(mesh)) : nullptr;
}
const std::shared_ptr<FbxPropertyWrapper> FbxNodeWrapper::FindProperty(const char* name) const
{
FbxProperty propertyName = m_fbxNode->FindProperty(name);
return std::shared_ptr<FbxPropertyWrapper>(new FbxPropertyWrapper(&propertyName));
}
bool FbxNodeWrapper::IsBone() const
{
return (m_fbxNode->GetSkeleton() != nullptr);
}
bool FbxNodeWrapper::IsMesh() const
{
return (m_fbxNode->GetMesh() != nullptr);
}
const char* FbxNodeWrapper::GetName() const
{
return m_fbxNode->GetName();
}
AZ::u64 FbxNodeWrapper::GetUniqueId() const
{
return m_fbxNode->GetUniqueID();
}
SceneAPI::DataTypes::MatrixType FbxNodeWrapper::EvaluateGlobalTransform()
{
return FbxTypeConverter::ToTransform(m_fbxNode->EvaluateGlobalTransform());
}
Vector3 FbxNodeWrapper::EvaluateLocalTranslation()
{
return FbxTypeConverter::ToVector3(m_fbxNode->EvaluateLocalTranslation());
}
Vector3 FbxNodeWrapper::EvaluateLocalTranslation(FbxTimeWrapper& time)
{
return FbxTypeConverter::ToVector3(m_fbxNode->EvaluateLocalTranslation(time.m_fbxTime));
}
SceneAPI::DataTypes::MatrixType FbxNodeWrapper::EvaluateLocalTransform()
{
return FbxTypeConverter::ToTransform(m_fbxNode->EvaluateLocalTransform());
}
SceneAPI::DataTypes::MatrixType FbxNodeWrapper::EvaluateLocalTransform(FbxTimeWrapper& time)
{
return FbxTypeConverter::ToTransform(m_fbxNode->EvaluateLocalTransform(time.m_fbxTime));
}
Vector3 FbxNodeWrapper::EvaluateLocalRotation()
{
return FbxTypeConverter::ToVector3(m_fbxNode->EvaluateLocalTransform().GetR());
}
Vector3 FbxNodeWrapper::EvaluateLocalRotation(FbxTimeWrapper& time)
{
return FbxTypeConverter::ToVector3(m_fbxNode->EvaluateLocalTransform(time.m_fbxTime).GetR());
}
Vector3 FbxNodeWrapper::GetGeometricTranslation() const
{
return FbxTypeConverter::ToVector3(m_fbxNode->GetGeometricTranslation(FbxNode::eSourcePivot));
}
Vector3 FbxNodeWrapper::GetGeometricScaling() const
{
return FbxTypeConverter::ToVector3(m_fbxNode->GetGeometricScaling(FbxNode::eSourcePivot));
}
Vector3 FbxNodeWrapper::GetGeometricRotation() const
{
return FbxTypeConverter::ToVector3(m_fbxNode->GetGeometricRotation(FbxNode::eSourcePivot));
}
SceneAPI::DataTypes::MatrixType FbxNodeWrapper::GetGeometricTransform() const
{
FbxAMatrix geoTransform(m_fbxNode->GetGeometricTranslation(FbxNode::eSourcePivot),
m_fbxNode->GetGeometricRotation(FbxNode::eSourcePivot), m_fbxNode->GetGeometricScaling(FbxNode::eSourcePivot));
return FbxTypeConverter::ToTransform(geoTransform);
}
const AZStd::shared_ptr<FbxAnimCurveWrapper> FbxNodeWrapper::GetLocalTranslationCurve(const AZStd::shared_ptr<FbxAnimLayerWrapper>& layer,
CurveNodeComponent component) const
{
if (!layer)
{
return nullptr;
}
const char* componentString = nullptr;
switch (component)
{
case Component_X:
componentString = FBXSDK_CURVENODE_COMPONENT_X;
break;
case Component_Y:
componentString = FBXSDK_CURVENODE_COMPONENT_Y;
break;
case Component_Z:
componentString = FBXSDK_CURVENODE_COMPONENT_Z;
break;
default:
break;
}
// If there is available animation curve data of specified component/channel for translation, create and return a wrapped version of it.
return m_fbxNode->LclTranslation.GetCurve(layer->m_fbxAnimLayer, componentString) ?
AZStd::make_shared<FbxAnimCurveWrapper>(m_fbxNode->LclTranslation.GetCurve(layer->m_fbxAnimLayer, componentString)) : nullptr;
}
const AZStd::shared_ptr<FbxAnimCurveWrapper> FbxNodeWrapper::GetLocalRotationCurve(const AZStd::shared_ptr<FbxAnimLayerWrapper>& layer,
CurveNodeComponent component) const
{
if (!layer)
{
return nullptr;
}
const char* componentString = nullptr;
switch (component)
{
case Component_X:
componentString = FBXSDK_CURVENODE_COMPONENT_X;
break;
case Component_Y:
componentString = FBXSDK_CURVENODE_COMPONENT_Y;
break;
case Component_Z:
componentString = FBXSDK_CURVENODE_COMPONENT_Z;
break;
default:
break;
}
// If there is available animation curve data of specified component/channel for rotation, create and return a wrapped version of it.
return m_fbxNode->LclRotation.GetCurve(layer->m_fbxAnimLayer, componentString) ?
AZStd::make_shared<FbxAnimCurveWrapper>(m_fbxNode->LclRotation.GetCurve(layer->m_fbxAnimLayer, componentString)) : nullptr;
}
bool FbxNodeWrapper::IsAnimated() const
{
return FbxAnimUtilities::IsAnimated(m_fbxNode);
}
int FbxNodeWrapper::GetChildCount() const
{
return m_fbxNode->GetChildCount();
}
const std::shared_ptr<SDKNode::NodeWrapper> FbxNodeWrapper::GetChild(int childIndex) const
{
FbxNode* child = m_fbxNode->GetChild(childIndex);
AZ_Assert(child, "Cannot get child FbxNode at index %d", childIndex);
return child ? std::shared_ptr<SDKNode::NodeWrapper>(new FbxNodeWrapper(child)) : nullptr;
}
const std::shared_ptr<FbxMaterialWrapper> FbxNodeWrapper::GetMaterial(int index) const
{
if (index < GetMaterialCount())
{
return std::shared_ptr<FbxMaterialWrapper>(new FbxMaterialWrapper(m_fbxNode->GetMaterial(index)));
}
AZ_Assert(index < GetMaterialCount(), "Invalid material index %d", index);
return nullptr;
}
} // namespace FbxSDKWrapper
} // namespace AZ

69
Code/Tools/SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h
Unescape Escape View File

@ -1,69 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxMeshWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxPropertyWrapper.h>
#include <SceneAPI/SceneCore/DataTypes/MatrixType.h>
#include <SceneAPI/SDKWrapper/NodeWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxMaterialWrapper;
class FbxAnimLayerWrapper;
class FbxAnimCurveWrapper;
class FbxNodeWrapper : public SDKNode::NodeWrapper
{
public:
AZ_RTTI(FbxNodeWrapper, "{5F1C09D1-791C-41CA-94DB-D7DD2810C859}", SDKNode::NodeWrapper);
FbxNodeWrapper(FbxNode* fbxNode);
~FbxNodeWrapper() override;
int GetMaterialCount() const override;
virtual const char* GetMaterialName(int index) const;
virtual const std::shared_ptr<FbxMaterialWrapper> GetMaterial(int index) const;
virtual const std::shared_ptr<FbxMeshWrapper> GetMesh() const;
virtual const std::shared_ptr<FbxPropertyWrapper> FindProperty(const char* name) const;
virtual bool IsBone() const;
virtual bool IsMesh() const;
const char* GetName() const override;
AZ::u64 GetUniqueId() const override;
virtual SceneAPI::DataTypes::MatrixType EvaluateGlobalTransform();
virtual Vector3 EvaluateLocalTranslation();
virtual Vector3 EvaluateLocalTranslation(FbxTimeWrapper& time);
virtual SceneAPI::DataTypes::MatrixType EvaluateLocalTransform();
virtual SceneAPI::DataTypes::MatrixType EvaluateLocalTransform(FbxTimeWrapper& time);
virtual Vector3 EvaluateLocalRotation();
virtual Vector3 EvaluateLocalRotation(FbxTimeWrapper& time);
virtual Vector3 GetGeometricTranslation() const;
virtual Vector3 GetGeometricScaling() const;
virtual Vector3 GetGeometricRotation() const;
virtual SceneAPI::DataTypes::MatrixType GetGeometricTransform() const;
virtual const AZStd::shared_ptr<FbxAnimCurveWrapper> GetLocalTranslationCurve(const AZStd::shared_ptr<FbxAnimLayerWrapper>& layer, CurveNodeComponent component) const;
virtual const AZStd::shared_ptr<FbxAnimCurveWrapper> GetLocalRotationCurve(const AZStd::shared_ptr<FbxAnimLayerWrapper>& layer, CurveNodeComponent component) const;
int GetChildCount() const override;
const std::shared_ptr<NodeWrapper> GetChild(int childIndex) const override;
virtual bool IsAnimated() const;
protected:
FbxNodeWrapper() = default;
};
} // namespace FbxSDKWrapper
} // namespace AZ

57
Code/Tools/SceneAPI/FbxSDKWrapper/FbxPropertyWrapper.cpp
Unescape Escape View File

@ -1,57 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Casting/numeric_cast.h>
#include <SceneAPI/FbxSDKWrapper/FbxPropertyWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxTypeConverter.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxPropertyWrapper::FbxPropertyWrapper(FbxProperty* fbxProperty)
: m_fbxProperty(fbxProperty)
{
AZ_Assert(fbxProperty, "Invalid FbxProperty to initialize FbxPropertyWrapper");
}
FbxPropertyWrapper::~FbxPropertyWrapper()
{
m_fbxProperty = nullptr;
}
bool FbxPropertyWrapper::IsValid() const
{
return m_fbxProperty->IsValid();
}
Vector3 FbxPropertyWrapper::GetFbxVector3() const
{
return FbxTypeConverter::ToVector3(m_fbxProperty->Get<FbxVector4>());
}
int FbxPropertyWrapper::GetFbxInt() const
{
return aznumeric_caster(m_fbxProperty->Get<FbxInt>());
}
AZStd::string FbxPropertyWrapper::GetFbxString() const
{
return AZStd::string(m_fbxProperty->Get<FbxString>().Buffer());
}
const char* FbxPropertyWrapper::GetEnumValue(int index) const
{
return m_fbxProperty->GetEnumValue(index);
}
} // namespace FbxSDKWrapper
} // namespace AZ

39
Code/Tools/SceneAPI/FbxSDKWrapper/FbxPropertyWrapper.h
Unescape Escape View File

@ -1,39 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/Math/Vector3.h>
#include <AzCore/std/string/string.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxPropertyWrapper
{
public:
FbxPropertyWrapper(FbxProperty* fbxProperty);
virtual ~FbxPropertyWrapper();
virtual bool IsValid() const;
virtual Vector3 GetFbxVector3() const;
virtual int GetFbxInt() const;
virtual AZStd::string GetFbxString() const;
virtual const char* GetEnumValue(int index) const;
protected:
FbxProperty* m_fbxProperty;
};
} // namespace FbxSDKWrapper
} // namespace AZ

200
Code/Tools/SceneAPI/FbxSDKWrapper/FbxSceneWrapper.cpp
Unescape Escape View File

@ -1,200 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/FbxSDKWrapper/FbxSceneWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxSceneWrapper::FbxSceneWrapper()
: SceneWrapperBase()
, m_fbxManager(nullptr)
, m_fbxImporter(nullptr)
, m_fbxIOSettings(nullptr)
{
}
FbxSceneWrapper::FbxSceneWrapper(FbxScene* fbxScene)
: SceneWrapperBase(fbxScene)
, m_fbxManager(nullptr)
, m_fbxImporter(nullptr)
, m_fbxIOSettings(nullptr)
{
AZ_Assert(fbxScene, "FbxSceneWrapper should have a valid scene to initialize.");
}
FbxSceneWrapper::~FbxSceneWrapper()
{
if (m_fbxScene)
{
m_fbxScene->Destroy();
m_fbxScene = nullptr;
}
if (m_fbxImporter)
{
m_fbxImporter->Destroy();
m_fbxImporter = nullptr;
}
if (m_fbxIOSettings)
{
m_fbxIOSettings->Destroy();
m_fbxIOSettings = nullptr;
}
if (m_fbxManager)
{
m_fbxManager->Destroy();
m_fbxManager = nullptr;
}
}
AZStd::shared_ptr<FbxAxisSystemWrapper> FbxSceneWrapper::GetAxisSystem() const
{
return AZStd::make_shared<FbxAxisSystemWrapper>(m_fbxScene->GetGlobalSettings().GetAxisSystem());
}
AZStd::shared_ptr<FbxSystemUnitWrapper> FbxSceneWrapper::GetSystemUnit() const
{
return AZStd::make_shared<FbxSystemUnitWrapper>(m_fbxScene->GetGlobalSettings().GetSystemUnit());
}
FbxTimeWrapper FbxSceneWrapper::GetTimeLineDefaultDuration() const
{
FbxTimeSpan timeSpan;
m_fbxScene->GetGlobalSettings().GetTimelineDefaultTimeSpan(timeSpan);
return FbxTimeWrapper(timeSpan.GetDuration());
}
const char* FbxSceneWrapper::GetLastSavedApplicationName() const
{
if (m_fbxScene->GetDocumentInfo())
{
return m_fbxScene->GetDocumentInfo()->LastSaved_ApplicationName.Get().Buffer();
}
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Cannot get valid document info from FbxScene");
return nullptr;
}
const char* FbxSceneWrapper::GetLastSavedApplicationVersion() const
{
if (m_fbxScene->GetDocumentInfo())
{
return m_fbxScene->GetDocumentInfo()->LastSaved_ApplicationVersion.Get().Buffer();
}
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Cannot get valid document info from FbxScene");
return nullptr;
}
const std::shared_ptr<SDKNode::NodeWrapper> FbxSceneWrapper::GetRootNode() const
{
return std::shared_ptr<FbxNodeWrapper>(new FbxNodeWrapper(m_fbxScene->GetRootNode()));
}
std::shared_ptr<SDKNode::NodeWrapper> FbxSceneWrapper::GetRootNode()
{
return std::shared_ptr<FbxNodeWrapper>(new FbxNodeWrapper(m_fbxScene->GetRootNode()));
}
int FbxSceneWrapper::GetAnimationStackCount() const
{
return m_fbxScene->GetSrcObjectCount<FbxAnimStack>();
}
const std::shared_ptr<FbxAnimStackWrapper> FbxSceneWrapper::GetAnimationStackAt(int index) const
{
return std::shared_ptr<FbxAnimStackWrapper>(new FbxAnimStackWrapper(FbxCast<FbxAnimStack>(m_fbxScene->GetSrcObject<FbxAnimStack>(index))));
}
bool FbxSceneWrapper::LoadSceneFromFile(const char* fileName)
{
AZ_TracePrintf(SceneAPI::Utilities::LogWindow, "FbxSceneWrapper::LoadSceneFromFile %s", fileName);
AZ_TraceContext("Filename", fileName);
if (!m_fbxManager)
{
m_fbxManager = FbxManager::Create();
if (!m_fbxManager)
{
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Failed to create FbxManager");
return false;
}
}
if (!m_fbxIOSettings)
{
m_fbxIOSettings = FbxIOSettings::Create(m_fbxManager, IOSROOT);
if (!m_fbxIOSettings)
{
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Failed to create FbxIOSettings");
return false;
}
}
m_fbxManager->SetIOSettings(m_fbxIOSettings);
if (!m_fbxImporter)
{
m_fbxImporter = FbxImporter::Create(m_fbxManager, "");
if (!m_fbxImporter)
{
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Failed to create FbxImporter with FbxManager");
return false;
}
}
if (!m_fbxImporter->Initialize(fileName, -1, m_fbxManager->GetIOSettings()))
{
FbxString error = m_fbxImporter->GetStatus().GetErrorString();
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Failed to initialize FbxImporter with fbx file. Error returned: %s", error.Buffer());
return false;
}
// Create a new FBX scene so it can be populated by the imported file.
m_fbxScene = FbxScene::Create(m_fbxManager, s_defaultSceneName);
if (!m_fbxScene)
{
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Failed to create FbxScene");
return false;
}
if (!m_fbxImporter->Import(m_fbxScene))
{
FbxString error = m_fbxImporter->GetStatus().GetErrorString();
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Failed to import FbxScene. Error returned: %s", error.Buffer());
return false;
}
return true;
}
bool FbxSceneWrapper::LoadSceneFromFile(const AZStd::string& fileName)
{
return LoadSceneFromFile(fileName.c_str());
}
void FbxSceneWrapper::Clear()
{
if (m_fbxScene)
{
m_fbxScene->Clear();
}
}
}//namespace FbxSDKWrapper
} // namespace AZ

62
Code/Tools/SceneAPI/FbxSDKWrapper/FbxSceneWrapper.h
Unescape Escape View File

@ -1,62 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// FBX SDK Wrapper
// provides isolation between AUTODESK FBX SDK and FBX Serializer
// provides necessary APIs for FBX Serializer
//
////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
#include <AzCore/std/smart_ptr/shared_ptr.h>
#include <SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimStackWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxAxisSystemWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxSystemUnitWrapper.h>
#include <SceneAPI/SDKWrapper/SceneWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxSceneWrapper : public SDKScene::SceneWrapperBase
{
public:
AZ_RTTI(FbxSceneWrapper, "{63637E50-BB26-4BE9-AECD-D1168AE2355B}", SDKScene::SceneWrapperBase);
FbxSceneWrapper();
FbxSceneWrapper(fbxsdk::FbxScene* fbxScene);
~FbxSceneWrapper();
bool LoadSceneFromFile(const char* fileName) override;
bool LoadSceneFromFile(const AZStd::string& fileName) override;
virtual AZStd::shared_ptr<FbxSystemUnitWrapper> GetSystemUnit() const;
virtual AZStd::shared_ptr<FbxAxisSystemWrapper> GetAxisSystem() const;
virtual FbxTimeWrapper GetTimeLineDefaultDuration() const;
virtual const char* GetLastSavedApplicationName() const;
virtual const char* GetLastSavedApplicationVersion() const;
const std::shared_ptr<SDKNode::NodeWrapper> GetRootNode() const override;
std::shared_ptr<SDKNode::NodeWrapper> GetRootNode() override;
virtual int GetAnimationStackCount() const;
virtual const std::shared_ptr<FbxAnimStackWrapper> GetAnimationStackAt(int index) const;
void Clear() override;
protected:
FbxManager* m_fbxManager;
FbxImporter* m_fbxImporter;
FbxIOSettings* m_fbxIOSettings;
};
} // namespace FbxSDKWrapper
} // namespace AZ

86
Code/Tools/SceneAPI/FbxSDKWrapper/FbxSkinWrapper.cpp
Unescape Escape View File

@ -1,86 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzCore/Debug/Trace.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/FbxSDKWrapper/FbxSkinWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxSkinWrapper::FbxSkinWrapper(FbxSkin* fbxSkin)
: m_fbxSkin(fbxSkin)
{
AZ_Assert(fbxSkin, "Invalid FbxSkin input to initialize FbxSkinWrapper");
}
FbxSkinWrapper::~FbxSkinWrapper()
{
m_fbxSkin = nullptr;
}
const char* FbxSkinWrapper::GetName() const
{
return m_fbxSkin->GetName();
}
int FbxSkinWrapper::GetClusterCount() const
{
return m_fbxSkin->GetClusterCount();
}
int FbxSkinWrapper::GetClusterControlPointIndicesCount(int index) const
{
if (index < m_fbxSkin->GetClusterCount())
{
return m_fbxSkin->GetCluster(index)->GetControlPointIndicesCount();
}
AZ_Assert(index < m_fbxSkin->GetClusterCount(), "Invalid skin cluster index %d", index);
return 0;
}
int FbxSkinWrapper::GetClusterControlPointIndex(int clusterIndex, int pointIndex) const
{
bool validIndex = clusterIndex < m_fbxSkin->GetClusterCount() && pointIndex < m_fbxSkin->GetCluster(clusterIndex)->GetControlPointIndicesCount();
if (validIndex)
{
return m_fbxSkin->GetCluster(clusterIndex)->GetControlPointIndices()[pointIndex];
}
AZ_Assert(validIndex, "Invalid skin cluster control point index at cluster index %d control point index %d", clusterIndex, pointIndex);
return -1;
}
double FbxSkinWrapper::GetClusterControlPointWeight(int clusterIndex, int pointIndex) const
{
bool validIndex = clusterIndex < m_fbxSkin->GetClusterCount() && pointIndex < m_fbxSkin->GetCluster(clusterIndex)->GetControlPointIndicesCount();
if (validIndex)
{
return m_fbxSkin->GetCluster(clusterIndex)->GetControlPointWeights()[pointIndex];
}
AZ_Assert(validIndex, "Invalid skin cluster control point weight at cluster index %d control point index %d", clusterIndex, pointIndex);
return 0.0f;
}
AZStd::shared_ptr<const FbxNodeWrapper> FbxSkinWrapper::GetClusterLink(int index) const
{
if (index < m_fbxSkin->GetClusterCount())
{
return AZStd::make_shared<const FbxNodeWrapper>(m_fbxSkin->GetCluster(index)->GetLink());
}
AZ_Assert(index < m_fbxSkin->GetClusterCount(), "Invalid skin cluster index %d", index);
return nullptr;
}
} // namespace FbxSDKWrapper
} // namespace AZ

42
Code/Tools/SceneAPI/FbxSDKWrapper/FbxSkinWrapper.h
Unescape Escape View File

@ -1,42 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/std/smart_ptr/shared_ptr.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxNodeWrapper;
class FbxSkinWrapper
{
public:
FbxSkinWrapper(FbxSkin* fbxSkin);
virtual ~FbxSkinWrapper();
virtual const char* GetName() const;
virtual int GetClusterCount() const;
virtual int GetClusterControlPointIndicesCount(int index) const;
virtual int GetClusterControlPointIndex(int clusterIndex, int pointIndex) const;
virtual double GetClusterControlPointWeight(int clusterIndex, int pointIndex) const;
virtual AZStd::shared_ptr<const FbxNodeWrapper> GetClusterLink(int index) const;
protected:
FbxSkinWrapper() = default;
FbxSkin* m_fbxSkin;
};
} // namespace FbxSDKWrapper
} // namespace AZ

108
Code/Tools/SceneAPI/FbxSDKWrapper/FbxSystemUnitWrapper.cpp
Unescape Escape View File

@ -1,108 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Casting/numeric_cast.h>
#include <AzCore/Debug/Trace.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/FbxSDKWrapper/FbxSystemUnitWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxSystemUnitWrapper::FbxSystemUnitWrapper(const FbxSystemUnit& fbxSystemUnit)
: m_fbxSystemUnit(fbxSystemUnit)
{
}
FbxSystemUnitWrapper::Unit FbxSystemUnitWrapper::GetUnit() const
{
if (m_fbxSystemUnit == FbxSystemUnit::mm)
{
return mm;
}
if (m_fbxSystemUnit == FbxSystemUnit::dm)
{
return dm;
}
if (m_fbxSystemUnit == FbxSystemUnit::cm)
{
return cm;
}
if (m_fbxSystemUnit == FbxSystemUnit::m)
{
return m;
}
if (m_fbxSystemUnit == FbxSystemUnit::km)
{
return km;
}
if (m_fbxSystemUnit == FbxSystemUnit::Inch)
{
return inch;
}
if (m_fbxSystemUnit == FbxSystemUnit::Foot)
{
return foot;
}
if (m_fbxSystemUnit == FbxSystemUnit::Mile)
{
return mile;
}
if (m_fbxSystemUnit == FbxSystemUnit::Yard)
{
return yard;
}
AZ_TracePrintf(SceneAPI::Utilities::WarningWindow, "Unrecognized current unit type");
return unknown;
}
float FbxSystemUnitWrapper::GetConversionFactorTo(Unit to)
{
FbxSystemUnit targetUnit;
switch (to)
{
case mm:
targetUnit = FbxSystemUnit::mm;
break;
case dm:
targetUnit = FbxSystemUnit::dm;
break;
case cm:
targetUnit = FbxSystemUnit::cm;
break;
case m:
targetUnit = FbxSystemUnit::m;
break;
case km:
targetUnit = FbxSystemUnit::km;
break;
case inch:
targetUnit = FbxSystemUnit::Inch;
break;
case foot:
targetUnit = FbxSystemUnit::Foot;
break;
case mile:
targetUnit = FbxSystemUnit::Mile;
break;
case yard:
targetUnit = FbxSystemUnit::Yard;
break;
default:
AZ_TracePrintf(SceneAPI::Utilities::WarningWindow, "Unrecognized unit conversion target type");
targetUnit = FbxSystemUnit::m;
}
return aznumeric_caster(m_fbxSystemUnit.GetConversionFactorTo(targetUnit));
}
} // namespace FbxSDKWrapper
} // namespace AZ

49
Code/Tools/SceneAPI/FbxSDKWrapper/FbxSystemUnitWrapper.h
Unescape Escape View File

@ -1,49 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxSystemUnitWrapper
{
public:
enum Unit
{
mm,
dm,
cm,
m,
km,
inch,
foot,
mile,
yard,
unknown
};
FbxSystemUnitWrapper() = default;
FbxSystemUnitWrapper(const FbxSystemUnit& fbxSystemUnit);
virtual ~FbxSystemUnitWrapper() = default;
virtual Unit GetUnit() const;
virtual float GetConversionFactorTo(Unit to);
protected:
FbxSystemUnit m_fbxSystemUnit;
};
} // namespace FbxSDKWrapper
} // namespace AZ

45
Code/Tools/SceneAPI/FbxSDKWrapper/FbxTimeSpanWrapper.cpp
Unescape Escape View File

@ -1,45 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Debug/Trace.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeSpanWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxTimeSpanWrapper::FbxTimeSpanWrapper(const FbxTimeSpan& fbxTimeSpan)
: m_fbxTimeSpan(fbxTimeSpan)
{
}
FbxTimeWrapper FbxTimeSpanWrapper::GetStartTime() const
{
return FbxTimeWrapper(m_fbxTimeSpan.GetStart());
}
FbxTimeWrapper FbxTimeSpanWrapper::GetStopTime() const
{
return FbxTimeWrapper(m_fbxTimeSpan.GetStop());
}
double FbxTimeSpanWrapper::GetFrameRate() const
{
return FbxTimeWrapper(m_fbxTimeSpan.GetStart()).GetFrameRate();
}
int64_t FbxTimeSpanWrapper::GetNumFrames() const
{
return GetStopTime().GetFrameCount() - GetStartTime().GetFrameCount() + 1;
}
} // namespace FbxSDKWrapper
} // namespace AZ

37
Code/Tools/SceneAPI/FbxSDKWrapper/FbxTimeSpanWrapper.h
Unescape Escape View File

@ -1,37 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h>
#include <fbxsdk.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxTimeSpanWrapper
{
public:
FbxTimeSpanWrapper(const FbxTimeSpan& fbxTimeSpan);
virtual ~FbxTimeSpanWrapper() = default;
virtual FbxTimeWrapper GetStartTime() const;
virtual FbxTimeWrapper GetStopTime() const;
virtual double GetFrameRate() const;
int64_t GetNumFrames() const;
protected:
FbxTimeSpan m_fbxTimeSpan;
};
} // namespace FbxSDKWrapper
} // namespace AZ

76
Code/Tools/SceneAPI/FbxSDKWrapper/FbxTimeWrapper.cpp
Unescape Escape View File

@ -1,76 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Debug/Trace.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxTimeWrapper::FbxTimeWrapper() : m_fbxTime(FBXSDK_TIME_INFINITE)
{
}
FbxTimeWrapper::FbxTimeWrapper(const FbxTime& fbxTime) : m_fbxTime(fbxTime)
{
}
FbxTimeWrapper::~FbxTimeWrapper()
{
}
void FbxTimeWrapper::SetFrame(int64_t frames, TimeMode timeMode)
{
m_fbxTime.SetFrame(static_cast<FbxLongLong>(frames), GetFbxTimeMode(timeMode));
}
void FbxTimeWrapper::SetTime(double time)
{
m_fbxTime.SetSecondDouble(time);
}
double FbxTimeWrapper::GetFrameRate() const
{
return m_fbxTime.GetFrameRate(m_fbxTime.GetGlobalTimeMode());
}
int64_t FbxTimeWrapper::GetFrameCount() const
{
return static_cast<int64_t>(m_fbxTime.GetFrameCount());
}
double FbxTimeWrapper::GetTime() const
{
return m_fbxTime.GetSecondDouble();
}
FbxTime::EMode FbxTimeWrapper::GetFbxTimeMode(TimeMode timeMode) const
{
switch (timeMode)
{
case frames60:
return FbxTime::eFrames60;
case frames30:
return FbxTime::eFrames30;
case frames24:
return FbxTime::eFrames24;
case defaultMode:
return FbxTime::eDefaultMode;
default:
AZ_TracePrintf(SceneAPI::Utilities::WarningWindow, "Unsupported frame rate");
return FbxTime::eDefaultMode;
}
}
} // namespace FbxSDKWrapper
} // namespace AZ

52
Code/Tools/SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h
Unescape Escape View File

@ -1,52 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <stdint.h>
#include <fbxsdk.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxTimeWrapper
{
friend class FbxNodeWrapper;
friend class FbxAnimCurveWrapper;
public:
enum TimeMode
{
defaultMode,
frames60,
frames30,
frames24,
eModesCount
};
FbxTimeWrapper();
FbxTimeWrapper(const FbxTime& fbxTime);
virtual ~FbxTimeWrapper();
virtual void SetFrame(int64_t frames, TimeMode timeMode = defaultMode);
virtual void SetTime(double time);
virtual double GetFrameRate() const;
virtual int64_t GetFrameCount() const;
virtual double GetTime() const;
protected:
FbxTime::EMode GetFbxTimeMode(TimeMode timeMode) const;
FbxTime m_fbxTime;
};
} // namespace FbxSDKWrapper
} // namespace AZ

64
Code/Tools/SceneAPI/FbxSDKWrapper/FbxTypeConverter.cpp
Unescape Escape View File

@ -1,64 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSDKWrapper/FbxTypeConverter.h>
namespace AZ
{
namespace FbxSDKWrapper
{
Vector2 FbxTypeConverter::ToVector2(const FbxVector2& vector)
{
return Vector2(static_cast<float>(vector[0]),
static_cast<float>(vector[1]));
}
Vector3 FbxTypeConverter::ToVector3(const FbxVector4& vector)
{
// Note: FbxVector4[x] is of type FbxDouble and aznumeric_caster does not accept it as cast from type.
return Vector3(static_cast<float>(vector[0]),
static_cast<float>(vector[1]),
static_cast<float>(vector[2]));
}
SceneAPI::DataTypes::MatrixType FbxTypeConverter::ToTransform(const FbxAMatrix& matrix)
{
SceneAPI::DataTypes::MatrixType transform;
for (int row = 0; row < 3; ++row)
{
FbxVector4 line = matrix.GetColumn(row);
for (int column = 0; column < 4; ++column)
{
// Note: FbxVector4[x] is of type FbxDouble and aznumeric_caster does not accept it as cast from type.
transform.SetElement(row, column, static_cast<float>(line[column]));
}
}
return transform;
}
SceneAPI::DataTypes::MatrixType FbxTypeConverter::ToTransform(const FbxMatrix& matrix)
{
// This implementation ignores the last row, effectively assuming it to be (0,0,0,1)
SceneAPI::DataTypes::MatrixType transform;
for (int row = 0; row < 3; ++row)
{
FbxVector4 line = matrix.GetColumn(row);
for (int column = 0; column < 4; ++column)
{
// Note: FbxVector4[x] is of type FbxDouble and aznumeric_caster does not accept it as cast from type.
transform.SetElement(row, column, static_cast<float>(line[column]));
}
}
return transform;
}
} // namespace FbxSDKWrapper
} // namespace AZ

32
Code/Tools/SceneAPI/FbxSDKWrapper/FbxTypeConverter.h
Unescape Escape View File

@ -1,32 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/Math/Vector2.h>
#include <AzCore/Math/Vector3.h>
#include <SceneAPI/SceneCore/DataTypes/MatrixType.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxTypeConverter
{
public:
static Vector2 ToVector2(const FbxVector2& vector);
static Vector3 ToVector3(const FbxVector4& vector);
static SceneAPI::DataTypes::MatrixType ToTransform(const FbxAMatrix& matrix);
static SceneAPI::DataTypes::MatrixType ToTransform(const FbxMatrix& matrix);
};
} // namespace FbxSDKWrapper
} // namespace AZ

53
Code/Tools/SceneAPI/FbxSDKWrapper/FbxUVWrapper.cpp
Unescape Escape View File

@ -1,53 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSDKWrapper/FbxUVWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxLayerElementUtilities.h>
#include <SceneAPI/FbxSDKWrapper/FbxTypeConverter.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxUVWrapper::FbxUVWrapper(FbxGeometryElementUV* fbxUV)
: m_fbxUV(fbxUV)
{
AZ_Assert(fbxUV, "Invalid FbxGeometryElementUV to initialize FbxUVWrapper")
}
FbxUVWrapper::~FbxUVWrapper()
{
m_fbxUV = nullptr;
}
const char* FbxUVWrapper::GetName() const
{
if (m_fbxUV)
{
return m_fbxUV->GetName();
}
return nullptr;
}
Vector2 FbxUVWrapper::GetElementAt(int polygonIndex, int polygonVertexIndex, int controlPointIndex) const
{
FbxVector2 uv;
FbxLayerElementUtilities::GetGeometryElement(uv, m_fbxUV, polygonIndex, polygonVertexIndex, controlPointIndex);
return FbxTypeConverter::ToVector2(uv);
}
bool FbxUVWrapper::IsValid() const
{
return m_fbxUV != nullptr;
}
} // namespace FbxSDKWrapper
} // namespace AZ

37
Code/Tools/SceneAPI/FbxSDKWrapper/FbxUVWrapper.h
Unescape Escape View File

@ -1,37 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/Math/Vector2.h>
#include <SceneAPI/FbxSDKWrapper/FbxLayerElementUtilities.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxUVWrapper
{
public:
FbxUVWrapper(FbxGeometryElementUV* fbxUV);
~FbxUVWrapper();
Vector2 GetElementAt(int polygonIndex, int polygonVertexIndex, int controlPointIndex) const;
const char* GetName() const;
bool IsValid() const;
protected:
FbxGeometryElementUV* m_fbxUV;
};
} // namespace FbxSDKWrapper
} // namespace AZ

58
Code/Tools/SceneAPI/FbxSDKWrapper/FbxVertexBitangentWrapper.cpp
Unescape Escape View File

@ -1,58 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSDKWrapper/FbxVertexBitangentWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxLayerElementUtilities.h>
#include <SceneAPI/FbxSDKWrapper/FbxTypeConverter.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxVertexBitangentWrapper::FbxVertexBitangentWrapper(FbxGeometryElementBinormal* fbxBitangent)
: m_fbxBitangent(fbxBitangent)
{
AZ_Assert(fbxBitangent, "Invalid FbxGeometryElementBinormal to initialize FbxVertexBitangentWrapper")
}
FbxVertexBitangentWrapper::~FbxVertexBitangentWrapper()
{
m_fbxBitangent = nullptr;
}
const char* FbxVertexBitangentWrapper::GetName() const
{
if (m_fbxBitangent)
{
return m_fbxBitangent->GetName();
}
return "";
}
Vector3 FbxVertexBitangentWrapper::GetElementAt(int polygonIndex, int polygonVertexIndex, int controlPointIndex) const
{
FbxVector4 bitangent;
FbxLayerElementUtilities::GetGeometryElement(bitangent, m_fbxBitangent, polygonIndex, polygonVertexIndex, controlPointIndex);
return FbxTypeConverter::ToVector3(bitangent);
}
bool FbxVertexBitangentWrapper::IsValid() const
{
return m_fbxBitangent != nullptr;
}
} // namespace FbxSDKWrapper
} // namespace AZ

39
Code/Tools/SceneAPI/FbxSDKWrapper/FbxVertexBitangentWrapper.h
Unescape Escape View File

@ -1,39 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/Math/Vector3.h>
#include <SceneAPI/FbxSDKWrapper/FbxLayerElementUtilities.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxVertexBitangentWrapper
{
public:
FbxVertexBitangentWrapper(FbxGeometryElementBinormal* fbxBitangent);
~FbxVertexBitangentWrapper();
Vector3 GetElementAt(int polygonIndex, int polygonVertexIndex, int controlPointIndex) const;
const char* GetName() const;
bool IsValid() const;
protected:
FbxGeometryElementBinormal* m_fbxBitangent;
};
} // namespace FbxSDKWrapper
} // namespace AZ

79
Code/Tools/SceneAPI/FbxSDKWrapper/FbxVertexColorWrapper.cpp
Unescape Escape View File

@ -1,79 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Casting/numeric_cast.h>
#include <SceneAPI/FbxSDKWrapper/FbxVertexColorWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxLayerElementUtilities.h>
#include <SceneAPI/FbxSDKWrapper/FbxTypeConverter.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxColorWrapper::FbxColorWrapper(FbxColor& fbxColor)
: m_fbxColor(fbxColor)
{
}
float FbxColorWrapper::GetR() const
{
return aznumeric_caster(m_fbxColor.mRed);
}
float FbxColorWrapper::GetG() const
{
return aznumeric_caster(m_fbxColor.mGreen);
}
float FbxColorWrapper::GetB() const
{
return aznumeric_caster(m_fbxColor.mBlue);
}
float FbxColorWrapper::GetAlpha() const
{
return aznumeric_caster(m_fbxColor.mAlpha);
}
FbxVertexColorWrapper::FbxVertexColorWrapper(FbxGeometryElementVertexColor* fbxVertexColor)
: m_fbxVertexColor(fbxVertexColor)
{
AZ_Assert(m_fbxVertexColor, "Invalid FbxGeometryElementVertexColor to initialie FbxVertexColorWrapper");
}
FbxVertexColorWrapper::~FbxVertexColorWrapper()
{
m_fbxVertexColor = nullptr;
}
const char* FbxVertexColorWrapper::GetName() const
{
if (m_fbxVertexColor)
{
return m_fbxVertexColor->GetName();
}
return nullptr;
}
FbxColorWrapper FbxVertexColorWrapper::GetElementAt(int polygonIndex, int polygonVertexIndex, int controlPointIndex) const
{
FbxColor color;
FbxLayerElementUtilities::GetGeometryElement(color, m_fbxVertexColor, polygonIndex, polygonVertexIndex, controlPointIndex);
return FbxColorWrapper(color);
}
bool FbxVertexColorWrapper::IsValid() const
{
return m_fbxVertexColor != nullptr;
}
} // namespace FbxSDKWrapper
} // namespace AZ

49
Code/Tools/SceneAPI/FbxSDKWrapper/FbxVertexColorWrapper.h
Unescape Escape View File

@ -1,49 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <SceneAPI/FbxSDKWrapper/FbxLayerElementUtilities.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxColorWrapper
{
public:
FbxColorWrapper(FbxColor& fbxColor);
float GetR() const;
float GetG() const;
float GetB() const;
float GetAlpha() const;
protected:
FbxColor m_fbxColor;
};
class FbxVertexColorWrapper
{
public:
FbxVertexColorWrapper(FbxGeometryElementVertexColor* fbxVertexColor);
~FbxVertexColorWrapper();
FbxColorWrapper GetElementAt(int polygonIndex, int polygonVertexIndex, int controlPointIndex) const;
const char* GetName() const;
bool IsValid() const;
protected:
FbxGeometryElementVertexColor* m_fbxVertexColor;
};
} // namespace FbxSDKWrapper
} // namespace AZ

59
Code/Tools/SceneAPI/FbxSDKWrapper/FbxVertexTangentWrapper.cpp
Unescape Escape View File

@ -1,59 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSDKWrapper/FbxVertexTangentWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxLayerElementUtilities.h>
#include <SceneAPI/FbxSDKWrapper/FbxTypeConverter.h>
namespace AZ
{
namespace FbxSDKWrapper
{
FbxVertexTangentWrapper::FbxVertexTangentWrapper(FbxGeometryElementTangent* fbxTangent)
: m_fbxTangent(fbxTangent)
{
AZ_Assert(fbxTangent, "Invalid FbxGeometryElementTangent to initialize FbxVertexTangentWrapper")
}
FbxVertexTangentWrapper::~FbxVertexTangentWrapper()
{
m_fbxTangent = nullptr;
}
const char* FbxVertexTangentWrapper::GetName() const
{
if (m_fbxTangent)
{
return m_fbxTangent->GetName();
}
return "";
}
Vector3 FbxVertexTangentWrapper::GetElementAt(int polygonIndex, int polygonVertexIndex, int controlPointIndex) const
{
FbxVector4 tangent;
FbxLayerElementUtilities::GetGeometryElement(tangent, m_fbxTangent, polygonIndex, polygonVertexIndex, controlPointIndex);
return FbxTypeConverter::ToVector3(tangent);
}
bool FbxVertexTangentWrapper::IsValid() const
{
return m_fbxTangent != nullptr;
}
} // namespace FbxSDKWrapper
} // namespace AZ

39
Code/Tools/SceneAPI/FbxSDKWrapper/FbxVertexTangentWrapper.h
Unescape Escape View File

@ -1,39 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <AzCore/Math/Vector3.h>
#include <SceneAPI/FbxSDKWrapper/FbxLayerElementUtilities.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxVertexTangentWrapper
{
public:
FbxVertexTangentWrapper(FbxGeometryElementTangent* fbxTangent);
~FbxVertexTangentWrapper();
Vector3 GetElementAt(int polygonIndex, int polygonVertexIndex, int controlPointIndex) const;
const char* GetName() const;
bool IsValid() const;
protected:
FbxGeometryElementTangent* m_fbxTangent;
};
} // namespace FbxSDKWrapper
} // namespace AZ

32
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxAnimStackWrapper.h
Unescape Escape View File

@ -1,32 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSDKWrapper/FbxAnimStackWrapper.h>
#include <AzTest/AzTest.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxAnimStackWrapper
: public FbxAnimStackWrapper
{
public:
MOCK_CONST_METHOD0(GetMemberCount,
int());
MOCK_CONST_METHOD1(GetAnimationLayerAt,
FbxAnimLayer * (int index));
};
} // namespace FbxSDKWrapper
} // namespace AZ

32
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxAxisSystemWrapper.h
Unescape Escape View File

@ -1,32 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzTest/AzTest.h>
#include <SceneAPI/FbxSDKWrapper/FbxAxisSystemWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxAxisSystemWrapper
: public FbxAxisSystemWrapper
{
public:
MOCK_CONST_METHOD1(GetUpVector,
UpVector(int));
MOCK_METHOD1(CalculateConversionTransform,
Transform(UpVector));
};
} // namespace FbxSDKWrapper
} // namespace AZ

38
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxMaterialWrapper.h
Unescape Escape View File

@ -1,38 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzTest/AzTest.h>
#include <SceneAPI/FbxSDKWrapper/FbxMaterialWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxMaterialWrapper
: public FbxMaterialWrapper
{
public:
MOCK_CONST_METHOD0(GetName,
std::string());
MOCK_CONST_METHOD1(GetTextureFileName,
std::string(const char* textureType));
MOCK_CONST_METHOD1(GetTextureFileName,
std::string(const std::string& textureType));
MOCK_CONST_METHOD1(GetTextureFileName,
std::string(MaterialMapType textureType));
MOCK_CONST_METHOD0(IsNoDraw,
bool());
};
} // namespace FbxSDKWrapper
} // namespace AZ

56
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxMeshWrapper.h
Unescape Escape View File

@ -1,56 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzTest/AzTest.h>
#include <SceneAPI/FbxSDKWrapper/FbxMeshWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxMeshWrapper
: public FbxMeshWrapper
{
public:
MOCK_CONST_METHOD0(GetDeformerCount,
int());
MOCK_CONST_METHOD1(GetSkin,
AZStd::shared_ptr<const FbxSkinWrapper>(int index));
MOCK_CONST_METHOD1(GetMaterialIndices,
bool(FbxLayerElementArrayTemplate<int>**));
MOCK_CONST_METHOD0(GetControlPointsCount,
int());
MOCK_CONST_METHOD0(GetControlPoints,
AZStd::vector<Vector3>());
MOCK_CONST_METHOD0(GetPolygonCount,
int());
MOCK_CONST_METHOD1(GetPolygonSize,
int(int));
MOCK_CONST_METHOD1(GetPolygonVertics,
int(int index));
MOCK_CONST_METHOD1(GetPolygonVertexIndex,
int(int));
MOCK_CONST_METHOD1(GetElementUV,
FbxUVWrapper(int));
MOCK_CONST_METHOD0(GetElementUVCount,
int());
MOCK_CONST_METHOD1(GetElementVertexColor,
FbxVertexColorWrapper(int));
MOCK_CONST_METHOD0(GetElementVertexColorCount,
int());
MOCK_CONST_METHOD3(GetPolygonVertexNormal,
bool(int, int, Vector3&));
};
} // namespace FbxSDKWrapper
} // namespace AZ

67
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxNodeWrapper.h
Unescape Escape View File

@ -1,67 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h>
#include <AzTest/AzTest.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxNodeWrapper
: public FbxNodeWrapper
{
public:
MOCK_CONST_METHOD0(GetMaterialCount,
int());
MOCK_CONST_METHOD1(GetMaterialName,
const char*(int index));
MOCK_CONST_METHOD1(GetMaterial,
const std::shared_ptr<FbxMaterialWrapper>(int index));
MOCK_CONST_METHOD0(GetMesh,
const std::shared_ptr<FbxMeshWrapper>());
MOCK_CONST_METHOD1(FindProperty,
const std::shared_ptr<FbxPropertyWrapper>(const char* name));
MOCK_CONST_METHOD0(IsBone,
bool());
MOCK_CONST_METHOD0(GetName,
const char*());
MOCK_METHOD0(EvaluateGlobalTransform,
Transform());
MOCK_METHOD0(EvaluateLocalTranslation,
Vector3());
MOCK_METHOD1(EvaluateLocalTranslation,
Vector3(FbxTimeWrapper& time));
MOCK_METHOD0(EvaluateLocalTransform,
Transform());
MOCK_METHOD1(EvaluateLocalTransform,
Transform(FbxTimeWrapper& time));
MOCK_CONST_METHOD0(GetGeometricTranslation,
Vector3());
MOCK_CONST_METHOD0(GetGeometricScaling,
Vector3());
MOCK_CONST_METHOD0(GetGeometricRotation,
Vector3());
MOCK_CONST_METHOD0(GetGeometricTransform,
Transform());
MOCK_CONST_METHOD0(GetChildCount,
int());
MOCK_CONST_METHOD1(GetChild,
const std::shared_ptr<FbxNodeWrapper>(int childIndex));
MOCK_CONST_METHOD0(IsAnimated,
bool());
};
} // namespace FbxSDKWrapper
} // namespace AZ

42
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxPropertyWrapper.h
Unescape Escape View File

@ -1,42 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSDKWrapper/FbxPropertyWrapper.h>
#include <AzTest/AzTest.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxPropertyWrapper
: public FbxPropertyWrapper
{
public:
MockFbxPropertyWrapper()
: FbxPropertyWrapper(new FbxProperty())
{
}
MOCK_CONST_METHOD0(IsValid,
bool());
MOCK_CONST_METHOD0(GetFbxVector4,
Vector4());
MOCK_CONST_METHOD0(GetFbxInt,
FbxInt());
MOCK_CONST_METHOD0(GetFbxString,
AZStd::string());
MOCK_CONST_METHOD1(GetEnumValue,
const char*(int index));
};
} // namespace FbxSDKWrapper
} // namespace AZ

55
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxSceneWrapper.h
Unescape Escape View File

@ -1,55 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSDKWrapper/FbxSceneWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h>
#include <AzTest/AzTest.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxSceneWrapper
: public FbxSceneWrapper
{
public:
virtual ~MockFbxSceneWrapper() = default;
MOCK_METHOD1(LoadSceneFromFile,
bool(const char* fileName));
MOCK_METHOD1(LoadSceneFromFile,
bool(const std::string& fileName));
MOCK_CONST_METHOD0(GetSystemUnit,
AZStd::shared_ptr<FbxSystemUnitWrapper>());
MOCK_CONST_METHOD0(GetAxisSystem,
AZStd::shared_ptr<FbxAxisSystemWrapper>());
MOCK_CONST_METHOD0(GetTimeLineDefaultDuration,
FbxTimeWrapper());
MOCK_CONST_METHOD0(GetLastSavedApplicationName,
const char*());
MOCK_CONST_METHOD0(GetLastSavedApplicationVersion,
const char*());
MOCK_CONST_METHOD0(GetRootNode,
const std::shared_ptr<FbxNodeWrapper>());
MOCK_METHOD0(GetRootNode,
std::shared_ptr<FbxNodeWrapper>());
MOCK_CONST_METHOD0(GetAnimationStackCount,
int());
MOCK_CONST_METHOD1(GetAnimationStackAt,
const std::shared_ptr<FbxAnimStackWrapper>(int index));
MOCK_METHOD0(Clear,
void());
};
} // namespace FbxSDKWrapper
} // namespace AZ

40
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxSkinWrapper.h
Unescape Escape View File

@ -1,40 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSdkWrapper/FbxSkinWrapper.h>
#include <AzTest/AzTest.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxSkinWrapper
: public FbxSkinWrapper
{
public:
MOCK_CONST_METHOD0(GetName,
const char*());
MOCK_CONST_METHOD0(GetClusterCount,
int());
MOCK_CONST_METHOD1(GetClusterControlPointIndicesCount,
int(int index));
MOCK_CONST_METHOD2(GetClusterControlPointIndices,
int(int clusterIndex, int pointIndex));
MOCK_CONST_METHOD2(GetClusterControlPointWeights,
double(int clusterIndex, int pointIndex));
MOCK_CONST_METHOD1(GetClusterLink,
AZStd::shared_ptr<const FbxNodeWrapper>(int index));
};
} // namespace FbxSDKWrapper
} // namespace AZ

32
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxSystemUnitWrapper.h
Unescape Escape View File

@ -1,32 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzTest/AzTest.h>
#include <SceneAPI/FbxSDKWrapper/FbxSystemUnitWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxSystemUnitWrapper
: public FbxSystemUnitWrapper
{
public:
MOCK_CONST_METHOD0(GetUnit,
Unit());
MOCK_METHOD1(GetConversionFactorTo,
float(Unit));
};
} // namespace FbxSDKWrapper
} // namespace AZ

34
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxTimeWrapper.h
Unescape Escape View File

@ -1,34 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzTest/AzTest.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxTimeWrapper
: public FbxTimeWrapper
{
public:
MOCK_METHOD2(SetFrame,
void(int64_t, TimeMode));
MOCK_CONST_METHOD0(GetFrameRate,
double());
MOCK_CONST_METHOD0(GetFrameCount,
int64_t());
};
} // namespace FbxSDKWrapper
} // namespace AZ

34
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxUVWrapper.h
Unescape Escape View File

@ -1,34 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSDKWrapper/FbxUVWrapper.h>
#include <AzTest/AzTest.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxUVWrapper
: public FbxUVWrapper
{
public:
MOCK_CONST_METHOD3(GetElementAt,
Vector2(int, int, int));
MOCK_CONST_METHOD0(GetName,
const char*());
MOCK_CONST_METHOD0(IsValid,
bool());
};
} // namespace FbxSDKWrapper
} // namespace AZ

35
Code/Tools/SceneAPI/FbxSDKWrapper/Mocks/MockFbxVertexColorWrapper.h
Unescape Escape View File

@ -1,35 +0,0 @@
#pragma once
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzTest/AzTest.h>
#include <SceneAPI/FbxSDKWrapper/FbxVertexColorWrapper.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class MockFbxVertexColorWrapper
: public FbxVertexColorWrapper
{
public:
MOCK_CONST_METHOD3(GetElementAt,
FbxColorWrapper(int, int, int));
MOCK_CONST_METHOD0(GetName,
const char*());
MOCK_CONST_METHOD0(IsValid,
bool());
};
} // namespace FbxSDKWrapper
} // namespace AZ

69
Code/Tools/SceneAPI/FbxSDKWrapper/fbxsdkwrapper_files.cmake
Unescape Escape View File

@ -1,69 +0,0 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
set(FILES
FbxSceneWrapper.cpp
FbxAnimStackWrapper.cpp
FbxAnimLayerWrapper.cpp
FbxAnimCurveNodeWrapper.cpp
FbxAnimCurveWrapper.cpp
FbxNodeWrapper.cpp
FbxMeshWrapper.cpp
FbxSkinWrapper.cpp
FbxPropertyWrapper.cpp
FbxMaterialWrapper.cpp
FbxTimeWrapper.cpp
FbxTimeSpanWrapper.cpp
FbxTypeConverter.cpp
FbxAxisSystemWrapper.cpp
FbxSystemUnitWrapper.cpp
FbxVertexColorWrapper.cpp
FbxVertexTangentWrapper.cpp
FbxVertexBitangentWrapper.cpp
FbxUVWrapper.cpp
FbxBlendShapeWrapper.cpp
FbxBlendShapeChannelWrapper.cpp
FbxLayerElementUtilities.inl
FbxSceneWrapper.h
FbxAnimStackWrapper.h
FbxAnimLayerWrapper.h
FbxAnimCurveNodeWrapper.h
FbxAnimCurveWrapper.h
FbxNodeWrapper.h
FbxMeshWrapper.h
FbxSkinWrapper.h
FbxPropertyWrapper.h
FbxMaterialWrapper.h
FbxTimeWrapper.h
FbxTimeSpanWrapper.h
FbxTypeConverter.h
FbxAxisSystemWrapper.h
FbxSystemUnitWrapper.h
FbxVertexColorWrapper.h
FbxVertexTangentWrapper.h
FbxVertexBitangentWrapper.h
FbxUVWrapper.h
FbxBlendShapeWrapper.h
FbxBlendShapeChannelWrapper.h
FbxLayerElementUtilities.h
Mocks/MockFbxAnimStackWrapper.h
Mocks/MockFbxAxisSystemWrapper.h
Mocks/MockFbxMaterialWrapper.h
Mocks/MockFbxMeshWrapper.h
Mocks/MockFbxNodeWrapper.h
Mocks/MockFbxPropertyWrapper.h
Mocks/MockFbxSceneWrapper.h
Mocks/MockFbxSkinWrapper.h
Mocks/MockFbxSystemUnitWrapper.h
Mocks/MockFbxTimeWrapper.h
Mocks/MockFbxUVWrapper.h
Mocks/MockFbxVertexColorWrapper.h
)

2
Code/Tools/SceneAPI/FbxSceneBuilder/CMakeLists.txt
Unescape Escape View File

@ -31,9 +31,9 @@ ly_add_target(
AZ::AzFramework
PUBLIC
AZ::AzToolsFramework
AZ::FbxSDKWrapper
AZ::SceneCore
AZ::SceneData
AZ::SDKWrapper
)
ly_add_target(

24
Code/Tools/SceneAPI/FbxSceneBuilder/DllMain.cpp
Unescape Escape View File

@ -31,18 +31,6 @@
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpBoneImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpAnimationImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpBlendShapeImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxAnimationImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxBlendShapeImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxBoneImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxColorStreamImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxTangentStreamImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxBitangentStreamImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxMaterialImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxMeshImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxSkinImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxSkinWeightsImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxTransformImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxUvMapImporter.h>
namespace AZ
{
@ -78,18 +66,6 @@ namespace AZ
g_componentDescriptors.push_back(FbxSceneBuilder::FbxImporter::CreateDescriptor());
// Node and attribute importers
g_componentDescriptors.push_back(FbxAnimationImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxBlendShapeImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxBoneImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxColorStreamImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxMaterialImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxMeshImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxSkinImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxSkinWeightsImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxTransformImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxUvMapImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxTangentStreamImporter::CreateDescriptor());
g_componentDescriptors.push_back(FbxBitangentStreamImporter::CreateDescriptor());
g_componentDescriptors.push_back(AssImpBitangentStreamImporter::CreateDescriptor());
g_componentDescriptors.push_back(AssImpColorStreamImporter::CreateDescriptor());
g_componentDescriptors.push_back(AssImpMaterialImporter::CreateDescriptor());

195
Code/Tools/SceneAPI/FbxSceneBuilder/FbxImporter.cpp
Unescape Escape View File

@ -20,13 +20,10 @@
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/FbxSceneBuilder/FbxImporter.h>
#include <SceneAPI/FbxSceneBuilder/ImportContexts/FbxImportContexts.h>
#include <SceneAPI/FbxSceneBuilder/ImportContexts/AssImpImportContexts.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpMaterialImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/ImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/RenamedNodesMap.h>
#include <SceneAPI/FbxSDKWrapper/FbxSceneWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxMeshWrapper.h>
#include <SceneAPI/SceneCore/Containers/Scene.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/SceneData/GraphData/TransformData.h>
@ -55,16 +52,7 @@ namespace AZ
FbxImporter::FbxImporter()
: m_sceneSystem(new FbxSceneSystem())
{
if (m_useAssetImporterSDK)
{
m_sceneWrapper = AZStd::make_unique<AssImpSDKWrapper::AssImpSceneWrapper>();
}
else
{
m_sceneWrapper = AZStd::make_unique<FbxSDKWrapper::FbxSceneWrapper>();
}
m_sceneWrapper = AZStd::make_unique<AssImpSDKWrapper::AssImpSceneWrapper>();
BindToCall(&FbxImporter::ImportProcessing);
}
@ -89,15 +77,13 @@ namespace AZ
typedef AZStd::function<bool(Containers::Scene & scene)> ConvertFunc;
ConvertFunc convertFunc;
m_sceneSystem->Set(m_sceneWrapper.get());
if (azrtti_istypeof<FbxSDKWrapper::FbxSceneWrapper>(m_sceneWrapper.get()))
{
convertFunc = AZStd::bind(&FbxImporter::ConvertFbxSceneContext, this, AZStd::placeholders::_1);
}
else
if (!azrtti_istypeof<AssImpSDKWrapper::AssImpSceneWrapper>(m_sceneWrapper.get()))
{
convertFunc = AZStd::bind(&FbxImporter::ConvertFbxScene, this, AZStd::placeholders::_1);
return Events::ProcessingResult::Failure;
}
convertFunc = AZStd::bind(&FbxImporter::ConvertFbxScene, this, AZStd::placeholders::_1);
if (convertFunc(context.GetScene()))
{
return Events::ProcessingResult::Success;
@ -108,175 +94,6 @@ namespace AZ
}
}
bool FbxImporter::ConvertFbxSceneContext(Containers::Scene& scene) const
{
std::shared_ptr<SDKNode::NodeWrapper> fbxRoot = m_sceneWrapper->GetRootNode();
if (!fbxRoot)
{
return false;
}
FbxSDKWrapper::FbxSceneWrapper* fbxSceneWrapper = azrtti_cast <FbxSDKWrapper::FbxSceneWrapper*>(m_sceneWrapper.get());
int sign = 0;
FbxSDKWrapper::FbxAxisSystemWrapper::UpVector upVector = fbxSceneWrapper->GetAxisSystem()->GetUpVector(sign);
AZ_Assert(sign != 0, "sign failed to populate which is a failure in GetUpVector");
if (upVector == FbxSDKWrapper::FbxAxisSystemWrapper::UpVector::Z)
{
if (sign > 0)
{
scene.SetOriginalSceneOrientation(Containers::Scene::SceneOrientation::ZUp);
}
else
{
scene.SetOriginalSceneOrientation(Containers::Scene::SceneOrientation::NegZUp);
AZ_Assert(false, "Negative Z Up scene orientation is not a currently supported orientation.");
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Negative Z Up scene orientation is not a currently supported orientation.");
}
}
else if (upVector == FbxSDKWrapper::FbxAxisSystemWrapper::UpVector::Y)
{
if (sign > 0)
{
scene.SetOriginalSceneOrientation(Containers::Scene::SceneOrientation::YUp);
}
else
{
scene.SetOriginalSceneOrientation(Containers::Scene::SceneOrientation::NegYUp);
AZ_Assert(false, "Negative Y Up scene orientation is not a currently supported orientation.");
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Negative Y Up scene orientation is not a currently supported orientation.");
}
}
else if (upVector == FbxSDKWrapper::FbxAxisSystemWrapper::UpVector::X)
{
if (sign > 0)
{
scene.SetOriginalSceneOrientation(Containers::Scene::SceneOrientation::XUp);
AZ_Assert(false, "Positive X Up scene orientation is not a currently supported orientation.");
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Positive X Up scene orientation is not a currently supported orientation.");
}
else
{
scene.SetOriginalSceneOrientation(Containers::Scene::SceneOrientation::NegXUp);
AZ_Assert(false, "Negative X Up scene orientation is not a currently supported orientation.");
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Negative X Up scene orientation is not a currently supported orientation.");
}
}
AZStd::queue<FbxSceneBuilder::QueueNode> nodes;
nodes.emplace(AZStd::move(fbxRoot), scene.GetGraph().GetRoot());
RenamedNodesMap nodeNameMap;
while (!nodes.empty())
{
FbxSceneBuilder::QueueNode& node = nodes.front();
AZ_Assert(node.m_node, "Empty fbx node queued");
if (!nodeNameMap.RegisterNode(node.m_node, scene.GetGraph(), node.m_parent))
{
AZ_TracePrintf(Utilities::ErrorWindow, "Failed to register fbx node in name table.");
continue;
}
AZStd::string nodeName = nodeNameMap.GetNodeName(node.m_node);
AZ_TraceContext("SceneAPI Node Name", nodeName);
Containers::SceneGraph::NodeIndex newNode = scene.GetGraph().AddChild(node.m_parent, nodeName.c_str());
AZ_Assert(newNode.IsValid(), "Failed to add node to scene graph");
if (!newNode.IsValid())
{
continue;
}
FbxNodeEncounteredContext sourceNodeEncountered(scene, newNode, *fbxSceneWrapper, *m_sceneSystem, nodeNameMap, *azrtti_cast<AZ::FbxSDKWrapper::FbxNodeWrapper*>(node.m_node.get()));
Events::ProcessingResultCombiner nodeResult;
nodeResult += Events::Process(sourceNodeEncountered);
// If no importer created data, we still create an empty node that may eventually contain a transform
if (sourceNodeEncountered.m_createdData.empty())
{
AZ_Assert(nodeResult.GetResult() != Events::ProcessingResult::Success,
"Importers returned success but no data was created");
AZStd::shared_ptr<DataTypes::IGraphObject> nullData(nullptr);
sourceNodeEncountered.m_createdData.emplace_back(nullData);
nodeResult += Events::ProcessingResult::Success;
}
// Create single node since only one piece of graph data was created
if (sourceNodeEncountered.m_createdData.size() == 1)
{
AZ_Assert(nodeResult.GetResult() != Events::ProcessingResult::Ignored,
"An importer created data, but did not return success");
if (nodeResult.GetResult() == Events::ProcessingResult::Failure)
{
AZ_TracePrintf(Utilities::ErrorWindow, "One or more importers failed to create data.");
}
SceneDataPopulatedContext dataProcessed(sourceNodeEncountered,
sourceNodeEncountered.m_createdData[0], nodeName.c_str());
Events::ProcessingResult result = AddDataNodeWithContexts(dataProcessed);
if (result != Events::ProcessingResult::Failure)
{
newNode = dataProcessed.m_currentGraphPosition;
}
}
// Create an empty parent node and place all data under it. The remaining
// tree will be built off of this as the logical parent
else
{
AZ_Assert(nodeResult.GetResult() != Events::ProcessingResult::Ignored,
"%i importers created data, but did not return success",
sourceNodeEncountered.m_createdData.size());
if (nodeResult.GetResult() == Events::ProcessingResult::Failure)
{
AZ_TracePrintf(Utilities::ErrorWindow, "One or more importers failed to create data.");
}
size_t offset = nodeName.length();
for (size_t i = 0; i < sourceNodeEncountered.m_createdData.size(); ++i)
{
nodeName += '_';
nodeName += AZStd::to_string(aznumeric_cast<AZ::u64>(i + 1));
Containers::SceneGraph::NodeIndex subNode =
scene.GetGraph().AddChild(newNode, nodeName.c_str());
AZ_Assert(subNode.IsValid(), "Failed to create new scene sub node");
SceneDataPopulatedContext dataProcessed(sourceNodeEncountered,
sourceNodeEncountered.m_createdData[i], nodeName);
dataProcessed.m_currentGraphPosition = subNode;
AddDataNodeWithContexts(dataProcessed);
// Remove the temporary extension again.
nodeName.erase(offset, nodeName.length() - offset);
}
}
AZ_Assert(nodeResult.GetResult() == Events::ProcessingResult::Success,
"No importers successfully added processed scene data.");
AZ_Assert(newNode != node.m_parent,
"Failed to update current graph position during data processing.");
int childCount = node.m_node->GetChildCount();
for (int i = 0; i < childCount; ++i)
{
std::shared_ptr<FbxSDKWrapper::FbxNodeWrapper> child = std::make_shared<FbxSDKWrapper::FbxNodeWrapper>(node.m_node->GetChild(i)->GetFbxNode());
if (child)
{
nodes.emplace(AZStd::move(child), newNode);
}
}
nodes.pop();
}
Events::ProcessingResult result = Events::Process<FinalizeSceneContext>(scene, *fbxSceneWrapper, *m_sceneSystem, nodeNameMap);
if (result == Events::ProcessingResult::Failure)
{
return false;
}
return true;
}
bool FbxImporter::ConvertFbxScene(Containers::Scene& scene) const
{
std::shared_ptr<SDKNode::NodeWrapper> fbxRoot = m_sceneWrapper->GetRootNode();

2
Code/Tools/SceneAPI/FbxSceneBuilder/FbxImporter.h
Unescape Escape View File

@ -45,13 +45,11 @@ namespace AZ
Events::ProcessingResult ImportProcessing(Events::ImportEventContext& context);
protected:
bool ConvertFbxSceneContext(Containers::Scene& scene) const;
bool ConvertFbxScene(Containers::Scene& scene) const;
void SanitizeNodeName(AZStd::string& nodeName) const;
AZStd::unique_ptr<SDKScene::SceneWrapperBase> m_sceneWrapper;
AZStd::shared_ptr<FbxSceneSystem> m_sceneSystem;
bool m_useAssetImporterSDK = true;
};
} // namespace FbxSceneBuilder
} // namespace SceneAPI

149
Code/Tools/SceneAPI/FbxSceneBuilder/FbxSceneSystem.cpp
Unescape Escape View File

@ -11,8 +11,8 @@
*/
#include <AzCore/Math/Vector3.h>
#include <SceneAPI/FbxSDKWrapper/FbxSceneWrapper.h>
#include <SceneAPI/FbxSceneBuilder/FbxSceneSystem.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/SDKWrapper/AssImpSceneWrapper.h>
#include <SceneAPI/SDKWrapper/AssImpTypeConverter.h>
#include <assimp/scene.h>
@ -33,103 +33,86 @@ namespace AZ
void FbxSceneSystem::Set(const SDKScene::SceneWrapperBase* fbxScene)
{
// Get unit conversion factor to meter.
if (azrtti_istypeof<FbxSDKWrapper::FbxSceneWrapper>(fbxScene))
if (!azrtti_istypeof<AssImpSDKWrapper::AssImpSceneWrapper>(fbxScene))
{
const FbxSDKWrapper::FbxSceneWrapper* fbxSDKScene = azrtti_cast <const FbxSDKWrapper::FbxSceneWrapper*>(fbxScene);
m_unitSizeInMeters = fbxSDKScene->GetSystemUnit()->GetConversionFactorTo(FbxSDKWrapper::FbxSystemUnitWrapper::m);
const FbxGlobalSettings& globalSettings = fbxSDKScene->GetFbxScene()->GetGlobalSettings();
m_originalUnitSizeInMeters = static_cast<float>(globalSettings.GetOriginalSystemUnit().GetConversionFactorTo(FbxSystemUnit::m));
int sign = 0;
FbxSDKWrapper::FbxAxisSystemWrapper::UpVector upVector = fbxSDKScene->GetAxisSystem()->GetUpVector(sign);
if (upVector != FbxSDKWrapper::FbxAxisSystemWrapper::Z && upVector != FbxSDKWrapper::FbxAxisSystemWrapper::Unknown)
{
m_adjustTransform.reset(new DataTypes::MatrixType(fbxSDKScene->GetAxisSystem()->CalculateConversionTransform(FbxSDKWrapper::FbxAxisSystemWrapper::Z)));
m_adjustTransformInverse.reset(new DataTypes::MatrixType(m_adjustTransform->GetInverseFull()));
}
return;
}
else if (azrtti_istypeof<AssImpSDKWrapper::AssImpSceneWrapper>(fbxScene))
{
const AssImpSDKWrapper::AssImpSceneWrapper* assImpScene = azrtti_cast<const AssImpSDKWrapper::AssImpSceneWrapper*>(fbxScene);
// If either meta data piece is not available, the default of 1 will be used.
assImpScene->GetAssImpScene()->mMetaData->Get("UnitScaleFactor", m_unitSizeInMeters);
assImpScene->GetAssImpScene()->mMetaData->Get("OriginalUnitScaleFactor", m_originalUnitSizeInMeters);
const AssImpSDKWrapper::AssImpSceneWrapper* assImpScene = azrtti_cast<const AssImpSDKWrapper::AssImpSceneWrapper*>(fbxScene);
/* Conversion factor for converting from centimeters to meters */
m_unitSizeInMeters = m_unitSizeInMeters *.01f;
// If either meta data piece is not available, the default of 1 will be used.
assImpScene->GetAssImpScene()->mMetaData->Get("UnitScaleFactor", m_unitSizeInMeters);
assImpScene->GetAssImpScene()->mMetaData->Get("OriginalUnitScaleFactor", m_originalUnitSizeInMeters);
AZStd::pair<AssImpSDKWrapper::AssImpSceneWrapper::AxisVector, int32_t> upAxisAndSign = assImpScene->GetUpVectorAndSign();
/* Conversion factor for converting from centimeters to meters */
m_unitSizeInMeters = m_unitSizeInMeters * .01f;
if (upAxisAndSign.second <= 0)
{
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Negative scene orientation is not a currently supported orientation.");
return;
}
AZStd::pair<AssImpSDKWrapper::AssImpSceneWrapper::AxisVector, int32_t> upAxisAndSign = assImpScene->GetUpVectorAndSign();
AZStd::pair<AssImpSDKWrapper::AssImpSceneWrapper::AxisVector, int32_t> frontAxisAndSign = assImpScene->GetFrontVectorAndSign();
if (upAxisAndSign.second <= 0)
{
AZ_TracePrintf(SceneAPI::Utilities::ErrorWindow, "Negative scene orientation is not a currently supported orientation.");
return;
}
AZStd::pair<AssImpSDKWrapper::AssImpSceneWrapper::AxisVector, int32_t> frontAxisAndSign = assImpScene->GetFrontVectorAndSign();
if (upAxisAndSign.first != AssImpSDKWrapper::AssImpSceneWrapper::AxisVector::Z &&
upAxisAndSign.first != AssImpSDKWrapper::AssImpSceneWrapper::AxisVector::Unknown)
if (upAxisAndSign.first != AssImpSDKWrapper::AssImpSceneWrapper::AxisVector::Z &&
upAxisAndSign.first != AssImpSDKWrapper::AssImpSceneWrapper::AxisVector::Unknown)
{
AZ::Matrix4x4 currentCoordMatrix = AZ::Matrix4x4::CreateIdentity();
//(UpVector = +Z, FrontVector = +Y, CoordSystem = -X(RightHanded))
AZ::Matrix4x4 targetCoordMatrix = AZ::Matrix4x4::CreateFromColumns(
AZ::Vector4(-1, 0, 0, 0),
AZ::Vector4(0, 0, 1, 0),
AZ::Vector4(0, 1, 0, 0),
AZ::Vector4(0, 0, 0, 1));
switch (upAxisAndSign.first)
{
AZ::Matrix4x4 currentCoordMatrix = AZ::Matrix4x4::CreateIdentity();
//(UpVector = +Z, FrontVector = +Y, CoordSystem = -X(RightHanded))
AZ::Matrix4x4 targetCoordMatrix = AZ::Matrix4x4::CreateFromColumns(
AZ::Vector4(-1, 0, 0, 0),
AZ::Vector4(0, 0, 1, 0),
AZ::Vector4(0, 1, 0, 0),
AZ::Vector4(0, 0, 0, 1));
switch (upAxisAndSign.first)
case AssImpSDKWrapper::AssImpSceneWrapper::AxisVector::X: {
if (frontAxisAndSign.second == 1)
{
currentCoordMatrix = AZ::Matrix4x4::CreateFromColumns(
AZ::Vector4(0, -1, 0, 0),
AZ::Vector4(1, 0, 0, 0),
AZ::Vector4(0, 0, 1, 0),
AZ::Vector4(0, 0, 0, 1));
}
else
{
case AssImpSDKWrapper::AssImpSceneWrapper::AxisVector::X:
currentCoordMatrix = AZ::Matrix4x4::CreateFromColumns(
AZ::Vector4(0, 1, 0, 0),
AZ::Vector4(1, 0, 0, 0),
AZ::Vector4(0, 0, -1, 0),
AZ::Vector4(0, 0, 0, 1));
}
}
break;
case AssImpSDKWrapper::AssImpSceneWrapper::AxisVector::Y: {
if (frontAxisAndSign.second == 1)
{
if (frontAxisAndSign.second == 1)
{
currentCoordMatrix = AZ::Matrix4x4::CreateFromColumns(
AZ::Vector4(0, -1, 0, 0),
AZ::Vector4(1, 0, 0, 0),
AZ::Vector4(0, 0, 1, 0),
AZ::Vector4(0, 0, 0, 1));
}
else
{
currentCoordMatrix = AZ::Matrix4x4::CreateFromColumns(
AZ::Vector4(0, 1, 0, 0),
AZ::Vector4(1, 0, 0, 0),
AZ::Vector4(0, 0, -1, 0),
AZ::Vector4(0, 0, 0, 1));
}
currentCoordMatrix = AZ::Matrix4x4::CreateFromColumns(
AZ::Vector4(1, 0, 0, 0),
AZ::Vector4(0, 1, 0, 0),
AZ::Vector4(0, 0, 1, 0),
AZ::Vector4(0, 0, 0, 1));
}
break;
case AssImpSDKWrapper::AssImpSceneWrapper::AxisVector::Y:
{
if (frontAxisAndSign.second == 1)
{
currentCoordMatrix = AZ::Matrix4x4::CreateFromColumns(
AZ::Vector4(1, 0, 0, 0),
AZ::Vector4(0, 1, 0, 0),
AZ::Vector4(0, 0, 1, 0),
AZ::Vector4(0, 0, 0, 1));
}
else
{
currentCoordMatrix = AZ::Matrix4x4::CreateFromColumns(
AZ::Vector4(-1, 0, 0, 0),
AZ::Vector4(0, 1, 0, 0),
AZ::Vector4(0, 0, -1, 0),
AZ::Vector4(0, 0, 0, 1));
}
}
break;
else
{
currentCoordMatrix = AZ::Matrix4x4::CreateFromColumns(
AZ::Vector4(-1, 0, 0, 0),
AZ::Vector4(0, 1, 0, 0),
AZ::Vector4(0, 0, -1, 0),
AZ::Vector4(0, 0, 0, 1));
}
AZ::Matrix4x4 inverse = currentCoordMatrix.GetInverseTransform();
AZ::Matrix4x4 adjustmatrix = targetCoordMatrix * currentCoordMatrix.GetInverseTransform();
m_adjustTransform.reset(new DataTypes::MatrixType(AssImpSDKWrapper::AssImpTypeConverter::ToTransform(adjustmatrix)));
m_adjustTransformInverse.reset(new DataTypes::MatrixType(m_adjustTransform->GetInverseFull()));
}
break;
}
AZ::Matrix4x4 inverse = currentCoordMatrix.GetInverseTransform();
AZ::Matrix4x4 adjustmatrix = targetCoordMatrix * currentCoordMatrix.GetInverseTransform();
m_adjustTransform.reset(new DataTypes::MatrixType(AssImpSDKWrapper::AssImpTypeConverter::ToTransform(adjustmatrix)));
m_adjustTransformInverse.reset(new DataTypes::MatrixType(m_adjustTransform->GetInverseFull()));
}
}

115
Code/Tools/SceneAPI/FbxSceneBuilder/ImportContexts/FbxImportContexts.cpp
Unescape Escape View File

@ -1,115 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <SceneAPI/FbxSceneBuilder/ImportContexts/FbxImportContexts.h>
#include <SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h>
#include <SceneAPI/SceneCore/Events/ImportEventContext.h>
namespace AZ
{
namespace SceneAPI
{
namespace FbxSceneBuilder
{
FbxImportContext::FbxImportContext(const FbxSDKWrapper::FbxSceneWrapper& sourceScene,
const FbxSceneSystem& sourceSceneSystem, FbxSDKWrapper::FbxNodeWrapper& sourceNode)
: m_sourceScene(sourceScene)
, m_sourceSceneSystem(sourceSceneSystem)
, m_sourceNode(sourceNode)
{
}
FbxNodeEncounteredContext::FbxNodeEncounteredContext(Containers::Scene& scene,
Containers::SceneGraph::NodeIndex currentGraphPosition, const FbxSDKWrapper::FbxSceneWrapper& sourceScene,
const FbxSceneSystem& sourceSceneSystem, RenamedNodesMap& nodeNameMap, FbxSDKWrapper::FbxNodeWrapper& sourceNode)
: FbxImportContext(sourceScene, sourceSceneSystem, sourceNode)
, NodeEncounteredContext(scene, currentGraphPosition, nodeNameMap)
{
}
FbxNodeEncounteredContext::FbxNodeEncounteredContext(
Events::ImportEventContext& parent, Containers::SceneGraph::NodeIndex currentGraphPosition,
const FbxSDKWrapper::FbxSceneWrapper& sourceScene, const FbxSceneSystem& sourceSceneSystem,
RenamedNodesMap& nodeNameMap, FbxSDKWrapper::FbxNodeWrapper& sourceNode)
: FbxImportContext(sourceScene, sourceSceneSystem, sourceNode)
, NodeEncounteredContext(parent.GetScene(), currentGraphPosition, nodeNameMap)
{
}
SceneDataPopulatedContext::SceneDataPopulatedContext(FbxNodeEncounteredContext& parent,
const AZStd::shared_ptr<DataTypes::IGraphObject>& graphData, const AZStd::string& dataName)
: FbxImportContext(parent.m_sourceScene, parent.m_sourceSceneSystem, parent.m_sourceNode)
, SceneDataPopulatedContextBase(parent, graphData, dataName)
{
}
SceneDataPopulatedContext::SceneDataPopulatedContext(Containers::Scene& scene,
Containers::SceneGraph::NodeIndex currentGraphPosition, const FbxSDKWrapper::FbxSceneWrapper& sourceScene,
const FbxSceneSystem& sourceSceneSystem, RenamedNodesMap& nodeNameMap, FbxSDKWrapper::FbxNodeWrapper& sourceNode,
const AZStd::shared_ptr<DataTypes::IGraphObject>& nodeData, const AZStd::string& dataName)
: FbxImportContext(sourceScene, sourceSceneSystem, sourceNode)
, SceneDataPopulatedContextBase(scene, currentGraphPosition, nodeNameMap, nodeData, dataName)
{
}
SceneNodeAppendedContext::SceneNodeAppendedContext(SceneDataPopulatedContext& parent,
Containers::SceneGraph::NodeIndex newIndex)
: FbxImportContext(parent.m_sourceScene, parent.m_sourceSceneSystem, parent.m_sourceNode)
, SceneNodeAppendedContextBase(parent.m_scene, newIndex, parent.m_nodeNameMap)
{
}
SceneNodeAppendedContext::SceneNodeAppendedContext(Containers::Scene& scene,
Containers::SceneGraph::NodeIndex currentGraphPosition, const FbxSDKWrapper::FbxSceneWrapper& sourceScene,
const FbxSceneSystem& sourceSceneSystem, RenamedNodesMap& nodeNameMap, FbxSDKWrapper::FbxNodeWrapper& sourceNode)
: FbxImportContext(sourceScene, sourceSceneSystem, sourceNode)
, SceneNodeAppendedContextBase(scene, currentGraphPosition, nodeNameMap)
{
}
SceneAttributeDataPopulatedContext::SceneAttributeDataPopulatedContext(SceneNodeAppendedContext& parent,
const AZStd::shared_ptr<DataTypes::IGraphObject>& nodeData,
const Containers::SceneGraph::NodeIndex attributeNodeIndex, const AZStd::string& dataName)
: FbxImportContext(parent.m_sourceScene, parent.m_sourceSceneSystem, parent.m_sourceNode)
, SceneAttributeDataPopulatedContextBase(parent, nodeData, attributeNodeIndex, dataName)
{
}
SceneAttributeNodeAppendedContext::SceneAttributeNodeAppendedContext(
SceneAttributeDataPopulatedContext& parent, Containers::SceneGraph::NodeIndex newIndex)
: FbxImportContext(parent.m_sourceScene, parent.m_sourceSceneSystem, parent.m_sourceNode)
, SceneAttributeNodeAppendedContextBase(parent, newIndex)
{
}
SceneNodeAddedAttributesContext::SceneNodeAddedAttributesContext(SceneNodeAppendedContext& parent)
: FbxImportContext(parent.m_sourceScene, parent.m_sourceSceneSystem, parent.m_sourceNode)
, SceneNodeAddedAttributesContextBase(parent)
{
}
SceneNodeFinalizeContext::SceneNodeFinalizeContext(SceneNodeAddedAttributesContext& parent)
: FbxImportContext(parent.m_sourceScene, parent.m_sourceSceneSystem, parent.m_sourceNode)
, SceneNodeFinalizeContextBase(parent)
{
}
FinalizeSceneContext::FinalizeSceneContext(Containers::Scene& scene, const FbxSDKWrapper::FbxSceneWrapper& sourceScene,
const FbxSceneSystem& sourceSceneSystem, RenamedNodesMap& nodeNameMap)
: FinalizeSceneContextBase(scene, nodeNameMap)
, m_sourceScene(sourceScene)
, m_sourceSceneSystem(sourceSceneSystem)
{
}
} // namespace SceneAPI
} // namespace FbxSceneBuilder
} // namespace AZ

184
Code/Tools/SceneAPI/FbxSceneBuilder/ImportContexts/FbxImportContexts.h
Unescape Escape View File

@ -1,184 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <AzCore/RTTI/RTTI.h>
#include <AzCore/std/string/string.h>
#include <SceneAPI/FbxSceneBuilder/ImportContexts/ImportContexts.h>
#include <SceneAPI/SceneCore/Containers/SceneGraph.h>
namespace AZ
{
namespace FbxSDKWrapper
{
class FbxSceneWrapper;
class FbxNodeWrapper;
}
namespace SceneAPI
{
class FbxSceneSystem;
namespace FbxSceneBuilder
{
class RenamedNodesMap;
// FbxImportContext
// Base structure containing common data needed for all import contexts
// Member Variables:
// m_sourceScene - Basic scene data extracted from the FBX Scene. Used to
// transform data.
// m_sourceNode - FBX node being used for data processing.
struct FbxImportContext
{
AZ_RTTI(FbxImportContext, "{C8D665D5-E871-41AD-90E7-C84CF6842BCF}");
FbxImportContext(const FbxSDKWrapper::FbxSceneWrapper& sourceScene, const FbxSceneSystem& sourceSceneSystem,
FbxSDKWrapper::FbxNodeWrapper& sourceNode);
const FbxSDKWrapper::FbxSceneWrapper& m_sourceScene;
const FbxSceneSystem& m_sourceSceneSystem; // Needed for unit and axis conversion
FbxSDKWrapper::FbxNodeWrapper& m_sourceNode;
};
// FbxNodeEncounteredContext
// Context pushed to indicate that a new FBX Node has been found and any
// importers that have means to process the contained data should do so
// Member Variables:
// m_createdData - out container that importers must add their created data
// to.
struct FbxNodeEncounteredContext
: public FbxImportContext
, public NodeEncounteredContext
{
AZ_RTTI(FbxNodeEncounteredContext, "{BE21E324-6745-41FD-A79C-A6CA7AB15A7A}", FbxImportContext, NodeEncounteredContext);
FbxNodeEncounteredContext(Containers::Scene& scene,
Containers::SceneGraph::NodeIndex currentGraphPosition, const FbxSDKWrapper::FbxSceneWrapper& sourceScene,
const FbxSceneSystem& sourceSceneSystem, RenamedNodesMap& nodeNameMap, FbxSDKWrapper::FbxNodeWrapper& sourceNode);
FbxNodeEncounteredContext(Events::ImportEventContext& parent,
Containers::SceneGraph::NodeIndex currentGraphPosition, const FbxSDKWrapper::FbxSceneWrapper& sourceScene,
const FbxSceneSystem& sourceSceneSystem, RenamedNodesMap& nodeNameMap, FbxSDKWrapper::FbxNodeWrapper& sourceNode);
};
// SceneDataPopulatedContext
// Context pushed to indicate that a piece of scene data has been fully
// processed and any importers that wish to place it within the scene graph
// may now do so. This may be triggered by processing a FbxNodeEncounteredContext
// (for base data, e.g. bones, meshes) or from a SceneNodeAppendedContext
// (for attribute data, e.g. UV Maps, materials)
// Member Variables:
// m_graphData - the piece of data that should be inserted in the graph
// m_dataName - the name that should be used as the basis for the scene node
// name
// m_isAttribute - Indicates whether the graph data is an attribute
struct SceneDataPopulatedContext
: public FbxImportContext
, public SceneDataPopulatedContextBase
{
AZ_RTTI(SceneDataPopulatedContext, "{DF17306C-FE28-4BEB-9CF0-88CF0472B8A8}", FbxImportContext, SceneDataPopulatedContextBase);
SceneDataPopulatedContext(FbxNodeEncounteredContext& parent,
const AZStd::shared_ptr<DataTypes::IGraphObject>& nodeData,
const AZStd::string& dataName);
SceneDataPopulatedContext(Containers::Scene& scene,
Containers::SceneGraph::NodeIndex currentGraphPosition, const FbxSDKWrapper::FbxSceneWrapper& sourceScene,
const FbxSceneSystem& sourceSceneSystem, RenamedNodesMap& nodeNameMap, FbxSDKWrapper::FbxNodeWrapper& sourceNode,
const AZStd::shared_ptr<DataTypes::IGraphObject>& nodeData, const AZStd::string& dataName);
};
// SceneNodeAppendedContext
// Context pushed to indicate that data has been added to the scene graph.
// Generally created due to the insertion of a node during SceneDataPopulatedContext
// processing.
struct SceneNodeAppendedContext
: public FbxImportContext
, public SceneNodeAppendedContextBase
{
AZ_RTTI(SceneNodeAppendedContext, "{72C1C37A-C6ED-4CB7-B929-DA03AA44131C}", FbxImportContext, SceneNodeAppendedContextBase);
SceneNodeAppendedContext(SceneDataPopulatedContext& parent, Containers::SceneGraph::NodeIndex newIndex);
SceneNodeAppendedContext(Containers::Scene& scene,
Containers::SceneGraph::NodeIndex currentGraphPosition, const FbxSDKWrapper::FbxSceneWrapper& sourceScene,
const FbxSceneSystem& sourceSceneSystem, RenamedNodesMap& nodeNameMap, FbxSDKWrapper::FbxNodeWrapper& sourceNode);
};
// SceneAttributeDataPopulatedContext
// Context pushed to indicate that attribute data has been found and processed
struct SceneAttributeDataPopulatedContext
: public FbxImportContext
, public SceneAttributeDataPopulatedContextBase
{
AZ_RTTI(SceneAttributeDataPopulatedContext, "{93E67C26-5A40-4385-8189-947A626E3CDA}", FbxImportContext, SceneAttributeDataPopulatedContextBase);
SceneAttributeDataPopulatedContext(SceneNodeAppendedContext& parent,
const AZStd::shared_ptr<DataTypes::IGraphObject>& nodeData,
const Containers::SceneGraph::NodeIndex attributeNodeIndex, const AZStd::string& dataName);
};
// SceneAttributeNodeAppendedContext
// Context pushed to indicate that an attribute node has been added to the scene graph
struct SceneAttributeNodeAppendedContext
: public FbxImportContext
, public SceneAttributeNodeAppendedContextBase
{
AZ_RTTI(SceneAttributeNodeAppendedContext, "{C0DD4F39-5C61-4CA0-96C5-9EA3AC40D98B}", FbxImportContext, SceneAttributeNodeAppendedContextBase);
SceneAttributeNodeAppendedContext(SceneAttributeDataPopulatedContext& parent,
Containers::SceneGraph::NodeIndex newIndex);
};
// SceneNodeAddedAttributesContext
// Context pushed to indicate that all attribute processors have completed their
// work for a specific data node.
struct SceneNodeAddedAttributesContext
: public FbxImportContext
, public SceneNodeAddedAttributesContextBase
{
AZ_RTTI(SceneNodeAddedAttributesContext, "{1601900C-5109-4D37-83F1-22317A4D7C78}", FbxImportContext, SceneNodeAddedAttributesContextBase);
SceneNodeAddedAttributesContext(SceneNodeAppendedContext& parent);
};
// SceneNodeFinalizeContext
// Context pushed last after all other contexts for a scene node to allow any
// post-processing needed for an importer.
struct SceneNodeFinalizeContext
: public FbxImportContext
, public SceneNodeFinalizeContextBase
{
AZ_RTTI(SceneNodeFinalizeContext, "{D1D9839A-EA48-425D-BB7A-A9AEA65B8B7A}", FbxImportContext, SceneNodeFinalizeContextBase);
SceneNodeFinalizeContext(SceneNodeAddedAttributesContext& parent);
};
// FinalizeSceneContext
// Context pushed after the scene has been fully created. This can be used to finalize pending work
// such as resolving named links.
struct FinalizeSceneContext
: public FinalizeSceneContextBase
{
AZ_RTTI(FinalizeSceneContext, "{C8D665D5-E871-41AD-90E7-C84CF6842BCF}", FinalizeSceneContextBase);
FinalizeSceneContext(Containers::Scene& scene, const FbxSDKWrapper::FbxSceneWrapper& sourceScene,
const FbxSceneSystem& sourceSceneSystem, RenamedNodesMap& nodeNameMap);
const FbxSDKWrapper::FbxSceneWrapper& m_sourceScene;
const FbxSceneSystem& m_sourceSceneSystem; // Needed for unit and axis conversion
};
} // namespace FbxSceneBuilder
} // namespace SceneAPI
} // namespace AZ

5
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpAnimationImporter.cpp
Unescape Escape View File

@ -22,11 +22,6 @@
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpAnimationImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/RenamedNodesMap.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimCurveWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimLayerWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxSceneWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeSpanWrapper.h>
#include <SceneAPI/SceneCore/Containers/Scene.h>
#include <SceneAPI/SceneData/GraphData/AnimationData.h>
#include <SceneAPI/SDKWrapper/AssImpNodeWrapper.h>

2
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpAnimationImporter.h
Unescape Escape View File

@ -12,8 +12,6 @@
#pragma once
#include <SceneAPI/FbxSceneBuilder/ImportContexts/FbxImportContexts.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h>
#include <SceneAPI/SceneCore/Components/LoadingComponent.h>
#include <SceneAPI/FbxSceneBuilder/ImportContexts/AssImpImportContexts.h>

3
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpBitangentStreamImporter.cpp
Unescape Escape View File

@ -14,13 +14,14 @@
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpBitangentStreamImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/ImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/AssImpMeshImporterUtilities.h>
#include <SceneAPI/SceneData/GraphData/MeshVertexBitangentData.h>
#include <SceneAPI/SDKWrapper/AssImpNodeWrapper.h>
#include <SceneAPI/SDKWrapper/AssImpSceneWrapper.h>
#include <SceneAPI/SDKWrapper/AssImpTypeConverter.h>
#include <SceneAPI/SceneData/GraphData/MeshData.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <assimp/scene.h>
#include <assimp/mesh.h>

2
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpBlendShapeImporter.cpp
Unescape Escape View File

@ -17,7 +17,7 @@
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpBlendShapeImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/AssImpMeshImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/RenamedNodesMap.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/ImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/FbxSceneSystem.h>
#include <SceneAPI/SDKWrapper/AssImpNodeWrapper.h>
#include <SceneAPI/SDKWrapper/AssImpSceneWrapper.h>

3
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpBoneImporter.cpp
Unescape Escape View File

@ -17,8 +17,7 @@
#include <SceneAPI/FbxSceneBuilder/FbxSceneSystem.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpBoneImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h>
#include <SceneAPI/FbxSceneBuilder/Importers/ImporterUtilities.h>
#include <SceneAPI/SceneCore/Containers/Scene.h>
#include <SceneAPI/SceneData/GraphData/BoneData.h>
#include <SceneAPI/SceneData/GraphData/RootBoneData.h>

3
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpColorStreamImporter.cpp
Unescape Escape View File

@ -14,13 +14,14 @@
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpColorStreamImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/ImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/AssImpMeshImporterUtilities.h>
#include <SceneAPI/SDKWrapper/AssImpNodeWrapper.h>
#include <SceneAPI/SDKWrapper/AssImpSceneWrapper.h>
#include <SceneAPI/SDKWrapper/AssImpTypeConverter.h>
#include <SceneAPI/SceneData/GraphData/MeshData.h>
#include <SceneAPI/SceneData/GraphData/MeshVertexColorData.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <assimp/scene.h>
#include <assimp/mesh.h>

2
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpMaterialImporter.cpp
Unescape Escape View File

@ -17,7 +17,7 @@
#include <AzCore/std/containers/unordered_map.h>
#include <AzCore/StringFunc/StringFunc.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/ImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/AssImpMeshImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/RenamedNodesMap.h>
#include <SceneAPI/SDKWrapper/AssImpNodeWrapper.h>

2
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpSkinWeightsImporter.cpp
Unescape Escape View File

@ -15,7 +15,7 @@
#include <AzCore/std/string/conversions.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpSkinWeightsImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/ImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/AssImpMeshImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/RenamedNodesMap.h>
#include <SceneAPI/SceneCore/Events/ImportEventContext.h>

3
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpTangentStreamImporter.cpp
Unescape Escape View File

@ -14,13 +14,14 @@
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpTangentStreamImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/ImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/AssImpMeshImporterUtilities.h>
#include <SceneAPI/SceneData/GraphData/MeshVertexTangentData.h>
#include <SceneAPI/SDKWrapper/AssImpNodeWrapper.h>
#include <SceneAPI/SDKWrapper/AssImpSceneWrapper.h>
#include <SceneAPI/SDKWrapper/AssImpTypeConverter.h>
#include <SceneAPI/SceneData/GraphData/MeshData.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <assimp/scene.h>
#include <assimp/mesh.h>

2
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpTransformImporter.cpp
Unescape Escape View File

@ -15,7 +15,7 @@
#include <AzCore/Serialization/SerializeContext.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/FbxSceneBuilder/FbxSceneSystem.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/ImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/RenamedNodesMap.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/SceneData/GraphData/TransformData.h>

3
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpUvMapImporter.cpp
Unescape Escape View File

@ -16,12 +16,13 @@
#include <AzToolsFramework/Debug/TraceContext.h>
#include <SceneAPI/FbxSceneBuilder/ImportContexts/AssImpImportContexts.h>
#include <SceneAPI/FbxSceneBuilder/Importers/AssImpUvMapImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/ImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/AssImpMeshImporterUtilities.h>
#include <SceneAPI/SDKWrapper/AssImpNodeWrapper.h>
#include <SceneAPI/SDKWrapper/AssImpSceneWrapper.h>
#include <SceneAPI/SceneData/GraphData/MeshData.h>
#include <SceneAPI/SceneData/GraphData/MeshVertexUVData.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <assimp/scene.h>
#include <assimp/mesh.h>

215
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/FbxAnimationImporter.cpp
Unescape Escape View File

@ -1,215 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzCore/Serialization/SerializeContext.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <SceneAPI/FbxSceneBuilder/FbxSceneSystem.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxAnimationImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxImporterUtilities.h>
#include <SceneAPI/FbxSceneBuilder/Importers/FbxTransformImporter.h>
#include <SceneAPI/FbxSceneBuilder/Importers/Utilities/RenamedNodesMap.h>
#include <SceneAPI/FbxSDKWrapper/FbxNodeWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxSceneWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeSpanWrapper.h>
#include <SceneAPI/SceneCore/Containers/Scene.h>
#include <SceneAPI/SceneCore/Utilities/Reporting.h>
#include <SceneAPI/SceneData/GraphData/BoneData.h>
#include <SceneAPI/SceneData/GraphData/AnimationData.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimLayerWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimCurveNodeWrapper.h>
#include <SceneAPI/FbxSDKWrapper/FbxAnimCurveWrapper.h>
namespace AZ
{
namespace SceneAPI
{
namespace FbxSceneBuilder
{
const char* FbxAnimationImporter::s_animationNodeName = "animation";
const FbxSDKWrapper::FbxTimeWrapper::TimeMode FbxAnimationImporter::s_defaultTimeMode =
FbxSDKWrapper::FbxTimeWrapper::frames30;
FbxAnimationImporter::FbxAnimationImporter()
{
BindToCall(&FbxAnimationImporter::ImportAnimation);
}
void FbxAnimationImporter::Reflect(ReflectContext* context)
{
SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context);
if (serializeContext)
{
serializeContext->Class<FbxAnimationImporter, SceneCore::LoadingComponent>()->Version(1);
}
}
Events::ProcessingResult FbxAnimationImporter::ImportAnimation(SceneNodeAppendedContext& context)
{
AZ_TraceContext("Importer", "Animation");
// Add check for animation layers at the scene level.
if (context.m_sourceScene.GetAnimationStackCount() <= 0)
{
return Events::ProcessingResult::Ignored;
}
if (context.m_sourceNode.IsMesh())
{
return ImportBlendShapeAnimation(context);
}
if (!context.m_sourceNode.IsBone())
{
return Events::ProcessingResult::Ignored;
}
AZStd::string nodeName = s_animationNodeName;
RenamedNodesMap::SanitizeNodeName(nodeName, context.m_scene.GetGraph(), context.m_currentGraphPosition);
AZ_TraceContext("Animation node name", nodeName);
auto animStackWrapper = context.m_sourceScene.GetAnimationStackAt(0);
const FbxSDKWrapper::FbxTimeWrapper startTime = animStackWrapper->GetLocalTimeSpan().GetStartTime();
const double frameRate = startTime.GetFrameRate();
if (frameRate == 0.0)
{
AZ_TracePrintf(Utilities::ErrorWindow, "Scene has a 0 framerate. Animation cannot be processed without timing information.");
return Events::ProcessingResult::Failure;
}
const int64_t startFrame = startTime.GetFrameCount();
const int64_t numFrames = animStackWrapper->GetLocalTimeSpan().GetNumFrames();
AZStd::shared_ptr<SceneData::GraphData::AnimationData> createdAnimationData =
AZStd::make_shared<SceneData::GraphData::AnimationData>();
createdAnimationData->ReserveKeyFrames(numFrames);
createdAnimationData->SetTimeStepBetweenFrames(1.0 / frameRate);
{
FbxSDKWrapper::FbxTimeWrapper currTime = startTime;
for (int64_t currFrame = startFrame; currFrame < startFrame + numFrames; currFrame++)
{
currTime.SetFrame(currFrame);
SceneAPI::DataTypes::MatrixType animTransform = context.m_sourceNode.EvaluateLocalTransform(currTime);
context.m_sourceSceneSystem.SwapTransformForUpAxis(animTransform);
context.m_sourceSceneSystem.ConvertBoneUnit(animTransform);
createdAnimationData->AddKeyFrame(animTransform);
}
AZ_Assert(createdAnimationData->GetKeyFrameCount() == numFrames, "The imported animation data created does not have the same number of keyframes as the FBX data.");
}
Containers::SceneGraph::NodeIndex addNode = context.m_scene.GetGraph().AddChild(
context.m_currentGraphPosition, nodeName.c_str(), AZStd::move(createdAnimationData));
context.m_scene.GetGraph().MakeEndPoint(addNode);
return Events::ProcessingResult::Success;
}
Events::ProcessingResult FbxAnimationImporter::ImportBlendShapeAnimation(SceneNodeAppendedContext& context)
{
FbxNode * node = context.m_sourceNode.GetFbxNode();
FbxMesh * pMesh = node->GetMesh();
if (!pMesh)
{
return Events::ProcessingResult::Ignored;
}
int deformerCount = pMesh->GetDeformerCount(FbxDeformer::eBlendShape);
int blendShapeIndex = -1;
AZStd::string nodeName;
AZStd::string animNodeName;
for (int deformerIndex = 0; deformerIndex < deformerCount; ++deformerIndex)
{
//we are assuming 1 anim stack (single animation clip export)
const FbxBlendShape* pDeformer = (FbxBlendShape*)pMesh->GetDeformer(deformerIndex, FbxDeformer::eBlendShape);
if (!pDeformer)
{
continue;
}
blendShapeIndex++;
int blendShapeChannelCount = pDeformer->GetBlendShapeChannelCount();
auto animStackWrapper = context.m_sourceScene.GetAnimationStackAt(0);
const FbxSDKWrapper::FbxTimeWrapper startTime = animStackWrapper->GetLocalTimeSpan().GetStartTime();
const double frameRate = startTime.GetFrameRate();
if (frameRate == 0.0)
{
AZ_TracePrintf("Animation_Warning", "Scene has a 0 framerate. Animation cannot be processed without timing information.");
return Events::ProcessingResult::Failure;
}
const int64_t startFrame = startTime.GetFrameCount();
const int64_t numFrames = animStackWrapper->GetLocalTimeSpan().GetNumFrames();
const int layerCount = animStackWrapper->GetAnimationLayerCount();
for (int blendShapeChannelIdx = 0; blendShapeChannelIdx < blendShapeChannelCount; ++blendShapeChannelIdx)
{
const FbxBlendShapeChannel* pChannel = pDeformer->GetBlendShapeChannel(blendShapeChannelIdx);
if (!pChannel)
{
continue;
}
for (int layerIndex = 0; layerIndex < layerCount; layerIndex++)
{
FbxAnimLayer* animationLayer = animStackWrapper->GetAnimationLayerAt(layerIndex)->GetFbxLayer();
FbxAnimCurve* animCurve = pMesh->GetShapeChannel(blendShapeIndex, blendShapeChannelIdx, animationLayer);
if (!animCurve)
{
continue;
}
AZStd::shared_ptr<FbxSDKWrapper::FbxAnimCurveWrapper> animCurveWrapper = AZStd::make_shared<FbxSDKWrapper::FbxAnimCurveWrapper>(animCurve);
AZStd::shared_ptr<SceneData::GraphData::BlendShapeAnimationData> createdAnimationData =
AZStd::make_shared<SceneData::GraphData::BlendShapeAnimationData>();
createdAnimationData->ReserveKeyFrames(numFrames);
createdAnimationData->SetTimeStepBetweenFrames(1.0 / frameRate);
{
FbxSDKWrapper::FbxTimeWrapper currTime = startTime;
for (int64_t currFrame = startFrame; currFrame < startFrame + numFrames; currFrame++)
{
currTime.SetFrame(currFrame);
//weight values from FBX are range 0 - 100
float sampleValue = animCurveWrapper->Evaluate(currTime) / 100.0f;
createdAnimationData->AddKeyFrame(sampleValue);
}
AZ_Assert(createdAnimationData->GetKeyFrameCount() == numFrames, "Imported animation blend data does not contain the same number of keyframes as the source FBX data.")
}
nodeName = pChannel->GetName();
const size_t dotIndex = nodeName.find_last_of('.');
nodeName = nodeName.substr(dotIndex + 1);
createdAnimationData->SetBlendShapeName(nodeName.c_str());
animNodeName = AZStd::string::format("%s_%s", s_animationNodeName, nodeName.c_str());
Containers::SceneGraph::NodeIndex addNode = context.m_scene.GetGraph().AddChild(
context.m_currentGraphPosition, animNodeName.c_str(), AZStd::move(createdAnimationData));
context.m_scene.GetGraph().MakeEndPoint(addNode);
}
}
}
return Events::ProcessingResult::Success;
}
} // namespace FbxSceneBuilder
} // namespace SceneAPI
} // namespace AZ

46
Code/Tools/SceneAPI/FbxSceneBuilder/Importers/FbxAnimationImporter.h
Unescape Escape View File

@ -1,46 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <fbxsdk.h>
#include <SceneAPI/FbxSceneBuilder/ImportContexts/FbxImportContexts.h>
#include <SceneAPI/FbxSDKWrapper/FbxTimeWrapper.h>
#include <SceneAPI/SceneCore/Components/LoadingComponent.h>
namespace AZ
{
namespace SceneAPI
{
namespace FbxSceneBuilder
{
class FbxAnimationImporter
: public SceneCore::LoadingComponent
{
public:
AZ_COMPONENT(FbxAnimationImporter, "{26ABDA62-9DB7-4B4D-961D-44B5F5F56808}", SceneCore::LoadingComponent);
FbxAnimationImporter();
~FbxAnimationImporter() override = default;
static void Reflect(ReflectContext* context);
Events::ProcessingResult ImportAnimation(SceneNodeAppendedContext& context);
Events::ProcessingResult ImportBlendShapeAnimation(SceneNodeAppendedContext& context);
protected:
static const char* s_animationNodeName;
static const FbxSDKWrapper::FbxTimeWrapper::TimeMode s_defaultTimeMode;
};
} // namespace FbxSceneBuilder
} // namespace SceneAPI
} // namespace AZ

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

Write Preview
Loading…
Cancel
Save