FilterObstructedObjectsByGrouping()

static void FilterObstructedObjectsByGrouping ( vector origin, float range, float distanceDelta, array< Object > objects, array< Object > obstructingObjects, out array< Object > filteredObjects, bool doDistanceCheck = false, bool checkIfDistanceCanBeIgnored = false, float maxDist = 0 )

staticprotected

group objects that are close to each other together

См. определение в файле MiscGameplayFunctions.c строка 1292

    {
        array<Object> vicinityObjects= new array<Object>;
        vicinityObjects.Copy(objects);
        
        int i = 0;
        int j = 0;
        int k = 0;          
        int mCount = vicinityObjects.Count();
        
        if (!filteredObjects)
            filteredObjects = new array<Object>;
        
        // Remove objects that are too far from the player anyways
        if ( doDistanceCheck )
        {
            for ( i = vicinityObjects.Count() - 1; i >= 0; --i )
            {
                Object obj = vicinityObjects[i];
                if ( obj && !CanIgnoreDistanceCheck( obj ) && vector.DistanceSq(origin, obj.GetPosition()) > maxDist * maxDist )
                    vicinityObjects.Remove(i);
            }
        }
 
        // Sort obstructingObjects to have the furthest one first
        array<Object> sortedObstructingObjects = new array<Object>;
        array<float> distanceHelper = new array<float>;
        array<float> distanceHelperUnsorted = new array<float>;
        float distance, dist1, dist2;
 
        for ( i = 0; i < obstructingObjects.Count(); ++i )
        {
            distance = vector.DistanceSq(obstructingObjects[i].GetWorldPosition(), origin);
            distanceHelper.Insert(distance);
        }
 
        distanceHelperUnsorted.Copy(distanceHelper);
        distanceHelper.Sort();
 
        for ( i = distanceHelper.Count() - 1; i >= 0; --i )
            sortedObstructingObjects.Insert(obstructingObjects[distanceHelperUnsorted.Find(distanceHelper[i])]);
 
        array<ref array<Object>> tempGroups = new array<ref array<Object>>;
        array<ref array<Object>> objectGroups = new array<ref array<Object>>;
        array<Object> group;
        
        float cos = Math.Cos(90);
        float sin = Math.Sin(90);
 
        // Iterate through sorted obstructingObjects
        for ( i = 0; i < sortedObstructingObjects.Count(); ++i )
        {
            Object obstrObj = sortedObstructingObjects[i];
            vector worldPos = obstrObj.GetWorldPosition();
            vector min, max;
            vector minMax[2];
            if ( obstrObj.GetCollisionBox(minMax) )
            {
                min = minMax[0];
                max = minMax[1];
                max = max * (obstrObj.GetOrientation() * range);
 
                vector center, dx, dy, dz, half;
                center = (min + max) * 0.5;
                dz = obstrObj.GetOrientation();
                dx = vector.RotateAroundZero(dz, vector.Up, cos, sin);
                dy = vector.RotateAroundZero(dz, vector.Aside, cos, sin);
                half = (max - min) * 0.5;
                half = Vector(Math.AbsFloat(half[0]), Math.AbsFloat(half[1]), Math.AbsFloat(half[2]));
 
                group = new array<Object>;
 
                // Group objects within the above box
                for ( j = vicinityObjects.Count() - 1; j >= 0; --j )
                {
                    Object vicObj = vicinityObjects[j];
                    if ( vicObj )
                    {
                        vector d = vicObj.GetWorldPosition() - worldPos + center;
                        if ( Math.AbsFloat(vector.Dot(d, dx)) <= half[0] && Math.AbsFloat(vector.Dot(d, dy)) <= half[1] && Math.AbsFloat(vector.Dot(d, dz)) <= half[2] )
                        {
                            group.Insert(vicObj);
                            vicinityObjects.Remove(j);
                        }
                    }
                }
 
                if ( group.Count() > 0 )
                    tempGroups.Insert(group);
            }
        }
 
        // Go through the objects grouped by obstruction to split them by distance too
        for ( i = 0; i < tempGroups.Count(); ++i )
            SplitArrayIntoGroupsByDistance(tempGroups[i], objectGroups, distanceDelta);
 
        // Split initial groups by distance
        SplitArrayIntoGroupsByDistance(vicinityObjects, objectGroups, distanceDelta);
 
        // Raycast accordingly to groups        
        IsObjectObstructedCache cache = new IsObjectObstructedCache(origin, mCount);
        for ( i = 0; i < objectGroups.Count(); ++i )
        {
            array<Object> objectGroup = objectGroups[i];
            Object sampleObject = objectGroup[0];
 
            if ( !IsObjectObstructedEx(sampleObject, cache) )
                filteredObjects.InsertAll(objectGroup);
 
            cache.ClearCache();
        }
    }

Перекрестные ссылки Math::AbsFloat(), vector::Aside, CanIgnoreDistanceCheck(), Math::Cos(), vector::DistanceSq(), vector::Dot(), IsObjectObstructedCache(), IsObjectObstructedEx(), vector::RotateAroundZero(), Math::Sin(), SplitArrayIntoGroupsByDistance(), vector::Up и Vector().