unsafe public void TestCreateTriangle()
{
float3[] vertices =
{
new float3(-1.4f, 1.4f, 5.6f),
new float3(1.4f, 1.4f, 3.6f),
new float3(0.2f, 1.2f, 5.6f)
};
float3 normal = math.normalize(math.cross(vertices[1] - vertices[0], vertices[2] - vertices[0]));
var collider = PolygonCollider.CreateTriangle(vertices[0], vertices[1], vertices[2]);
var triangleCollider = UnsafeUtilityEx.AsRef <PolygonCollider>(collider.GetUnsafePtr());
Assert.IsTrue(triangleCollider.IsTriangle);
Assert.IsFalse(triangleCollider.IsQuad);
TestUtils.AreEqual(triangleCollider.Vertices[0], vertices[0], 1e-3f);
TestUtils.AreEqual(triangleCollider.Vertices[1], vertices[1], 1e-3f);
TestUtils.AreEqual(triangleCollider.Vertices[2], vertices[2], 1e-3f);
Assert.AreEqual(2, triangleCollider.Planes.Length);
TestUtils.AreEqual(normal, triangleCollider.Planes[0].Normal, 1e-3f);
TestUtils.AreEqual(-normal, triangleCollider.Planes[1].Normal, 1e-3f);
Assert.AreEqual(ColliderType.Triangle, triangleCollider.Type);
Assert.AreEqual(CollisionType.Convex, triangleCollider.CollisionType);
}
unsafe public void TestCreateQuad()
{
float3[] vertices =
{
new float3(-4.5f, 0.0f, 1.0f),
new float3(3.4f, 0.7f, 1.0f),
new float3(3.4f, 2.7f, 1.0f),
new float3(-3.4f, 1.2f, 1.0f)
};
float3 normal = math.normalize(math.cross(vertices[2] - vertices[1], vertices[0] - vertices[1]));
var collider = PolygonCollider.CreateQuad(vertices[0], vertices[1], vertices[2], vertices[3]);
var quadCollider = UnsafeUtilityEx.AsRef <PolygonCollider>(collider.GetUnsafePtr());
Assert.IsFalse(quadCollider.IsTriangle);
Assert.IsTrue(quadCollider.IsQuad);
TestUtils.AreEqual(quadCollider.Vertices[0], vertices[0], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[1], vertices[1], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[2], vertices[2], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[3], vertices[3], 1e-3f);
Assert.AreEqual(2, quadCollider.Planes.Length);
TestUtils.AreEqual(normal, quadCollider.Planes[0].Normal, 1e-3f);
TestUtils.AreEqual(-normal, quadCollider.Planes[1].Normal, 1e-3f);
Assert.AreEqual(ColliderType.Quad, quadCollider.Type);
Assert.AreEqual(CollisionType.Convex, quadCollider.CollisionType);
}
public unsafe void should_able_to_create_and_fetch_data_from_node_blob()
{
Debug.Log($"sizeof NodeA: {sizeof(NodeA.Data)}");
Debug.Log($"sizeof NodeB: {sizeof(NodeB.Data)}");
var size = sizeof(NodeA.Data) + sizeof(NodeB.Data);
using (var blobBuilder = new BlobBuilder(Allocator.Temp))
{
ref var blob = ref blobBuilder.ConstructRoot <NodeBlob>();
var endIndices = blobBuilder.Allocate(ref blob.EndIndices, 3);
endIndices[0] = 3;
endIndices[1] = 2;
endIndices[2] = 3;
var offsets = blobBuilder.Allocate(ref blob.Offsets, 3);
var unsafePtr = (byte *)blobBuilder.Allocate(ref blob.DefaultDataBlob, size).GetUnsafePtr();
var offset = 0;
offsets[0] = offset;
offsets[1] = offset;
UnsafeUtilityEx.AsRef <NodeA.Data>(unsafePtr + offset).A = 111;
offset += sizeof(NodeA.Data);
offsets[2] = offset;
ref var local2 = ref UnsafeUtilityEx.AsRef <NodeB.Data>(unsafePtr + offset);
public unsafe T GetData <T>() where T : struct
{
var index = TypeManager.GetTypeIndex <T>();
var ptr = GetPtrByTypeIndexRO(index);
return(UnsafeUtilityEx.AsRef <T>(ptr));
}
protected override unsafe void OnUpdate()
{
_mainThreadBlackboard.EntityCommandMainThread.EntityCommandBuffer =
_endSimulationEntityCommandBufferSystem.CreateCommandBuffer();
var behaviorTreeJobDeps = new JobHandle();
Entities.WithoutBurst().ForEach((Entity entity, DynamicBuffer <BehaviorTreeBufferElement> buffers, ref CurrentBehaviorTreeComponent currentBehaviorTree) =>
{
_mainThreadBlackboard.Entity = entity;
_mainThreadBlackboard.EntityCommandMainThread.Entity = entity;
for (var i = 0; i < buffers.Length; i++)
{
var bufferPtr = (IntPtr)buffers.GetUnsafeReadOnlyPtr() + UnsafeUtility.SizeOf <BehaviorTreeBufferElement>() * i;
ref var buffer = ref UnsafeUtilityEx.AsRef <BehaviorTreeBufferElement>(bufferPtr.ToPointer());
if (buffer.RuntimeThread == BehaviorTreeRuntimeThread.MainThread ||
buffer.RuntimeThread == BehaviorTreeRuntimeThread.ForceMainThread)
{
if (buffer.QueryMask.Matches(entity))
{
var blob = buffers[i].NodeBlob;
currentBehaviorTree.Value = bufferPtr;
VirtualMachine.Tick(ref blob, ref _mainThreadBlackboard);
}
}
else
{
// TODO: is this right way to do this? seems not optimize?
behaviorTreeJobDeps = JobHandle.CombineDependencies(behaviorTreeJobDeps, buffers[i].Dependency);
}
}
}).Run();
public unsafe T GetData <T>() where T : struct
{
var index = TypeManager.GetTypeIndex <T>();
var ptr = Entity.GetComponentDataRawRO(EntityManager, index);
return(UnsafeUtilityEx.AsRef <T>(ptr));
}
private static unsafe bool IsTrigger(NativeSlice <RigidBody> bodies, int rigidBodyIndex, ColliderKey colliderKey)
{
RigidBody hitBody = bodies[rigidBodyIndex];
hitBody.Collider.Value.GetLeaf(colliderKey, out ChildCollider leafCollider);
Material material = UnsafeUtilityEx.AsRef <ConvexColliderHeader>(leafCollider.Collider).Material;
return(material.IsTrigger);
}
public static unsafe T GetData <T>(this IBlackboard bb, ulong componentStableHash, int componentDataOffset)
where T : struct
{
var componentPtr = (byte *)bb.GetPtrRO(componentStableHash);
// TODO: type safety check
var dataPtr = componentPtr + componentDataOffset;
return(UnsafeUtilityEx.AsRef <T>(dataPtr));
}
public static unsafe void Allocate <T>(
this VariableProperty <T> variable
, ref BlobBuilder builder
, void *blobVariablePtr
, INodeDataBuilder self
, ITreeNode <INodeDataBuilder>[] tree
) where T : struct
{
variable.Allocate(ref builder, ref UnsafeUtilityEx.AsRef <BlobVariable <T> >(blobVariablePtr), self, tree);
}
public unsafe void SetComponentData <T>(T value) where T : struct, IComponentData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
if (TypeManager.IsZeroSized(typeIndex))
{
throw new ArgumentException($"SetComponentData<{typeof(T)}> can not be called with a zero sized component.");
}
UnsafeUtilityEx.AsRef <T>(Chunk.GetComponentDataWithTypeRW(Index, typeIndex, GlobalSystemVersion)) = value;
}
public unsafe T GetComponentData <T>() where T : struct, IComponentData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
if (TypeManager.IsZeroSized(typeIndex))
{
throw new ArgumentException($"GetComponentData<{typeof(T)}> can not be called with a zero sized component.");
}
return(UnsafeUtilityEx.AsRef <T>(Chunk.GetComponentDataWithTypeRO(Index, typeIndex)));
}
unsafe public void TestSphereColliderCreate()
{
float3 center = new float3(-8.45f, 9.65f, -0.10f);
float radius = 0.98f;
var collider = SphereCollider.Create(center, radius);
var sphereCollider = UnsafeUtilityEx.AsRef <SphereCollider>(collider.GetUnsafePtr());
TestUtils.AreEqual(center, sphereCollider.Center, 1e-3f);
TestUtils.AreEqual(radius, sphereCollider.Radius, 1e-3f);
Assert.AreEqual(ColliderType.Sphere, sphereCollider.Type);
Assert.AreEqual(CollisionType.Convex, sphereCollider.CollisionType);
}
protected override unsafe void Build(void *dataPtr, BlobBuilder _, ITreeNode <INodeDataBuilder>[] __)
{
switch (_source)
{
case SourceType.Component:
break;
case SourceType.Custom:
{
ref var data = ref UnsafeUtilityEx.AsRef <SetTransformRotationWithCustomRotationNode>(dataPtr);
data.Rotation = quaternion.Euler(CustomRotation);
break;
}
public T ReadBlittable <T>() where T : struct
{
T val;
unsafe
{
int size = UnsafeUtility.SizeOf <T>();
NativeSlice <byte> bytes = ReadSlice(size);
val = UnsafeUtilityEx.AsRef <T>((void *)((byte *)bytes.GetUnsafePtr()));
}
return(val);
}
unsafe public void TestCapsuleColliderCreate()
{
float3 v0 = new float3(1.45f, 0.34f, -8.65f);
float3 v1 = new float3(100.45f, -80.34f, -8.65f);
float radius = 1.45f;
var collider = CapsuleCollider.Create(v0, v1, radius);
var capsuleCollider = UnsafeUtilityEx.AsRef <CapsuleCollider>(collider.GetUnsafePtr());
Assert.AreEqual(ColliderType.Capsule, capsuleCollider.Type);
Assert.AreEqual(CollisionType.Convex, capsuleCollider.CollisionType);
TestUtils.AreEqual(v0, capsuleCollider.Vertex0);
TestUtils.AreEqual(v1, capsuleCollider.Vertex1);
TestUtils.AreEqual(radius, capsuleCollider.Radius);
}
public unsafe void TestBoxColliderCreate()
{
float3 center = new float3(-10.10f, 10.12f, 0.01f);
quaternion orientation = quaternion.AxisAngle(math.normalize(new float3(1.4f, 0.2f, 1.1f)), 38.50f);
float3 size = new float3(0.01f, 120.40f, 5.4f);
float convexRadius = 0.0f;
var collider = BoxCollider.Create(center, orientation, size, convexRadius);
var boxCollider = UnsafeUtilityEx.AsRef <BoxCollider>(collider.GetUnsafePtr());
Assert.AreEqual(center, boxCollider.Center);
Assert.AreEqual(orientation, boxCollider.Orientation);
Assert.AreEqual(size, boxCollider.Size);
Assert.AreEqual(convexRadius, boxCollider.ConvexRadius);
Assert.AreEqual(CollisionType.Convex, boxCollider.CollisionType);
Assert.AreEqual(ColliderType.Box, boxCollider.Type);
}
unsafe public void TestSphereColliderCreate()
{
var sphere = new SphereGeometry
{
Center = new float3(-8.45f, 9.65f, -0.10f),
Radius = 0.98f
};
var collider = SphereCollider.Create(sphere);
var sphereCollider = UnsafeUtilityEx.AsRef <SphereCollider>(collider.GetUnsafePtr());
TestUtils.AreEqual(sphere.Center, sphereCollider.Center, 1e-3f);
TestUtils.AreEqual(sphere.Center, sphereCollider.Geometry.Center, 1e-3f);
TestUtils.AreEqual(sphere.Radius, sphereCollider.Radius, 1e-3f);
TestUtils.AreEqual(sphere.Radius, sphereCollider.Geometry.Radius, 1e-3f);
Assert.AreEqual(ColliderType.Sphere, sphereCollider.Type);
Assert.AreEqual(CollisionType.Convex, sphereCollider.CollisionType);
}
protected override unsafe void Build(void *dataPtr, BlobBuilder _, ITreeNode <INodeDataBuilder>[] __)
{
switch (Source)
{
case VelocitySource.Component:
return;
case VelocitySource.CustomGlobal:
UnsafeUtilityEx.AsRef <CharacterSimpleMoveWithCustomGlobalVelocityNode>(dataPtr).Velocity = CustomVelocity;
break;
case VelocitySource.CustomLocal:
UnsafeUtilityEx.AsRef <CharacterSimpleMoveWithCustomLocalVelocityNode>(dataPtr).Velocity = CustomVelocity;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
unsafe public void TestCapsuleColliderCreate()
{
var geometry = new CapsuleGeometry
{
Vertex0 = new float3(1.45f, 0.34f, -8.65f),
Vertex1 = new float3(100.45f, -80.34f, -8.65f),
Radius = 1.45f
};
var collider = CapsuleCollider.Create(geometry);
var capsuleCollider = UnsafeUtilityEx.AsRef <CapsuleCollider>(collider.GetUnsafePtr());
Assert.AreEqual(ColliderType.Capsule, capsuleCollider.Type);
Assert.AreEqual(CollisionType.Convex, capsuleCollider.CollisionType);
TestUtils.AreEqual(geometry.Vertex0, capsuleCollider.Vertex0);
TestUtils.AreEqual(geometry.Vertex0, capsuleCollider.Geometry.Vertex0);
TestUtils.AreEqual(geometry.Vertex1, capsuleCollider.Vertex1);
TestUtils.AreEqual(geometry.Vertex1, capsuleCollider.Geometry.Vertex1);
TestUtils.AreEqual(geometry.Radius, capsuleCollider.Radius);
TestUtils.AreEqual(geometry.Radius, capsuleCollider.Geometry.Radius);
}
// keep it static.
private static void OnConnectionUpdateStatus(StatusInfo status, IntPtr ptr)
{
var driver = UnsafeUtilityEx.AsRef <ValveDriver>(ptr.ToPointer());
Debug.Log(driver.Listening + " : " + status.connectionInfo.state);
if (!driver.m_Connections.TryGetValue(status.connection, out var connection))
{
connection = driver.AddConnection(status.connection);
}
switch (status.connectionInfo.state)
{
case ConnectionState.None:
break;
case ConnectionState.Connecting:
driver.Sockets.AcceptConnection(status.connection);
//driver.m_QueuedConnections.Enqueue(status.connection);
break;
case ConnectionState.Connected:
connection.AddEvent(NetworkEvent.Type.Connect);
break;
case ConnectionState.ProblemDetectedLocally:
case ConnectionState.ClosedByPeer:
{
connection.AddEvent(NetworkEvent.Type.Disconnect);
if (driver.m_Connections.ContainsKey(connection.Id))
{
driver.RemoveConnection(connection.Id);
}
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
static unsafe void InitializeDefaultRotationValues(int index, ref BlobBuilderArray <float> arrayBuilder, List <LocalRotationChannel> rotationChannels)
{
if (rotationChannels.Count == 0)
{
return;
}
// Fill as SOA 4-wide quaternions
quaternion4 *dataPtr = (quaternion4 *)((float *)arrayBuilder.GetUnsafePtr() + index);
int length = rotationChannels.Count >> 2;
for (int i = 0; i < length; ++i)
{
int idx = i << 2;
*(dataPtr + i) = mathex.quaternion4(
rotationChannels[idx + 0].DefaultValue,
rotationChannels[idx + 1].DefaultValue,
rotationChannels[idx + 2].DefaultValue,
rotationChannels[idx + 3].DefaultValue
);
}
// Fill remaining rotations
for (int i = length << 2; i < rotationChannels.Count; ++i)
{
int chunkIdx = i >> 2;
int subIdx = i & 0x3; // equivalent to % 4;
quaternion q = rotationChannels[i].DefaultValue;
ref quaternion4 q4 = ref UnsafeUtilityEx.AsRef <quaternion4>(dataPtr + chunkIdx);
q4.x[subIdx] = q.value.x;
q4.y[subIdx] = q.value.y;
q4.z[subIdx] = q.value.z;
q4.w[subIdx] = q.value.w;
}
public unsafe void TestBoxColliderCreate()
{
var geometry = new BoxGeometry
{
Center = new float3(-10.10f, 10.12f, 0.01f),
Orientation = quaternion.AxisAngle(math.normalize(new float3(1.4f, 0.2f, 1.1f)), 38.50f),
Size = new float3(0.01f, 120.40f, 5.4f),
BevelRadius = 0.0f
};
var collider = BoxCollider.Create(geometry);
var boxCollider = UnsafeUtilityEx.AsRef <BoxCollider>(collider.GetUnsafePtr());
Assert.AreEqual(geometry.Center, boxCollider.Center);
Assert.AreEqual(geometry.Center, boxCollider.Geometry.Center);
Assert.AreEqual(geometry.Orientation, boxCollider.Orientation);
Assert.AreEqual(geometry.Orientation, boxCollider.Geometry.Orientation);
Assert.AreEqual(geometry.Size, boxCollider.Size);
Assert.AreEqual(geometry.Size, boxCollider.Geometry.Size);
Assert.AreEqual(geometry.BevelRadius, boxCollider.BevelRadius);
Assert.AreEqual(geometry.BevelRadius, boxCollider.Geometry.BevelRadius);
Assert.AreEqual(CollisionType.Convex, boxCollider.CollisionType);
Assert.AreEqual(ColliderType.Box, boxCollider.Type);
}
public static unsafe int GetHashCodeFunc(void *lhs)
{
return(UnsafeUtilityEx.AsRef <T>(lhs).GetHashCode());
}
public static unsafe bool CompareFunc(void *lhs, void *rhs)
{
return(UnsafeUtilityEx.AsRef <T>(lhs).Equals(UnsafeUtilityEx.AsRef <T>(rhs)));
}
public static unsafe ref T AsRef <T>(void *ptr) where T : struct => ref UnsafeUtilityEx.AsRef <T>(ptr);
protected override void OnUpdate()
{
//EntityManager.CompleteAllJobs();
var batchCount = Data.Batches.Length;
var batchesPtr = (byte *)Data.Batches.Ptr;
var dataPtr = (byte *)_dataPtr;
Job.WithCode(() =>
{
ref var data = ref UnsafeUtilityEx.AsRef <EventSystemData>(dataPtr);
data.StructuralChanges.Clear();
data.EntityCount = 0;
data.HasChanged = false;
// Process Queues
for (var i = 0; i < data.Batches.Length; i++)
{
ref var batch = ref UnsafeUtilityEx.ArrayElementAsRef <EventBatch>(batchesPtr, i);
var requiredEntities = batch.ComponentQueue.Count();
data.EntityCount += requiredEntities;
batch.HasChanged = batch.EntityCount != requiredEntities;
if (!batch.HasChanged)
{
continue;
}
data.HasChanged = true;
batch.EntityCount = requiredEntities;
if (requiredEntities == 0)
{
// Deactivate all
if (batch.ActiveChunks.ChunkCount != 0)
{
data.StructuralChanges.AddComponentToChunks.Add(new AddComponentChunkOp
{
Chunks = batch.ActiveArchetypeChunks.Ptr,
Count = batch.ActiveArchetypeChunks.Length,
TypeIndex = data.DisabledTypeIndex,
});
}
continue;
}
var capacity = batch.Archetype.ChunkCapacity;
var requiredFullChunks = requiredEntities / capacity;
var fitsExactlyInChunkCapacity = requiredEntities % capacity == 0;
var requiredPartialChunks = fitsExactlyInChunkCapacity ? 0 : 1;
var requiredChunks = requiredFullChunks + requiredPartialChunks;
var remainingEntities = requiredEntities;
var remainingInactiveFulls = batch.InactiveFullArchetypeChunks.Length;
if (requiredFullChunks > 0)
{
var remainingFullChunks = requiredFullChunks;
// Keep full active chunks
if (batch.ActiveFullArchetypeChunks.Length != 0)
{
var kept = math.min(remainingFullChunks, batch.ActiveFullArchetypeChunks.Length);
remainingFullChunks -= kept;
var excessActiveChunks = batch.ActiveFullArchetypeChunks.Length - kept;
if (excessActiveChunks != 0)
{
// Deactivate excess
data.StructuralChanges.AddComponentToChunks.Add(new AddComponentChunkOp
{
Chunks = batch.ActiveFullArchetypeChunks.Ptr,
Count = excessActiveChunks,
TypeIndex = data.DisabledTypeIndex,
});
}
}
if (batch.ActivePartialArchetypeChunk.Length != 0)
{
// Deactivate partial chunks
data.StructuralChanges.AddComponentToChunks.Add(new AddComponentChunkOp
{
Chunks = batch.ActivePartialArchetypeChunk.Ptr,
Count = batch.ActivePartialArchetypeChunk.Length,
TypeIndex = data.DisabledTypeIndex,
});
}
// Activate inactive full chunks
if (remainingFullChunks > 0 && remainingInactiveFulls != 0)
{
var conversionCount = math.min(remainingFullChunks, batch.InactiveFullArchetypeChunks.Length);
data.StructuralChanges.RemoveComponentFromChunks.Add(new RemoveComponentChunkOp
{
Chunks = batch.InactiveFullArchetypeChunks.Ptr,
TypeIndex = data.DisabledTypeIndex,
Count = conversionCount,
});
remainingInactiveFulls -= conversionCount;
remainingFullChunks -= conversionCount;
}
remainingEntities -= (requiredFullChunks - remainingFullChunks) * capacity;
}
else if (batch.ActiveArchetypeChunks.Length != 0)
{
// Deactivate all active chunks
data.StructuralChanges.AddComponentToChunks.Add(new AddComponentChunkOp
{
Chunks = batch.ActiveArchetypeChunks.Ptr,
Count = batch.ActiveArchetypeChunks.Length,
TypeIndex = data.DisabledTypeIndex,
});
}
if (remainingEntities > 0 && batch.InactiveChunks.ChunkCount != 0)
{
// Create from inactive partials
if (batch.InactivePartialArchetypeChunk.Length != 0)
{
var batchInChunks = new NativeList <EntityBatchInChunkProxy>(Allocator.Temp);
for (var j = 0; j < batch.InactivePartialArchetypeChunk.Length; j++)
{
var archetypeChunk = ((ArchetypeChunk *)batch.InactivePartialArchetypeChunk.Ptr)[j];
var amountToMove = math.min(archetypeChunk.Count, remainingEntities);
var entityBatch = new EntityBatchInChunkProxy
{
ChunkPtr = archetypeChunk.GetChunkPtr(),
Count = amountToMove,
StartIndex = 0,
};
batchInChunks.Add(entityBatch);
remainingEntities -= amountToMove;
if (remainingEntities == 0)
{
break;
}
}
data.StructuralChanges.RemoveComponentBatches.Add(new RemoveComponentBatchOp
{
EntityBatches = batchInChunks.AsParallelWriter().ListData,
TypeIndex = data.DisabledTypeIndex,
});
}
// Create from inactive fulls
if (remainingEntities > 0 && remainingInactiveFulls != 0)
{
var batchInChunks = new NativeList <EntityBatchInChunkProxy>(Allocator.Temp);
for (var j = remainingInactiveFulls - 1; j == -1; j--)
{
var archetypeChunk = ((ArchetypeChunk *)batch.InactiveFullArchetypeChunks.Ptr)[j];
var amountToMove = math.min(archetypeChunk.Count, remainingEntities);
var entityBatch = new EntityBatchInChunkProxy
{
ChunkPtr = archetypeChunk.GetChunkPtr(),
Count = amountToMove,
StartIndex = 0,
};
batchInChunks.Add(entityBatch);
remainingEntities -= amountToMove;
if (remainingEntities == 0)
{
break;
}
}
data.StructuralChanges.RemoveComponentBatches.Add(new RemoveComponentBatchOp
{
EntityBatches = batchInChunks.AsParallelWriter().ListData,
TypeIndex = data.DisabledTypeIndex,
});
}
}
if (remainingEntities != 0)
{
data.StructuralChanges.CreateChunks.Add(new CreateChunksOp
{
Archetype = batch.Archetype,
EntityCount = remainingEntities,
});
}
}
private static unsafe NodeState Tick <T>(IntPtr ptr, int index, INodeBlob blob, IBlackboard bb) where T : struct, INodeData
{
return(UnsafeUtilityEx.AsRef <T>((void *)ptr).Tick(index, blob, bb));
}
private static unsafe void Reset <T>(IntPtr ptr, int index, INodeBlob blob, IBlackboard bb) where T : struct, INodeData
{
UnsafeUtilityEx.AsRef <T>((void *)ptr).Reset(index, blob, bb);
}
private static unsafe IEnumerable <ComponentType> ReadOnlyTypes <T>(IntPtr ptr) where T : struct, IRuntimeComponentAccessor
{
return(UnsafeUtilityEx.AsRef <T>((void *)ptr).ComponentAccessList.Select(t => ComponentType.ReadOnly(t.TypeIndex)));
}
private static unsafe IEnumerable <ComponentType> ReadWriteTypes <T>(IntPtr ptr) where T : struct, IRuntimeComponentAccessor
{
return(UnsafeUtilityEx.AsRef <T>((void *)ptr).ComponentAccessList);
}