public void ObjectEquals_AlwaysThrows()
{
var array0 = new ResizableArray64Byte <int>();
var array1 = new ResizableArray64Byte <int>();
Assert.Throws <InvalidOperationException>(() => array0.Equals(array1));
}
public SequenceBuilder MoveView(float delay, float duration, Easing easing, float3 position, quaternion rotation, float3 scale)
{
var data = new ResizableArray64Byte <float>();
// position
data.Add(position.x);
data.Add(position.y);
data.Add(position.z);
//rotation
data.Add(rotation.value.x);
data.Add(rotation.value.y);
data.Add(rotation.value.z);
data.Add(rotation.value.w);
//scale
data.Add(scale.x);
data.Add(scale.y);
data.Add(scale.z);
// easing
data.Add((float)easing);
_commands.Add(new SequenceCommand
{
Type = CommandType.Move,
Delay = delay,
Duration = duration,
Data = data
});
return(this);
}
public static RestoreParentView fromData(ResizableArray64Byte <float> data)
{
return(new RestoreParentView
{
Position = new float3(data[0], data[1], data[2])
});
}
public static ImplodeView fromData(float duration, ResizableArray64Byte <float> data)
{
return(new ImplodeView
{
Duration = duration,
Easing = data.Length == 0 ? Easing.Linear : (Easing)data[0]
});
}
internal EntityQueryBuilder(ComponentSystem system)
{
m_System = system;
m_Any = new ResizableArray64Byte <int>();
m_None = new ResizableArray64Byte <int>();
m_All = new ResizableArray64Byte <int>();
m_Query = null;
}
public unsafe ComponentTypes(ComponentType a)
{
this.m_sorted = new ResizableArray64Byte <int>();
this.m_masks = new Masks();
this.m_sorted.Length = 1;
SortingUtilities.InsertSorted((int *)this.m_sorted.GetUnsafePointer(), 0, a.TypeIndex);
this.ComputeMasks();
}
internal EntityQueryBuilder(ComponentSystem system)
{
m_System = system;
m_Any = new ResizableArray64Byte <int>();
m_None = new ResizableArray64Byte <int>();
m_All = new ResizableArray64Byte <int>();
m_AnyWritableBitField = m_AllWritableBitField = 0;
m_Options = EntityQueryOptions.Default;
m_Query = null;
}
public void GetHashCode_OnlyHashesLengthBytes()
{
var array = new ResizableArray64Byte <int>();
var hashPre = array.GetHashCode();
++array.Length;
var hashPost = array.GetHashCode();
Assert.AreNotEqual(hashPre, hashPost);
}
public static MoveView fromData(float duration, ResizableArray64Byte <float> data)
{
return(new MoveView
{
Duration = duration,
Position = new float3(data[0], data[1], data[2]),
Rotation = new quaternion(data[3], data[4], data[5], data[6]),
Scale = new float3(data[7], data[8], data[9]),
Easing = data.Length > 10 ? (Easing)data[10] : Easing.Linear
});
}
public unsafe ComponentTypes(ComponentType a, ComponentType b)
{
this.m_sorted = new ResizableArray64Byte <int>();
this.m_masks = new Masks();
this.m_sorted.Length = 2;
int *data = (int *)ref this.m_sorted.GetUnsafePointer();
SortingUtilities.InsertSorted(data, 0, a.TypeIndex);
SortingUtilities.InsertSorted(data, 1, b.TypeIndex);
this.ComputeMasks();
}
public void ArrayEquals_OnlyTestsLengthBytes()
{
var array0 = new ResizableArray64Byte <long>();
array0.Add(20);
array0.Add(30);
--array0.Length;
var array1 = new ResizableArray64Byte <long>();
array1.Add(20);
Assert.IsTrue(array0.Equals(ref array1));
}
public void TestResizableArray64Byte()
{
ResizableArray64Byte <int> array = new ResizableArray64Byte <int>();
for (int i = 0; i < array.Capacity; ++i)
{
array.Add(i);
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
Assert.Throws <IndexOutOfRangeException>(() => { array.Add((int)array.Capacity); });
#endif
for (int i = 0; i < array.Capacity; ++i)
{
Assert.AreEqual(array[i], i);
}
}
public unsafe ComponentTypes(ComponentType[] componentType)
{
this.m_sorted = new ResizableArray64Byte <int>();
this.m_masks = new Masks();
this.m_sorted.Length = componentType.Length;
int *data = (int *)ref this.m_sorted.GetUnsafePointer();
int length = 0;
while (true)
{
if (length >= componentType.Length)
{
this.ComputeMasks();
return;
}
SortingUtilities.InsertSorted(data, length, componentType[length].TypeIndex);
length++;
}
}
public void Ctors_WriteDataToCorrectSlots()
{
{
var array1 = new ResizableArray64Byte <int>(1);
Assert.AreEqual(1, array1.Length);
Assert.AreEqual(1, array1[0]);
}
{
var array2 = new ResizableArray64Byte <int>(2, 3);
Assert.AreEqual(2, array2.Length);
Assert.AreEqual(2, array2[0]);
Assert.AreEqual(3, array2[1]);
}
{
var array3 = new ResizableArray64Byte <int>(4, 5, 6);
Assert.AreEqual(3, array3.Length);
Assert.AreEqual(4, array3[0]);
Assert.AreEqual(5, array3[1]);
Assert.AreEqual(6, array3[2]);
}
{
var array4 = new ResizableArray64Byte <int>(7, 8, 9, 10);
Assert.AreEqual(4, array4.Length);
Assert.AreEqual(7, array4[0]);
Assert.AreEqual(8, array4[1]);
Assert.AreEqual(9, array4[2]);
Assert.AreEqual(10, array4[3]);
}
{
var array5 = new ResizableArray64Byte <int>(11, 12, 13, 14, 15);
Assert.AreEqual(5, array5.Length);
Assert.AreEqual(11, array5[0]);
Assert.AreEqual(12, array5[1]);
Assert.AreEqual(13, array5[2]);
Assert.AreEqual(14, array5[3]);
Assert.AreEqual(15, array5[4]);
}
}
