跳至主要內容

18. 自定义搭建复杂建筑与导出

EVOCOSMOS2026/4/14大约 20 分钟

自定义搭建复杂建筑与导出

自定义建筑核心思路

搭建复杂的游戏建筑就像玩乐高——你不需要一块巨大的积木，而是用很多小积木块拼出想要的形状。这种方法叫做模块化搭建。

模块化搭建的核心思路：

  1. 拆分：把复杂建筑拆成小的、可重复使用的模块（墙壁、地板、窗户、门、楼梯等）
  2. 制作：为每个模块创建独立的场景文件
  3. 组合：在编辑器或代码中把模块像积木一样拼起来
  4. 参数化：通过参数控制生成不同大小、样式的建筑

这样做的好处：

  • 复用：一面墙的模块可以在几十栋建筑里反复使用
  • 高效：修改一个模块，所有使用该模块的建筑自动更新
  • 灵活：改变参数就能生成不同的建筑变体

模块化建筑组件设计

每种模块都是一个独立的 .tscn 场景文件。下面我们来设计四种基础模块。

墙壁模块

墙壁是最基本的建筑模块。一面标准墙壁通常高 3 米、宽 3 米、厚 0.2 米。

C#
// 墙壁模块场景脚本
using Godot;

public partial class WallModule : StaticBody3D
{
    [Export] public float Width { get; set; } = 3.0f;
    [Export] public float Height { get; set; } = 3.0f;
    [Export] public float Thickness { get; set; } = 0.2f;
    [Export] public Color WallColor { get; set; } = new Color(0.85f, 0.82f, 0.78f);

    private CSGBox3D _wallMesh;
    private CollisionShape3D _collision;

    public override void _Ready()
    {
        BuildWall();
    }

    public void BuildWall()
    {
        // 创建视觉效果
        _wallMesh = new CSGBox3D();
        _wallMesh.Name = "WallMesh";
        _wallMesh.Size = new Vector3(Width, Height, Thickness);

        var mat = new StandardMaterial3D();
        mat.AlbedoColor = WallColor;
        _wallMesh.Material = mat;

        AddChild(_wallMesh);

        // 创建碰撞
        _collision = new CollisionShape3D();
        _collision.Name = "WallCollision";
        var box = new BoxShape3D();
        box.Size = new Vector3(Width, Height, Thickness);
        _collision.Shape = box;

        AddChild(_collision);
    }

    /// <summary>设置墙壁大小</summary>
    public void SetSize(float width, float height)
    {
        Width = width;
        Height = height;

        if (_wallMesh != null)
        {
            _wallMesh.Size = new Vector3(Width, Height, Thickness);
        }
        if (_collision != null)
        {
            ((BoxShape3D)_collision.Shape).Size = new Vector3(Width, Height, Thickness);
        }
    }
}

地板模块

C#
// 地板模块场景脚本
using Godot;

public partial class FloorModule : StaticBody3D
{
    [Export] public float Width { get; set; } = 3.0f;
    [Export] public float Depth { get; set; } = 3.0f;
    [Export] public float Thickness { get; set; } = 0.15f;
    [Export] public Color FloorColor { get; set; } = new Color(0.6f, 0.5f, 0.4f);

    public override void _Ready()
    {
        // 创建地板视觉
        var mesh = new CSGBox3D();
        mesh.Name = "FloorMesh";
        mesh.Size = new Vector3(Width, Thickness, Depth);

        var mat = new StandardMaterial3D();
        mat.AlbedoColor = FloorColor;
        mesh.Material = mat;

        AddChild(mesh);

        // 创建碰撞
        var collision = new CollisionShape3D();
        var box = new BoxShape3D();
        box.Size = new Vector3(Width, Thickness, Depth);
        collision.Shape = box;
        AddChild(collision);
    }
}

屋顶模块

C#
// 屋顶模块场景脚本
using Godot;

public partial class RoofModule : StaticBody3D
{
    [Export] public float Width { get; set; } = 3.2f; // 稍微比墙壁宽一点，形成屋檐
    [Export] public float Depth { get; set; } = 3.2f;
    [Export] public float Thickness { get; set; } = 0.2f;
    [Export] public Color RoofColor { get; set; } = new Color(0.6f, 0.3f, 0.2f);

