Home Designer Suite

Installation

Before opening the demo scenes, install the following packages via the Unity Package Manager (Window > Package Manager).

Input System

Required for all keyboard and touch input handling. Install from the Unity Registry:

1. In the Package Manager, select Unity Registry from the dropdown.
2. Search for Input System.
3. Click Install. Unity will prompt you to enable the new input system and restart the editor — accept.

UniGLTF (required for GLB export)

Install from a Git URL:

1. In the Package Manager, click + > Add package from git URL.
2. Enter the following URL and click Add:

Git URL
https://github.com/vrm-c/UniVRM.git?path=/Packages/UniGLTF#v0.131.0

Quick Start

Try the Demo Scene

The fastest way to get started is to open and run the Demo_Editor scene:

Assets/Exoa/HomeDesigner/Scenes/Demo_Editor.unity

This scene contains a fully working interior design editor — you can draw floor plans, paint materials, place furniture, and switch to 3D preview mode right away. It is designed to be used as-is or as a starting point: feel free to extend it, rearrange the UI, or strip it down to only the features your application needs.

License Activation

A valid license is required to use Home Designer in the Unity Editor. To activate:

1. In the Unity menu bar, go to Exoa > Home Designer > Licensing.
2. Enter your email address and your invoice number (from your Asset Store purchase).
3. Click Activate.

Home Designer Settings

The settings panel is the central place to configure the plugin. Open it from the menu bar:

Tools > Exoa > Home Designer > Settings

The panel is a direct reflection of the HomeDesignerSettings ScriptableObject. Any change made in the panel is immediately written to that asset. It exposes all the settings needed to set up the plugin, including the database of furniture modules and materials available to the designer at runtime.

GLB Export Setup (Optional)

When a project is saved, Home Designer can export the building as a GLB 3D model alongside the JSON file. This requires the UniGLTF package and a scripting define symbol.

Step 1 — Install UniGLTF

Open Window > Package Manager, click + > Add package from git URL, and enter the UniGLTF package URL. Alternatively install it via the .unitypackage file if you have a local copy.

Step 2 — Add the Scripting Define Symbol

Open Edit > Project Settings > Player > Other Settings > Scripting Define Symbols and add:

Symbol
UNIGLTF

Apply the change. Unity will recompile; GLB export code will be compiled in after that.

Step 3 — Enable in HomeDesignerSettings

Select the HomeDesignerSettings asset in the Project window. The Export GLB On Save option is now available — enable it to export a .glb file every time a project is saved.

Render Pipeline Setup

Home Designer supports Built-in RP, URP, and HDRP. After importing the package or switching your project's render pipeline, you must convert the built-in materials to match your pipeline using the Render Pipeline Switcher.

Using the Render Pipeline Switcher

Open it from the menu bar: Tools > Exoa > Render Pipeline Switcher.

The tool batch-converts all Home Designer materials (walls, floors, grid, doors, windows, ghost, exterior) to the shaders expected by your current render pipeline. Select your target pipeline in the popup and click Convert.

Per-Pipeline Notes

Project Structure

Key Scenes

Requirements

License System

The license check runs editor-only — it is stripped from all builds. Activating the license via Exoa > Home Designer > Licensing stores a token locally; no check occurs at runtime in a shipped application. If the license DLLs are deleted, a compile error is raised by design to prevent accidental removal.

Scripting Define Symbols

Integration Guide

If you want to embed Home Designer into an existing scene or project rather than building on top of Demo_Editor, follow the steps below.

Minimum Required Components

Your scene needs the following GameObjects at minimum to run the plugin:

The easiest approach is to copy the root GameObject hierarchy from Demo_Editor and strip out only the UI you don't need.

Adding the UI (Optional)

If you want the built-in editor panels, add the main UI Canvas prefab to your scene and ensure BuildingUIBridge is present. After creating a building call:

C#
BuildingUIBridge.Instance.ConnectBuildingToUI(building);

