// 輸出檔案
int GmodelExp::DoExport(const TCHAR *name,ExpInterface *ei,Interface *i, BOOL suppressPrompts, DWORD options)
{
// Set a global prompt display switch
showPrompts = suppressPrompts ? FALSE : TRUE;
exportSelected = (options & SCENE_EXPORT_SELECTED) ? TRUE : FALSE;
// Grab the interface pointer.
ip = i;
if(showPrompts)
{
// Prompt the user with our dialogbox, and get all the options.
if (!DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_GMODELEXPORT_DLG),
ip->GetMAXHWnd(), ExportDlgProc, (LPARAM)this))
{
return 1;
}
}
// Open the stream
m_pFile = _tfopen(name,_T("wt"));
if ( !m_pFile )
{
return 0;
}
// Startup the progress bar.
ip->ProgressStart(GetString(IDS_PROGRESS_MSG), TRUE, fn, NULL);
// Get node & material list
BuildTable();
// Export file header
ExportHeader();
// Material
//if ( m_bExportMaterial )
ExportMaterial();
// Mesh
//if ( m_bExportMesh )
ExportMesh();
// Done :) Finish the progress bar.
ip->ProgressEnd();
// Close the stream
fclose(m_pFile);
return 1;
}
void Exporter::ExportGeomObject(INode* node, int indentLevel)
{
ObjectState os = node->EvalWorldState(GetStaticFrame());
if (!os.obj)
return;
// Targets are actually geomobjects, but we will export them
// from the camera and light objects, so we skip them here.
if (os.obj->ClassID() == Class_ID(TARGET_CLASS_ID, 0))
return;
ExportNodeHeader(node);
ExportNodeTM(node, indentLevel,&rsm->mesh->mat);
ExportMesh(node, GetStaticFrame(), indentLevel);
ExportMaterial(node, indentLevel);
}
void AWDExporter::PrepareMaterials(AWD *awd, awd_ncache *ncache)
{
if (!GetIncludeMtl()) {
return;
}
int numMtls = mtlList.Count();
//fprintf(pStream, "\t%s %d\n", ID_MATERIAL_COUNT, numMtls);
for (int i=0; i<numMtls; i++) {
ExportMaterial( awd, ncache, mtlList.GetMtl(i), i, -1);
}
//fprintf(pStream, "}\n");
}
void XsiExp::ExportMesh( INode * node, TimeValue t, int indentLevel)
{
ObjectState os = node->EvalWorldState(t);
if (!os.obj || os.obj->SuperClassID() != GEOMOBJECT_CLASS_ID)
{
return; // Safety net. This shouldn't happen.
}
BOOL needDel;
TriObject * tri = GetTriObjectFromNode(node, t, needDel);
if (!tri)
{
// no tri object
return;
}
// prepare mesh
Mesh * mesh = &tri->GetMesh();
mesh->buildNormals();
// object offset matrix; apply to verts
// swap y and z; max to soft correction
Matrix3 matrix(1);
// translate
matrix.PreTranslate( Point3( node->GetObjOffsetPos().x, node->GetObjOffsetPos().z, -node->GetObjOffsetPos().y));
// rotate
AngAxis aa( node->GetObjOffsetRot());
float temp = aa.axis.z;
aa.axis.z = -aa.axis.y;
aa.axis.y = temp;
PreRotateMatrix(matrix, Quat( aa));
// scale
ScaleValue scale = node->GetObjOffsetScale();
aa.Set( scale.q);
temp = aa.axis.z;
aa.axis.z = -aa.axis.y;
aa.axis.y = temp;
scale.q.Set( aa);
temp = scale.s.z;
scale.s.z = scale.s.y;
scale.s.y = temp;
ApplyScaling(matrix, scale);
// apply root transform
matrix = matrix * topMatrix;
// only rotation for normals
AffineParts ap;
Matrix3 rotMatrix(1);
decomp_affine( matrix, &ap);
PreRotateMatrix( rotMatrix, ap.q);
// set winding order
int vx1 = 0, vx2 = 1, vx3 = 2;
if (TMNegParity( node->GetNodeTM(GetStaticFrame())) != TMNegParity( matrix) )
{
// negative scaling; invert winding order and normal rotation
vx1 = 2; vx2 = 1; vx3 = 0;
rotMatrix = rotMatrix * Matrix3( Point3(-1,0,0), Point3(0,-1,0), Point3(0,0,-1), Point3(0,0,0));
}
// header
TSTR indent = GetIndent(indentLevel+1);
fprintf(pStream, "%s%s %s {\n",indent.data(), "Mesh", FixupName(node->GetName()));
// write number of verts
int numLoop = mesh->getNumVerts();
fprintf(pStream, "%s\t%d;\n",indent.data(), numLoop);
// write verts
for (int i = 0; i < numLoop; i++)
{
Point3 v = mesh->verts[i];
float temp = v.z;
v.z = -v.y;
v.y = temp;
v = matrix * v;
fprintf(pStream, "%s\t%.6f;%.6f;%.6f;%s\n", indent.data(), v.x, v.y, v.z,
i == numLoop - 1 ? ";\n" : ",");
}
// write number of faces
numLoop = mesh->getNumFaces();
fprintf(pStream, "%s\t%d;\n", indent.data(), numLoop);
// write faces
for (i = 0; i < numLoop; i++)
{
fprintf(pStream, "%s\t3;%d,%d,%d;%s\n",
indent.data(),
mesh->faces[i].v[vx1],
mesh->faces[i].v[vx2],
mesh->faces[i].v[vx3],
i == numLoop - 1 ? ";\n" : ",");
}
// face materials
Mtl * nodeMtl = node->GetMtl();
int numMtls = !nodeMtl || !nodeMtl->NumSubMtls() ? 1 : nodeMtl->NumSubMtls();
// write face material list header
fprintf(pStream, "%s\tMeshMaterialList {\n", indent.data());
// write number of materials
fprintf(pStream, "%s\t\t%d;\n", indent.data(), numMtls);
// write number of faces
fprintf(pStream, "%s\t\t%d;\n", indent.data(), numLoop);
// write face material indices (1 for each face)
for (i = 0; i < numLoop; i++)
{
int index = numMtls ? mesh->faces[i].getMatID() % numMtls : 0;
fprintf(pStream,"%s\t\t%d%s\n",
indent.data(),
index,
i == numLoop - 1 ? ";\n" : ",");
}
// write the materials
ExportMaterial( node, indentLevel+2);
// verts close brace
fprintf(pStream, "%s\t}\n\n",indent.data());
// write normals header
fprintf(pStream, "%s\t%s {\n", indent.data(), "SI_MeshNormals");
// write number of normals
fprintf(pStream, "%s\t\t%d;\n", indent.data(), numLoop * 3);
// write normals (3 for each face)
for (i = 0; i < numLoop; i++)
{
Face * f = &mesh->faces[i];
int vert = f->getVert(vx1);
Point3 vn = GetVertexNormal(mesh, i, mesh->getRVertPtr(vert));
float temp = vn.z;
vn.z = -vn.y;
vn.y = temp;
vn = rotMatrix * vn;
fprintf(pStream,"%s\t\t%.6f;%.6f;%.6f;,\n", indent.data(), vn.x, vn.y, vn.z);
vert = f->getVert(vx2);
vn = GetVertexNormal(mesh, i, mesh->getRVertPtr(vert));
temp = vn.z;
vn.z = -vn.y;
vn.y = temp;
vn = rotMatrix * vn;
fprintf(pStream,"%s\t\t%.6f;%.6f;%.6f;,\n", indent.data(), vn.x, vn.y, vn.z);
vert = f->getVert(vx3);
vn = GetVertexNormal(mesh, i, mesh->getRVertPtr(vert));
temp = vn.z;
vn.z = -vn.y;
vn.y = temp;
vn = rotMatrix * vn;
fprintf(pStream,"%s\t\t%.6f;%.6f;%.6f;%s\n", indent.data(), vn.x, vn.y, vn.z,
i == numLoop - 1 ? ";\n" : ",");
}
// write number of faces
fprintf(pStream, "%s\t\t%d;\n", indent.data(), numLoop);
// write faces
for (i = 0; i < numLoop; i++)
{
fprintf(pStream, "%s\t\t%d;3;%d,%d,%d;%s\n",
indent.data(),
i,
i * 3 + vx1, i * 3 + vx2, i * 3 + vx3,
i == numLoop - 1 ? ";\n" : ",");
}
// normals close brace
fprintf(pStream, "%s\t}\n\n",indent.data());
// texcoords
if (nodeMtl && mesh && (nodeMtl->Requirements(-1) & MTLREQ_FACEMAP))
{
// facemapping
numLoop = mesh->getNumFaces() * 3;
// write texture coords header
fprintf(pStream, "%s\tSI_MeshTextureCoords {\n", indent.data());
// write number of texture coords
fprintf(pStream, "%s\t\t%d;\n", indent.data(), numLoop);
// write texture coords
for (int i = 0; i < numLoop; i++)
{
Point3 tv[3];
Face * f = &mesh->faces[i];
make_face_uv( f, tv);
fprintf(pStream, "%s\t\t%.6f;%.6f;,\n", indent.data(), tv[0].x, tv[0].y);
fprintf(pStream, "%s\t\t%.6f;%.6f;,\n", indent.data(), tv[1].x, tv[1].y);
fprintf(pStream, "%s\t\t%.6f;%.6f;%s\n", indent.data(), tv[2].x, tv[2].y,
i == numLoop - 1 ? ";\n" : ",");
}
// write number of faces
numLoop = mesh->getNumFaces();
fprintf(pStream, "%s\t\t%d;\n", indent.data(), numLoop);
// write faces
for (i = 0; i < numLoop; i++)
{
fprintf(pStream,"%s\t\t%d;3;%d,%d,%d;%s\n",
indent.data(),
i,
mesh->tvFace[i].t[vx1],
mesh->tvFace[i].t[vx2],
mesh->tvFace[i].t[vx3],
i == numLoop - 1 ? ";\n" : ",");
}
// texture coords close brace
fprintf(pStream, "%s\t}\n\n", indent.data());
}
else
{
numLoop = mesh->getNumTVerts();
if (numLoop)
{
// write texture coords header
fprintf(pStream, "%s\tSI_MeshTextureCoords {\n", indent.data());
// write number of texture coords
fprintf(pStream, "%s\t\t%d;\n", indent.data(), numLoop);
// write texture coords
for (i = 0; i < numLoop; i++)
{
UVVert tv = mesh->tVerts[i];
fprintf(pStream, "%s\t\t%.6f;%.6f;%s\n", indent.data(), tv.x, tv.y,
i == numLoop - 1 ? ";\n" : ",");
}
// write number of faces
numLoop = mesh->getNumFaces();
fprintf(pStream, "%s\t\t%d;\n", indent.data(), numLoop);
// write faces
for (i = 0; i < numLoop; i++)
{
fprintf(pStream,"%s\t\t%d;3;%d,%d,%d;%s\n",
indent.data(),
i,
mesh->tvFace[i].t[vx1],
mesh->tvFace[i].t[vx2],
mesh->tvFace[i].t[vx3],
i == numLoop - 1 ? ";\n" : ",");
}
// texture coords close brace
fprintf(pStream, "%s\t}\n\n", indent.data());
}
}
/*
// Export color per vertex info
if (GetIncludeVertexColors()) {
int numCVx = mesh->numCVerts;
fprintf(pStream, "%s\t%s %d\n",indent.data(), ID_MESH_NUMCVERTEX, numCVx);
if (numCVx) {
fprintf(pStream,"%s\t%s {\n",indent.data(), ID_MESH_CVERTLIST);
for (i=0; i<numCVx; i++) {
Point3 vc = mesh->vertCol[i];
fprintf(pStream, "%s\t\t%s %d\t%s\n",indent.data(), ID_MESH_VERTCOL, i, Format(vc));
}
fprintf(pStream,"%s\t}\n",indent.data());
fprintf(pStream, "%s\t%s %d\n",indent.data(), ID_MESH_NUMCVFACES, mesh->getNumFaces());
fprintf(pStream, "%s\t%s {\n",indent.data(), ID_MESH_CFACELIST);
for (i=0; i<mesh->getNumFaces(); i++) {
fprintf(pStream,"%s\t\t%s %d\t%d\t%d\t%d\n",
indent.data(),
ID_MESH_CFACE, i,
mesh->vcFace[i].t[vx1],
mesh->vcFace[i].t[vx2],
mesh->vcFace[i].t[vx3]);
}
fprintf(pStream, "%s\t}\n",indent.data());
}
}
*/
// Mesh close brace
fprintf(pStream, "%s}\n",indent.data());
// dispose of tri object
if (needDel)
{
delete tri;
}
}
static void ExportMeshLod(ExportContext& Context, const CBaseMeshLod& Lod, const CMeshVertex* Verts, FArchive& Ar, FArchive& Ar2)
{
guard(ExportMeshLod);
// Opening brace
Ar.Printf("{\n");
// Asset
Ar.Printf(
" \"asset\" : {\n"
" \"generator\" : \"UE Viewer (umodel) build %s\",\n"
" \"version\" : \"2.0\"\n"
" },\n",
STR(GIT_REVISION));
// Scene
Ar.Printf(
" \"scene\" : 0,\n"
" \"scenes\" : [\n"
" {\n"
" \"nodes\" : [ 0 ]\n"
" }\n"
" ],\n"
);
// Nodes
if (!Context.IsSkeletal())
{
Ar.Printf(
" \"nodes\" : [\n"
" {\n"
" \"name\" : \"%s\",\n"
" \"mesh\" : 0\n"
" }\n"
" ],\n",
Context.MeshName
);
}
else
{
ExportSkinData(Context, static_cast<const CSkelMeshLod&>(Lod), Ar);
}
// Materials
Ar.Printf(" \"materials\" : [\n");
for (int i = 0; i < Lod.Sections.Num(); i++)
{
ExportMaterial(Lod.Sections[i].Material, Ar, i, i == Lod.Sections.Num() - 1);
}
Ar.Printf(" ],\n");
// Meshes
Ar.Printf(
" \"meshes\" : [\n"
" {\n"
" \"primitives\" : [\n"
);
for (int i = 0; i < Lod.Sections.Num(); i++)
{
ExportSection(Context, Lod, Verts, i, Ar);
}
Ar.Printf(
" ],\n"
" \"name\" : \"%s\"\n"
" }\n"
" ],\n",
Context.MeshName
);
// Write animations
if (Context.IsSkeletal() && Context.SkelMesh->Anim)
{
ExportAnimations(Context, Ar);
}
// Write buffers
int bufferLength = 0;
for (int i = 0; i < Context.Data.Num(); i++)
{
bufferLength += Context.Data[i].DataSize;
}
Ar.Printf(
" \"buffers\" : [\n"
" {\n"
" \"uri\" : \"%s.bin\",\n"
" \"byteLength\" : %d\n"
" }\n"
" ],\n",
Context.MeshName, bufferLength
);
// Write bufferViews
Ar.Printf(
" \"bufferViews\" : [\n"
);
int bufferOffset = 0;
for (int i = 0; i < Context.Data.Num(); i++)
{
const BufferData& B = Context.Data[i];
Ar.Printf(
" {\n"
" \"buffer\" : 0,\n"
" \"byteOffset\" : %d,\n"
" \"byteLength\" : %d\n"
" }%s\n",
bufferOffset,
B.DataSize,
i == (Context.Data.Num()-1) ? "" : ","
);
bufferOffset += B.DataSize;
}
Ar.Printf(
" ],\n"
);
// Write accessors
Ar.Printf(
" \"accessors\" : [\n"
);
for (int i = 0; i < Context.Data.Num(); i++)
{
const BufferData& B = Context.Data[i];
Ar.Printf(
" {\n"
" \"bufferView\" : %d,\n",
i
);
if (B.bNormalized)
{
Ar.Printf(" \"normalized\" : true,\n");
}
if (B.BoundsMin.Len())
{
Ar.Printf(
" \"min\" : %s,\n"
" \"max\" : %s,\n",
*B.BoundsMin, *B.BoundsMax
);
}
Ar.Printf(
" \"componentType\" : %d,\n"
" \"count\" : %d,\n"
" \"type\" : \"%s\"\n"
" }%s\n",
B.ComponentType,
B.Count,
B.Type,
i == (Context.Data.Num()-1) ? "" : ","
);
}
Ar.Printf(
" ]\n"
);
// Write binary data
guard(WriteBIN);
for (int i = 0; i < Context.Data.Num(); i++)
{
const BufferData& B = Context.Data[i];
#if MAX_DEBUG
assert(B.FillCount == B.Count);
#endif
Ar2.Serialize(B.Data, B.DataSize);
}
unguard;
// Closing brace
Ar.Printf("}\n");
unguard;
}
/**
* Adds an Fbx Mesh to the FBX scene based on the data in the given FStaticLODModel
*/
FbxNode* FFbxExporter::CreateMesh(const USkeletalMesh* SkelMesh, const TCHAR* MeshName)
{
const FSkeletalMeshResource* SkelMeshResource = SkelMesh->GetImportedResource();
const FStaticLODModel& SourceModel = SkelMeshResource->LODModels[0];
const int32 VertexCount = SourceModel.NumVertices;
// Verify the integrity of the mesh.
if (VertexCount == 0) return NULL;
// Copy all the vertex data from the various chunks to a single buffer.
// Makes the rest of the code in this function cleaner and easier to maintain.
TArray<FSoftSkinVertex> Vertices;
SourceModel.GetVertices(Vertices);
if (Vertices.Num() != VertexCount) return NULL;
FbxMesh* Mesh = FbxMesh::Create(Scene, TCHAR_TO_UTF8(MeshName));
// Create and fill in the vertex position data source.
Mesh->InitControlPoints(VertexCount);
FbxVector4* ControlPoints = Mesh->GetControlPoints();
for (int32 VertIndex = 0; VertIndex < VertexCount; ++VertIndex)
{
FVector Position = Vertices[VertIndex].Position;
ControlPoints[VertIndex] = Converter.ConvertToFbxPos(Position);
}
// Create Layer 0 to hold the normals
FbxLayer* LayerZero = Mesh->GetLayer(0);
if (LayerZero == NULL)
{
Mesh->CreateLayer();
LayerZero = Mesh->GetLayer(0);
}
// Create and fill in the per-face-vertex normal data source.
// We extract the Z-tangent and drop the X/Y-tangents which are also stored in the render mesh.
FbxLayerElementNormal* LayerElementNormal= FbxLayerElementNormal::Create(Mesh, "");
LayerElementNormal->SetMappingMode(FbxLayerElement::eByControlPoint);
// Set the normal values for every control point.
LayerElementNormal->SetReferenceMode(FbxLayerElement::eDirect);
for (int32 VertIndex = 0; VertIndex < VertexCount; ++VertIndex)
{
FVector Normal = Vertices[VertIndex].TangentZ;
FbxVector4 FbxNormal = Converter.ConvertToFbxPos(Normal);
LayerElementNormal->GetDirectArray().Add(FbxNormal);
}
LayerZero->SetNormals(LayerElementNormal);
// Create and fill in the per-face-vertex texture coordinate data source(s).
// Create UV for Diffuse channel.
const int32 TexCoordSourceCount = SourceModel.NumTexCoords;
TCHAR UVChannelName[32];
for (int32 TexCoordSourceIndex = 0; TexCoordSourceIndex < TexCoordSourceCount; ++TexCoordSourceIndex)
{
FbxLayer* Layer = Mesh->GetLayer(TexCoordSourceIndex);
if (Layer == NULL)
{
Mesh->CreateLayer();
Layer = Mesh->GetLayer(TexCoordSourceIndex);
}
if (TexCoordSourceIndex == 1)
{
FCString::Sprintf(UVChannelName, TEXT("LightMapUV"));
}
else
{
FCString::Sprintf(UVChannelName, TEXT("DiffuseUV"));
}
FbxLayerElementUV* UVDiffuseLayer = FbxLayerElementUV::Create(Mesh, TCHAR_TO_UTF8(UVChannelName));
UVDiffuseLayer->SetMappingMode(FbxLayerElement::eByControlPoint);
UVDiffuseLayer->SetReferenceMode(FbxLayerElement::eDirect);
// Create the texture coordinate data source.
for (int32 TexCoordIndex = 0; TexCoordIndex < VertexCount; ++TexCoordIndex)
{
const FVector2D& TexCoord = Vertices[TexCoordIndex].UVs[TexCoordSourceIndex];
UVDiffuseLayer->GetDirectArray().Add(FbxVector2(TexCoord.X, -TexCoord.Y + 1.0));
}
Layer->SetUVs(UVDiffuseLayer, FbxLayerElement::eTextureDiffuse);
}
FbxLayerElementMaterial* MatLayer = FbxLayerElementMaterial::Create(Mesh, "");
MatLayer->SetMappingMode(FbxLayerElement::eByPolygon);
MatLayer->SetReferenceMode(FbxLayerElement::eIndexToDirect);
LayerZero->SetMaterials(MatLayer);
// Create the per-material polygons sets.
TArray<uint32> Indices;
SourceModel.MultiSizeIndexContainer.GetIndexBuffer(Indices);
int32 SectionCount = SourceModel.Sections.Num();
for (int32 SectionIndex = 0; SectionIndex < SectionCount; ++SectionIndex)
{
const FSkelMeshSection& Section = SourceModel.Sections[SectionIndex];
int32 MatIndex = Section.MaterialIndex;
// Static meshes contain one triangle list per element.
int32 TriangleCount = Section.NumTriangles;
// Copy over the index buffer into the FBX polygons set.
for (int32 TriangleIndex = 0; TriangleIndex < TriangleCount; ++TriangleIndex)
{
Mesh->BeginPolygon(MatIndex);
for (int32 PointIndex = 0; PointIndex < 3; PointIndex++)
{
Mesh->AddPolygon(Indices[Section.BaseIndex + ((TriangleIndex * 3) + PointIndex)]);
}
Mesh->EndPolygon();
}
}
// Create and fill in the vertex color data source.
FbxLayerElementVertexColor* VertexColor = FbxLayerElementVertexColor::Create(Mesh, "");
VertexColor->SetMappingMode(FbxLayerElement::eByControlPoint);
VertexColor->SetReferenceMode(FbxLayerElement::eDirect);
FbxLayerElementArrayTemplate<FbxColor>& VertexColorArray = VertexColor->GetDirectArray();
LayerZero->SetVertexColors(VertexColor);
for (int32 VertIndex = 0; VertIndex < VertexCount; ++VertIndex)
{
FLinearColor VertColor = Vertices[VertIndex].Color.ReinterpretAsLinear();
VertexColorArray.Add( FbxColor(VertColor.R, VertColor.G, VertColor.B, VertColor.A ));
}
FbxNode* MeshNode = FbxNode::Create(Scene, TCHAR_TO_UTF8(MeshName));
MeshNode->SetNodeAttribute(Mesh);
// Add the materials for the mesh
int32 MaterialCount = SkelMesh->Materials.Num();
for(int32 MaterialIndex = 0; MaterialIndex < MaterialCount; ++MaterialIndex)
{
UMaterialInterface* MatInterface = SkelMesh->Materials[MaterialIndex].MaterialInterface;
FbxSurfaceMaterial* FbxMaterial = NULL;
if(MatInterface && !FbxMaterials.Find(MatInterface))
{
FbxMaterial = ExportMaterial(MatInterface);
}
else
{
// Note: The vertex data relies on there being a set number of Materials.
// If you try to add the same material again it will not be added, so create a
// default material with a unique name to ensure the proper number of materials
TCHAR NewMaterialName[MAX_SPRINTF]=TEXT("");
FCString::Sprintf( NewMaterialName, TEXT("Fbx Default Material %i"), MaterialIndex );
FbxMaterial = FbxSurfaceLambert::Create(Scene, TCHAR_TO_UTF8(NewMaterialName));
((FbxSurfaceLambert*)FbxMaterial)->Diffuse.Set(FbxDouble3(0.72, 0.72, 0.72));
}
MeshNode->AddMaterial(FbxMaterial);
}
int32 SavedMaterialCount = MeshNode->GetMaterialCount();
check(SavedMaterialCount == MaterialCount);
return MeshNode;
}
void AWDExporter::ExportMaterial( AWD *awd, awd_ncache *ncache, Mtl* mtl, int mtlID, int subNo) {
TimeValue t = GetStaticFrame();
int i;
BOOL usediffusemap = FALSE;
const char *name = mtl->GetName();
int namelen = strlen( name );
AWDMaterial *material = new AWDMaterial( AWD_MATTYPE_COLOR, name, namelen );
AWDTexture *tex;
for (i=0; i<mtl->NumSubTexmaps(); i++) {
Texmap* subTex = mtl->GetSubTexmap(i);
float amt = 1.0f;
if (subTex) {
// If it is a standard material we can see if the map is enabled.
if (mtl->ClassID() == Class_ID(DMTL_CLASS_ID, 0)) {
if (!((StdMat*)mtl)->MapEnabled(i))
continue;
amt = ((StdMat*)mtl)->GetTexmapAmt(i, 0);
}
tex = ExportTexture(awd, ncache, subTex, mtl->ClassID(), i, material );
if( tex && i == ID_DI ) {
usediffusemap = true;
}
}
}
if (mtl->ClassID() == Class_ID(DMTL_CLASS_ID, 0)) {
StdMat* std = (StdMat*)mtl;
material->color = get_awd_color( std->GetDiffuse(t), 1.0f );
} else {
material->color = get_awd_color( mtl->GetDiffuse(), 1.0f );
}
AWD_mat_type mattype;
if( usediffusemap ) mattype = AWD_MATTYPE_BITMAP;
else mattype = AWD_MATTYPE_COLOR;
material->set_type( mattype );
awd_ncache_add(ncache, (InterfaceServer*)mtl, material);
awd->add_material( material );
if (mtl->NumSubMtls() > 0) {
for (i=0; i<mtl->NumSubMtls(); i++) {
Mtl* subMtl = mtl->GetSubMtl(i);
if (subMtl && mtlList.GetMtlID( subMtl ) == -1 ) {
ExportMaterial(awd, ncache, subMtl, 0, i);
}
}
}
}
void UJanusExporterTool::Export()
{
TArray<UObject*> ObjectsToExport;
FString Root = FString(ExportPath); // copy so we dont mess with the original reference
FString Index = "<html>\n\t<head>\n\t\t<title>Unreal Export</title>\n\t</head>\n\t<body>\n\t\t<FireBoxRoom>\n\t\t\t<Assets>";
TArray<AActor*> ActorsExported;
TArray<UStaticMesh*> StaticMeshesExp;
TArray<FString> TexturesExp;
TArray<FString> MaterialsExported;
for (TObjectIterator<AActor> Itr; Itr; ++Itr)
{
AActor *Actor = *Itr;
FString Name = Actor->GetName();
/*if (!Name.StartsWith("SM_Floor_R"))
{
continue;
}*/
if (Actor->IsHiddenEd())
{
continue;
}
ActorsExported.Add(Actor);
TArray<UStaticMeshComponent*> StaticMeshes;
Actor->GetComponents<UStaticMeshComponent>(StaticMeshes);
for (int32 i = 0; i < StaticMeshes.Num(); i++)
{
UStaticMeshComponent* Component = StaticMeshes[i];
UStaticMesh *Mesh = Component->StaticMesh;
if (!Mesh)
{
continue;
}
if (Component->LODData.Num() > 0)
//if (false)
{
FStaticMeshComponentLODInfo* LODInfo = &Component->LODData[0];
FLightMap* LightMap = LODInfo->LightMap;
FShadowMap* ShadowMap = LODInfo->ShadowMap;
if (LightMap != NULL)
{
FLightMap2D* LightMap2D = LightMap->GetLightMap2D();
UTexture2D* Texture = LightMap2D->GetTexture(0); // 0 = HQ LightMap
FString TexName = Texture->GetName();
if (TexturesExp.Contains(TexName))
{
continue;
}
TexturesExp.Add(TexName);
ExportPNG(Texture, Root);
}
if (ShadowMap != NULL)
{
FShadowMap2D* ShadowMap2D = ShadowMap->GetShadowMap2D();
UShadowMapTexture2D* ShadowTex = ShadowMap2D->GetTexture();
FString TexName = ShadowTex->GetName();
if (TexturesExp.Contains(TexName))
{
continue;
}
TexturesExp.Add(TexName);
ExportPNG(ShadowTex, Root);
}
}
if (!StaticMeshesExp.Contains(Mesh))
{
StaticMeshesExp.Add(Mesh);
ExportFBX(Mesh, Root);
}
TArray<UMaterialInterface*> Materials = Component->GetMaterials();
for (int32 j = 0; j < Materials.Num(); j++)
{
UMaterialInterface* Material = Materials[j];
if (!Material)
{
continue;
}
FString MatName = Material->GetName();
if (MaterialsExported.Contains(MatName))
{
continue;
}
MaterialsExported.Add(MatName);
ExportMaterial(Root, Material, &TexturesExp);
}
}
}
// Models before textures so we can start showing the scene faster (textures take too long to load)
for (int32 i = 0; i < StaticMeshesExp.Num(); i++)
{
UStaticMesh *mesh = StaticMeshesExp[i];
Index.Append("\n\t\t\t\t<AssetObject id=\"" + mesh->GetName() + "\" src=\"" + mesh->GetName() + ".fbx\" />");
}
for (int32 i = 0; i < TexturesExp.Num(); i++)
{
FString Path = TexturesExp[i];
Index.Append("\n\t\t\t\t<AssetImage id=\"" + Path + "\" src=\"" + Path + ".png\" />");
}
Index.Append("\n\t\t\t</Assets>\n\t\t\t<Room>");
for (int32 i = 0; i < ActorsExported.Num(); i++)
{
AActor *Actor = ActorsExported[i];
TArray<UStaticMeshComponent*> StaticMeshes;
Actor->GetComponents<UStaticMeshComponent>(StaticMeshes);
for (int32 i = 0; i < StaticMeshes.Num(); i++)
{
UStaticMeshComponent* Component = StaticMeshes[i];
UStaticMesh *Mesh = Component->StaticMesh;
if (!Mesh)
{
continue;
}
FString ImageID = "";
TArray<UMaterialInterface*> Materials = Component->GetMaterials();
for (int32 j = 0; j < Materials.Num(); j++)
{
UMaterialInterface* Material = Materials[j];
if (!Material)
{
continue;
}
ImageID = Material->GetName() + "_BaseColor";
break;
}
if (ImageID == "")
{
Index.Append("\n\t\t\t\t<Object collision_id=\"" + Mesh->GetName() + "\" id=\"" + Mesh->GetName() + "\" lighting=\"true\" pos=\"");
}
else
{
Index.Append("\n\t\t\t\t<Object collision_id=\"" + Mesh->GetName() + "\" id=\"" + Mesh->GetName() + "\" image_id=\"" + ImageID + "\" lighting=\"true\" pos=\"");
}
FRotator Rot = Actor->GetActorRotation();
FVector XDir = Rot.RotateVector(FVector::RightVector);
FVector YDir = Rot.RotateVector(FVector::UpVector);
FVector ZDir = Rot.RotateVector(FVector::ForwardVector);
FVector Pos = Actor->GetActorLocation() * UniformScale;
FVector Sca = Actor->GetActorScale();
Pos = ChangeSpace(Pos);
Sca = ChangeSpaceScalar(Sca) * UniformScale;
XDir = ChangeSpace(XDir);
YDir = ChangeSpace(YDir);
ZDir = ChangeSpace(ZDir);
FVector Sign = GetSignVector(Sca);
Index.Append(FString::SanitizeFloat(Pos.X) + " " + FString::SanitizeFloat(Pos.Y) + " " + FString::SanitizeFloat(Pos.Z));
if (Sca.X < 0 || Sca.Y < 0 || Sca.Z < 0)
{
Index.Append("\" cull_face=\"front");
}
Index.Append("\" scale=\"");
Index.Append(FString::SanitizeFloat(Sca.X) + " " + FString::SanitizeFloat(Sca.Y) + " " + FString::SanitizeFloat(Sca.Z));
Index.Append("\" xdir=\"");
Index.Append(FString::SanitizeFloat(XDir.X) + " " + FString::SanitizeFloat(XDir.Y) + " " + FString::SanitizeFloat(XDir.Z));
Index.Append("\" ydir=\"");
Index.Append(FString::SanitizeFloat(YDir.X) + " " + FString::SanitizeFloat(YDir.Y) + " " + FString::SanitizeFloat(YDir.Z));
Index.Append("\" zdir=\"");
Index.Append(FString::SanitizeFloat(ZDir.X) + " " + FString::SanitizeFloat(ZDir.Y) + " " + FString::SanitizeFloat(ZDir.Z));
Index.Append("\" />");
}
}
Index.Append("\n\t\t\t</Room>\n\t\t</FireBoxRoom>\n\t</body>\n</html>");
FString IndexPath = FString(ExportPath).Append("index.html");
FFileHelper::SaveStringToFile(Index, *IndexPath);
}