Reference

Lookup material: every setting with its default and range, the components, the deterministic seed contract, the runtime API, and what ships in the package. If you are learning the tool, start with How It Works instead.

All values on this page were read from the shipping source of version 2.5.0.

Menu items

Everything under Tools ▸ BoneCracker Games ▸ Building Generator ▸:

The last four also exist inside the window; they are mirrored as menu items so they work with no window open.

Window structure

Primary button per pane

Settings

Every field in the window, grouped by the pane it appears on. Defaults are what a fresh install gives you; ranges are the hard limits the controls enforce.

Build ▸ Single

Archetype presets (applied when you switch archetype; every field stays editable):

Build ▸ Street

Plan ▸ City Grid

Plan ▸ Zones / Build ▸ Districts

Generation Settings ▸ Geometry

Generation Settings ▸ Saving

Where (placement)

Dress ▸ Mood

Presets: Day = intensity 0 · Dusk = 0.8, warm (shipped default) · Night = 2.5, warm.

Dress ▸ Probes

Probe heights: street level 1.5 m, mid-rise 8 m, rooftop tallest roof + 2 m (only where a building stands nearby).

Components

The two components the tool puts in your scene. Both are data-only and safe to ship in a build — neither contains any generation logic.

BCG_BuildingZone (district component)

A Runtime MonoBehaviour that gives a BoxCollider area its own district settings. Requires a BoxCollider on the same GameObject; carries no generation logic, so it is safe in a build.

lastPopulated is hidden in the Inspector and managed by the tool.

Gizmo colours: cyan (0.2, 0.9, 1.0) while empty, green (0.3, 1.0, 0.4) once populated, with an 8%-alpha solid fill when selected.

BCG_BuildingMarker (per-building tag)

Stamped on every generated building. Hidden from the Add Component menu and the Inspector; data-only and safe in a build. It is how the tool finds, audits and cleans up its own output.

The three option flags default to false so buildings made before those features existed deserialise honestly rather than claiming content they do not have.

The seed contract

Every building is built from a single System.Random(seed) sequence, consumed in a fixed order. This is the load-bearing invariant behind "same seed = same building", so the order is never changed — new features append to the end.

1. Massing plan — setback / podium / L-plan picks. Tower only, and only when eligible. House short-circuits to a slab without consuming any draws; its roof pitch is a pure function of the seed, not a draw.
2. Facade style pair — a primary and secondary style rolled from the archetype's pool.
3. Per block, in plan order — four per-side U offsets, then one band/style roll per floor.
4. Rooftop / storefront props — gated on rooftopProps, non-House only. Fixed draw counts depending only on archetype and floor count, drawn before the tail so a Simple build can truncate without desyncing. With props off, this step is skipped entirely.
5. Tail — either 5a per-block roof clutter (non-House), or 5b the House chimney rolls (always 3 draws: presence, side, position — regardless of outcome).
6. Facade extras — gated on facadeExtras, non-House only. Appended after the tail. Per side (0–3), always 3 draws: presence, density, phase — 12 total, fixed regardless of outcome.
7. Lit signage — gated on litSigns. Shop = 2 draws; Tower with 10+ floors = 7 draws; Apartment, shorter Towers and House consume nothing.

Simple is a strict prefix: it consumes identical draws through step 4 and truncates from there. It is never a different roll sequence.

Detailed adds nothing to this list. Every Detailed-only feature is either always-present geometry or a pure function of the seed, consuming zero draws. Standard and Detailed are byte-identical through steps 1–6; only the vertex count differs.

Road generation consumes nothing from any seeded sequence, which is why toggling roads never reshuffles a building.

Mesh name content tags

Generated mesh assets are name-tagged whenever their geometry departs from the untagged baseline, so flipping an option can never overwrite a different combination's shared mesh. Tags compose in this fixed order:

A mesh's full name is BCG_BuildingMesh_{baseId}{tags} — for example a Detailed building with props and extras is ..._P_D_X. Extras and signage are suppressed at the Simple tier, which is why they are not tagged there: a Simple mesh with extras on is byte-identical to one with extras off, and tagging it would create a spurious duplicate.

LOD transition points

Values are fractions of screen height.

Runtime API

The geometry engine lives in the Runtime assembly, so buildings can be generated in-game.

using BoneCrackerGames.BuildingGen;

public class CitySpawner : MonoBehaviour {

    //  Assign one of the shipped facade materials (Generated/BCG_Building_Facade_A..D.mat)
    //  in the Inspector — runtime code cannot create pipeline-aware materials itself.
    public Material facadeMaterial;

    void Start() {

        BCG_BuildingParams p = new BCG_BuildingParams {
            archetype = BCG_BuildingArchetype.Tower,
            cellsX = 7,
            cellsZ = 5,
            floors = 12,
            seed = 4242
        };

        GameObject building = BCG_RuntimeBuildingFactory.Build(p, facadeMaterial);
        building.transform.position = new Vector3(30f, 0f, 0f);

    }

}

Entry points

//  Just the mesh.
Mesh BCG_BuildingMeshCore.BuildMesh(BCG_BuildingParams p);
Mesh BCG_BuildingMeshCore.BuildMesh(BCG_BuildingParams p, BCG_BuildingDetail detail);

//  The whole GameObject: mesh, material, per-block colliders, identity marker.
GameObject BCG_RuntimeBuildingFactory.Build(
    BCG_BuildingParams p,
    Material material,
    bool addColliders = true,
    BCG_BuildingDetail detail = BCG_BuildingDetail.Full);

BCG_BuildingParams

Notes

• The same seed produces the same building everywhere. The Editor and the runtime share one engine.
• Runtime output has no static flags, lightmap UVs or LODGroup. Those are editor-time concerns; runtime output is meant to be dynamic.
• Generation is main-thread (it uses Unity's mesh API). A large tower costs a few milliseconds, so spread bulk generation across frames.

Enumerations

enum BCG_BuildingArchetype { Tower, Shop, Apartment, House }
enum BCG_BuildingDetail    { Full, Simple, Detailed }        //  UI: Standard, Simple, Detailed
enum BCG_FacadeStyle       { OfficeDark, OfficeLit, Punched, Ribbon, Balcony, Mullion }

Stored preferences

Settings are stored per user in EditorPrefs under the BCG.BuildingGen. prefix — for example BCG.BuildingGen.Stage, BCG.BuildingGen.DetailLevel, BCG.BuildingGen.GenerateLODs, BCG.BuildingGen.SaveAsPrefab, BCG.BuildingGen.FakeInteriors, BCG.BuildingGen.ProbeBudget.

Three of them are stored per project (the key carries the project's GUID) because they reference project-specific things: the output root, the obstacle layer mask and the ground layer mask.

Nothing about your city depends on these — they are UI state. A teammate opening your scene sees the same city with their own tool preferences.

Package contents

Not shipped: the Edit Mode tests, the internal Python texture-authoring scripts, and the development documents outside Assets/.

Version

The authoritative version is BuildingGen_Version.Version in Runtime/BuildingGen_Version.cs — currently 2.5.0. The generator window shows it in its title row. See the Changelog for what changed in each release.

See also

• How It Works — the concepts behind this reference.
• Atlas Layout — the texture atlas band layout.
• Troubleshooting — every Console message explained.