This wires every floor, room, and opening in the building to the corresponding UI list items. If you create buildings programmatically after scene load, call this once after building.Build().

Running Without UI

Omit the Canvas and BuildingUIBridge entirely. Use HeadlessBuildingAPI to create geometry and HomeDesignerEvents to react to state changes. This is the pattern used by Demo_API.

Multiple Buildings

Each BuildingController is an independent GameObject. Instantiate as many as you need. The system tracks one active building — switch with:

C#
BuildingController.SetCurrentBuilding(mySecondBuilding);

Editor operations (draw, paint, furnish) always apply to the active building.

Architecture Overview

Home Designer follows an event-driven architecture with a centralized state machine. The core pattern: user input → events → controllers → procedural generation → 3D output.

State Machine

AppController is a SingletonMonoBehaviour<AppController> managing the application lifecycle. Setting AppController.State fires the OnAppStateChange delegate.

C#
// Subscribe to state changes
AppController.OnAppStateChange += (AppController.States newState) =>
{
    if (newState == AppController.States.FloorPlan)
        ShowFloorPlanUI();
};

// Change state programmatically
AppController.Instance.State = AppController.States.Preview;

Data Flow Pipeline

From user drawing to 3D geometry — the complete build pipeline:

Class Hierarchy

Controllers

Hierarchy
MonoBehaviour
├── SingletonMonoBehaviour<T>
│   ├── AppController                    // State machine
│   ├── ProjectSerializer              // JSON persistence
│   ├── HeadlessBuildingAPI              // Programmatic building API
│   ├── BuildingFactory                  // Prefab instantiation & coord conversion
│   └── BuildingUIBridge                 // Scene↔UI connection
├── BuildingComponentBase
│   ├── SpaceController : IObjectDrawer   // Base for rooms/outside
│   │   ├── RoomController               // Room management
│   │   └── OutsideController            // Outdoor areas
│   └── OpeningController : IObjectDrawer // Doors/windows/archways
├── BuildingController                   // Building root
├── FloorController                      // Per-floor management
├── ControlPointsController              // Point drawing system
└── ServiceLocator (static)             // Lightweight DI container

Procedural Generation

Hierarchy
BuildingComponentBase
├── ProceduralSpace (abstract)
│   ├── ProceduralRoom       // Walls, floor, ceiling, colliders, reflection probe
│   └── ProceduralOutside    // Outdoor area geometry
├── ProceduralArea           // Area visualization / overlay geometry
├── ProceduralOpening        // Door/window/archway meshes
├── ProceduralExterior       // Building shell from contours
└── ProceduralRoof (abstract, IConstructible<MeshDraft>)
    ├── ProceduralRoofFlat
    ├── ProceduralRoofHipped
    └── ProceduralRoofGabled

HeadlessBuildingAPI

SingletonMonoBehaviour<HeadlessBuildingAPI> — High-level API for creating buildings programmatically without UI dependencies. Used by deserialization, undo/redo, and headless creation scenarios.

Building Creation

Floor Creation

Room & Opening Creation

Complete Example

C#
// Example 1: Create a simple house programmatically
var settings = new BuildingConstructionSettings();
settings.ApplyDefaults();

BuildingController building = HeadlessBuildingAPI.Instance.CreateBuilding("My House", settings);
FloorController floor = HeadlessBuildingAPI.Instance.CreateFloor(building);

// Create a 6x8 meter room
RoomController room = HeadlessBuildingAPI.Instance.CreateRectangularRoom(
    width: 6f, length: 8f,
    floorCtrl: floor,
    position: Vector3.zero,
    roomName: "Living Room"
);

// Add a front door
OpeningController door = HeadlessBuildingAPI.Instance.CreateDoor(
    floor, worldPos: new Vector3(8f, 0, 0),
    w: 1.0f, h: 2.0f
);

