Example #1
0
        /// <summary>
        /// Size of the array should be of multipler of i_compositesCountPerPatternGroup
        /// Assigning composites to prefab
        /// </summary>
        /// <param name="a_compositesInPatternPrefab"></param>
        static private int _AssignComponents2PatternPrefab(NativeArray <Blocks.Pattern.CompositeInPatternPrefabComponent> a_compositesInPatternPrefab)
        {
            int i_prefabOffsetIndex = i_currentPrefabsCount * i_compositesCountPerPatternGroup;

            while (i_prefabOffsetIndex < a_compositesInPatternPrefab.Length)
            {
                // expand storage if needed
                if (a_patternPrefabs.Length <= i_prefabOffsetIndex + i_compositesCountPerPatternGroup)
                {
                    // it multiplies minimum size of patter storage, by given number, of empty pattern storages
                    int i_capacityExpanderMultipler = 10;
                    // add extra space
                    NativeArray <Blocks.Pattern.CompositeInPatternPrefabComponent> a_compositesPatternPrefabsExpand = new NativeArray <Blocks.Pattern.CompositeInPatternPrefabComponent> (a_patternPrefabs.Length + i_capacityExpanderMultipler * i_compositesCountPerPatternGroup, Allocator.Temp);

                    // copy old array to new bigger aray
                    for (int i_copyIndex = 0; i_copyIndex < a_patternPrefabs.Length; i_copyIndex++)
                    {
                        a_compositesPatternPrefabsExpand [i_copyIndex] = a_patternPrefabs [i_copyIndex];
                    }
                    // a_compositesPatternPrefabs.Dispose () ;
                    a_patternPrefabs = new NativeArray <Blocks.Pattern.CompositeInPatternPrefabComponent> (a_compositesPatternPrefabsExpand.Length, Allocator.Persistent);
                    // assign back to old array, but now with bigger capacity
                    a_patternPrefabs.CopyFrom(a_compositesPatternPrefabsExpand);
                    a_compositesPatternPrefabsExpand.Dispose();
                }

                int i_ignoredOffsetIndex = 0;
                // assign components to prefab
                for (int i = 0; i < i_compositesCountPerPatternGroup; i++)
                {
                    int i_targetCpmpositeFromPrefabIndex = i_prefabOffsetIndex + i;

                    if (a_compositesInPatternPrefab [i_targetCpmpositeFromPrefabIndex].i_compositePrefabIndex >= 0)
                    {
                        // Ensuring all valid composites are stored next to each other in array, rahter tha being scattered in the array storage
                        // Allows to discard early (break;) iteration through, when first invalid composite is found,
                        // withouth accidentally discarding valid composites (per pattern)
                        a_patternPrefabs [i_targetCpmpositeFromPrefabIndex - i_ignoredOffsetIndex] = a_compositesInPatternPrefab [i_targetCpmpositeFromPrefabIndex];
                    }
                    else
                    {
                        i_ignoredOffsetIndex++;

                        // Add component to the end of store, for given prefab
                        // These are not used anymnore, but stored, just in case are needed at some point.
                        // TODO: Potentially shrinking array store cane be beneficial

                        CompositeInPatternPrefabComponent tempComposite = a_patternPrefabs [i_prefabOffsetIndex + i_compositesCountPerPatternGroup - i_ignoredOffsetIndex];
                        tempComposite.i_compositePrefabIndex = a_compositesInPatternPrefab [i].i_compositePrefabIndex;
                        a_patternPrefabs [i_prefabOffsetIndex + i_compositesCountPerPatternGroup - i_ignoredOffsetIndex] = tempComposite;
                        // other properties like position and scale is ignored

                        // Debug.Log ( "also -1: a_patternPrefabs index: " + (i_prefabOffsetIndex + i_compositesCountPerPatternGroup - i_ignoredOffsetIndex) ) ;
                    }
                }

                i_currentPrefabsCount++;

                i_prefabOffsetIndex = i_currentPrefabsCount * i_compositesCountPerPatternGroup;
            }

            return(i_currentPrefabsCount);
        }
