C# MySlimBlock.GetWorldBoundingBox方法代码示例

        public static bool IsInVoxels(MySlimBlock block,bool checkForPhysics = true)
        {
            if (block.CubeGrid.Physics == null && checkForPhysics)
               return false;

            if (MyPerGameSettings.Destruction && block.CubeGrid.GridSizeEnum == MyCubeSize.Large)
                return block.CubeGrid.Physics.Shape.BlocksConnectedToWorld.Contains(block.Position);

            BoundingBoxD blockWorldAABB;
            block.GetWorldBoundingBox(out blockWorldAABB);

            m_tmpVoxelList.Clear();
            MyGamePruningStructure.GetAllVoxelMapsInBox(ref blockWorldAABB, m_tmpVoxelList);
            var cubeSize = block.CubeGrid.GridSize;
            BoundingBoxD localAAABB = new BoundingBoxD(cubeSize * ((Vector3D)block.Min - 0.5), cubeSize * ((Vector3D)block.Max + 0.5));
            var gridWorldMatrix = block.CubeGrid.WorldMatrix;
            foreach(var map in m_tmpVoxelList)
            {
                if (map.IsAnyAabbCornerInside(ref gridWorldMatrix, localAAABB))
                {
                    return true;
                }
            }
            return false;
        }

        public static bool IsInVoxels(MySlimBlock block,bool checkForPhysics = true)
        {
            if (block.CubeGrid.Physics == null && checkForPhysics)
               return false;

            if (MyPerGameSettings.Destruction && block.CubeGrid.GridSizeEnum == Common.ObjectBuilders.MyCubeSize.Large)
                return block.CubeGrid.Physics.Shape.BlocksConnectedToWorld.Contains(block.Position);

            BoundingBoxD blockWorldAABB;
            block.GetWorldBoundingBox(out blockWorldAABB);

            var voxelMap = MySession.Static.VoxelMaps.GetVoxelMapWhoseBoundingBoxIntersectsBox(ref blockWorldAABB, null);
            if (voxelMap == null)
                return false;

            var cubeSize = block.CubeGrid.GridSize;
            BoundingBoxD localAAABB = new BoundingBoxD(cubeSize * ((Vector3D)block.Min - 0.5), cubeSize * ((Vector3D)block.Max + 0.5));
            var gridWorldMatrix = block.CubeGrid.WorldMatrix;

            return voxelMap.IsAnyAabbCornerInside(ref gridWorldMatrix, localAAABB);
        }

        private MyCubeGrid DetectTouchingGrid(MySlimBlock block)
        {
            if (MyCubeBuilder.Static.DynamicMode)
                return null;

            if (block == null)
                return null;

            if (block.FatBlock is MyCompoundCubeBlock)
            {
                foreach (var blockInCompound in (block.FatBlock as MyCompoundCubeBlock).GetBlocks())
                {
                    MyCubeGrid touchingGrid = DetectTouchingGrid(blockInCompound);
                    if (touchingGrid != null)
                        return touchingGrid;
                }

                return null;
            }

            ProfilerShort.Begin("MultiBlockClipboard: DetectMerge");

            float gridSize = block.CubeGrid.GridSize;
            BoundingBoxD aabb;
            block.GetWorldBoundingBox(out aabb);
            // Inflate by half cube, so it will intersect for sure when there's anything
            aabb.Inflate(gridSize / 2);

            m_tmpNearEntities.Clear();
            MyEntities.GetElementsInBox(ref aabb, m_tmpNearEntities);

            var mountPoints = block.BlockDefinition.GetBuildProgressModelMountPoints(block.BuildLevelRatio);

            try
            {
                for (int i = 0; i < m_tmpNearEntities.Count; i++)
                {
                    var grid = m_tmpNearEntities[i] as MyCubeGrid;
                    if (grid != null && grid != block.CubeGrid && grid.Physics != null && grid.Physics.Enabled && grid.IsStatic && grid.GridSizeEnum == block.CubeGrid.GridSizeEnum)
                    {
                        Vector3I gridOffset = grid.WorldToGridInteger(m_pastePosition);
                        if (!grid.CanMergeCubes(block.CubeGrid, gridOffset))
                            continue;

                        MatrixI transform = grid.CalculateMergeTransform(block.CubeGrid, gridOffset);
                        Base6Directions.Direction forward = transform.GetDirection(block.Orientation.Forward);
                        Base6Directions.Direction up = transform.GetDirection(block.Orientation.Up);
                        MyBlockOrientation newOrientation = new MyBlockOrientation(forward, up);
                        Quaternion newRotation;
                        newOrientation.GetQuaternion(out newRotation);
                        Vector3I newPosition = Vector3I.Transform(block.Position, transform);

                        if (!MyCubeGrid.CheckConnectivity(grid, block.BlockDefinition, mountPoints, ref newRotation, ref newPosition))
                            continue;

                        return grid;
                    }
                }
            }
            finally
            {
                m_tmpNearEntities.Clear();
                ProfilerShort.End();
            }

            return null;
        }

        private void MyCubeGridsOnBlockBuilt(MyCubeGrid myCubeGrid, MySlimBlock mySlimBlock)
        {
            if (mySlimBlock == null || !myCubeGrid.IsStatic) return;

            // Avoid multiple queues for compound block additions.
            var compound = myCubeGrid.GetCubeBlock(mySlimBlock.Min).FatBlock as MyCompoundCubeBlock;
            if (compound != null && mySlimBlock.FatBlock != compound) return;

            BoundingBoxD blockAabb;
            mySlimBlock.GetWorldBoundingBox(out blockAabb, true);
            m_cubeBlocksPending.Add(myCubeGrid, blockAabb);

            //Debug.Print("CubeGrid {0}: Block added at {1}.", myCubeGrid, mySlimBlock.Position);
        }

        private void grid_OnBlockRemoved(MySlimBlock block)
        {
            bool ignore = true;
            bool noEntry = false;
            bool meshFound = false;

            var existingBlock = m_grid.GetCubeBlock(block.Position);
            var compound = existingBlock == null ? null : existingBlock.FatBlock as MyCompoundCubeBlock;

            if (!(block.FatBlock is MyCompoundCubeBlock) && block.BlockDefinition.NavigationDefinition == null) return;

            // Ignore blocks without navigation info (i.e. decorations and such)
            if (compound == null)
            {
                Debug.Assert(existingBlock == null, "Removed a block from position, but there still is another block and it's not a compound!");

                ignore = false;
                if (existingBlock != null)
                {
                    if (block.BlockDefinition.NavigationDefinition.NoEntry)
                        noEntry = true;
                    else
                        meshFound = true;
                }
            }
            else
            {
                var blocks = compound.GetBlocks();

                if (blocks.Count != 0)
                {
                    foreach (var subBlock in blocks)
                    {
                        if (subBlock.BlockDefinition.NavigationDefinition == null) continue;
                        if (subBlock.BlockDefinition.NavigationDefinition.NoEntry || meshFound)
                        {
                            ignore = false;
                            noEntry = true;
                            break;
                        }
                        else
                        {
                            ignore = false;
                            meshFound = true;
                            block = subBlock;
                        }
                    }
                }
            }

            BoundingBoxD bbox;
            block.GetWorldBoundingBox(out bbox);
            bbox.Inflate(5.1f);

            //m_coordinator.RemoveGridNavmeshLinks(m_grid);
            m_coordinator.InvalidateVoxelsBBox(ref bbox);

            MarkBlockChanged(block);
            MyAIComponent.Static.Pathfinding.GridPathfinding.MarkHighLevelDirty();

            if (ignore)
            {
                RemoveBlock(block.Min, block.Max, eraseCubeSet: true);
                FixBlockFaces(block);
            }
            else if (noEntry)
            {
                RemoveBlock(block.Min, block.Max, eraseCubeSet: false);
            }
            else if (meshFound)
            {
                RemoveBlock(block.Min, block.Max, eraseCubeSet: true);
                AddBlock(block);
            }
            else
            {
                if (m_cubeSet.Contains(block.Position))
                {
                    RemoveBlock(block.Min, block.Max, eraseCubeSet: true);
                    FixBlockFaces(block);
                }
            }
        }