// Add windows
HeadlessBuildingAPI.Instance.CreateWindow(
    floor, worldPos: new Vector3(-3f, 0, 0),
    windowWidth: 1.2f, windowHeight: 1.0f
);

// Build the 3D geometry
building.Build();

C#
// Example 2: Create building from data objects
var buildingData = new UnifiedBuildingData("v3");
buildingData.constructionSettings.ApplyDefaults();

var floor = new FloorData(null);

// Add room with normalized positions
var office = new FloorSpaceItemData(SpaceType.Room, "Office");
office.normalizedPositions = BuildingFactory.Instance.ConvertWorldPointsToNormalized(
    new List<Vector3> {
        new Vector3(-2, 0, -2), new Vector3(2, 0, -2),
        new Vector3(2, 0, 2),  new Vector3(-2, 0, 2)
    });
floor.spaces.Add(office);
buildingData.floors.Add(floor);

BuildingController building = HeadlessBuildingAPI.Instance.CreateBuilding("Office", buildingData);
building.Build();

C#
// Example 3: Create from JSON string
string json = File.ReadAllText("building.json");
BuildingController building = HeadlessBuildingAPI.Instance.CreateBuildingFromJson("Loaded", json);
building.Build();

// Optionally connect to UI
BuildingUIBridge.Instance?.ConnectBuildingToUI(building);

BuildingController

Root controller for a building. Manages floor collection, construction settings, and the build pipeline. Static currentBuilding tracks the active building.

Properties

Key Methods

IObjectDrawer Interface

Common interface implemented by both SpaceController and OpeningController. Defines the contract for drawable objects.

C#
public interface IObjectDrawer
{
    ControlPointsController Cpc { get; set; }
    Color DrawingColor { get; set; }

    void Init();                            // Initialize for drawing
    void Build();                           // Generate 3D geometry
    void SetDisplayed(bool displayed);     // Show/hide
    void SetData(FloorPlanItemData data);   // Apply data
    FloorPlanItemData GetData();           // Read data
    void OnSettingsChanged(FloorPlanItemData data);
}

SpaceController

Base class for room and outside controllers. Inherits BuildingComponentBase, implements IObjectDrawer. Manages control points, procedural space generation, and opening lists.

OpeningController

Controls doors, windows, and archways. Manages drawing, snapping to walls, and procedural mesh generation. Throttles rebuilds with configurable delayBetweenRebuilds.

FloorController

Manages all rooms and openings for a single floor. Runs the multi-pass build pipeline: collecting openings, building spaces twice (so wall geometry exists before opening holes are cut), building opening meshes, and finally building the exterior shell.

Key Methods

Build Pipeline

Event System

All inter-system communication uses System.Action delegates in Exoa.Events.HomeDesignerEvents. No Unity messaging — clean, type-safe event dispatch.

File & Persistence Events

Request Events (UI → Logic)

State & UI Events

Enums

C#
// Subscribing to events
void OnEnable()
{
    HomeDesignerEvents.OnFileLoaded += OnFileLoaded;
    HomeDesignerEvents.OnRequestRebuild += OnRebuild;
    HomeDesignerEvents.OnFloorChanged += OnFloorChanged;
}

void OnDisable()
{
    HomeDesignerEvents.OnFileLoaded -= OnFileLoaded;
    HomeDesignerEvents.OnRequestRebuild -= OnRebuild;
    HomeDesignerEvents.OnFloorChanged -= OnFloorChanged;
}

// Firing events
HomeDesignerEvents.OnRequestButtonAction?.Invoke(ButtonAction.SaveProject, true);
HomeDesignerEvents.OnRequestFloorAction?.Invoke(FloorPlanAction.Add, floorId);

Procedural Generation

The procedural system generates all 3D geometry from 2D floor plan data. It uses ProceduralToolkit for mesh building, ClipperLib for polygon offsetting (wall thickness), and LibTessDotNet for tessellation.

ProceduralRoom

Generates complete room geometry from a polygon of control points.

ProceduralOpening