    public override void _Ready()
    {
        // 创建平屋顶
        var mesh = new CSGBox3D();
        mesh.Name = "RoofMesh";
        mesh.Size = new Vector3(Width, Thickness, Depth);

        var mat = new StandardMaterial3D();
        mat.AlbedoColor = RoofColor;
        mesh.Material = mat;

        AddChild(mesh);

        // 碰撞
        var collision = new CollisionShape3D();
        var box = new BoxShape3D();
        box.Size = new Vector3(Width, Thickness, Depth);
        collision.Shape = box;
        AddChild(collision);
    }
}

楼梯模块

C#
// 楼梯模块场景脚本
using Godot;

public partial class StairModule : StaticBody3D
{
    [Export] public float Width { get; set; } = 1.5f;
    [Export] public float StepHeight { get; set; } = 0.2f;
    [Export] public float StepDepth { get; set; } = 0.3f;
    [Export] public int StepCount { get; set; } = 10;

    public override void _Ready()
    {
        BuildStairs();
    }

    private void BuildStairs()
    {
        var mat = new StandardMaterial3D();
        mat.AlbedoColor = new Color(0.7f, 0.65f, 0.6f);

        for (int i = 0; i < StepCount; i++)
        {
            // 每一级台阶
            var step = new CSGBox3D();
            step.Name = $"Step_{i}";
            step.Size = new Vector3(Width, StepHeight, StepDepth);

            // 位置：每级向上和向前偏移
            float y = StepHeight / 2 + i * StepHeight;
            float z = -(StepDepth / 2 + i * StepDepth);
            step.Position = new Vector3(0, y, z);

            step.Material = mat;
            AddChild(step);
        }

        // 整体碰撞（用斜面简化）
        var collision = new CollisionShape3D();
        collision.Name = "StairCollision";
        collision.Position = new Vector3(0, StepCount * StepHeight / 2, -StepCount * StepDepth / 2);

        var box = new BoxShape3D();
        box.Size = new Vector3(Width, StepCount * StepHeight, StepCount * StepDepth);
        collision.Shape = box;
        collision.Rotation = new Vector3(
            Mathf.Atan2(StepHeight, StepDepth), 0, 0
        );
        AddChild(collision);
    }
}

用场景实例化组合复杂建筑

现在我们有了各种模块，可以像搭积木一样组合出一栋完整的建筑。

C#
// 用模块化组件组合一栋两层小楼
using Godot;

public partial class ModularBuilding : Node3D
{
    [Export] public PackedScene WallPrefab { get; set; }
    [Export] public PackedScene FloorPrefab { get; set; }
    [Export] public PackedScene RoofPrefab { get; set; }
    [Export] public PackedScene StairPrefab { get; set; }

    private const float ModuleSize = 3.0f;
    private const float WallHeight = 3.0f;

    public override void _Ready()
    {
        // 如果没有在编辑器中指定，从默认路径加载
        WallPrefab ??= GD.Load<PackedScene>("res://modules/wall_module.tscn");
        FloorPrefab ??= GD.Load<PackedScene>("res://modules/floor_module.tscn");
        RoofPrefab ??= GD.Load<PackedScene>("res://modules/roof_module.tscn");
        StairPrefab ??= GD.Load<PackedScene>("res://modules/stair_module.tscn");

        BuildHouse(2, 3); // 2层、3格宽
        GD.Print("模块化建筑搭建完成！");
    }

