void FBXModel::loadMeshes(KFbxNode* node, const GraphicsDevice& device, KFbxGeometryConverter& converter)
{
const char* name = node->GetName();
if (node->GetNodeAttribute())
{
KFbxNodeAttribute::EAttributeType attributeType = node->GetNodeAttribute()->GetAttributeType();
if (attributeType == KFbxNodeAttribute::eMESH)
{
KFbxMesh* kfbxMesh = converter.TriangulateMesh((KFbxMesh*)node->GetNodeAttribute());
VertexCollection vertices = getVertices(kfbxMesh);
MaterialCollection materials = getMaterials(device, node);
unsigned long numFaces = kfbxMesh->GetPolygonCount();
unsigned long numVertices = kfbxMesh->GetControlPointsCount();
Mesh mesh = Mesh::create(device, numFaces, numVertices, FBXVertex::vertexElements, D3DXMESH_MANAGED | D3DXMESH_32BIT);
mesh.getVertexBuffer().setData(vertices);
mesh.getIndexBuffer().setData(kfbxMesh->GetPolygonVertices(), kfbxMesh->GetPolygonVertexCount());
KFbxLayerElementArrayTemplate<int>* materialIndices;
kfbxMesh->GetMaterialIndices(&materialIndices);
unsigned long* buffer = mesh.lockAttributeBuffer();
for(int i = 0; i < kfbxMesh->GetPolygonCount(); ++i)
buffer[i] = materialIndices->GetAt(i);
mesh.unlockAttributeBuffer();
Mesh::Adjacency adjacency = mesh.generateAdjacency();
mesh.clean(D3DXCLEAN_SIMPLIFICATION, adjacency);
mesh.optimizeInplace(D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE, adjacency);
mesh.computeNormals(adjacency);
meshes[name] = FBXMesh(mesh, materials, name);
}
}
for (int i = 0; i < node->GetChildCount(); i++)
loadMeshes(node->GetChild(i), device, converter);
}
void Model::UpdateVertexBuffer( bool pstatic ) {
int total_verts = 0;
for( u32 mesh_index = 0; mesh_index < MeshNodes.size(); mesh_index++ ) {
KFbxMesh *mesh = MeshNodes[mesh_index]->GetMesh();
total_verts += mesh->GetPolygonVertexCount();
}
nvertices=total_verts;
Video::generic_vertex *vertices = new Video::generic_vertex[ total_verts ];
int vert_write = 0;
for( u32 mesh_index = 0; mesh_index < MeshNodes.size(); mesh_index++ ) {
KFbxMesh *mesh = MeshNodes[mesh_index]->GetMesh();
int cp_count = mesh->GetControlPointsCount();
KFbxVector4 *control_points = new KFbxVector4[cp_count];
memcpy(control_points, mesh->GetControlPoints(), cp_count * sizeof(KFbxVector4));
const int skin_count = mesh->GetDeformerCount(KFbxDeformer::eSKIN);
// deform mesh with animation
if( skin_count ) {
int cluster_count = 0;
for( int i = 0; i < skin_count; i++ ) {
cluster_count += ((KFbxSkin*)(mesh->GetDeformer(i, KFbxDeformer::eSKIN)))->GetClusterCount();
}
if( cluster_count){
ComputeSkinDeformation( mesh, AnimationCurrentTime, control_points, NULL );
}
}
// copy vertex data
int vcount = mesh->GetPolygonVertexCount();
int *vertex_index = mesh->GetPolygonVertices();
KStringList lUVNames;
mesh->GetUVSetNames(lUVNames);
for( int i = 0; i < vcount; i++ ) {
vertices[vert_write].x = control_points[ vertex_index[i] ][0];
vertices[vert_write].y = control_points[ vertex_index[i] ][2];
vertices[vert_write].z = control_points[ vertex_index[i] ][1];
KFbxVector2 uv;
mesh->GetPolygonVertexUV( i/3, i%3, lUVNames[0], uv );
vertices[vert_write].u = uv[0];
vertices[vert_write].v = -uv[1];
vertices[vert_write].r = vertices[vert_write].g = vertices[vert_write].b = 255;
vertices[vert_write].a = 255;
vert_write++;
}
}
// reverse vertex order
for( int i = 0; i < total_verts; i+= 3 ) {
Video::generic_vertex a;
a = vertices[i];
vertices[i] = vertices[i+2];
vertices[i+2] = a;
}
// update VBO
buffer.BufferData( vertices, total_verts * sizeof( Video::generic_vertex ), pstatic ? GL_STATIC_DRAW_ARB : GL_STREAM_DRAW_ARB );
delete[] vertices;
}
SceneObject* parseNode(KFbxNode *node, int level = 0) {
KString s = node->GetName();
KFbxNodeAttribute::EAttributeType attributeType;
stringstream ss;
for (int i=0;i<level;i++){
ss<<" ";
}
SceneObject* sceneObject = NULL;
MeshComponent* ga = NULL;
if (node->GetNodeAttribute() == NULL){
ss<<"No node attribute"<<endl;
} else {
attributeType = node->GetNodeAttribute()->GetAttributeType();
switch (attributeType) {
case KFbxNodeAttribute::eMARKER:
ss<<"eMarker"<<endl;
break;
case KFbxNodeAttribute::eSKELETON:
ss<<"eSkeleton"<<endl;
break;
case KFbxNodeAttribute::eMESH:
{
KFbxMesh *fbxMesh = node->GetMesh();
KFbxVector4 *controlPoints = fbxMesh->GetControlPoints();
int polygonCount = fbxMesh->GetPolygonCount();
vector<glm::vec3> vertices;
vector<glm::vec3> normals;
vector<glm::vec2> texCords;
vector<int> polycount;
assert(fbxMesh->GetLayerCount(KFbxLayerElement::eNORMAL)==1); // assume only one normal layer
KFbxLayer *normalLayer = fbxMesh->GetLayer(0, KFbxLayerElement::eNORMAL);
KFbxLayerElementNormal *normalElement = normalLayer->GetNormals();
KFbxLayerElementArrayTemplate<KFbxVector4> *normalArray = &(normalElement->GetDirectArray());
int normalCount = normalArray->GetCount();
vector<int> indices;
assert(fbxMesh->GetControlPointsCount() <= USHRT_MAX);
for (int i=0;i<fbxMesh->GetControlPointsCount();i++){
glm::vec3 v = toVector(controlPoints[i]);
vertices.push_back(v);
v = toVector(normalArray->GetAt(i));
normals.push_back(v);
}
for (int i=0;i<polygonCount;i++){
int polygonSize = fbxMesh->GetPolygonSize(i);
polycount.push_back(polygonSize);
for (int j=0;j<polygonSize;j++){
if (j>2){
// if polygon size > 2 then add first and last index
// this triangulates the mesh
int first = fbxMesh->GetPolygonVertex(i,0);
int last = fbxMesh->GetPolygonVertex(i,j-1);
indices.push_back(first);
indices.push_back(last);
}
int polygonIndex = fbxMesh->GetPolygonVertex(i,j);
indices.push_back(polygonIndex);
/*KFbxVector4 vectorSrc = controlPoints[polygonIndex];
Vector3 vectorDst = toVector(vectorSrc);
vertices.push_back(vectorDst);
texCords.push_back(Vector2(0,0));
KFbxVector4 normalSrc = normalArray->GetAt(polygonIndex);
Vector3 normalDst = toVector(normalSrc);
normals.push_back(normalDst);*/
}
}
Mesh mesh;
ss<<"Creating mesh: vertices "<<vertices.size()<<" normals "<<normals.size()<<" indices "<<indices.size()<<endl;
mesh.SetVertices(vertices);
mesh.SetNormals(normals);
mesh.SetIndices(indices);
sceneObject = new SceneObject();
ga = new MeshComponent();
ga->SetMesh(&mesh);
sceneObject->AddCompnent(ga);
// Set translate
fbxDouble3 v3 = node->LclTranslation.Get();
glm::vec3 translate = toVector(v3);
sceneObject->GetTransform()->SetPosition(translate);
// Set rotation
v3 = node->LclRotation.Get();
glm::vec3 rotation = toVector(v3)*Mathf::DEGREE_TO_RADIAN;
sceneObject->GetTransform()->SetRotation(rotation);
// Set scale
v3 = node->LclScaling.Get();
glm::vec3 scale = toVector(v3);
sceneObject->GetTransform()->SetScale(scale);
}
break;
case KFbxNodeAttribute::eCAMERA:
ss<<"eCAMERA"<<endl;
break;
case KFbxNodeAttribute::eLIGHT:
ss<<"eLIGHT"<<endl;
break;
case KFbxNodeAttribute::eBOUNDARY:
ss<<"eBOUNDARY"<<endl;
break;
default:
ss<<s<<endl;
}
}
if (node->GetChildCount()>0){
for (int i=0;i<node->GetChildCount();i++){
SceneObject *res = parseNode(node->GetChild(i),level+1);
if (res!=NULL){
if (sceneObject == NULL){
sceneObject = new SceneObject();
}
sceneObject->AddChild(res);
}
}
}
DEBUG(ss.str());
return sceneObject;
}