跳至主要內容

14. 地形与建筑物搭建

EVOCOSMOS2026/4/14大约 12 分钟

地形与建筑物搭建

GridMap 节点介绍

上一章我们学会了用 CSG 搭建简单场景。现在让我们来学习更强大的工具——GridMap（网格地图）节点。

GridMap 就像一套巨大的乐高积木。你准备好各种积木块（墙壁、地板、屋顶等），然后在一个 3D 网格上把它们一块一块地摆放上去，就能快速搭建出城市、迷宫、建筑群等大型场景。

GridMap 的优势：

  • 像画画一样简单：在编辑器里点击网格就能放置积木
  • 自动对齐：所有积木都会对齐到网格上，不用担心摆放歪了
  • 高效管理：用一个节点就能管理成千上万个积木实例

MeshLibrary 资源——积木库

在用 GridMap 搭建世界之前，你需要先准备好"积木库"——也就是 MeshLibrary 资源。

MeshLibrary 就像一个积木收纳箱，里面装着各种可用的积木块。每个积木块就是一个 3D 模型（Mesh），可以附带碰撞形状和导航信息。

创建 MeshLibrary 的步骤：

  1. 准备好各种 3D 模型（可以从 Blender 导入，也可以用 CSG 制作）
  2. 创建一个新的 MeshLibrary 资源（右键资源面板 → 新建资源 → 搜索 MeshLibrary）
  3. 把模型添加到 MeshLibrary 中
  4. 为每个模型设置碰撞形状
C#
// 通过代码创建简单的 MeshLibrary
using Godot;

public partial class MeshLibraryBuilder : MeshLibrary
{
    public override void _Ready()
    {
        // 创建一个简单的方块积木
        var boxMesh = new BoxMesh();
        boxMesh.Size = new Vector3(2, 2, 2);

        // 创建材质
        var material = new StandardMaterial3D();
        material.AlbedoColor = new Color(0.7f, 0.7f, 0.7f);
        boxMesh.SurfaceSetMaterial(0, material);

        // 创建碰撞形状
        var shape = new BoxShape3D();
        shape.Size = new Vector3(2, 2, 2);

        // 将方块添加到 MeshLibrary 的第0个槽位
        var itemMesh = new ArrayMesh();
        // ... 在编辑器中操作更方便

        GD.Print("MeshLibrary 创建提示：建议在编辑器中可视化操作");
    }
}

编辑器操作更高效

虽然可以用代码创建 MeshLibrary，但强烈建议在编辑器中可视化操作。选中 GridMap 节点后，编辑器顶部会出现专门的网格绘制工具栏，你可以像画画一样点击放置积木。

用 GridMap 搭建简单城市街区

C#
// 用 GridMap 代码搭建简单城市街区
using Godot;

public partial class CityBuilder : GridMap
{
    // 积木类型的编号（对应 MeshLibrary 中的索引）
    private const int FloorTile = 0;
    private const int WallTile = 1;
    private const int DoorTile = 2;
    private const int RoofTile = 3;
    private const int RoadTile = 4;

    public override void _Ready()
    {
        // 加载 MeshLibrary
        MeshLibrary = GD.Load<MeshLibrary>("res://resources/city_mesh_library.tres");

        // 设置网格大小（每个格子2米）
        CellSize = new Vector3I(2, 2, 2);

        // 搭建地面
        BuildGround();

        // 搭建道路
        BuildRoads();

        // 搭建建筑
        BuildBuilding(0, 0, 2, 3, 2, 3); // x, z位置，宽、高、深
        BuildBuilding(8, 0, 2, 4, 2, 3);
        BuildBuilding(-8, 0, 2, 2, 2, 4);

        GD.Print("城市街区搭建完成！");
    }

    /// <summary>搭建地面</summary>
    private void BuildGround()
    {
        for (int x = -10; x <= 10; x++)
        {
            for (int z = -10; z <= 10; z++)
            {
                SetCellItem(new Vector3I(x, -1, z), FloorTile);
            }
        }
    }

