public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponent <UINumbers>(entity);
dstManager.AddBuffer <UINumberMaterial>(entity);
if (!conversionSystem.TryGetBuildConfigurationComponent <DotsRuntimeBuildProfile>(out var _))
{
return;
}
//Add additional entity for the Empty material
var primaryEntity = conversionSystem.GetPrimaryEntity(Empty);
var mat = dstManager.GetComponentData <SimpleMaterial>(primaryEntity);
Entity additionalEntity = conversionSystem.CreateAdditionalEntity(Empty);
dstManager.AddComponentData <SimpleMaterial>(additionalEntity, mat);
//Add additional entities for each numbers material
for (int i = 0; i < Numbers.Length; i++)
{
primaryEntity = conversionSystem.GetPrimaryEntity(Numbers[i]);
mat = dstManager.GetComponentData <SimpleMaterial>(primaryEntity);
additionalEntity = conversionSystem.CreateAdditionalEntity(Numbers[i]);
dstManager.AddComponentData <SimpleMaterial>(additionalEntity, mat);
}
}
private Entity GetCurveEntityFromAnimationCurve(AnimationCurve curve, float multiplier, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var curveEntity = conversionSystem.CreateAdditionalEntity(this);
var keysEntity = conversionSystem.CreateAdditionalEntity(this);
var curveFloat = new BezierCurveFloat {
keys = keysEntity
};
dstManager.AddComponentData <BezierCurveFloat>(curveEntity, curveFloat);
var buffer = dstManager.AddBuffer <BezierKeyFloat>(keysEntity);
var keyFrames = curve.keys;
for (int i = 0; i < keyFrames.Length; i++)
{
var keyFrame = keyFrames[i];
var time = keyFrame.time;
var value = keyFrame.value;
value *= multiplier;
var inValue = value - keyFrame.inTangent * 0.15f;
var outValue = value + keyFrame.outTangent * 0.15f;
buffer.Add(new BezierKeyFloat(time, value, inValue, outValue));
}
return(curveEntity);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
conversionSystem.DeclareLinkedEntityGroup(this.gameObject);
Entity additional1 = conversionSystem.CreateAdditionalEntity(this.gameObject);
dstManager.SetName(additional1, $"{this.name}_Add1");
Entity additional2 = conversionSystem.CreateAdditionalEntity(this.gameObject);
dstManager.SetName(additional2, $"{this.name}_Add2");
conversionSystem.GetPrimaryEntity(referPrefab);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var player = entity;
dstManager.AddComponentData <Position>(player, new float2(10, 8));
dstManager.AddComponentData <Renderable>(player, new Renderable
{
FGColor = Color.yellow,
BGColor = Color.black,
Glyph = RLTK.CodePage437.ToCP437('@')
});
dstManager.AddComponentData <InputData>(player, new InputData());
for (int i = 0; i < 10; ++i)
{
var e = conversionSystem.CreateAdditionalEntity(gameObject);
var renderable = new Renderable
{
FGColor = Color.red,
BGColor = Color.black,
Glyph = RLTK.CodePage437.ToCP437('☺')
};
dstManager.AddComponentData <Position>(e, new float2(i * 3, 13));
dstManager.AddComponentData(e, renderable);
dstManager.AddComponentData(e, new MoveLeft {
Speed = 15
});
}
}
public static Entity ConvertSubmesh(GameObjectConversionSystem gsys, UnityEngine.MeshRenderer uMeshRenderer,
UnityEngine.Mesh uMesh, Entity meshEntity, int subMeshIndex, Entity materialEntity)
{
Entity primaryMeshRenderer = gsys.GetPrimaryEntity(uMeshRenderer);
Entity meshRendererEntity = primaryMeshRenderer;
if (subMeshIndex > 0)
{
meshRendererEntity = gsys.CreateAdditionalEntity(uMeshRenderer);
AddTransformComponent(gsys, primaryMeshRenderer, meshRendererEntity);
}
gsys.DstEntityManager.AddComponentData(meshRendererEntity, new Unity.Tiny.Rendering.MeshRenderer()
{
mesh = meshEntity,
material = materialEntity,
startIndex = Convert.ToInt32(uMesh.GetIndexStart(subMeshIndex)),
indexCount = Convert.ToInt32(uMesh.GetIndexCount(subMeshIndex))
});
gsys.DstEntityManager.AddComponentData(meshRendererEntity, new Unity.Tiny.Rendering.CameraMask()
{
mask = (ulong)(1 << uMeshRenderer.gameObject.layer)
});
gsys.DstEntityManager.AddComponentData(meshRendererEntity, new WorldBounds());
return(meshRendererEntity);
}
private static Entity GenerateMeshRendererEntity(GameObjectConversionSystem gsys,
UnityEngine.SkinnedMeshRenderer uSkinnedMeshRenderer, Entity meshEntity, Entity materialEntity, int startIndex,
int indexCount, bool createAdditionlEntity, bool canUseGPUSkinning, bool canUseCPUSkinning)
{
Entity primarySkinnedMeshRenderer = gsys.GetPrimaryEntity(uSkinnedMeshRenderer);
Entity meshRendererEntity = primarySkinnedMeshRenderer;
if (createAdditionlEntity)
{
meshRendererEntity = gsys.CreateAdditionalEntity(uSkinnedMeshRenderer);
MeshRendererConversion.AddTransformComponent(gsys, primarySkinnedMeshRenderer, meshRendererEntity);
}
Unity.Tiny.Rendering.SkinnedMeshRenderer smr = new Unity.Tiny.Rendering.SkinnedMeshRenderer();
smr.sharedMesh = meshEntity;
smr.material = materialEntity;
smr.startIndex = startIndex;
smr.indexCount = indexCount;
smr.canUseGPUSkinning = canUseGPUSkinning;
smr.canUseCPUSkinning = canUseCPUSkinning;
smr.shadowCastingMode = (Unity.Tiny.Rendering.ShadowCastingMode)uSkinnedMeshRenderer.shadowCastingMode;
smr.skinQuality = ConvertSkinQuality(uSkinnedMeshRenderer);
gsys.DstEntityManager.AddComponentData(meshRendererEntity, smr);
gsys.DstEntityManager.AddComponentData(meshRendererEntity, new WorldBounds());
return(meshRendererEntity);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var rt = this.GetComponent <RectTransform>();
textTransform.rect = rt.rect;
dstManager.AddComponentData <TextTransform>(entity, textTransform);
//Account for pivot, so pivot could be anywhere and not influencing starting position of glyphs.
var shiftBack = rt.pivot;
shiftBack.y = 1 - shiftBack.y;
shiftBack *= rt.sizeDelta;
var translation = dstManager.GetComponentData <Translation>(entity);
translation.Value.x -= shiftBack.x;
translation.Value.y += shiftBack.y;
dstManager.SetComponentData <Translation>(entity, translation);
dstManager.AddComponent <FontMetrics>(entity);
var ea = new NativeArray <GlyphEntityGroup>(persistentCharacterEntities, Allocator.Temp);
for (int i = 0; i < persistentCharacterEntities; i++)
{
Entity persistentCharacter = conversionSystem.CreateAdditionalEntity(this.gameObject);
#if UNITY_EDITOR
dstManager.SetName(persistentCharacter, $"{this.name}_Char{i}");
#endif
foreach (var type in ArchetypeCollection.CharacterTypes)
{
dstManager.AddComponent(persistentCharacter, type);
}
ea[i] = new GlyphEntityGroup {
character = persistentCharacter
};
//buffer.Add(new CharacterEntityGroup {character = persistentCharacter});
dstManager.SetComponentData(persistentCharacter, new Parent {
Value = entity
});
}
var buffer = dstManager.AddBuffer <GlyphEntityGroup>(entity);
buffer.AddRange(ea);
dstManager.AddComponentData(entity, new TextContent
{
text = text,
});
textStructure.persistentCharacterEntityMode = persistentCharacterEntities > 0;
dstManager.AddComponentData <TextStructure>(entity, textStructure);
dstManager.AddSharedComponentData <FontAssetHolder>(entity, new FontAssetHolder
{
htmFontAsset = htmFontAsset
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
//var rootPath = EditorApplication.applicationContentsPath;
//var path = Path.Combine(rootPath, DataPath);
dstManager.AddComponent <GameDataManager>(entity);
var folders = AssetDatabase.GetSubFolders(DataPath);
if (folders != null)
{
for (int i = 0; i < folders.Length; i++)
{
var folderPath = folders[i];
var typeName = GetGameDataTypeNameFromPath(folderPath);
if (authoringDict.TryGetValue(typeName, out var authoring))
{
//Debug.LogFormat("Convert: {0}: {1}, {2}", i, folderPath, authoring.GetType().Name);
var listEntity = conversionSystem.CreateAdditionalEntity(this);
authoring.Convert(gameObject, listEntity, dstManager, conversionSystem);
}
}
}
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var blob = new NodeBlobRef(_source.GetBlobAsset());
var bb = new EntityBlackboard {
Entity = entity, EntityManager = dstManager
};
VirtualMachine.Reset(ref blob, ref bb);
dstManager.AddBuffer <BehaviorTreeBufferElement>(entity);
dstManager.AddComponent <CurrentBehaviorTreeComponent>(entity);
var behaviorTreeEntity = conversionSystem.CreateAdditionalEntity(gameObject);
#if UNITY_EDITOR
dstManager.SetName(behaviorTreeEntity, $"[BT]{dstManager.GetName(entity)}:{_order}.{_debugName}");
#endif
var query = blob.GetAccessTypes();
var dataQuery = new BlackboardDataQuery(query, components =>
// HACK: workaround for different world/dstManager in subscenes.
// dstManager.CreateEntityQuery(components.ToArray()));
World.DefaultGameObjectInjectionWorld.EntityManager.CreateEntityQuery(components.ToArray()));
dstManager.AddSharedComponentData(behaviorTreeEntity, dataQuery);
dstManager.AddComponentData(behaviorTreeEntity, new BehaviorTreeComponent
{
Blob = blob, Thread = _thread, AutoCreation = _autoCreateTypes
});
dstManager.AddComponentData(behaviorTreeEntity, new BehaviorTreeTargetComponent {
Value = entity
});
dstManager.AddComponentData(behaviorTreeEntity, new BehaviorTreeOrderComponent {
Value = _order
});
}
/// <summary>
/// Convert the given <see cref="Renderer"/> into a multiple Hybrid Rendered entities such that every
/// <see cref="Material"/> in the <see cref="Renderer"/> is converted into one entity that uses that <see cref="Material"/>
/// with the corresponding sub-mesh from <see cref="RenderMesh.mesh"/>. All created entities will be parented
/// to the entity created from <see cref="root"/>.
/// </summary>
public void ConvertToMultipleEntities(
EntityManager dstEntityManager,
GameObjectConversionSystem conversionSystem,
RenderMeshDescription renderMeshDescription,
Renderer renderer,
List <Material> sharedMaterials,
Transform root)
{
int materialCount = sharedMaterials.Count;
float4x4 localToWorld = root.localToWorldMatrix;
var rootEntity = conversionSystem.GetPrimaryEntity(root);
for (var m = 0; m != materialCount; m++)
{
var meshEntity = conversionSystem.CreateAdditionalEntity(renderer);
// required for incremental conversion to work without a dependency on the transform itself.
dstEntityManager.AddComponent <CopyTransformFromPrimaryEntityTag>(meshEntity);
dstEntityManager.AddComponentData(meshEntity, new LocalToWorld {
Value = localToWorld
});
if (!dstEntityManager.HasComponent <Static>(meshEntity))
{
dstEntityManager.AddComponentData(meshEntity, new Parent {
Value = rootEntity
});
dstEntityManager.AddComponentData(meshEntity,
new LocalToParent {
Value = float4x4.identity
});
}
var material = sharedMaterials[m];
var lightmappedMaterial = ConfigureHybridLightMapping(
meshEntity,
dstEntityManager,
renderer,
material);
if (lightmappedMaterial != null)
{
material = lightmappedMaterial;
}
renderMeshDescription.RenderMesh.subMesh = m;
renderMeshDescription.RenderMesh.material = material;
RenderMeshUtility.AddComponents(
meshEntity,
dstEntityManager,
renderMeshDescription);
RemoveLightProbeComponentsFromLightMappedEntities(meshEntity, dstEntityManager);
conversionSystem.ConfigureEditorRenderData(meshEntity, renderer.gameObject, true);
}
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var e = conversionSystem.CreateAdditionalEntity(this);
dstManager.AddComponentData(e, new SetFixedTimestep {
Timestep = 1f / StepsPerSecond
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponent <UINumbers>(entity);
dstManager.AddBuffer <UINumberMaterial>(entity);
//Add additional entity for the Empty material
var primaryEntity = conversionSystem.GetPrimaryEntity(Empty);
var mat = dstManager.GetComponentData <SimpleMaterial>(primaryEntity);
Entity additionalEntity = conversionSystem.CreateAdditionalEntity(Empty);
dstManager.AddComponentData <SimpleMaterial>(additionalEntity, mat);
//Add additional entities for each numbers material
for (int i = 0; i < Numbers.Length; i++)
{
primaryEntity = conversionSystem.GetPrimaryEntity(Numbers[i]);
mat = dstManager.GetComponentData <SimpleMaterial>(primaryEntity);
additionalEntity = conversionSystem.CreateAdditionalEntity(Numbers[i]);
dstManager.AddComponentData <SimpleMaterial>(additionalEntity, mat);
}
}
// モーションエンティティ生成
// メインオブジェクトの関連エンティティとして生成し、リンクもここでつける。
static Entity createMotionEntity
(GameObjectConversionSystem gcs, GameObject motionMain, ComponentType[] motionTypes)
{
var em = gcs.DstEntityManager;
var motionArchetype = em.CreateArchetype(motionTypes);
var motionEntity = gcs.CreateAdditionalEntity(motionMain, motionArchetype);
em.SetName_(motionEntity, $"{motionMain.name} motion");
return(motionEntity);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, GetLightSource());
dstManager.AddComponentData(entity, GetLightPosition());
dstManager.AddComponentData(entity,
new Velocity {
vel = 0,
angVel = angularVelocity * Mathf.Deg2Rad,
}
);
dstManager.AddComponentData(entity,
new Mass {
mass = math.INFINITY,
inertia = inertia
}
);
dstManager.AddComponentData(entity,
new GravityScale {
gravityScale = 0
}
);
dstManager.AddComponentData(entity, new IgnoreHierarchyTag());
if (toTrack != null)
{
dstManager.AddComponentData(entity,
new LightTrackingJoint {
toTrack = conversionSystem.GetPrimaryEntity(toTrack),
trackSpeed = math.radians(trackSpeed),
trackSoftness = trackSoftness
}
);
}
foreach (var snapInfo in snapInfos)
{
var joint = conversionSystem.CreateAdditionalEntity(gameObject);
dstManager.SetName(joint, "Light mount joint");
dstManager.AddComponentData(joint,
new LightMountJoint {
lightEntity = entity,
mount = conversionSystem.GetPrimaryEntity(snapInfo.mount),
rangeStart = Ang.SignedAngleOf(snapInfo.ccw),
rangeEnd = Ang.SignedAngleOf(snapInfo.cw),
id = Random.Range(0, int.MaxValue)
}
);
}
}
// ストリームエンティティ生成
// ボーンオブジェクトの関連エンティティとして生成する。
//
static Entity[] createStreamEntitiesOfSection
(
GameObjectConversionSystem gcs, GameObject[] enabledBoneObjects,
ComponentType[] streamTypes
)
{
var em = gcs.DstEntityManager;
var streamArchetype = em.CreateArchetype(streamTypes);
var streamEntities = enabledBoneObjects
.Select(boneObject => gcs.CreateAdditionalEntity(boneObject, streamArchetype))
.Do(ent => em.SetName_(ent, $"{em.GetName_(ent)} stream"))
.ToArray();
return(streamEntities);
}
public static void CreatePanel(EntityManager dstManager, GameObjectConversionSystem conversionSystem, GameObject gameObject, GameObject prefab, LocalToWorld localToWorld)
{
var meshRenderer = prefab.GetComponent <MeshRenderer>();
var meshFilter = prefab.GetComponent <MeshFilter>();
var materials = new List <Material>(10);
var mesh = meshFilter.sharedMesh;
meshRenderer.GetSharedMaterials(materials);
var segmentEntity = conversionSystem.CreateAdditionalEntity(gameObject);
var pos = localToWorld.Position;
var renderBounds = new RenderBounds
{
Value = new AABB
{
Center = new float3(0.0f, 0.0f, 0.0f),
Extents = new float3(0.5f, 0.5f, 0.5f)
}
};
var worldRenderBounds = new WorldRenderBounds
{
Value = new AABB
{
Center = pos,
Extents = new float3(0.5f, 0.5f, 0.5f)
}
};
var frozenRenderSceneTag = new FrozenRenderSceneTag
{
HasStreamedLOD = 0,
SceneGUID = Hash128.Compute("Grid Panel"),
SectionIndex = 0
};
#if UNITY_EDITOR
dstManager.SetName(segmentEntity, "Grid Panel");
#endif
dstManager.AddComponentData(segmentEntity, localToWorld);
dstManager.AddComponentData(segmentEntity, renderBounds);
dstManager.AddComponentData(segmentEntity, worldRenderBounds);
dstManager.AddSharedComponentData(segmentEntity, frozenRenderSceneTag);
dstManager.AddComponent(segmentEntity, typeof(Static));
CreateRenderMesh(segmentEntity, dstManager, conversionSystem, meshRenderer, mesh, materials);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
Entity swappableDetector = conversionSystem.CreateAdditionalEntity(this);
dstManager.AddBuffer <DirectContactStore>(swappableDetector);
dstManager.AddComponent <Box>(swappableDetector);
dstManager.AddComponent <Position>(swappableDetector);
dstManager.AddComponent <IsTrigger>(swappableDetector);
dstManager.AddComponentData(entity,
new PlayerRoot {
swappableDetector = swappableDetector
}
);
dstManager.AddComponent <ActivePlayer>(entity);
dstManager.AddBuffer <DirectContactStore>(entity);
dstManager.AddBuffer <ShadowContactStore>(entity);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
foreach (var giveItem in GiveItems)
{
var item = conversionSystem.GetPrimaryEntity(giveItem.prefab);
var give = conversionSystem.CreateAdditionalEntity(gameObject);
dstManager.AddComponentData(give, new GiveItem
{
item = item,
amount = giveItem.amount,
receiver = entity
});
#if UNITY_EDITOR
var name = dstManager.GetName(item);
dstManager.SetName(give, $"Give {name}");
#endif
}
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new EntityRefTestData {
Value = conversionSystem.GetPrimaryEntity(Value)
});
for (int i = 0; i != AdditionalEntityCount; i++)
{
var additional = conversionSystem.CreateAdditionalEntity(this);
dstManager.AddComponentData(additional, new EntityRefTestData {
Value = conversionSystem.GetPrimaryEntity(Value)
});
}
if (DeclareLinkedEntityGroup)
{
conversionSystem.DeclareLinkedEntityGroup(gameObject);
}
}
// ----------------------------------------------------------------------------------
static Entity createDrawInstanceEntity
(GameObjectConversionSystem gcs, GameObject top, GameObject main)
{
var em = gcs.DstEntityManager;
var archetype = em.CreateArchetype
(
typeof(DrawInstance.MeshTag),
typeof(DrawInstance.ModeLinkData),
typeof(DrawInstance.PostureLinkData),
typeof(DrawInstance.TargetWorkData)
);
var ent = gcs.CreateAdditionalEntity(top, archetype);
em.SetComponentData(ent,
new DrawInstance.ModeLinkData
{
DrawModelEntityCurrent = gcs.GetFromModelEntityDictionary(top),
}
);
em.SetComponentData(ent,
new DrawInstance.PostureLinkData
{
PostureEntity = gcs.GetPrimaryEntity(main),
}
);
em.SetComponentData(ent,
new DrawInstance.TargetWorkData
{
DrawInstanceId = -1,
}
);
em.SetName_(ent, $"{top.name} draw");
return(ent);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
for (int j = 0; j < vehiclePrefabs.Count; j++)
{
// A primary entity needs to be called before additional entities can be used
Entity vehiclePrefab = conversionSystem.CreateAdditionalEntity(this);
var prefabData = new VehiclePrefabData
{
VehiclePrefab = conversionSystem.GetPrimaryEntity(vehiclePrefabs[j]),
VehicleSpeed = j < speedMultipliers.Length ? speedMultipliers[j] : 3.0f
};
dstManager.AddComponentData(vehiclePrefab, prefabData);
}
var trafficSettings = new TrafficSettingsData
{
GlobalSpeedFactor = globalSpeedFactor,
PathSegments = pathSegments,
MaxCars = maxCars
};
dstManager.AddComponentData(entity, trafficSettings);
}
public override FontData ConvertGameData(GameObject gameObject, Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem, FontDataSO dataSO)
{
bool isRuntime = conversionSystem.TryGetBuildConfigurationComponent <DotsRuntimeBuildProfile>(out var _);
var data = new FontData();
data.Id = dataSO.Id;
data.Name = dataSO.Name;
var font = dataSO.Font;
data.Ascent = font.ascent;
data.Dynamic = font.dynamic;
if (isRuntime)
{
data.MaterialEntity = conversionSystem.GetPrimaryEntity(font.material);
Debug.LogFormat("[R]FontDataSOListConverter.ConvertGameData: {0}", font.material);
}
else
{
var materialEntity = conversionSystem.CreateAdditionalEntity(gameObject);
dstManager.AddSharedComponentData(materialEntity, new FontMaterial {
Material = font.material
});
data.MaterialEntity = materialEntity;
Debug.LogFormat("FontDataSOListConverter.ConvertGameData: {0}", font.material);
}
data.LineHeight = font.lineHeight;
data.FontSize = font.fontSize;
data.CharacterInfoArrayAssetRef = CreateArrayAssetRef(font.characterInfo);
return(data);
}
//TODO: Editor Rendering not working for some reason.
public async void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
if (map != null)
{
var mapSystem = dstManager.World.GetOrCreateSystem <MapSystemGroup>();
dstManager.AppendArchetype(entity, mapSystem.Archetypes.Map);
var mesh = map.CreateMesh();
mesh.RecalculateBounds();
dstManager.AddComponentData(entity, new MapData(map.CreateBlob()));
dstManager.AddComponentData(entity, new MapHighlightState {
dirty = 0, states = new Unity.Collections.LowLevel.Unsafe.UnsafeMultiHashMap <ushort, Point>(16, Allocator.Persistent)
});
dstManager.AddComponentData(entity, new MapCollisionState {
value = new Unity.Collections.LowLevel.Unsafe.UnsafeHashMap <Point, Entity>(16, Allocator.Persistent)
});
dstManager.AddComponentData(entity, new MapRenderInfo {
baseIndexCount = mesh.GetIndexCount(0), tileSize = 1f, elevationStep = 0.25f
});
var layerEntities = new NativeArray <Entity>(MapLayers.Count, Allocator.TempJob);
for (int i = 0; i < MapLayers.Count; i++)
{
layerEntities[i] = conversionSystem.CreateAdditionalEntity(this);
dstManager.AppendArchetype(layerEntities[i], mapSystem.Archetypes.MapRenderLayer);
}
var layers = (MapLayer[])Enum.GetValues(typeof(MapLayer));
Material material = mapMaterial;
for (int i = 0; i < layers.Length; i++)
{
#if UNITY_EDITOR
dstManager.SetName(layerEntities[i], $"{this.name} ({layers[i]} Layer)");
#endif
dstManager.SetSharedComponentData(layerEntities[i], new RenderMesh
{
mesh = mesh,
material = material,
subMesh = i,
castShadows = ShadowCastingMode.Off,
receiveShadows = false,
layer = transform.gameObject.layer
});
dstManager.SetComponentData(layerEntities[i], new MapElement {
value = entity
});
dstManager.SetComponentData(layerEntities[i], new MaterialColor
{
Value = layerColors[layers[i]].ToFloat4()
});
dstManager.SetComponentData(layerEntities[i], new RenderBounds {
Value = mesh.bounds.ToAABB()
});
/* dstManager.AddComponentData(layerEntities[i], new Translation { Value = new float3(0, 0, 0) });
* dstManager.AddComponentData(layerEntities[i], new Rotation { Value = quaternion.identity });
* dstManager.AddComponentData(layerEntities[i], new CompositeScale { Value = float4x4.Scale(1) });
* dstManager.AddComponentData(layerEntities[i], new PerInstanceCullingTag());
* dstManager.AddComponentData(layerEntities[i], new BuiltinMaterialPropertyUnity_RenderingLayer { Value = 1 }); */
//Overlapping submeshes can't overlap anymore so offset position slightly upward for each layer.
dstManager.SetComponentData(layerEntities[i], new LocalToWorld {
Value = float4x4.Translate(new float3(0, transform.position.y + (LAYER_OFFSET * i), 0))
});
dstManager.GetBuffer <MapLayerRenderer>(entity).Add(new MapLayerRenderer {
entity = layerEntities[i], layer = layers[i]
});
//dstManager.AddBuffer<MapTileEffect>(entity);
dstManager.AddComponentData(layerEntities[i], new Parent {
Value = entity
});
conversionSystem.ConfigureEditorRenderData(layerEntities[i], this.gameObject, true);
}
var children = dstManager.AddBuffer <Child>(entity);
children.AddRange(layerEntities.Reinterpret <Child>());
conversionSystem.DeclareLinkedEntityGroup(this.gameObject);
conversionSystem.ConfigureEditorRenderData(entity, this.gameObject, true);
layerEntities.Dispose();
}
}
public static void Convert(
EntityManager dstEntityManager,
GameObjectConversionSystem conversionSystem,
bool attachToPrimaryEntityForSingleMaterial,
Renderer meshRenderer,
Mesh mesh,
List <Material> materials,
Dictionary <MaterialLookupKey, Material> createdMaterials,
LightMaps lightMaps,
int lightmapIndex,
Transform root,
AABB localBounds)
{
var materialCount = materials.Count;
// Don't add RenderMesh (and other required components) unless both mesh and material are assigned.
if (mesh == null || materialCount == 0)
{
Debug.LogWarning(
"MeshRenderer is not converted because either the assigned mesh is null or no materials are assigned.",
meshRenderer);
return;
}
//@TODO: Transform system should handle RenderMeshFlippedWindingTag automatically. This should not be the responsibility of the conversion system.
float4x4 localToWorld = root.localToWorldMatrix;
var flipWinding = math.determinant(localToWorld) < 0.0;
if (materialCount == 1 && attachToPrimaryEntityForSingleMaterial)
{
var meshEntity = conversionSystem.GetPrimaryEntity(meshRenderer);
AddComponentsToEntity(
meshEntity,
dstEntityManager,
conversionSystem,
meshRenderer,
mesh,
materials,
createdMaterials,
flipWinding,
0,
lightMaps,
lightmapIndex,
localBounds);
}
else
{
var rootEntity = conversionSystem.GetPrimaryEntity(root);
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 = rootEntity
});
dstEntityManager.AddComponentData(meshEntity,
new LocalToParent {
Value = float4x4.identity
});
}
AddComponentsToEntity(
meshEntity,
dstEntityManager,
conversionSystem,
meshRenderer,
mesh,
materials,
createdMaterials,
flipWinding,
m,
lightMaps,
lightmapIndex,
localBounds);
}
}
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
Debug.Log("Converting");
unsafeMemoryReferences = new List <CustomMemoryManagerBase>();
List <VehicleObject> vehiclePrefabs;
InitializeTotalVehicles(out vehiclePrefabs);
for (int i = 0; i < vehiclePrefabs.Count; i++)
{
Entity bodyEntity = conversionSystem.CreateAdditionalEntity(this);
//convert vehicle body part to ECS
var vehicleBody = new VehicleBody
{
prefab = conversionSystem.GetPrimaryEntity(vehiclePrefabs[i].body),
length = vehiclePrefabs[i].bodyLength,
id = VEHICLE_ID_POOL
};
dstManager.AddComponentData(bodyEntity, vehicleBody);
//convert vehicle wheel(s) part to ECS
var wheels = vehiclePrefabs[i].wheels;
for (int j = 0; j < wheels.Length; j++)
{
Entity wheelEntity = conversionSystem.CreateAdditionalEntity(this);
var vehicleWheel = new VehicleWheel
{
prefab = conversionSystem.GetPrimaryEntity(wheels[j]),
positionOffset = wheels[j].gameObject.transform.position,
rotationOffset = wheels[j].gameObject.transform.eulerAngles,
id = VEHICLE_ID_POOL
};
dstManager.AddComponentData(wheelEntity, vehicleWheel);
}
VEHICLE_ID_POOL++;
}
//
/*********** WORKING ON PATHS ********/
//assign path's ID
for (int i = 0; i < pathsCollector.bakedTrafficPaths.Length; i++)
{
pathsCollector.bakedTrafficPaths[i].id = (byte)PATH_ID_POOL;
PATH_ID_POOL++;
}
//conver path asset to ecs data
unsafe
{
for (int i = 0; i < pathsCollector.bakedTrafficPaths.Length; i++)
{
//get current path
var currentPath = pathsCollector.bakedTrafficPaths[i];
//Debug.Log(currentPath.PathName);
//create entity
var pathEntity = conversionSystem.CreateAdditionalEntity(this);
//allocate native memory
CustomMemoryManager <float3> pathMem = new CustomMemoryManager <float3>();
pathMem.AllocateMemory(currentPath.PathNodes.Count, 32, Allocator.Persistent);
CustomMemoryManager <byte> occupiedSlotMem = new CustomMemoryManager <byte>();
occupiedSlotMem.AllocateMemory(currentPath.PathNodes.Count, 8, Allocator.Persistent);
//add to list
unsafeMemoryReferences.Add(pathMem);
unsafeMemoryReferences.Add(occupiedSlotMem);
//populate allocated memory
var nodesPtr = pathMem.GetPointer();
var occupiedPtr = occupiedSlotMem.GetPointer();
for (int j = 0; j < currentPath.PathNodes.Count; j++)
{
nodesPtr[j] = currentPath.PathNodes[j];
occupiedPtr[j] = 0;
}
//populate linked count
byte linkedCount = 0;
CustomMemoryManager <PathLinkedData> linkedData = new CustomMemoryManager <PathLinkedData>();
unsafeMemoryReferences.Add(linkedData);
if (currentPath.splittingPaths != null && currentPath.splittingPaths.Count > 0)
{
linkedData.AllocateMemory(currentPath.splittingPaths.Count, 32, Allocator.Persistent);
var linkedDataPtr = linkedData.GetPointer();
for (int j = 0; j < currentPath.splittingPaths.Count; j++)
{
linkedDataPtr[j].chance = (byte)currentPath.splittingPaths[j].turnedChance;
linkedDataPtr[j].connectingNode = currentPath.splittingPaths[j].startNode;
linkedDataPtr[j].transitionNode = currentPath.splittingPaths[j].transitionNode;
linkedDataPtr[j].linkedID = currentPath.splittingPaths[j].turnedPath.id;
}
}
//create ecs data
var pathData = new Path
{
id = currentPath.id,
maxSpeed = (byte)currentPath.actualSpeedLimit,
nodesCount = currentPath.PathNodes.Count,
pathNodes = nodesPtr,
occupied = occupiedPtr,
linkedCount = linkedCount,
linked = linkedData.GetPointer()
};
//add ecs data
dstManager.AddComponentData(pathEntity, pathData);
}
}
//add total vehicles to ECS
var traffSettings = new TrafficSettingsData
{
vehicleCount = totalVehicles,
};
dstManager.AddComponentData(entity, traffSettings);
Debug.Log("Finished");
//Done with paths
//upload them
Resources.UnloadAsset(pathsCollector);
pathsCollector = null;
//explicitly call garbage collector
System.GC.Collect();
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
// set up initial counts and values for everything
MaxFarmers = maxFarmers;
MaxDrones = maxDrones;
droneCount = 0;
farmerCount = 0;
BoardWidth = boardWidth;
PerformTaskSystem.InitializeTillSystem(maxFarmers);
// set up mesh rendering from prefab
MeshRenderer meshRenderer = TilePrefab.GetComponent <MeshRenderer>();
var meshFilter = TilePrefab.GetComponent <MeshFilter>();
var materials = new List <Material>(MATERIAL_NUMBER);
var mesh = meshFilter.sharedMesh;
meshRenderer.GetSharedMaterials(materials);
// set up entity and manager
entityManager = dstManager;
boardEntity = conversionSystem.GetPrimaryEntity(TilePrefab);
// a board archetype
boardArchetype = entityManager.CreateArchetype(
typeof(Translation), typeof(GridBoard));
// Generate rock prefab entity
rockEntity = conversionSystem.GetPrimaryEntity(RockPrefab);
entityManager.AddComponentData(rockEntity, new RockTag {
});
// Generate drone prefab entity
droneEntity = conversionSystem.GetPrimaryEntity(DronePrefab);
entityManager.AddComponentData(droneEntity, new MovementComponent {
});
entityManager.AddComponentData(droneEntity, new EntityInfo {
specificEntity = droneEntity, type = -1
});
entityManager.AddComponent(droneEntity, typeof(DroneTag));
// generate 3 plants to use for everything else
plantEntity = new Entity[DIFF_PLANT_COUNT];
Unity.Mathematics.Random rand = new Unity.Mathematics.Random(42);
int nextRandom = rand.NextInt();
MeshRenderer meshPlantRenderer = PlantMeshPrefab.GetComponent <MeshRenderer>();
var meshPlantFilter = PlantMeshPrefab.GetComponent <MeshFilter>();
var materials2 = new List <Material>(MATERIAL_NUMBER);
meshPlantRenderer.GetSharedMaterials(materials2);
for (int i = 0; i < DIFF_PLANT_COUNT; i++)
{
plantMesh = GeneratePlantMesh(nextRandom);
var meshPlantTmp = Instantiate(plantMesh);
meshPlantFilter.sharedMesh = meshPlantTmp;
plantEntity[i] = conversionSystem.GetPrimaryEntity(PlantMeshPrefab);
Convert(plantEntity[i], dstManager, conversionSystem, meshPlantRenderer, meshPlantTmp, materials2);
entityManager.AddComponent(plantEntity[i], typeof(PlantTag));
entityManager.SetComponentData(plantEntity[i], new Translation {
Value = new float3(-1, -5, -1)
});
entityManager.AddComponentData(plantEntity[i], new NonUniformScale {
Value = new float3(1.0f, 2.0f, 1.0f)
});
entityManager.AddComponentData(plantEntity[i], new PlantComponent
{
timeGrown = 0,
state = (int)PlantState.None,
reserveIndex = -1
});
nextRandom = rand.NextInt();
}
// create atlas and texture info
CalculatePredeterminedTextures();
// if textures changed we'd have to re-create them with the following:
//CreateAtlasData();
//CreateTextures();
// the texture indices in the world
// clearing memory gives everything the first image in the uv's,
// which is conveniently non-tilled ground
blockIndices = new NativeArray <int>(BoardWidth * BoardWidth, Allocator.Persistent, NativeArrayOptions.ClearMemory);
// initialize hash table that stores all the tile state info
GridData gdata = GridData.GetInstance();
gdata.Initialize(BoardWidth);
// generate the terrain mesh and add it to the world
Mesh mesh2;
int maxX = BoardWidth / MAX_MESH_WIDTH;
int maxZ = BoardWidth / MAX_MESH_WIDTH;
// only one mesh
allMeshes = new Mesh[(maxX + 1) * (maxZ + 1)];
allUVs = new NativeArray <float2> [(maxX + 1) * (maxZ + 1)];
allVerts = new NativeArray <float3> [(maxX + 1) * (maxZ + 1)];
allTris = new NativeArray <int> [(maxX + 1) * (maxZ + 1)];
// for small enough meshes it's just a single mesh in the world
int height = 0;
if (maxX == 0 && maxZ == 0)
{
int cornerX = 0;
int cornerZ = 0;
allUVs[0] = new NativeArray <float2>(BoardWidth * BoardWidth * 4, Allocator.Persistent);
mesh2 = GenerateTerrainMesh(BoardWidth, BoardWidth, 0, 0, height, allUVs[0]);
mesh = Instantiate(mesh2);
allMeshes[0] = mesh;
meshFilter.sharedMesh = mesh;
var segmentEntity = conversionSystem.CreateAdditionalEntity(gameObject);
var pos = new float3(cornerX, 0, cornerZ);
var localToWorld = new LocalToWorld
{
Value = float4x4.Translate(pos)
};
var aabb = new AABB
{
Center = pos,
Extents = new float3(BoardWidth, 0.5f, BoardWidth)
};
var worldRenderBounds = new WorldRenderBounds
{
Value = aabb
};
dstManager.AddComponentData(segmentEntity, localToWorld);
dstManager.AddComponentData(segmentEntity, worldRenderBounds);
dstManager.AddComponent(segmentEntity, ComponentType.ChunkComponent <ChunkWorldRenderBounds>());
//dstManager.AddComponent(segmentEntity, typeof(Frozen));
Convert(segmentEntity, dstManager, conversionSystem, meshRenderer, mesh, materials);
}
else
{
// FIX: this could be parallelized as all meshes are
// independent from each other
// for larger meshes it's broken up into
// 64k vertex pieces
for (int index = 0; index < (maxX + 1) * (maxZ + 1); index++)
{
//Parallel.For(0, (maxX + 1) * (maxZ + 1), (index) =>
//{
int x = (int)(index / (maxX + 1));
int z = index - (maxX + 1) * x;
//UnityEngine.Debug.Log("x: " + x + " " + z);
int cornerX = x * MAX_MESH_WIDTH;
int cornerZ = z * MAX_MESH_WIDTH;
int width = 0;
int depth = 0;
int startX = 0;
int startZ = 0;
float3 pos = new float3(cornerX, 0, cornerZ);
if (x < maxX && z < maxZ)
{
startX = cornerX;
startZ = cornerZ;
width = MAX_MESH_WIDTH;
depth = MAX_MESH_WIDTH;
}
else if (x < maxX)
{
startX = cornerX;
startZ = cornerZ;
width = MAX_MESH_WIDTH;
depth = BoardWidth - cornerZ;
}
else if (z < maxZ)
{
startX = cornerX;
startZ = cornerZ;
width = BoardWidth - cornerX;
depth = MAX_MESH_WIDTH;
}
else
{
startX = cornerX;
startZ = cornerZ;
width = BoardWidth - cornerX;
depth = BoardWidth - cornerZ;
}
//UnityEngine.Debug.Log("index " + index + " " + width + " " + depth +
// " " + cornerX + " " + cornerZ);
allUVs[index] = new NativeArray <float2>(width * depth * 4, Allocator.Persistent);
allVerts[index] = new NativeArray <float3>(width * depth * 4, Allocator.Persistent);
allTris[index] = new NativeArray <int>(width * depth * 6, Allocator.Persistent);
NativeArray <float2> uvs = allUVs[index];
NativeArray <float3> vert = allVerts[index];
NativeArray <int> tri = allTris[index];
int triangleIndex = 0;
int vertexIndex = 0;
int vertexMultiplier = 4; // create quads to fit uv's to so we can use more than one uv
int uvIndex = 0;
for (x = 0; x < width; x++)
{
for (z = 0; z < depth; z++)
{
int y = height;
int textureIndex = 0;
int index2D = (z + startZ) + width * (x + startX);
textureIndex = blockIndices[index2D];
// add vertices for the quad first
// front
vert[vertexIndex] = new float3(x + 0.5f, 0.5f, z + -0.5f);
vert[vertexIndex + 1] = new float3(x + 0.5f, 0.5f, z + 0.5f);
vert[vertexIndex + 2] = new float3(x + -0.5f, 0.5f, z + 0.5f);
vert[vertexIndex + 3] = new float3(x + -0.5f, 0.5f, z + -0.5f);
// set the UV's
uvs[uvIndex] = new float2(textures[textureIndex].pixelStartX,
textures[textureIndex].pixelStartY);
uvs[uvIndex + 1] = new float2(textures[textureIndex].pixelStartX,
textures[textureIndex].pixelEndY);
uvs[uvIndex + 2] = new float2(textures[textureIndex].pixelEndX,
textures[textureIndex].pixelEndY);
uvs[uvIndex + 3] = new float2(textures[textureIndex].pixelEndX,
textures[textureIndex].pixelStartY);
uvIndex += 4;
// front or top face
tri[triangleIndex] = vertexIndex;
tri[triangleIndex + 1] = vertexIndex + 2;
tri[triangleIndex + 2] = vertexIndex + 1;
tri[triangleIndex + 3] = vertexIndex;
tri[triangleIndex + 4] = vertexIndex + 3;
tri[triangleIndex + 5] = vertexIndex + 2;
triangleIndex += 6;
// increment the vertices
vertexIndex += vertexMultiplier;
}
}
AABB aabb;
aabb = new AABB
{
Center = pos,
Extents = new float3(width, 0.5f, depth)
};
mesh2 = new Mesh();
mesh2.SetVertices(allVerts[index]);
mesh2.SetUVs(0, allUVs[index]);
mesh2.SetTriangles(allTris[index].ToArray(), 0);
mesh2.RecalculateNormals();
mesh2.RecalculateBounds();
mesh = Instantiate(mesh2);
meshFilter.sharedMesh = mesh;
//Debug.Log("creating mesh for : " + x + " " + z + " " + (z + (maxX + 1) * x));
allMeshes[index] = mesh;
var segmentEntity = conversionSystem.CreateAdditionalEntity(gameObject);
var localToWorld = new LocalToWorld
{
Value = float4x4.Translate(pos)
};
var worldRenderBounds = new WorldRenderBounds
{
Value = aabb
};
dstManager.AddComponentData(segmentEntity, localToWorld);
dstManager.AddComponentData(segmentEntity, worldRenderBounds);
dstManager.AddComponent(segmentEntity, ComponentType.ChunkComponent <ChunkWorldRenderBounds>());
//dstManager.AddComponent(segmentEntity, typeof(Frozen));
Convert(segmentEntity, dstManager, conversionSystem, meshRenderer, mesh, materials);
}
//);
}
// generate rocks and such on the grid
GenerateGrid();
// generate the farmers
// Create farmer entity prefab from the game object hierarchy once
farmerEntity = conversionSystem.GetPrimaryEntity(FarmerPrefab);
entityManager.AddComponent <FarmerTag>(farmerEntity);
// FIX: this could be parallelized
// NOTE: NOT WORTH DOING UNTIL ALL THE add/set component is
// part of burst as that's all this is
// Also note: usually not that many farmers to justify
// parallelization.
for (int i = 0; i < farmerNumber; i++)
{
farmerCount++;
var instance = entityManager.Instantiate(farmerEntity);
if (i == 0)
{
firstFarmer = instance;
}
int startX = Math.Abs(rand.NextInt()) % gdata.width;
int startZ = Math.Abs(rand.NextInt()) % gdata.width;
// Place the instantiated entity in a grid with some noise
var position = new float3(startX, 2, startZ);
entityManager.SetComponentData(instance, new Translation()
{
Value = position
});
var data = new MovementComponent
{
startPos = new float2(startX, startZ),
speed = 2,
targetPos = new float2(startX, startZ),
};
var entityData = new EntityInfo {
specificEntity = instance, type = -1
};
entityManager.AddComponentData(instance, data);
entityManager.AddComponentData(instance, entityData);
// give his first command based on the 1's in the hash
entityManager.AddComponent <NeedsTaskTag>(instance);
}
if (blockIndices.IsCreated)
{
blockIndices.Dispose();
}
}
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
};
//@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)
{
renderMesh.material = materials[0];
renderMesh.subMesh = 0;
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);
}
else
{
for (var m = 0; m != materialCount; m++)
{
var meshEntity = conversionSystem.CreateAdditionalEntity(meshRenderer);
renderMesh.material = materials[m];
renderMesh.subMesh = m;
dstEntityManager.AddSharedComponentData(meshEntity, renderMesh);
dstEntityManager.AddComponentData(meshEntity, new PerInstanceCullingTag());
dstEntityManager.AddComponentData(meshEntity, new RenderBounds {
Value = mesh.bounds.ToAABB()
});
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
});
}
if (flipWinding)
{
dstEntityManager.AddComponent(meshEntity, ComponentType.ReadWrite <RenderMeshFlippedWindingTag>());
}
conversionSystem.ConfigureEditorRenderData(meshEntity, meshRenderer.gameObject, true);
}
}
}
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
//var top = this.GetComponentInParent<CharacterModelAuthoring>();// プレハブだとできない（ children はできるのに）
var top = this.gameObject.Ancestors().First(go => go.GetComponent <CharacterModelAuthoring>());
var main = top.transform.GetChild(0).gameObject;
var waponSelectorEntity = conversionSystem.CreateAdditionalEntity(this.gameObject);
dstManager.SetName_(waponSelectorEntity, $"{main.name} wapon selector");
var types = new ComponentTypes
(
typeof(WaponSelector.LinkData),
typeof(WaponSelector.ToggleModeData),
typeof(WaponSelector.WaponLink0)
//typeof(Disabled)// 何も持っていない状態用
);
dstManager.AddComponents(waponSelectorEntity, types);
dstManager.SetComponentData(waponSelectorEntity,
new WaponSelector.LinkData
{
OwnerMainEntity = conversionSystem.GetPrimaryEntity(main),
muzzleBodyEntity = entity,
}
);
dstManager.SetComponentData(waponSelectorEntity,
new WaponSelector.ToggleModeData
{
CurrentWaponCarryId = 0,
WaponCarryLength = 0,
}
);
if (this.Wapons.Length >= 2)
{
dstManager.AddComponentData(waponSelectorEntity, new WaponSelector.WaponLink1 {
});
}
if (this.Wapons.Length >= 3)
{
dstManager.AddComponentData(waponSelectorEntity, new WaponSelector.WaponLink2 {
});
}
if (this.Wapons.Length >= 4)
{
dstManager.AddComponentData(waponSelectorEntity, new WaponSelector.WaponLink3 {
});
}
if (this.Wapons.Length > 0)
{
var msg = new WaponMessage.ReplaceWapon4MsgData
{
NumPeplace = math.min(this.Wapons.Where(x => x != null).Count(), 4),
WaponPrefab0 = this.Wapons.Length >= 1 ? conversionSystem.GetPrimaryEntity(this.Wapons[0]) : Entity.Null,
WaponPrefab1 = this.Wapons.Length >= 2 ? conversionSystem.GetPrimaryEntity(this.Wapons[1]) : Entity.Null,
WaponPrefab2 = this.Wapons.Length >= 3 ? conversionSystem.GetPrimaryEntity(this.Wapons[2]) : Entity.Null,
WaponPrefab3 = this.Wapons.Length >= 4 ? conversionSystem.GetPrimaryEntity(this.Wapons[3]) : Entity.Null,
};
dstManager.AddComponentData(waponSelectorEntity, msg);
}
//var waponEnities = this.Wapons
// .Where(x => x != null)
// .Take(4)
// .Select(w => conversionSystem.GetPrimaryEntity(w))
// .ToArray();
//if (waponEnities.Length >= 1)
// dstManager.AddComponentData(waponSelectorEntity, new WaponSelector.WaponPrefab0 { WaponPrefab = waponEnities[0] });
//if (waponEnities.Length >= 2)
// dstManager.AddComponentData(waponSelectorEntity, new WaponSelector.WaponPrefab1 { WaponPrefab = waponEnities[1] });
//if (waponEnities.Length >= 3)
// dstManager.AddComponentData(waponSelectorEntity, new WaponSelector.WaponPrefab2 { WaponPrefab = waponEnities[2] });
//if (waponEnities.Length >= 4)
// dstManager.AddComponentData(waponSelectorEntity, new WaponSelector.WaponPrefab3 { WaponPrefab = waponEnities[3] });
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var conversionTarget = GhostAuthoringConversion.GetConversionTarget(conversionSystem);
if (conversionTarget == NetcodeConversionTarget.Undefined)
{
throw new InvalidOperationException(
$"A ghost prefab can only be created in the client or server world, not {dstManager.World.Name}");
}
var collection = default(GhostPrefabCollectionComponent);
Type enableSystem = null;
if (conversionTarget == NetcodeConversionTarget.Server)
{
enableSystem = FindComponentWithName($"Enable{NamePrefix}GhostSendSystemComponent");
if (enableSystem == null)
{
throw new InvalidOperationException($"Could not find Enable{NamePrefix}GhostSendSystemComponent, make sure the ghost collection is generated");
}
var prefabList = new NativeList <GhostPrefabBuffer>(Allocator.Temp);
foreach (var ghost in Ghosts)
{
if (ghost.prefab == null || !ghost.enabled)
{
continue;
}
var prefabEntity =
GameObjectConversionUtility.ConvertGameObjectHierarchy(ghost.prefab.gameObject,
conversionSystem.ForkSettings(1));
EnsurePrefab(prefabEntity, dstManager);
prefabList.Add(new GhostPrefabBuffer {
Value = prefabEntity
});
}
collection.serverPrefabs = conversionSystem.CreateAdditionalEntity(this);
var prefabs = dstManager.AddBuffer <GhostPrefabBuffer>(collection.serverPrefabs);
for (int i = 0; i < prefabList.Length; ++i)
{
prefabs.Add(prefabList[i]);
}
}
else if (conversionTarget == NetcodeConversionTarget.Client)
{
enableSystem = FindComponentWithName($"Enable{NamePrefix}GhostReceiveSystemComponent");
if (enableSystem == null)
{
throw new InvalidOperationException($"Could not find Enable{NamePrefix}GhostReceiveSystemComponent, make sure the ghost collection is generated");
}
var predictedList = new NativeList <GhostPrefabBuffer>(Allocator.Temp);
var interpolatedList = new NativeList <GhostPrefabBuffer>(Allocator.Temp);
foreach (var ghost in Ghosts)
{
if (ghost.prefab == null || !ghost.enabled)
{
continue;
}
var origInstantiate = ghost.prefab.DefaultClientInstantiationType;
ghost.prefab.DefaultClientInstantiationType =
GhostAuthoringComponent.ClientInstantionType.Interpolated;
var prefabEntity =
GameObjectConversionUtility.ConvertGameObjectHierarchy(ghost.prefab.gameObject,
conversionSystem.ForkSettings(1));
ghost.prefab.DefaultClientInstantiationType =
GhostAuthoringComponent.ClientInstantionType.Predicted;
var predictedPrefabEntity =
GameObjectConversionUtility.ConvertGameObjectHierarchy(ghost.prefab.gameObject,
conversionSystem.ForkSettings(2));
ghost.prefab.DefaultClientInstantiationType = origInstantiate;
EnsurePrefab(predictedPrefabEntity, dstManager);
EnsurePrefab(prefabEntity, dstManager);
predictedList.Add(new GhostPrefabBuffer {
Value = predictedPrefabEntity
});
interpolatedList.Add(new GhostPrefabBuffer {
Value = prefabEntity
});
}
collection.clientInterpolatedPrefabs = conversionSystem.CreateAdditionalEntity(this);
var interpolatedPrefabs = dstManager.AddBuffer <GhostPrefabBuffer>(collection.clientInterpolatedPrefabs);
for (int i = 0; i < interpolatedList.Length; ++i)
{
interpolatedPrefabs.Add(interpolatedList[i]);
}
collection.clientPredictedPrefabs = conversionSystem.CreateAdditionalEntity(this);
var predictedPrefabs = dstManager.AddBuffer <GhostPrefabBuffer>(collection.clientPredictedPrefabs);
for (int i = 0; i < predictedList.Length; ++i)
{
predictedPrefabs.Add(predictedList[i]);
}
}
dstManager.AddComponentData(entity, collection);
if (enableSystem != null)
{
dstManager.AddComponent(entity, enableSystem);
}
}
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);
}
}
}
}
