IEnumerator BuildMesh(MeshImporter.MeshContext x, int i)
{
using (MeasureTime("BuildMesh"))
{
MeshWithMaterials meshWithMaterials;
if (EnableLoadBalancing)
{
var buildMesh = MeshImporter.BuildMeshCoroutine(MaterialFactory, x);
yield return(buildMesh);
meshWithMaterials = buildMesh.Current as MeshWithMaterials;
}
else
{
meshWithMaterials = MeshImporter.BuildMesh(MaterialFactory, x);
}
var mesh = meshWithMaterials.Mesh;
// mesh name
if (string.IsNullOrEmpty(mesh.name))
{
mesh.name = string.Format("UniGLTF import#{0}", i);
}
var originalName = mesh.name;
for (int j = 1; Meshes.Any(y => y.Mesh.name == mesh.name); ++j)
{
mesh.name = string.Format("{0}({1})", originalName, j);
}
yield return(meshWithMaterials);
}
}
void ImportMeshes()
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter = "Meshes (*.obj;*.dae;*.3ds;*.x)|*.obj;*.dae;*.3ds;*.x";
dialog.Multiselect = true;
if (dialog.ShowDialog() == false)
{
return;
}
foreach (var filePath in dialog.FileNames)
{
if (Meshes.Any(a => a.Name == Path.GetFileNameWithoutExtension(filePath)))
{
MessageBox.Show("Already exists!");
continue;
}
Meshes.Add(_formatter.LoadMesh(filePath));
}
}
async Task <MeshWithMaterials> BuildMeshAsync(IAwaitCaller awaitCaller, Func <string, IDisposable> MeasureTime, MeshData meshData, int i)
{
using (MeasureTime("BuildMesh"))
{
var meshWithMaterials = await MeshUploader.BuildMeshAndUploadAsync(awaitCaller, meshData, MaterialFactory.GetMaterial);
var mesh = meshWithMaterials.Mesh;
// mesh name
if (string.IsNullOrEmpty(mesh.name))
{
mesh.name = string.Format("UniGLTF import#{0}", i);
}
var originalName = mesh.name;
for (int j = 1; Meshes.Any(y => y.Mesh.name == mesh.name); ++j)
{
mesh.name = string.Format("{0}({1})", originalName, j);
}
return(meshWithMaterials);
}
}
IEnumerator LoadMeshes()
{
var meshImporter = new MeshImporter();
for (int i = 0; i < GLTF.meshes.Count; ++i)
{
var meshContext = meshImporter.ReadMesh(this, i);
var meshWithMaterials = MeshImporter.BuildMesh(this, meshContext);
var mesh = meshWithMaterials.Mesh;
if (string.IsNullOrEmpty(mesh.name))
{
mesh.name = string.Format("UniGLTF import#{0}", i);
}
var originalName = mesh.name;
for (int j = 1; Meshes.Any(y => y.Mesh.name == mesh.name); ++j)
{
mesh.name = string.Format("{0}({1})", originalName, j);
}
Meshes.Add(meshWithMaterials);
yield return(null);
}
}
protected virtual Schedulable <Unit> LoadAsync()
{
return
(Schedulable.Create()
.AddTask(Scheduler.ThreadPool, () =>
{
if (m_textures.Count == 0)
{
//
// runtime
//
CreateTextureItems();
}
else
{
//
// already CreateTextures(by assetPostProcessor or editor menu)
//
}
})
.ContinueWithCoroutine(Scheduler.ThreadPool, TexturesProcessOnAnyThread)
.ContinueWithCoroutine(Scheduler.MainThread, TexturesProcessOnMainThread)
.ContinueWithCoroutine(Scheduler.MainThread, LoadMaterials)
.OnExecute(Scheduler.ThreadPool, parent =>
{
// UniGLTF does not support draco
// https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md#conformance
if (GLTF.extensionsRequired.Contains("KHR_draco_mesh_compression"))
{
throw new UniGLTFNotSupportedException("draco is not supported");
}
// meshes
var meshImporter = new MeshImporter();
for (int i = 0; i < GLTF.meshes.Count; ++i)
{
var index = i;
parent.AddTask(Scheduler.ThreadPool,
() =>
{
using (MeasureTime("ReadMesh"))
{
return meshImporter.ReadMesh(this, index);
}
})
.ContinueWith(Scheduler.MainThread, x =>
{
using (MeasureTime("BuildMesh"))
{
var meshWithMaterials = MeshImporter.BuildMesh(this, x);
var mesh = meshWithMaterials.Mesh;
// mesh name
if (string.IsNullOrEmpty(mesh.name))
{
mesh.name = string.Format("UniGLTF import#{0}", i);
}
var originalName = mesh.name;
for (int j = 1; Meshes.Any(y => y.Mesh.name == mesh.name); ++j)
{
mesh.name = string.Format("{0}({1})", originalName, j);
}
return meshWithMaterials;
}
})
.ContinueWith(Scheduler.ThreadPool, x => Meshes.Add(x))
;
}
})
.ContinueWithCoroutine(Scheduler.MainThread, LoadNodes)
.ContinueWithCoroutine(Scheduler.MainThread, BuildHierarchy)
.ContinueWith(Scheduler.MainThread, _ =>
{
using (MeasureTime("AnimationImporter"))
{
AnimationImporter.ImportAnimation(this);
}
})
.ContinueWith(Scheduler.CurrentThread,
_ =>
{
OnLoadModel();
if (m_showSpeedLog)
{
Debug.Log(GetSpeedLog());
}
return Unit.Default;
}));
}
public Entity CreateEntity()
{
var result = new Entity();
var boneTransforms = new TransformComponent[Bones.Length];
for (var i = 0; i < Bones.Length; i++)
{
var bone = Bones[i];
var parentTransform = bone.Parent != null
? boneTransforms[bone.Parent.Index]
: result.Transform;
var boneEntity = new Entity();
boneEntity.Name = bone.Name + " Animation Offset Parent";
boneEntity.Transform.LocalPosition = bone.Translation;
boneEntity.Transform.LocalRotation = bone.Rotation;
parentTransform.Children.Add(boneEntity.Transform);
var animatedBoneEntity = new Entity();
animatedBoneEntity.Name = bone.Name;
boneEntity.AddChild(animatedBoneEntity);
boneTransforms[i] = animatedBoneEntity.Transform;
}
result.Components.Add(new ModelComponent(boneTransforms, Meshes.Any(x => x.Skinned)));
foreach (var mesh in Meshes)
{
var boneEntity = boneTransforms[mesh.ParentBone.Index].Entity;
if (mesh.Skinned)
{
// Add skinned mesh component to root model entity,
// not bone entity.
result.Components.Add(new MeshComponent
{
Mesh = mesh
});
}
else
{
boneEntity.Components.Add(new MeshComponent
{
Mesh = mesh
});
}
}
foreach (var animation in Animations)
{
result.Components.Add(new AnimationComponent
{
Animation = animation
});
}
return(result);
}
public void Save(Stream stream)
{
var packageXml = new XDocument(new XElement("PartPackage"));
packageXml.Root.Add(new XElement("Info",
new XElement("Part", PartID),
new XElement("Description", Description)
));
if (Meshes.Any())
{
var meshesElem = new XElement("Meshes");
packageXml.Root.Add(meshesElem);
foreach (var partMesh in Meshes)
{
meshesElem.Add(partMesh.Serialize());
}
}
if (DecorationImages.Any())
{
var decoElem = packageXml.Root.AddElement("Decorations");
foreach (var decImg in DecorationImages)
{
decoElem.Add(decImg.Serialize());
}
}
if (Configurations.Any())
{
var brickElem = packageXml.Root.AddElement("Configurations");
foreach (var brick in Configurations)
{
var elem = new XElement("Brick",
new XAttribute("ElementID", brick.ElementID),
new XAttribute("MaterialID", brick.MaterialID));
foreach (var dec in brick.Decorations)
{
elem.Add(XmlHelper.DefaultSerialize(dec));
}
foreach (var subMat in brick.SubMaterials)
{
elem.Add(XmlHelper.DefaultSerialize(subMat));
}
brickElem.Add(elem);
}
}
using (var zipStream = new ZipOutputStream(stream))
{
zipStream.SetLevel(1);
zipStream.PutNextEntry(new ZipEntry(PACKAGE_XML_FILENAME));
packageXml.Save(zipStream);
zipStream.CloseEntry();
if (Primitive != null)
{
zipStream.PutNextEntry(new ZipEntry("primitive.xml"));
Primitive.Save(zipStream);
zipStream.CloseEntry();
}
foreach (var partMesh in Meshes)
{
zipStream.PutNextEntry(new ZipEntry($"{MESH_FOLDER}{partMesh.GetFileName()}"));
using (var ms = new MemoryStream())
{
partMesh.Mesh.Save(ms);
ms.Seek(0, SeekOrigin.Begin);
ms.CopyTo(zipStream);
}
zipStream.CloseEntry();
}
foreach (var decImg in DecorationImages)
{
zipStream.PutNextEntry(new ZipEntry($"{DECO_FOLDER}{decImg.GetFileName()}"));
decImg.Image.Save(zipStream, decImg.Image.RawFormat);
zipStream.CloseEntry();
}
}
}
protected virtual Schedulable <Unit> LoadAsync()
{
return
(Schedulable.Create()
.AddTask(Scheduler.ThreadPool, () =>
{
if (m_textures.Count == 0)
{
//
// runtime
//
CreateTextureItems();
}
else
{
//
// already CreateTextures(by assetPostProcessor or editor menu)
//
}
})
.ContinueWithCoroutine(Scheduler.ThreadPool, () =>
{
using (MeasureTime("TexturesProcessOnAnyThread"))
{
return TexturesProcessOnAnyThread();
}
})
.ContinueWithCoroutine(Scheduler.MainThread, () =>
{
using (MeasureTime("TexturesProcessOnMainThread"))
{
return TexturesProcessOnMainThread();
}
})
.ContinueWithCoroutine(Scheduler.MainThread, () =>
{
using (MeasureTime("LoadMaterials"))
{
return LoadMaterials();
}
})
.OnExecute(Scheduler.ThreadPool, parent =>
{
if (GLTF.meshes
.SelectMany(x => x.primitives)
.Any(x => x.extensions.KHR_draco_mesh_compression != null))
{
throw new UniGLTFNotSupportedException("draco is not supported");
}
// meshes
var meshImporter = new MeshImporter();
for (int i = 0; i < GLTF.meshes.Count; ++i)
{
var index = i;
parent.AddTask(Scheduler.ThreadPool,
() =>
{
using (MeasureTime("ReadMesh"))
{
return meshImporter.ReadMesh(this, index);
}
})
.ContinueWith(Scheduler.MainThread, x =>
{
using (MeasureTime("BuildMesh"))
{
var meshWithMaterials = MeshImporter.BuildMesh(this, x);
var mesh = meshWithMaterials.Mesh;
// mesh name
if (string.IsNullOrEmpty(mesh.name))
{
mesh.name = string.Format("UniGLTF import#{0}", i);
}
var originalName = mesh.name;
for (int j = 1; Meshes.Any(y => y.Mesh.name == mesh.name); ++j)
{
mesh.name = string.Format("{0}({1})", originalName, j);
}
return meshWithMaterials;
}
})
.ContinueWith(Scheduler.ThreadPool, x => Meshes.Add(x))
;
}
})
.ContinueWithCoroutine(Scheduler.MainThread, () =>
{
using (MeasureTime("LoadNodes"))
{
return LoadNodes();
}
})
.ContinueWithCoroutine(Scheduler.MainThread, () =>
{
using (MeasureTime("BuildHierarchy"))
{
return BuildHierarchy();
}
})
.ContinueWith(Scheduler.MainThread, _ =>
{
AnimationImporter.ImportAnimation(this);
})
.ContinueWith(Scheduler.CurrentThread,
_ =>
{
OnLoadModel();
Debug.Log(GetSpeedLog());
return Unit.Default;
}));
}
protected bool CollisionDetected() => Meshes.Any(mesh => NearObjects().FindAll(obj => obj.Collisionable).Any(obj => CollidesWith(obj)));
public bool CollidesWith(GameObject foreign)
{
return(Meshes.Any(mesh => foreign.Meshes.Any(foreignMesh => TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, foreignMesh.BoundingBox) != TgcCollisionUtils.BoxBoxResult.Afuera)));
}