    /// <summary>搭建道路</summary>
    private void BuildRoads()
    {
        // 东西向道路
        for (int x = -10; x <= 10; x++)
        {
            SetCellItem(new Vector3I(x, -1, 0), RoadTile);
            SetCellItem(new Vector3I(x, -1, 1), RoadTile);
        }
        // 南北向道路
        for (int z = -10; z <= 10; z++)
        {
            SetCellItem(new Vector3I(0, -1, z), RoadTile);
            SetCellItem(new Vector3I(1, -1, z), RoadTile);
        }
    }

    /// <summary>搭建一栋建筑</summary>
    private void BuildBuilding(int startX, int startZ, int width, int height, int floors, int depth)
    {
        for (int floor = 0; floor < floors; floor++)
        {
            int y = floor * height;

            // 四面墙壁
            for (int x = 0; x < width; x++)
            {
                for (int z = 0; z < depth; z++)
                {
                    // 只在最外圈放置墙壁
                    bool isEdge = (x == 0 || x == width - 1 || z == 0 || z == depth - 1);
                    bool isDoor = (floor == 0 && x == width / 2 && z == 0);

                    if (isEdge)
                    {
                        int tileType = isDoor ? DoorTile : WallTile;
                        SetCellItem(new Vector3I(startX + x, y, startZ + z), tileType);
                    }
                }
            }
        }

        // 屋顶
        int roofY = floors * height;
        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < depth; z++)
            {
                SetCellItem(new Vector3I(startX + x, roofY, startZ + z), RoofTile);
            }
        }
    }
}

CSG 组合模式搭建建筑

CSG 除了简单拼接外，还支持布尔运算——就像做雕塑一样，可以通过"加"和"减"来创造复杂形状。

CSG 支持 3 种布尔运算：

运算类型英文名效果比喻
合并Union把两个形状融为一体把两块橡皮泥捏在一起
减去Subtraction从一个形状中挖掉另一个用模具在饼干上压出形状
相交Intersection只保留两个形状重叠的部分两个交集部分的模具

CSG 建筑实例——带窗户和门洞的房屋

C#
// 用 CSG 布尔运算搭建一栋小房子
using Godot;

public partial class CSGHouse : Node3D
{
    // 房屋尺寸参数
    private const float Width = 6.0f;
    private const float Height = 3.5f;
    private const float Depth = 5.0f;
    private const float WallThickness = 0.25f;

    public override void _Ready()
    {
        BuildMainBody();
        BuildDoor();
        BuildWindows();
        BuildRoof();
        AddCollision();
        GD.Print("CSG 房屋搭建完成！");
    }

    /// <summary>搭建房屋主体（四面墙壁）</summary>
    private void BuildMainBody()
    {
        // 使用一个实心方块作为基础
        var mainBlock = new CSGBox3D();
        mainBlock.Name = "MainBody";
        mainBlock.Size = new Vector3(Width, Height, Depth);
        mainBlock.Position = new Vector3(0, Height / 2, 0);
        mainBlock.Operation = CSGShape3D.OperationEnum.Union;

        var mat = new StandardMaterial3D();
        mat.AlbedoColor = new Color(0.85f, 0.8f, 0.72f); // 米黄色墙壁
        mainBlock.Material = mat;

        AddChild(mainBlock);

        // 从内部挖空（让墙壁有厚度）
        var hollow = new CSGBox3D();
        hollow.Size = new Vector3(
            Width - WallThickness * 2,
            Height - WallThickness,
            Depth - WallThickness * 2
        );
        hollow.Position = new Vector3(0, Height / 2 + WallThickness / 2, 0);
        hollow.Operation = CSGShape3D.OperationEnum.Subtraction;
        mainBlock.AddChild(hollow);
    }

    /// <summary>挖出门洞</summary>
    private void BuildDoor()
    {
        var doorHole = new CSGBox3D();
        doorHole.Size = new Vector3(1.2f, 2.4f, WallThickness + 0.2f);
        doorHole.Position = new Vector3(-0.5f, 1.2f, Depth / 2);
        doorHole.Operation = CSGShape3D.OperationEnum.Subtraction;

        var body = GetNode<CSGBox3D>("MainBody");
        body.AddChild(doorHole);
    }

