static void ExportMaterial(UUnrealMaterial* Mat, FArchive& Ar, int index, bool bLast)
{
char dummyName[64];
appSprintf(ARRAY_ARG(dummyName), "dummy_material_%d", index);
CVec3 Color = GetMaterialDebugColor(index);
Ar.Printf(
" {\n"
" \"name\" : \"%s\",\n"
" \"pbrMetallicRoughness\" : {\n"
" \"baseColorFactor\" : [ %g, %g, %g, 1.0 ],\n"
" \"metallicFactor\" : 0.1,\n"
" \"roughnessFactor\" : 0.5\n"
" }\n"
" }%s\n",
Mat ? Mat->Name : dummyName,
Color[0], Color[1], Color[2],
bLast ? "" : ","
);
}
void ExportMd5Mesh(const CSkeletalMesh *Mesh)
{
guard(ExportMd5Mesh);
int i;
UObject *OriginalMesh = Mesh->OriginalMesh;
if (!Mesh->Lods.Num())
{
appNotify("Mesh %s has 0 lods", OriginalMesh->Name);
return;
}
FArchive *Ar = CreateExportArchive(OriginalMesh, "%s.md5mesh", OriginalMesh->Name);
if (!Ar) return;
const CSkelMeshLod &Lod = Mesh->Lods[0];
Ar->Printf(
"MD5Version 10\n"
"commandline \"Created with UE Viewer\"\n"
"\n"
"numJoints %d\n"
"numMeshes %d\n"
"\n",
Mesh->RefSkeleton.Num(),
Lod.Sections.Num()
);
// compute skeleton
TArray<CCoords> BoneCoords;
BuildSkeleton(BoneCoords, Mesh->RefSkeleton);
// write joints
Ar->Printf("joints {\n");
for (i = 0; i < Mesh->RefSkeleton.Num(); i++)
{
const CSkelMeshBone &B = Mesh->RefSkeleton[i];
const CCoords &BC = BoneCoords[i];
CVec3 BP;
CQuat BO;
BP = BC.origin;
BO.FromAxis(BC.axis);
if (BO.w < 0) BO.Negate(); // W-component of quaternion will be removed ...
Ar->Printf(
"\t\"%s\"\t%d ( %f %f %f ) ( %.10f %.10f %.10f )\n",
*B.Name, (i == 0) ? -1 : B.ParentIndex,
VECTOR_ARG(BP),
BO.x, BO.y, BO.z
);
#if 0
//!!
if (i == 32 || i == 34)
{
CCoords BC;
BC.origin = BP;
BO.ToAxis(BC.axis);
appNotify("Bone %d (%8.3f %8.3f %8.3f) - (%8.3f %8.3f %8.3f %8.3f)", i, VECTOR_ARG(BP), QUAT_ARG(BO));
#define C BC
appNotify("INV : o=%8.3f %8.3f %8.3f", VECTOR_ARG(C.origin ));
appNotify(" 0=%8.3f %8.3f %8.3f", VECTOR_ARG(C.axis[0]));
appNotify(" 1=%8.3f %8.3f %8.3f", VECTOR_ARG(C.axis[1]));
appNotify(" 2=%8.3f %8.3f %8.3f", VECTOR_ARG(C.axis[2]));
#undef C
// BO.Negate();
BO.w *= -1;
BO.ToAxis(BC.axis);
#define C BC
appNotify("INV2 : o=%8.3f %8.3f %8.3f", VECTOR_ARG(C.origin ));
appNotify(" 0=%8.3f %8.3f %8.3f", VECTOR_ARG(C.axis[0]));
appNotify(" 1=%8.3f %8.3f %8.3f", VECTOR_ARG(C.axis[1]));
appNotify(" 2=%8.3f %8.3f %8.3f", VECTOR_ARG(C.axis[2]));
#undef C
}
#endif
}
Ar->Printf("}\n\n");
// collect weights information
TArray<VertInfluences> Weights; // Point -> Influences
Weights.AddZeroed(Lod.NumVerts);
for (i = 0; i < Lod.NumVerts; i++)
{
const CSkelMeshVertex &V = Lod.Verts[i];
CVec4 UnpackedWeights;
V.UnpackWeights(UnpackedWeights);
for (int j = 0; j < NUM_INFLUENCES; j++)
{
if (V.Bone[j] < 0) break;
VertInfluence *I = new (Weights[i].Inf) VertInfluence;
I->Bone = V.Bone[j];
I->Weight = UnpackedWeights[j];
}
}
CIndexBuffer::IndexAccessor_t Index = Lod.Indices.GetAccessor();
// write meshes
// we are using some terms here:
// - "mesh vertex" is a vertex in Lod.Verts[] array, global for whole mesh
// - "surcace vertex" is a vertex from the mesh stripped to only one (current) section
for (int m = 0; m < Lod.Sections.Num(); m++)
{
const CMeshSection &Sec = Lod.Sections[m];
TArray<int> MeshVerts; // surface vertex -> mesh vertex
TArray<int> BackWedge; // mesh vertex -> surface vertex
TArray<bool> UsedVerts; // mesh vertex -> surface: used of not
TArray<int> MeshWeights; // mesh vertex -> weight index
MeshVerts.Empty(Lod.NumVerts);
UsedVerts.AddZeroed(Lod.NumVerts);
BackWedge.AddZeroed(Lod.NumVerts);
MeshWeights.AddZeroed(Lod.NumVerts);
// find verts and triangles for current material
for (i = 0; i < Sec.NumFaces * 3; i++)
{
int idx = Index(i + Sec.FirstIndex);
if (UsedVerts[idx]) continue; // vertex is already used in previous triangle
UsedVerts[idx] = true;
int locWedge = MeshVerts.Add(idx);
BackWedge[idx] = locWedge;
}
// find influences
int WeightIndex = 0;
for (i = 0; i < Lod.NumVerts; i++)
{
if (!UsedVerts[i]) continue;
MeshWeights[i] = WeightIndex;
WeightIndex += Weights[i].Inf.Num();
}
// mesh header
const UUnrealMaterial *Tex = Sec.Material;
if (Tex)
{
Ar->Printf(
"mesh {\n"
"\tshader \"%s\"\n\n",
Tex->Name
);
ExportObject(Tex);
}
else
{
Ar->Printf(
"mesh {\n"
"\tshader \"material_%d\"\n\n",
m
);
}
// verts
Ar->Printf("\tnumverts %d\n", MeshVerts.Num());
for (i = 0; i < MeshVerts.Num(); i++)
{
int iPoint = MeshVerts[i];
const CSkelMeshVertex &V = Lod.Verts[iPoint];
Ar->Printf("\tvert %d ( %f %f ) %d %d\n",
i, V.UV.U, V.UV.V, MeshWeights[iPoint], Weights[iPoint].Inf.Num());
}
// triangles
Ar->Printf("\n\tnumtris %d\n", Sec.NumFaces);
for (i = 0; i < Sec.NumFaces; i++)
{
Ar->Printf("\ttri %d", i);
#if MIRROR_MESH
for (int j = 2; j >= 0; j--)
#else
for (int j = 0; j < 3; j++)
#endif
Ar->Printf(" %d", BackWedge[Index(Sec.FirstIndex + i * 3 + j)]);
Ar->Printf("\n");
}
// weights
Ar->Printf("\n\tnumweights %d\n", WeightIndex);
int saveWeightIndex = WeightIndex;
WeightIndex = 0;
for (i = 0; i < Lod.NumVerts; i++)
{
if (!UsedVerts[i]) continue;
for (int j = 0; j < Weights[i].Inf.Num(); j++)
{
const VertInfluence &I = Weights[i].Inf[j];
CVec3 v;
v = Lod.Verts[i].Position;
#if MIRROR_MESH
v[1] *= -1; // y
#endif
BoneCoords[I.Bone].TransformPoint(v, v);
Ar->Printf(
"\tweight %d %d %f ( %f %f %f )\n",
WeightIndex, I.Bone, I.Weight, VECTOR_ARG(v)
);
WeightIndex++;
}
}
assert(saveWeightIndex == WeightIndex);
// mesh footer
Ar->Printf("}\n");
}
delete Ar;
unguard;
}
void ExportMd5Anim(const CAnimSet *Anim)
{
guard(ExportMd5Anim);
int numBones = Anim->TrackBoneNames.Num();
UObject *OriginalAnim = Anim->OriginalAnim;
for (int AnimIndex = 0; AnimIndex < Anim->Sequences.Num(); AnimIndex++)
{
int i;
const CAnimSequence &S = Anim->Sequences[AnimIndex];
FArchive *Ar = CreateExportArchive(OriginalAnim, "%s/%s.md5anim", OriginalAnim->Name, *S.Name);
if (!Ar) continue;
Ar->Printf(
"MD5Version 10\n"
"commandline \"Created with UE Viewer\"\n"
"\n"
"numFrames %d\n"
"numJoints %d\n"
"frameRate %g\n"
"numAnimatedComponents %d\n"
"\n",
S.NumFrames,
numBones,
S.Rate,
numBones * 6
);
// skeleton
Ar->Printf("hierarchy {\n");
for (i = 0; i < numBones; i++)
{
Ar->Printf("\t\"%s\" %d %d %d\n", *Anim->TrackBoneNames[i], (i == 0) ? -1 : 0, 63, i * 6);
// ParentIndex is unknown for UAnimSet, so always write "0"
// here: 6 is number of components per frame, 63 = (1<<6)-1 -- flags "all components are used"
}
// bounds
Ar->Printf("}\n\nbounds {\n");
for (i = 0; i < S.NumFrames; i++)
Ar->Printf("\t( -100 -100 -100 ) ( 100 100 100 )\n"); //!! dummy
Ar->Printf("}\n\n");
// baseframe and frames
for (int Frame = -1; Frame < S.NumFrames; Frame++)
{
int t = Frame;
if (Frame == -1)
{
Ar->Printf("baseframe {\n");
t = 0;
}
else
Ar->Printf("frame %d {\n", Frame);
for (int b = 0; b < numBones; b++)
{
CVec3 BP;
CQuat BO;
S.Tracks[b].GetBonePosition(t, S.NumFrames, false, BP, BO);
if (!b) BO.Conjugate(); // root bone
#if MIRROR_MESH
BO.y *= -1;
BO.w *= -1;
BP[1] *= -1; // y
#endif
if (BO.w < 0) BO.Negate(); // W-component of quaternion will be removed ...
if (Frame < 0)
Ar->Printf("\t( %f %f %f ) ( %.10f %.10f %.10f )\n", VECTOR_ARG(BP), BO.x, BO.y, BO.z);
else
Ar->Printf("\t%f %f %f %.10f %.10f %.10f\n", VECTOR_ARG(BP), BO.x, BO.y, BO.z);
}
Ar->Printf("}\n\n");
}
delete Ar;
}
unguard;
}
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;
}
static void ExportAnimations(ExportContext& Context, FArchive& Ar)
{
guard(ExportAnimations);
const CAnimSet* Anim = Context.SkelMesh->Anim;
int NumBones = Context.SkelMesh->RefSkeleton.Num();
// Build mesh to anim bone map
TArray<int> BoneMap;
BoneMap.Init(-1, NumBones);
TArray<int> AnimBones;
AnimBones.Empty(NumBones);
for (int i = 0; i < NumBones; i++)
{
const CSkelMeshBone &B = Context.SkelMesh->RefSkeleton[i];
for (int j = 0; j < Anim->TrackBoneNames.Num(); j++)
{
if (!stricmp(B.Name, Anim->TrackBoneNames[j]))
{
BoneMap[i] = j; // lookup CAnimSet bone by mesh bone index
AnimBones.Add(i); // indicate that the bone has animation
break;
}
}
}
Ar.Printf(
" \"animations\" : [\n"
);
int FirstDataIndex = Context.Data.Num();
// Iterate over all animations
for (int SeqIndex = 0; SeqIndex < Anim->Sequences.Num(); SeqIndex++)
{
const CAnimSequence &Seq = *Anim->Sequences[SeqIndex];
Ar.Printf(
" {\n"
" \"name\" : \"%s\",\n",
*Seq.Name
);
struct AnimSampler
{
enum ChannelType
{
TRANSLATION,
ROTATION
};
int BoneNodeIndex;
ChannelType Type;
const CAnimTrack* Track;
};
TArray<AnimSampler> Samplers;
Samplers.Empty(AnimBones.Num() * 2);
//!! Optimization:
//!! 1. there will be missing tracks (AnimRotationOnly etc) - drop such samplers
//!! 2. store all time tracks in a single BufferView, all rotation tracks in another, and all position track in 3rd one - this
//!! will reduce amount of BufferViews in json text (combine them by data type)
// Prepare channels array
Ar.Printf(" \"channels\" : [\n");
for (int BoneIndex = 0; BoneIndex < AnimBones.Num(); BoneIndex++)
{
int MeshBoneIndex = AnimBones[BoneIndex];
int AnimBoneIndex = BoneMap[MeshBoneIndex];
const CAnimTrack* Track = Seq.Tracks[AnimBoneIndex];
int TranslationSamplerIndex = Samplers.Num();
AnimSampler* Sampler = new (Samplers) AnimSampler;
Sampler->Type = AnimSampler::TRANSLATION;
Sampler->BoneNodeIndex = MeshBoneIndex + FIRST_BONE_NODE;
Sampler->Track = Track;
int RotationSamplerIndex = Samplers.Num();
Sampler = new (Samplers) AnimSampler;
Sampler->Type = AnimSampler::ROTATION;
Sampler->BoneNodeIndex = MeshBoneIndex + FIRST_BONE_NODE;
Sampler->Track = Track;
// Print glTF information. Not using usual formatting here to make output a little bit more compact.
Ar.Printf(
" { \"sampler\" : %d, \"target\" : { \"node\" : %d, \"path\" : \"%s\" } },\n",
TranslationSamplerIndex, MeshBoneIndex + FIRST_BONE_NODE, "translation"
);
Ar.Printf(
" { \"sampler\" : %d, \"target\" : { \"node\" : %d, \"path\" : \"%s\" } }%s\n",
RotationSamplerIndex, MeshBoneIndex + FIRST_BONE_NODE, "rotation", BoneIndex == AnimBones.Num()-1 ? "" : ","
);
}
Ar.Printf(" ],\n");
// Prepare samplers
Ar.Printf(" \"samplers\" : [\n");
for (int SamplerIndex = 0; SamplerIndex < Samplers.Num(); SamplerIndex++)
{
const AnimSampler& Sampler = Samplers[SamplerIndex];
// Prepare time array
const TArray<float>* TimeArray = (Sampler.Type == AnimSampler::TRANSLATION) ? &Sampler.Track->KeyPosTime : &Sampler.Track->KeyQuatTime;
if (TimeArray->Num() == 0)
{
// For this situation, use track's time array
TimeArray = &Sampler.Track->KeyTime;
}
int NumKeys = Sampler.Type == (AnimSampler::TRANSLATION) ? Sampler.Track->KeyPos.Num() : Sampler.Track->KeyQuat.Num();
int TimeBufIndex = Context.Data.AddZeroed();
BufferData& TimeBuf = Context.Data[TimeBufIndex];
TimeBuf.Setup(NumKeys, "SCALAR", BufferData::FLOAT, sizeof(float));
float RateScale = 1.0f / Seq.Rate;
float LastFrameTime = 0;
if (TimeArray->Num() == 0 || NumKeys == 1)
{
// Fill with equally spaced values
for (int i = 0; i < NumKeys; i++)
{
TimeBuf.Put(i * RateScale);
}
LastFrameTime = NumKeys-1;
}
else
{
for (int i = 0; i < TimeArray->Num(); i++)
{
TimeBuf.Put((*TimeArray)[i] * RateScale);
}
LastFrameTime = (*TimeArray)[TimeArray->Num()-1];
}
// Prepare min/max values for time track, it's required by glTF standard
TimeBuf.BoundsMin = "[ 0 ]";
char buf[64];
appSprintf(ARRAY_ARG(buf), "[ %g ]", LastFrameTime * RateScale);
TimeBuf.BoundsMax = buf;
// Try to reuse TimeBuf from previous tracks
TimeBufIndex = Context.GetFinalIndexForLastBlock(FirstDataIndex);
// Prepare data
int DataBufIndex = Context.Data.AddZeroed();
BufferData& DataBuf = Context.Data[DataBufIndex];
if (Sampler.Type == AnimSampler::TRANSLATION)
{
// Translation track
DataBuf.Setup(NumKeys, "VEC3", BufferData::FLOAT, sizeof(CVec3));
for (int i = 0; i < NumKeys; i++)
{
CVec3 Pos = Sampler.Track->KeyPos[i];
TransformPosition(Pos);
DataBuf.Put(Pos);
}
}
else
{
// Rotation track
DataBuf.Setup(NumKeys, "VEC4", BufferData::FLOAT, sizeof(CQuat));
for (int i = 0; i < NumKeys; i++)
{
CQuat Rot = Sampler.Track->KeyQuat[i];
TransformRotation(Rot);
if (Sampler.BoneNodeIndex - FIRST_BONE_NODE == 0)
{
Rot.Conjugate();
}
DataBuf.Put(Rot);
}
}
// Try to reuse data block as well
DataBufIndex = Context.GetFinalIndexForLastBlock(FirstDataIndex);
// Write glTF info
Ar.Printf(
" { \"input\" : %d, \"output\" : %d }%s\n",
TimeBufIndex, DataBufIndex, SamplerIndex == Samplers.Num()-1 ? "" : ","
);
}
Ar.Printf(" ]\n");
Ar.Printf(" }%s\n", SeqIndex == Anim->Sequences.Num()-1 ? "" : ",");
}
Ar.Printf(" ],\n");
unguard;
}
static void ExportSkinData(ExportContext& Context, const CSkelMeshLod& Lod, FArchive& Ar)
{
guard(ExportSkinData);
int numBones = Context.SkelMesh->RefSkeleton.Num();
int MatrixBufIndex = Context.Data.AddZeroed();
BufferData& MatrixBuf = Context.Data[MatrixBufIndex];
MatrixBuf.Setup(numBones, "MAT4", BufferData::FLOAT, sizeof(CMat4));
Ar.Printf(
" \"nodes\" : [\n"
" {\n"
" \"name\" : \"%s\",\n"
" \"mesh\" : 0,\n"
" \"skin\" : 0,\n"
" \"children\" : [ 1 ]\n"
" },\n",
Context.MeshName);
TArray<CCoords> BoneCoords;
BoneCoords.AddZeroed(numBones);
for (int boneIndex = 0; boneIndex < numBones; boneIndex++)
{
const CSkelMeshBone& B = Context.SkelMesh->RefSkeleton[boneIndex];
// Find all children
TStaticArray<int, 32> children;
for (int j = 0; j < numBones; j++)
{
if (boneIndex == j) continue;
const CSkelMeshBone& B2 = Context.SkelMesh->RefSkeleton[j];
if (B2.ParentIndex == boneIndex)
{
children.Add(j);
}
}
Ar.Printf(
" {\n"
" \"name\" : \"%s\",\n",
*B.Name
);
// Write children
if (children.Num())
{
Ar.Printf(" \"children\" : [ %d", children[0]+FIRST_BONE_NODE);
for (int j = 1; j < children.Num(); j++)
{
Ar.Printf(", %d", children[j]+FIRST_BONE_NODE);
}
Ar.Printf(" ],\n");
}
// Bone transform
CVec3 bonePos = B.Position;
CQuat boneRot = B.Orientation;
if (boneIndex == 0)
{
boneRot.Conjugate();
}
TransformPosition(bonePos);
TransformRotation(boneRot);
Ar.Printf(
" \"translation\" : [ %g, %g, %g ],\n"
" \"rotation\" : [ %g, %g, %g, %g ]\n",
bonePos[0], bonePos[1], bonePos[2],
boneRot.x, boneRot.y, boneRot.z, boneRot.w
);
boneRot.w *= -1;
CCoords& BC = BoneCoords[boneIndex];
BC.origin = bonePos;
boneRot.ToAxis(BC.axis);
if (boneIndex)
{
// World coordinate
BoneCoords[B.ParentIndex].UnTransformCoords(BC, BC);
}
CCoords InvCoords;
InvertCoords(BC, InvCoords);
CMat4 BC4x4(InvCoords);
MatrixBuf.Put(BC4x4);
// Closing brace
Ar.Printf(
" }%s\n",
boneIndex == (numBones-1) ? "" : ","
);
}
// Close "nodes" array
Ar.Printf(" ],\n");
// Make "skins"
Ar.Printf(
" \"skins\" : [\n"
" {\n"
" \"inverseBindMatrices\" : %d,\n"
" \"skeleton\" : 1,\n"
" \"joints\" : [",
MatrixBufIndex
);
for (int i = 0; i < numBones; i++)
{
if ((i & 31) == 0) Ar.Printf("\n ");
Ar.Printf("%d%s", i+FIRST_BONE_NODE, (i == numBones-1) ? "" : ",");
}
Ar.Printf(
"\n"
" ]\n"
" }\n"
" ],\n"
);
unguard;
}
static void ExportSection(ExportContext& Context, const CBaseMeshLod& Lod, const CMeshVertex* Verts, int SectonIndex, FArchive& Ar)
{
guard(ExportSection);
int VertexSize = Context.IsSkeletal() ? sizeof(CSkelMeshVertex) : sizeof(CStaticMeshVertex);
const CMeshSection& S = Lod.Sections[SectonIndex];
bool bLast = (SectonIndex == Lod.Sections.Num()-1);
// Remap section indices to local indices
CIndexBuffer::IndexAccessor_t GetIndex = Lod.Indices.GetAccessor();
TArray<int> indexRemap; // old vertex index -> new vertex index
indexRemap.Init(-1, Lod.NumVerts);
int numLocalVerts = 0;
int numLocalIndices = S.NumFaces * 3;
for (int idx = 0; idx < numLocalIndices; idx++)
{
int vertIndex = GetIndex(S.FirstIndex + idx);
if (indexRemap[vertIndex] == -1)
{
indexRemap[vertIndex] = numLocalVerts++;
}
}
// Prepare buffers
int IndexBufIndex = Context.Data.AddZeroed();
int PositionBufIndex = Context.Data.AddZeroed();
int NormalBufIndex = Context.Data.AddZeroed();
int TangentBufIndex = Context.Data.AddZeroed();
int BonesBufIndex = -1;
int WeightsBufIndex = -1;
if (Context.IsSkeletal())
{
BonesBufIndex = Context.Data.AddZeroed();
WeightsBufIndex = Context.Data.AddZeroed();
}
int UVBufIndex[MAX_MESH_UV_SETS];
for (int i = 0; i < Lod.NumTexCoords; i++)
{
UVBufIndex[i] = Context.Data.AddZeroed();
}
BufferData& IndexBuf = Context.Data[IndexBufIndex];
BufferData& PositionBuf = Context.Data[PositionBufIndex];
BufferData& NormalBuf = Context.Data[NormalBufIndex];
BufferData& TangentBuf = Context.Data[TangentBufIndex];
BufferData* UVBuf[MAX_MESH_UV_SETS];
BufferData* BonesBuf = NULL;
BufferData* WeightsBuf = NULL;
PositionBuf.Setup(numLocalVerts, "VEC3", BufferData::FLOAT, sizeof(CVec3));
NormalBuf.Setup(numLocalVerts, "VEC3", BufferData::FLOAT, sizeof(CVec3));
TangentBuf.Setup(numLocalVerts, "VEC4", BufferData::FLOAT, sizeof(CVec4));
for (int i = 0; i < Lod.NumTexCoords; i++)
{
UVBuf[i] = &Context.Data[UVBufIndex[i]];
UVBuf[i]->Setup(numLocalVerts, "VEC2", BufferData::FLOAT, sizeof(CMeshUVFloat));
}
if (Context.IsSkeletal())
{
BonesBuf = &Context.Data[BonesBufIndex];
WeightsBuf = &Context.Data[WeightsBufIndex];
BonesBuf->Setup(numLocalVerts, "VEC4", BufferData::UNSIGNED_SHORT, sizeof(uint16)*4);
WeightsBuf->Setup(numLocalVerts, "VEC4", BufferData::UNSIGNED_BYTE, sizeof(uint32), /*InNormalized=*/ true);
}
// Prepare and build indices
TArray<int> localIndices;
localIndices.AddUninitialized(numLocalIndices);
int* pIndex = localIndices.GetData();
for (int i = 0; i < numLocalIndices; i++)
{
*pIndex++ = GetIndex(S.FirstIndex + i);
}
if (numLocalVerts <= 65536)
{
IndexBuf.Setup(numLocalIndices, "SCALAR", BufferData::UNSIGNED_SHORT, sizeof(uint16));
for (int idx = 0; idx < numLocalIndices; idx++)
{
IndexBuf.Put<uint16>(indexRemap[localIndices[idx]]);
}
}
else
{
IndexBuf.Setup(numLocalIndices, "SCALAR", BufferData::UNSIGNED_INT, sizeof(uint32));
for (int idx = 0; idx < numLocalIndices; idx++)
{
IndexBuf.Put<uint32>(indexRemap[localIndices[idx]]);
}
}
// Build reverse index map for fast lookup of vertex by its new index.
// It maps new vertex index to old vertex index.
TArray<int> revIndexMap;
revIndexMap.AddUninitialized(numLocalVerts);
for (int i = 0; i < indexRemap.Num(); i++)
{
int newIndex = indexRemap[i];
if (newIndex != -1)
{
revIndexMap[newIndex] = i;
}
}
// Build vertices
for (int i = 0; i < numLocalVerts; i++)
{
int vertIndex = revIndexMap[i];
const CMeshVertex& V = VERT(vertIndex);
CVec3 Position = V.Position;
CVec4 Normal, Tangent;
Unpack(Normal, V.Normal);
Unpack(Tangent, V.Tangent);
// Unreal (and we are) using normal.w for computing binormal. glTF
// uses tangent.w for that. Make this value exactly 1.0 of -1.0 to make glTF
// validator happy.
#if 0
// There's some problem: V.Normal.W == 0x80 -> -1.008 instead of -1.0
if (Normal.w > 1.001 || Normal.w < -1.001)
{
appError("%X -> %g\n", V.Normal.Data, Normal.w);
}
#endif
Tangent.w = (Normal.w < 0) ? -1 : 1;
TransformPosition(Position);
TransformDirection(Normal);
TransformDirection(Tangent);
Normal.Normalize();
Tangent.Normalize();
// Fill buffers
PositionBuf.Put(Position);
NormalBuf.Put(Normal.xyz);
TangentBuf.Put(Tangent);
UVBuf[0]->Put(V.UV);
}
// Compute bounds for PositionBuf
CVec3 Mins, Maxs;
ComputeBounds((CVec3*)PositionBuf.Data, numLocalVerts, sizeof(CVec3), Mins, Maxs);
char buf[256];
appSprintf(ARRAY_ARG(buf), "[ %g, %g, %g ]", VECTOR_ARG(Mins));
PositionBuf.BoundsMin = buf;
appSprintf(ARRAY_ARG(buf), "[ %g, %g, %g ]", VECTOR_ARG(Maxs));
PositionBuf.BoundsMax = buf;
if (Context.IsSkeletal())
{
for (int i = 0; i < numLocalVerts; i++)
{
int vertIndex = revIndexMap[i];
const CMeshVertex& V0 = VERT(vertIndex);
const CSkelMeshVertex& V = static_cast<const CSkelMeshVertex&>(V0);
int16 Bones[NUM_INFLUENCES];
static_assert(NUM_INFLUENCES == 4, "Code designed for 4 influences");
static_assert(sizeof(Bones) == sizeof(V.Bone), "Unexpected V.Bones size");
memcpy(Bones, V.Bone, sizeof(Bones));
for (int j = 0; j < NUM_INFLUENCES; j++)
{
// We have INDEX_NONE as list terminator, should replace with something else for glTF
if (Bones[j] == INDEX_NONE)
{
Bones[j] = 0;
}
}
BonesBuf->Put(*(uint64*)&Bones);
WeightsBuf->Put(V.PackedWeights);
}
}
// Secondary UVs
for (int uvIndex = 1; uvIndex < Lod.NumTexCoords; uvIndex++)
{
BufferData* pBuf = UVBuf[uvIndex];
const CMeshUVFloat* srcUV = Lod.ExtraUV[uvIndex-1];
for (int i = 0; i < numLocalVerts; i++)
{
int vertIndex = revIndexMap[i];
pBuf->Put(srcUV[vertIndex]);
}
}
// Write primitive information to json
Ar.Printf(
" {\n"
" \"attributes\" : {\n"
" \"POSITION\" : %d,\n"
" \"NORMAL\" : %d,\n"
" \"TANGENT\" : %d,\n",
PositionBufIndex, NormalBufIndex, TangentBufIndex
);
if (Context.IsSkeletal())
{
Ar.Printf(
" \"JOINTS_0\" : %d,\n"
" \"WEIGHTS_0\" : %d,\n",
BonesBufIndex, WeightsBufIndex
);
}
for (int i = 0; i < Lod.NumTexCoords; i++)
{
Ar.Printf(
" \"TEXCOORD_%d\" : %d%s\n",
i, UVBufIndex[i], i < (Lod.NumTexCoords-1) ? "," : ""
);
}
Ar.Printf(
" },\n"
" \"indices\" : %d,\n"
" \"material\" : %d\n"
" }%s\n",
IndexBufIndex, SectonIndex,
SectonIndex < (Lod.Sections.Num()-1) ? "," : ""
);
unguard;
}