protected override void OnCreate() { m_vertices = new NativeList <Vertex>(10000, Allocator.Persistent); m_triangles = new NativeList <VertexIndex>(10000, Allocator.Persistent); m_vertexCounter = new NativeCounter(Allocator.Persistent); m_vertexIndexCounter = new NativeCounter(Allocator.Persistent); m_subMeshCounter = new NativeCounter(Allocator.Persistent); m_offsets = new NativeList <OffsetInfo>(0, Allocator.Persistent); m_entityIndexMap = new NativeHashMap <Entity, int>(1000, Allocator.Persistent); m_sharedFontIndices = new NativeList <int>(0, Allocator.Persistent); m_canvasdRootQuery = GetEntityQuery( ComponentType.ReadOnly <CanvasRoot>(), ComponentType.ReadWrite <Vertex>(), ComponentType.ReadWrite <VertexIndex>(), ComponentType.ReadWrite <SubMeshInfo>()); m_vertexDataQuery = GetEntityQuery( ComponentType.ReadOnly <FontMaterial>(), ComponentType.ReadOnly <TextRenderer>(), ComponentType.ReadOnly <Vertex>(), ComponentType.ReadOnly <VertexIndex>()); m_filterChanged = new ComponentType[] { ComponentType.ReadOnly <Vertex>(), ComponentType.ReadOnly <VertexIndex>() }; }
protected override JobHandle OnUpdate(JobHandle inputDeps) { EntityManager.GetAllUniqueSharedComponentData <LineRenderer>(lineRenderers); NativeCounter lineCounter = new NativeCounter(Allocator.Temp); LineMeshBuilderJob job = new LineMeshBuilderJob(); for (int i = 0; i < lineRenderers.Count; ++i) { LineRenderer renderer = lineRenderers[i]; group.SetFilter(renderer); int groupCount = group.CalculateLength(); if (groupCount == 0) { continue; } lineCounter.Count = 0; job.Initialize(group, renderer.Vertices, renderer.Normals, lineCounter); inputDeps = job.Schedule(groupCount, 8, inputDeps); inputDeps.Complete(); } lineRenderers.Clear(); lineCounter.Dispose(); return(inputDeps); }
static DataWithIndex <T>[] Sort <T>(NativeArray <DataWithIndex <T> > array, int processAmount, int concurrentJobs) where T : struct, IComparable <T> { var length = array.Length; var timeSpanParallelSort = new TimeSpanParallelSort <DataWithIndex <T> >(); var counter = new NativeCounter(Allocator.TempJob); var cycles = 0; timeSpanParallelSort.Start(array, processAmount, concurrentJobs).Complete(); while (!timeSpanParallelSort.IsComplete) { timeSpanParallelSort.Update().Complete(); cycles++; } SortUtilityTest .CountSortedData(timeSpanParallelSort.SortedData.AsDeferredJobArray(), counter, length, default) .Complete(); var sortedArray = timeSpanParallelSort.SortedData.ToArray(); var result = counter.Value; counter.Dispose(); array.Dispose(); timeSpanParallelSort.Dispose(); Assert.True(result == length); UnityEngine.Debug.Log($"Sorted array in {cycles} cycles"); return(sortedArray); }
/// <summary> /// Starts a mesh generation job /// </summary> /// <param name="voxelDataStore">The store where to retrieve the voxel data from</param> /// <param name="chunkCoordinate">The coordinate of the chunk that will be generated</param> /// <returns>The job handle and the actual mesh generation job</returns> public override JobHandleWithData <IMesherJob> CreateMesh(VoxelDataStore voxelDataStore, int3 chunkCoordinate) { if (!voxelDataStore.TryGetVoxelDataChunk(chunkCoordinate, out VoxelDataVolume boundsVoxelData)) { return(null); } NativeCounter vertexCountCounter = new NativeCounter(Allocator.TempJob); int voxelCount = (boundsVoxelData.Width - 1) * (boundsVoxelData.Height - 1) * (boundsVoxelData.Depth - 1); int maxLength = 15 * voxelCount; NativeArray <MeshingVertexData> outputVertices = new NativeArray <MeshingVertexData>(maxLength, Allocator.TempJob); NativeArray <ushort> outputTriangles = new NativeArray <ushort>(maxLength, Allocator.TempJob); MarchingCubesJob marchingCubesJob = new MarchingCubesJob { VoxelData = boundsVoxelData, Isolevel = Isolevel, VertexCountCounter = vertexCountCounter, OutputVertices = outputVertices, OutputTriangles = outputTriangles }; JobHandle jobHandle = marchingCubesJob.Schedule(voxelCount, 128); JobHandleWithData <IMesherJob> jobHandleWithData = new JobHandleWithData <IMesherJob>(); jobHandleWithData.JobHandle = jobHandle; jobHandleWithData.JobData = marchingCubesJob; return(jobHandleWithData); }
public void SortMultipleTimes() { var length01 = 100; var length02 = 1000; var parallelSort = new ParallelSort <DataWithIndex <float> >(); var array01 = SortUtilityTest.GenerateFloatNativeArray(length01, out var inputDeps); var counter01 = new NativeCounter(Allocator.TempJob); inputDeps = parallelSort.Sort(array01, array01.Length, 8, inputDeps); inputDeps = SortUtilityTest.CountSortedData(parallelSort.SortedData.AsDeferredJobArray(), counter01, array01.Length, inputDeps); var array02 = SortUtilityTest.GenerateFloatNativeArray(length02, out var moreFloatsHandle); inputDeps = JobHandle.CombineDependencies(inputDeps, moreFloatsHandle); var counter02 = new NativeCounter(Allocator.TempJob); inputDeps = parallelSort.Sort(array02, array02.Length, 3, inputDeps); inputDeps = SortUtilityTest.CountSortedData(parallelSort.SortedData.AsDeferredJobArray(), counter02, array02.Length, inputDeps); inputDeps.Complete(); var result01 = counter01.Value; var result02 = counter02.Value; counter01.Dispose(); array01.Dispose(); counter02.Dispose(); array02.Dispose(); parallelSort.Dispose(); Assert.True(result01 == length01); Assert.True(result02 == length02); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { EntityManager.GetAllUniqueSharedComponentData <LineRendererRef>(lineRendererRefs); NativeCounter lineCounter = new NativeCounter(Allocator.TempJob); var vertexBuffers = GetBufferFromEntity <BufferableVertex>(); for (int i = 0; i < lineRendererRefs.Count; ++i) { Entity lineRendererEntity = lineRendererRefs[i].Value; LineRendererRef rendererRef = lineRendererRefs[i]; lineQuery.SetFilter(rendererRef); int groupCount = lineQuery.CalculateEntityCount(); if (groupCount == 0) { continue; } lineCounter.Count = 0; LineMeshBuilderJob job = new LineMeshBuilderJob { _counter = lineCounter, _vertexBuffer = (vertexBuffers[lineRendererEntity]), }; inputDeps = job.Schedule(this, inputDeps); inputDeps.Complete(); } lineRendererRefs.Clear(); lineCounter.Dispose(); return(inputDeps); }
protected override void OnCreate() { m_rootsQuery = GetEntityQuery(new EntityQueryDesc { All = new ComponentType[] { ComponentType.ReadOnly <LocalToWorld>(), ComponentType.ReadOnly <Child>() }, None = new ComponentType[] { typeof(Parent) }, Options = EntityQueryOptions.FilterWriteGroup }); m_allChildrenQuery = GetEntityQuery(new EntityQueryDesc { All = new ComponentType[] { ComponentType.ReadOnly <LocalToWorld>(), ComponentType.ReadOnly <Parent>() }, Options = EntityQueryOptions.IncludeDisabled }); m_childrenEntities = new NativeList <ChildInfo>(Allocator.Persistent); m_topLevelChildrenCounter = new NativeCounter(Allocator.Persistent); }
public static JobHandle CountSortedData <T>(NativeArray <T> input, NativeCounter output, int length, JobHandle inputDeps) where T : struct, IComparable <T> { return(new ValidateSortedArray <T> { Source = input, Counter = output }.Schedule(length, 128, inputDeps)); }
public static JobHandle CountBufferElements <TBufferElementData>( this EntityQuery entityQuery, ref NativeCounter counter, JobHandle inputDeps) where TBufferElementData : struct, IBufferElementData { return(new CountBufferElements <TBufferElementData> { Counter = counter }.Schedule(entityQuery, inputDeps)); }
protected sealed override bool Filter(NativeCounter c) { if ((c.Section & mask) != 0) { Console.Write("{0,10} {1,10} {2,10} ", c.Section, c.Type, c.Unit); return(true); } return(false); }
public void GetSetCount() { var counter = new NativeCounter(Allocator.Temp); Assert.AreEqual(0, counter.Count); counter.Count = 42; Assert.AreEqual(42, counter.Count); counter.Count = 3; Assert.AreEqual(3, counter.Count); counter.Dispose(); }
public void Increment() { var counter = new NativeCounter(Allocator.Temp); Assert.AreEqual(0, counter.Count); counter.Increment(); Assert.AreEqual(1, counter.Count); counter.Increment(); counter.Increment(); Assert.AreEqual(3, counter.Count); counter.Dispose(); }
public void ParallelIncrement() { var counter = new NativeCounter(Allocator.Temp); var jobData = new ParallelCountTo(); jobData.counter = counter; // Count every second item jobData.countMask = 1; jobData.Schedule(1000000, 1).Complete(); Assert.AreEqual(500000, counter.Count); counter.Dispose(); }
public NativeMeshData(int chunkSize) { int maxVertices = 12 * chunkSize * chunkSize * chunkSize; int maxIndices = 18 * chunkSize * chunkSize * chunkSize; nativeVertices = new NativeArray <float3>(maxVertices, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); nativeNormals = new NativeArray <float3>(maxVertices, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); nativeUVs = new NativeArray <float4>(maxVertices, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); nativeColors = new NativeArray <Color>(maxVertices, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); nativeIndices = new NativeArray <int>(maxIndices, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); counter = new NativeCounter(Allocator.TempJob); }
public static JobHandle ResizeBufferDeferred <TBufferElementData>( this EntityQuery entityQuery, ComponentSystemBase system, NativeCounter length, JobHandle inputDeps) where TBufferElementData : struct, IBufferElementData { return(new ResizeBufferDeferred <TBufferElementData> { BufferType = system.GetArchetypeChunkBufferType <TBufferElementData>(false), Length = length }.Schedule(entityQuery, inputDeps)); }
public static JobHandle CountBufferElements <TBufferElementData>( this EntityQuery entityQuery, EntityManager entityManager, ref NativeCounter counter, JobHandle inputDeps) where TBufferElementData : struct, IBufferElementData { return(new CountBufferElements <TBufferElementData> { ChunkBufferType = entityManager.GetArchetypeChunkBufferType <TBufferElementData>(true), Counter = counter }.Schedule(entityQuery, inputDeps)); }
protected override void OnStartRunning() { batches = new RequestBatch[MAX_QUERIES]; for (var i = 0; i < MAX_QUERIES; ++i) { batches[i] = new RequestBatch(2000); } waitingEntities = new NativeQueue <Entity>(Allocator.Persistent); counter = new NativeCounter(Allocator.Persistent); endFence = new JobHandle(); }
public void ParallelDecrementSetCount() { var counter = new NativeCounter(Allocator.Temp); var jobData = new ParallelDecrementCountTo(); jobData.counter = counter.ToConcurrent(); counter.Count = -42; // Count every second item jobData.countMask = 1; jobData.Schedule(1000, 1).Complete(); Assert.AreEqual(-542, counter.Count); counter.Dispose(); }
public NativeMeshData(int3 chunkSize) { int numVoxels = chunkSize.x * chunkSize.y * chunkSize.z; int maxVertices = 12 * numVoxels; int maxIndices = 18 * numVoxels; nativeVoxels = new NativeArray <Voxel>(numVoxels, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); nativeVertices = new NativeArray <float3>(maxVertices, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); nativeNormals = new NativeArray <float3>(maxVertices, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); nativeUVs = new NativeArray <float4>(maxVertices, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); nativeColors = new NativeArray <Color>(maxVertices, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); nativeIndices = new NativeArray <int>(maxIndices, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); counter = new NativeCounter(Allocator.TempJob); }
void CreateOffsets( NativeHashMap <Entity, int> entitiesIndexMap, NativeArray <SortedEntity> sortedEntities, NativeArray <int> sharedComponentIndices, NativeArray <OffsetInfo> offsets, NativeCounter vertexCounter, NativeCounter vertexIndexCounter, NativeCounter subMeshCounter) { var vertices = GetBufferFromEntity <Vertex>(true); var vertexIndices = GetBufferFromEntity <VertexIndex>(true); Job .WithReadOnly(entitiesIndexMap) .WithReadOnly(sortedEntities) .WithReadOnly(sharedComponentIndices) .WithReadOnly(vertices) .WithReadOnly(vertexIndices) .WithCode(() => { var prevIndex = -1; for (var i = sortedEntities.Length - 1; i >= 0; --i) { var entity = sortedEntities[i].Value; if (!entitiesIndexMap.TryGetValue(entity, out var index)) { continue; } var vertexData = vertices[entity]; var vertexIndexData = vertexIndices[entity]; var sharedComponentIndex = sharedComponentIndices[index]; var prevSharedComponentIndex = prevIndex >= 0 ? sharedComponentIndices[prevIndex] : -1; offsets[index] = new OffsetInfo { Vertex = vertexCounter.Value, VertexCount = vertexData.Length, Indices = vertexIndexCounter.Value, SubMeshIndex = sharedComponentIndex != prevSharedComponentIndex ? subMeshCounter.Value : -1, SubMesh = sharedComponentIndex != prevSharedComponentIndex ? vertexIndexCounter.Value : -1, SubMeshMaterialId = sharedComponentIndex != prevSharedComponentIndex ? sharedComponentIndex : -1 }; if (sharedComponentIndex != prevSharedComponentIndex) { subMeshCounter.Increment(1); } vertexCounter.Increment(vertexData.Length); vertexIndexCounter.Increment(vertexIndexData.Length); prevIndex = index; } }).Schedule(); }
public void Decrement() { int count; var counter = new NativeCounter(Allocator.Temp); Assert.AreEqual(0, counter.Count); count = counter.Decrement(); Assert.AreEqual(-1, count); Assert.AreEqual(-1, counter.Count); count = counter.Decrement(); count = counter.Decrement(); Assert.AreEqual(-3, count); Assert.AreEqual(-3, counter.Count); counter.Dispose(); }
public void SetCountConcurrentDecrement() { var counter = new NativeCounter(Allocator.Temp); var concurrentCounter = counter.ToConcurrent(); Assert.AreEqual(0, counter.Count); concurrentCounter.Decrement(); Assert.AreEqual(-1, counter.Count); counter.Count = 40; Assert.AreEqual(40, counter.Count); concurrentCounter.Decrement(); concurrentCounter.Decrement(); Assert.AreEqual(38, counter.Count); counter.Dispose(); }
public void SetCountConcurrentIncrement() { var counter = new NativeCounter(Allocator.Temp); NativeCounter.Concurrent concurrentCounter = counter; Assert.AreEqual(0, counter.Count); concurrentCounter.Increment(); Assert.AreEqual(1, counter.Count); counter.Count = 40; Assert.AreEqual(40, counter.Count); concurrentCounter.Increment(); concurrentCounter.Increment(); Assert.AreEqual(42, counter.Count); counter.Dispose(); }
public void ConcurrentIncrement() { int count; var counter = new NativeCounter(Allocator.Temp); var concurrentCounter = counter.ToConcurrent(); Assert.AreEqual(0, counter.Count); count = concurrentCounter.Increment(); Assert.AreEqual(1, count); Assert.AreEqual(1, counter.Count); count = concurrentCounter.Increment(); count = concurrentCounter.Increment(); Assert.AreEqual(3, count); Assert.AreEqual(3, counter.Count); counter.Dispose(); }
static void FloatSort(int length, int concurrentJobs) { var array = SortUtilityTest.GenerateFloatNativeArray(length, out var inputDeps); var parallelSort = new ParallelSort <DataWithIndex <float> >(); var counter = new NativeCounter(Allocator.TempJob); inputDeps = parallelSort.Sort(array, array.Length, concurrentJobs, inputDeps: inputDeps); inputDeps = SortUtilityTest.CountSortedData(parallelSort.SortedData.AsDeferredJobArray(), counter, array.Length, inputDeps); inputDeps.Complete(); var result = counter.Value; counter.Dispose(); array.Dispose(); parallelSort.Dispose(); Assert.True(result == length); }
static DataWithIndex <int>[] IntSort(NativeArray <DataWithIndex <int> > array, int concurrentJobs, JobHandle inputDeps = default) { var length = array.Length; var parallelSort = new ParallelSort <DataWithIndex <int> >(); var counter = new NativeCounter(Allocator.TempJob); inputDeps = parallelSort.Sort(array, length, concurrentJobs, inputDeps); inputDeps = SortUtilityTest.CountSortedData(parallelSort.SortedData.AsDeferredJobArray(), counter, length, inputDeps); inputDeps.Complete(); var sortedArray = parallelSort.SortedData.ToArray(); var result = counter.Value; counter.Dispose(); array.Dispose(); parallelSort.Dispose(); Assert.True(result == length); return(sortedArray); }
/// <inheritdoc/> public override JobHandleWithData <IMesherJob> CreateMesh(VoxelDataStore voxelDataStore, VoxelColorStore voxelColorStore, int3 chunkCoordinate) { if (!voxelDataStore.TryGetDataChunk(chunkCoordinate, out VoxelDataVolume <byte> boundsVoxelData)) { return(null); } if (!voxelColorStore.TryGetDataChunk(chunkCoordinate, out VoxelDataVolume <Color32> boundsVoxelColors)) { return(null); } NativeCounter vertexCountCounter = new NativeCounter(Allocator.TempJob); int voxelCount = VoxelWorld.WorldSettings.ChunkSize.x * VoxelWorld.WorldSettings.ChunkSize.y * VoxelWorld.WorldSettings.ChunkSize.z; int maxLength = 15 * voxelCount; NativeArray <MeshingVertexData> outputVertices = new NativeArray <MeshingVertexData>(maxLength, Allocator.TempJob); NativeArray <ushort> outputTriangles = new NativeArray <ushort>(maxLength, Allocator.TempJob); MarchingCubesJob marchingCubesJob = new MarchingCubesJob { VoxelData = boundsVoxelData, VoxelColors = boundsVoxelColors, Isolevel = Isolevel, VertexCountCounter = vertexCountCounter, OutputVertices = outputVertices, OutputTriangles = outputTriangles }; JobHandle jobHandle = marchingCubesJob.Schedule(); JobHandleWithData <IMesherJob> jobHandleWithData = new JobHandleWithData <IMesherJob> { JobHandle = jobHandle, JobData = marchingCubesJob }; return(jobHandleWithData); }
protected override bool Filter(NativeCounter c) => c.Section == CounterSection.Gc;
public DirectivesTest1(Allocator type) { Kek = new NativeCounter(type); }
public void SetupCounterTest() { counter = new NativeCounter(Allocator.Temp); }