namespace Graphics {
    class Renderer {
        void draw();
    };
    
    class Shader {
        void compile();
    };
}

namespace Physics {
    class Vector {
        double x, y, z;
    };
    
    class Collision {
        bool detect();
    };
}

// C++17 이전
namespace MyCompany {
    namespace Graphics {
        namespace Rendering {
            class Engine { };
        }
    }
}

// C++17 이후 - 훨씬 깔끔!
namespace MyCompany::Graphics::Rendering {
    class Engine { };
}

namespace MyLib {
    inline namespace v2 {  // 기본 버전
        class Widget {
            void newFeature();
        };
    }
    
    namespace v1 {  // 레거시 버전
        class Widget {
            void oldFeature();
        };
    }
}

// 사용할 때
MyLib::Widget w;  // v2::Widget이 자동 선택됨!
MyLib::v1::Widget oldW;  // 명시적으로 v1 사용

// utils.cpp
namespace {  // 익명 네임스페이스
    const int BUFFER_SIZE = 1024;
    
    void internalHelper() {
        // 이 파일 내부에서만 사용
    }
}

void publicFunction() {
    internalHelper();  // OK!
    // 다른 파일에서는 접근 불가
}

// math_utils.ixx (모듈 인터페이스 파일)
export module math_utils;  // 모듈 선언

export namespace MathUtils {
    int add(int a, int b) {
        return a + b;
    }
    
    int multiply(int a, int b) {
        return a * b;
    }
}

// 내부 구현 (export 안 붙이면 비공개)
namespace {
    int internalHelper() {
        return 42;
    }
}

// main.cpp
import math_utils;  // #include 대신 import!

int main() {
    int result = MathUtils::add(10, 20);
    // internalHelper()는 접근 불가 - 캡슐화 완벽!
    return 0;
}

// graphics-rendering.ixx (파티션)
export module graphics:rendering;

export class Renderer {
    void draw();
};

// graphics-shaders.ixx (파티션)
export module graphics:shaders;

export class Shader {
    void compile();
};

// graphics.ixx (메인 모듈)
export module graphics;

export import :rendering;  // 파티션 재공개
export import :shaders;

// main.cpp
import graphics;  // 모든 파티션 자동 포함!

Renderer r;
Shader s;

module;  // 전역 모듈 프래그먼트 시작

// 여기서는 전통적인 #include 사용 가능
#include <vector>
#include <string>
#include "legacy_header.h"

export module my_module;  // 실제 모듈 시작

export class MyClass {
    std::vector<std::string> data;
    // legacy_header.h의 타입도 사용 가능
};

MyGameEngine/
├── Core/
│   ├── core.ixx              (export module engine.core)
│   ├── memory.ixx            (export module engine.core:memory)
│   └── threading.ixx         (export module engine.core:threading)
├── Graphics/
│   ├── graphics.ixx          (export module engine.graphics)
│   ├── rendering.ixx         (파티션)
│   ├── shaders.ixx           (파티션)
│   └── textures.ixx          (파티션)
├── Physics/
│   ├── physics.ixx           (export module engine.physics)
│   ├── collision.ixx         (파티션)
│   └── dynamics.ixx          (파티션)
└── Audio/
    ├── audio.ixx             (export module engine.audio)
    └── mixer.ixx             (파티션)

// graphics.ixx
export module engine.graphics;

export namespace Engine::Graphics {
    namespace Rendering {
        class Renderer { };
        class Pipeline { };
    }
    
    namespace Shaders {
        class ShaderProgram { };
        class ShaderCompiler { };
    }
    
    namespace Textures {
        class Texture2D { };
        class TextureCache { };
    }
}

// 계층적 의존성 (OK!)
Application Layer
    ↓ (의존)
Business Logic Layer
    ↓ (의존)
Data Access Layer
    ↓ (의존)
Core Utilities

// 각 레이어는 모듈로 구현
export module app.ui;
import app.business;  // 하위 레이어만 import

export module app.business;
import app.data;      // 하위 레이어만 import

export module app.data;
import app.core;      // 최하위 레이어

// common.ixx - 공통 인터페이스
export module engine.common;

export namespace Engine {
    class IRenderable {  // 인터페이스
        virtual void render() = 0;
    };
}

// graphics.ixx
export module engine.graphics;
import engine.common;

export namespace Engine::Graphics {
    class Renderer {
        void draw(IRenderable* obj);
    };
}

// physics.ixx
export module engine.physics;
import engine.common;

export namespace Engine::Physics {
    class PhysicsObject : public IRenderable {
        void render() override;
    };
}

# CMakeLists.txt
cmake_minimum_required(VERSION 3.28)  # 모듈 지원 버전
project(MyProject CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 모듈 지원 활성화
set(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API "aa1f7df0-828a-4fcd-9afc-2dc80491aca7")
set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP ON)

