FCDGeometryInstance* FCDPhysicsShape::CreateGeometryInstance(FCDGeometry* geom, bool createConvexMesh)
{
analGeom = NULL;
SAFE_RELEASE(geometry);
geometry = (FCDGeometryInstance*)FCDEntityInstanceFactory::CreateInstance(GetDocument(), NULL, FCDEntity::GEOMETRY);
if (createConvexMesh)
{
FCDGeometry* convexHullGeom = GetDocument()->GetGeometryLibrary()->AddEntity();
fm::string convexId = geom->GetDaeId()+"-convex";
convexHullGeom->SetDaeId(convexId);
convexHullGeom->SetName(FUStringConversion::ToFString(convexId));
FCDGeometryMesh* convexHullGeomMesh = convexHullGeom->CreateMesh();
convexHullGeomMesh->SetConvexHullOf(geom);
convexHullGeomMesh->SetConvex(true);
geometry->SetEntity(convexHullGeom);
}
else
{
geometry->SetEntity(geom);
}
SetNewChildFlag();
return geometry;
}
bool FArchiveXML::LoadGeometryInstance(FCDObject* object, xmlNode* instanceNode)
{
if (!FArchiveXML::LoadEntityInstance(object, instanceNode)) return false;
bool status = true;
FCDGeometryInstance* geometryInstance = (FCDGeometryInstance*)object;
// Look for the <bind_material> element. The others are discarded for now.
xmlNode* bindMaterialNode = FindChildByType(instanceNode, DAE_BINDMATERIAL_ELEMENT);
if (bindMaterialNode != NULL)
{
for (xmlNode* child = bindMaterialNode->children; child != NULL; child = child->next)
{
if (child->type != XML_ELEMENT_NODE) continue;
if (IsEquivalent(child->name, DAE_PARAMETER_ELEMENT))
{
FCDEffectParameter* parameter = geometryInstance->AddEffectParameter(FArchiveXML::GetEffectParameterType(child));
parameter->SetAnimator();
status &= FArchiveXML::LoadSwitch(parameter, ¶meter->GetObjectType(), child);
}
}
// Retrieve the list of the <technique_common><instance_material> elements.
xmlNode* techniqueNode = FindChildByType(bindMaterialNode, DAE_TECHNIQUE_COMMON_ELEMENT);
xmlNodeList materialNodes;
FindChildrenByType(techniqueNode, DAE_INSTANCE_MATERIAL_ELEMENT, materialNodes);
for (xmlNodeList::iterator itM = materialNodes.begin(); itM != materialNodes.end(); ++itM)
{
FCDMaterialInstance* material = geometryInstance->AddMaterialInstance();
status &= (FArchiveXML::LoadMaterialInstance(material, *itM));
}
}
else
{
// Blinding attempt to use the material semantic from the polygons as a material id.
FCDGeometry* geometry = (FCDGeometry*) geometryInstance->GetEntity();
if (geometry != NULL && geometry->HasType(FCDGeometry::GetClassType()) && geometry->IsMesh())
{
FCDGeometryMesh* mesh = geometry->GetMesh();
size_t polyCount = mesh->GetPolygonsCount();
for (size_t i = 0; i < polyCount; ++i)
{
FCDGeometryPolygons* polys = mesh->GetPolygons(i);
const fstring& semantic = polys->GetMaterialSemantic();
fm::string semanticUTF8 = TO_STRING(semantic);
semanticUTF8 = FCDObjectWithId::CleanId(semanticUTF8.c_str());
FCDMaterial* material = geometry->GetDocument()->FindMaterial(semanticUTF8);
if (material != NULL)
{
geometryInstance->AddMaterialInstance(material, polys);
}
}
}
}
geometryInstance->SetDirtyFlag();
return status;
}
void SketchUpModel::ReserveObject(Scene & Scene)
{
// Calculate the total triangle and line counts
m_TriangleCount = 0;
m_LineCount = 0;
size_t nMeshCount = m_pDocument->GetGeometryLibrary()->GetEntityCount();
for (size_t nMesh = 0; nMesh < nMeshCount; ++nMesh)
{
FCDGeometryMesh * pMesh = m_pDocument->GetGeometryLibrary()->GetEntity(nMesh)->GetMesh();
size_t nPolygonsCount = pMesh->GetPolygonsCount();
for (size_t nPolygon = 0; nPolygon < nPolygonsCount; ++nPolygon)
{
if (pMesh->GetPolygons(nPolygon)->IsTriangles())
{
size_t nTriangleCount = pMesh->GetPolygons(nPolygon)->GetFaceCount();
//float * pVertexData = pMesh->GetVertexSource(0)->GetData();
float * pVertexData = pMesh->GetPolygons(nPolygon)->GetInput(0)->GetSource()->GetData();
uint32 * pVertexIndicies = pMesh->GetPolygons(nPolygon)->GetInput(0)->GetIndices();
for (size_t nTriangle = 0; nTriangle < nTriangleCount; ++nTriangle)
{
// Check for degenerate (i.e. zero area) triangles
Wm5::Triangle3f Triangle(Wm5::Vector3f(pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 0], pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 1], pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 2]),
Wm5::Vector3f(pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 0], pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 1], pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 2]),
Wm5::Vector3f(pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 0], pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 1], pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 2]));
bool DegenerateTriangle = IsTriangleDegenerate(Triangle);
if (DegenerateTriangle) printf("Warning:\n \"%s\":\n Zero-area triangle %d found and ignored!\n", m_pDocument->GetFileUrl().c_str(), nTriangle);
else
++m_TriangleCount;
}
}
else if (FCDGeometryPolygons::PrimitiveType::LINES == pMesh->GetPolygons(nPolygon)->GetPrimitiveType())
{
size_t nLineCount = pMesh->GetPolygons(nPolygon)->GetInput(0)->GetIndexCount() / 2;
//float * pVertexData = pMesh->GetVertexSource(0)->GetData();
float * pVertexData = pMesh->GetPolygons(nPolygon)->GetInput(0)->GetSource()->GetData();
uint32 * pVertexIndicies = pMesh->GetPolygons(nPolygon)->GetInput(0)->GetIndices();
for (size_t nLine = 0; nLine < nLineCount; ++nLine)
{
// Check for degenerate (i.e. zero length) lines
// TODO: Finish that
if (false) printf("Warning:\n \"%s\":\n Zero-length line %d found and ignored!\n", m_pDocument->GetFileUrl().c_str(), nLine);
else
++m_LineCount;
}
}
}
}
Scene.ReserveObject(m_TriangleCount, m_LineCount);
}
static FCDGeometryPolygons* GetPolysFromGeometry(FCDGeometry* geom)
{
REQUIRE(geom->IsMesh(), "geometry is mesh");
FCDGeometryMesh* mesh = geom->GetMesh();
if (! mesh->IsTriangles())
FCDGeometryPolygonsTools::Triangulate(mesh);
REQUIRE(mesh->IsTriangles(), "mesh is made of triangles");
REQUIRE(mesh->GetPolygonsCount() == 1, "mesh has single set of polygons");
FCDGeometryPolygons* polys = mesh->GetPolygons(0);
REQUIRE(polys->FindInput(FUDaeGeometryInput::POSITION) != NULL, "mesh has vertex positions");
REQUIRE(polys->FindInput(FUDaeGeometryInput::NORMAL) != NULL, "mesh has vertex normals");
REQUIRE(polys->FindInput(FUDaeGeometryInput::TEXCOORD) != NULL, "mesh has vertex tex coords");
return polys;
}
void SketchUpModel::PopulateObject(Scene & Scene)
{
float * pEntireVertexData = new float[3 * 3 * m_TriangleCount];
float * pEntireNormalData = new float[3 * 3 * m_TriangleCount];
uint8 * pEntireColorData = new uint8[3 * 3 * m_TriangleCount];
float * pEntireLineVertexData = new float[3 * 3 * m_LineCount];
size_t nTriangleNumber = 0;
size_t nLineNumber = 0;
FCDSceneNode * pNode = m_pDocument->GetVisualSceneRoot();
size_t nMeshCount = m_pDocument->GetGeometryLibrary()->GetEntityCount();
for (size_t nMesh = 0; nMesh < nMeshCount; ++nMesh)
{
FCDGeometryMesh * pMesh = m_pDocument->GetGeometryLibrary()->GetEntity(nMesh)->GetMesh();
size_t nPolygonsCount = pMesh->GetPolygonsCount();
for (size_t nPolygon = 0; nPolygon < nPolygonsCount; ++nPolygon)
{
if (pMesh->GetPolygons(nPolygon)->IsTriangles())
{
size_t nTriangleCount = pMesh->GetPolygons(nPolygon)->GetFaceCount();
//float * pVertexData = pMesh->GetVertexSource(0)->GetData();
float * pVertexData = pMesh->GetPolygons(nPolygon)->GetInput(0)->GetSource()->GetData();
//float * pNormalData = pMesh->GetSource(1)->GetData();
float * pNormalData = pMesh->GetPolygons(nPolygon)->GetInput(1)->GetSource()->GetData();
uint32 * pVertexIndicies = pMesh->GetPolygons(nPolygon)->GetInput(0)->GetIndices();
uint32 * pNormalIndicies = pMesh->GetPolygons(nPolygon)->GetInput(1)->GetIndices();
//size_t d = pMesh->GetPolygons(nPolygon)->GetInputCount();
//printf("d = %d\n", d);
// Material info
FCDEffectStandard * effect = nullptr;
for (size_t nGeometryInstance = 0; nGeometryInstance < m_pDocument->GetVisualSceneLibrary()->GetEntity(0)->GetChild(0)->GetInstanceCount(); ++nGeometryInstance) {
if (pMesh->GetDaeId() == m_pDocument->GetVisualSceneLibrary()->GetEntity(0)->GetChild(0)->GetInstance(nGeometryInstance)->GetEntity()->GetDaeId()
&& FCDEntityInstance::Type::GEOMETRY == m_pDocument->GetVisualSceneLibrary()->GetEntity(0)->GetChild(0)->GetInstance(nGeometryInstance)->GetType()
&& 1 <= reinterpret_cast<FCDGeometryInstance *>(m_pDocument->GetVisualSceneLibrary()->GetEntity(0)->GetChild(0)->GetInstance(nGeometryInstance))->GetMaterialInstanceCount())
{
effect = dynamic_cast<FCDEffectStandard *>(reinterpret_cast<FCDGeometryInstance *>(m_pDocument->GetVisualSceneLibrary()->GetEntity(0)->GetChild(0)->GetInstance(nGeometryInstance))->GetMaterialInstance(0)->GetMaterial()->GetEffect()->GetProfile(0));
break;
}
}
//if (nullptr == effect) printf("no effect: mesh %d, poly %d\n", nMesh, nPolygon);
if (nullptr == effect) effect = dynamic_cast<FCDEffectStandard *>(m_pDocument->GetMaterialLibrary()->GetEntity(0)->GetEffect()->GetProfile(0));
//if (pMesh->GetSourceCount() != 3 || 1 != pMesh->GetVertexSourceCount())
// printf("wth %d source, %d vertex source\n", pMesh->GetSourceCount(), pMesh->GetVertexSourceCount());
/*size_t x = 0;
FCDEntityInstance * inst = nullptr;
if (pNode->GetChild(nMesh)->GetChildrenCount() == 0)
inst = pNode->GetChild(nMesh)->GetInstance(0);
else
inst = pNode->GetChild(nMesh)->GetChild(0)->GetInstance(0);
if (nMesh < 50) {
//printf("%d\n", x);
//printf("%s\n", inst->GetEntityReference()->GetObjectType().GetTypeName());
printf("%d: %s\n", nMesh, !pNode->GetChild(nMesh)->GetChildrenCount() ? pNode->GetChild(nMesh)->GetDaeId().c_str() : pNode->GetChild(nMesh)->GetChild(0)->GetDaeId().c_str());
printf(" %s\n", pMesh->GetPolygons(nPolygon)->GetMaterialSemantic().c_str());
for (size_t Material = 0; Material < m_pDocument->GetMaterialLibrary()->GetEntityCount(); ++Material)
{
if (m_pDocument->GetMaterialLibrary()->GetEntity(Material)->GetDaeId() == pMesh->GetPolygons(nPolygon)->GetMaterialSemantic())
{
FCDEffectStandard * standardProfile = dynamic_cast<FCDEffectStandard *>(m_pDocument->GetMaterialLibrary()->GetEntity(Material)->GetEffect()->GetProfile(0));
printf(" DiffuseColor().x = %f\n", standardProfile->GetDiffuseColor().x);
}
}
}*/
//printf("GetEffectParameterCount %d\n", m_pDocument->GetEffectLibrary()->GetEntity(400)->GetEffectParameterCount());
/*Wm5::Matrix4f oMatrix(pNode->GetChild(nMesh)->CalculateWorldTransform().m[0][0], pNode->GetChild(nMesh)->CalculateWorldTransform().m[0][1], pNode->GetChild(nMesh)->CalculateWorldTransform().m[0][2], pNode->GetChild(nMesh)->CalculateWorldTransform().m[0][3],
pNode->GetChild(nMesh)->CalculateWorldTransform().m[1][0], pNode->GetChild(nMesh)->CalculateWorldTransform().m[1][1], pNode->GetChild(nMesh)->CalculateWorldTransform().m[1][2], pNode->GetChild(nMesh)->CalculateWorldTransform().m[1][3],
pNode->GetChild(nMesh)->CalculateWorldTransform().m[2][0], pNode->GetChild(nMesh)->CalculateWorldTransform().m[2][1], pNode->GetChild(nMesh)->CalculateWorldTransform().m[2][2], pNode->GetChild(nMesh)->CalculateWorldTransform().m[2][3],
pNode->GetChild(nMesh)->CalculateWorldTransform().m[3][0], pNode->GetChild(nMesh)->CalculateWorldTransform().m[3][1], pNode->GetChild(nMesh)->CalculateWorldTransform().m[3][2], pNode->GetChild(nMesh)->CalculateWorldTransform().m[3][3]);
if (pNode->GetChild(nMesh)->GetChildrenCount() > 0) {
Wm5::Matrix4f oMatrix1(pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[0][0], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[0][1], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[0][2], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[0][3],
pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[1][0], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[1][1], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[1][2], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[1][3],
pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[2][0], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[2][1], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[2][2], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[2][3],
pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[3][0], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[3][1], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[3][2], pNode->GetChild(nMesh)->GetChild(0)->CalculateLocalTransform().m[3][3]);
oMatrix = oMatrix1 * oMatrix;
}*/
Wm5::Matrix4f oMatrix(Wm5::Matrix4f::IDENTITY);
if (fstring::npos != m_pDocument->GetAsset()->GetContributor(0)->GetAuthoringTool().find("Google SketchUp 8"))
for (uint8 i = 0; i < 3; ++i)
oMatrix[i][i] *= 0.4f;
for (size_t nTriangle = 0; nTriangle < nTriangleCount; ++nTriangle)
{
// Check for and skip degenerate (i.e. zero area) triangles
{
Wm5::Triangle3f Triangle(Wm5::Vector3f(pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 0], pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 1], pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 2]),
Wm5::Vector3f(pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 0], pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 1], pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 2]),
Wm5::Vector3f(pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 0], pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 1], pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 2]));
bool DegenerateTriangle = IsTriangleDegenerate(Triangle);
if (DegenerateTriangle)
continue;
}
#define PREAPPLYMATRIX
pEntireColorData[3 * 3 * nTriangleNumber + 0] = static_cast<uint8>(255.999 * effect->GetDiffuseColor().x);// + effect->GetAmbientColor().x - rand()%1000 * 0.0001f;//rand()%1000 * 0.001f;
pEntireColorData[3 * 3 * nTriangleNumber + 1] = static_cast<uint8>(255.999 * effect->GetDiffuseColor().y);// + effect->GetAmbientColor().y - rand()%1000 * 0.0001f;//rand()%1000 * 0.001f;
pEntireColorData[3 * 3 * nTriangleNumber + 2] = static_cast<uint8>(255.999 * effect->GetDiffuseColor().z);// + effect->GetAmbientColor().z - rand()%1000 * 0.0001f;//rand()%1000 * 0.001f;
#ifdef PREAPPLYMATRIX
{Wm5::Vector4f oPoint(pNormalData[3 * pNormalIndicies[3 * nTriangle + 0] + 0], pNormalData[3 * pNormalIndicies[3 * nTriangle + 0] + 1], pNormalData[3 * pNormalIndicies[3 * nTriangle + 0] + 2], 0); oPoint = oPoint * oMatrix; oPoint.Normalize();
pEntireNormalData[3 * 3 * nTriangleNumber + 0] = oPoint.X();
pEntireNormalData[3 * 3 * nTriangleNumber + 1] = oPoint.Y();
pEntireNormalData[3 * 3 * nTriangleNumber + 2] = oPoint.Z();}
Wm5::Vector4f oPoint1(pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 0], pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 1], pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 2], 1); oPoint1 = oPoint1 * oMatrix;
pEntireVertexData[3 * 3 * nTriangleNumber + 0] = oPoint1.X();
pEntireVertexData[3 * 3 * nTriangleNumber + 1] = oPoint1.Y();
pEntireVertexData[3 * 3 * nTriangleNumber + 2] = oPoint1.Z();
#else
pEntireNormalData[3 * 3 * nTriangleNumber + 0] = pNormalData[3 * pNormalIndicies[3 * nTriangle + 0] + 0];
pEntireNormalData[3 * 3 * nTriangleNumber + 1] = pNormalData[3 * pNormalIndicies[3 * nTriangle + 0] + 1];
pEntireNormalData[3 * 3 * nTriangleNumber + 2] = pNormalData[3 * pNormalIndicies[3 * nTriangle + 0] + 2];
pEntireVertexData[3 * 3 * nTriangleNumber + 0] = pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 0];
pEntireVertexData[3 * 3 * nTriangleNumber + 1] = pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 1];
pEntireVertexData[3 * 3 * nTriangleNumber + 2] = pVertexData[3 * pVertexIndicies[3 * nTriangle + 0] + 2];
#endif
pEntireColorData[3 * 3 * nTriangleNumber + 3] = static_cast<uint8>(255.999 * effect->GetDiffuseColor().x);// + effect->GetAmbientColor().x - rand()%1000 * 0.0001f;//rand()%1000 * 0.001f;
pEntireColorData[3 * 3 * nTriangleNumber + 4] = static_cast<uint8>(255.999 * effect->GetDiffuseColor().y);// + effect->GetAmbientColor().y - rand()%1000 * 0.0001f;//rand()%1000 * 0.001f;
pEntireColorData[3 * 3 * nTriangleNumber + 5] = static_cast<uint8>(255.999 * effect->GetDiffuseColor().z);// + effect->GetAmbientColor().z - rand()%1000 * 0.0001f;//rand()%1000 * 0.001f;
#ifdef PREAPPLYMATRIX
{Wm5::Vector4f oPoint(pNormalData[3 * pNormalIndicies[3 * nTriangle + 1] + 0], pNormalData[3 * pNormalIndicies[3 * nTriangle + 1] + 1], pNormalData[3 * pNormalIndicies[3 * nTriangle + 1] + 2], 0); oPoint = oPoint * oMatrix; oPoint.Normalize();
pEntireNormalData[3 * 3 * nTriangleNumber + 3] = oPoint.X();
pEntireNormalData[3 * 3 * nTriangleNumber + 4] = oPoint.Y();
pEntireNormalData[3 * 3 * nTriangleNumber + 5] = oPoint.Z();}
Wm5::Vector4f oPoint2(pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 0], pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 1], pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 2], 1); oPoint2 = oPoint2 * oMatrix;
pEntireVertexData[3 * 3 * nTriangleNumber + 3] = oPoint2.X();
pEntireVertexData[3 * 3 * nTriangleNumber + 4] = oPoint2.Y();
pEntireVertexData[3 * 3 * nTriangleNumber + 5] = oPoint2.Z();
#else
pEntireNormalData[3 * 3 * nTriangleNumber + 3] = pNormalData[3 * pNormalIndicies[3 * nTriangle + 1] + 0];
pEntireNormalData[3 * 3 * nTriangleNumber + 4] = pNormalData[3 * pNormalIndicies[3 * nTriangle + 1] + 1];
pEntireNormalData[3 * 3 * nTriangleNumber + 5] = pNormalData[3 * pNormalIndicies[3 * nTriangle + 1] + 2];
pEntireVertexData[3 * 3 * nTriangleNumber + 3] = pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 0];
pEntireVertexData[3 * 3 * nTriangleNumber + 4] = pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 1];
pEntireVertexData[3 * 3 * nTriangleNumber + 5] = pVertexData[3 * pVertexIndicies[3 * nTriangle + 1] + 2];
#endif
pEntireColorData[3 * 3 * nTriangleNumber + 6] = static_cast<uint8>(255.999 * effect->GetDiffuseColor().x);// + effect->GetAmbientColor().x - rand()%1000 * 0.0001f;//rand()%1000 * 0.001f;
pEntireColorData[3 * 3 * nTriangleNumber + 7] = static_cast<uint8>(255.999 * effect->GetDiffuseColor().y);// + effect->GetAmbientColor().y - rand()%1000 * 0.0001f;//rand()%1000 * 0.001f;
pEntireColorData[3 * 3 * nTriangleNumber + 8] = static_cast<uint8>(255.999 * effect->GetDiffuseColor().z);// + effect->GetAmbientColor().z - rand()%1000 * 0.0001f;//rand()%1000 * 0.001f;
#ifdef PREAPPLYMATRIX
{Wm5::Vector4f oPoint(pNormalData[3 * pNormalIndicies[3 * nTriangle + 2] + 0], pNormalData[3 * pNormalIndicies[3 * nTriangle + 2] + 1], pNormalData[3 * pNormalIndicies[3 * nTriangle + 2] + 2], 0); oPoint = oPoint * oMatrix; oPoint.Normalize();
pEntireNormalData[3 * 3 * nTriangleNumber + 6] = oPoint.X();
pEntireNormalData[3 * 3 * nTriangleNumber + 7] = oPoint.Y();
pEntireNormalData[3 * 3 * nTriangleNumber + 8] = oPoint.Z();}
Wm5::Vector4f oPoint3(pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 0], pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 1], pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 2], 1); oPoint3 = oPoint3 * oMatrix;
pEntireVertexData[3 * 3 * nTriangleNumber + 6] = oPoint3.X();
pEntireVertexData[3 * 3 * nTriangleNumber + 7] = oPoint3.Y();
pEntireVertexData[3 * 3 * nTriangleNumber + 8] = oPoint3.Z();
#else
pEntireNormalData[3 * 3 * nTriangleNumber + 6] = pNormalData[3 * pNormalIndicies[3 * nTriangle + 2] + 0];
pEntireNormalData[3 * 3 * nTriangleNumber + 7] = pNormalData[3 * pNormalIndicies[3 * nTriangle + 2] + 1];
pEntireNormalData[3 * 3 * nTriangleNumber + 8] = pNormalData[3 * pNormalIndicies[3 * nTriangle + 2] + 2];
pEntireVertexData[3 * 3 * nTriangleNumber + 6] = pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 0];
pEntireVertexData[3 * 3 * nTriangleNumber + 7] = pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 1];
pEntireVertexData[3 * 3 * nTriangleNumber + 8] = pVertexData[3 * pVertexIndicies[3 * nTriangle + 2] + 2];
#endif
++nTriangleNumber;
}
}
else if (FCDGeometryPolygons::PrimitiveType::LINES == pMesh->GetPolygons(nPolygon)->GetPrimitiveType())
{
size_t nLineCount = pMesh->GetPolygons(nPolygon)->GetInput(0)->GetIndexCount() / 2;
//float * pLineVertexData = pMesh->GetVertexSource(0)->GetData();
float * pLineVertexData = pMesh->GetPolygons(nPolygon)->GetInput(0)->GetSource()->GetData();
uint32 * pLineVertexIndicies = pMesh->GetPolygons(nPolygon)->GetInput(0)->GetIndices();
Wm5::Matrix4f oMatrix(Wm5::Matrix4f::IDENTITY);
if (fstring::npos != m_pDocument->GetAsset()->GetContributor(0)->GetAuthoringTool().find("Google SketchUp 8"))
for (uint8 i = 0; i < 3; ++i)
oMatrix[i][i] *= 0.4f;
for (size_t nLine = 0; nLine < nLineCount; ++nLine)
{
#ifdef PREAPPLYMATRIX
{Wm5::Vector4f oPoint(pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 0] + 0], pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 0] + 1], pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 0] + 2], 0); oPoint = oPoint * oMatrix;
pEntireLineVertexData[2 * 3 * nLineNumber + 0] = oPoint.X();
pEntireLineVertexData[2 * 3 * nLineNumber + 1] = oPoint.Y();
pEntireLineVertexData[2 * 3 * nLineNumber + 2] = oPoint.Z();}
{Wm5::Vector4f oPoint(pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 1] + 0], pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 1] + 1], pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 1] + 2], 0); oPoint = oPoint * oMatrix;
pEntireLineVertexData[2 * 3 * nLineNumber + 3] = oPoint.X();
pEntireLineVertexData[2 * 3 * nLineNumber + 4] = oPoint.Y();
pEntireLineVertexData[2 * 3 * nLineNumber + 5] = oPoint.Z();}
#else
pEntireLineVertexData[2 * 3 * nLineNumber + 0] = pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 0] + 0];
pEntireLineVertexData[2 * 3 * nLineNumber + 1] = pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 0] + 1];
pEntireLineVertexData[2 * 3 * nLineNumber + 2] = pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 0] + 2];
pEntireLineVertexData[2 * 3 * nLineNumber + 3] = pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 1] + 0];
pEntireLineVertexData[2 * 3 * nLineNumber + 4] = pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 1] + 1];
pEntireLineVertexData[2 * 3 * nLineNumber + 5] = pLineVertexData[3 * pLineVertexIndicies[2 * nLine + 1] + 2];
#endif
++nLineNumber;
}
}
}
}
// Populate Object
float * pVertexData, * pNormalData, * pTextureCoordData, * pLineVertexData;
uint8 * pColorData;
Scene.PopulateObjectPointers(pVertexData, pNormalData, pColorData, pTextureCoordData, pLineVertexData);
memcpy(pVertexData, pEntireVertexData, 3 * 3 * m_TriangleCount * sizeof(*pEntireVertexData));
memcpy(pNormalData, pEntireNormalData, 3 * 3 * m_TriangleCount * sizeof(*pEntireNormalData));
memcpy(pColorData, pEntireColorData, 3 * 3 * m_TriangleCount * sizeof(*pEntireColorData));
memset(pTextureCoordData, 0, 2 * 3 * m_TriangleCount * sizeof(*pTextureCoordData));
memcpy(pLineVertexData, pEntireLineVertexData, 2 * 3 * m_LineCount * sizeof(*pEntireLineVertexData));
Scene.PopulatedObject(m_TriangleCount, m_LineCount);
delete[] pEntireVertexData;
delete[] pEntireNormalData;
delete[] pEntireColorData;
delete[] pEntireLineVertexData;
}
bool CModelConverter::ReadDAE(const tstring& sFilename)
{
if (m_pWorkListener)
m_pWorkListener->BeginProgress();
FCollada::Initialize();
FCDocument* pDoc = FCollada::NewTopDocument();
if (m_pWorkListener)
m_pWorkListener->SetAction("Reading file", 0);
if (FCollada::LoadDocumentFromFile(pDoc, convert_to_fstring(sFilename)))
{
size_t i;
FCDocumentTools::StandardizeUpAxisAndLength(pDoc, FMVector3(0, 1, 0));
FCDMaterialLibrary* pMatLib = pDoc->GetMaterialLibrary();
size_t iEntities = pMatLib->GetEntityCount();
if (m_pWorkListener)
m_pWorkListener->SetAction("Reading materials", iEntities);
for (i = 0; i < iEntities; ++i)
{
FCDMaterial* pColladaMaterial = pMatLib->GetEntity(i);
FCDEffect* pEffect = pColladaMaterial->GetEffect();
size_t iMaterial = m_pScene->AddMaterial(convert_from_fstring(pColladaMaterial->GetName()));
CConversionMaterial* pMaterial = m_pScene->GetMaterial(iMaterial);
if (pEffect->GetProfileCount() < 1)
continue;
FCDEffectProfile* pEffectProfile = pEffect->GetProfile(0);
FUDaeProfileType::Type eProfileType = pEffectProfile->GetType();
if (eProfileType == FUDaeProfileType::COMMON)
{
FCDEffectStandard* pStandardProfile = dynamic_cast<FCDEffectStandard*>(pEffectProfile);
if (pStandardProfile)
{
pMaterial->m_vecAmbient = Vector((float*)pStandardProfile->GetAmbientColor());
pMaterial->m_vecDiffuse = Vector((float*)pStandardProfile->GetDiffuseColor());
pMaterial->m_vecSpecular = Vector((float*)pStandardProfile->GetSpecularColor());
pMaterial->m_vecEmissive = Vector((float*)pStandardProfile->GetEmissionColor());
pMaterial->m_flShininess = pStandardProfile->GetShininess();
}
}
for (size_t j = 0; j < pEffectProfile->GetEffectParameterCount(); j++)
{
FCDEffectParameter* pEffectParameter = pEffectProfile->GetEffectParameter(j);
FCDEffectParameter::Type eType = pEffectParameter->GetType();
if (eType == FCDEffectParameter::SAMPLER)
{
FCDEffectParameterSampler* pSampler = dynamic_cast<FCDEffectParameterSampler*>(pEffectParameter);
if (pSampler)
{
FCDEffectParameterSurface* pSurface = pSampler->GetSurface();
if (pSurface)
{
if (pSurface->GetImageCount())
{
// Christ Collada why do you have to make things so damn complicated?
FCDImage* pImage = pSurface->GetImage(0);
pMaterial->m_sDiffuseTexture = convert_from_fstring(pImage->GetFilename());
// Fix up a bug in the Max Collada exporter
if (pMaterial->m_sDiffuseTexture.startswith("\\\\C\\"))
pMaterial->m_sDiffuseTexture = "C:\\" + pMaterial->m_sDiffuseTexture.substr(4);
else if (pMaterial->m_sDiffuseTexture.startswith("\\\\D\\"))
pMaterial->m_sDiffuseTexture = "D:\\" + pMaterial->m_sDiffuseTexture.substr(4);
}
}
}
}
}
if (m_pWorkListener)
m_pWorkListener->WorkProgress(i+1);
}
FCDGeometryLibrary* pGeoLib = pDoc->GetGeometryLibrary();
iEntities = pGeoLib->GetEntityCount();
if (m_pWorkListener)
m_pWorkListener->SetAction("Loading entities", iEntities);
for (i = 0; i < iEntities; ++i)
{
FCDGeometry* pGeometry = pGeoLib->GetEntity(i);
if (pGeometry->IsMesh())
{
size_t j;
size_t iMesh = m_pScene->AddMesh(convert_from_fstring(pGeometry->GetName()));
CConversionMesh* pMesh = m_pScene->GetMesh(iMesh);
pMesh->AddBone(convert_from_fstring(pGeometry->GetName()));
FCDGeometryMesh* pGeoMesh = pGeometry->GetMesh();
FCDGeometrySource* pPositionSource = pGeoMesh->GetPositionSource();
size_t iVertexCount = pPositionSource->GetValueCount();
for (j = 0; j < iVertexCount; j++)
{
const float* pflValues = pPositionSource->GetValue(j);
pMesh->AddVertex(pflValues[0], pflValues[1], pflValues[2]);
}
FCDGeometrySource* pNormalSource = pGeoMesh->FindSourceByType(FUDaeGeometryInput::NORMAL);
if (pNormalSource)
{
iVertexCount = pNormalSource->GetValueCount();
for (j = 0; j < iVertexCount; j++)
{
const float* pflValues = pNormalSource->GetValue(j);
pMesh->AddNormal(pflValues[0], pflValues[1], pflValues[2]);
}
}
FCDGeometrySource* pUVSource = pGeoMesh->FindSourceByType(FUDaeGeometryInput::TEXCOORD);
if (pUVSource)
{
iVertexCount = pUVSource->GetValueCount();
for (j = 0; j < iVertexCount; j++)
{
const float* pflValues = pUVSource->GetValue(j);
pMesh->AddUV(pflValues[0], pflValues[1]);
}
}
for (j = 0; j < pGeoMesh->GetPolygonsCount(); j++)
{
FCDGeometryPolygons* pPolygons = pGeoMesh->GetPolygons(j);
FCDGeometryPolygonsInput* pPositionInput = pPolygons->FindInput(FUDaeGeometryInput::POSITION);
FCDGeometryPolygonsInput* pNormalInput = pPolygons->FindInput(FUDaeGeometryInput::NORMAL);
FCDGeometryPolygonsInput* pUVInput = pPolygons->FindInput(FUDaeGeometryInput::TEXCOORD);
size_t iPositionCount = pPositionInput->GetIndexCount();
uint32* pPositions = pPositionInput->GetIndices();
size_t iNormalCount = 0;
uint32* pNormals = NULL;
if (pNormalInput)
{
iNormalCount = pNormalInput->GetIndexCount();
pNormals = pNormalInput->GetIndices();
}
size_t iUVCount = 0;
uint32* pUVs = NULL;
if (pUVInput)
{
iUVCount = pUVInput->GetIndexCount();
pUVs = pUVInput->GetIndices();
}
fm::stringT<fchar> sMaterial = pPolygons->GetMaterialSemantic();
size_t iCurrentMaterial = pMesh->AddMaterialStub(convert_from_fstring(sMaterial));
if (pPolygons->TestPolyType() == 3)
{
// All triangles!
for (size_t k = 0; k < iPositionCount; k+=3)
{
size_t iFace = pMesh->AddFace(iCurrentMaterial);
pMesh->AddVertexToFace(iFace, pPositions[k+0], pUVs?pUVs[k+0]:~0, pNormals?pNormals[k+0]:~0);
pMesh->AddVertexToFace(iFace, pPositions[k+1], pUVs?pUVs[k+1]:~0, pNormals?pNormals[k+1]:~0);
pMesh->AddVertexToFace(iFace, pPositions[k+2], pUVs?pUVs[k+2]:~0, pNormals?pNormals[k+2]:~0);
}
}
else if (pPolygons->TestPolyType() == 4)
{
// All quads!
for (size_t k = 0; k < iPositionCount; k+=4)
{
size_t iFace = pMesh->AddFace(iCurrentMaterial);
pMesh->AddVertexToFace(iFace, pPositions[k+0], pUVs?pUVs[k+0]:~0, pNormals?pNormals[k+0]:~0);
pMesh->AddVertexToFace(iFace, pPositions[k+1], pUVs?pUVs[k+1]:~0, pNormals?pNormals[k+1]:~0);
pMesh->AddVertexToFace(iFace, pPositions[k+2], pUVs?pUVs[k+2]:~0, pNormals?pNormals[k+2]:~0);
pMesh->AddVertexToFace(iFace, pPositions[k+3], pUVs?pUVs[k+3]:~0, pNormals?pNormals[k+3]:~0);
}
}
else
{
size_t iFaces = pPolygons->GetFaceCount();
for (size_t k = 0; k < iFaces; k++)
{
size_t iFace = pMesh->AddFace(iCurrentMaterial);
size_t o = pPolygons->GetFaceVertexOffset(k);
size_t iFaceVertexCount = pPolygons->GetFaceVertexCount(k);
for (size_t v = 0; v < iFaceVertexCount; v++)
pMesh->AddVertexToFace(iFace, pPositions[o+v], pUVs?pUVs[o+v]:~0, pNormals?pNormals[o+v]:~0);
}
}
}
}
if (m_pWorkListener)
m_pWorkListener->WorkProgress(i+1);
}
FCDVisualSceneNodeLibrary* pVisualScenes = pDoc->GetVisualSceneLibrary();
iEntities = pVisualScenes->GetEntityCount();
for (i = 0; i < iEntities; ++i)
{
FCDSceneNode* pNode = pVisualScenes->GetEntity(i);
size_t iScene = m_pScene->AddScene(convert_from_fstring(pNode->GetName()));
ReadDAESceneTree(pNode, m_pScene->GetScene(iScene));
}
}
else
{
printf("Oops! Some kind of error happened!\n");
return false;
}
m_pScene->SetWorkListener(m_pWorkListener);
m_pScene->CalculateExtends();
for (size_t i = 0; i < m_pScene->GetNumMeshes(); i++)
{
if (m_bWantEdges)
m_pScene->GetMesh(i)->CalculateEdgeData();
if (m_pScene->GetMesh(i)->GetNumNormals() == 0)
m_pScene->GetMesh(i)->CalculateVertexNormals();
m_pScene->GetMesh(i)->CalculateVertexTangents();
}
pDoc->Release();
FCollada::Release();
if (m_pWorkListener)
m_pWorkListener->EndProgress();
return true;
}
void CModelConverter::SaveDAE(const tstring& sFilename)
{
if (m_pWorkListener)
m_pWorkListener->BeginProgress();
FCollada::Initialize();
FCDocument* pDoc = FCollada::NewTopDocument();
FCDocumentTools::StandardizeUpAxisAndLength(pDoc, FMVector3(0, 1, 0));
FCDAsset* pAsset = pDoc->GetAsset();
FCDAssetContributor* pContributor = pAsset->AddContributor();
pContributor->SetAuthoringTool(fstring_literal("Created by SMAK using FCollada"));
FCDMaterialLibrary* pMatLib = pDoc->GetMaterialLibrary();
if (m_pWorkListener)
m_pWorkListener->SetAction("Saving materials", m_pScene->GetNumMaterials());
for (size_t iMaterial = 0; iMaterial < m_pScene->GetNumMaterials(); iMaterial++)
{
CConversionMaterial* pConversionMaterial = m_pScene->GetMaterial(iMaterial);
FCDMaterial* pColladaMaterial = pMatLib->AddEntity();
pColladaMaterial->SetName(convert_to_fstring(pConversionMaterial->GetName()));
FCDEffect* pEffect = pMatLib->GetDocument()->GetEffectLibrary()->AddEntity();
pColladaMaterial->SetEffect(pEffect);
FCDEffectProfile* pEffectProfile = pEffect->AddProfile(FUDaeProfileType::COMMON);
pEffect->SetName(convert_to_fstring(pConversionMaterial->GetName()));
FCDEffectStandard* pStandardProfile = dynamic_cast<FCDEffectStandard*>(pEffectProfile);
if (pStandardProfile)
{
pStandardProfile->SetLightingType(FCDEffectStandard::PHONG);
pStandardProfile->SetAmbientColor(FMVector4(FMVector3((float*)pConversionMaterial->m_vecAmbient), 1));
pStandardProfile->SetDiffuseColor(FMVector4(FMVector3((float*)pConversionMaterial->m_vecDiffuse), 1));
pStandardProfile->SetSpecularColor(FMVector4(FMVector3((float*)pConversionMaterial->m_vecSpecular), 1));
pStandardProfile->SetEmissionColor(FMVector4(FMVector3((float*)pConversionMaterial->m_vecEmissive), 1));
pStandardProfile->SetShininess(pConversionMaterial->m_flShininess);
}
if (pConversionMaterial->GetDiffuseTexture().length())
{
FCDEffectParameter* pEffectParameterSampler = pEffectProfile->AddEffectParameter(FCDEffectParameter::SAMPLER);
FCDEffectParameter* pEffectParameterSurface = pEffectProfile->AddEffectParameter(FCDEffectParameter::SURFACE);
FCDEffectParameterSampler* pSampler = dynamic_cast<FCDEffectParameterSampler*>(pEffectParameterSampler);
FCDEffectParameterSurface* pSurface = dynamic_cast<FCDEffectParameterSurface*>(pEffectParameterSurface);
FCDImage* pSurfaceImage = pMatLib->GetDocument()->GetImageLibrary()->AddEntity();
pSurfaceImage->SetFilename(convert_to_fstring(pConversionMaterial->GetDiffuseTexture()));
pSurface->SetInitMethod(new FCDEffectParameterSurfaceInitFrom());
pSurface->AddImage(pSurfaceImage);
pSurface->SetReference((pConversionMaterial->GetName() + "-surface").c_str());
pSampler->SetSurface(pSurface);
}
if (m_pWorkListener)
m_pWorkListener->WorkProgress(iMaterial);
}
if (m_pWorkListener)
m_pWorkListener->SetAction("Saving geometry", m_pScene->GetNumMeshes());
FCDGeometryLibrary* pGeoLib = pDoc->GetGeometryLibrary();
for (size_t i = 0; i < m_pScene->GetNumMeshes(); ++i)
{
CConversionMesh* pConversionMesh = m_pScene->GetMesh(i);
FCDGeometry* pGeometry = pGeoLib->AddEntity();
pGeometry->SetName(convert_to_fstring(pConversionMesh->GetName()));
pGeometry->CreateMesh();
FCDGeometryMesh* pMesh = pGeometry->GetMesh();
FCDGeometrySource* pPositionSource = pMesh->AddSource(FUDaeGeometryInput::POSITION);
pPositionSource->SetName(convert_to_fstring(pConversionMesh->GetName() + "-position"));
pPositionSource->SetStride(3);
pPositionSource->SetValueCount(pConversionMesh->GetNumVertices());
for (size_t j = 0; j < pConversionMesh->GetNumVertices(); j++)
pPositionSource->SetValue(j, pConversionMesh->GetVertex(j));
pMesh->AddVertexSource(pPositionSource);
FCDGeometrySource* pNormalSource = pMesh->AddSource(FUDaeGeometryInput::NORMAL);
pNormalSource->SetName(convert_to_fstring(pConversionMesh->GetName() + "-normal"));
pNormalSource->SetStride(3);
pNormalSource->SetValueCount(pConversionMesh->GetNumNormals());
for (size_t j = 0; j < pConversionMesh->GetNumNormals(); j++)
pNormalSource->SetValue(j, pConversionMesh->GetNormal(j));
FCDGeometrySource* pUVSource = NULL;
if (pConversionMesh->GetNumUVs())
{
pUVSource = pMesh->AddSource(FUDaeGeometryInput::TEXCOORD);
pUVSource->SetName(convert_to_fstring(pConversionMesh->GetName() + "-texcoord"));
pUVSource->SetStride(2);
pUVSource->SetValueCount(pConversionMesh->GetNumUVs());
for (size_t j = 0; j < pConversionMesh->GetNumUVs(); j++)
pUVSource->SetValue(j, pConversionMesh->GetUV(j));
}
for (size_t iMaterials = 0; iMaterials < pConversionMesh->GetNumMaterialStubs(); iMaterials++)
{
CConversionMaterialStub* pStub = pConversionMesh->GetMaterialStub(iMaterials);
FCDGeometryPolygons* pPolygons = pMesh->AddPolygons();
pPolygons->SetMaterialSemantic(convert_to_fstring(pStub->GetName()));
pPolygons->AddInput(pPositionSource, 0);
pPolygons->AddInput(pNormalSource, 1);
if (pConversionMesh->GetNumUVs())
pPolygons->AddInput(pUVSource, 2);
FCDGeometryPolygonsInput* pPositionInput = pPolygons->FindInput(pPositionSource);
FCDGeometryPolygonsInput* pNormalInput = pPolygons->FindInput(pNormalSource);
FCDGeometryPolygonsInput* pUVInput = pPolygons->FindInput(pUVSource);
for (size_t iFace = 0; iFace < pConversionMesh->GetNumFaces(); iFace++)
{
CConversionFace* pFace = pConversionMesh->GetFace(iFace);
if (pFace->m != iMaterials)
continue;
pPolygons->AddFaceVertexCount(pFace->GetNumVertices());
for (size_t iVertex = 0; iVertex < pFace->GetNumVertices(); iVertex++)
{
pPositionInput->AddIndex(pFace->GetVertex(iVertex)->v);
pNormalInput->AddIndex(pFace->GetVertex(iVertex)->vn);
if (pConversionMesh->GetNumUVs())
pUVInput->AddIndex(pFace->GetVertex(iVertex)->vu);
}
}
}
if (m_pWorkListener)
m_pWorkListener->WorkProgress(i);
}
if (m_pWorkListener)
m_pWorkListener->SetAction("Saving scenes", m_pScene->GetNumScenes());
FCDVisualSceneNodeLibrary* pVisualScenes = pDoc->GetVisualSceneLibrary();
for (size_t i = 0; i < m_pScene->GetNumScenes(); ++i)
{
FCDSceneNode* pNode = pVisualScenes->AddEntity();
SaveDAEScene(pNode, m_pScene->GetScene(i));
if (m_pWorkListener)
m_pWorkListener->WorkProgress(i);
}
if (m_pWorkListener)
m_pWorkListener->SetAction("Writing to disk...", 0);
FCollada::SaveDocument(pDoc, convert_to_fstring(sFilename));
pDoc->Release();
FCollada::Release();
if (m_pWorkListener)
m_pWorkListener->EndProgress();
}
xmlNode* FArchiveXML::WriteGeometryMesh(FCDObject* object, xmlNode* parentNode)
{
FCDGeometryMesh* geometryMesh = (FCDGeometryMesh*)object;
xmlNode* meshNode = NULL;
if (geometryMesh->IsConvex() && !geometryMesh->GetConvexHullOf().empty())
{
meshNode = AddChild(parentNode, DAE_CONVEX_MESH_ELEMENT);
FUSStringBuilder convexHullOfName(geometryMesh->GetConvexHullOf());
AddAttribute(meshNode, DAE_CONVEX_HULL_OF_ATTRIBUTE, convexHullOfName);
}
else
{
meshNode = AddChild(parentNode, DAE_MESH_ELEMENT);
// Write out the sources
for (size_t i = 0; i < geometryMesh->GetSourceCount(); ++i)
{
FArchiveXML::LetWriteObject(geometryMesh->GetSource(i), meshNode);
}
// Write out the <vertices> element
xmlNode* verticesNode = AddChild(meshNode, DAE_VERTICES_ELEMENT);
xmlNode* verticesInputExtraNode = NULL,* verticesInputExtraTechniqueNode = NULL;
for (size_t i = 0; i < geometryMesh->GetVertexSourceCount(); ++i)
{
FCDGeometrySource* source = geometryMesh->GetVertexSource(i);
const char* semantic = FUDaeGeometryInput::ToString(source->GetType());
AddInput(verticesNode, source->GetDaeId(), semantic);
if (geometryMesh->GetPolygonsCount() > 0)
{
FCDGeometryPolygons* firstPolys = geometryMesh->GetPolygons(0);
FCDGeometryPolygonsInput* input = firstPolys->FindInput(source);
FUAssert(input != NULL, continue);
if (input->GetSet() != -1)
{
// We are interested in the set information, so if it is available, export it as an extra.
if (verticesInputExtraNode == NULL)
{
verticesInputExtraNode = FUXmlWriter::CreateNode(DAE_EXTRA_ELEMENT);
verticesInputExtraTechniqueNode = FUXmlWriter::AddChild(verticesInputExtraNode, DAE_TECHNIQUE_ELEMENT);
FUXmlWriter::AddAttribute(verticesInputExtraTechniqueNode, DAE_PROFILE_ATTRIBUTE, DAE_FCOLLADA_PROFILE);
}
AddInput(verticesInputExtraTechniqueNode, source->GetDaeId(), semantic, -1, input->GetSet());
}
}
}
if (verticesInputExtraNode != NULL) AddChild(verticesNode, verticesInputExtraNode);
FUSStringBuilder verticesNodeId(geometryMesh->GetDaeId());
verticesNodeId.append("-vertices");
AddAttribute(verticesNode, DAE_ID_ATTRIBUTE, verticesNodeId);
// Write out the polygons
for (size_t i = 0; i < geometryMesh->GetPolygonsCount(); ++i)
{
FArchiveXML::LetWriteObject(geometryMesh->GetPolygons(i), meshNode);
}
}