    /// <summary>挖出窗户</summary>
    private void BuildWindows()
    {
        var body = GetNode<CSGBox3D>("MainBody");

        // 左侧窗户
        var win1 = new CSGBox3D();
        win1.Size = new Vector3(WallThickness + 0.2f, 1.0f, 1.2f);
        win1.Position = new Vector3(-Width / 2, 2.0f, 0);
        win1.Operation = CSGShape3D.OperationEnum.Subtraction;
        body.AddChild(win1);

        // 右侧窗户
        var win2 = new CSGBox3D();
        win2.Size = new Vector3(WallThickness + 0.2f, 1.0f, 1.2f);
        win2.Position = new Vector3(Width / 2, 2.0f, 0);
        win2.Operation = CSGShape3D.OperationEnum.Subtraction;
        body.AddChild(win2);
    }

    /// <summary>搭建屋顶（用三角形棱柱）</summary>
    private void BuildRoof()
    {
        // 用 CSGCylinder3D 的低细分近似三角棱柱
        var roof = new CSGCylinder3D();
        roof.Name = "Roof";
        roof.Radius = Width / 2 + 0.3f;
        roof.Height = Depth + 0.6f;
        roof.Sides = 4; // 四边形截面
        roof.Position = new Vector3(0, Height + 1.0f, 0);
        roof.Rotation = new Vector3(0, Mathf.DegToRad(45), 0);

        var mat = new StandardMaterial3D();
        mat.AlbedoColor = new Color(0.6f, 0.3f, 0.2f); // 棕色屋顶
        roof.Material = mat;

        AddChild(roof);
    }

    /// <summary>添加碰撞</summary>
    private void AddCollision()
    {
        var body = new StaticBody3D();
        body.Name = "Collision";

        // 简单的盒子碰撞覆盖整个建筑
        var shape = new CollisionShape3D();
        var box = new BoxShape3D();
        box.Size = new Vector3(Width, Height, Depth);
        shape.Shape = box;
        shape.Position = new Vector3(0, Height / 2, 0);

        body.AddChild(shape);
        AddChild(body);
    }
}

程序化放置建筑物

当你需要在地图上放置大量建筑时，手动一个个放太慢了。可以用代码程序化地随机放置建筑物。

C#
// 程序化放置建筑物
using Godot;
using System.Collections.Generic;

public partial class ProceduralCityPlacer : Node3D
{
    [Export] public PackedScene[] BuildingPrefabs { get; set; }
    [Export] public int BuildingCount { get; set; } = 20;
    [Export] public float CityRadius { get; set; } = 50.0f;
    [Export] public float MinBuildingSpacing { get; set; } = 8.0f;

    private readonly List<Vector3> _placedPositions = new();
    private RandomNumberGenerator _rng;

    public override void _Ready()
    {
        _rng = new RandomNumberGenerator();
        PlaceBuildings();
    }

    private void PlaceBuildings()
    {
        int placed = 0;
        int attempts = 0;
        int maxAttempts = BuildingCount * 10;

        while (placed < BuildingCount && attempts < maxAttempts)
        {
            attempts++;

            // 在圆形区域内随机位置
            float angle = _rng.RandfRange(0, Mathf.Tau);
            float dist = _rng.RandfRange(10, CityRadius);
            Vector3 candidatePos = new Vector3(
                Mathf.Cos(angle) * dist,
                0,
                Mathf.Sin(angle) * dist
            );

            // 检查是否离已有建筑太近
            if (!IsPositionValid(candidatePos)) continue;

            // 随机选择建筑模板
            int prefabIndex = _rng.RandiRange(0, BuildingPrefabs.Length - 1);
            var building = BuildingPrefabs[prefabIndex].Instantiate<Node3D>();
            building.Position = candidatePos;

            // 随机旋转（只绕Y轴）
            building.Rotation = new Vector3(0, _rng.RandfRange(0, Mathf.Tau), 0);

            // 随机缩放（让建筑有大小差异）
            float scale = _rng.RandfRange(0.8f, 1.5f);
            building.Scale = Vector3.One * scale;

            AddChild(building);
            _placedPositions.Add(candidatePos);
            placed++;

            GD.Print($"建筑 {placed} 放置在 {candidatePos}");
        }

        GD.Print($"共放置 {placed} 栋建筑");
    }