Generates door, window, and archway meshes. Supports configurable dimensions, glass panels, handles, and window subdivisions.

ProceduralExterior

Builds the exterior shell from room contours using polygon union operations. Creates the outer walls visible in Preview mode.

Roof Types

Build Pipeline Detail

💡

Serialization

ProjectSerializer (singleton) handles all JSON persistence via the included Newtonsoft.Json (custom IL2CPP-compatible build).

Data Model Hierarchy

Structure
UnifiedBuildingData
├── version: "v3"
├── constructionSettings: BuildingConstructionSettings
│   ├── wallsHeight, doorsHeight
│   ├── interiorWallThickness, exteriorWallThickness
│   ├── windowsThickness, doorsThickness
│   ├── roofType, roofThickness, roofOverhang
│   └── RoofConfig { type, thickness, overhang, color }
├── estheticSettings: BuildingEstheticSettings
│   └── exteriorWallMat, roofMat, texture settings
└── floors: List<FloorData>
    ├── uniqueId: string
    ├── spaces: List<FloorSpaceItemData>
    │   ├── type: SpaceType (Room | Outside | SingleWall)
    │   ├── name, uniqueId
    │   ├── normalizedPositions: List<Vector2>
    │   ├── roomSettings (wall/floor/ceiling textures)
    │   └── sceneObjects (furniture placements)
    └── openings: List<FloorOpeningItemData>
        ├── type: OpeningType (Door | Window | Archway)
        ├── name, uniqueId
        ├── width, height, ypos
        ├── normalizedPositions: List<Vector2>
        ├── directions: List<Vector3>
        ├── hasWindow, windowFrameSize
        └── windowSubDivH, windowSubDivV

Enums

Save / Load Flow

Undo/Redo

UndoRedoManager stores up to 50 JSON snapshots. Before each user action, TakeSnapshot() serializes the current building state. Undo/Redo destroys the current building and recreates from a snapshot.

File Locations

JSON Example

JSON
{
  "version": "v3",
  "floors": [
    {
      "uniqueId": "e9eb0652-19b3-475a-9b47-7bce13274c22",
      "spaces": [
        {
          "type": 0,
          "name": "Office",
          "normalizedPositions": [
            { "x": 0.3, "y": 0.3 },
            { "x": 0.7, "y": 0.3 },
            { "x": 0.7, "y": 0.7 },
            { "x": 0.3, "y": 0.7 }
          ]
        }
      ],
      "openings": [
        {
          "type": 0,
          "width": 1.0,
          "height": 2.0,
          "name": "Office Door",
          "normalizedPositions": [{ "x": 0.5, "y": 0.3 }]
        }
      ]
    }
  ],
  "constructionSettings": {
    "wallsHeight": 2.5,
    "doorsHeight": 2.0,
    "interiorWallThickness": 0.05,
    "exteriorWallThickness": 0.1,
    "roofType": 2,
    "roofThickness": 0.1,
    "roofOverhang": 0.8
  }
}

Save / Load Walkthrough

The simplest way to trigger save and load is through the event system, which lets existing UI and any other subscribers react automatically:

C#
// ── Trigger save (fires OnFileSaved when complete) ──────────────────
HomeDesignerEvents.OnRequestButtonAction?.Invoke(
    HomeDesignerEvents.ButtonAction.SaveProject, true);

// ── Listen for save / load completion ───────────────────────────────
void OnEnable()
{
    HomeDesignerEvents.OnFileSaved  += OnSaved;
    HomeDesignerEvents.OnFileLoaded += OnLoaded;
}

void OnDisable()
{
    HomeDesignerEvents.OnFileSaved  -= OnSaved;
    HomeDesignerEvents.OnFileLoaded -= OnLoaded;
}

void OnSaved(string fileName, HomeDesignerEvents.FileType type)
    => Debug.Log($"Saved: {fileName}");

void OnLoaded(HomeDesignerEvents.FileType type)
    => Debug.Log("Project loaded");

