Пример #1
0
        public static Vector3 GetFillerPosition(BAgentSpace space, SpaceFillInfo fillInfo, Vector3 contenstSize, int index)
        {
            Vector3Int matrixIndex = Vector3Int.one;

            matrixIndex.z = index / (fillInfo.division[0] * fillInfo.division[1]);
            matrixIndex.y = (index - matrixIndex.z) / fillInfo.division[0];
            matrixIndex.x = index % fillInfo.division[0];
            var positionIndex = (matrixIndex + Vector3.one * 0.5f);

            for (int i = 0; i < 3; i++)
            {
                positionIndex[i] = space.upperBoundary[i] - space.lowerBoundary[i] == 0 ? 0 : positionIndex[i];
            }

            /*var result =  space.origin.localToWorldMatrix * Vector3.Scale(
             *      Vector3.Scale(space.lowerBoundary, Vector3.Scale(contenstSize, fillInfo.contentScaling * (Vector3.one - positionIndex))	)
             + Vector3.Scale(space.upperBoundary, Vector3.Scale(contenstSize, fillInfo.contentScaling * positionIndex))
             +      , new Vector3(-1, 1, 1));*/
            var result = space.origin.TransformPoint(Vector3.Scale(
                                                         space.lowerBoundary + Vector3.Scale(contenstSize, fillInfo.contentScaling * positionIndex)
                                                         , new Vector3(-1, 1, 1))
                                                     );

            return(result);
        }
Пример #2
0
        public static SpaceFillInfo ScaleToFill(SpaceFillSetting setting)
        {
            var result   = new SpaceFillInfo();
            var division = Vector3Int.one;

            result.division = division;
            // max size case
            var looseFitScale  = GetLooseFittingScaling(setting.contentSize, setting.spaceSize, out int fitAxisIndex);
            int looseFillCount = 1;

            for (int i = 0; i < 3; i++)
            {
                int cellCount = Mathf.FloorToInt((setting.spaceSize[i] / (setting.contentSize[i] * looseFitScale)));
                if (cellCount <= 0)
                {
                    cellCount = 1;
                }
                division[i]     = cellCount;
                looseFillCount *= cellCount;
            }
            result.contentScaling = looseFitScale;
            int actualFillCount = looseFillCount;

            while (actualFillCount < setting.contentCount)
            {
                float newContentScale = -1;
                int   increaseIndex   = -1;
                for (int i = 0; i < 3; i++)
                {
                    float decreasedContentSizeInAxis = setting.spaceSize[i] / (division[i] + 1);
                    float decreasedFitScale          = decreasedContentSizeInAxis / setting.contentSize[i];
                    if (newContentScale < decreasedFitScale)
                    {
                        newContentScale = decreasedFitScale;
                        increaseIndex   = i;
                    }
                }
                result.contentScaling = newContentScale;
                division[increaseIndex]++;
                actualFillCount = division[0] * division[1] * division[2];
                result.division = division;
            }
            return(result);
        }