//.........这里部分代码省略.........
            }
            else
            {
                if (block.BlockDefinition.NavigationDefinition != null)
                {
                    if (block.BlockDefinition.NavigationDefinition.NoEntry)
                    {
                        meshFound = false;
                        noEntry = true;
                    }
                    else
                    {
                        meshFound = true;
                    }
                }
            }

            // Ignore compounds with blocks without navigation info
            if (!noEntry && !meshFound) return;

            if (noEntry)
            {
                if (m_cubeSet.Contains(block.Position))
                    RemoveBlock(block.Min, block.Max, true);

                Vector3I pos = default(Vector3I);
                for (pos.X = block.Min.X; pos.X <= block.Max.X; ++pos.X)
                {
                    for (pos.Y = block.Min.Y; pos.Y <= block.Max.Y; ++pos.Y)
                    {
                        pos.Z = block.Min.Z - 1;
                        if (m_cubeSet.Contains(ref pos))
                        {
                            EraseFaceTriangles(pos, Base6Directions.Direction.Backward);
                        }

                        pos.Z = block.Max.Z + 1;
                        if (m_cubeSet.Contains(ref pos))
                        {
                            EraseFaceTriangles(pos, Base6Directions.Direction.Forward);
                        }
                    }

                    for (pos.Z = block.Min.Z; pos.Z <= block.Max.Z; ++pos.Z)
                    {
                        pos.Y = block.Min.Y - 1;
                        if (m_cubeSet.Contains(ref pos))
                        {
                            EraseFaceTriangles(pos, Base6Directions.Direction.Up);
                        }

                        pos.Y = block.Max.Y + 1;
                        if (m_cubeSet.Contains(ref pos))
                        {
                            EraseFaceTriangles(pos, Base6Directions.Direction.Down);
                        }
                    }
                }

                for (pos.Y = block.Min.Y; pos.Y <= block.Max.Y; ++pos.Y)
                {
                    for (pos.Z = block.Min.Z; pos.Z <= block.Max.Z; ++pos.Z)
                    {
                        pos.X = block.Min.X - 1;
                        if (m_cubeSet.Contains(ref pos))
                        {
                            EraseFaceTriangles(pos, Base6Directions.Direction.Right);
                        }

                        pos.X = block.Max.X + 1;
                        if (m_cubeSet.Contains(ref pos))
                        {
                            EraseFaceTriangles(pos, Base6Directions.Direction.Left);
                        }
                    }
                }

                pos = block.Min;
                for (var it = new Vector3I.RangeIterator(ref pos, ref block.Max); it.IsValid(); it.GetNext(out pos))
                {
                    m_cubeSet.Add(pos);
                }
            }
            else
            {
                if (m_cubeSet.Contains(block.Position))
                {
                    RemoveBlock(block.Min, block.Max, eraseCubeSet: true);
                }
                AddBlock(block);
            }

            BoundingBoxD bbox;
            block.GetWorldBoundingBox(out bbox);
            bbox.Inflate(5.1f);

            m_coordinator.InvalidateVoxelsBBox(ref bbox);

            MarkBlockChanged(block);
        }