Example #2
0
        /// <summary>
        /// Remove inner composites, which are not on outside boundary (shell)
        /// </summary>
        /// <param name="i_prefablIndex"></param>
        static private void _RemoveInnerComposites(int i_prefablIndex)
        {
            int i_discardedCompositesCount = 0;

            // store temporarly filtered prefab composites
            //NativeArray<CompositeInPatternPrefabComponent> a_requestAddComposites2PatternPrefabTemp = new NativeArray<CompositeInPatternPrefabComponent> ( a_requestAddComposites2PatternPrefab.Length, Allocator.Temp ) ;

            for (int i = 0; i < a_requestAddComposites2PatternPrefab.Length; i++)
            {
                CompositeInPatternPrefabComponent compositeFromPrefab2Filter = a_requestAddComposites2PatternPrefab [i];


                float3 f3_size      = float3.zero;
                float3 f3_sizeHalve = float3.zero;

                bool isCheckRequired = false;

                if (compositeFromPrefab2Filter.i_compositePrefabIndex >= 0 && math.lengthSquared(compositeFromPrefab2Filter.f3_scale) > 0.00001f)
                {
                    isCheckRequired = true;

                    //f3_size = compositeFromPrefab2Filter.f3_scale - new float3 ( 1,1,1 ) * f_compositeScale ; // / f_compositeScale ) ;
                    //f3_sizeHalve = f3_size * 0.5f ;
                }

                float3 f3_filterPositionMin     = a_requestAddComposites2PatternPrefab [i].f3_position - (a_requestAddComposites2PatternPrefab [i].f3_scale - f_compositeScale) * 0.5f;
                float3 f3_filterPositionMax     = new float3(i_compositesCountInRowPerPatternGroup, i_compositesCountInColumnPerPatternGroup, i_compositesCountInDepthPerPatternGroup);
                float3 f3_filterPositionMaxDiff = (f3_filterPositionMax - 1) * f_compositeScale - (a_requestAddComposites2PatternPrefab [i].f3_position + (a_requestAddComposites2PatternPrefab [i].f3_scale - f_compositeScale) * 0.5f);

                if (!isCheckRequired ||
                    (
                        f3_filterPositionMin.x < 0.0001f || // ensure that floatin precision error is not detected
                        f3_filterPositionMin.y < 0.0001f ||
                        f3_filterPositionMin.z < 0.0001f ||
                        f3_filterPositionMaxDiff.x < 0.0001f ||
                        f3_filterPositionMaxDiff.y < 0.0001f ||
                        f3_filterPositionMaxDiff.z < 0.0001f
                    ))
                {
                    isCheckRequired = false;
                }

                /*
                 * float3 f3_filterPositionMax  = ( f_posMax -1 ) * f_compositeScale - a_requestAddComposites2PatternPrefab [i].f3_position ;
                 * float3 f3_difPosAbs = math.abs ( f3_filterPositionMax ) ;
                 *
                 * if ( f3_difPosAbs.x < 0.00001 ||
                 *   f3_difPosAbs.y < 0.00001 ||
                 *   f3_difPosAbs.z < 0.00001
                 *  ) // assumes almost 0
                 * {
                 *  isCheckRequired = false ;
                 *  //isHavingNeighbour = false ;
                 *  //break ;
                 * }
                 */
                //float3 f3_filterPositionMin = math.abs ( compositeFromPrefab2Filter.f3_position - f3_sizeHalve ) ;
                //float3 f3_filterPositionMax = math.abs ( compositeFromPrefab2Filter.f3_position - ( new float3 ( i_compositesCountInRowPerPatternGroup, i_compositesCountInColumnPerPatternGroup, i_compositesCountInDepthPerPatternGroup ) -1 ) * f_compositeScale - f3_sizeHalve ) ;
                // Ignore check of absolute borders, of the boxing area, where composites are allocate located.
                // i.e. when position x, or y, or z are 0, or max

                /*
                 * if ( !isCheckRequired ||
                 *  (
                 *  f3_filterPositionMin.x < 0.0001f || // ensure that floatin precision error is not detected
                 *  f3_filterPositionMin.y < 0.0001f ||
                 *  f3_filterPositionMin.z < 0.0001f ||
                 *  f3_filterPositionMax.x < 0.0001f ||
                 *  f3_filterPositionMax.y < 0.0001f ||
                 *  f3_filterPositionMax.z < 0.0001f
                 *  ) )
                 * {
                 *  isCheckRequired = false ;
                 * }
                 * else
                 * {
                 *
                 * }
                 */

                //if ( i == 27 )
                //{
                //    Debug.Log ( "test catch #" + i ) ;
                //}

                // Only check main part of composite, from which direction is extended, if box mesh is expanded.
                if (isCheckRequired)
                {
                    // Absolute boundary checked, now check inner area, of possible naighbours

                    int3 i3_size = (int3)math.round(compositeFromPrefab2Filter.f3_scale / f_compositeScale);      // scalle back to integer units, for easier use as index
                    CompositeInPatternPrefabComponent neighbourComposite;

                    bool isHavingNeighbour = true;

                    // check boundary neighbours, of the merged composite, into bigger block, if applicable
                    for (int x = 0; x < i3_size.x; x++)
                    {
                        for (int y = 0; y < i3_size.y; y++)
                        {
                            for (int z = 0; z < i3_size.z; z++)
                            {
                                //bool isHavingNeighbour = true ;

                                int i_offset;
                                int i_index = i + y + x * i_compositesCountInColumnPerPatternGroup + z * i_compositesCountInColumnPerPatternGroup * i_compositesCountInRowPerPatternGroup;

                                float3 f_posMax     = new float3(i_compositesCountInRowPerPatternGroup, i_compositesCountInColumnPerPatternGroup, i_compositesCountInDepthPerPatternGroup);
                                float3 f3_difPos    = (f_posMax - 1) * f_compositeScale - a_requestAddComposites2PatternPrefab [i_index].f3_position;
                                float3 f3_difPosAbs = math.abs(f3_difPos);

                                if (f3_difPosAbs.x < 0.00001 ||
                                    f3_difPosAbs.y < 0.00001 ||
                                    f3_difPosAbs.z < 0.00001
                                    ) // assumes almost 0
                                {
                                    isHavingNeighbour = false;
                                    break;
                                }

                                // check all 6 sides
                                for (int i_sides = 0; i_sides < 6; i_sides++)
                                {
                                    switch (i_sides)
                                    {
                                    case 0:
                                        neighbourComposite = a_requestAddComposites2PatternPrefab [i_index + 1];      // +y
                                        break;

                                    case 1:
                                        // i_index = i_compositesCountInColumnPerPatternGroup ;
                                        i_offset           = i_index - 1;
                                        neighbourComposite = a_requestAddComposites2PatternPrefab [i_offset >= 0 ? i_offset : i];      // -y
                                        break;

                                    case 2:
                                        neighbourComposite = a_requestAddComposites2PatternPrefab [i_index + i_compositesCountInColumnPerPatternGroup];      // +x
                                        break;

                                    case 3:
                                        i_offset           = i_index - i_compositesCountInColumnPerPatternGroup;
                                        neighbourComposite = a_requestAddComposites2PatternPrefab [i_offset >= 0 ? i_offset : i];      // -x
                                        break;

                                    case 4:
                                        neighbourComposite = a_requestAddComposites2PatternPrefab [i_compositesCountInColumnPerPatternGroup + i_compositesCountInColumnPerPatternGroup * i_compositesCountInRowPerPatternGroup];      // +z
                                        break;

                                    case 5:
                                        i_offset           = i_compositesCountInColumnPerPatternGroup - i_compositesCountInColumnPerPatternGroup * i_compositesCountInRowPerPatternGroup;
                                        neighbourComposite = a_requestAddComposites2PatternPrefab [i_offset >= 0 ? i_offset : i];       // -z
                                        break;

                                    default:
                                        // error
                                        neighbourComposite = a_requestAddComposites2PatternPrefab [i];
                                        break;
                                    }

                                    if (math.lengthSquared(neighbourComposite.f3_scale) < 0.00001f)
                                    {
                                        isHavingNeighbour = false;
                                        break;
                                    }
                                } // for

                                if (!isHavingNeighbour)
                                {
                                    break;
                                }
                            } // for

                            if (!isHavingNeighbour)
                            {
                                break;
                            }
                        } // for

                        if (!isHavingNeighbour)
                        {
                            break;
                        }
                    } // for

                    // has no neighbour
                    // means is probably on the boundary, or detached
                    if (!isHavingNeighbour)
                    {
                        break;
                    }
                    else
                    {
                        i_discardedCompositesCount++;

                        //int3 i3_ = new int3 ( x,y,z ) ;
                        // Debug.Log ( "#" + i_discardedCompositesCount + " discarded composite #" + i + " has all 6 neghbour, at position: " + compositeFromPrefab2Filter.f3_position ) ;

                        //float3 f3_maxOffset = new float3 ( i_compositesCountInRowPerPatternGroup, i_compositesCountInColumnPerPatternGroup, i_compositesCountInDepthPerPatternGroup ) -
                        //    ( compositeFromPrefab2Filter.f3_position + compositeFromPrefab2Filter.f3_scale * 0.5f + ( compositeFromPrefab2Filter.f3_scale - f_compositeScale ) * 0.5f );
                        //float3 f3_maxOffsetAbs = math.abs ( f3_maxOffset ) ;

                        /*
                         * // check scaling
                         * // must not touch borders, even if is expanded
                         * if ( f3_maxOffsetAbs.x > 0.0001f &&
                         *  f3_maxOffsetAbs.y > 0.0001f &&
                         *  f3_maxOffsetAbs.z > 0.0001f )
                         * {
                         */
                        // yes haveing neighbours
                        // hence composite should be removed / deactivated
                        compositeFromPrefab2Filter.i_compositePrefabIndex = -1;
                        //compositeFromPrefab2Filter.f3_position = float3.zero ;
                        //compositeFromPrefab2Filter.f3_scale = float3.zero ;


                        a_requestAddComposites2PatternPrefab [i] = compositeFromPrefab2Filter;
                    }
                }
            }

            //a_requestAddComposites2PatternPrefabTemp.Dispose () ;
        }