# 모듈 라이브러리
add_library(graphics)
target_sources(graphics
    PUBLIC
        FILE_SET CXX_MODULES FILES
        graphics.ixx
        rendering.ixx
        shaders.ixx
)

# 실행 파일
add_executable(game main.cpp)
target_link_libraries(game PRIVATE graphics)

# Clang (libc++ 사용)
clang++ -std=c++20 -stdlib=libc++ -fmodules \
    --precompile graphics.ixx -o graphics.pcm
clang++ -std=c++20 -stdlib=libc++ -fmodules \
    -fmodule-file=graphics.pcm main.cpp graphics.pcm -o game

# GCC (아직 부분 지원)
g++ -std=c++20 -fmodules-ts \
    -xc++-system-header iostream
g++ -std=c++20 -fmodules-ts \
    graphics.ixx main.cpp -o game

전통적 헤더 방식:
- 풀 빌드: 8분 30초
- 증분 빌드: 45초
- 헤더 변경 시: 3분 20초

모듈 방식:
- 풀 빌드: 3분 10초 (63% 개선! 🎉)
- 증분 빌드: 12초 (73% 개선!)
- 모듈 변경 시: 25초 (87% 개선!)

→ 특히 증분 빌드에서 압도적 차이!

export module database;

// 1. 명확한 네임스페이스
export namespace DB {
    // 2. 추상 인터페이스 제공
    class IConnection {
    public:
        virtual ~IConnection() = default;
        virtual bool connect(const std::string& url) = 0;
        virtual void disconnect() = 0;
    };
    
    // 3. 팩토리 함수로 구현 숨기기
    std::unique_ptr<IConnection> createConnection(
        const std::string& type
    );
    
    // 4. 필요한 타입만 공개
    enum class ConnectionType {
        MySQL, PostgreSQL, SQLite
    };
    
    // 5. 유틸리티 함수
    std::string escapeString(const std::string& str);
}

// 내부 구현은 export 안 함 (캡슐화!)
namespace DB::Internal {
    class MySQLConnection : public IConnection {
        // 구현 세부사항
    };
}

// 네임스페이스 별칭
namespace GFX = MyCompany::GameEngine::Graphics::Rendering;

GFX::Renderer renderer;  // 훨씬 간결!

// using 선언 (특정 타입만)
using MyCompany::GameEngine::Physics::Vector3D;

Vector3D position;  // 네임스페이스 생략

// using 지시문 (로컬 스코프에서만!)
void render() {
    using namespace MyCompany::GameEngine::Graphics;
    // 이 함수 안에서만 적용
    Renderer r;
    Shader s;
}

// 복잡한 템플릿 타입 별칭
namespace Utils {
    template<typename T>
    using SharedPtr = std::shared_ptr<T>;
    
    template<typename K, typename V>
    using HashMap = std::unordered_map<K, V>;
}

Utils::SharedPtr<Player> player;
Utils::HashMap<int, std::string> idToName;

// 표준 라이브러리 헤더를 모듈처럼 import
import <iostream>;
import <vector>;
import <string>;

// 전통적인 #include보다 빠름!
int main() {
    std::vector<std::string> names;
    std::cout << "Hello Module!\n";
}

AwesomeEngine/
├── Core/
│   ├── core.ixx                    (메인 모듈)
│   ├── core-memory.ixx             (메모리 관리)
│   ├── core-threading.ixx          (멀티스레딩)
│   └── core-math.ixx               (수학 라이브러리)
├── Platform/
│   ├── platform.ixx                (플랫폼 추상화)
│   ├── platform-windows.ixx        (Windows 구현)
│   └── platform-linux.ixx          (Linux 구현)
├── Graphics/
│   ├── graphics.ixx                (그래픽스 메인)
│   ├── graphics-renderer.ixx       (렌더러)
│   ├── graphics-shader.ixx         (셰이더)
│   └── graphics-texture.ixx        (텍스처)
├── Physics/
│   ├── physics.ixx                 (물리 엔진)
│   ├── physics-collision.ixx       (충돌 감지)
│   └── physics-dynamics.ixx        (동역학)
└── Game/
    ├── game.ixx                    (게임 로직)
    └── game-entities.ixx           (엔티티 시스템)

// core-math.ixx
export module engine.core:math;

export namespace Engine::Core::Math {
    struct Vector3 {
        float x, y, z;
        
        Vector3 operator+(const Vector3& other) const {
            return {x + other.x, y + other.y, z + other.z};
        }
        
        float length() const {
            return std::sqrt(x*x + y*y + z*z);
        }
    };
    
    struct Matrix4x4 {
        float data[16];
        
        Matrix4x4 operator*(const Matrix4x4& other) const;
        Vector3 transform(const Vector3& v) const;
    };
    
