Ejemplo n.º 1
0
        private static void UnitySortBucket(BucketSlices slices)
        {
            var ranks = new NativeArray <Ranker>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);

            for (int i = 0; i < slices.count; i++)
            {
                ranks[i] = new Ranker
                {
                    index = i,
                    key   = slices.xmins[i]
                };
            }

            ranks.Sort();

            NativeArray <float>        xminBackup     = new NativeArray <float>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            NativeArray <float>        xmaxBackup     = new NativeArray <float>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            NativeArray <float4>       yzminmaxBackup = new NativeArray <float4>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            NativeArray <ColliderBody> bodyBackup     = new NativeArray <ColliderBody>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);

            slices.xmins.CopyTo(xminBackup);
            slices.xmaxs.CopyTo(xmaxBackup);
            slices.yzminmaxs.CopyTo(yzminmaxBackup);
            slices.bodies.CopyTo(bodyBackup);

            for (int i = 0; i < slices.count; i++)
            {
                int src = ranks[i].index;
                slices.xmins[i]     = xminBackup[src];
                slices.xmaxs[i]     = xmaxBackup[src];
                slices.yzminmaxs[i] = yzminmaxBackup[src];
                slices.bodies[i]    = bodyBackup[src];
            }
        }
Ejemplo n.º 2
0
        public unsafe static void RadixSortBucket3(BucketSlices slices, NativeSlice <int> remapSrcIndices, int sliceSrcStartIndex)
        {
            if (slices.count <= 0)
            {
                return;
            }

            NativeArray <int> counts1    = new NativeArray <int>(256, Allocator.Temp, NativeArrayOptions.ClearMemory);
            NativeArray <int> counts2    = new NativeArray <int>(256, Allocator.Temp, NativeArrayOptions.ClearMemory);
            NativeArray <int> counts3    = new NativeArray <int>(256, Allocator.Temp, NativeArrayOptions.ClearMemory);
            NativeArray <int> counts4    = new NativeArray <int>(256, Allocator.Temp, NativeArrayOptions.ClearMemory);
            NativeArray <int> prefixSum1 = new NativeArray <int>(256, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            NativeArray <int> prefixSum2 = new NativeArray <int>(256, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            NativeArray <int> prefixSum3 = new NativeArray <int>(256, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            NativeArray <int> prefixSum4 = new NativeArray <int>(256, Allocator.Temp, NativeArrayOptions.UninitializedMemory);

            NativeArray <Indexer> frontArray = new NativeArray <Indexer>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            NativeArray <Indexer> backArray  = new NativeArray <Indexer>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);

            NativeArray <float>        xminBackup     = new NativeArray <float>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            NativeArray <float>        xmaxBackup     = new NativeArray <float>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            NativeArray <float4>       yzminmaxBackup = new NativeArray <float4>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
            NativeArray <ColliderBody> bodyBackup     = new NativeArray <ColliderBody>(slices.count, Allocator.Temp, NativeArrayOptions.UninitializedMemory);

            slices.xmins.CopyTo(xminBackup);
            //slices.xmaxs.CopyTo(xmaxBackup);
            //slices.yzminmaxs.CopyTo(yzminmaxBackup);
            //slices.bodies.CopyTo(bodyBackup);

            //Counts
            for (int i = 0; i < slices.count; i++)
            {
                var keys = Keys(slices.xmins[i]);
                counts1[keys.byte1] = counts1[keys.byte1] + 1;
                counts2[keys.byte2] = counts2[keys.byte2] + 1;
                counts3[keys.byte3] = counts3[keys.byte3] + 1;
                counts4[keys.byte4] = counts4[keys.byte4] + 1;
                frontArray[i]       = new Indexer {
                    key = keys, index = i
                };
            }

            //Sums
            calculatePrefixSum(counts1, prefixSum1);
            calculatePrefixSum(counts2, prefixSum2);
            calculatePrefixSum(counts3, prefixSum3);
            calculatePrefixSum(counts4, prefixSum4);

            for (int i = 0; i < slices.count; i++)
            {
                byte key  = frontArray[i].key.byte1;
                int  dest = prefixSum1[key];
                backArray[dest] = frontArray[i];
                prefixSum1[key] = prefixSum1[key] + 1;
            }

            for (int i = 0; i < slices.count; i++)
            {
                byte key  = backArray[i].key.byte2;
                int  dest = prefixSum2[key];
                frontArray[dest] = backArray[i];
                prefixSum2[key]  = prefixSum2[key] + 1;
            }

            for (int i = 0; i < slices.count; i++)
            {
                byte key  = frontArray[i].key.byte3;
                int  dest = prefixSum3[key];
                backArray[dest] = frontArray[i];
                prefixSum3[key] = prefixSum3[key] + 1;
            }

            for (int i = 0; i < slices.count; i++)
            {
                byte key  = backArray[i].key.byte4;
                int  dest = prefixSum4[key];
                frontArray[dest] = backArray[i];
                prefixSum4[key]  = prefixSum4[key] + 1;
            }

            /*if (remapSrcIndices.Length > 0)
             * {
             * for (int i = 0; i < slices.count; i++)
             * {
             *   int src = frontArray[i].index;
             *   remapSrcIndices[i] = src + sliceSrcStartIndex;
             *   slices.xmins[i] = xminBackup[src];
             *   slices.xmaxs[i] = xmaxBackup[src];
             *   slices.yzminmaxs[i] = yzminmaxBackup[src];
             *   slices.bodies[i] = bodyBackup[src];
             * }
             * }
             * else
             * {
             * for (int i = 0; i < slices.count; i++)
             * {
             *   int src = frontArray[i].index;
             *   slices.xmins[i] = xminBackup[src];
             *   slices.xmaxs[i] = xmaxBackup[src];
             *   slices.yzminmaxs[i] = yzminmaxBackup[src];
             *   slices.bodies[i] = bodyBackup[src];
             * }
             * }*/
            for (int i = 0; i < slices.count; i++)
            {
                int src = frontArray[i].index;
                slices.xmins[i] = xminBackup[src];
            }
        }