    /// <summary>检查位置是否有效（不与其他建筑重叠）</summary>
    private bool IsPositionValid(Vector3 pos)
    {
        foreach (var placedPos in _placedPositions)
        {
            float distance = pos.DistanceTo(placedPos);
            if (distance < MinBuildingSpacing)
                return false;
        }
        return true;
    }
}

地形碰撞设置

有了地形和建筑的外观还不够，还需要设置碰撞，这样角色才不会掉到地里或穿墙而过。

C#
// 为地形添加碰撞
using Godot;

public partial class TerrainCollisionSetup : Node3D
{
    public override void _Ready()
    {
        SetupGroundCollision();
        SetupBuildingCollision();
    }

    /// <summary>为地面添加碰撞</summary>
    private void SetupGroundCollision()
    {
        // 创建一个无限大的地面碰撞
        var ground = new StaticBody3D();
        ground.Name = "Ground";

        var shape = new CollisionShape3D();
        var plane = new WorldBoundaryShape3D();
        shape.Shape = plane;

        ground.AddChild(shape);
        AddChild(ground);
        GD.Print("地面碰撞已添加");
    }

    /// <summary>为建筑物添加碰撞</summary>
    private void SetupBuildingCollision()
    {
        // 遍历所有建筑场景，为每个添加碰撞
        foreach (var child in GetChildren())
        {
            if (child is Node3D building && building.Name.ToString().StartsWith("Building"))
            {
                // 检查是否已经有碰撞体
                if (building.GetNodeOrNull<StaticBody3D>("Collision") == null)
                {
                    var body = new StaticBody3D();
                    body.Name = "Collision";

                    var colShape = new CollisionShape3D();
                    var box = new BoxShape3D();
                    box.Size = new Vector3(4, 6, 4); // 根据建筑大小调整
                    colShape.Shape = box;

                    body.AddChild(colShape);
                    building.AddChild(body);
                }
            }
        }
    }
}

常见问题

GridMap 积木不显示

问题：GridMap 节点里画了积木但看不到。

解决方案：

  1. 确认已正确加载 MeshLibrary 资源
  2. 检查 MeshLibrary 中的模型是否正确导入
  3. 确认摄像机位置能看到积木区域

CSG 布尔运算结果不对

问题：减法操作没有正确挖洞。

解决方案：

  1. 确保子 CSG 节点的 Operation 属性设为 Subtraction
  2. 减去的形状需要比目标区域的厚度更大（各方向多 0.1）
  3. 父子关系要正确：减去的 CSG 必须是被减 CSG 的子节点

碰撞体位置偏移

问题：角色在某些位置穿墙。

解决方案：

  1. 在编辑器中打开"可见碰撞形状"调试选项
  2. 检查 CollisionShape3D 的位置是否与视觉匹配
  3. 使用 Simple 碰撞检测模式确保精度

调试碰撞的方法

在 Godot 编辑器顶部菜单中，点击 Debug → Visible Collision Shapes，运行游戏时所有碰撞形状会用蓝色线框显示出来，方便你检查碰撞是否正确。

本章小结

本章我们学习了两种搭建大型场景的方法：

方法适用场景优点缺点
GridMap大型城市、迷宫、重复性地形快速绘制、自动对齐模型需要提前准备
CSG 布尔运算单体建筑、复杂形状原型不需要建模软件、灵活性能较差、不够精细
程序化放置大量建筑随机分布自动化、多样性需要编写逻辑代码

通过组合这些方法，你可以快速搭建出丰富的游戏世界。

最近更新:
贡献者: bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS