/// <summary>
/// Entityをランダムな位置に生成
/// </summary>
/// <param name="onCreateEntity">Entity生成毎に呼ばれるコールバック</param>
protected void CreateEntitiesFromRandomPosition(UnityAction <Entity, float3> onCreateEntity)
{
var look = Utility.CreateMeshInstanceRenderer(this._dokabenRenderData);
var halfX = this._boundSize.x / 2;
var halfY = this._boundSize.y / 2;
var halfZ = this._boundSize.z / 2;
var manager = World.Active.GetExistingManager <EntityManager>();
var entities = new NativeArray <Entity>(_maxObjectNum, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
try
{
entities[0] = manager.CreateEntity(Archetype);
manager.SetSharedComponentData(entities[0], look);
unsafe
{
var ptr = (Entity *)NativeArrayUnsafeUtility.GetUnsafePtr(entities);
var rest = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <Entity>(ptr + 1, entities.Length - 1, Allocator.None);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref rest, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
manager.Instantiate(entities[0], rest);
}
for (int i = 0; i < entities.Length; ++i)
{
onCreateEntity(entities[i], new float3(UnityEngine.Random.Range(-halfX, halfX), UnityEngine.Random.Range(-halfY, halfY), UnityEngine.Random.Range(-halfZ, halfZ)));
}
}
finally
{
entities.Dispose();
}
}
public NetworkEvent.Type PopEvent(out DataStreamReader bs)
{
bs = default;
if (m_IncomingEvents->Length == 0)
{
return(NetworkEvent.Type.Empty);
}
var ev = UnsafeUtility.ReadArrayElement <DriverEvent>(m_IncomingEvents->Ptr, 0);
if (m_IncomingEvents->Length > 0)
{
//m_IncomingEvents->RemoveAtSwapBack<DriverEvent>(0);
m_IncomingEvents->Length--;
UnsafeUtility.MemMove(m_IncomingEvents->Ptr, (byte *)m_IncomingEvents->Ptr + sizeof(DriverEvent), sizeof(DriverEvent) * m_IncomingEvents->Length);
}
if (ev.Type == NetworkEvent.Type.Data)
{
var slice = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <byte>((byte *)m_DataStream->Ptr + ev.StreamOffset, sizeof(byte), ev.Length);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref slice, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
bs = new DataStreamReader(slice);
}
return(ev.Type);
}
internal NativeArray <T> ToNativeArray()
{
var array = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <T>(_pointer, Length, Allocator.Invalid);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref array, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
return(array);
}
public unsafe ElementPool(void *userBuffer, int capacity)
{
m_Elements = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <T>(userBuffer, capacity, Allocator.None);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref m_Elements, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
m_DisposeArray = false;
m_FirstFreeIndex = -1;
PeakCount = 0;
}
public ElementEnumerable <T> GetElements <T>() where T : unmanaged, IPoolElement
{
NativeArray <T> slice = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <T>(m_Elements, PeakCount, Allocator.None);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref slice, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
return(new ElementEnumerable <T> {
Slice = slice
});
}
//-----------------------------------------------------------------------------
public unsafe static void CopyMatrices(ComponentDataArray <TransformMatrix> transforms, int beginIndex, int length, Matrix4x4[] outMatrices)
{
fixed(Matrix4x4 *matricesPtr = outMatrices)
{
Assert.AreEqual(sizeof(Matrix4x4), sizeof(TransformMatrix));
var matricesSlice = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <TransformMatrix>(matricesPtr, sizeof(Matrix4x4), length);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref matricesSlice, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
transforms.CopyTo(matricesSlice, beginIndex);
}
}
public unsafe static void CopyMatrices(NativeArray <LocalToWorld> transforms, int beginIndex, int length, Matrix4x4[] outMatrices)
{
fixed(Matrix4x4 *matricesPtr = outMatrices)
{
Assert.AreEqual(sizeof(Matrix4x4), sizeof(LocalToWorld));
var matricesSlice = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <LocalToWorld>(matricesPtr, sizeof(Matrix4x4), length);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref matricesSlice, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
matricesSlice.CopyFrom(transforms.Slice(beginIndex, length));
}
}
// This is the ugly bit, necessary until Graphics.DrawMeshInstanced supports NativeArrays pulling the data in from a job.
public unsafe static Vector4[] CopyToArray(this NativeSlice <Vector4> src, Vector4[] dst) // where T:struct
{
fixed(Vector4 *p = dst)
{
UnityEngine.Assertions.Assert.IsTrue(UnsafeUtility.IsBlittable <Vector4>());
var s = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <Vector4>(p, UnsafeUtility.SizeOf <Vector4>(), src.Length);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref s, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
s.CopyFrom(src);
}
return(dst);
}
protected NativeArray <T> GetNativeArray <T>(Chunk *chunk) where T : struct, IComponentData
{
var hash = typeof(T).GetHashCode();
int componentIndex = ArcheType->GetIndex(hash);
Assert.IsTrue(componentIndex >= 0);
var buf = Block.GetComponentDataArray(chunk, componentIndex);
var len = Block.GetComponentDataCount(chunk, componentIndex);
var array = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <T>(buf, len, Allocator.Persistent);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref array, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
return(array);
}
// This is the ugly bit, necessary until Graphics.DrawMeshInstanced supports NativeArrays pulling the data in from a job.
public unsafe static void CopyMatrices(ComponentDataArray <TransformMatrix> transforms, int beginIndex, int length, Matrix4x4[] outMatrices)
{
// @TODO: This is using unsafe code because the Unity DrawInstances API takes a Matrix4x4[] instead of NativeArray.
// We want to use the ComponentDataArray.CopyTo method
// because internally it uses memcpy to copy the data,
// if the nativeslice layout matches the layout of the component data. It's very fast...
fixed(Matrix4x4 *matricesPtr = outMatrices)
{
Assert.AreEqual(sizeof(Matrix4x4), sizeof(TransformMatrix));
var matricesSlice = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <TransformMatrix>(matricesPtr, sizeof(Matrix4x4), length);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref matricesSlice, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
transforms.CopyTo(matricesSlice, beginIndex);
}
}
public static unsafe void FromString(this DynamicBuffer <char> buffer, string name)
{
if (string.IsNullOrEmpty(name))
{
buffer.Clear();
return;
}
fixed(char *ptr = name)
{
var array = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <char>(ptr, name.Length, Allocator.None);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref array, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
buffer.CopyFrom(array);
}
}
GetNativeArray <T>(this ReadOnlySpan <T> span) where T : unmanaged
{
unsafe
{
fixed(void *ptr = &span.GetPinnableReference())
{
var array = NativeArrayUnsafeUtility.
ConvertExistingDataToNativeArray <T>
(ptr, span.Length, Allocator.None);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var handle = AtomicSafetyHandle.GetTempUnsafePtrSliceHandle();
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref array, handle);
#endif
return(array);
}
}
}
GetNativeSlice <T>(this ReadOnlySpan <T> span, int offset, int stride)
where T : unmanaged
{
fixed(void *ptr = &span.GetPinnableReference())
{
var headPtr = (T *)ptr + offset;
var strideInByte = sizeof(T) * stride;
var elementCount = span.Length / stride - offset / stride;
var slice =
NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <T>
(headPtr, strideInByte, elementCount);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeSliceUnsafeUtility.SetAtomicSafetyHandle
(ref slice, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
return(slice);
}
}
public static unsafe void CopyIntegers(NativeList <int> src, List <int> dst)
{
if (dst.Capacity < src.Length)
{
dst.Capacity = src.Length;
}
var array = NoAllocHelpers.ExtractArrayFromListT(dst);
fixed(int *arrayPtr = array)
{
var dstSlice = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <int>(arrayPtr, sizeof(int), src.Length);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref dstSlice, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
dstSlice.CopyFrom((NativeArray <int>)src);
}
NoAllocHelpers.ResizeList(dst, src.Length);
}
static unsafe int CopyMatrices()
{
int length = native_sprite_data_list_.Length;
if (length == 0)
{
return(0);
fixed(Matrix4x4 *ptr = managed_matrix_list_)
{
Assert.IsTrue(native_sprite_data_list_.Length <= BULK_NUM);
Assert.AreEqual(sizeof(Matrix4x4), sizeof(SpriteData));
var array = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <SpriteData>(ptr, length, Allocator.Persistent);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref array, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
native_sprite_data_list_.CopyTo(array);
}
return(length);
}
public unsafe void SetComponentData <T>(Entity entity, T componentData) where T : struct, IComponentData
{
var data = _dataManager.Get(entity.Index);
if (data->ArcheType == null)
{
return;
}
var block = _componentBlockManager.GetOrCreateBlock(data->ArcheType);
var hash = typeof(T).GetHashCode();
int componentIndex = data->ArcheType->GetIndex(hash);
Assert.IsTrue(componentIndex >= 0);
var buf = block.GetComponentDataArray(data->Chunk, componentIndex);
var len = block.GetComponentDataCount(data->Chunk, componentIndex);
var array = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <T>(buf, len, Allocator.Persistent);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref array, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
array[data->IndexInChunk] = componentData;
}
public void Execute()
{
UnityEngine.Assertions.Assert.AreEqual(sizeof(Matrix4x4), sizeof(EntityInstanceRendererTransform));
var matricesSlice = Unity.Collections.LowLevel.Unsafe.NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <EntityInstanceRendererTransform>(matricesPtr, sizeof(Matrix4x4), length);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
Unity.Collections.LowLevel.Unsafe.NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref matricesSlice, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
transforms.CopyTo(matricesSlice, beginIndex);
}
public unsafe static void CopyMatrices(ComponentDataArray <EntityInstanceRendererTransform> transforms, int beginIndex, int length, Matrix4x4[] outMatrices)
{
// @TODO: This is only unsafe because the Unity DrawInstances API takes a Matrix4x4[] instead of NativeArray.
/// And we also want the code to be really fast.
fixed(Matrix4x4 *matricesPtr = outMatrices)
{
UnityEngine.Assertions.Assert.AreEqual(sizeof(Matrix4x4), sizeof(EntityInstanceRendererTransform));
var matricesSlice = Unity.Collections.LowLevel.Unsafe.NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <EntityInstanceRendererTransform>(matricesPtr, sizeof(Matrix4x4), length);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
Unity.Collections.LowLevel.Unsafe.NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref matricesSlice, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
transforms.CopyTo(matricesSlice, beginIndex);
}
}
#pragma warning restore 0649
#endregion // Private Fields(Editable)
// ----------------------------------------------------
#region // Unity Events
/// <summary>
/// MonoBehaviour.Start
/// </summary>
void Start()
{
// Worldの作成
World.Active = new World("Sample World");
EntityManager entityManager = World.Active.CreateManager <EntityManager>();
World.Active.CreateManager(typeof(EndFrameTransformSystem));
World.Active.CreateManager(typeof(RenderingSystemBootstrap));
World.Active.CreateManager(typeof(PlayerMove), Camera.main.transform, this.Range);
World.Active.CreateManager(typeof(ColliderUpdate));
if (this._isSplitSpace)
{
// 衝突判定(空間分割)
World.Active.CreateManager(typeof(SplitSpaceCollisionSystem));
}
else
{
// 衝突判定(総当たり)
World.Active.CreateManager(typeof(CollisionSystem));
}
var destroyBarrier = World.Active.CreateManager <DestroyBarrier>();
World.Active.CreateManager(typeof(DestroySystem), destroyBarrier);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
// create player entity.
var playerArchetype = entityManager.CreateArchetype(
ComponentType.Create <Position>(), ComponentType.Create <Rotation>(), ComponentType.Create <Scale>(),
ComponentType.Create <Player>(), ComponentType.Create <SphereCollider>(),
ComponentType.Create <MeshInstanceRenderer>());
var playerEntity = entityManager.CreateEntity(playerArchetype);
entityManager.SetSharedComponentData(playerEntity, this._playerLook);
entityManager.SetComponentData(playerEntity, new Position {
Value = new float3(0)
});
entityManager.SetComponentData(playerEntity, new Scale {
Value = new float3(PlayerScale)
});
entityManager.SetComponentData(playerEntity, new SphereCollider {
Radius = SphereColliderRadius * PlayerScale
});
// create check hit entities.
var checkHitArchetype = entityManager.CreateArchetype(
ComponentType.Create <Position>(), ComponentType.Create <Rotation>(),
ComponentType.Create <CheckHit>(), ComponentType.Create <SphereCollider>(),
ComponentType.Create <Destroyable>(),
ComponentType.Create <MeshInstanceRenderer>());
// Entityの生成(各種ComponentData/SharedComponentDataの初期化)
// やっている事としては以下のリンクを参照。
// - https://qiita.com/pCYSl5EDgo/items/18f1827a5b323a7712d7
var entities = new NativeArray <Entity>(MaxObjectNum, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
try
{
entities[0] = entityManager.CreateEntity(checkHitArchetype);
// MeshInstanceRendererに対するデータの設定
entityManager.SetSharedComponentData(entities[0], this._checkHitLook);
unsafe
{
var ptr = (Entity *)NativeArrayUnsafeUtility.GetUnsafePtr(entities);
var rest = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <Entity>(ptr + 1, entities.Length - 1, Allocator.None);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref rest, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
entityManager.Instantiate(entities[0], rest);
}
// 各種ComponentDataの設定
for (int i = 0; i < MaxObjectNum; ++i)
{
#if ENABLE_DEBUG
// テスト用. 横一列に配置
entityManager.SetComponentData(entities[i], new Position {
Value = new float3(5 + (i * 10), 0, 0)
});
#else
// ランダムに配置
entityManager.SetComponentData(entities[i], new Position {
Value = this.GetRandomPosition()
});
#endif
entityManager.SetComponentData(entities[i], new SphereCollider {
Radius = SphereColliderRadius * CheckHitScale
});
}
}
finally
{
entities.Dispose();
}
}