    /// <summary>
    /// 搭建一栋房屋
    /// </summary>
    /// <param name="floors">楼层数</param>
    /// <param name="widthModules">宽度方向的模块数量</param>
    public void BuildHouse(int floors, int widthModules)
    {
        float buildingWidth = widthModules * ModuleSize;
        float buildingDepth = ModuleSize;

        for (int floor = 0; floor < floors; floor++)
        {
            float baseY = floor * WallHeight;

            // === 地板 ===
            for (int w = 0; w < widthModules; w++)
            {
                var floorModule = FloorPrefab.Instantiate<Node3D>();
                floorModule.Position = new Vector3(
                    w * ModuleSize - buildingWidth / 2 + ModuleSize / 2,
                    baseY,
                    0
                );
                AddChild(floorModule);
            }

            // === 前墙 ===
            for (int w = 0; w < widthModules; w++)
            {
                var wall = WallPrefab.Instantiate<Node3D>();
                wall.Position = new Vector3(
                    w * ModuleSize - buildingWidth / 2 + ModuleSize / 2,
                    baseY + WallHeight / 2,
                    buildingDepth / 2
                );
                AddChild(wall);
            }

            // === 后墙 ===
            for (int w = 0; w < widthModules; w++)
            {
                var wall = WallPrefab.Instantiate<Node3D>();
                wall.Position = new Vector3(
                    w * ModuleSize - buildingWidth / 2 + ModuleSize / 2,
                    baseY + WallHeight / 2,
                    -buildingDepth / 2
                );
                AddChild(wall);
            }

            // === 左右墙 ===
            var leftWall = WallPrefab.Instantiate<Node3D>();
            leftWall.Position = new Vector3(
                -buildingWidth / 2,
                baseY + WallHeight / 2,
                0
            );
            leftWall.Rotation = new Vector3(0, Mathf.DegToRad(90), 0);
            AddChild(leftWall);

            var rightWall = WallPrefab.Instantiate<Node3D>();
            rightWall.Position = new Vector3(
                buildingWidth / 2,
                baseY + WallHeight / 2,
                0
            );
            rightWall.Rotation = new Vector3(0, Mathf.DegToRad(90), 0);
            AddChild(rightWall);

            // === 楼梯（从第二层开始） ===
            if (floor > 0)
            {
                var stair = StairPrefab.Instantiate<Node3D>();
                stair.Position = new Vector3(
                    buildingWidth / 2 - ModuleSize / 2,
                    (floor - 1) * WallHeight,
                    0
                );
                AddChild(stair);
            }
        }

        // === 屋顶 ===
        float roofY = floors * WallHeight;
        for (int w = 0; w < widthModules; w++)
        {
            var roof = RoofPrefab.Instantiate<Node3D>();
            roof.Position = new Vector3(
                w * ModuleSize - buildingWidth / 2 + ModuleSize / 2,
                roofY,
                0
            );
            AddChild(roof);
        }
    }
}

参数化建筑生成

参数化生成就是通过改变几个参数（比如楼层数、宽度），自动生成不同的建筑。就像工厂里调整机器参数就能生产不同规格的产品。

C#
// 参数化建筑生成器
using Godot;

[GlobalClass]
public partial class BuildingGenerator : Node3D
{
    [ExportGroup("Building Parameters")]
    [Export] public int Floors { get; set; } = 3;
    [Export] public int WidthModules { get; set; } = 4;
    [Export] public int DepthModules { get; set; } = 2;
    [Export] public float FloorHeight { get; set; } = 3.0f;
    [Export] public float ModuleSize { get; set; } = 3.0f;
    [Export] public bool HasStairs { get; set; } = true;
    [Export] public bool HasRoofOverhang { get; set; } = true;

    [ExportGroup("Module Prefabs")]
    [Export] public PackedScene WallPrefab { get; set; }
    [Export] public PackedScene FloorPrefab { get; set; }
    [Export] public PackedScene RoofPrefab { get; set; }
    [Export] public PackedScene StairPrefab { get; set; }

    [ExportGroup("Colors")]
    [Export] public Color WallColor { get; set; } = new Color(0.85f, 0.82f, 0.78f);
    [Export] public Color FloorColor { get; set; } = new Color(0.6f, 0.5f, 0.4f);
    [Export] public Color RoofColor { get; set; } = new Color(0.6f, 0.3f, 0.2f);

    /// <summary>重新生成建筑（在编辑器中调用）</summary>
    public void Regenerate()
    {
        // 清除旧的子节点
        foreach (var child in GetChildren())
        {
            child.QueueFree();
        }

        Generate();
    }

