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);
}
void Assignment::ApplyToMeshes()
{
UClass *refMeshClass= AStaticMeshActor::StaticClass();
UClass *refSkeletaMeshClass = ASkeletalMeshActor::StaticClass();
for (TObjectIterator<UObject> Itr; Itr; ++Itr)
{
if (Itr->GetClass()->IsChildOf(refMeshClass))
{
UE_LOG(ModoMaterialImporter, Log, TEXT("Scan materials in: %s %s"), *Itr->GetName(), *Itr->GetClass()->GetDesc());
AStaticMeshActor *aMeshActor = dynamic_cast<AStaticMeshActor*> (*Itr);
if (aMeshActor != NULL)
{
UMeshComponent* meshCompo = aMeshActor->GetStaticMeshComponent();
if (meshCompo != NULL)
{
for (int i = 0; i < meshCompo->GetNumMaterials(); i++)
{
UMaterialInterface* material = meshCompo->GetMaterial(i);
// It seems a UE4 bug, GetNumMaterials contains NULL materials!
if (material == NULL)
continue;
std::string strName = (TCHAR_TO_UTF8(*material->GetName()));
std::map<std::string, UMaterial*>::iterator mat_itr = Materials.find(strName);
if (mat_itr != Materials.end())
{
UE_LOG(ModoMaterialImporter, Log, TEXT("Set Material: %s"), *material->GetName());
meshCompo->SetMaterial(i, mat_itr->second);
}
}
}
}
}
else if (Itr->GetClass()->IsChildOf(refSkeletaMeshClass))
{
UE_LOG(ModoMaterialImporter, Log, TEXT("Scan materials in: %s %s"), *Itr->GetName(), *Itr->GetClass()->GetDesc());
ASkeletalMeshActor *aMeshActor = dynamic_cast<ASkeletalMeshActor*> (*Itr);
if (aMeshActor != NULL)
{
UMeshComponent * meshCompo = aMeshActor->GetSkeletalMeshComponent();
for (int i = 0; i < meshCompo->GetNumMaterials(); i++)
{
UMaterialInterface* material = meshCompo->GetMaterial(i);
// It seems a UE4 bug, GetNumMaterials contains NULL materials!
if (material == NULL)
continue;
std::string strName = (TCHAR_TO_UTF8(*material->GetName()));
std::map<std::string, UMaterial*>::iterator mat_itr = Materials.find(strName);
if (mat_itr != Materials.end())
{
UE_LOG(ModoMaterialImporter, Log, TEXT("Set Material: %s"), *material->GetName());
meshCompo->SetMaterial(i, mat_itr->second);
}
}
}
}
}
}
bool SetApexDestructibleAsset(UDestructibleMesh& DestructibleMesh, NxDestructibleAsset& ApexDestructibleAsset, FSkeletalMeshImportData* OutData, EImportOptions::Type Options)
{
DestructibleMesh.PreEditChange(NULL);
#if WITH_EDITORONLY_DATA
// Handle the StaticMesh import case, where we have the materials only stored in the fracture settings
if (DestructibleMesh.Materials.Num() == 0 && DestructibleMesh.FractureSettings != NULL &&
DestructibleMesh.FractureSettings->Materials.Num() > 0)
{
for (int32 i=0; i < DestructibleMesh.FractureSettings->Materials.Num(); ++i)
{
FSkeletalMaterial Mat;
Mat.MaterialInterface = DestructibleMesh.FractureSettings->Materials[i];
Mat.bEnableShadowCasting = true;
DestructibleMesh.Materials.Add(Mat);
}
}
#endif
ExistingDestMeshData* ExistDestMeshDataPtr = NULL;
ExistDestMeshDataPtr = SaveExistingDestMeshData(&DestructibleMesh);
// The asset is going away, which will destroy any actors created from it. We must destroy the physics state of any destructible mesh components before we release the asset.
for(TObjectIterator<UDestructibleComponent> It; It; ++It)
{
UDestructibleComponent* DestructibleComponent = *It;
if(DestructibleComponent->SkeletalMesh == &DestructibleMesh && DestructibleComponent->GetScene())
{
DestructibleComponent->DestroyPhysicsState();
}
}
// Release old NxDestructibleAsset if it exists
if (DestructibleMesh.ApexDestructibleAsset != NULL && DestructibleMesh.ApexDestructibleAsset != &ApexDestructibleAsset)
{
GPhysCommandHandler->DeferredRelease(DestructibleMesh.ApexDestructibleAsset);
}
// BRGTODO - need to remove the render data from the ApexDestructibleAsset, no longer need it
// Removing const cast ... we'll have to make it non-const anyway when we modify it
DestructibleMesh.ApexDestructibleAsset = &ApexDestructibleAsset;
if ( !(Options&EImportOptions::PreserveSettings) )
{
// Resize the depth parameters array to the appropriate size
DestructibleMesh.DefaultDestructibleParameters.DepthParameters.Init(FDestructibleDepthParameters(), ApexDestructibleAsset.getDepthCount());
// Resize the fracture effects array to the appropriate size
DestructibleMesh.FractureEffects.AddZeroed(ApexDestructibleAsset.getDepthCount());
// Load the UnrealEd-editable parameters from the destructible asset
DestructibleMesh.LoadDefaultDestructibleParametersFromApexAsset();
}
// Create body setup for the destructible mesh
DestructibleMesh.CreateBodySetup();
#if 0 // BRGTODO
// warning for missing smoothing group info
CheckSmoothingInfo(FbxMesh);
#endif
FSkeletalMeshImportData TempData;
// Fill with data from buffer
FSkeletalMeshImportData* SkelMeshImportDataPtr = &TempData;
if( OutData )
{
SkelMeshImportDataPtr = OutData;
}
// Import animation hierarchy, although this is trivial for an Apex Destructible Asset
CreateBones(*SkelMeshImportDataPtr, ApexDestructibleAsset);
if (!(Options & EImportOptions::PreserveSettings))
{
// Get all material names here
ImportMaterialsForSkelMesh(*SkelMeshImportDataPtr, ApexDestructibleAsset);
}
else
{
SkelMeshImportDataPtr->Materials.Empty(DestructibleMesh.Materials.Num());
for (int32 i=0; i < DestructibleMesh.Materials.Num(); ++i)
{
UMaterialInterface* MI = DestructibleMesh.Materials[i].MaterialInterface;
VMaterial NewMat;
NewMat.MaterialName = MI != NULL ? MI->GetName() : TEXT("");
SkelMeshImportDataPtr->Materials.Add(NewMat);
}
}
// Import graphics data
bool bHaveNormals, bHaveTangents;
if (!FillSkelMeshImporterFromApexDestructibleAsset(*SkelMeshImportDataPtr, ApexDestructibleAsset, bHaveNormals, bHaveTangents))
{
return false;
}
#if 0 // BRGTODO - what is this?
if( SkelMeshImportDataPtr->Materials.Num() == FbxMatList.Num() )
{
// reorder material according to "SKinXX" in material name
SetMaterialSkinXXOrder(*SkelMeshImportDataPtr, FbxMatList );
}
#endif
#if 0 // BRGTODO - what is this?
if( ImportOptions->bSplitNonMatchingTriangles )
{
DoUnSmoothVerts(*SkelMeshImportDataPtr);
}
#endif
if ( !(Options&EImportOptions::PreserveSettings) )
{
// process materials from import data
ProcessImportMeshMaterials( DestructibleMesh.Materials,*SkelMeshImportDataPtr );
}
// process reference skeleton from import data
int32 SkeletalDepth=0;
if(!ProcessImportMeshSkeleton(DestructibleMesh.RefSkeleton, SkeletalDepth, *SkelMeshImportDataPtr))
{
return false;
}
UE_LOG(LogApexDestructibleAssetImport, Warning, TEXT("Bones digested - %i Depth of hierarchy - %i"), DestructibleMesh.RefSkeleton.GetNum(), SkeletalDepth);
// process bone influences from import data
ProcessImportMeshInfluences(*SkelMeshImportDataPtr);
FSkeletalMeshResource& DestructibleMeshResource = *DestructibleMesh.GetImportedResource();
check(DestructibleMeshResource.LODModels.Num() == 0);
DestructibleMeshResource.LODModels.Empty();
new(DestructibleMeshResource.LODModels)FStaticLODModel();
DestructibleMesh.LODInfo.Empty();
DestructibleMesh.LODInfo.AddZeroed();
DestructibleMesh.LODInfo[0].LODHysteresis = 0.02f;
// Create initial bounding box based on expanded version of reference pose for meshes without physics assets. Can be overridden by artist.
FBox BoundingBox( SkelMeshImportDataPtr->Points.GetTypedData(), SkelMeshImportDataPtr->Points.Num() );
FBox Temp = BoundingBox;
FVector MidMesh = 0.5f*(Temp.Min + Temp.Max);
BoundingBox.Min = Temp.Min + 1.0f*(Temp.Min - MidMesh);
BoundingBox.Max = Temp.Max + 1.0f*(Temp.Max - MidMesh);
// BRGTODO : what is this?
// Tuck up the bottom as this rarely extends lower than a reference pose's (e.g. having its feet on the floor).
// Maya has Y in the vertical, other packages have Z.
//BEN const int32 CoordToTuck = bAssumeMayaCoordinates ? 1 : 2;
//BEN BoundingBox.Min[CoordToTuck] = Temp.Min[CoordToTuck] + 0.1f*(Temp.Min[CoordToTuck] - MidMesh[CoordToTuck]);
BoundingBox.Min[2] = Temp.Min[2] + 0.1f*(Temp.Min[2] - MidMesh[2]);
DestructibleMesh.Bounds= FBoxSphereBounds(BoundingBox);
// Store whether or not this mesh has vertex colors
DestructibleMesh.bHasVertexColors = SkelMeshImportDataPtr->bHasVertexColors;
FStaticLODModel& LODModel = DestructibleMeshResource.LODModels[0];
// Pass the number of texture coordinate sets to the LODModel. Ensure there is at least one UV coord
LODModel.NumTexCoords = FMath::Max<uint32>(1,SkelMeshImportDataPtr->NumTexCoords);
// if( bCreateRenderData ) // We always create render data
{
// copy vertex data needed to generate skinning streams for LOD
TArray<FVector> LODPoints;
TArray<FMeshWedge> LODWedges;
TArray<FMeshFace> LODFaces;
TArray<FVertInfluence> LODInfluences;
TArray<int32> LODPointToRawMap;
SkelMeshImportDataPtr->CopyLODImportData(LODPoints,LODWedges,LODFaces,LODInfluences,LODPointToRawMap);
#include "Developer/MeshUtilities/Public/MeshUtilities.h"
IMeshUtilities& MeshUtilities = FModuleManager::Get().LoadModuleChecked<IMeshUtilities>("MeshUtilities");
// Create actual rendering data.
if (!MeshUtilities.BuildSkeletalMesh(DestructibleMeshResource.LODModels[0], DestructibleMesh.RefSkeleton, LODInfluences,LODWedges,LODFaces,LODPoints,LODPointToRawMap,false,!bHaveNormals,!bHaveTangents))
{
DestructibleMesh.MarkPendingKill();
return false;
}
// Presize the per-section shadow casting array with the number of sections in the imported LOD.
const int32 NumSections = LODModel.Sections.Num();
for ( int32 SectionIndex = 0 ; SectionIndex < NumSections ; ++SectionIndex )
{
DestructibleMesh.LODInfo[0].TriangleSortSettings.AddZeroed();
}
if (ExistDestMeshDataPtr)
{
RestoreExistingDestMeshData(ExistDestMeshDataPtr, &DestructibleMesh);
delete ExistDestMeshDataPtr;
ExistDestMeshDataPtr = NULL;
}
DestructibleMesh.CalculateInvRefMatrices();
DestructibleMesh.PostEditChange();
DestructibleMesh.MarkPackageDirty();
#if 0 // BRGTODO : Check, we don't need this, do we?
// We have to go and fix any AnimSetMeshLinkup objects that refer to this skeletal mesh, as the reference skeleton has changed.
for(TObjectIterator<UAnimSet> It;It;++It)
{
UAnimSet* AnimSet = *It;
// Get DestructibleMesh path name
FName SkelMeshName = FName( *DestructibleMesh.GetPathName() );
// See if we have already cached this Skeletal Mesh.
const int32* IndexPtr = AnimSet->SkelMesh2LinkupCache.Find( SkelMeshName );
if( IndexPtr )
{
AnimSet->LinkupCache( *IndexPtr ).BuildLinkup( &DestructibleMesh, AnimSet );
}
}
#endif
// Now iterate over all skeletal mesh components re-initialising them.
for(TObjectIterator<UDestructibleComponent> It; It; ++It)
{
UDestructibleComponent* DestructibleComponent = *It;
if(DestructibleComponent->SkeletalMesh == &DestructibleMesh && DestructibleComponent->GetScene())
{
FComponentReregisterContext ReregisterContext(DestructibleComponent);
}
}
}
#if INVERT_Y_AND_V
// Apply transformation for Y inversion
const physx::PxMat44 MirrorY = physx::PxMat44(physx::PxVec4(1.0f, -1.0f, 1.0f, 1.0f));
#if !USE_TEMPORARY_TRANSFORMATION_FUNCTION
ApexDestructibleAsset.applyTransformation(MirrorY, 1.0f);
#else
ApplyTransformationToApexDestructibleAsset( ApexDestructibleAsset, MirrorY );
#endif
#endif
return true;
}