protected override void OnUpdate()
{
var typeLookup = new Dictionary <string, Type>();
var allTypes = TypeManager.GetAllTypes();
foreach (var compType in allTypes)
{
if (compType.Category == TypeManager.TypeCategory.BufferData &&
compType.Type != null && compType.Type.Name.EndsWith("SnapshotData"))
{
if (typeLookup.ContainsKey(compType.Type.Name))
{
throw new InvalidOperationException(
$"Found multiple snapshot data types named {compType.Type.Name}, namespaces are not fully supported for snapshot data");
}
typeLookup.Add(compType.Type.Name, compType.Type);
}
}
Entities.ForEach((GhostAuthoringComponent ghostAuthoring) =>
{
if (String.IsNullOrEmpty(ghostAuthoring.prefabId))
{
throw new InvalidOperationException($"The ghost {ghostAuthoring.gameObject.name} is not a valid prefab, all ghosts must be the top-level GameObject in a prefab. Ghost instances in scenes must be instances of such prefabs.");
}
DeclareLinkedEntityGroup(ghostAuthoring.gameObject);
if (ghostAuthoring.doNotStrip)
{
return;
}
var entity = GetPrimaryEntity(ghostAuthoring);
var target = GetConversionTarget(this);
// FIXME: A2 hack
if (target == NetcodeConversionTarget.Undefined)
{
// throw new InvalidOperationException($"A ghost prefab can only be created in the client or server world, not {DstEntityManager.World.Name}");
Debug.LogWarning(
$"A ghost prefab can only be created in the client or server world, not {DstEntityManager.World.Name}.\nDefaulting to server conversion.");
target = NetcodeConversionTarget.Server;
}
if (ghostAuthoring.prefabId.Length != 32)
{
throw new InvalidOperationException("Invalid guid for ghost prefab type");
}
var ghostType = new GhostTypeComponent();
ghostType.guid0 = Convert.ToUInt32(ghostAuthoring.prefabId.Substring(0, 8), 16);
ghostType.guid1 = Convert.ToUInt32(ghostAuthoring.prefabId.Substring(8, 8), 16);
ghostType.guid2 = Convert.ToUInt32(ghostAuthoring.prefabId.Substring(16, 8), 16);
ghostType.guid3 = Convert.ToUInt32(ghostAuthoring.prefabId.Substring(24, 8), 16);
DstEntityManager.AddComponentData(entity, ghostType);
var toRemove = new HashSet <string>();
if (target == NetcodeConversionTarget.Server)
{
// Make sure different ghost types are in different chunks
DstEntityManager.AddSharedComponentData(entity, new SharedGhostTypeComponent {
SharedValue = ghostType
});
DstEntityManager.AddComponentData(entity, new GhostComponent());
DstEntityManager.AddComponentData(entity, new PredictedGhostComponent());
// Create server version of prefab
foreach (var comp in ghostAuthoring.Components)
{
if (!comp.server && comp.entityIndex == 0)
{
toRemove.Add(comp.name);
}
}
}
else if (target == NetcodeConversionTarget.Client)
{
var snapshotTypeName = $"{ghostAuthoring.name}SnapshotData";
if (!typeLookup.TryGetValue(snapshotTypeName, out var snapshotType))
{
throw new InvalidOperationException(
$"Could not find snapshot data {snapshotTypeName}, did you generate the ghost code?");
}
DstEntityManager.AddComponent(entity, snapshotType);
DstEntityManager.AddComponentData(entity, new GhostComponent());
if (ghostAuthoring.DefaultClientInstantiationType ==
GhostAuthoringComponent.ClientInstantionType.Interpolated)
{
foreach (var comp in ghostAuthoring.Components)
{
if (!comp.interpolatedClient && comp.entityIndex == 0)
{
toRemove.Add(comp.name);
}
}
}
else
{
DstEntityManager.AddComponentData(entity, new PredictedGhostComponent());
foreach (var comp in ghostAuthoring.Components)
{
if (!comp.predictedClient && comp.entityIndex == 0)
{
toRemove.Add(comp.name);
}
}
}
}
// Add list of things to strip based on target world
// Strip the things in GhostAuthoringConversion
var components = DstEntityManager.GetComponentTypes(entity);
foreach (var comp in components)
{
if (toRemove.Contains(comp.GetManagedType().FullName))
{
DstEntityManager.RemoveComponent(entity, comp);
}
}
});
}
protected override void OnUpdate()
{
using (var context = new BlobAssetComputationContext <int, GhostPrefabMetaData>(BlobAssetStore, 16, Allocator.Temp))
{
Entities.ForEach((GhostAuthoringComponent ghostAuthoring) =>
{
bool isPrefab = !ghostAuthoring.gameObject.scene.IsValid() || ghostAuthoring.ForcePrefabConversion;
var target = GetConversionTarget(this, isPrefab);
// Check if the ghost is valid before starting to process
if (String.IsNullOrEmpty(ghostAuthoring.prefabId))
{
throw new InvalidOperationException($"The ghost {ghostAuthoring.gameObject.name} is not a valid prefab, all ghosts must be the top-level GameObject in a prefab. Ghost instances in scenes must be instances of such prefabs and changes should be made on the prefab asset, not the prefab instance");
}
if (!isPrefab && ghostAuthoring.DefaultGhostMode == GhostAuthoringComponent.GhostMode.OwnerPredicted && target != NetcodeConversionTarget.Server)
{
throw new InvalidOperationException($"Cannot convert a owner predicted ghost {ghostAuthoring.Name} as a scene instance");
}
if (!isPrefab && DstEntityManager.World.GetExistingSystem <ClientSimulationSystemGroup>() != null)
{
throw new InvalidOperationException($"The ghost {ghostAuthoring.gameObject.name} cannot be created on the client, either put it in a sub-scene or spawn it on the server only");
}
if (ghostAuthoring.prefabId.Length != 32)
{
throw new InvalidOperationException("Invalid guid for ghost prefab type");
}
// All ghosts should have a linked entity group
DeclareLinkedEntityGroup(ghostAuthoring.gameObject);
var entity = GetPrimaryEntity(ghostAuthoring);
// Generate a ghost type component so the ghost can be identified by mathcing prefab asset guid
var ghostType = new GhostTypeComponent();
ghostType.guid0 = Convert.ToUInt32(ghostAuthoring.prefabId.Substring(0, 8), 16);
ghostType.guid1 = Convert.ToUInt32(ghostAuthoring.prefabId.Substring(8, 8), 16);
ghostType.guid2 = Convert.ToUInt32(ghostAuthoring.prefabId.Substring(16, 8), 16);
ghostType.guid3 = Convert.ToUInt32(ghostAuthoring.prefabId.Substring(24, 8), 16);
DstEntityManager.AddComponentData(entity, ghostType);
// FIXME: maybe stripping should be individual systems running before this to make sure it can be changed in a way that always triggers a reconvert - and to avoid reflection
var components = DstEntityManager.GetComponentTypes(entity);
if (target != NetcodeConversionTarget.Client)
{
// If this ghost should be usable on a server we must add a shared ghost type to make sure different ghost types
// with the same archetype end up in different chunks. If conversion is client and server the client needs to remove
// this at runtime
DstEntityManager.AddSharedComponentData(entity, new SharedGhostTypeComponent {
SharedValue = ghostType
});
}
if (target != NetcodeConversionTarget.Server)
{
// Converting to client or client and server, if client and server this should be stripped from servers at runtime
DstEntityManager.AddComponentData(entity, new SnapshotData());
DstEntityManager.AddBuffer <SnapshotDataBuffer>(entity);
}
// All types have the ghost components
DstEntityManager.AddComponentData(entity, new GhostComponent());
// No need to add the predicted ghost component for interpolated only ghosts if the data is only used by the client
if (target != NetcodeConversionTarget.Client || ghostAuthoring.SupportedGhostModes != GhostAuthoringComponent.GhostModeMask.Interpolated)
{
DstEntityManager.AddComponentData(entity, new PredictedGhostComponent());
}
if (target == NetcodeConversionTarget.Server)
{
// If converting server-only data we can remove all components which are not used on the server
foreach (var comp in components)
{
var attr = comp.GetManagedType().GetCustomAttribute <GhostComponentAttribute>();
if (attr != null && (attr.PrefabType & GhostPrefabType.Server) == 0)
{
DstEntityManager.RemoveComponent(entity, comp);
}
}
}
else if (target == NetcodeConversionTarget.Client)
{
// If converting client-only data we can remove all components which are not used on the client
// If the ghost is interpolated only we can also remove all componens which are not used on interpolated clients,
// and if it is predicted only we can remove everything which is not used on predicted clients
foreach (var comp in components)
{
var attr = comp.GetManagedType().GetCustomAttribute <GhostComponentAttribute>();
if (attr == null)
{
continue;
}
if ((attr.PrefabType & GhostPrefabType.Client) == 0)
{
DstEntityManager.RemoveComponent(entity, comp);
}
else if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.Interpolated && (attr.PrefabType & GhostPrefabType.InterpolatedClient) == 0)
{
DstEntityManager.RemoveComponent(entity, comp);
}
else if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.Predicted && (attr.PrefabType & GhostPrefabType.PredictedClient) == 0)
{
DstEntityManager.RemoveComponent(entity, comp);
}
}
}
// Even if converting for client and server we can remove components which are only for predicted clients when
// the ghost is always interpolated, or components which are only for interpolated clients if the ghost is always
// predicted
else if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.Interpolated)
{
foreach (var comp in components)
{
var attr = comp.GetManagedType().GetCustomAttribute <GhostComponentAttribute>();
if (attr != null && (attr.PrefabType & (GhostPrefabType.InterpolatedClient | GhostPrefabType.Server)) == 0)
{
DstEntityManager.RemoveComponent(entity, comp);
}
}
}
else if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.Predicted)
{
foreach (var comp in components)
{
var attr = comp.GetManagedType().GetCustomAttribute <GhostComponentAttribute>();
if (attr != null && (attr.PrefabType & (GhostPrefabType.PredictedClient | GhostPrefabType.Server)) == 0)
{
DstEntityManager.RemoveComponent(entity, comp);
}
}
}
// This logic needs to match the logic creating LinkedEntityGroups, gather a list of all child entities
var linkedEntities = new NativeList <Entity>(1, Allocator.Temp);
var selfAndChildren = ghostAuthoring.gameObject.GetComponentsInChildren <Transform>(true);
foreach (var transform in selfAndChildren)
{
foreach (var child in GetEntities(transform.gameObject))
{
if (DstEntityManager.Exists(child))
{
linkedEntities.Add(child);
}
}
}
// Mark all child entities as ghost children, entity 0 is the root and hsould not be marked
for (int i = 1; i < linkedEntities.Length; ++i)
{
DstEntityManager.AddComponentData(linkedEntities[i], default(GhostChildEntityComponent));
}
if (isPrefab)
{
var contentHash = TypeHash.FNV1A64(ghostAuthoring.Importance);
contentHash = TypeHash.CombineFNV1A64(contentHash, TypeHash.FNV1A64((int)ghostAuthoring.SupportedGhostModes));
contentHash = TypeHash.CombineFNV1A64(contentHash, TypeHash.FNV1A64((int)ghostAuthoring.DefaultGhostMode));
contentHash = TypeHash.CombineFNV1A64(contentHash, TypeHash.FNV1A64((int)ghostAuthoring.OptimizationMode));
contentHash = TypeHash.CombineFNV1A64(contentHash, TypeHash.FNV1A64(ghostAuthoring.Name.ToString()));
foreach (var comp in components)
{
contentHash = TypeHash.CombineFNV1A64(contentHash, TypeManager.GetTypeInfo(comp.TypeIndex).StableTypeHash);
var attr = comp.GetManagedType().GetCustomAttribute <GhostComponentAttribute>();
if (attr != null)
{
contentHash = TypeHash.CombineFNV1A64(contentHash, TypeHash.FNV1A64((int)attr.PrefabType));
}
}
var blobHash = new Unity.Entities.Hash128(ghostType.guid0 ^ (uint)(contentHash >> 32), ghostType.guid1 ^ (uint)(contentHash), ghostType.guid2, ghostType.guid3);
context.AssociateBlobAssetWithUnityObject(blobHash, ghostAuthoring.gameObject);
if (context.NeedToComputeBlobAsset(blobHash))
{
var builder = new BlobBuilder(Allocator.Temp);
ref var root = ref builder.ConstructRoot <GhostPrefabMetaData>();
// Store importance, supported modes, default mode and name in the meta data blob asset
root.Importance = ghostAuthoring.Importance;
root.SupportedModes = GhostPrefabMetaData.GhostMode.Both;
root.DefaultMode = GhostPrefabMetaData.GhostMode.Interpolated;
if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.Interpolated)
{
root.SupportedModes = GhostPrefabMetaData.GhostMode.Interpolated;
}
else if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.Predicted)
{
root.SupportedModes = GhostPrefabMetaData.GhostMode.Predicted;
root.DefaultMode = GhostPrefabMetaData.GhostMode.Predicted;
}
else if (ghostAuthoring.DefaultGhostMode == GhostAuthoringComponent.GhostMode.OwnerPredicted)
{
if (!DstEntityManager.HasComponent <GhostOwnerComponent>(entity))
{
throw new InvalidOperationException("OwnerPrediction mode can only be used on prefabs which have a GhostOwnerComponent");
}
root.DefaultMode = GhostPrefabMetaData.GhostMode.Both;
}
else if (ghostAuthoring.DefaultGhostMode == GhostAuthoringComponent.GhostMode.Predicted)
{
root.DefaultMode = GhostPrefabMetaData.GhostMode.Predicted;
}
root.StaticOptimization = (ghostAuthoring.OptimizationMode == GhostAuthoringComponent.GhostOptimizationMode.Static);
builder.AllocateString(ref root.Name, ghostAuthoring.Name);
var serverComponents = new NativeList <ulong>(components.Length, Allocator.Temp);
var removeOnServer = new NativeList <ulong>(components.Length, Allocator.Temp);
var removeOnClient = new NativeList <ulong>(components.Length, Allocator.Temp);
var disableOnPredicted = new NativeList <ulong>(components.Length, Allocator.Temp);
var disableOnInterpolated = new NativeList <ulong>(components.Length, Allocator.Temp);
// Snapshot data buffers should be removed from the server, and shared ghost type from the client
removeOnServer.Add(TypeManager.GetTypeInfo(ComponentType.ReadWrite <SnapshotData>().TypeIndex).StableTypeHash);
removeOnServer.Add(TypeManager.GetTypeInfo(ComponentType.ReadWrite <SnapshotDataBuffer>().TypeIndex).StableTypeHash);
removeOnClient.Add(TypeManager.GetTypeInfo(ComponentType.ReadWrite <SharedGhostTypeComponent>().TypeIndex).StableTypeHash);
// If both interpolated and predicted clients are supported the interpolated client needs to disable the prediction component
// If the ghost is interpolated only the prediction component can be removed on clients
if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.All)
{
disableOnInterpolated.Add(TypeManager.GetTypeInfo(ComponentType.ReadWrite <PredictedGhostComponent>().TypeIndex).StableTypeHash);
}
else if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.Interpolated)
{
removeOnClient.Add(TypeManager.GetTypeInfo(ComponentType.ReadWrite <PredictedGhostComponent>().TypeIndex).StableTypeHash);
}
foreach (var comp in components)
{
var hash = TypeManager.GetTypeInfo(comp.TypeIndex).StableTypeHash;
var attr = comp.GetManagedType().GetCustomAttribute <GhostComponentAttribute>();
if (attr == null)
{
serverComponents.Add(hash);
continue;
}
if ((attr.PrefabType & GhostPrefabType.Server) == 0)
{
removeOnServer.Add(hash);
}
else
{
serverComponents.Add(hash);
}
// If something is not used on the client, remove it. Make sure to include things that is interpolated only if ghost
// is predicted only and the other way around
if ((attr.PrefabType & GhostPrefabType.Client) == 0)
{
removeOnClient.Add(hash);
}
else if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.Interpolated &&
(attr.PrefabType & GhostPrefabType.InterpolatedClient) == 0)
{
removeOnClient.Add(hash);
}
else if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.Predicted &&
(attr.PrefabType & GhostPrefabType.PredictedClient) == 0)
{
removeOnClient.Add(hash);
}
// If the prefab only supports a single mode on the client there is no need to enable / disable, if is handled by the
// previous loop removing components on the client instead
if (ghostAuthoring.SupportedGhostModes == GhostAuthoringComponent.GhostModeMask.All)
{
// Components available on predicted but not interpolated should be disabled on interpolated clients
if ((attr.PrefabType & GhostPrefabType.InterpolatedClient) == 0 && (attr.PrefabType & GhostPrefabType.PredictedClient) != 0)
{
disableOnInterpolated.Add(hash);
}
if ((attr.PrefabType & GhostPrefabType.InterpolatedClient) != 0 && (attr.PrefabType & GhostPrefabType.PredictedClient) == 0)
{
disableOnPredicted.Add(hash);
}
}
}
var blobServerComponents = builder.Allocate(ref root.ServerComponentList, serverComponents.Length);
for (int i = 0; i < serverComponents.Length; ++i)
{
blobServerComponents[i] = serverComponents[i];
}
// A pre-spawned instance can be created in ClientServer even if the prefab is not, so anything which should
// be usable on the server needs to know what to remove from the server version
if (target != NetcodeConversionTarget.Client)
{
// Client only data never needs information about the server
var blobRemoveOnServer = builder.Allocate(ref root.RemoveOnServer, removeOnServer.Length);
for (int i = 0; i < removeOnServer.Length; ++i)
{
blobRemoveOnServer[i] = removeOnServer[i];
}
}
else
{
builder.Allocate(ref root.RemoveOnServer, 0);
}
if (target != NetcodeConversionTarget.Server)
{
var blobRemoveOnClient = builder.Allocate(ref root.RemoveOnClient, removeOnClient.Length);
for (int i = 0; i < removeOnClient.Length; ++i)
{
blobRemoveOnClient[i] = removeOnClient[i];
}
}
else
{
builder.Allocate(ref root.RemoveOnClient, 0);
}
if (target != NetcodeConversionTarget.Server)
{
// The data for interpolated / predicted diff is required unless this is server-only
var blobDisableOnPredicted = builder.Allocate(ref root.DisableOnPredictedClient, disableOnPredicted.Length);
for (int i = 0; i < disableOnPredicted.Length; ++i)
{
blobDisableOnPredicted[i] = disableOnPredicted[i];
}
var blobDisableOnInterpolated = builder.Allocate(ref root.DisableOnInterpolatedClient, disableOnInterpolated.Length);
for (int i = 0; i < disableOnInterpolated.Length; ++i)
{
blobDisableOnInterpolated[i] = disableOnInterpolated[i];
}
}
else
{
builder.Allocate(ref root.DisableOnPredictedClient, 0);
builder.Allocate(ref root.DisableOnInterpolatedClient, 0);
}
var blobAsset = builder.CreateBlobAssetReference <GhostPrefabMetaData>(Allocator.Persistent);
context.AddComputedBlobAsset(blobHash, blobAsset);
}
context.GetBlobAsset(blobHash, out var blob);
DstEntityManager.AddComponentData(entity, new GhostPrefabMetaDataComponent {
Value = blob
});
}
});