Removing ArtistTools and CurveEditor projects

4 files changed, 0 insertions, 1728 deletions

diff --git a/tools/ArtistTools/source/CoreLib/Anim/AnimUtil.cpp b/tools/ArtistTools/source/CoreLib/Anim/AnimUtil.cpp
deleted file mode 100644
index f070f42..0000000
--- a/tools/ArtistTools/source/CoreLib/Anim/AnimUtil.cpp
+++ /dev/null
@@ -1,417 +0,0 @@
-// This code contains NVIDIA Confidential Information and is disclosed 
-// under the Mutual Non-Disclosure Agreement. 
-// 
-// Notice 
-// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES 
-// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO 
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT, 
-// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. 
-// 
-// NVIDIA Corporation assumes no responsibility for the consequences of use of such 
-// information or for any infringement of patents or other rights of third parties that may 
-// result from its use. No license is granted by implication or otherwise under any patent 
-// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless 
-// expressly authorized by NVIDIA.  Details are subject to change without notice. 
-// This code supersedes and replaces all information previously supplied. 
-// NVIDIA Corporation products are not authorized for use as critical 
-// components in life support devices or systems without express written approval of 
-// NVIDIA Corporation. 
-// 
-// Copyright (c) 2013 NVIDIA Corporation. All rights reserved.
-//
-// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
-// rights in and to this software and related documentation and any modifications thereto.
-// Any use, reproduction, disclosure or distribution of this software and related
-// documentation without an express license agreement from NVIDIA Corporation is
-// strictly prohibited.
-//
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// This file contains wrapper functions to make hair lib easy to setup and use
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#include <vector>
-#include <string>
-
-#include "AnimUtil.h"
-#include "MathUtil.h"
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AnimationCache::~AnimationCache()
-{
-	Release();
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AnimationCache::Initialize(int numBones, NvInt32 frameStart, NvInt32 frameEnd)
-{
-	m_numBones = numBones;
-	m_frameStart = frameStart;
-	m_frameEnd = frameEnd;
-
-	m_numFrames = frameEnd - frameStart + 1;
-
-	Release();
-	Allocate();
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AnimationCache::Allocate()
-{
-	m_pBoneMatrices = new atcore_float4x4[m_numFrames * m_numBones];
-	m_pBoneNames	= new char[NV_HAIR_MAX_STRING * m_numBones];
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AnimationCache::Release()
-{
-	if (m_pBoneMatrices)
-		delete []m_pBoneMatrices;
-
-	if (m_pBoneNames)
-		delete []m_pBoneNames;
-
-	m_pBoneMatrices = 0;
-	m_pBoneNames = 0;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AnimationCache::GetInterpolationInfo(float frame, int& indexStart, int& indexEnd, float &fracFrame)
-{
-	if (frame < m_frameStart)
-		return false;
-
-	if (frame > m_frameEnd)
-		return false;
-
-	int startFrame = (int)frame;
-	
-	fracFrame = frame - startFrame;
-
-	indexStart = (int)(frame - m_frameStart);
-	indexEnd = indexStart + 1;
-
-	if (indexEnd >= (int)m_numFrames)
-	{
-		indexEnd = indexStart;
-		fracFrame = 0.0f;
-	}
-
-	return true;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-int AnimationCache::FindBone(const char *toFind) const
-{
-	if (!toFind)
-		return -1;
-	for (int i = 0; i < m_numBones; i++)
-	{
-		const char* boneName = GetBoneName(i);
-		if (!strcmp(boneName, toFind))
-			return i;
-	}
-	return -1;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AnimationCache::FindBoneMapping( int numBones, const NvChar* boneNames, int* mappedBoneId) const
-{
-	// mappedBoneId must be pre-allocated
-
-	for (int i = 0; i < numBones; i++)
-	{
-		mappedBoneId[i] = FindBone(boneNames + i * NV_HAIR_MAX_STRING);
-	}
-
-	return true;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void BoneData::Allocate(NvUInt32 numBones)
-{
-	Release();
-
-	m_numBones = numBones;
-
-	m_pPoseMatrices		= new atcore_float4x4[numBones];
-	m_pSkinMatrices		= new atcore_float4x4[numBones];
-	m_pBoneMatrices		= new atcore_float4x4[numBones];
-
-	m_pSkinDQs			= new atcore_dualquaternion[numBones];
-	m_pBoneNames		= new char[NV_HAIR_MAX_STRING * m_numBones];
-	m_pMappedBoneId		= new int[numBones];
-
-	for (int i = 0; i < numBones; i++)
-	{
-		gfsdk_makeIdentity(m_pPoseMatrices[i]);
-		gfsdk_makeIdentity(m_pSkinMatrices[i]);
-		m_pMappedBoneId[i] = -1;
-	}
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void BoneData::Release()
-{
-	if (m_pPoseMatrices)
-	{
-		delete []m_pPoseMatrices;
-		m_pPoseMatrices = 0;
-	}
-
-	if (m_pBoneMatrices)
-	{
-		delete []m_pBoneMatrices;
-		m_pBoneMatrices = 0;
-	}
-
-	if (m_pSkinMatrices)
-	{
-		delete []m_pSkinMatrices;
-		m_pSkinMatrices = 0;
-	}
-
-	if (m_pSkinDQs)
-	{
-		delete []m_pSkinDQs;
-		m_pSkinDQs = 0;
-	}
-
-	if (m_pBoneNames)
-	{
-		delete []m_pBoneNames;
-		m_pBoneNames = 0;
-	}
-
-	if (m_pMappedBoneId)
-	{
-		delete []m_pMappedBoneId;
-		m_pMappedBoneId = 0;
-	}
-
-	m_numBones = 0;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void BoneData::InitializeAnimationCache(AnimationCache* pGlobalCache, const char* nodeName)
-{
-	if (!pGlobalCache || !pGlobalCache->isValid())
-		return;
-
-	pGlobalCache->FindBoneMapping(m_numBones, m_pBoneNames, m_pMappedBoneId);
-
-	m_nodeId = pGlobalCache->FindBone(nodeName);
-
-	m_pAnimationCache = pGlobalCache;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool BoneData::Update(float frameTime, const char* rootBoneName, bool bindPose, bool zup)
-{
-	if (!m_pAnimationCache || !m_pAnimationCache->isValid() )
-		bindPose = true;
-
-	atcore_float4x4 model;
-	gfsdk_makeIdentity(model);
-
-	if (bindPose)
-	{
-		for (int i = 0; i < m_numBones; i++)
-		{
-			m_pBoneMatrices[i] = m_pPoseMatrices[i];
-			m_pSkinMatrices[i] = model;
-			m_pSkinDQs[i] = gfsdk_makeDQ(m_pSkinMatrices[i]);
-		}
-		return true;
-	}
-
-	int indexStart, indexEnd;
-	float fracFrame = 0.0f;
-	if (false == m_pAnimationCache->GetInterpolationInfo(frameTime, indexStart, indexEnd, fracFrame))
-		return false;
-
-	atcore_float4x4* pBoneStart	= m_pAnimationCache->GetNodeMatrices(indexStart);
-	atcore_float4x4* pBoneEnd	= m_pAnimationCache->GetNodeMatrices(indexEnd);
-
-	int numBones = m_numBones;
-
-	atcore_float4x4 root;
-	gfsdk_makeIdentity(root);
-
-	if (rootBoneName)
-	{
-		int rootIndex = m_pAnimationCache->FindBone(rootBoneName);
-
-		if (rootIndex >= 0)
-		{
-			root = gfsdk_lerp(pBoneStart[rootIndex], pBoneEnd[rootIndex], fracFrame);
-
-			atcore_float3 lT = gfsdk_getTranslation(root);
-
-			if (zup)
-				lT.z = 0;
-			else
-				lT.y = 0;
-
-			gfsdk_makeIdentity(root);
-			gfsdk_setTranslation(root, -1.0f * lT);
-		}
-	}
-
-	// interpolate skinning matrix
-	for (int i = 0; i < numBones; i++)
-	{
-		atcore_float4x4 bone;
-
-		int index = m_pMappedBoneId[i];
-		if (index >= 0)
-			bone = gfsdk_lerp(pBoneStart[index], pBoneEnd[index], fracFrame);
-		else
-			gfsdk_makeIdentity(bone);
-
-		atcore_float4x4 pose = m_pPoseMatrices[i];
-
-		m_pBoneMatrices[i] = bone;
-		m_pSkinMatrices[i] = gfsdk_inverse(pose) * bone * root;
-		m_pSkinDQs[i] = gfsdk_makeDQ(m_pSkinMatrices[i]);
-	}
-
-	return true;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void MeshDesc::Allocate(NvUInt32 numVertices, NvUInt32 numTriangles)
-{
-	Release();
-
-	m_NumTriangles			= numTriangles;
-	m_NumVertices			= numVertices;
-
-	m_pVertices				= new atcore_float3[numVertices];
-
-	m_pVertexNormals		= new atcore_float3[numTriangles * 3];
-	m_pFaceNormals			= new atcore_float3[numTriangles * 3];
-
-	m_pTangents				= new atcore_float3[numTriangles * 3];
-
-	m_pIndices = new NvUInt32[numTriangles * 3];
-	m_pTexCoords			= new atcore_float2[numTriangles * 3];
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void MeshDesc::Release()
-{
-	if (m_pVertices)
-		delete []m_pVertices;
-	if (m_pVertexNormals)
-		delete []m_pVertexNormals;
-	if (m_pFaceNormals)
-		delete []m_pFaceNormals;
-	if (m_pTangents)
-		delete []m_pTangents;
-
-	if (m_pIndices)
-		delete []m_pIndices;
-	if (m_pTexCoords)
-		delete []m_pTexCoords;
-
-	m_NumTriangles = 0;
-	m_NumVertices = 0;
-
-	m_pVertices				= nullptr;
-	m_pVertexNormals		= nullptr;
-	m_pFaceNormals			= nullptr;
-	m_pTangents				= nullptr;
-
-	m_pIndices				= nullptr;
-	m_pTexCoords			= nullptr;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void MeshDesc::UpdateNormal(bool updateVertexNormal)
-{
-	atcore_float3* vertexNormal = new atcore_float3[m_NumVertices];
-	memset(vertexNormal, 0, sizeof(atcore_float3) * m_NumVertices);
-
-	for (int i = 0; i < m_NumTriangles; i++)
-	{
-		atcore_float3 faceNormal;
-
-		int fidx = i*3;
-		int id0 = m_pIndices[fidx++];
-		int id1 = m_pIndices[fidx++];
-		int id2 = m_pIndices[fidx++];
-		
-		atcore_float3 p0 = m_pVertices[id0];
-		atcore_float3 p1 = m_pVertices[id1];
-		atcore_float3 p2 = m_pVertices[id2];
-		atcore_float3 p01 = p1 - p0;
-		atcore_float3 p02 = p2 - p0;
-
-		faceNormal.x = p01.y * p02.z - p01.z * p02.y;
-		faceNormal.y = p01.z * p02.x - p01.x * p02.z;
-		faceNormal.z = p01.x * p02.y - p01.y * p02.x;
-
-		gfsdk_normalize(faceNormal);
-
-		m_pFaceNormals[i * 3 + 0] = faceNormal;
-		m_pFaceNormals[i * 3 + 1] = faceNormal;
-		m_pFaceNormals[i * 3 + 2] = faceNormal;
-
-		vertexNormal[id0] += faceNormal;
-		vertexNormal[id1] += faceNormal;
-		vertexNormal[id2] += faceNormal;
-	}
-	
-	if (updateVertexNormal)
-	{
-		for (int i = 0; i < m_NumVertices; ++i)
-			gfsdk_normalize(vertexNormal[i]);
-
-		for (int i = 0; i < m_NumTriangles; i++)
-		{
-			int fidx = i*3;
-			int id0 = m_pIndices[fidx++];
-			int id1 = m_pIndices[fidx++];
-			int id2 = m_pIndices[fidx++];
-		
-			for (int k = 0; k < 3; k++)
-			{
-				int fidx = i*3 + k;
-				int vidx = m_pIndices[fidx];
-				m_pVertexNormals[fidx] = vertexNormal[vidx];
-			}
-		}
-	}
-
-	delete []vertexNormal;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void SkinData::Allocate(NvUInt32 numBones, NvUInt32 numVertices)
-{
-	Release();
-
-	m_boneData.Allocate(numBones);
-
-	m_pBoneIndices = new atcore_float4[numVertices];
-	m_pBoneWeights = new atcore_float4[numVertices];
-
-	memset(m_pBoneIndices, 0, sizeof(atcore_float4) * numVertices);
-	memset(m_pBoneWeights, 0, sizeof(atcore_float4) * numVertices);
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void SkinData::Release()
-{
-	// clear memory
-	if (m_pBoneIndices)
-		delete []m_pBoneIndices;
-	if (m_pBoneWeights)
-		delete []m_pBoneWeights;
-
-	m_pBoneIndices	= 0;
-	m_pBoneWeights	= 0;
-
-	m_boneData.Release();
-}
-
diff --git a/tools/ArtistTools/source/CoreLib/Anim/AnimUtil.h b/tools/ArtistTools/source/CoreLib/Anim/AnimUtil.h
deleted file mode 100644
index 5fd239b..0000000
--- a/tools/ArtistTools/source/CoreLib/Anim/AnimUtil.h
+++ /dev/null
@@ -1,219 +0,0 @@
-// This code contains NVIDIA Confidential Information and is disclosed 
-// under the Mutual Non-Disclosure Agreement. 
-// 
-// Notice 
-// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES 
-// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO 
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT, 
-// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. 
-// 
-// NVIDIA Corporation assumes no responsibility for the consequences of use of such 
-// information or for any infringement of patents or other rights of third parties that may 
-// result from its use. No license is granted by implication or otherwise under any patent 
-// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless 
-// expressly authorized by NVIDIA.  Details are subject to change without notice. 
-// This code supersedes and replaces all information previously supplied. 
-// NVIDIA Corporation products are not authorized for use as critical 
-// components in life support devices or systems without express written approval of 
-// NVIDIA Corporation. 
-// 
-// Copyright (c) 2013 NVIDIA Corporation. All rights reserved.
-//
-// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
-// rights in and to this software and related documentation and any modifications thereto.
-// Any use, reproduction, disclosure or distribution of this software and related
-// documentation without an express license agreement from NVIDIA Corporation is
-// strictly prohibited.
-//
-#pragma once
-
-#include "MathUtil.h"
-#include <string.h>
-#define NV_HAIR_MAX_STRING 128
-
-////////////////////////////////////////////////////////////////////////////////////////
-// cache for animated bone data
-struct CORELIB_EXPORT AnimationCache
-{
-	NvUInt32		m_numBones;
-	NvChar*			m_pBoneNames;
-
-	NvInt32			m_frameStart;
-	NvInt32			m_frameEnd;
-	NvUInt32		m_numFrames;
-
-	atcore_float4x4*		m_pBoneMatrices;
-
-	AnimationCache() :
-		m_numBones(0),
-		m_frameStart(0),
-		m_frameEnd(0),
-		m_numFrames(0),
-		m_pBoneMatrices(nullptr),
-		m_pBoneNames(nullptr)
-		{
-		}
-
-	bool isValid() const {
-		return (m_numBones > 0) && (m_numFrames > 0) && (m_pBoneMatrices != 0);
-	}
-
-	void Allocate();
-	void Release();
-	void Initialize(int numBones, NvInt32 frameStart, NvInt32 frameEnd);
-
-	bool GetInterpolationInfo(float frameTime, int& indexStart, int& indexEnd, float &fracFrame);
-
-	const atcore_float4x4* GetNodeMatrices(int index) const { return m_pBoneMatrices + index * m_numBones; }
-	atcore_float4x4* GetNodeMatrices(int index) { return m_pBoneMatrices + index * m_numBones; }
-	
-	const char* GetBoneName(int index) const
-	{
-		return m_pBoneNames + index * NV_HAIR_MAX_STRING;
-	}
-
-	void	SetBoneName(int index, const char* boneName)
-	{
-		char* str = m_pBoneNames + index * NV_HAIR_MAX_STRING;
-		strcpy_s(str, NV_HAIR_MAX_STRING, boneName);
-	}
-
-	int		FindBone(const char *boneName) const;
-	bool	FindBoneMapping( int numBones, const NvChar* boneNames, int* mappedBoneId) const;
-
-	~AnimationCache();
-};
-
-////////////////////////////////////////////////////////////////////////////////////////
-// bone matrices at each frame
-////////////////////////////////////////////////////////////////////////////////////////
-struct CORELIB_EXPORT BoneData
-{
-	NvUInt32			m_numBones;
-	NvChar*				m_pBoneNames;
-
-	atcore_float4x4*			m_pPoseMatrices; // rest pose for each bone
-	atcore_float4x4*			m_pBoneMatrices; // updated bone matrix
-	atcore_float4x4*			m_pSkinMatrices; // interpolated skinning matrix for current frame
-	atcore_dualquaternion*	m_pSkinDQs; // dual quats
-
-	AnimationCache*			m_pAnimationCache; 
-	int*					m_pMappedBoneId;
-	int						m_nodeId;
-
-public:
-	BoneData() :
-		m_numBones(0),
-		m_pBoneNames(nullptr),
-		m_pPoseMatrices(nullptr),
-		m_pBoneMatrices(nullptr),
-		m_pSkinMatrices(nullptr),
-		m_pSkinDQs(nullptr),
-		m_pAnimationCache(nullptr),
-		m_pMappedBoneId(nullptr),
-		m_nodeId(-1)
-		{}
-
-	void Allocate(NvUInt32 numBones);
-	void Release();
-
-	const char* getBoneName(int index)
-	{
-		return m_pBoneNames + index * NV_HAIR_MAX_STRING;
-	}
-
-	void setBoneName(int index, const char* boneName)
-	{
-		char* str = m_pBoneNames + index * NV_HAIR_MAX_STRING;
-		strcpy_s(str, NV_HAIR_MAX_STRING, boneName);
-	}
-
-	void InitializeAnimationCache(AnimationCache* pGlobalCache, const char* nodeName);
-	bool Update(float frameTime, const char* rootBoneName, bool bindPose, bool zup);
-
-};
-
-////////////////////////////////////////////////////////////////////////////////////////
-// Skinning data
-struct CORELIB_EXPORT SkinData
-{
-	BoneData			m_boneData;
-
-	atcore_float4*		m_pBoneIndices;
-	atcore_float4*		m_pBoneWeights;
-
-public:
-	SkinData() : 
-		m_pBoneIndices(nullptr),
-		m_pBoneWeights(nullptr)
-		{}
-
-	void Allocate(NvUInt32 numBones, NvUInt32 numVertices);
-	void Release();
-};
-
-
-////////////////////////////////////////////////////////////////////////////////////////
-struct CORELIB_EXPORT MeshDesc
-{
-	NvUInt32				m_NumVertices;
-	NvUInt32				m_NumTriangles;
-
-	atcore_float3*			m_pVertices;
-	atcore_float3*			m_pVertexNormals;
-	atcore_float3*			m_pFaceNormals;
-	atcore_float3*			m_pTangents;
-	atcore_float3			m_ColorRGB;
-
-	NvUInt32*				m_pIndices;
-	atcore_float2*			m_pTexCoords;
-
-public:
-	MeshDesc() :
-		m_NumVertices(0),
-		m_NumTriangles(0),
-
-		m_pVertices(nullptr),
-		m_pVertexNormals(nullptr),
-		m_pFaceNormals(nullptr),
-		m_pTangents(nullptr),
-
-		m_pIndices(nullptr),
-		m_pTexCoords(nullptr)
-		{
-			m_ColorRGB = gfsdk_makeFloat3(0, 0, 0);
-		}
-
-	void Allocate(NvUInt32 numVertices, NvUInt32 numTriangles);
-	void Release();
-
-	void UpdateNormal(bool updateVertexNormal = false);
-};
-
-////////////////////////////////////////////////////////////////////////////////////////
-#define MATERIAL_NAME_SIZE	128
-
-struct CORELIB_EXPORT MeshMaterial
-{
-	NvChar				m_name[MATERIAL_NAME_SIZE];
-
-	atcore_float3		m_ambientColor;
-	float				m_ambientFactor;
-
-	atcore_float3		m_diffuseColor;
-	float				m_diffuseFactor;
-
-	float				m_specularFactor;
-	float				m_shininess;
-
-	NvChar				m_diffuseTexture[MATERIAL_NAME_SIZE];
-	NvChar				m_specularTexture[MATERIAL_NAME_SIZE];
-	NvChar				m_bumpTexture[MATERIAL_NAME_SIZE];
-	NvChar				m_normalTexture[MATERIAL_NAME_SIZE];
-	NvChar				m_transparentTexture[MATERIAL_NAME_SIZE];
-
-public:
-	MeshMaterial() 
-		{}
-};
-
diff --git a/tools/ArtistTools/source/CoreLib/Anim/FbxUtil.cpp b/tools/ArtistTools/source/CoreLib/Anim/FbxUtil.cpp
deleted file mode 100644
index 1d78d5c..0000000
--- a/tools/ArtistTools/source/CoreLib/Anim/FbxUtil.cpp
+++ /dev/null
@@ -1,1029 +0,0 @@
-// This code contains NVIDIA Confidential Information and is disclosed 
-// under the Mutual Non-Disclosure Agreement. 
-// 
-// Notice 
-// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES 
-// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO 
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT, 
-// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. 
-// 
-// NVIDIA Corporation assumes no responsibility for the consequences of use of such 
-// information or for any infringement of patents or other rights of third parties that may 
-// result from its use. No license is granted by implication or otherwise under any patent 
-// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless 
-// expressly authorized by NVIDIA.  Details are subject to change without notice. 
-// This code supersedes and replaces all information previously supplied. 
-// NVIDIA Corporation products are not authorized for use as critical 
-// components in life support devices or systems without express written approval of 
-// NVIDIA Corporation. 
-// 
-// Copyright (c) 2013 NVIDIA Corporation. All rights reserved.
-//
-// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
-// rights in and to this software and related documentation and any modifications thereto.
-// Any use, reproduction, disclosure or distribution of this software and related
-// documentation without an express license agreement from NVIDIA Corporation is
-// strictly prohibited.
-//
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// This file contains wrapper functions to make hair lib easy to setup and use
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#include "fbxsdk.h"
-#include <vector>
-#include <string>
-
-#include "FbxUtil.h"
-#include "MathUtil.h"
-#include "GlobalSettings.h"
-
-// local functions used only in this file
-namespace {
-
-	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-	// Get the geometry offset to a node. It is never inherited by the children.
-	FbxAMatrix GetGeometry(FbxNode* pNode)
-	{
-		const FbxVector4 lT = pNode->GetGeometricTranslation(FbxNode::eSourcePivot);
-		const FbxVector4 lR = pNode->GetGeometricRotation(FbxNode::eSourcePivot);
-		const FbxVector4 lS = pNode->GetGeometricScaling(FbxNode::eSourcePivot);
-
-		return FbxAMatrix(lT, lR, lS);
-	}
-
-	////////////////////////////////////////////////////////////////////////////////////////
-	void convertFromFbxMatrix(atcore_float4x4& transform, FbxAMatrix& tmatrix)
-	{
-		float* data = (float*)&transform;
-
-		// update skinning matrix
-		for (int row = 0; row < 4; row++)
-			for (int col = 0; col < 4; col++)
-			{
-				data[ row * 4 + col] = float(tmatrix.Get(row,col));
-			}
-	}
-
-	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-	bool checkMesh(FbxNode* pNode)
-	{
-		FbxMesh* pMesh = pNode->GetMesh();
-		if (!pMesh)
-			return false;
-
-		return true;
-	}
-
-	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-	bool checkSkinned(FbxNode* pNode)
-	{
-		FbxGeometry* pFbxGeometry = pNode->GetGeometry();
-		if (!pFbxGeometry)
-			return false;
-	
-		FbxSkin* pFbxSkin = (FbxSkin*)pFbxGeometry->GetDeformer(0, FbxDeformer::eSkin);
-		if (!pFbxSkin)
-			return false;
-
-		return true;
-	}
-}
-
-namespace
-{
-	FbxManager*			s_FbxManager = nullptr;
-	FbxScene*			s_FbxScene = nullptr;
-	
-
-	/////////////////////////////////////////////////////////////////////////////
-	// find node by name
-	FbxNode* 
-	FindNodeByName(FbxScene* scene, const char* nodeName)
-	{
-		if (!scene)
-			return 0;
-
-		if (!nodeName)
-			return 0;
-
-		for (int i = 0; i < scene->GetNodeCount(); i++)
-		{
-			FbxNode* node = scene->GetNode(i);
-			const char* name = node->GetName();
-			if (!strcmp(nodeName, name))
-				return node;
-		}
-		return 0;
-	}
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool
-FbxUtil::Release(void)
-{
-	if (s_FbxScene)
-	{
-		s_FbxScene->Destroy();
-		s_FbxScene = nullptr;
-	}
-
-	if (s_FbxManager)
-	{
-		s_FbxManager->Destroy();
-		s_FbxManager = nullptr;
-	}
-	
-	return true;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//// if fbx uses one unit which is not supported, we will also convert its unit.
-bool FbxUtil::Initialize(const char* fbxFileName, nvidia::Float& fbxSceneUnit, nvidia::Float toScneUnit, bool bConvertUnit)
-{
-	if (fbxFileName)
-	{
-		FbxImporter*		s_FbxImporter = nullptr;
-
-		if (!s_FbxManager)
-			s_FbxManager = FbxManager::Create();
-
-		if (!s_FbxImporter)
-			s_FbxImporter = FbxImporter::Create(s_FbxManager, "");
-
-		if (!s_FbxScene)
-			s_FbxScene = FbxScene::Create(s_FbxManager, "");
-	
-		if (!s_FbxImporter->Initialize(fbxFileName, -1))
-			return false;
-
-		if (!s_FbxImporter->Import(s_FbxScene))
-			return false;
-
-		FbxGlobalSettings& settings = s_FbxScene->GetGlobalSettings();
-
-		FbxSystemUnit fbxUnit = settings.GetSystemUnit();
-		fbxSceneUnit = fbxUnit.GetScaleFactor();
-		bool bSupported = GlobalSettings::Inst().isSupportedUnitByUnitInCm(fbxSceneUnit);
-		bool bNeedConvert = ((toScneUnit > 0.0f) && bConvertUnit && (fabs(toScneUnit - fbxSceneUnit) > 0.001f));
-		if (bNeedConvert || !bSupported)
-		{
-			// if FBX has a non-supported unit, we still convert its unit
-			FbxSystemUnit convertUnit(toScneUnit);
-			convertUnit.ConvertScene(s_FbxScene);
-		}
-
-		s_FbxImporter->Destroy();
-
-		// get time info
-		FbxTimeSpan timespan;
-		settings.GetTimelineDefaultTimeSpan(timespan);
-
-		FbxTime startTime = timespan.GetStart();
-		FbxTime endTime = timespan.GetStop();
-
-	}
-
-	return true;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool FbxUtil::GetGlobalSettings(float* pStartFrame, float* pEndFrame, float *pFps, int *upAxis, char* rootBoneName)
-{
-	if ( !s_FbxScene)
-		return false;
-
-	FbxGlobalSettings& settings = s_FbxScene->GetGlobalSettings();
-
-	FbxTimeSpan timespan;
-	settings.GetTimelineDefaultTimeSpan(timespan);
-
-	FbxTime startTime = timespan.GetStart();
-	FbxTime endTime = timespan.GetStop();
-	
-	if (pStartFrame) 
-		*pStartFrame = (float)startTime.GetFrameCount();
-
-	if (pEndFrame) 
-		*pEndFrame = (float)endTime.GetFrameCount();
-
-	if (pFps)
-		*pFps = (float)endTime.GetFrameRate(FbxTime::GetGlobalTimeMode());
-
-	if (upAxis)
-	{
-		int upSign = 0;
-		FbxAxisSystem axisSystem = settings.GetAxisSystem();
-		FbxAxisSystem::EUpVector upVector = axisSystem.GetUpVector(upSign);
-
-		enum FbxAxisSystem::ECoordSystem coordSystem = axisSystem.GetCoorSystem();
-
-		switch (upVector)
-		{
-		case FbxAxisSystem::eXAxis: *upAxis = 0; break;
-		case FbxAxisSystem::eYAxis: *upAxis = 1; break;
-		case FbxAxisSystem::eZAxis: *upAxis = 2; break;
-		}
-	}
-
-	if (rootBoneName)
-	{
-		FbxNode* pRoot = s_FbxScene->GetRootNode();
-		if (pRoot)
-		{
-			strncpy(rootBoneName, pRoot->GetName(), NV_HAIR_MAX_STRING);
-		}
-		else
-			strcpy(rootBoneName, "");
-	}
-
-	return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-bool
-FbxUtil::InitializeAnimationCache(AnimationCache& animCache)
-{
-	if (!s_FbxScene)
-		return false;
-
-	float startFrame, endFrame, fps;
-	FbxUtil::GetGlobalSettings(&startFrame, &endFrame, &fps);
-
-	int numNodes = s_FbxScene->GetNodeCount();
-
-	////////////////////////////////////////////
-	animCache.Initialize(numNodes, (NvInt32)startFrame, (NvInt32)endFrame);
-
-	for (int i = 0; i < numNodes; i++)
-	{
-		FbxNode* node = s_FbxScene->GetNode(i);
-		const char* nodeName = node->GetName();
-		animCache.SetBoneName(i, nodeName);
-	}
-
-	////////////////////////////////////////////
-	for (NvInt frame = animCache.m_frameStart; frame <= animCache.m_frameEnd; frame++)
-	{
-		FbxTime lTime;
-		lTime.SetSecondDouble( frame / fps);
-
-		int index = frame - animCache.m_frameStart;
-		atcore_float4x4 *pNodeMatrices = animCache.GetNodeMatrices(index);
-
-		for (int i = 0; i < numNodes; i++)
-		{
-			FbxNode* node = s_FbxScene->GetNode(i);
-			FbxAMatrix nodeMatrix = node->EvaluateGlobalTransform(lTime);
-			convertFromFbxMatrix(pNodeMatrices[i], nodeMatrix);
-		}
-	}
-
-	return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-static FbxSkin* GetFbxSkin( FbxNode* pFbxNode )
-{
-	if (!pFbxNode)
-		return 0;
-	
-	FbxMesh* pFbxMesh = pFbxNode->GetMesh();
-	if (!pFbxMesh)
-		return 0;
-
-	FbxGeometry* pFbxGeometry = pFbxNode->GetGeometry();
-	if (!pFbxGeometry)
-		return 0;
-
-	int deformerCount = pFbxGeometry->GetDeformerCount(FbxDeformer::eSkin);
-
-	FbxSkin *pFbxSkin = 0;
-	if (deformerCount > 0)
-		pFbxSkin = (FbxSkin*)pFbxGeometry->GetDeformer(0, FbxDeformer::eSkin);
-
-	return pFbxSkin;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-static int GetNumMeshPoints( FbxNode* pFbxNode)
-{
-	if (!pFbxNode)
-		return 0;
-
-	FbxMesh* pFbxMesh = pFbxNode->GetMesh();
-	if (!pFbxMesh)
-		return 0;
-
-	return pFbxMesh->GetControlPointsCount();
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-static bool GetBoneData(FbxSkin *pFbxSkin, FbxNode* pFbxNode, NvChar* pBoneNames, atcore_float4x4 *pBindPoses)
-{
-	if (!pFbxSkin || !pFbxNode)
-		return false;
-
-	int numBones = (int)pFbxSkin->GetClusterCount();
-
-	for (int i = 0; i < numBones; i++)
-	{
-		FbxCluster* pFbxCluster = pFbxSkin->GetCluster(i);
-			
-		FbxNode* pLink = pFbxCluster->GetLink();
-
-		// copy bone names
-		const char* boneName = pLink->GetName();
-		char* str = pBoneNames + i * NV_HAIR_MAX_STRING;
-		strcpy_s(str, NV_HAIR_MAX_STRING, boneName);
-
-		// write pose matrix
-		{
-			FbxAMatrix lReferenceGlobalInitPosition;
-			pFbxCluster->GetTransformMatrix(lReferenceGlobalInitPosition);
-
-			FbxAMatrix lReferenceGeometry = GetGeometry(pFbxNode);
-			lReferenceGlobalInitPosition *= lReferenceGeometry;
-
-			FbxAMatrix lClusterGlobalInitPosition;
-			pFbxCluster->GetTransformLinkMatrix(lClusterGlobalInitPosition);
-
-			FbxAMatrix lClusterMatrix = lClusterGlobalInitPosition.Inverse() * lReferenceGlobalInitPosition;
-			convertFromFbxMatrix(pBindPoses[i], lClusterMatrix.Inverse());
-		}
-	}
-	return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-static bool GetSkinningWeights(FbxSkin* pFbxSkin, atcore_float4* boneIndices, atcore_float4* boneWeights, int numPoints)
-{
-	int numClusters = (int)pFbxSkin->GetClusterCount();
-	if (numClusters == 0)
-		return false;
-
-	// copy skinning weights and indices
-	int* pIndexCounts = new int[numPoints];
-	memset(pIndexCounts, 0, sizeof(int) * numPoints);
-
-	for (int i = 0; i < numClusters; i++)
-	{
-		if (!pFbxSkin) continue;
-
-		FbxCluster* pFbxCluster = pFbxSkin->GetCluster(i);
-
-		if (!pFbxCluster) continue;
-
-		int		cpCount = pFbxCluster->GetControlPointIndicesCount();
-		int*		pPointIndices = pFbxCluster->GetControlPointIndices();
-		double*		pWeights = pFbxCluster->GetControlPointWeights();
-
-		for (int j = 0; j < cpCount; j++)
-		{
-			if (pWeights[j] == 0.0f)
-				continue;
-
-			int pointIndex = pPointIndices[j];
-			int& cnt = pIndexCounts[pointIndex];
-
-			float* pBoneIndex = (float*)&boneIndices[pointIndex];
-			float* pBoneWeights = (float*)&boneWeights[pointIndex];
-
-			if (cnt < 4)
-			{
-				pBoneIndex[cnt] = float(i);
-				pBoneWeights[cnt] = float(pWeights[j]);
-				cnt++;
-			}
-			else // over 4, so we just bind to largest weights
-			{
-				float minWeight = (float)pWeights[j];
-				int minIndex = -1;
-				for (int b = 0; b < 4; b++) 
-				{
-					float w = pBoneWeights[b];
-
-					if (w < minWeight)
-					{
-						minWeight = w;
-						minIndex = b;
-					}
-				}
-
-				if (minIndex >= 0)
-				{
-					pBoneIndex[minIndex] = float(i);
-					pBoneWeights[minIndex] = float(pWeights[j]);
-				}
-
-				cnt++;
-			}
-		}
-	}
-
-	for (int i = 0; i < numPoints; i++)
-	{
-		float* pBoneWeights = (float*)&boneWeights[i];
-
-		float weightsum = 0;
-		for (int i = 0; i < 4; i++)
-		{
-			weightsum += pBoneWeights[i];
-		}
-
-		if (weightsum == 0)
-			continue;
-
-		for (int i = 0; i < 4; i++)
-			pBoneWeights[i] /= weightsum;
-	}
-
-	if (pIndexCounts) delete []pIndexCounts;
-
-	return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-bool FbxUtil::InitializeSkinData( const char* meshName, SkinData& skinData)
-{
-	FbxNode* pFbxNode = FindNodeByName(s_FbxScene, meshName);
-	if (!pFbxNode)
-		return false;
-	
-	FbxSkin* pFbxSkin = GetFbxSkin(pFbxNode);
-	int numPoints = GetNumMeshPoints(pFbxNode);
-
-	BoneData& boneData = skinData.m_boneData;
-
-	if (pFbxSkin)
-	{
-		int numBones = (int)pFbxSkin->GetClusterCount();
-		skinData.Allocate(numBones, numPoints);
-
-		// get bone data (bind pose, bone names, ..)
-		GetBoneData(pFbxSkin, pFbxNode, boneData.m_pBoneNames, boneData.m_pPoseMatrices);
-
-		// get skinning weights 
-		atcore_float4* boneIndices = skinData.m_pBoneIndices;
-		atcore_float4* boneWeights = skinData.m_pBoneWeights;
-
-		GetSkinningWeights(pFbxSkin, boneIndices, boneWeights, numPoints);
-	}
-	else // no skinning, use model matrix
-	{
-		int numBones = 1;
-
-		skinData.Allocate(numBones, numPoints);
-
-		// copy bone name
-		const char* boneName = pFbxNode->GetName();
-		boneData.setBoneName(0, boneName);
-
-		// make pose matrix
-		gfsdk_makeIdentity(boneData.m_pPoseMatrices[0]);
-
-		// all the vertices map to the model matrix
-		atcore_float4* boneIndices = skinData.m_pBoneIndices;
-		atcore_float4* boneWeights = skinData.m_pBoneWeights;
-
-		for (int i = 0; i < numPoints; i++)
-		{
-			boneIndices[i] = gfsdk_makeFloat4(0, 0, 0, 0);
-			boneWeights[i] = gfsdk_makeFloat4(1, 0, 0, 0);
-		}
-	}
-
-	return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool FbxUtil::GetMeshInfo(int* numMeshes, char** meshNames, char** parents, char** skinned)
-{
-	int cnt = 0;
-
-	for (int i = 0; i < s_FbxScene->GetNodeCount(); i++)
-	{
-		FbxNode* pNode = s_FbxScene->GetNode(i);
-		if (checkMesh(pNode))
-			cnt++;
-	}
-
-	char *pNameBuffer = new char[cnt * 128];
-	char *pSkinnedBuffer = new char[cnt];
-
-	char *pParentBuffer = new char[cnt * 128];
-	memset(pParentBuffer, 0, cnt * 128);
-
-	cnt = 0;
-	for (int i = 0; i < s_FbxScene->GetNodeCount(); i++)
-	{
-		FbxNode* pNode = s_FbxScene->GetNode(i);
-
-		if (!checkMesh(pNode))
-			continue;
-
-		strcpy(pNameBuffer + cnt * 128, pNode->GetName());
-
-		FbxNode* pParentNode = pNode->GetParent();
-		if (pParentNode != nullptr)
-		{
-			strcpy(pParentBuffer + cnt * 128, pParentNode->GetName());
-		}
-
-		pSkinnedBuffer[cnt] = checkSkinned(pNode);
-
-		cnt++;
-	}
-
-	*numMeshes = cnt;
-	if (skinned)
-	{
-		*skinned = pSkinnedBuffer;
-	}
-	else
-		delete []pSkinnedBuffer;
-
-	*meshNames = pNameBuffer;
-	*parents = pParentBuffer;
-
-	return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool FbxUtil::GetMeshMaterials( const NvChar* meshName, int *numMaterials, MeshMaterial** materials)
-{
-	if (!s_FbxScene)
-		return false;
-
-	FbxNode* pNode = FindNodeByName(s_FbxScene, meshName);
-	if (!pNode)
-		return false;
-
-	int numMats = pNode->GetMaterialCount();
-	if (numMats == 0)
-		return false;
-
-	*materials = new MeshMaterial[numMats];
-
-	int matCnt = 0;
-
-	for (int i = 0; i < numMats; i++)
-	{
-		FbxSurfaceMaterial *mat = pNode->GetMaterial(i);
-		if (!mat) continue;
-		if (mat->GetUserDataPtr()) continue;
-
-		MeshMaterial& material = (*materials)[matCnt];
-			
-		strcpy(material.m_name, mat->GetName());
-		strcpy(material.m_diffuseTexture, "");
-		strcpy(material.m_bumpTexture, "");
-		strcpy(material.m_transparentTexture, "");
-		strcpy(material.m_normalTexture, "");
-
-		(atcore_float3&)material.m_ambientColor = gfsdk_makeFloat3(1.0f, 1.0f, 1.0f);
-		(atcore_float3&)material.m_diffuseColor = gfsdk_makeFloat3(1.0f, 1.0f, 1.0f);
-	
-		FbxProperty prop;
-		FbxProperty fact;
-		FbxDouble3 d3;
-
-		// get ambient
-		{
-			fact = mat->FindProperty(FbxSurfaceMaterial::sAmbientFactor);
-			material.m_ambientFactor = fact.IsValid() ? (float)fact.Get<FbxDouble>() : 0.1f;
-
-			prop = mat->FindProperty(FbxSurfaceMaterial::sAmbient);
-			if (prop.IsValid())
-			{
-				FbxDouble3 d3 = prop.Get<FbxDouble3>();
-				material.m_ambientColor = gfsdk_makeFloat3((float)d3[0], (float)d3[1], (float)d3[2]);
-			}
-		}
-
-		// get specular
-		{
-			fact = mat->FindProperty(FbxSurfaceMaterial::sSpecularFactor);
-			material.m_specularFactor = fact.IsValid() ? (float)fact.Get<FbxDouble>() : 0.1f;
-
-			fact = mat->FindProperty(FbxSurfaceMaterial::sShininess);
-			material.m_shininess = fact.IsValid() ? (float)fact.Get<FbxDouble>() : 20.0f;
-		}
-
-		// get diffuse
-		{
-			fact = mat->FindProperty(FbxSurfaceMaterial::sDiffuseFactor);
-			material.m_diffuseFactor = fact.IsValid() ? (float)fact.Get<FbxDouble>() : 0.5f;
-
-			prop = mat->FindProperty(FbxSurfaceMaterial::sDiffuse);
-			if (prop.IsValid())
-			{
-				FbxDouble3 d3 = prop.Get<FbxDouble3>();
-				material.m_diffuseColor = gfsdk_makeFloat3((float)d3[0], (float)d3[1], (float)d3[2]);
-
-				const FbxFileTexture* tex = prop.GetSrcObject<FbxFileTexture>();
-				if (tex) 
-					strcpy(material.m_diffuseTexture, tex->GetFileName());
-			}
-		}
-
-		// get normal map
-		{
-			prop = mat->FindProperty(FbxSurfaceMaterial::sNormalMap);
-			if (prop.IsValid())
-			{
-				const FbxFileTexture* tex = prop.GetSrcObject<FbxFileTexture>();
-				if (tex) 
-					strcpy(material.m_normalTexture, tex->GetFileName());
-			}
-		}
-
-		matCnt++;
-	}
-
-	*numMaterials = matCnt;
-
-	return true;
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool FbxUtil::CreateMeshDescriptor(const char* meshName, MeshDesc &desc)
-{
-	if (!s_FbxScene)
-		return false;
-
-	FbxNode* pNode = FindNodeByName(s_FbxScene, meshName);
-	if (!pNode)
-		return false;
-
-	// read growth mesh data
-	FbxMesh* pMesh = pNode->GetMesh();
-	if (!pMesh)
-		return false;
-
-	FbxDouble3 meshColor = pMesh->Color.Get();
-	desc.m_ColorRGB = gfsdk_makeFloat3(meshColor[0], meshColor[1], meshColor[2]);
-
-	int cpCount = pMesh->GetControlPointsCount();
-
-	int triCount = 0;
-	for (int i = 0; i < pMesh->GetPolygonCount(); i++)
-	{
-		int psize = pMesh->GetPolygonSize(i);
-		triCount += (psize - 2);
-	}
-
-	// allocate buffers
-	desc.Allocate(cpCount, triCount);
-
-	// read positions
-	FbxVector4* points = pMesh->GetControlPoints();
-	FbxAMatrix matrixGeo = pNode->EvaluateGlobalTransform();
-	for (int i = 0; i < desc.m_NumVertices; i++)
-	{		
-		FbxVector4 v = matrixGeo.MultT(points[i]);
-		desc.m_pVertices[i] = gfsdk_makeFloat3(v.mData[0], v.mData[1], v.mData[2]);
-	}
-
-	memset(desc.m_pTexCoords, 0, sizeof(atcore_float2) * desc.m_NumTriangles * 3);
-	
-	// read uvs 
-	FbxLayerElementUV* leUV = pMesh->GetLayer(0)->GetUVs();
-
-	FbxGeometryElementNormal *lNormals = pMesh->GetElementNormal();
-	FbxGeometryElementTangent* lTangents = pMesh->GetElementTangent();
-
-	int tcnt = 0;
-	int vertexBase = 0;
-	for (int i = 0; i < pMesh->GetPolygonCount(); i++)
-	{
-		int vcnt = pMesh->GetPolygonSize(i);
-		for (int j = 0; j < (vcnt-2); j++)
-		{	
-			int pIndex[3] = { 0, j+1, j+2 };
-
-			// get polygon index
-			for (int p = 0; p < 3; ++p)
-				desc.m_pIndices[tcnt*3+p] = pMesh->GetPolygonVertex(i, pIndex[p]);	
-			
-			// get face normal
-			if (lNormals)
-			{
-				FbxLayerElement::EMappingMode mode = lNormals->GetMappingMode();
-
-				for (int p = 0; p < 3; ++p)
-				{
-					int vertexId = vertexBase + pIndex[p];
-					int normalId = vertexId;
-					if (mode == FbxGeometryElement::eByPolygonVertex) 
-					{
-						if (lNormals->GetReferenceMode() == FbxGeometryElement::eIndexToDirect) 
-							normalId = lNormals->GetIndexArray().GetAt(vertexId);
-					}
-					else if (mode == FbxGeometryElement::eByControlPoint)
-						normalId = pMesh->GetPolygonVertex(i, pIndex[p]);
-
-					const FbxVector4 &n = lNormals->GetDirectArray().GetAt(normalId);
-					desc.m_pVertexNormals[tcnt*3+p] = gfsdk_makeFloat3((float)n[0], (float)n[1], (float)n[2]);
-				}
-			}
-
-			// get face normal
-			if (lTangents)
-			{
-				FbxLayerElement::EMappingMode mode = lTangents->GetMappingMode();
-
-				for (int p = 0; p < 3; ++p)
-				{
-					int vertexId = vertexBase + pIndex[p];
-					int tangentId = vertexId;
-					if (mode == FbxGeometryElement::eByPolygonVertex) 
-					{
-						if (lTangents->GetReferenceMode() == FbxGeometryElement::eIndexToDirect) 
-							tangentId = lTangents->GetIndexArray().GetAt(vertexId);
-					}
-					else if (mode == FbxGeometryElement::eByControlPoint)
-						tangentId = pMesh->GetPolygonVertex(i, pIndex[p]);
-
-					const FbxVector4 &n = lTangents->GetDirectArray().GetAt(tangentId);
-					desc.m_pTangents[tcnt*3+p] = gfsdk_makeFloat3((float)n[0], (float)n[1], (float)n[2]);
-				}
-			}
-
-			if (leUV)
-			{
-				int i0 = pMesh->GetTextureUVIndex(i, 0);
-				int i1 = pMesh->GetTextureUVIndex(i, j+1);
-				int i2 = pMesh->GetTextureUVIndex(i, j+2);
-
-				FbxVector2 texCoord0 = leUV->GetDirectArray().GetAt(i0);
-				FbxVector2 texCoord1 = leUV->GetDirectArray().GetAt(i1);
-				FbxVector2 texCoord2 = leUV->GetDirectArray().GetAt(i2);
-
-				desc.m_pTexCoords[tcnt*3+0] = gfsdk_makeFloat2(1.0f * float(texCoord0[0]), 1.0f - float(texCoord0[1]));
-				desc.m_pTexCoords[tcnt*3+1] = gfsdk_makeFloat2(1.0f * float(texCoord1[0]), 1.0f - float(texCoord1[1]));
-				desc.m_pTexCoords[tcnt*3+2] = gfsdk_makeFloat2(1.0f * float(texCoord2[0]), 1.0f - float(texCoord2[1]));
-			}
-			
-			tcnt++;			
-		}
-		vertexBase += vcnt;
-	}
-
-	return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
-bool FbxUtil::CreateHairFromFbx(const char* guideName, const char* growthMeshName, NvHair::AssetDescriptor& hairAsset)
-{
-	if (!s_FbxScene)
-		return false;
-
-	// read growth mesh data
-	MeshDesc meshDesc;
-	if (false == FbxUtil::CreateMeshDescriptor(growthMeshName, meshDesc))
-		return false;
-
-	FbxNode* pHairNode = FindNodeByName(s_FbxScene, guideName);
-	if (!pHairNode)
-		return false;
-
-	FbxNode* pMeshNode = FindNodeByName(s_FbxScene, growthMeshName);
-	if (!pMeshNode)
-		return false;
-
-	FbxSkin* pFbxSkin = GetFbxSkin(pMeshNode);
-	int numBones = 1;
-
-	if (pFbxSkin)
-		numBones = (int)pFbxSkin->GetClusterCount();
-
-	// get skin data from mesh
-	int numPoints = meshDesc.m_NumVertices;
-
-	atcore_float4* pMeshBoneIndices = new atcore_float4[numPoints];
-	atcore_float4* pMeshBoneWeights = new atcore_float4[numPoints];
-
-	GetSkinningWeights(pFbxSkin, pMeshBoneIndices, pMeshBoneWeights, numPoints);
-
-	// create raw hair array
-	FbxLine* pLine = pHairNode->GetLine();
-	if (!pLine)
-		return false;
-
-	int cpCount = pLine->GetControlPointsCount();
-	int curveCount = pLine->GetEndPointCount();
-
-	atcore_float3*	pVertices	= new atcore_float3[cpCount];
-	NvUInt32*		pEndIndices = new NvUInt32[curveCount];
-
-	FbxVector4*		pFbxPoints		= pLine->GetControlPoints();
-	FbxArray<int>*	pFbxEndIndices	= pLine->GetEndPointArray();
-
-	for (int i = 0; i < cpCount; i++)
-		pVertices[i] = gfsdk_makeFloat3(float(pFbxPoints[i][0]), float(pFbxPoints[i][1]), float(pFbxPoints[i][2]));
-
-	for (int i = 0; i < curveCount; i++)
-		pEndIndices[i] = (*pFbxEndIndices)[i];
-
-	// check against closest growth mesh points
-	const float distThreshold = 25.0;
-
-	int numValidHairs = 0;
-	int numValidHairVertices = 0;
-
-	int* pMeshToHairMap = new int[meshDesc.m_NumVertices];
-	int* pHairToMeshMap = new int[curveCount];
-	int* pHairToHairMap = new int[curveCount];
-	float* pMinDistances = new float[meshDesc.m_NumVertices];
-	atcore_float3* pRootVertices = new atcore_float3[curveCount];
-	atcore_float3* pTriangleCenters = new atcore_float3[meshDesc.m_NumTriangles];
-
-	// initialize triangle centers
-	for (int i = 0; i < meshDesc.m_NumTriangles; i++)
-	{
-		NvUInt32 v0 = meshDesc.m_pIndices[i*3 + 0];
-		NvUInt32 v1 = meshDesc.m_pIndices[i * 3 + 1];
-		NvUInt32 v2 = meshDesc.m_pIndices[i * 3 + 2];
-
-		atcore_float3 p0 = meshDesc.m_pVertices[v0];
-		atcore_float3 p1 = meshDesc.m_pVertices[v1];
-		atcore_float3 p2 = meshDesc.m_pVertices[v2];
-
-		pTriangleCenters[i] = 1.0f / 3.0f * (p0 + p1 + p2);
-	}
-
-	// initialize mesh to hair map
-	for (int i = 0; i < meshDesc.m_NumVertices; i++)
-	{
-		pMeshToHairMap[i] = -1;
-		pMinDistances[i] = FLT_MAX;
-	}
-
-	// copy root vertices of input hairs
-
-	for (int i = 0; i < curveCount; i++)
-	{
-		int root = (i == 0) ? 0 : pEndIndices[i-1]+1;
-		pRootVertices[i] = pVertices[root];
-		pHairToMeshMap[i] = -1;
-	}
-
-	// for each input hair curve, find the closest mesh vertex
-	for (int i = 0; i < curveCount; i++)
-	{
-		atcore_float3 hp = pRootVertices[i];
-
-		float minDist = FLT_MAX;
-		int closestTriangle = -1;
-		for (int j = 0; j < meshDesc.m_NumTriangles; j++)
-		{
-			atcore_float3 c = pTriangleCenters[j];
-
-			float distSquared = gfsdk_lengthSquared(hp - c);
-			if (distSquared < minDist) 
-			{
-				minDist = distSquared;
-				closestTriangle = j;
-			}
-		}
-
-		if (closestTriangle >= 0)
-		{
-			for (int k = 0; k < 3; k++)
-			{
-				NvUInt32 v = meshDesc.m_pIndices[closestTriangle * 3 + k];
-				atcore_float3 p = meshDesc.m_pVertices[v];
-
-				float distSquared = gfsdk_lengthSquared(hp - p);
-				if (distSquared < pMinDistances[v])
-				{
-					pMinDistances[v] = distSquared;
-					pMeshToHairMap[v] = i;
-				}
-			}
-		}
-	}
-
-	// prepare mapping from new hair set to mesh and old hairs
-	for (int i = 0; i < meshDesc.m_NumVertices; i++)
-	{
-		int closestHair = pMeshToHairMap[i];
-		if (closestHair < 0)
-			continue;
-
-		pHairToMeshMap[numValidHairs] = i;
-		pHairToHairMap[numValidHairs] = closestHair;
-		pMeshToHairMap[i] = numValidHairs; // update hair with new hair index
-
-		int root	= (closestHair == 0) ? 0 : pEndIndices[closestHair-1]+1;
-		int tip		= pEndIndices[closestHair];
-
-		numValidHairVertices += (tip - root + 1);
-		numValidHairs++;
-	}
-
-	// allocate new hairs
-	hairAsset.m_numGuideHairs	= numValidHairs;
-	hairAsset.m_numVertices		= numValidHairVertices;
-
-	hairAsset.m_boneIndices	= new atcore_float4[hairAsset.m_numGuideHairs];
-	hairAsset.m_boneWeights	= new atcore_float4[hairAsset.m_numGuideHairs];
-
-	hairAsset.m_vertices		= new atcore_float3[hairAsset.m_numVertices];
-	hairAsset.m_endIndices = new NvUInt32[hairAsset.m_numGuideHairs];
-	hairAsset.m_faceIndices = new NvUInt32[meshDesc.m_NumTriangles * 3];
-	hairAsset.m_faceUvs		= new atcore_float2[meshDesc.m_NumTriangles * 3];
-
-	hairAsset.m_numBones		= numBones;
-	hairAsset.m_boneNames		= new NvChar[NV_HAIR_MAX_STRING * hairAsset.m_numBones];
-	hairAsset.m_bindPoses		= new atcore_float4x4[hairAsset.m_numBones];
-	hairAsset.m_boneParents	= new NvInt32[hairAsset.m_numBones];
-
-	if (pFbxSkin)
-		GetBoneData(pFbxSkin, pMeshNode, hairAsset.m_boneNames, hairAsset.m_bindPoses);
-	else
-	{
-		strcpy(hairAsset.m_boneNames, "Root");
-		gfsdk_makeIdentity(hairAsset.m_bindPoses[0]);
-		hairAsset.m_boneParents[0] = -1;
-	}
-
-	// copy vertex data
-	int vertexCnt = 0;
-
-	for (int i = 0; i < hairAsset.m_numGuideHairs; i++)
-	{
-		int oldHair = pHairToHairMap[i];
-
-		int oldRoot = (oldHair == 0) ? 0 : pEndIndices[oldHair-1]+1;
-		int oldTip	= pEndIndices[oldHair];
-
-		int offset = oldTip - oldRoot;
-
-		int newRoot = vertexCnt;
-		int newTip	= vertexCnt + offset;
-
-		vertexCnt += (offset + 1);
-
-		hairAsset.m_endIndices[i] = newTip;
-
-		int meshVertex = pHairToMeshMap[i];
-		atcore_float3 meshRoot = meshDesc.m_pVertices[meshVertex];
-		atcore_float3 hairRoot = pVertices[oldRoot];
-
-		atcore_float3 rootOffset = meshRoot - hairRoot;
-
-		for (int j = 0; j <= offset; j++)
-			hairAsset.m_vertices[newRoot + j] = pVertices[oldRoot + j] + rootOffset;
-
-		hairAsset.m_boneIndices[i] = gfsdk_makeFloat4(0,0,0,0);
-		hairAsset.m_boneWeights[i] = gfsdk_makeFloat4(1,0,0,0);
-
-		if (pFbxSkin)
-		{
-			hairAsset.m_boneIndices[i] = pMeshBoneIndices[meshVertex];
-			hairAsset.m_boneWeights[i] = pMeshBoneWeights[meshVertex];
-		}
-	}
-
-	// copy face indices and texture uvs
-	int faceCnt = 0;
-	for (int i = 0; i < meshDesc.m_NumTriangles; i++)
-	{
-		NvUInt32 i0 = meshDesc.m_pIndices[i * 3 + 0];
-		NvUInt32 i1 = meshDesc.m_pIndices[i * 3 + 1];
-		NvUInt32 i2 = meshDesc.m_pIndices[i * 3 + 2];
-
-		int h0 = pMeshToHairMap[i0];
-		int h1 = pMeshToHairMap[i1];
-		int h2 = pMeshToHairMap[i2];
-
-		if ((h0 < 0) || (h1 < 0) || (h2 < 0))
-			continue; // invalid face
-
-		hairAsset.m_faceIndices[ faceCnt * 3 + 0] = h0;
-		hairAsset.m_faceIndices[ faceCnt * 3 + 1] = h1;
-		hairAsset.m_faceIndices[ faceCnt * 3 + 2] = h2;
-
-		hairAsset.m_faceUvs[ faceCnt * 3 + 0 ] = meshDesc.m_pTexCoords[i * 3 + 0];
-		hairAsset.m_faceUvs[ faceCnt * 3 + 1 ] = meshDesc.m_pTexCoords[i * 3 + 1];
-		hairAsset.m_faceUvs[ faceCnt * 3 + 2 ] = meshDesc.m_pTexCoords[i * 3 + 2];
-
-		faceCnt++;
-	}
-
-	hairAsset.m_numFaces = faceCnt;
-
-	delete []pMeshBoneIndices;
-	delete []pMeshBoneWeights;
-
-	delete []pMeshToHairMap;
-	delete []pHairToMeshMap;
-	delete []pHairToHairMap;
-
-	return true;
-}
-*/
diff --git a/tools/ArtistTools/source/CoreLib/Anim/FbxUtil.h b/tools/ArtistTools/source/CoreLib/Anim/FbxUtil.h
deleted file mode 100644
index 5cbf18c..0000000
--- a/tools/ArtistTools/source/CoreLib/Anim/FbxUtil.h
+++ /dev/null
@@ -1,63 +0,0 @@
-// This code contains NVIDIA Confidential Information and is disclosed 
-// under the Mutual Non-Disclosure Agreement. 
-// 
-// Notice 
-// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES 
-// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO 
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT, 
-// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. 
-// 
-// NVIDIA Corporation assumes no responsibility for the consequences of use of such 
-// information or for any infringement of patents or other rights of third parties that may 
-// result from its use. No license is granted by implication or otherwise under any patent 
-// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless 
-// expressly authorized by NVIDIA.  Details are subject to change without notice. 
-// This code supersedes and replaces all information previously supplied. 
-// NVIDIA Corporation products are not authorized for use as critical 
-// components in life support devices or systems without express written approval of 
-// NVIDIA Corporation. 
-// 
-// Copyright (c) 2013 NVIDIA Corporation. All rights reserved.
-//
-// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
-// rights in and to this software and related documentation and any modifications thereto.
-// Any use, reproduction, disclosure or distribution of this software and related
-// documentation without an express license agreement from NVIDIA Corporation is
-// strictly prohibited.
-//
-#pragma once
-
-#include "AnimUtil.h"
-
-
-////////////////////////////////////////////////////////////////////////////////////////
-// Helper for fbx file load
-class CORELIB_EXPORT FbxUtil
-{
-public:
-
-	/// initialize fbx loader.  
-	static bool Initialize(const nvidia::Char* fbxFileName, nvidia::Float& fbxSceneUnit, float toScneUnit = 0.0f, bool bConvertUnit = true);
-	static bool Release(void);
-
-	static bool InitializeAnimationCache(AnimationCache& cache);
-
-	/// Get global frame range and fps information from fbx.
-	static bool GetGlobalSettings(nvidia::Float32* pStarfFrame = 0, nvidia::Float32* pEndFrame = 0, nvidia::Float32 *pFps = 0, int* upAxis = 0, char* rootBoneName = 0);
-
-	/// get skinning data from the mesh node
-	static bool InitializeSkinData( const nvidia::Char* meshName, SkinData& pSkinningDataToUpdate);
-
-	/// create mesh descriptor from fbx mesh node
-	static bool CreateMeshDescriptor(const nvidia::Char* meshName, MeshDesc &meshDesc);
-
-	/// get all the renderable meshes from the fbx scene
-	static bool GetMeshInfo(int* numMeshes, char** meshNames, char** parents, char** skinned);
-
-	/// get mesh material info from fbx scene
-	static bool GetMeshMaterials(const nvidia::Char* meshName, int *numMaterials, MeshMaterial** materials);
-
-	/// get hair directly from fbx
-//	static bool CreateHairFromFbx(const char* guideName, const char* growthMeshName, NvHair::AssetDescriptor &hairAsset);
-};
-