private void LoadObject(ObjectData data)
{
GameObject gobject;
string absoluteMeshPath;
Transform importedParent = null;
// Check for import
if (data.isImported)
{
try
{
importedParent = new GameObject("__VRtist_tmp_load__").transform;
absoluteMeshPath = data.meshPath;
// Don't use async import since we may reference the game object for animations or constraints
// and the object must be loaded before we do so
GlobalState.GeometryImporter.ImportObject(absoluteMeshPath, importedParent, true);
if (importedParent.childCount == 0)
{
return;
}
gobject = importedParent.GetChild(0).gameObject;
}
catch (System.Exception e)
{
Debug.LogError("Failed to load external object: " + e.Message);
return;
}
}
else
{
absoluteMeshPath = GetSaveFolderPath(currentProjectName) + data.meshPath;
gobject = new GameObject(data.name);
}
LoadCommonData(gobject, data);
gobject.name = data.name;
// Mesh
if (null != data.meshPath && data.meshPath.Length > 0)
{
if (!data.isImported && !data.isSkinMesh)
{
if (!loadedMeshes.TryGetValue(absoluteMeshPath, out Mesh mesh))
{
MeshData meshData = new MeshData();
SerializationManager.Load(absoluteMeshPath, meshData);
mesh = meshData.CreateMesh();
loadedMeshes.Add(absoluteMeshPath, mesh);
}
gobject.AddComponent <MeshFilter>().sharedMesh = mesh;
gobject.AddComponent <MeshRenderer>().materials = LoadMaterials(data);
gobject.AddComponent <MeshCollider>();
}
if (data.isSkinMesh)
{
SkinMeshData skinData = new SkinMeshData();
SerializationManager.Load(absoluteMeshPath, skinData);
loadedSkinMeshes.Add(gobject, skinData);
skinMeshMaterials.Add(gobject, LoadMaterials(data));
}
if (!data.visible)
{
foreach (Component component in gobject.GetComponents <Component>())
{
Type componentType = component.GetType();
var prop = componentType.GetProperty("enabled");
if (null != prop)
{
prop.SetValue(component, data.visible);
}
}
}
}
SceneManager.AddObject(gobject);
if (data.parentPath.Length > 0)
{
SceneManager.SetObjectParent(gobject, rootTransform.Find(data.parentPath).gameObject);
}
if (data.isImported)
{
if (!gobject.TryGetComponent <ParametersController>(out ParametersController controller))
{
controller = gobject.AddComponent <ParametersController>();
}
controller.isImported = true;
controller.importPath = data.meshPath;
if (null != importedParent)
{
Destroy(importedParent.gameObject);
}
}
}
private void SetObjectData(Transform trans, ParametersController controller, ObjectData data)
{
// Mesh for non-imported objects
if (null == controller || !controller.isImported)
{
MeshRenderer meshRenderer = trans.GetComponent <MeshRenderer>();
MeshFilter meshFilter = trans.GetComponent <MeshFilter>();
if (null != meshFilter && null != meshRenderer)
{
// Materials
foreach (Material material in meshRenderer.materials)
{
string materialId = trans.name + "_" + material.name;
GetMaterialPath(currentProjectName, materialId, out string materialAbsolutePath, out string materialRelativePath);
MaterialInfo materialInfo = new MaterialInfo {
relativePath = materialRelativePath, absolutePath = materialAbsolutePath, material = material
};
if (!materials.ContainsKey(materialId))
{
materials.Add(materialId, materialInfo);
}
data.materialsData.Add(new MaterialData(materialInfo));
}
// Mesh
GetMeshPath(currentProjectName, meshFilter.sharedMesh.name, out string meshAbsolutePath, out string meshRelativePath);
meshes[meshRelativePath] = new MeshInfo {
relativePath = meshRelativePath, absolutePath = meshAbsolutePath, mesh = meshFilter.sharedMesh
};
data.meshPath = meshRelativePath;
}
data.isImported = false;
if (trans.TryGetComponent <SkinnedMeshRenderer>(out SkinnedMeshRenderer skinRenderer))
{
foreach (Material material in skinRenderer.materials)
{
string materialId = trans.name + "_" + material.name;
GetMaterialPath(currentProjectName, materialId, out string materialAbsolutePath, out string materialRelativePath);
MaterialInfo materialInfo = new MaterialInfo {
relativePath = materialRelativePath, absolutePath = materialAbsolutePath, material = material
};
if (!materials.ContainsKey(materialId))
{
materials.Add(materialId, materialInfo);
}
data.materialsData.Add(new MaterialData(materialInfo));
}
GetMeshPath(currentProjectName, skinRenderer.sharedMesh.name, out string meshAbsolutePath, out string meshRelativePath);
MeshInfo meshI = new MeshInfo {
absolutePath = meshAbsolutePath, relativePath = meshRelativePath, mesh = skinRenderer.sharedMesh
};
skinMeshes[meshRelativePath] = new SkinMeshInfo {
absolutePath = meshAbsolutePath, relativePath = meshRelativePath, skinMesh = skinRenderer, mesh = meshI
};
data.meshPath = meshRelativePath;
data.isSkinMesh = true;
}
}
else if (null != controller && controller.isImported)
{
data.meshPath = controller.importPath;
data.isImported = true;
}
}
private void SetCommonData(Transform trans, string parentPath, string path, ParametersController controller, ObjectData data)
{
data.name = trans.name;
data.parentPath = parentPath == "" ? "" : parentPath.Substring(1);
data.path = path.Substring(1);
data.tag = trans.gameObject.tag;
data.visible = true;
MeshRenderer mesh = trans.GetComponent <MeshRenderer>();
if (null != mesh && !mesh.enabled)
{
data.visible = false;
}
if (trans.gameObject.activeSelf == false)
{
data.visible = false;
}
// Transform
data.position = trans.localPosition;
data.rotation = trans.localRotation;
data.scale = trans.localScale;
if (null != controller)
{
data.lockPosition = controller.lockPosition;
data.lockRotation = controller.lockRotation;
data.lockScale = controller.lockScale;
}
}
private void TraverseScene(Transform root, string parentPath)
{
foreach (Transform currentTransform in root)
{
if (currentTransform == SceneManager.BoundingBox)
{
continue;
}
string path = parentPath;
path += "/" + currentTransform.name;
// Depending on its type (which controller we can find on it) create data objects to be serialized
LightController lightController = currentTransform.GetComponent <LightController>();
if (null != lightController)
{
LightData lightData = new LightData();
SetCommonData(currentTransform, parentPath, path, lightController, lightData);
SetLightData(lightController, lightData);
SceneData.Current.lights.Add(lightData);
continue;
}
CameraController cameraController = currentTransform.GetComponent <CameraController>();
if (null != cameraController)
{
CameraData cameraData = new CameraData();
SetCommonData(currentTransform, parentPath, path, cameraController, cameraData);
SetCameraData(cameraController, cameraData);
SceneData.Current.cameras.Add(cameraData);
continue;
}
ColimatorController colimatorController = currentTransform.GetComponent <ColimatorController>();
if (null != colimatorController)
{
// Nothing to do here, ignore the object
continue;
}
RigController skinController = currentTransform.GetComponent <RigController>();
if (null != skinController && !skinController.isImported)
{
SceneData.Current.rigs.Add(new RigData(skinController));
}
// Do this one at the end, because other controllers inherits from ParametersController
ParametersController controller = currentTransform.GetComponent <ParametersController>();
ObjectData data = new ObjectData();
SetCommonData(currentTransform, parentPath, path, controller, data);
try
{
SetObjectData(currentTransform, controller, data);
SceneData.Current.objects.Add(data);
}
catch (Exception e)
{
Debug.Log("Failed to set object data: " + e.Message);
}
// Serialize children
if (!data.isImported)
{
TraverseScene(currentTransform, path);
}
}
}
