Project Structure

When you create a new project, Polygon Engine generates a folder layout designed around source assets, imported runtime assets, editable scenes, and generated PS1 output. Keep the project in a user-writable folder outside the Polygon Engine installation directory.

MyProject/
  polygon.project.json      # Portable project configuration (budgets, build, scripting)
  Assets/
    Models/                  # Static or hard-skinned source models (.obj, .fbx)
    Textures/                # Source textures (.png, .bmp, .tga)
    Materials/               # Material source files (.mat.json)
    Meshes/                  # Level Builder source meshes (.pmsh)
    Scripts/                 # Lua scripts (.lua)
    Audio/                   # Source audio files (.wav)
    Prefabs/                 # Reusable GameObject hierarchies (.prefab.json)
  Scenes/
    scene_main.json          # GameObjects, components, UI, world data, and animation
  Library/
    asset_db.json            # Asset database (GUIDs, paths, stats)
    meshes/                  # Compiled mesh binaries (.msh)
    level_builder/           # Cached editable Level Builder meshes (.pmsh)
    textures/                # Compiled texture binaries (.tex)
    materials/               # Compiled material files (.mat)
    audio/                   # Compiled resident audio files (.vag)
    animations/              # Hard-skinned mesh and animation assets (.skn)
    build_history.json       # Last 20 local build summaries
  Build/
    ps1/
      disc_root/             # Staged SYSTEM.CNF, runtime, manifest, and DATA assets
      package/               # Final .bin/.cue/.iso output
      logs/                  # Build logs, summary, budgets, and performance reports
  Intermediate/
    editor_cache.json        # Rebuildable editor cache

Rooms, Portals, navigation settings, loading presentation, bitmap fonts, UI canvases, cutscene timelines, and standalone Animation clips are stored in the scene JSON. Prefabs remain separate reusable authoring assets and are expanded into linked GameObject instances in scenes. Scene data is compiled into bounded chunks in the generated .BSN; these systems do not require separate source folders.

Key Files

polygon.project.json

The root project configuration file. Contains:

Section	Description
projectName	Project display name
ps1	PS1-specific settings (exe name, disc image name, region)
rendering	Far distance and project rendering defaults
ps1Budgets	Hardware budget limits (VRAM, RAM, SPU, triangles)
scripting	Lua runtime configuration (heap size, script limits)
input	Semantic Input Action names, kinds, and physical bindings
buildSettings	Ordered scenes included in the build and the startup scene

The PS1 section also stores the NTSC/PAL region, executable and disc-image names, plus the memory-card file ID and display title. Give every game a unique save ID so it cannot overwrite another Polygon Engine project's card file.

Tool paths, Project Hub entries, and custom editor layouts are local editor state. They are stored under %APPDATA%/Polygon Engine/Editor/ on Windows so projects stay portable between machines and source-control checkouts.

When opening a supported older project, the editor migrates project and scene documents transactionally and moves machine-specific tool paths to local state. Documents created by a newer, unsupported engine are rejected rather than overwritten.

Prefab Files (*.prefab.json)

Prefab assets live under Assets/Prefabs/. They contain a complete GameObject subtree, a stable prefab GUID, and stable local IDs used to reconnect references when an instance is created or synchronized. Edit them through linked instances and the Inspector's Sync, Apply, and Unpack actions; do not hand-edit the JSON.

Library/asset_db.json

Maps asset GUIDs to their compiled output paths. Updated automatically on import. Each entry contains:

• guid - Unique identifier
• type - Asset type (Mesh, Material, Texture, AudioClip, or SkeletalAnimation)
• name - Display name
• path - Relative path to compiled output
• sourceGuid - GUID of the source meta file
• sourcePath - Source asset path when the asset has an editable source file
• stats - Asset statistics (vertex count, file size, etc.)

Meta Files (*.meta.json)

Every imported source asset has a companion .meta.json file next to it. Meta files store:

• Import settings (format, scale, sample rate, etc.)
• Output paths to compiled assets in Library/
• Import status and error messages
• Asset statistics

Model, texture, and audio metadata also stores source/settings hashes and the paths of generated outputs. The build uses those hashes to detect stale compiled data before staging the PS1 package. An animated FBX can produce a static .msh/.mat pair and a bounded .skn asset from the same source.

What a PS1 Build Produces

The build converts friendly project paths into a compact disc layout:

Build/ps1/disc_root/
  SYSTEM.CNF
  POLYGON.EXE
  DATA/
    MANIFEST.JSN
    S/                 # Binary scenes (.BSN)
    L/                 # Compiled Lua
    M/                 # Meshes
    K/                 # Hard-skinned animation assets
    R/                 # Materials
    T/                 # Textures
    A/                 # Resident VAG audio
    X/                 # CD-XA streams when present
    B/                 # Scene-local sequential dependency bundles (.PGB)

MANIFEST.JSN maps project GUIDs and scene names to the compact paths and each scene's optional sequential bundle. Treat everything under Build/ps1/ as generated output. See Build Pipeline for binary scene chunks, reports, and the package contract.

Generated vs Editable Data

Do not edit files in Library/ or Build/ps1/ by hand. They are generated by the editor and build pipeline.

Use these source locations instead:

Data	Edit here
Imported models	Assets/Models/
Imported textures	Assets/Textures/
Imported audio	Assets/Audio/
Reusable hierarchies	Assets/Prefabs/ through linked instances
Skeletal FBX source	Assets/Models/
Lua gameplay	Assets/Scripts/
Materials	Assets/Materials/
Level Builder meshes	Assets/Meshes/
Scene systems and timelines	Scenes/ through the editor

For the first build path, see Quick Start.