    private void Generate()
    {
        float halfWidth = WidthModules * ModuleSize / 2.0f;
        float halfDepth = DepthModules * ModuleSize / 2.0f;

        for (int floor = 0; floor < Floors; floor++)
        {
            float baseY = floor * FloorHeight;

            // 地板
            for (int x = 0; x < WidthModules; x++)
            {
                for (int z = 0; z < DepthModules; z++)
                {
                    PlaceModule(FloorPrefab, new Vector3(
                        x * ModuleSize - halfWidth + ModuleSize / 2,
                        baseY,
                        z * ModuleSize - halfDepth + ModuleSize / 2
                    ));
                }
            }

            // 四面墙
            for (int x = 0; x < WidthModules; x++)
            {
                // 前墙
                PlaceModule(WallPrefab, new Vector3(
                    x * ModuleSize - halfWidth + ModuleSize / 2,
                    baseY + FloorHeight / 2,
                    halfDepth
                ));
                // 后墙
                PlaceModule(WallPrefab, new Vector3(
                    x * ModuleSize - halfWidth + ModuleSize / 2,
                    baseY + FloorHeight / 2,
                    -halfDepth
                ));
            }

            for (int z = 0; z < DepthModules; z++)
            {
                // 左墙
                var leftWall = PlaceModule(WallPrefab, new Vector3(
                    -halfWidth,
                    baseY + FloorHeight / 2,
                    z * ModuleSize - halfDepth + ModuleSize / 2
                ));
                leftWall.Rotation = new Vector3(0, Mathf.DegToRad(90), 0);

                // 右墙
                var rightWall = PlaceModule(WallPrefab, new Vector3(
                    halfWidth,
                    baseY + FloorHeight / 2,
                    z * ModuleSize - halfDepth + ModuleSize / 2
                ));
                rightWall.Rotation = new Vector3(0, Mathf.DegToRad(90), 0);
            }

            // 楼梯
            if (HasStairs && floor > 0)
            {
                PlaceModule(StairPrefab, new Vector3(
                    halfWidth - ModuleSize,
                    (floor - 1) * FloorHeight,
                    0
                ));
            }
        }

        // 屋顶
        float roofY = Floors * FloorHeight;
        float roofOverhang = HasRoofOverhang ? 0.3f : 0;

        for (int x = 0; x < WidthModules; x++)
        {
            for (int z = 0; z < DepthModules; z++)
            {
                var roof = PlaceModule(RoofPrefab, new Vector3(
                    x * ModuleSize - halfWidth + ModuleSize / 2,
                    roofY,
                    z * ModuleSize - halfDepth + ModuleSize / 2
                ));
            }
        }

        GD.Print($"建筑生成完成：{Floors}层 x {WidthModules}格宽 x {DepthModules}格深");
    }

    private Node3D PlaceModule(PackedScene prefab, Vector3 position)
    {
        var instance = prefab.Instantiate<Node3D>();
        instance.Position = position;
        AddChild(instance);
        return instance;
    }
}

建筑放置系统

建筑放置系统允许玩家在游戏中选择模块、通过鼠标点击来放置建筑物。这在模拟建造类游戏中非常常见。

C#
// 建筑放置系统
using Godot;

public partial class BuildingPlacementSystem : Node3D
{
    [Export] public Camera3D Camera { get; set; }
    [Export] public float GridSize { get; set; } = 3.0f;
    [Export] public float RotationStep { get; set; } = 90.0f;

    private PackedScene[] _availableModules;
    private int _selectedModuleIndex;
    private Node3D _previewInstance;
    private float _currentRotation;
    private bool _isPlacing;

    public override void _Ready()
    {
        _availableModules = new PackedScene[]
        {
            GD.Load<PackedScene>("res://modules/wall_module.tscn"),
            GD.Load<PackedScene>("res://modules/floor_module.tscn"),
            GD.Load<PackedScene>("res://modules/roof_module.tscn"),
            GD.Load<PackedScene>("res://modules/stair_module.tscn")
        };

        _selectedModuleIndex = 0;
        _isPlacing = false;
    }

    public override void _Process(double delta)
    {
        if (!_isPlacing) return;

        // 鼠标位置 → 3D 世界位置
        Vector3? worldPos = GetMouseWorldPosition();
        if (worldPos == null) return;

        // 吸附到网格
        Vector3 snappedPos = SnapToGrid(worldPos.Value);

        // 更新预览位置
        if (_previewInstance != null)
        {
            _previewInstance.Position = snappedPos;
            _previewInstance.RotationDegrees = new Vector3(0, _currentRotation, 0);
        }
    }

