bool FArchiveXML::LoadEntityInstance(FCDObject* object, xmlNode* instanceNode)
{
FCDEntityInstance* entityInstance = (FCDEntityInstance*)object;
bool status = true;
FUUri uri = ReadNodeUrl(instanceNode);
entityInstance->GetEntityReference()->SetUri(uri);
if (!entityInstance->IsExternalReference() && entityInstance->GetEntity() == NULL)
{
FUError::Error(FUError::WARNING_LEVEL, FUError::WARNING_INST_ENTITY_MISSING, instanceNode->line);
}
entityInstance->SetWantedSubId(TO_STRING(ReadNodeSid(instanceNode)));
entityInstance->SetName(TO_FSTRING(ReadNodeName(instanceNode)));
// Read in the extra nodes
xmlNodeList extraNodes;
FindChildrenByType(instanceNode, DAE_EXTRA_ELEMENT, extraNodes);
for (xmlNodeList::iterator it = extraNodes.begin(); it != extraNodes.end(); ++it)
{
xmlNode* extraNode = (*it);
FArchiveXML::LoadExtra(entityInstance->GetExtra(), extraNode);
}
entityInstance->SetDirtyFlag();
return status;
}
void ColladaScene::ExportScene(FCDSceneNode * fcdNode /* = 0 */, ColladaSceneNode * node /* = 0 */)
{
exportSceneLevel++;
if (fcdNode == 0)fcdNode = rootFCDNode;
if (node == 0)node = rootNode;
node->UpdateTransforms(0);
for (int i = 0; i < (int)fcdNode->GetInstanceCount(); ++i)
{
FCDEntityInstance* instance = fcdNode->GetInstance(i);
FCDEntity * entity = instance->GetEntity();
if (!entity) continue;
fm::string name = entity->GetDaeId();
for (int space = 0; space < exportSceneLevel; ++space)
printf(" ");
printf(" - instance: %s\n", name.c_str());
ColladaMesh * mesh = FindMeshWithName(name);
if (mesh)
{
ColladaMeshInstance * meshInstance = CreateMeshInstance(mesh, dynamic_cast<FCDGeometryInstance*>(instance), false);
//for (int space = 0; space < exportSceneLevel; ++space)
// printf(" ");
//printf(" - mesh: %s\n", name.c_str());
node->AddMeshInstance(meshInstance);
}
ColladaLight * light = FindLightWithName(name);
if (light)
{
//for (int space = 0; space < exportSceneLevel; ++space)
// printf(" ");
//printf(" - light: %s\n", name.c_str());
node->AddLight(light);
}
ColladaAnimatedMesh * aMesh = FindAnimatedMeshWithName(name);
if (aMesh)
{
FCDControllerInstance * controllerInstance = dynamic_cast<FCDControllerInstance*>(instance);
//for (int space = 0; space < exportSceneLevel; ++space)
// printf(" ");
//printf("- controller instance: %s\n", name.c_str());
if (aMesh->mesh)
{
ColladaMeshInstance * meshInstance = CreateMeshInstance(aMesh->mesh, dynamic_cast<FCDGeometryInstance*>(instance), true);
node->AddMeshInstance(meshInstance);
}
}
ColladaCamera * aCam = FindCameraWithName(name);
if (aCam)
{
node->AddCamera(aCam);
}
}
for (int i = 0; i < (int)fcdNode->GetChildrenCount(); i++)
{
FCDSceneNode * fcdChildNode = fcdNode->GetChild(i);
ColladaSceneNode * childNode = new ColladaSceneNode(this, fcdChildNode);
ExportScene(fcdChildNode, childNode);
node->AddNode(childNode);
}
exportSceneLevel--;
}
bool FArchiveXML::LoadPhysicsRigidBodyParameters(FCDPhysicsRigidBodyParameters* parameters, xmlNode* techniqueNode, FCDPhysicsRigidBodyParameters* defaultParameters)
{
bool status = true;
xmlNode* param = FindChildByType(techniqueNode, DAE_DYNAMIC_ELEMENT);
if (param)
{
parameters->SetDynamic(FUStringConversion::ToBoolean(ReadNodeContentDirect(param)));
FArchiveXML::LoadAnimatable(¶meters->GetDynamic(), param);
}
else if (defaultParameters != NULL)
{
parameters->SetDynamic(defaultParameters->GetDynamic() > 0.5f);
if (defaultParameters->GetDynamic().IsAnimated())
{
defaultParameters->GetDynamic().GetAnimated()->Clone(parameters->GetDynamic().GetAnimated());
}
}
xmlNode* massFrame;
massFrame = FindChildByType(techniqueNode, DAE_MASS_FRAME_ELEMENT);
if (massFrame)
{
param = FindChildByType(massFrame, DAE_TRANSLATE_ELEMENT);
if (param)
{
parameters->SetMassFrameTranslate(FUStringConversion::ToVector3(ReadNodeContentDirect(param)));
FArchiveXML::LoadAnimatable(¶meters->GetMassFrameTranslate(), param);
}
else if (defaultParameters != NULL)
{
parameters->SetMassFrameTranslate(defaultParameters->GetMassFrameTranslate());
if (defaultParameters->GetMassFrameTranslate().IsAnimated())
{
defaultParameters->GetMassFrameTranslate().GetAnimated()->Clone(parameters->GetMassFrameTranslate().GetAnimated());
}
}
else
{
// no movement
parameters->SetMassFrameTranslate(FMVector3::Zero);
}
param = FindChildByType(massFrame, DAE_ROTATE_ELEMENT);
if (param)
{
FMVector4 temp = FUStringConversion::ToVector4(ReadNodeContentDirect(param));
parameters->SetMassFrameOrientation(FMAngleAxis(FMVector3(temp.x, temp.y, temp.z), temp.w));
LoadAnimatable(¶meters->GetMassFrameOrientation(), param);
}
else if (defaultParameters != NULL)
{
parameters->SetMassFrameOrientation(defaultParameters->GetMassFrameOrientation());
if (defaultParameters->GetMassFrameOrientation().IsAnimated())
{
defaultParameters->GetMassFrameOrientation().GetAnimated()->Clone(parameters->GetMassFrameOrientation().GetAnimated());
}
}
else
{
// no movement
parameters->SetMassFrameOrientation(FMAngleAxis(FMVector3::XAxis, 0.0f));
}
}
else if (defaultParameters != NULL)
{
parameters->SetMassFrameTranslate(defaultParameters->GetMassFrameTranslate());
parameters->SetMassFrameOrientation(defaultParameters->GetMassFrameOrientation());
if (defaultParameters->GetMassFrameTranslate().IsAnimated())
{
defaultParameters->GetMassFrameTranslate().GetAnimated()->Clone(parameters->GetMassFrameTranslate().GetAnimated());
}
if (defaultParameters->GetMassFrameOrientation().IsAnimated())
{
defaultParameters->GetMassFrameOrientation().GetAnimated()->Clone(parameters->GetMassFrameOrientation().GetAnimated());
}
}
else
{
// no movement
parameters->SetMassFrameTranslate(FMVector3::Zero);
parameters->SetMassFrameOrientation(FMAngleAxis(FMVector3::XAxis, 0.0f));
}
xmlNodeList shapeNodes;
FindChildrenByType(techniqueNode, DAE_SHAPE_ELEMENT, shapeNodes);
if (shapeNodes.empty())
{
FUError::Error(FUError::WARNING_LEVEL, FUError::WARNING_SHAPE_NODE_MISSING, techniqueNode->line);
}
for (xmlNodeList::iterator itS = shapeNodes.begin(); itS != shapeNodes.end(); ++itS)
{
FCDPhysicsShape* shape = parameters->AddPhysicsShape();
status &= (FArchiveXML::LoadPhysicsShape(shape, *itS));
}
// shapes are not taken from the default parameters
param = FindChildByType(techniqueNode, DAE_PHYSICS_MATERIAL_ELEMENT);
if (param != NULL)
{
FCDPhysicsMaterial* material = parameters->AddOwnPhysicsMaterial();
FArchiveXML::LoadPhysicsMaterial(material, param);
}
else
{
param = FindChildByType(techniqueNode, DAE_INSTANCE_PHYSICS_MATERIAL_ELEMENT);
if (param != NULL)
{
FCDEntityInstance* physicsMaterialInstance = FCDEntityInstanceFactory::CreateInstance(parameters->GetDocument(), NULL, FCDEntity::PHYSICS_MATERIAL);
parameters->SetInstanceMaterial(physicsMaterialInstance);
FArchiveXML::LoadSwitch(physicsMaterialInstance, &physicsMaterialInstance->GetObjectType(), param);
FCDPhysicsMaterial* material = (FCDPhysicsMaterial*) physicsMaterialInstance->GetEntity();
if (material == NULL)
{
FUError::Error(FUError::ERROR_LEVEL, FUError::WARNING_MISSING_URI_TARGET, param->line);
}
parameters->SetPhysicsMaterial(material);
}
else
{
FUError::Error(FUError::WARNING_LEVEL, FUError::WARNING_PHYS_MAT_DEF_MISSING, techniqueNode->line);
}
}
// material is not taken fromt he default parameters
param = FindChildByType(techniqueNode, DAE_MASS_ELEMENT);
if (param)
{
parameters->SetMass(FUStringConversion::ToFloat(ReadNodeContentDirect(param)));
parameters->SetDensityMoreAccurate(false);
parameters->SetDensity(0.0f);
FArchiveXML::LoadAnimatable(¶meters->GetMass(), param);
}
else if (defaultParameters != NULL)
{
parameters->SetMass(defaultParameters->GetMass());
parameters->SetDensity(defaultParameters->GetDensity());
parameters->SetDensityMoreAccurate(defaultParameters->IsDensityMoreAccurate());
if (defaultParameters->GetMass().IsAnimated())
{
defaultParameters->GetMass().GetAnimated()->Clone(parameters->GetMass().GetAnimated());
}
}
else
{
/* Default value for mass is density x total shape volume, but
since our shape's mass is already calculated with respect to the
volume, we can just read it from there. If the user specified a
mass, then this overrides the calculation of density x volume,
as expected. */
parameters->SetMass(0.0f);
float totalDensity = 0.0f;
parameters->SetDensityMoreAccurate(false);
for (size_t i = 0; i < parameters->GetPhysicsShapeCount(); ++i)
{
FCDPhysicsShape* shape = parameters->GetPhysicsShape(i);
parameters->SetMass(parameters->GetMass() + shape->GetMass());
totalDensity += shape->GetDensity();
parameters->SetDensityMoreAccurate(parameters->IsDensityMoreAccurate() || shape->IsDensityMoreAccurate()); // common case: 1 shape, density = 1.0f
}
parameters->SetDensity(totalDensity / parameters->GetPhysicsShapeCount());
}
param = FindChildByType(techniqueNode, DAE_INERTIA_ELEMENT);
if (param)
{
parameters->SetInertia(FUStringConversion::ToVector3(ReadNodeContentDirect(param)));
parameters->SetInertiaAccurate(true);
FArchiveXML::LoadAnimatable(¶meters->GetInertia(), param);
}
else if (defaultParameters != NULL)
{
parameters->SetInertia(defaultParameters->GetInertia());
parameters->SetInertiaAccurate(defaultParameters->IsInertiaAccurate());
if (defaultParameters->GetInertia().IsAnimated())
{
defaultParameters->GetInertia().GetAnimated()->Clone(parameters->GetInertia().GetAnimated());
}
}
else
{
/* FIXME: Approximation: sphere shape, with mass distributed
equally across the volume and center of mass is at the center of
the sphere. Real moments of inertia call for complex
integration. Sphere it is simply I = k * m * r^2 on all axes. */
float volume = 0.0f;
for (size_t i = 0; i < parameters->GetPhysicsShapeCount(); ++i)
{
volume += parameters->GetPhysicsShape(i)->CalculateVolume();
}
float radiusCubed = 0.75f * volume / (float)FMath::Pi;
float I = 0.4f * parameters->GetMass() * pow(radiusCubed, 2.0f / 3.0f);
parameters->SetInertia(FMVector3(I, I, I));
parameters->SetInertiaAccurate(false);
}
return status;
}