// ── Direct API (bypasses event chain) ───────────────────────────────
ProjectSerializer.Instance.SaveProject("MyHouse");
ProjectSerializer.Instance.LoadProject("MyHouse");

// ── Enumerate saved files ────────────────────────────────────────────
string[] files = System.IO.Directory.GetFiles(
    Application.persistentDataPath, "*.json");
foreach (var f in files)
    Debug.Log(System.IO.Path.GetFileNameWithoutExtension(f));

Module System (Furniture)

Furniture modules and their categories are configured through the HomeDesignerSettings database. Open it via Tools > Exoa > Home Designer > Settings.

Module Data Model

C#
public class SceneObjectItemData
{
    public string uniqueId;      // Instance GUID
    public string objectId;      // Prefab identifier
    public Vector3 position;     // World-space position
    public Vector3 rotation;     // Euler rotation angles
    public Vector3 scale;        // Local scale
    public int variantIndex;     // Active variant index
}

Asset Locations

Wall materials, floor materials, and furniture module prefabs are no longer loaded from a Resources/ folder. All asset references are managed directly in the HomeDesignerSettings database (Tools > Exoa > Home Designer > Settings).

Sample Module Categories

Ready-to-use furniture prefabs in Samples/Modules/, each with a thumbnail:

Creating a Custom Module

Any GameObject from the Project panel can be converted into a ready-to-use furniture module in a few steps.

The converter creates a new prefab containing your object, a Box Collider (used for placement validation and snapping), and a ModuleController component. Once the prefab is configured, register it in the HomeDesignerSettings database to make it available at runtime.

Interior Design System

The interior design system handles furniture and decoration placement in 3D space. It activates in the Furnish app state and supports both mouse and touch-driven module manipulation with ghost preview, wall detection, and variant switching.

Key Classes

Placement Layers

Modules raycast against the following Unity layers to determine valid placement surfaces:

Serialized Module Data

Placed modules are stored as SceneObjectItemData entries inside FloorSpaceItemData.sceneObjects:

C#
public class SceneObjectItemData
{
    public string uniqueId;      // Instance GUID
    public string objectId;      // Prefab identifier
    public Vector3 position;     // World-space position
    public Vector3 rotation;     // Euler rotation angles
    public Vector3 scale;        // Local scale
    public int variantIndex;     // Active variant index
}

Material System

Materials can be applied independently to interior room surfaces (per-wall, floor, ceiling), exterior building walls, and the roof. All material controllers are render-pipeline aware and work with Built-in RP, URP, and HDRP.

Material Controllers

Material Asset References

Wall and floor material assets are registered in the HomeDesignerSettings database. Open it via Tools > Exoa > Home Designer > Settings to add, remove, or reorder available materials.

RoomSetting — Per-Room Textures

C#
// RoomSetting is stored inside FloorSpaceItemData
public class RoomSetting
{
    public string wallMat;     // Wall material resource name
    public string floorMat;    // Floor material resource name
    public string ceilingMat;  // Ceiling material resource name
}

Render Pipeline Switching

Use Tools > Exoa > Render Pipeline Switcher to batch-convert all project materials between Built-in RP, URP, and HDRP. At runtime, MaterialExtensions handles pipeline-aware material property lookups (e.g., _BaseColor vs _Color).

Preview Mode

PreviewModeManager controls the multi-floor 3D preview where all floors of a building are displayed simultaneously, stacked vertically so the entire building is visible at once.

How It Works

When entering the Preview state, each FloorController is repositioned at Y = floorIndex × wallsHeight. The exterior shell and roof are rebuilt to span the full stacked height. Returning to another state restores each floor to Y = 0 and rebuilds normally.

Transition Events

Entering/leaving preview mode fires HomeDesignerEvents.OnRequestRebuild and triggers camera refocus via CameraEvents. UI panels are hidden (only preview controls remain visible) via CanvasGroupsFader.

