C# AABB.Intersects方法代码示例

        /// <summary> Determines whether any of the blocks that intersect the
        /// given bounding box satisfy the given condition. </summary>
        public bool TouchesAny( AABB bounds, Predicate<byte> condition )
        {
            Vector3I bbMin = Vector3I.Floor( bounds.Min );
            Vector3I bbMax = Vector3I.Floor( bounds.Max );

            // Order loops so that we minimise cache misses
            for( int y = bbMin.Y; y <= bbMax.Y; y++ )
                for( int z = bbMin.Z; z <= bbMax.Z; z++ )
                    for( int x = bbMin.X; x <= bbMax.X; x++ )
            {
                if( !game.World.IsValidPos( x, y, z ) ) continue;
                byte block = game.World.GetBlock( x, y, z );
                Vector3 min = new Vector3( x, y, z ) + info.MinBB[block];
                Vector3 max = new Vector3( x, y, z ) + info.MaxBB[block];

                AABB blockBB = new AABB( min, max );
                if( !blockBB.Intersects( bounds ) ) continue;
                if( condition( block ) ) return true;
            }
            return false;
        }

        float LowestModifier( AABB bounds, bool checkSolid )
        {
            Vector3I bbMin = Vector3I.Floor( bounds.Min );
            Vector3I bbMax = Vector3I.Floor( bounds.Max );
            float modifier = inf;

            for( int y = bbMin.Y; y <= bbMax.Y; y++ )
                for( int z = bbMin.Z; z <= bbMax.Z; z++ )
                    for( int x = bbMin.X; x <= bbMax.X; x++ )
            {
                byte block = game.World.SafeGetBlock( x, y, z );
                if( block == 0 ) continue;
                CollideType type = info.Collide[block];
                if( type == CollideType.Solid && !checkSolid )
                    continue;

                Vector3 min = new Vector3( x, y, z ) + info.MinBB[block];
                Vector3 max = new Vector3( x, y, z ) + info.MaxBB[block];
                AABB blockBB = new AABB( min, max );
                if( !blockBB.Intersects( bounds ) ) continue;

                modifier = Math.Min( modifier, info.SpeedMultiplier[block] );
                if( block >= BlockInfo.CpeCount && type == CollideType.SwimThrough )
                    useLiquidGravity = true;
            }
            return modifier;
        }

        void FindReachableBlocks( ref int count, out AABB entityBB, 
            out AABB entityExtentBB)
        {
            Vector3 vel = entity.Velocity;
            entityBB = entity.CollisionBounds;

            // Exact maximum extent the entity can reach, and the equivalent map coordinates.
            entityExtentBB = new AABB(
                vel.X < 0 ? entityBB.Min.X + vel.X : entityBB.Min.X,
                vel.Y < 0 ? entityBB.Min.Y + vel.Y : entityBB.Min.Y,
                vel.Z < 0 ? entityBB.Min.Z + vel.Z : entityBB.Min.Z,
                vel.X > 0 ? entityBB.Max.X + vel.X : entityBB.Max.X,
                vel.Y > 0 ? entityBB.Max.Y + vel.Y : entityBB.Max.Y,
                vel.Z > 0 ? entityBB.Max.Z + vel.Z : entityBB.Max.Z
            );
            Vector3I min = Vector3I.Floor( entityExtentBB.Min );
            Vector3I max = Vector3I.Floor( entityExtentBB.Max );

            int elements = (max.X + 1 - min.X) * (max.Y + 1 - min.Y) * (max.Z + 1 - min.Z);
            if( elements > stateCache.Length ) {
                stateCache = new State[elements];
            }

            AABB blockBB = default( AABB );
            // Order loops so that we minimise cache misses
            for( int y = min.Y; y <= max.Y; y++ )
                for( int z = min.Z; z <= max.Z; z++ )
                    for( int x = min.X; x <= max.X; x++ )
            {
                byte blockId = GetPhysicsBlockId( x, y, z );
                if( !GetBoundingBox( blockId, x, y, z, ref blockBB ) ) continue;
                if( !entityExtentBB.Intersects( blockBB ) ) continue; // necessary for non whole blocks. (slabs)

                float tx = 0, ty = 0, tz = 0;
                CalcTime( ref vel, ref entityBB, ref blockBB, out tx, out ty, out tz );
                if( tx > 1 || ty > 1 || tz > 1 ) continue;
                float tSquared = tx * tx + ty * ty + tz * tz;
                stateCache[count++] = new State( x, y, z, blockId, tSquared );
            }
        }

        void CollideWithReachableBlocks( int count, ref Vector3 size,
            ref AABB entityBB, ref AABB entityExtentBB)
        {
            bool wasOn = entity.onGround;
            entity.onGround = false;
            if( count > 0 )
                QuickSort( stateCache, 0, count - 1 );
            hitXMin = false; hitYMin = false; hitZMin = false;
            hitXMax = false; hitYMax = false; hitZMax = false;
            AABB blockBB = default(AABB);

            for( int i = 0; i < count; i++ ) {
                State state = stateCache[i];
                Vector3 blockPos = new Vector3( state.X >> 3, state.Y >> 3, state.Z >> 3 );
                int block = (state.X & 0x7) | (state.Y & 0x7) << 3 | (state.Z & 0x7) << 6;
                blockBB.Min = blockPos + info.MinBB[block];
                blockBB.Max = blockPos + info.MaxBB[block];
                if( !entityExtentBB.Intersects( blockBB ) ) continue;

                float tx = 0, ty = 0, tz = 0;
                CalcTime( ref entity.Velocity, ref entityBB, ref blockBB, out tx, out ty, out tz );
                if( tx > 1 || ty > 1 || tz > 1 )
                    Utils.LogDebug( "t > 1 in physics calculation.. this shouldn't have happened." );
                AABB finalBB = entityBB.Offset( entity.Velocity * new Vector3( tx, ty, tz ) );

                // if we have hit the bottom of a block, we need to change the axis we test first.
                if( !hitYMin ) {
                    if( finalBB.Min.Y + Adjustment >= blockBB.Max.Y )
                        ClipYMax( ref blockBB, ref entityBB, ref entityExtentBB, ref size );
                    else if( finalBB.Max.Y - Adjustment <= blockBB.Min.Y )
                        ClipYMin( ref blockBB, ref entityBB, ref entityExtentBB, ref size );
                    else if( finalBB.Min.X + Adjustment >= blockBB.Max.X )
                        ClipXMax( ref blockBB, ref entityBB, wasOn, finalBB, ref entityExtentBB, ref size );
                    else if( finalBB.Max.X - Adjustment <= blockBB.Min.X )
                        ClipXMin( ref blockBB, ref entityBB, wasOn, finalBB, ref entityExtentBB, ref size );
                    else if( finalBB.Min.Z + Adjustment >= blockBB.Max.Z )
                        ClipZMax( ref blockBB, ref entityBB, wasOn, finalBB, ref entityExtentBB, ref size );
                    else if( finalBB.Max.Z - Adjustment <= blockBB.Min.Z )
                        ClipZMin( ref blockBB, ref entityBB, wasOn, finalBB, ref entityExtentBB, ref size );
                    continue;
                }

                // if flying or falling, test the horizontal axes first.
                if( finalBB.Min.X + Adjustment >= blockBB.Max.X )
                    ClipXMax( ref blockBB, ref entityBB, wasOn, finalBB, ref entityExtentBB, ref size );
                else if( finalBB.Max.X - Adjustment <= blockBB.Min.X )
                    ClipXMin( ref blockBB, ref entityBB, wasOn, finalBB, ref entityExtentBB, ref size );
                else if( finalBB.Min.Z + Adjustment >= blockBB.Max.Z )
                    ClipZMax( ref blockBB, ref entityBB, wasOn, finalBB, ref entityExtentBB, ref size );
                else if( finalBB.Max.Z - Adjustment <= blockBB.Min.Z )
                    ClipZMin( ref blockBB, ref entityBB, wasOn, finalBB, ref entityExtentBB, ref size );
                else if( finalBB.Min.Y + Adjustment >= blockBB.Max.Y )
                    ClipYMax( ref blockBB, ref entityBB, ref entityExtentBB, ref size );
                else if( finalBB.Max.Y - Adjustment <= blockBB.Min.Y )
                    ClipYMin( ref blockBB, ref entityBB, ref entityExtentBB, ref size );
            }
        }

        bool CanSlideThrough( ref AABB adjFinalBB )
        {
            Vector3I bbMin = Vector3I.Floor( adjFinalBB.Min );
            Vector3I bbMax = Vector3I.Floor( adjFinalBB.Max );

            for( int y = bbMin.Y; y <= bbMax.Y; y++ )
                for( int z = bbMin.Z; z <= bbMax.Z; z++ )
                    for( int x = bbMin.X; x <= bbMax.X; x++ )
            {
                byte block = GetPhysicsBlockId( x, y, z );
                Vector3 min = new Vector3( x, y, z ) + info.MinBB[block];
                Vector3 max = new Vector3( x, y, z ) + info.MaxBB[block];

                AABB blockBB = new AABB( min, max );
                if( !blockBB.Intersects( adjFinalBB ) )
                    continue;
                if( info.Collide[GetPhysicsBlockId( x, y, z )] == CollideType.Solid )
                    return false;
            }
            return true;
        }

 public static void Update(AABB player)
 {
     if (player.Intersects(levelEnding))
     {
         loadLevel(nextLevel);
     }
 }

        // If liquid block above, leave height same
        // otherwise reduce water BB height by 0.5 blocks
        bool TouchesAnyLiquid( AABB bounds, byte block1, byte block2 )
        {
            Vector3I bbMin = Vector3I.Floor( bounds.Min );
            Vector3I bbMax = Vector3I.Floor( bounds.Max );
            int height = game.World.Height;

            // Order loops so that we minimise cache misses
            for( int y = bbMin.Y; y <= bbMax.Y; y++ )
                for( int z = bbMin.Z; z <= bbMax.Z; z++ )
                    for( int x = bbMin.X; x <= bbMax.X; x++ )
            {
                if( !game.World.IsValidPos( x, y, z ) ) continue;
                byte block = game.World.GetBlock( x, y, z );
                byte below = (y - 1) < 0 ? (byte)0 : game.World.GetBlock( x, y - 1, z );
                byte above = (y + 1) >= height ? (byte)0 : game.World.GetBlock( x, y + 1, z );

                // TODO: use recording to find right constants when I have more time
                Vector3 min = new Vector3( x, y, z ) + info.MinBB[block];
                Vector3 max = new Vector3( x, y, z ) + info.MaxBB[block];
                //if( game.BlockInfo.Collide[below] != CollideType.SwimThrough )
                //	min.Y += 4/16f;
                //if( game.BlockInfo.Collide[above] != CollideType.SwimThrough )
                //	max.Y -= 4/16f;

                AABB blockBB = new AABB( min, max );
                if( !blockBB.Intersects( bounds ) ) continue;
                if( block == block1 || block == block2 ) return true;
            }
            return false;
        }