    public override void _UnhandledInput(InputEvent @event)
    {
        if (!_isPlacing) return;

        // 左键放置
        if (@event is InputEventMouseButton mouseBtn && mouseBtn.Pressed)
        {
            if (mouseBtn.ButtonIndex == MouseButton.Left)
            {
                PlaceModule();
            }
            else if (mouseBtn.ButtonIndex == MouseButton.Right)
            {
                CancelPlacement();
            }
        }

        // R 键旋转
        if (@event.IsActionPressed("rotate_building"))
        {
            _currentRotation += RotationStep;
            if (_currentRotation >= 360) _currentRotation = 0;
            GD.Print($"旋转到 {_currentRotation} 度");
        }

        // 数字键切换模块
        for (int i = 0; i < _availableModules.Length; i++)
        {
            if (@event.IsActionPressed($"select_module_{i + 1}"))
            {
                SelectModule(i);
            }
        }

        // ESC 取消
        if (@event.IsActionPressed("ui_cancel"))
        {
            CancelPlacement();
        }
    }

    /// <summary>开始放置模式</summary>
    public void StartPlacement(int moduleIndex = 0)
    {
        _isPlacing = true;
        _currentRotation = 0;
        SelectModule(moduleIndex);
        GD.Print("进入建筑放置模式");
    }

    /// <summary>选择模块</summary>
    private void SelectModule(int index)
    {
        if (index < 0 || index >= _availableModules.Length) return;

        // 移除旧预览
        if (_previewInstance != null)
        {
            _previewInstance.QueueFree();
        }

        _selectedModuleIndex = index;

        // 创建新预览（半透明显示）
        _previewInstance = _availableModules[index].Instantiate<Node3D>();
        _previewInstance.Name = "Preview";

        // 设置半透明效果
        SetPreviewTransparency(_previewInstance, 0.5f);

        AddChild(_previewInstance);
        GD.Print($"选择模块 {index + 1}");
    }

    /// <summary>确认放置</summary>
    private void PlaceModule()
    {
        if (_previewInstance == null) return;

        // 创建正式的实例（替换半透明预览）
        Vector3 pos = _previewInstance.Position;
        float rot = _currentRotation;

        // 移除预览
        _previewInstance.QueueFree();

        // 创建正式模块
        var placed = _availableModules[_selectedModuleIndex].Instantiate<Node3D>();
        placed.Position = pos;
        placed.RotationDegrees = new Vector3(0, rot, 0);
        AddChild(placed);

        // 创建新的预览继续放置
        _previewInstance = _availableModules[_selectedModuleIndex].Instantiate<Node3D>();
        _previewInstance.Position = pos;
        SetPreviewTransparency(_previewInstance, 0.5f);
        AddChild(_previewInstance);

        GD.Print($"放置模块在 {pos}");
    }

    /// <summary>取消放置</summary>
    private void CancelPlacement()
    {
        _isPlacing = false;
        if (_previewInstance != null)
        {
            _previewInstance.QueueFree();
            _previewInstance = null;
        }
        GD.Print("退出建筑放置模式");
    }

    /// <summary>将鼠标位置转换为3D世界坐标</summary>
    private Vector3? GetMouseWorldPosition()
    {
        Vector2 mousePos = GetViewport().GetMousePosition();
        var rayLength = 1000;
        var from = Camera.ProjectRayOrigin(mousePos);
        var to = from + Camera.ProjectRayNormal(mousePos) * rayLength;

        var spaceState = GetWorld3D().DirectSpaceState;
        var query = PhysicsRayQueryParameters3D.Create(from, to);
        query.CollideWithAreas = false;
        query.CollideWithBodies = true;

        var result = spaceState.IntersectRay(query);
        if (result != null && result.ContainsKey("position"))
        {
            return (Vector3)result["position"];
        }

        return null;
    }

