void FbxLoader::ComputeNodeMatrix(FbxNode* node, Node& meshNode, bool local)
{
if(!node)
return;
FbxAnimEvaluator* evaluator = scene->GetAnimationEvaluator();
FbxAMatrix global;
global.SetIdentity();
FbxTime time;
time.SetSecondDouble(0.0);
if(node != scene->GetRootNode()) {
if(local) {
global = evaluator->GetNodeLocalTransform(node, time);
}
else {
global = evaluator->GetNodeGlobalTransform(node, time);
}
}
auto T = global.GetT() * factor;
if(axismode == eLeftHanded) {
auto R = global.GetR();
R[1] *= -1; R[2] *= -1;
T[0] *= -1;
global.SetR(R);
}
global.SetT(T);
meshNode.matrix = Matrix(
(float)global[0][0], (float)global[0][1], (float)global[0][2], (float)global[0][3],
(float)global[1][0], (float)global[1][1], (float)global[1][2], (float)global[1][3],
(float)global[2][0], (float)global[2][1], (float)global[2][2], (float)global[2][3],
(float)global[3][0], (float)global[3][1], (float)global[3][2], (float)global[3][3]);
}
void FBXSceneEncoder::loadAnimations(FbxScene* fbxScene, const EncoderArguments& arguments)
{
FbxAnimEvaluator* evaluator = fbxScene->GetEvaluator();
if (!evaluator)
return;
FbxAnimStack* animStack = evaluator->GetContext();
if (!animStack)
return;
for (int i = 0; i < fbxScene->GetSrcObjectCount<FbxAnimStack>(); ++i)
{
FbxAnimStack* animStack = FbxCast<FbxAnimStack>(fbxScene->GetSrcObject<FbxAnimStack>(i));
int nbAnimLayers = animStack->GetMemberCount<FbxAnimLayer>();
for (int l = 0; l < nbAnimLayers; ++l)
{
FbxAnimLayer* animLayer = animStack->GetMember<FbxAnimLayer>(l);
loadAnimationLayer(animLayer, fbxScene->GetRootNode(), arguments);
}
}
}
void CFBXLoader::ComputeNodeMatrix(FbxNode* pNode, FBX_MESH_NODE* meshNode)
{
if(!pNode || !meshNode)
{
return ;
}
FbxAnimEvaluator* lEvaluator = mScene->GetAnimationEvaluator();
FbxMatrix lGlobal;
lGlobal.SetIdentity();
if(pNode != mScene->GetRootNode())
{
lGlobal= lEvaluator->GetNodeGlobalTransform(pNode);
FBXMatrixToFloat16( &lGlobal, meshNode->mat4x4 );
}
else
{
FBXMatrixToFloat16( &lGlobal, meshNode->mat4x4 );
}
}
void FbxParser::ProcessLight(FbxNode* pNode, std::vector<GS::Light*>& lights)
{
FbxLight* llight = (FbxLight*) pNode->GetNodeAttribute();
if (!llight)
return ;
// Get the light color.
FbxDouble3 c = llight->Color.Get();
GS::float4 lcolor( c[0], c[1], c[2], 1.0 );
float intensity = llight->Intensity.Get();
if (intensity)
lcolor= lcolor*(intensity/100);
// to do so far, we only process directional light
if (llight->LightType.Get() == FbxLight::eDirectional)
{
//FbxDouble3 dir = pNode->LclRotation.Get();
FbxAnimEvaluator* lEvaluator = mpFbxScene->GetAnimationEvaluator();
FbxAMatrix lGlobal;
lGlobal= lEvaluator->GetNodeGlobalTransform( pNode);
FbxVector4 rotation = lGlobal.GetR();
FbxVector4 tran = lGlobal.GetT();
FbxQuaternion quaternion = lGlobal.GetQ();
GS::float4 q(quaternion[0], quaternion[1], quaternion[2],quaternion[3]);
GS::float4x4 rotMat = GS::quat_rotation_matrix(q);
GS::float4 dir(mul(rotMat, GS::float4(0, 0, -1, 1)));
/* dir(0,0,-1);
FbxQuaternion quaternion = lGlobal.GetQ();
quaternion.
LcLRotation3f quaternion3f(quaternion[0], quaternion[1], quaternion[2], quaternion[3]);
LcLTransform3f rot3f(quaternion3f);
LcLVec3f rot_dir = dir * rot3f;*/
}
}