State Table

UI System

Event-driven UI that subscribes to HomeDesignerEvents and fires OnRequest* events. All panel transitions managed by CanvasGroupsFader.

Menu Panels

Popup Types

UI Item Hierarchy

Hierarchy
UIBaseItem
├── UISpaceBaseItem
│   └── UIRoomItem        // Room list entry
├── UIOpeningBaseItem
│   └── UIOpeningItem     // Door/window list entry
└── UIFloorItem           // Floor list entry

BuildingUIBridge

Singleton that connects scene objects to UI list items. Key methods:

Custom UI Integration

The built-in UI is entirely optional. You can replace it, extend it, or drive the plugin from a completely different interface — the core logic communicates only through HomeDesignerEvents static delegates.

Wiring a Custom Button

To trigger any action from your own UI, fire the appropriate OnRequest* event:

C#
// Save project from a custom Save button
public void OnSaveClicked()
{
    HomeDesignerEvents.OnRequestButtonAction?.Invoke(
        HomeDesignerEvents.ButtonAction.SaveProject, true);
}

// Switch to Furnish mode from a custom tab
public void OnFurnishTabClicked()
{
    AppController.Instance.State = AppController.States.Furnish;
}

// Add a new floor from a custom button
public void OnAddFloorClicked()
{
    HomeDesignerEvents.OnRequestFloorAction?.Invoke(
        HomeDesignerEvents.FloorPlanAction.Add, null);
}

Reacting to State Changes

Subscribe to AppController.OnAppStateChange to show/hide your own panels when the app state changes:

C#
void OnEnable()
{
    AppController.OnAppStateChange += OnStateChanged;
}

void OnDisable()
{
    AppController.OnAppStateChange -= OnStateChanged;
}

void OnStateChanged(AppController.States state)
{
    myFloorPanel.SetActive(state == AppController.States.Floors);
    myFurnishPanel.SetActive(state == AppController.States.Furnish);
}

Replacing the UI Entirely

To run with no built-in UI at all:

1. Remove the UI Canvas prefab from your scene.
2. Use HeadlessBuildingAPI to create and modify buildings from code.
3. Subscribe directly to HomeDesignerEvents delegates to react to persistence and state changes.
4. Call AppController.Instance.State = ... to drive the state machine from your own logic.

Camera System

TouchCameraLite provides orbit, pan, zoom, and focus controls. Supports both mouse and touch input for desktop and mobile platforms.

Key Features

CameraEvents

Secondary event source for camera-specific operations: focus on objects, perspective switching, and camera state changes.

Extension Methods

A rich set of C# extension methods in Exoa.Extensions namespace.

Troubleshooting

FAQ

Can I use Home Designer without the built-in UI?

Yes. HeadlessBuildingAPI creates and manipulates buildings entirely from code with no UI dependencies. Load the Demo_API scene for a working example, or instantiate HeadlessBuildingAPI in your own scene. The UI is optional — connect it later via BuildingUIBridge.Instance.ConnectBuildingToUI(building) if needed.

Can I have multiple buildings in one scene?

The system tracks one active building via BuildingController.currentBuilding. You can instantiate multiple BuildingController prefabs, but only one is "active" at a time for editor operations. Switching the active building is done with BuildingController.SetCurrentBuilding(building).

Does it work on WebGL?

The core procedural and serialization systems are WebGL-compatible. GLB export is not available on WebGL (filesystem access is restricted). Test thoroughly — some Application.persistentDataPath operations behave differently in a browser sandbox.

Can I customise keyboard shortcuts?

Yes — open the HomeDesignerInputActions asset in the Input Action editor and remap any binding. No code changes required. Camera shortcuts (F, Space, scroll) live in the same asset under the Camera action map.

How do I add a new app state?

Add a value to the AppController.States enum, then handle the new state in any subscriber of AppController.OnAppStateChange. The state machine itself has no hard-coded logic per state — all behaviour is driven by event subscribers.