    // 유틸리티 함수들
    float lerp(float a, float b, float t);
    Vector3 normalize(const Vector3& v);
}

// core.ixx (메인 모듈)
export module engine.core;

export import :math;
export import :memory;
export import :threading;

export namespace Engine::Core {
    // 엔진 초기화
    class Engine {
    public:
        static Engine& instance();
        
        bool initialize();
        void shutdown();
        void update(float deltaTime);
        
    private:
        Engine() = default;
        bool isInitialized = false;
    };
}

// graphics-renderer.ixx
export module engine.graphics:renderer;

import engine.core;

export namespace Engine::Graphics {
    class Renderer {
    public:
        virtual ~Renderer() = default;
        
        virtual bool initialize() = 0;
        virtual void beginFrame() = 0;
        virtual void endFrame() = 0;
        virtual void draw(const Mesh& mesh) = 0;
    };
    
    // 팩토리 패턴
    enum class RendererAPI {
        OpenGL, Vulkan, DirectX12
    };
    
    std::unique_ptr<Renderer> createRenderer(
        RendererAPI api
    );
}

// 내부 구현 (export 안 함)
namespace Engine::Graphics::Internal {
    class OpenGLRenderer : public Renderer {
        // OpenGL 구현
    };
    
    class VulkanRenderer : public Renderer {
        // Vulkan 구현
    };
}

// physics.ixx
export module engine.physics;

import engine.core;

export namespace Engine::Physics {
    class RigidBody {
    public:
        void applyForce(const Core::Math::Vector3& force);
        void applyImpulse(const Core::Math::Vector3& impulse);
        
        Core::Math::Vector3 getVelocity() const;
        void setVelocity(const Core::Math::Vector3& v);
        
    private:
        Core::Math::Vector3 velocity{0, 0, 0};
        Core::Math::Vector3 acceleration{0, 0, 0};
        float mass = 1.0f;
    };
    
    class PhysicsWorld {
    public:
        void addRigidBody(RigidBody* body);
        void removeRigidBody(RigidBody* body);
        
        void simulate(float deltaTime);
        
    private:
        std::vector<RigidBody*> bodies;
        Core::Math::Vector3 gravity{0, -9.81f, 0};
    };
}

// game.ixx
export module engine.game;

import engine.core;
import engine.graphics;
import engine.physics;

export namespace Engine::Game {
    class GameObject {
    public:
        virtual ~GameObject() = default;
        
        virtual void update(float deltaTime) = 0;
        virtual void render(Graphics::Renderer& renderer) = 0;
        
        Core::Math::Vector3 position{0, 0, 0};
        Core::Math::Vector3 rotation{0, 0, 0};
        Core::Math::Vector3 scale{1, 1, 1};
    };
    
    class Player : public GameObject {
    public:
        void update(float deltaTime) override {
            // 플레이어 로직
            handleInput();
            updatePhysics(deltaTime);
        }
        
        void render(Graphics::Renderer& renderer) override {
            // 플레이어 렌더링
        }
        
    private:
        void handleInput();
        void updatePhysics(float deltaTime);
        
        Physics::RigidBody* rigidBody = nullptr;
        float moveSpeed = 5.0f;
    };
    
    class GameWorld {
    public:
        void addGameObject(std::unique_ptr<GameObject> obj);
        void update(float deltaTime);
        void render(Graphics::Renderer& renderer);
        
    private:
        std::vector<std::unique_ptr<GameObject>> objects;
        Physics::PhysicsWorld physicsWorld;
    };
}

// main.cpp
import engine.core;
import engine.graphics;
import engine.physics;
import engine.game;

import <iostream>;
import <memory>;

int main() {
    using namespace Engine;
    
    // 엔진 초기화
    auto& engine = Core::Engine::instance();
    if (!engine.initialize()) {
        std::cerr << "Failed to initialize engine!\n";
        return -1;
    }
    
    // 렌더러 생성
    auto renderer = Graphics::createRenderer(
        Graphics::RendererAPI::Vulkan
    );
    renderer->initialize();
    
    // 게임 월드 생성
    Game::GameWorld world;
    
    // 플레이어 추가
    auto player = std::make_unique<Game::Player>();
    player->position = {0, 0, 0};
    world.addGameObject(std::move(player));
    
    // 게임 루프
    float deltaTime = 0.016f;  // 60 FPS
    bool running = true;
    
    while (running) {
        renderer->beginFrame();
        
        world.update(deltaTime);
        world.render(*renderer);
        
        renderer->endFrame();
        
        engine.update(deltaTime);
    }
    
    engine.shutdown();
    return 0;
}

// C++23 이후
import std;  // 모든 표준 라이브러리!

int main() {
    std::vector<int> v = {1, 2, 3};
    std::cout << "Hello!\n";
    // iostream, vector 등 모두 사용 가능
}