    /// <summary>吸附到网格</summary>
    private Vector3 SnapToGrid(Vector3 pos)
    {
        float x = Mathf.Snapped(pos.X, GridSize);
        float y = Mathf.Snapped(pos.Y, GridSize);
        float z = Mathf.Snapped(pos.Z, GridSize);
        return new Vector3(x, y, z);
    }

    /// <summary>设置预览节点的透明度</summary>
    private void SetPreviewTransparency(Node node, float alpha)
    {
        if (node is CSGBox3D csg)
        {
            var mat = csg.Material as StandardMaterial3D;
            if (mat == null)
            {
                mat = new StandardMaterial3D();
                csg.Material = mat;
            }
            mat.Transparency = BaseMaterial3D.TransparencyEnum.Alpha;
            mat.AlbedoColor = new Color(mat.AlbedoColor, alpha);
        }

        foreach (var child in node.GetChildren())
        {
            SetPreviewTransparency(child, alpha);
        }
    }
}

建筑碰撞自动生成

当建筑比较复杂时，手动添加碰撞很麻烦。可以通过代码自动生成碰撞。

C#
// 自动生成建筑碰撞
using Godot;

public static class CollisionAutoGenerator
{
    /// <summary>为建筑节点自动生成简化碰撞</summary>
    public static void GenerateCollisions(Node3D building)
    {
        var bounds = CalculateBounds(building);

        // 创建一个大的静态碰撞体包裹整个建筑
        var body = new StaticBody3D();
        body.Name = "AutoCollision";

        var shape = new CollisionShape3D();
        var box = new BoxShape3D();
        box.Size = bounds.Size;
        shape.Shape = box;
        shape.Position = bounds.Position + bounds.Size / 2;

        body.AddChild(shape);
        building.AddChild(body);

        GD.Print($"自动碰撞生成：大小 {box.Size}，位置 {shape.Position}");
    }

    /// <summary>计算节点的包围盒</summary>
    private static AABB CalculateBounds(Node3D node)
    {
        var bounds = new AABB();
        bool first = true;

        TraverseForBounds(node, ref bounds, ref first);

        return bounds;
    }

    private static void TraverseForBounds(Node node, ref AABB bounds, ref bool first)
    {
        if (node is CSGShape3D csg)
        {
            var aabb = csg.GetAabb();
            if (first)
            {
                bounds = aabb;
                first = false;
            }
            else
            {
                bounds = bounds.Merge(aabb);
            }
        }

        foreach (var child in node.GetChildren())
        {
            TraverseForBounds(child, ref bounds, ref first);
        }
    }
}

导出为独立场景

搭建好的建筑可以保存为独立的 .tscn 场景文件，方便在其他地方复用。

C#
// 场景保存工具
using Godot;

public static class SceneExportHelper
{
    /// <summary>将节点保存为场景文件</summary>
    public static bool SaveAsScene(Node node, string path)
    {
        var scene = new PackedScene();
        var result = scene.Pack(node);

        if (result == Error.Ok)
        {
            result = ResourceSaver.Save(scene, path);
            if (result == Error.Ok)
            {
                GD.Print($"场景已保存到：{path}");
                return true;
            }
        }

        GD.PrintErr($"保存场景失败：{result}");
        return false;
    }

    /// <summary>加载已保存的场景</summary>
    public static Node3D LoadScene(string path)
    {
        var scene = GD.Load<PackedScene>(path);
        if (scene != null)
        {
            return scene.Instantiate<Node3D>();
        }

        GD.PrintErr($"加载场景失败：{path}");
        return null;
    }
}

// 使用示例
// SceneExportHelper.SaveAsScene(buildingNode, "res://buildings/my_house.tscn");
// var house = SceneExportHelper.LoadScene("res://buildings/my_house.tscn");

建筑性能优化

当场景中有大量建筑时，性能可能会下降。以下是几种优化方法：

静态合批

将多个静态物体合并为一个，减少绘制调用（Draw Call）。

C#
// 静态合批优化
using Godot;

public partial class StaticBatchOptimizer : Node
{
    public override void _Ready()
    {
        OptimizeBuilding(GetParent() as Node3D);
    }

