static bool IsEmpty(SyncObject syncObject, SyncObjectImportConfig config)
{
if (syncObject.Children != null && syncObject.Children.Count > 0)
{
return(false);
}
if (syncObject.MeshId != SyncId.None)
{
return(false);
}
if (config.settings.importLights && syncObject.Light != null)
{
return(false);
}
if (syncObject.Rpc != null)
{
return(false);
}
if (syncObject.Camera != null)
{
return(false);
}
return(true);
}
void OnBuildGameObject(RpcContext <BuildGameObject> ctx)
{
var materialCache = new MaterialCache {
Materials = ctx.Data.Materials
};
var meshCache = new MeshCache {
Meshes = ctx.Data.Meshes
};
var configs = new SyncObjectImportConfig
{
settings = new SyncObjectImportSettings
{
defaultMaterial = ReflectMaterialManager.defaultMaterial,
importLights = true
},
materialCache = materialCache,
meshCache = meshCache
};
var gameObject = m_Importer.Import(ctx.Data.InstanceData.SourceId, ctx.Data.Object, configs);
gameObject.name = ctx.Data.Instance.Name;
gameObject.transform.SetParent(m_Settings.Root);
ImportersUtils.SetTransform(gameObject.transform, ctx.Data.Instance.Transform);
ImportersUtils.SetMetadata(gameObject, ctx.Data.Instance.Metadata);
ctx.SendSuccess(gameObject);
}
public SyncObjectBinding CreateInstance(StreamKey objectKey)
{
// Did we already instantiate an instance for the same?
if (m_Originals.TryGetValue(objectKey, out var original) &&
original.ObjectBinding != null)
{
++original.NbActiveInstances;
m_Originals[objectKey] = original;
TrackExistingDependencies(original.Dependencies);
return(Object.Instantiate(original.ObjectBinding));
}
// Did we receive the SyncObject?
var syncObject = m_SyncObjects[objectKey];
var configs = new SyncObjectImportConfig
{
settings = new SyncObjectImportSettings
{
defaultMaterial = ReflectMaterialManager.defaultMaterial, importLights = true
},
materialCache = m_MaterialCache, meshCache = m_MeshCache, lightImport = m_SyncLightImporter
};
var importer = new SyncObjectImporter();
var(dependencies, gameObject) = importer.ImportAndGetDependencies(objectKey.source, syncObject, configs);
var comp = gameObject.AddComponent <SyncObjectBinding>();
TrackDependencies(dependencies);
m_Originals[objectKey] = new OriginalInstance(1, comp, dependencies);
return(comp);
}
static void Import(string sourceId, SyncObject syncObject, GameObject gameObject, SyncObjectImportConfig config)
{
if (syncObject.MeshId != SyncId.None)
{
var meshKey = StreamKey.FromSyncId <SyncMesh>(sourceId, syncObject.MeshId);
var mesh = config.meshCache.GetMesh(meshKey);
if (mesh != null)
{
var meshFilter = gameObject.AddComponent <MeshFilter>();
meshFilter.sharedMesh = mesh;
var renderer = gameObject.GetComponent <MeshRenderer>();
if (renderer == null)
{
renderer = gameObject.AddComponent <MeshRenderer>();
}
var materials = new Material[meshFilter.sharedMesh.subMeshCount];
for (int i = 0; i < materials.Length; ++i)
{
Material material = null;
if (i < syncObject.MaterialIds.Count)
{
var materialId = syncObject.MaterialIds[i];
if (materialId != SyncId.None)
{
var materialKey = StreamKey.FromSyncId <SyncMaterial>(sourceId, materialId);
material = config.materialCache.GetMaterial(materialKey);
}
}
materials[i] = material ? material : config.settings.defaultMaterial;
}
renderer.sharedMaterials = materials;
}
}
if (config.settings.importLights && syncObject.Light != null)
{
ImportLight(syncObject.Light, gameObject);
}
if (syncObject.Rpc != null)
{
// TODO
}
if (syncObject.Camera != null)
{
ImportCamera(syncObject.Camera, gameObject);
}
if (syncObject.Children != null)
{
foreach (var child in syncObject.Children)
{
if (IsEmpty(child, config))
{
continue;
}
var childObject = new GameObject(child.Name);
childObject.transform.parent = gameObject.transform;
ImportersUtils.SetTransform(childObject.transform, child.Transform);
Import(sourceId, child, childObject, config);
}
}
}