void CSParseFBXHandler()
{
// If only I could just do vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv :'(
//m_csFBXHandler = (CSFBXHandler)Marshal.PtrToStructure(m_cppFBXHandler, typeof(CSFBXHandler));
unsafe
{
CPPImportedFBXScene *tempFbxSCene = (CPPImportedFBXScene *)(((CPPFBXHandler *)m_cppFBXHandler.ToPointer())->m_fbxScene);
m_csFBXHandler.m_fbxScene.m_numberOfObjects = tempFbxSCene->m_numberOfObjects;
m_csFBXHandler.m_fbxScene.m_objects = new CSObject[tempFbxSCene->m_numberOfObjects];
CPPObject **sceneObjects = (CPPObject **)tempFbxSCene->m_objects;
m_unityGameObjects = new List <GameObject>((int)m_csFBXHandler.m_fbxScene.m_numberOfObjects);
for (uint currObjectIndex = 0; currObjectIndex < m_csFBXHandler.m_fbxScene.m_numberOfObjects; currObjectIndex++)
{
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex] = new CSObject(sceneObjects[currObjectIndex]->m_numberOfChildren, sceneObjects[currObjectIndex]->m_numberOfMaterials, Marshal.PtrToStringAnsi(sceneObjects[currObjectIndex]->m_name));
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_arrayIndexID = sceneObjects[currObjectIndex]->m_arrayIndexID;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_parentArrayIndexID = sceneObjects[currObjectIndex]->m_parentArrayIndexID;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_childrenArrayIndexIDs = new int[m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_numberOfChildren];
int *children = (int *)sceneObjects[currObjectIndex]->m_childrenArrayIndexIDs.ToPointer();
for (int currChildIndex = 0; currChildIndex < m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_numberOfChildren; currChildIndex++)
{
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_childrenArrayIndexIDs[currChildIndex] = children[currChildIndex];
}
CPPMesh *currentMesh = ((CPPMesh *)sceneObjects[currObjectIndex]->m_mesh.ToPointer());
GameObject unityGameObject = new GameObject();
m_unityGameObjects.Add(unityGameObject);
MeshFilter currMeshFilter = unityGameObject.AddComponent <MeshFilter>();
MeshRenderer currMeshRenderer = unityGameObject.AddComponent <MeshRenderer>();
unityGameObject.name = m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_name;
print("Object: " + m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_name + "\tMaterial Count: " + sceneObjects[currObjectIndex]->m_numberOfMaterials + "\tNumber of Children: " + sceneObjects[currObjectIndex]->m_numberOfChildren);
if (currentMesh->m_vertexCount > 0)
{
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh = new CSMesh(currentMesh->m_vertexCount, currentMesh->m_indexCount);
CMath.Vector3 *vertices = (CMath.Vector3 *)currentMesh->m_allVerticesPositions.ToPointer();
CMath.Vector3 *normals = (CMath.Vector3 *)currentMesh->m_normals.ToPointer();
CMath.Vector2 *uvs = (CMath.Vector2 *)currentMesh->m_uvs.ToPointer();
Vector3[] unityVerts = new Vector3[m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_vertexCount];
Vector3[] unityNormals = new Vector3[m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_vertexCount];
Vector2[] unityUVs = new Vector2[m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_vertexCount];
int[] unityIndices = new int[m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_indexCount];
for (uint currVertex = 0; currVertex < currentMesh->m_vertexCount; currVertex++)
{
unityVerts[currVertex].x = vertices[currVertex].x;
unityVerts[currVertex].y = vertices[currVertex].y;
unityVerts[currVertex].z = vertices[currVertex].z;
unityNormals[currVertex].x = normals[currVertex].x;
unityNormals[currVertex].y = normals[currVertex].y;
unityNormals[currVertex].z = normals[currVertex].z;
unityUVs[currVertex].x = uvs[currVertex].x;
unityUVs[currVertex].y = uvs[currVertex].y;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_allVerticesPositions[currVertex].x = vertices[currVertex].x;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_allVerticesPositions[currVertex].y = vertices[currVertex].y;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_allVerticesPositions[currVertex].z = vertices[currVertex].z;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_allVerticesNormals[currVertex].x = normals[currVertex].x;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_allVerticesNormals[currVertex].y = normals[currVertex].y;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_allVerticesNormals[currVertex].z = normals[currVertex].z;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_allVerticesUVs[currVertex].x = uvs[currVertex].x;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_allVerticesUVs[currVertex].y = uvs[currVertex].y;
}
uint *indices = (uint *)currentMesh->m_indices.ToPointer();
for (uint currIndex = 0; currIndex < currentMesh->m_indexCount; currIndex++)
{
unityIndices[currIndex] = (int)indices[currIndex];
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_mesh.m_indices[currIndex] = indices[currIndex];
}
currMeshFilter.mesh.vertices = unityVerts;
currMeshFilter.mesh.normals = unityNormals;
currMeshFilter.mesh.uv = unityUVs;
currMeshFilter.mesh.triangles = unityIndices;
}
if (sceneObjects[currObjectIndex]->m_numberOfMaterials > 0)
{
currMeshRenderer.materials = new Material[sceneObjects[currObjectIndex]->m_numberOfMaterials];
for (int currMaterialIndex = 0; currMaterialIndex < sceneObjects[currObjectIndex]->m_numberOfMaterials; currMaterialIndex++)
{
CPPMaterial **materials = (CPPMaterial **)sceneObjects[currObjectIndex]->m_materials.ToPointer();
currMeshRenderer.materials[currMaterialIndex].shader = Shader.Find("Standard");
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_materialType = materials[currMaterialIndex]->m_materialType;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_materialProperties = new CSMaterial.CSPropertyData[(int)CMaterialInfo.PropertyType.PROPERTYTYPE_COUNT];
if (materials[currMaterialIndex]->m_textureCount > 0)
{
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_textures = new Texture2D[materials[currMaterialIndex]->m_textureCount];
}
uint currentTextureIndex = 0;
for (int propertyIndex = 0; propertyIndex < (int)CMaterialInfo.PropertyType.PROPERTYTYPE_COUNT; propertyIndex++)
{
CPPMaterial.CPPPropertyData **propertyData = (CPPMaterial.CPPPropertyData * *)materials[currMaterialIndex]->m_materialProperties.ToPointer();
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_materialProperties[propertyIndex].m_propertyType = propertyData[propertyIndex]->m_propertyType;
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_materialProperties[propertyIndex].m_textureRelativeFileName = Marshal.PtrToStringAnsi(propertyData[propertyIndex]->m_textureRelativeFileName);
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_materialProperties[propertyIndex].m_textureAbsoluteFilePath = Marshal.PtrToStringAnsi(propertyData[propertyIndex]->m_textureAbsoluteFilePath);
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_materialProperties[propertyIndex].m_dataColorValues = propertyData[propertyIndex]->m_dataColorValues;
if (m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_materialProperties[propertyIndex].m_textureRelativeFileName != null ||
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_materialProperties[propertyIndex].m_textureAbsoluteFilePath != null)
{
m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_textures[currentTextureIndex] = LoadPNG(m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_materialProperties[propertyIndex].m_textureAbsoluteFilePath);
Color color;
color.r = propertyData[propertyIndex]->m_dataColorValues.x;
color.g = propertyData[propertyIndex]->m_dataColorValues.y;
color.b = propertyData[propertyIndex]->m_dataColorValues.z;
color.a = propertyData[propertyIndex]->m_dataColorValues.w;
switch (propertyData[propertyIndex]->m_propertyType)
{
case CMaterialInfo.PropertyType.PROPERTYTYPE_EMISSIVE:
{
currMeshRenderer.materials[currMaterialIndex].EnableKeyword("_EMISSION");
currMeshRenderer.materials[currMaterialIndex].SetTexture("_EmissionMap", m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_textures[currentTextureIndex]);
currMeshRenderer.materials[currMaterialIndex].SetColor("_EmissionColor", color);
}
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_AMBIENT:
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_DIFFUSE:
{
currMeshRenderer.materials[currMaterialIndex].EnableKeyword("_MainTex");
currMeshRenderer.materials[currMaterialIndex].SetTexture("_MainTex", m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_textures[currentTextureIndex]);
currMeshRenderer.materials[currMaterialIndex].SetColor("_MainTex", color);
}
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_NORMAL:
{
currMeshRenderer.materials[currMaterialIndex].EnableKeyword("_BumpMap");
currMeshRenderer.materials[currMaterialIndex].SetTexture("_BumpMap", m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_textures[currentTextureIndex]);
currMeshRenderer.materials[currMaterialIndex].SetFloat("_BumpScale", color.a);
}
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_BUMP:
{
currMeshRenderer.materials[currMaterialIndex].EnableKeyword("_BumpMap");
currMeshRenderer.materials[currMaterialIndex].SetTexture("_BumpMap", m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_textures[currentTextureIndex]);
currMeshRenderer.materials[currMaterialIndex].SetFloat("_BumpScale", color.a);
}
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_TRANSPARENCY:
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_DISPLACEMENT:
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_VECTOR_DISPLACEMENT:
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_SPECULAR:
{
currMeshRenderer.materials[currMaterialIndex].EnableKeyword("_METALLICGLOSSMAP");
currMeshRenderer.materials[currMaterialIndex].SetTexture("_MetallicGlossMap", m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_materials[currMaterialIndex].m_textures[currentTextureIndex]);
currMeshRenderer.materials[currMaterialIndex].SetFloat("Metallic", color.a);
}
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_SHININESS:
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_REFLECTION:
{
currMeshRenderer.materials[currMaterialIndex].EnableKeyword("_Glossiness");
currMeshRenderer.materials[currMaterialIndex].SetFloat("Smoothness", color.a);
}
break;
case CMaterialInfo.PropertyType.PROPERTYTYPE_COUNT:
break;
default:
break;
}
++currentTextureIndex;
}
}
}
}
}
for (uint currObjectIndex = 0; currObjectIndex < m_csFBXHandler.m_fbxScene.m_numberOfObjects; currObjectIndex++)
{
m_unityGameObjects[(int)currObjectIndex].transform.parent = m_unityGameObjects[(int)m_csFBXHandler.m_fbxScene.m_objects[currObjectIndex].m_parentArrayIndexID].transform;
}
m_unityGameObjects[0].transform.parent = m_unityObjectTransform;
}
}
private int CSLoadFBXFile(string _fbxFilePath)
{
int result = CPPDLLLoadMeshFromFBXFile(m_cppImportedFBXScene, _fbxFilePath);
int result2 = CPPDLLLoadMaterialFromFBXFile(m_cppImportedFBXScene, _fbxFilePath);
if (result == 0)
{
print("Incorrect file path");
return(0);
}
else if (result == 1)
{
m_csImportedFBXScene = (CSImportedFBXScene)Marshal.PtrToStructure(m_cppImportedFBXScene, typeof(CSImportedFBXScene));
m_csImportedFBXScene.m_mesh = (CSImportedFBXScene.CPPMesh)Marshal.PtrToStructure(m_csImportedFBXScene.m_CPPMeshPtr, typeof(CSImportedFBXScene.CPPMesh));
uint vertexCount = m_csImportedFBXScene.m_mesh.m_vertexCount;
uint indexCount = m_csImportedFBXScene.m_mesh.m_indexCount;
uint materialCount = m_csImportedFBXScene.m_mesh.m_materialCount;
m_csMesh.m_vertexCount = vertexCount;
m_csMesh.m_indexCount = indexCount;
m_csMesh.m_materialCount = materialCount;
if (vertexCount > 0)
{
m_csMesh.m_allVerticesPositions = new CSMesh.Vector3[vertexCount];
m_csMesh.m_indices = new uint[indexCount];
unsafe
{
CSMesh.Vector3 *vertices = (CSMesh.Vector3 *)m_csImportedFBXScene.m_mesh.m_allVerticesPositions.ToPointer();
if (vertices != null)
{
for (int i = 0; i < vertexCount; i++)
{
m_csMesh.m_allVerticesPositions[i].x = vertices[i].x;
m_csMesh.m_allVerticesPositions[i].y = vertices[i].y;
m_csMesh.m_allVerticesPositions[i].z = vertices[i].z;
}
}
else
{
print("The mesh VERTEX POSITION data did not get read properly.");
}
uint *indices = (uint *)m_csImportedFBXScene.m_mesh.m_indices.ToPointer();
if (indices != null)
{
for (int i = 0; i < indexCount; i++)
{
m_csMesh.m_indices[i] = indices[i];
}
}
else
{
print("The mesh INDICE data did not get read properly.");
}
CSMesh.Vector3 *normals = (CSMesh.Vector3 *)m_csImportedFBXScene.m_mesh.m_normals.ToPointer();
if (normals != null)
{
m_csMesh.m_allVerticesNormals = new CSMesh.Vector3[vertexCount];
for (int i = 0; i < vertexCount; i++)
{
m_csMesh.m_allVerticesNormals[i].x = normals[i].x;
m_csMesh.m_allVerticesNormals[i].y = normals[i].y;
m_csMesh.m_allVerticesNormals[i].z = normals[i].z;
}
}
else
{
print("This mesh did not have NORMALS");
}
CSMesh.Vector2 *uvs = (CSMesh.Vector2 *)m_csImportedFBXScene.m_mesh.m_uvs.ToPointer();
if (uvs != null)
{
m_csMesh.m_allVerticesUVs = new CSMesh.Vector2[vertexCount];
for (int i = 0; i < vertexCount; i++)
{
m_csMesh.m_allVerticesUVs[i].x = uvs[i].x;
m_csMesh.m_allVerticesUVs[i].y = uvs[i].y;
}
if (materialCount > 0)
{
m_csMesh.m_materials = new CSMaterial[materialCount];
m_meshRenderer.materials = new Material[materialCount];
CPPMaterial **materials = (CPPMaterial **)m_csImportedFBXScene.m_mesh.m_materials.ToPointer();
for (int i = 0; i < materialCount; i++)
{
m_meshRenderer.materials[i].shader = Shader.Find("Standard");
m_csMesh.m_materials[i].m_materialType = materials[i]->m_materialType;
m_csMesh.m_materials[i].m_materialProperties = new CSMaterial.PropertyData[(int)PropertyType.PROPERTYTYPE_COUNT];
if (materials[i]->m_textureCount > 0)
{
m_csMesh.m_materials[i].m_textures = new Texture2D[materials[i]->m_textureCount];
}
uint currentTextureIndex = 0;
for (int j = 0; j < (int)PropertyType.PROPERTYTYPE_COUNT; j++)
{
CPPMaterial.PropertyData **propertyData = (CPPMaterial.PropertyData * *)materials[i]->m_materialProperties.ToPointer();
m_csMesh.m_materials[i].m_materialProperties[j].m_propertyType = propertyData[j]->m_propertyType;
m_csMesh.m_materials[i].m_materialProperties[j].m_textureRelativeFileName = Marshal.PtrToStringAnsi(propertyData[j]->m_textureRelativeFileName);
m_csMesh.m_materials[i].m_materialProperties[j].m_textureAbsoluteFilePath = Marshal.PtrToStringAnsi(propertyData[j]->m_textureAbsoluteFilePath);
m_csMesh.m_materials[i].m_materialProperties[j].m_dataColorValues = propertyData[j]->m_dataColorValues;
if (m_csMesh.m_materials[i].m_materialProperties[j].m_textureRelativeFileName != null || m_csMesh.m_materials[i].m_materialProperties[j].m_textureAbsoluteFilePath != null)
{
m_csMesh.m_materials[i].m_textures[currentTextureIndex] = LoadPNG(m_csMesh.m_materials[i].m_materialProperties[j].m_textureAbsoluteFilePath);
Color color;
color.r = propertyData[j]->m_dataColorValues.x;
color.g = propertyData[j]->m_dataColorValues.y;
color.b = propertyData[j]->m_dataColorValues.z;
color.a = propertyData[j]->m_dataColorValues.w;
switch (propertyData[j]->m_propertyType)
{
case PropertyType.PROPERTYTYPE_EMISSIVE:
{
m_meshRenderer.materials[i].EnableKeyword("_EMISSION");
m_meshRenderer.materials[i].SetTexture("_EmissionMap", m_csMesh.m_materials[i].m_textures[currentTextureIndex]);
m_meshRenderer.materials[i].SetColor("_EmissionColor", color);
}
break;
case PropertyType.PROPERTYTYPE_AMBIENT:
break;
case PropertyType.PROPERTYTYPE_DIFFUSE:
{
m_meshRenderer.materials[i].EnableKeyword("_MainTex");
m_meshRenderer.materials[i].SetTexture("_MainTex", m_csMesh.m_materials[i].m_textures[currentTextureIndex]);
m_meshRenderer.materials[i].SetColor("_MainTex", color);
}
break;
case PropertyType.PROPERTYTYPE_NORMAL:
{
m_meshRenderer.materials[i].EnableKeyword("_BumpMap");
m_meshRenderer.materials[i].SetTexture("_BumpMap", m_csMesh.m_materials[i].m_textures[currentTextureIndex]);
m_meshRenderer.materials[i].SetFloat("_BumpScale", color.a);
}
break;
case PropertyType.PROPERTYTYPE_BUMP:
{
m_meshRenderer.materials[i].EnableKeyword("_BumpMap");
m_meshRenderer.materials[i].SetTexture("_BumpMap", m_csMesh.m_materials[i].m_textures[currentTextureIndex]);
m_meshRenderer.materials[i].SetFloat("_BumpScale", color.a);
}
break;
case PropertyType.PROPERTYTYPE_TRANSPARENCY:
break;
case PropertyType.PROPERTYTYPE_DISPLACEMENT:
break;
case PropertyType.PROPERTYTYPE_VECTOR_DISPLACEMENT:
break;
case PropertyType.PROPERTYTYPE_SPECULAR:
{
m_meshRenderer.materials[i].EnableKeyword("_METALLICGLOSSMAP");
m_meshRenderer.materials[i].SetTexture("_MetallicGlossMap", m_csMesh.m_materials[i].m_textures[currentTextureIndex]);
m_meshRenderer.materials[i].SetFloat("Metallic", color.a);
}
break;
case PropertyType.PROPERTYTYPE_SHININESS:
break;
case PropertyType.PROPERTYTYPE_REFLECTION:
{
m_meshRenderer.materials[i].EnableKeyword("_Glossiness");
m_meshRenderer.materials[i].SetFloat("Smoothness", color.a);
}
break;
case PropertyType.PROPERTYTYPE_COUNT:
break;
default:
break;
}
++currentTextureIndex;
}
}
}
}
if (materialCount == 1)
{
print("This mesh had 1 material.");
}
else
{
print("This mesh had " + materialCount + " materials.");
}
}
else
{
print("This mesh did not have UVS");
}
}
return(1);
}
// Return false if the file loaded but some of the mesh data was incorrect
return(-1);
}
else
{
return(result);
}
}