Is the license check included in builds?

No. The license system is editor-only (#if UNITY_EDITOR). Builds contain no license enforcement — the DLLs that perform the check are editor assemblies and are stripped at build time.

Can I save and load multiple projects?

Yes. Projects are saved as individual JSON files (and optionally GLB files) under Application.persistentDataPath. Each file is identified by its project name. Call ProjectSerializer.Instance.SaveProject(name) and ProjectSerializer.Instance.LoadProject(name) to manage them, and enumerate the directory to show a file list in your UI.

Upgrading

When updating to a new version of Home Designer, follow these steps to avoid conflicts:

1. Back up your project (or commit to version control) before importing the new package.
2. Delete the old package folder (Assets/Exoa/HomeDesigner/) before importing the new .unitypackage — stale scripts can cause compile errors if files are renamed or removed.
3. Re-run the Render Pipeline Switcher after import if new materials were added (Tools > Exoa > Render Pipeline Switcher).
4. Regenerate the Input Actions asset if new shortcuts were added — run Tools > Exoa > Create Input Actions Asset to overwrite the old one.
5. Check HomeDesignerSettings for any new fields that need to be configured after the upgrade.

Breaking Changes to Watch For

Third-Party Dependencies

Common Recipes

Copy-pasteable snippets for the most frequent tasks.

Create a rectangular room from code

C#
var settings = new BuildingConstructionSettings();
settings.ApplyDefaults();

BuildingController building = HeadlessBuildingAPI.Instance.CreateBuilding("House", settings);
FloorController    floor    = HeadlessBuildingAPI.Instance.CreateFloor(building);
RoomController     room     = HeadlessBuildingAPI.Instance.CreateRectangularRoom(
    width: 5f, length: 7f, position: Vector3.zero, floorCtrl: floor, roomName: "Living Room");

building.Build();

Trigger a full rebuild

C#
HomeDesignerEvents.OnRequestRebuild?.Invoke();

Switch app state

C#
AppController.Instance.State = AppController.States.FloorPlan;  // enter draw mode
AppController.Instance.State = AppController.States.Preview;    // enter 3D preview

Clear the current scene

C#
// args: clearScene, clearFloorUI, clearFloorPlanUI
HomeDesignerEvents.OnRequestClearAll?.Invoke(true, true, true);

React to floor selection changes

C#
void OnEnable()  => HomeDesignerEvents.OnFloorChanged += OnFloorChanged;
void OnDisable() => HomeDesignerEvents.OnFloorChanged -= OnFloorChanged;

void OnFloorChanged(FloorData data, int index)
    => Debug.Log($"Now editing floor {index}");

Load a building from a JSON string

C#
string json = File.ReadAllText(path);
BuildingController building = HeadlessBuildingAPI.Instance.CreateBuildingFromJson("Loaded", json);
building.Build();
BuildingUIBridge.Instance?.ConnectBuildingToUI(building);

Focus camera on the current building

C#
CameraEvents.OnRequestObjectFocus?.Invoke(
    BuildingController.GetCurrentBuilding().gameObject, true);

Assembly Definitions

The project uses assembly definitions to isolate libraries and reduce compile times:

Service Locator

ServiceLocator is a lightweight dependency injection container that decouples systems from direct singleton references. Services are registered once (typically in Awake) and resolved wherever needed.

C#
// Register a service (e.g. in Awake)
ServiceLocator.Register<BuildingController>(building);

// Resolve anywhere — no direct static reference needed
var building = ServiceLocator.Get<BuildingController>();
building.Build();

// Check registration before use
if (ServiceLocator.Has<BuildingController>())
    ServiceLocator.Get<BuildingController>().Build();

// Unregister on scene unload
ServiceLocator.Clear();

BuildingFactory

BuildingFactory (singleton) provides factory methods for instantiating building component prefabs and converting between world-space coordinates and the normalized [0,1] range used in data models.

Key Methods