    /// <summary>优化建筑：合并同类材质的网格</summary>
    private void OptimizeBuilding(Node3D building)
    {
        // 将所有 CSG 替换为 MeshInstance3D 并合并
        var meshInstances = new Godot.Collections.Array<MeshInstance3D>();

        foreach (var child in building.GetChildren())
        {
            if (child is CSGBox3D csgBox)
            {
                // CSG 转换为 MeshInstance3D
                var meshInst = new MeshInstance3D();
                var boxMesh = new BoxMesh();
                boxMesh.Size = csgBox.Size;
                meshInst.Mesh = boxMesh;
                meshInst.Position = csgBox.Position;
                meshInst.Rotation = csgBox.Rotation;

                // 复制材质
                if (csgBox.Material != null)
                {
                    meshInst.MaterialOverride = csgBox.Material as Material;
                }

                meshInst.Name = csgBox.Name + "_Optimized";
                building.AddChild(meshInst);
                meshInstances.Add(meshInst);

                // 移除 CSG
                csgBox.QueueFree();
            }
        }

        GD.Print($"优化完成：{meshInstances.Count} 个网格已转换");
    }
}

LOD（Level of Detail）

LOD 就像看地图时的"缩放"——远处的建筑用低精度的模型，近处的用高精度的模型，节省性能。

C#
// 简单的 LOD 系统
using Godot;

public partial class SimpleLOD : Node3D
{
    [Export] public MeshInstance3D HighDetailMesh { get; set; }
    [Export] public MeshInstance3D LowDetailMesh { get; set; }
    [Export] public float LodDistance { get; set; } = 30.0f;

    private Camera3D _camera;

    public override void _Ready()
    {
        _camera = GetViewport().GetCamera3D();
    }

    public override void _Process(double delta)
    {
        if (_camera == null) return;

        float distance = GlobalPosition.DistanceTo(_camera.GlobalPosition);

        if (distance > LodDistance)
        {
            // 远处：低精度
            HighDetailMesh.Visible = false;
            LowDetailMesh.Visible = true;
        }
        else
        {
            // 近处：高精度
            HighDetailMesh.Visible = true;
            LowDetailMesh.Visible = false;
        }
    }
}

常见问题

模块之间有缝隙

问题：模块组合后，墙壁和地板之间出现可见的缝隙。

解决方案：

  1. 确保所有模块的尺寸是统一的（比如都是 3 米的倍数）
  2. 使用 SnapToGrid 函数确保位置精确对齐
  3. 模块之间稍微重叠 0.01 米来消除缝隙

放置时预览与实际位置不一致

问题：半透明预览和实际放置的位置有偏差。

解决方案：

  1. 确保预览实例和正式实例使用相同的场景
  2. 检查碰撞检测的偏移设置
  3. 确认网格吸附的大小与模块大小匹配

导出场景后碰撞丢失

问题：保存为 .tscn 文件后重新加载，碰撞不见了。

解决方案：

  1. 确保碰撞节点是场景的子节点（而非外部引用）
  2. 使用 ResourceSaver.Save 时检查返回值
  3. 在保存前调用 PackedScene.Pack 确认打包成功

建筑设计的最佳实践

  1. 保持模块尺寸统一：所有模块使用相同的基准尺寸（如 3x3x3 米），方便对齐
  2. 建立模块库：创建更多的模块变体（带窗户的墙、带门的墙、拐角墙等）
  3. 从简单开始：先用最基本的模块验证系统，再逐步增加复杂度
  4. 性能意识：每栋建筑的模块数量不要太多，CSG 适合原型，正式版应该用优化后的 Mesh

本章小结

本章我们学习了自定义搭建复杂建筑的完整流程：

知识点说明
模块化设计把复杂建筑拆分为可复用的小模块
墙壁/地板/屋顶/楼梯模块四种基础建筑模块的创建
场景实例化组合用模块像积木一样拼出完整建筑
参数化生成通过参数控制自动生成不同建筑
建筑放置系统鼠标选择+网格吸附+旋转放置
碰撞自动生成自动计算包围盒生成碰撞
场景导出保存为 .tscn 文件复用
静态合批CSG 转 Mesh 优化性能
LOD远近切换不同精度的模型

掌握了这些技术，你就能像真正的建筑师一样在游戏里搭建出各种复杂的建筑了。

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