日本語版はここ

1. Door Placement Optimization Based on Flow Simulation

| |

Highlights

  • Developed a door placement optimization program in Python for floor plan optimization
  • Built a 2D navigation mesh (half-edge mesh, A* pathfinding, funnel algorithm) from scratch to simulate large-scale pedestrian flow
  • Designed a runtime optimization system using dynamic mesh split/merge operations and history tracking
  • Applied Data-Oriented Design (DOD) for high-speed processing

Demo

Case 1 Case 2

Results

Challenges

▶ Dynamic Mesh Processing

Relevant Code: u_geometry.py, g_mesh.py, s_door_system.py
Implemented two basic operations on the half–edge structure: Splitting and **merging edges**. Maintaining the structure and preserving original mesh info during updates was critical.
Use of Half–edge Structure:
  • Embedded optimization-friendly info in each edge (e.g., face, opposite vertex).
  • Assigned IDs to geometry for easier management and debug drawing.

History Functionality:
  • Enabled retention of original edges through sequences of updates.
  • Introduced history tracking to monitor geometry changes.
  • History stored initial edge and position (0–1) to manage updates.

Debug Draw 🔼 In debug mode, the door component dynamically moves clockwise along edges, while the mesh is **split/merged**, yet the initial geometry is preserved.

Noteworthy Features

▶ Navigation Mesh Implementation

Relevant Code: u_cdt.py, u_path_finding.py, g_navmesh.py
Implemented a custom navigation mesh from scratch to ensure flexibility. This involved mesh construction, A\* search, and the funnel algorithm—all with technical challenges. In particular, the funnel algorithm had many edge cases, making debugging difficult.
Implementation Steps:
  1. 2D Mesh Construction
    Used Python bindings for CDT (Constrained Delaunay Triangulation).
    Converted resulting mesh into a half-edge structure and annotated edges with types and flags to enable efficient subsequent optimization.
  2. A* Pathfinding
    Found shortest path through triangles (faces) on the mesh.
  3. Funnel Algorithm
    Used to calculate optimal movement path based on the triangle route.

▶ Runtime Optimization Algorithm

Relevant Code: u*loader.py, s*\*\*\*.py, o_optimizer.py, f_layout.py
This program aims to optimize floor layouts considering flow lines by simulating human movement from sampling points. The main goal is to optimize door positions by minimizing the average travel distance as a loss function.
Optimization Procedure:
  1. Load Initial Settings
    Door setup, room connection requirements, and optimization parameters are described in a TOML file and loaded.
    The Flood Algorithm detects enclosed regions on the mesh and auto-generates room connectivity.
  2. Optimization Process
    Initial door positions are auto-generated based on connection rules.
    Then, door positions are dynamically adjusted using the MCMC (Markov Chain Monte Carlo) algorithm.
  3. Finalize Optimal Configuration & Manage History
    Once optimal door positions are determined, the mesh data is updated to reflect the result.
    Changes are tracked using the history management system to maintain optimal layouts.

Presentation Slides

Slides for Master’s Thesis Presentation (Revised)

Libraries & References

2. XenonVK: Vulkan Learning Engine

| |

Highlights

  • Developed a C++ game engine to study Vulkan and engine architecture
  • Implemented a 3D Vulkan renderer using Blinn–Phong reflection model
  • Integrated CMake build system and GLSL shader compilation
  • Added OBJ mesh loading, game time system, and mouse/keyboard input

Challenges

▶ Learning Vulkan API and Game Engine Architecture

Topics: Vulkan API, game engine design, graphics programming
Vulkan is a low-level graphics API compared to OpenGL, requiring manual management of resources and synchronization. Initially, I referenced the “LittleVulkanEngine” video series to implement the basic pipeline and resource management framework.
  • Issues: Though I built a basic framework, the low-level complexity and code size overwhelmed me and slowed progress.
  • Approach:
    1. Paused renderer development and focused on game engine architecture.
    2. Built a simpler 2D version to test primitives and basic physics animations.
    3. Studied OpenGL rendering pipelines via LearnOpenGL tutorials.
    4. Later implemented a tick-based time manager and ECS (Entity Component System) with help from ChatGPT, blogs, and books.
  • Results:
    1. Understood the internal engine flow and organized architecture through repeated refactoring inspired by existing engines.
    2. Resumed Vulkan implementation while handling validation layer warnings.
    3. Now progressing with render pass stabilization and debug features like wireframe rendering.

Noteworthy Features

▶ CMake Build System & GitHub CI

Technologies: CMake, cross-platform development, GitHub Actions, Vulkan, GLSL
I use both Windows and macOS, so cross-platform compatibility was necessary. For this, I adopted **CMake** for its flexibility and extensibility.
  1. CMake Build System:
    • Builds from the same codebase across Windows / Linux / macOS
    • Integrated automatic GLSL shader compilation into CMake
    • GLM, GLFW, and other libraries are auto-fetched and built through CMake

    Special care was needed for Vulkan on macOS, requiring MoltenVK (Metal backend), which involved additional setup and debugging.
  2. CI Integration:
    • Built auto-build workflows with GitHub Actions
    • Builds triggered on push and pull requests
    • Unit tests are not yet implemented but planned for the future
These tools improve development reliability and reproducibility by design.

Demo

WireRenderPass
ワイヤーフレーム 複雑なシーン

References

3. Other Projects

A) Apollonian Gasket Generator (Rhinoceros/Python)

B) Interactive Voronoi Diagram_(Python/GLSL)_

C) Publication: [PG24] Free-form Floor Plan Design

This is the end of the portfolio. Thank you for your interest!