public void Convert(GameObject gameObject, Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponent <GhostOwnerComponent>(entity);
dstManager.AddComponent <GhostPredictedOnly>(entity);
dstManager.AddComponent <GhostInterpolatedOnly>(entity);
dstManager.AddComponent <GhostGen_IntStruct>(entity);
dstManager.AddComponent <GhostTypeIndex>(entity);
dstManager.AddBuffer <GhostGenBuffer_ByteBuffer>(entity);
dstManager.AddBuffer <GhostGenTest_Buffer>(entity);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new Engine {
ForwardThrust = ForwardThrust, TurningThrust = TurningThrust
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new EntityPrefab(dstManager, entity, new FixedString64(Name)));
}
public void Convert(Unity.Entities.Entity entity, Unity.Entities.EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new PlayerReadyStateComponent {
IsReady = IsReady
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
//Create a separate entity to hold the waypoint buffer
Entity holder = dstManager.CreateEntity();
//dstManager.SetName(holder, "Waypoint Holder 1");
DynamicBuffer <WayPoint> tempBuff = dstManager.AddBuffer <WayPoint>(holder);
foreach (float3 location in positions1) //Add the waypoints
{
tempBuff.Add(new WayPoint {
value = location
});
}
dstManager.AddComponentData <FollowWayPointsStorage>(holder, new FollowWayPointsStorage {
id = 0,
curPointNum = 0
}); // add the FollowWayPointsAction to the crowd agent
Entity holder2 = dstManager.CreateEntity();
//dstManager.SetName(holder2, "Waypoint Holder 2");
DynamicBuffer <WayPoint> tempBuff2 = dstManager.AddBuffer <WayPoint>(holder2);
tempBuff2.Add(new WayPoint {
value = new float3(0, 0, 0)
});
dstManager.AddComponentData <FollowWayPointsStorage>(holder2, new FollowWayPointsStorage {
id = 1,
curPointNum = 0
}); // add the FollowWayPointsAction to the crowd agent*/
DynamicBuffer <Action> dynamicBuffer = dstManager.AddBuffer <Action>(entity); // add a buffer to the entity
//wpBuffer.Add(new WayPoint {point = float3.zero} );
for (int i = 0; i < priorites.Length; i++)
{
int curPriority = priorites[i];
//int curMessage = messages[i];
float curTime = times[i];
//find out where the new element should be added
int pos = 0;
//Debug.Log(i + " try, Length is: " + dynamicBuffer.Length);
while (pos < dynamicBuffer.Length && curPriority <= dynamicBuffer[pos].priority)
{
if (curPriority == dynamicBuffer[pos].priority) // if the current priorities are the same
//compare the times
{
if (curTime >= dynamicBuffer[pos].timeCreated) // if the current elements time is greater than the other element's time, this element should go later
{
pos++;
}
else
{
break;
}
}
else if (curPriority < dynamicBuffer[pos].priority) // if this elements priority is smaller than the other element's priority, this element should go later
{
pos++;
}
else
{
break;
}
}
//add the element at that location
if (i == 0)
{
dynamicBuffer.Insert(
pos,
new Action {
id = i,
priority = priorites[i],
type = ActionType.Follow_WayPoints,
timeCreated = times[i],
dataHolder = holder,
}); // the Values (in the buffer) are the values in the array
}
else if (i == 1)
{
dynamicBuffer.Insert(
pos,
new Action {
id = i,
priority = priorites[i],
type = ActionType.Follow_WayPoints,
timeCreated = times[i],
dataHolder = holder2,
}); // the Values (in the buffer) are the values in the array
}
}
dstManager.AddComponentData <CurrentAction>(entity, new CurrentAction {
id = 22,
type = ActionType.Follow_WayPoints
});
dstManager.AddComponentData <FollowWayPointsAction>(entity, new FollowWayPointsAction {
id = 22,
curPointNum = 0
});
DynamicBuffer <WayPoint> wpBuffer = dstManager.AddBuffer <WayPoint>(entity); // add a buffer to the entity
wpBuffer.Add(new WayPoint {
value = new float3(1, 1, 1)
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new EntityUpdater {
TimeToDie = TimeToDie, TimeToMove = TimeToMove
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentObject(entity, GetComponent <AnimationPlayer>());
dstManager.AddComponent(entity, ComponentType.ReadOnly <CopyTransformToGameObject>());
}
void IConvertGameObjectToEntity.Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new ModifyContactJacobians {
type = ModificationType
});
}
public static void Convert(
Entity entity,
EntityManager dstEntityManager,
GameObjectConversionSystem conversionSystem,
Renderer meshRenderer,
Mesh mesh,
List <Material> materials)
{
var materialCount = materials.Count;
// Don't add RenderMesh (and other required components) unless both mesh and material assigned.
if ((mesh != null) && (materialCount > 0))
{
var renderMesh = new RenderMesh
{
mesh = mesh,
castShadows = meshRenderer.shadowCastingMode,
receiveShadows = meshRenderer.receiveShadows,
layer = meshRenderer.gameObject.layer
};
renderMesh.needMotionVectorPass = (meshRenderer.motionVectorGenerationMode == MotionVectorGenerationMode.Object) ||
(meshRenderer.motionVectorGenerationMode == MotionVectorGenerationMode.ForceNoMotion);
//@TODO: Transform system should handle RenderMeshFlippedWindingTag automatically. This should not be the responsibility of the conversion system.
float4x4 localToWorld = meshRenderer.transform.localToWorldMatrix;
var flipWinding = math.determinant(localToWorld) < 0.0;
if (materialCount == 1 && AttachToPrimaryEntityForSingleMaterial)
{
AddComponentsToEntity(
renderMesh,
entity,
dstEntityManager,
conversionSystem,
meshRenderer,
mesh,
materials,
flipWinding,
0);
}
else
{
for (var m = 0; m != materialCount; m++)
{
var meshEntity = conversionSystem.CreateAdditionalEntity(meshRenderer);
dstEntityManager.AddComponentData(meshEntity, new LocalToWorld {
Value = localToWorld
});
if (!dstEntityManager.HasComponent <Static>(meshEntity))
{
dstEntityManager.AddComponentData(meshEntity, new Parent {
Value = entity
});
dstEntityManager.AddComponentData(meshEntity, new LocalToParent {
Value = float4x4.identity
});
}
AddComponentsToEntity(
renderMesh,
meshEntity,
dstEntityManager,
conversionSystem,
meshRenderer,
mesh,
materials,
flipWinding,
m);
}
}
}
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new State());
dstManager.AddBuffer <AbilityUIElement>(entity);
dstManager.AddBuffer <PresentationElement>(entity);
}
public void Convert(GameObject gameObject, Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new GhostValueSerializer {
});
}
public void Convert(GameObject gameObject, Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new GhostTypeIndex {
Value = gameObject.name == "GhostTypeIndex1Test" ? 1 : 0
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new RotationEulerXYZ());
}
void IConvertGameObjectToEntity.Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new VerifyBodyPairsIteratorData());
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var state = AnimConditionDead.State.Default;
dstManager.AddComponentData(entity, state);
}
private static void AddComponentsToEntity(
RenderMesh renderMesh,
Entity entity,
EntityManager dstEntityManager,
GameObjectConversionSystem conversionSystem,
Renderer meshRenderer,
Mesh mesh,
List <Material> materials,
bool flipWinding,
int id)
{
renderMesh.material = materials[id];
renderMesh.subMesh = id;
dstEntityManager.AddSharedComponentData(entity, renderMesh);
dstEntityManager.AddComponentData(entity, new PerInstanceCullingTag());
dstEntityManager.AddComponentData(entity, new RenderBounds {
Value = mesh.bounds.ToAABB()
});
if (flipWinding)
{
dstEntityManager.AddComponent(entity, ComponentType.ReadWrite <RenderMeshFlippedWindingTag>());
}
conversionSystem.ConfigureEditorRenderData(entity, meshRenderer.gameObject, true);
#if ENABLE_HYBRID_RENDERER_V2 && UNITY_2020_1_OR_NEWER && (HDRP_9_0_0_OR_NEWER || URP_9_0_0_OR_NEWER)
// Hybrid V2 uploads WorldToLocal from C# to rendering. Need to refresh it.
// TODO: Do this on GPU side in the copy compute shader. Would be free in BW bound shader!
dstEntityManager.AddComponent(entity, ComponentType.ReadWrite <WorldToLocal>());
#if HDRP_9_0_0_OR_NEWER
// HDRP previous frame matrices (for motion vectors)
if (renderMesh.needMotionVectorPass)
{
dstEntityManager.AddComponent(entity, ComponentType.ReadWrite <BuiltinMaterialPropertyUnity_MatrixPreviousM>());
dstEntityManager.AddComponent(entity, ComponentType.ReadWrite <BuiltinMaterialPropertyUnity_MatrixPreviousMI>());
}
dstEntityManager.AddComponentData(entity, CreateMotionVectorsParams(ref renderMesh, ref meshRenderer));
#endif
dstEntityManager.AddComponentData(entity, new BuiltinMaterialPropertyUnity_RenderingLayer
{
Value = new uint4(meshRenderer.renderingLayerMask, 0, 0, 0)
});
dstEntityManager.AddComponentData(entity, new BuiltinMaterialPropertyUnity_WorldTransformParams
{
Value = flipWinding ? new float4(0, 0, 0, -1) : new float4(0, 0, 0, 1)
});
#if URP_9_0_0_OR_NEWER
// Default initialized light data for URP
dstEntityManager.AddComponentData(entity, new BuiltinMaterialPropertyUnity_LightData
{
Value = new float4(0, 0, 1, 0)
});
#endif
#endif
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new Shield {
Health = Capacity, Radius = Radius
});
}
public override CardLibraryData ConvertGameData(GameObject gameObject, Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem, CardLibraryDataSO dataSO)
{
var data = new CardLibraryData();
data.Id = dataSO.Id;
data.Name = dataSO.Name;
ushort[] dataIds = dataSO.Datas.Select((d) => d == null ? (ushort)0: d.DataId).ToArray();
data.DataIdsAssetRef = EntityUtil.CreateArrayAssetRef(dataIds);
//var len = dataSO.CardDatas.Length;
//data.CardNum = (ushort)len;
//var builder = new BlobBuilder(Allocator.Temp);
//ref var root = ref builder.ConstructRoot<CardDataAsset>();
//var array = builder.Allocate(ref root.CardDataIds, len);
//for (int i = 0; i < len; i++)
//{
// var cardData = dataSO.CardDatas[i];
// if (cardData != null)
// {
// array[i] = cardData.Id;
// }
//}
//data.DataAssetRef = builder.CreateBlobAssetReference<CardDataAsset>(Allocator.Persistent);
//builder.Dispose();
return(data);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
prefabEntity = conversionSystem.GetPrimaryEntity(prefab);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new ShipTagComponentData());
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem) =>
dstManager.AddComponentData(entity, new LifeTime {
Value = Value
});
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new VerifyCollisionEventsData());
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponent <Projectile>(entity);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new PlayerControlled.State());
}
// add empty copy to attached entity
public void Convert(Entity entity, EntityManager dstManager,
GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new BoundMarkerEdge());
}
void IConvertGameObjectToEntity.Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new MousePick()
{
IgnoreTriggers = IgnoreTriggers ? 1 : 0,
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new RuntimeUnmanaged {
Value = Value
});
}
void IConvertGameObjectToEntity.Convert(Entity entity, EntityManager dstManager,
GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new Table());
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
using (NativeArray <Entity> obstacleEntities = dstManager.CreateEntity(dstManager.CreateObstacleArchetype(), this.obstacleDTOs.Count, Allocator.Temp))
{
for (int i = 0; i < obstacleDTOs.Count; ++i)
{
dstManager.SetComponentData(obstacleEntities[i], new Translation
{
Value = this.obstacleDTOs[i].Transform.position
});
dstManager.SetComponentData(obstacleEntities[i], new Rotation
{
Value = this.obstacleDTOs[i].Transform.rotation
});
dstManager.SetComponentData(obstacleEntities[i], new NonUniformScale
{
Value = this.obstacleDTOs[i].Transform.lossyScale
});
dstManager.SetComponentData(obstacleEntities[i], new RenderBounds
{
Value = new AABB
{
Center = this.obstacleDTOs[i].Mesh.bounds.center,
Extents = this.obstacleDTOs[i].Mesh.bounds.extents
}
});
if (this.obstacleDTOs[i].OverrideBoxCollider == null)
{
dstManager.SetComponentData(obstacleEntities[i], new PhysicsCollider
{
Value = BoxCollider.Create
(
CollisionGeomeotrySingleton.Instance.CreateOrGetBoxGeometry(this.obstacleDTOs[i].WorldSpaceBounds.size),
CollisionFilterSingleton.Instance.BelongsToNonTraversableFilter
)
});
}
else
{
dstManager.SetComponentData(obstacleEntities[i], new PhysicsCollider
{
Value = BoxCollider.Create
(
CollisionGeomeotrySingleton.Instance.CreateOrGetBoxGeometry(this.obstacleDTOs[i].OverrideBoxCollider.size, this.obstacleDTOs[i].OverrideBoxCollider.center),
CollisionFilterSingleton.Instance.BelongsToNonTraversableFilter
)
});
}
dstManager.AddSharedComponentData(obstacleEntities[i], new RenderMesh
{
mesh = this.obstacleDTOs[i].Mesh,
//Currently just choose the first material, but later on it should be possible to have more than 1 material for meshes
material = this.obstacleDTOs[i].Materials[0]
});
}
}
DestroyImmediate(obstacleHolder);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
this.entity = entity;
this.entityManager = dstManager;
}
