public void Req10Test() { StructArray <TestStruct> pool = new StructArray <TestStruct>(10, ClearAction, MoveAction); List <int> ids = new List <int>(); for (int i = 0; i < 10; i++) { ids.Add(pool.Request()); } foreach (int id in ids) { Assert.IsFalse(id == -1); } for (int i = 0; i < pool.Count; i++) { pool.Values[i].X += i; } foreach (int id in ids) { Assert.AreEqual(id, pool.Values[pool.IdsToIndices[id]].X); } }
/// <summary> /// Creates a byte array to be read by the game from a <see cref="HintFile"/>. /// </summary> public byte[] ToArray() { // Make native entries. var entries = new Entry[Entries.Length]; for (int x = 0; x < entries.Length; x++) { entries[x] = new Entry(Entries[x]); } // Write strings from managed entries to a byte region. var stringData = new List <byte>(entries.Length * LongStringLength); byte[] bytes; for (int x = 0; x < entries.Length; x++) { entries[x].Offset = stringData.Count; bytes = _encoder.GetBytes(Entries[x].Text); stringData.AddRange(bytes); stringData.Add(0); } var nullEntry = Entry.Null; var nullEntryBytes = Struct.GetBytes(ref nullEntry); var stringDataBytes = stringData.ToArray(); var entryData = StructArray.GetBytes(entries); var allData = new byte[entryData.Length + nullEntryBytes.Length + stringData.Count]; Buffer.BlockCopy(entryData, 0, allData, 0, entryData.Length); Buffer.BlockCopy(nullEntryBytes, 0, allData, entryData.Length, nullEntryBytes.Length); Buffer.BlockCopy(stringDataBytes, 0, allData, entryData.Length + nullEntryBytes.Length, stringDataBytes.Length); return(allData); }
public static void Main(string[] args) { StructArray <int> a = new StructArray <int>(3); a.Array[0] = 0; a.Array[1] = 1; a.Array[2] = 2; RefArray <StructArray <double> > b = new RefArray <StructArray <double> >(3); b.Array[0] = new StructArray <double>(5); b.Array[1] = new StructArray <double>(10); b.Array[2] = new StructArray <double>(1005); BaseArray <Base> c = new BaseArray <Base>(3); c.Array[0] = new Base(); c.Array[1] = new Derived(); c.Array[2] = CreateInstance <Base>(); BaseArray <Derived> d = new BaseArray <Derived>(3); d.Array[0] = new Derived(); d.Array[1] = CreateInstance <Derived>(); d.Array[2] = CreateInstance <Derived>(); BaseArray <Derived> e = new BaseArray <Derived>(3); e.CopyArray <Derived>(d.Array); }
static void Main(string[] args) { #region 값 형식, 참조 형식 제약조건 StructArray <int> a = new StructArray <int>(3); // T는 값 형식이어야 한다. a.Array[0] = 0; a.Array[1] = 1; a.Array[2] = 2; //StructArray<string> s = new StructArray<string>(3); // error RefArray <StructArray <double> > b = new RefArray <StructArray <double> >(3); b.Array[0] = new StructArray <double>(5); b.Array[1] = new StructArray <double>(10); b.Array[2] = new StructArray <double>(15); //RefArray<int> i = new RefArray<int>(3); // error #endregion BaseArray <Base> c = new BaseArray <Base>(3); c.Array[0] = new Base(); c.Array[1] = new Derived(); c.Array[2] = CreateInstance <Base>(); BaseArray <Derived> d = new BaseArray <Derived>(2); d.Array[0] = new Derived(); // Base 형식은 여기에 할달 할 수 없다. d.Array[1] = CreateInstance <Derived>(); BaseArray <Derived> e = new BaseArray <Derived>(2); e.CopyArray <Derived>(d.Array); }
public EntityChunk(EntityArchetype arch) { unsafe { chunkVersion = 0; currentCount = 0; this.arch = arch; TypeCache[] cTypes = arch.GetComponenTypes(); TypeCache[] sTypes = arch.GetSharedTypes(); int entityAmount = arch.GetChunkCapacity(CHUNK_SIZE); entities = new StructArray <Entity>(entityAmount, true); for (int i = 0; i < entityAmount; i++) { entities[i].id = 0; } componentCollections = new ComponentArray[cTypes.Length]; for (int i = 0; i < componentCollections.Length; i++) { componentCollections[i] = new ComponentArray(cTypes[i], entityAmount); } sharedComponents = new ISharedComponent[sTypes.Length]; } }
public void _test2() { var sa = new StructArray <MyStruct>(); AssertTrue(sa.Array is Array); AssertEquals(16, sa.Array.Length); AssertNotNull(sa.Array[0]); AssertEquals(0, sa.Array[0].A); }
public void Visit(StructArray array) { _buffers.Add(CreateBuffer(array.NullBitmapBuffer)); for (int i = 0; i < array.Fields.Count; i++) { array.Fields[i].Accept(this); } }
/// <summary> /// Changes memory permissions to ensure memory can be read and reads a generic type array from a specified memory address. /// </summary> /// <typeparam name="T">An individual struct type of a class with an explicit StructLayout.LayoutKind attribute.</typeparam> /// <param name="memory"></param> /// <param name="memoryAddress">The memory address to read from.</param> /// <param name="value">Local variable to receive the read in struct array.</param> /// <param name="arrayLength">The amount of array items to read.</param> /// <param name="marshal">Set this to true to enable struct marshalling.</param> public static void SafeRead <T>(this IMemory memory, IntPtr memoryAddress, out T[] value, int arrayLength, bool marshal = false) { int regionSize = StructArray.GetSize <T>(arrayLength, marshal); var oldProtection = memory.ChangePermission(memoryAddress, regionSize, Kernel32.Kernel32.MEM_PROTECTION.PAGE_EXECUTE_READWRITE); memory.Read(memoryAddress, out value, arrayLength, marshal); memory.ChangePermission(memoryAddress, regionSize, oldProtection); }
/// <summary> /// Changes memory permissions to ensure memory can be written and writes a generic type array to a specified memory address. /// </summary> /// <typeparam name="T">An individual struct type of a class with an explicit StructLayout.LayoutKind attribute.</typeparam> /// <param name="memory"></param> /// <param name="memoryAddress">The memory address to write to.</param> /// <param name="items">The array of items to write to the address.</param> /// <param name="marshal">Set this to true to enable struct marshalling.</param> public static void SafeWrite <T>(this IMemory memory, IntPtr memoryAddress, T[] items, bool marshal = false) { int regionSize = StructArray.GetSize <T>(items.Length, marshal); var oldProtection = memory.ChangePermission(memoryAddress, regionSize, Kernel32.Kernel32.MEM_PROTECTION.PAGE_EXECUTE_READWRITE); memory.Write(memoryAddress, items, marshal); memory.ChangePermission(memoryAddress, regionSize, oldProtection); }
/* Construction Helpers */ private void CopyVertices(ManagedSpline managedSpline) { var memory = Memory.Instance; var vertices = managedSpline.Vertices; int structSize = StructArray.GetSize <SplineVertex>(vertices.Length); VertexList = (SplineVertex *)memory.Allocate(structSize); StructArray.ToPtr((IntPtr)VertexList, vertices); }
public Segment(Vector3 start, Vector3 end) { this.start = new Node() { pos = start }; this.end = new Node() { pos = end }; lengthToPercentLut = new StructArray(); length = 0; }
/* Write Base Implementation */ /// <summary> /// Writes a generic type array to a specified memory address. /// </summary> /// <typeparam name="T">An individual struct type of a class with an explicit StructLayout.LayoutKind attribute.</typeparam> /// <param name="memory"></param> /// <param name="memoryAddress">The memory address to write to.</param> /// <param name="items">The array of items to write to the address.</param> /// <param name="marshal">Set this to true to enable struct marshalling.</param> public static void Write <T>(this IMemory memory, IntPtr memoryAddress, T[] items, bool marshal = false) { IMemory oldSource = Struct.Source; Struct.Source = memory; StructArray.ToPtr(memoryAddress, items, marshal); Struct.Source = oldSource; }
/* Read Base Implementation */ /// <summary> /// Reads a generic type array from a specified memory address. /// </summary> /// <typeparam name="T">An individual struct type of a class with an explicit StructLayout.LayoutKind attribute.</typeparam> /// <param name="value">Local variable to receive the read in struct array.</param> /// <param name="memory"></param> /// <param name="memoryAddress">The memory address to read from.</param> /// <param name="arrayLength">The amount of array items to read.</param> /// <param name="marshal">Set this to true to enable struct marshalling.</param> public static void Read <T>(this IMemory memory, IntPtr memoryAddress, out T[] value, int arrayLength, bool marshal = false) { IMemory oldSource = Struct.Source; Struct.Source = memory; value = new T[arrayLength]; StructArray.FromPtr(memoryAddress, out value, arrayLength, marshal); Struct.Source = oldSource; }
/// <summary> /// Imports a binary physics file. /// </summary> public void ImportFile(string filePath) { var file = File.ReadAllBytes(filePath); StructArray.FromArray <AdventurePhysics>(file, out var physics, true); // WARNING: Order of AllCharacters must match binary file! foreach (AllCharacters character in (AllCharacters[])Enum.GetValues(typeof(AllCharacters))) { Physics[character] = physics[(int)character]; } }
public void ReqAndRemoveTest() { StructArray <TestStruct> pool = new StructArray <TestStruct>(10, ClearAction, MoveAction); List <int> ids = new List <int>(); for (int i = 0; i < 10; i++) { ids.Add(pool.Request()); } foreach (int id in ids) { Assert.IsFalse(id == -1); } for (int i = 0; i < pool.Count; i++) { pool.Values[i].X += i; } foreach (int id in ids) { Assert.AreEqual(id, pool.Values[pool.IdsToIndices[id]].X); } for (int i = 5; i < 8; i++) { pool.ReturnId(ids[i]); // return 5, 6, and 7 } Assert.IsTrue(pool.Count == 7); // down from 10 Assert.IsTrue(pool.Values[pool.IdsToIndices[ids[9]]].X == 9); // verify that accessing id9 still works // request 3 new structs, to fill back up to 10 List <int> newids = new List <int>(); for (int i = 0; i < 3; i++) { newids.Add(pool.Request()); } foreach (int id in newids) { Assert.IsFalse(id == -1); } Assert.IsTrue(pool.Count == 10); // back to 10 foreach (int id in newids) { Assert.AreEqual(0, pool.Values[pool.IdsToIndices[id]].X); // verify that returned structs were cleared } }
public void Adding_1() { StructArray <Entity> entities = new StructArray <Entity>(); Entity entity = new Entity() { id = 2, version = 1 }; entities.Add(entity); Assert.AreEqual(entities.Count, 1); }
/* Construction/Destruction */ public RandomUInt64Generator(int megabytes) { int totalBytes = Mathematics.MegaBytesToBytes(megabytes); int structs = Mathematics.BytesToStructCount <UInt64>(totalBytes); Structs = new UInt64[structs]; for (int x = 0; x < structs; x++) { Structs[x] = (UInt64)NextRandom(UInt64.MinValue, UInt64.MaxValue); } Bytes = StructArray.GetBytes(Structs); }
/* Construction/Destruction */ public RandomDoubleGenerator(int megabytes) { int totalBytes = Mathematics.MegaBytesToBytes(megabytes); int structs = Mathematics.BytesToStructCount <Double>(totalBytes); Structs = new Double[structs]; for (int x = 0; x < structs; x++) { Structs[x] = (Double)NextRandom(Double.MinValue, Double.MaxValue); } Bytes = StructArray.GetBytes(Structs); }
/* Construction/Destruction */ public RandomInt32Generator(int megabytes) { int totalBytes = Mathematics.MegaBytesToBytes(megabytes); int structs = Mathematics.BytesToStructCount <Int32>(totalBytes); Structs = new Int32[structs]; for (int x = 0; x < structs; x++) { Structs[x] = (Int32)NextRandom(Int32.MinValue, Int32.MaxValue); } Bytes = StructArray.GetBytes(Structs); }
public void Insert_1() { StructArray <Entity> entities = new StructArray <Entity>(); Entity entity = new Entity() { id = 2, version = 1 }; entities.Add(entity); entity.id = 3; entities.Insert(0, entity); Assert.AreEqual(entities[0].id, 3); }
/* Construction/Destruction */ public RandomIntStructGenerator(int megabytes) { int totalBytes = Mathematics.MegaBytesToBytes(megabytes); int structs = Mathematics.BytesToStructCount <RandomIntStruct>(totalBytes); Structs = new RandomIntStruct[structs]; for (int x = 0; x < structs; x++) { Structs[x] = RandomIntStruct.BuildRandomStruct(); } Bytes = StructArray.GetBytes(Structs); File.WriteAllBytes(TestFileName, Bytes); }
/// <summary> /// Obtains the AFS header from a specific file path. /// </summary> private AfsFileEntry[] GetEntriesFromFile(string filePath) { using FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 8192); var data = new byte[sizeof(AfsHeader)]; stream.Read(data, 0, data.Length); Struct.FromArray(data, out AfsHeader header); data = new byte[sizeof(AfsFileEntry) * header.NumberOfFiles]; stream.Read(data, 0, data.Length); StructArray.FromArray(data, out AfsFileEntry[] entries); return(entries); }
/* Construction/Destruction */ public RandomIntegerGenerator(int megabytes) { int totalBytes = Mathematics.MegaBytesToBytes(megabytes); int structs = Mathematics.BytesToStructCount <int>(totalBytes); Structs = new int[structs]; for (int x = 0; x < structs; x++) { Structs[x] = _random.Next(); } Bytes = StructArray.GetBytes(Structs); File.WriteAllBytes(TestFileName, Bytes); }
/* Read Base Implementation */ /// <summary> /// Reads a generic type array from a specified memory address. /// </summary> /// <typeparam name="T">An individual struct type of a class with an explicit StructLayout.LayoutKind attribute.</typeparam> /// <param name="value">Local variable to receive the read in struct array.</param> /// <param name="memory"></param> /// <param name="memoryAddress">The memory address to read from.</param> /// <param name="arrayLength">The amount of array items to read.</param> /// <param name="marshal">Set this to true to enable struct marshalling.</param> public static void Read <T>(this IMemory memory, IntPtr memoryAddress, out T[] value, int arrayLength, bool marshal = false) { IMemory oldSource = Struct.Source; Struct.Source = memory; #if NET5_0_OR_GREATER value = GC.AllocateUninitializedArray <T>(arrayLength, false); #else value = new T[arrayLength]; #endif StructArray.FromPtr(memoryAddress, out value, arrayLength, marshal); Struct.Source = oldSource; }
public void Visit(StructArray array) { Assert.IsAssignableFrom <StructArray>(_expectedArray); StructArray expectedArray = (StructArray)_expectedArray; Assert.Equal(expectedArray.Length, array.Length); Assert.Equal(expectedArray.NullCount, array.NullCount); Assert.Equal(expectedArray.Offset, array.Offset); Assert.Equal(expectedArray.Data.Children.Length, array.Data.Children.Length); Assert.Equal(expectedArray.Fields.Count, array.Fields.Count); for (int i = 0; i < array.Fields.Count; i++) { array.Fields[i].Accept(new ArrayComparer(expectedArray.Fields[i])); } }
protected override void OnDraw() { EntityWorld world = EntityWorld.Active; StructArray <EntityChunk> chunks = world.EntityManager.GetChunks(); for (int i = 0; i < chunks.Count; i++) { ref EntityChunk chunk = ref chunks[i]; bool open = ImGui.TreeNode($"[{i}] Chunk: {chunk.Count}/{chunk.Capacity}"); if (ImGui.IsItemHovered()) { ImGui.SetTooltip(chunk.Archetype.ToString()); } if (open) { ImGuiTableFlags tFlags = ImGuiTableFlags.RowBg | ImGuiTableFlags.Resizable; if (ImGui.BeginTable("Entities", 2, tFlags)) { ImGui.TableSetupColumn("Id"); ImGui.TableSetupColumn("Version"); ImGui.TableHeadersRow(); for (int e = 0; e < chunk.Count; e++) { Entity entity = chunk.GetEntity(e); ImGui.TableNextRow(); ImGui.TableNextColumn(); bool isSelected = ObjectSelections.CurrentObj?.Equals(entity) ?? false; if (ImGui.Selectable($"##{e}", isSelected, ImGuiSelectableFlags.SpanAllColumns)) { ObjectSelections.SelectObject(entity); } ImGui.SameLine(); ImGui.Text(entity.id.ToString()); ImGui.TableNextColumn(); ImGui.Text(entity.version.ToString()); } ImGui.Separator(); ImGui.EndTable(); } ImGui.TreePop(); } }
public void Removing_1() { StructArray <Entity> entities = new StructArray <Entity>(); Entity entity = new Entity() { id = 2, version = 1 }; entities.Add(entity); entity.id = 3; entities.Add(entity); entity.id = 2; entities.SwapForLast(entity); Assert.AreEqual(entities.Count, 1); }
static void Main(string[] args) { StructArray <int> a = new StructArray <int>(3); a.Array[0] = 1; a.Array[1] = 3; a.Array[2] = 4; for (int i = 0; i < a.Array.Length; i++) { Console.WriteLine(a.Array[i]); } RefArray <StructArray <double> > b = new RefArray <StructArray <double> >(3); b.Array[0] = new StructArray <double>(5); b.Array[0].Array[0] = 1; b.Array[0].Array[1] = 1; b.Array[0].Array[2] = 1; b.Array[0].Array[3] = 1; b.Array[0].Array[4] = 1; b.Array[1] = new StructArray <double>(10); b.Array[2] = new StructArray <double>(105); for (int i = 0; i < b.Array.Length; i++) { Console.WriteLine(b.Array[0].Array[i]); } BaseArray <Base> c = new BaseArray <Base>(3); c.Array[0] = new Base(); c.Array[1] = new Derived(); c.Array[2] = CreateInstance <Base>(); BaseArray <Derived> d = new BaseArray <Derived>(3); d.Array[0] = new Derived(); d.Array[1] = CreateInstance <Derived>(); d.Array[2] = CreateInstance <Derived>(); BaseArray <Derived> e = new BaseArray <Derived>(3); e.CopyArray <Derived>(d.Array); }
public void DEBUG_LOG_INFO() { StringBuilder sb = new StringBuilder(); sb.Append("Entity Manager: \n"); StructArray <EntityChunk> chunks = entityManager.GetChunks(); sb.Append("Chunks Count: " + chunks.Count + "\n"); sb.Append($"----------------------------------- \n"); for (int i = 0; i < chunks.Count; i++) { EntityChunk chunk = chunks[i]; sb.Append($"Entities: {chunk.Count} / Version: {chunk.ChunkVersion} \n"); sb.Append($"Archetype: {chunk.Archetype} \n"); sb.Append($"----------------------------------- \n"); } sb.Append("\n"); Console.WriteLine(sb); }
public void Removing_2() { StructArray <Entity> entities = new StructArray <Entity>(); Entity entity = new Entity(); entities.Add(entity); entity.id = 1; entities.Add(entity); entity.id = 2; entities.Add(entity); entity.id = 3; entities.Add(entity); entities.SwapForLast(0); Assert.AreEqual(entities[0].id, 3); }
public override object Clone() { StructArray newObj = new StructArray(this); // clone the elements of the array? array.CopyTo(newObj.array, 0); return newObj; }
private StructArray(StructArray c) : base(c) { array = new _ElementType[c.Count]; }