Compare commits
6 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 YourWishes
|
d3715eece8 | ||
|
YourWishes
|
335d79f2c4 | ||
|
YourWishes
|
a9e33660cb | ||
|
YourWishes
|
8faf881399 | ||
|
YourWishes
|
c4969a36cc | ||
|
YourWishes
|
26fcaf6e75 |
@@ -1,74 +0,0 @@
|
||||
# Animation System
|
||||
|
||||
Source: `src/dusk/animation/`
|
||||
|
||||
Lightweight keyframe-based value interpolation using fixed-point math throughout.
|
||||
|
||||
---
|
||||
|
||||
## Easing (`animation/easing.h`)
|
||||
|
||||
`easingApply(type, t)` applies an easing function to a normalized time value `t ∈ [0, FIXED_ONE]` and returns the eased value in the same range.
|
||||
|
||||
All functions are also callable directly:
|
||||
|
||||
```c
|
||||
fixed_t t = FIXED(0.5f);
|
||||
fixed_t out = easingApply(EASING_IN_OUT_CUBIC, t);
|
||||
```
|
||||
|
||||
Available easing types (all in `easingtype_t`):
|
||||
|
||||
| Enum value | Curve |
|
||||
|---|---|
|
||||
| `EASING_LINEAR` | straight line |
|
||||
| `EASING_IN_SINE` / `OUT` / `IN_OUT` | sinusoidal |
|
||||
| `EASING_IN_QUAD` / `OUT` / `IN_OUT` | quadratic |
|
||||
| `EASING_IN_CUBIC` / `OUT` / `IN_OUT` | cubic |
|
||||
| `EASING_IN_QUART` / `OUT` / `IN_OUT` | quartic |
|
||||
| `EASING_IN_BACK` / `OUT` / `IN_OUT` | overshoots slightly |
|
||||
|
||||
`EASING_FUNCTIONS[EASING_COUNT]` is a table of `easingfn_t` function pointers for when you need to pick an easing at runtime without a switch.
|
||||
|
||||
---
|
||||
|
||||
## Keyframes (`animation/keyframe.h`)
|
||||
|
||||
```c
|
||||
typedef struct {
|
||||
fixed_t time; // time point this keyframe is at
|
||||
fixed_t value; // output value at this time
|
||||
easingtype_t easing; // easing to apply when interpolating toward the NEXT keyframe
|
||||
} keyframe_t;
|
||||
```
|
||||
|
||||
Keyframe arrays should be sorted ascending by `time`.
|
||||
|
||||
---
|
||||
|
||||
## Animation (`animation/animation.h`)
|
||||
|
||||
`animation_t` wraps a keyframe array and provides value lookup:
|
||||
|
||||
```c
|
||||
keyframe_t frames[] = {
|
||||
{ FIXED(0.0f), FIXED(0.0f), EASING_LINEAR },
|
||||
{ FIXED(1.0f), FIXED(1.0f), EASING_IN_OUT_CUBIC },
|
||||
{ FIXED(2.0f), FIXED(0.0f), EASING_LINEAR },
|
||||
};
|
||||
|
||||
animation_t anim;
|
||||
animationInit(&anim, frames, 3);
|
||||
|
||||
fixed_t value = animationGetValue(&anim, FIXED(0.75f)); // interpolated
|
||||
```
|
||||
|
||||
`animationGetValue` finds the surrounding keyframes for the given `time`, computes the local `t` within that segment, applies the keyframe's easing, and linearly interpolates between the two keyframe values.
|
||||
|
||||
The animation does not own the keyframe array — it holds a pointer. Pass a static or long-lived array.
|
||||
|
||||
---
|
||||
|
||||
## Usage in the engine
|
||||
|
||||
Entity animations (`entityanim_t`) do NOT use this system — they use a simple countdown timer (`animTime`) and a state enum. The `animation_t` system is intended for property animation: UI transitions, camera easing, visual effects, anything that needs a time → value curve.
|
||||
@@ -1,81 +0,0 @@
|
||||
# Architecture
|
||||
|
||||
## Platform abstraction
|
||||
|
||||
Every subsystem that differs across platforms (display, input, asset loading, save, time, network, log) follows the same pattern:
|
||||
|
||||
1. `src/dusk/<subsystem>/<subsystem>platform.h` — included by the public header. Contains `#include "path/to/platform-specific-header.h"` resolved by the build system include path.
|
||||
2. `src/dusk{platform}/<subsystem>/<subsystem>platform.h` — the actual platform-specific header included above (e.g. `src/duskgl/display/framebuffer/framebufferplatform.h`).
|
||||
3. The shared header (`src/dusk/<subsystem>/<subsystem>.h`) `#error`s at compile time if the platform doesn't define the expected macros/types.
|
||||
|
||||
The active platform backends are selected by `DUSK_TARGET_SYSTEM` in CMake, which includes `cmake/targets/<system>.cmake`. That file sets compile definitions (`DUSK_LINUX`, `DUSK_SDL2`, `DUSK_OPENGL`, …) and links platform libraries.
|
||||
|
||||
Platform source directories:
|
||||
- `src/duskgl/` — OpenGL rendering (used on Linux and as the GL layer for SDL2)
|
||||
- `src/dusksdl2/` — SDL2 window/input/time (Linux desktop)
|
||||
- `src/dusklinux/` — Linux filesystem/save/network
|
||||
- `src/duskdolphin/` — GameCube & Wii (GX renderer, libogc)
|
||||
- `src/duskpsp/` — PSP (GU renderer, PSPSDK)
|
||||
- `src/duskvita/` — PS Vita
|
||||
|
||||
## Subsystem lifecycle
|
||||
|
||||
All subsystems follow `init → update (per frame) → dispose`. Engine initialization order matters and is centralized in `engine.c`:
|
||||
|
||||
```
|
||||
systemInit → timeInit → consoleInit → inputInit → assetInit →
|
||||
localeManagerInit → displayInit → uiInit → uiTextboxInit →
|
||||
cutsceneInit → rpgInit → networkInit → sceneInit
|
||||
```
|
||||
|
||||
Dispose runs in reverse. Each call uses `errorChain()` to propagate failures.
|
||||
|
||||
## Error handling
|
||||
|
||||
Functions that can fail return `errorret_t` (a code + pointer to thread-local error state). Three core macros:
|
||||
|
||||
```c
|
||||
errorThrow("message %s", arg); // sets error, returns from current function
|
||||
errorChain(someCall()); // if someCall() fails, propagates and returns
|
||||
errorOk(); // returns success
|
||||
```
|
||||
|
||||
Check with `errorIsOk(ret)` / `errorIsNotOk(ret)`. The error state carries file/function/line info for a stack-like trace.
|
||||
|
||||
## Fixed-point math
|
||||
|
||||
`fixed_t` is `int32_t` with Q24.8 format (8 fractional bits, ~0.004 resolution). Use it for all world/game values:
|
||||
|
||||
```c
|
||||
fixed_t x = FIXED(1.5); // compile-time literal
|
||||
fixed_t y = fixedFromI32(3); // runtime conversion
|
||||
fixed_t z = fixedMul(x, y); // arithmetic
|
||||
float_t f = fixedToFloat(z); // only where float is needed (e.g. GL uniforms)
|
||||
```
|
||||
|
||||
## Code generation from CSV
|
||||
|
||||
Several subsystems define their data in CSV files and have corresponding Python tools that generate C headers at build time (via CMake `add_custom_command`):
|
||||
|
||||
| CSV | Tool | Output |
|
||||
|-----|------|--------|
|
||||
| `src/dusk/input/input.csv` | `tools/input/csv/` | input action enum + names |
|
||||
| `src/dusk/display/color.csv` | `tools/color/csv/` | color constants |
|
||||
| `src/dusk/rpg/item/item.csv` | `tools/item/csv/` | item enum + metadata |
|
||||
| `src/dusk/rpg/story/storyflag.csv` | `tools/story/csv/` | story flag enum + initial values |
|
||||
|
||||
Generated headers are written to `build-<target>/generated/` and included via `target_include_directories`.
|
||||
|
||||
## Asset system
|
||||
|
||||
Assets are packed into `dusk.dsk` (a zip archive) at build time from the `assets/` directory. At runtime `asset.c` opens the archive and serves files from it.
|
||||
|
||||
Loading is asynchronous: `assetLock()` registers a load request; the background thread calls the appropriate loader; call `assetRequireLoaded()` to block until ready. `assetUnlock()` / `assetUnlockEntry()` releases the entry so it can be reclaimed.
|
||||
|
||||
Loaders are registered per type (`assetloadertype_t`) and live under `src/dusk/asset/loader/`. Platform-specific asset init (finding the .dsk file) is in `src/dusk{platform}/asset/`.
|
||||
|
||||
## Display subsystem
|
||||
|
||||
The display system is currently organized around immediate GPU-style rendering: `mesh_t` (vertex buffers), `shader_t` (GLSL on GL / TEV state on Dolphin), `texture_t`, and `framebuffer_t`. See [display-refactor.md](display-refactor.md) for the planned move to a render-queue model (needed for a future Saturn port).
|
||||
|
||||
The `spritebatch_t` (`display/spritebatch/`) accumulates 2D quads and flushes in batches — the primary 2D drawing primitive used by the RPG layer.
|
||||
@@ -1,115 +0,0 @@
|
||||
# Asset System
|
||||
|
||||
Source: `src/dusk/asset/`
|
||||
|
||||
All game assets are packed into `dusk.dsk` (a zip archive) at build time and served from it at runtime. The asset system manages async loading, reference counting, and platform-specific archive location.
|
||||
|
||||
See [architecture.md](architecture.md#asset-system) for the high-level overview.
|
||||
|
||||
---
|
||||
|
||||
## Asset archive
|
||||
|
||||
The archive is opened at `assetInit()`. `assetFileExists(filename)` checks for a file without loading it. The file path format inside the archive matches the layout of the `assets/` source directory.
|
||||
|
||||
On each platform, `assetInitPlatform()` locates the `.dsk` file (e.g. adjacent to the binary on Linux, on the SD card on PSP).
|
||||
|
||||
---
|
||||
|
||||
## Entry lifecycle
|
||||
|
||||
An `assetentry_t` represents one file being managed by the system. States:
|
||||
|
||||
```
|
||||
NOT_STARTED → PENDING_ASYNC → LOADING_ASYNC → PENDING_SYNC → LOADING_SYNC → LOADED
|
||||
└→ ERROR
|
||||
```
|
||||
|
||||
- **PENDING_ASYNC / LOADING_ASYNC**: the background thread is handling I/O (file reads, decompression).
|
||||
- **PENDING_SYNC / LOADING_SYNC**: the main thread needs to finish loading (e.g. uploading to GPU), triggered during `assetUpdate()`.
|
||||
|
||||
The async/sync split exists because GPU operations must happen on the main thread.
|
||||
|
||||
---
|
||||
|
||||
## Using assets
|
||||
|
||||
```c
|
||||
// Acquire a loaded entry (blocks until loaded):
|
||||
assetentry_t *entry = assetLock(filename, ASSET_LOADER_TYPE_TEXTURE, &input);
|
||||
errorChain(assetRequireLoaded(entry));
|
||||
|
||||
// Use the loaded data:
|
||||
texture_t *tex = &entry->data.texture.texture;
|
||||
|
||||
// Release when done:
|
||||
assetUnlockEntry(entry);
|
||||
```
|
||||
|
||||
`assetLock` finds-or-creates an entry and increments its reference count. `assetUnlock` / `assetUnlockEntry` decrements it; when it reaches zero the entry is reclaimed at the next `assetUpdate()`.
|
||||
|
||||
To subscribe to async completion instead of blocking:
|
||||
```c
|
||||
eventSubscribe(&entry->onLoaded, myCallback, myUser);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Loader types
|
||||
|
||||
| Type constant | File | Output struct accessed via |
|
||||
|---|---|---|
|
||||
| `ASSET_LOADER_TYPE_TEXTURE` | `.png` etc. | `entry->data.texture.texture` |
|
||||
| `ASSET_LOADER_TYPE_TILESET` | tileset descriptor | `entry->data.tileset.tileset` |
|
||||
| `ASSET_LOADER_TYPE_MESH` | mesh data | `entry->data.mesh.mesh` |
|
||||
| `ASSET_LOADER_TYPE_LOCALE` | `.po` file | internal to locale manager |
|
||||
| `ASSET_LOADER_TYPE_JSON` | `.json` | `entry->data.json.*` |
|
||||
|
||||
Each loader type registers `loadAsync`, `loadSync`, and `dispose` callbacks in `ASSET_LOADER_CALLBACKS[]`.
|
||||
|
||||
The async callback runs on the loader thread; the sync callback runs on the main thread during `assetUpdate()`. Most loaders do file I/O async and GPU upload sync.
|
||||
|
||||
### Error handling inside loaders
|
||||
|
||||
Use these macros instead of `errorThrow` / `errorChain` inside loader callbacks — they also set the entry state to ERROR:
|
||||
|
||||
```c
|
||||
assetLoaderErrorChain(loading, someCall());
|
||||
assetLoaderErrorThrow(loading, "Descriptive message");
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Low-level file I/O (`asset/assetfile.h`)
|
||||
|
||||
`assetfile_t` wraps a `zip_file_t` handle and provides streaming reads:
|
||||
|
||||
```c
|
||||
assetFileInit(&file, "textures/player.png", NULL, NULL);
|
||||
assetFileOpen(&file);
|
||||
assetFileRead(&file, buffer, size);
|
||||
assetFileClose(&file);
|
||||
assetFileDispose(&file);
|
||||
|
||||
// Read entire file into a malloc'd buffer:
|
||||
uint8_t *buf; size_t size;
|
||||
assetFileReadEntire(&file, &buf, &size); // caller frees buf
|
||||
```
|
||||
|
||||
For line-by-line text parsing (`assetfilelinereader_t`):
|
||||
```c
|
||||
assetFileLineReaderInit(&reader, &file, readBuf, readBufSize, outBuf, outBufSize);
|
||||
while(!reader.eof) {
|
||||
errorChain(assetFileLineReaderNext(&reader));
|
||||
// reader.outBuffer contains the line, reader.lineLength its length
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Background loader thread
|
||||
|
||||
`assetUpdateAsync(thread)` is the thread entry point. It calls `assetUpdate()` in a loop, sleeping briefly between iterations, until `threadShouldStop()` returns true. The main thread also calls `assetUpdate()` once per frame to process the sync phase.
|
||||
|
||||
Up to `ASSET_LOADING_COUNT_MAX` (4) entries can be loading concurrently.
|
||||
Up to `ASSET_ENTRY_COUNT_MAX` (128) entries can exist at once.
|
||||
@@ -1,92 +0,0 @@
|
||||
# Display Refactor Progress
|
||||
|
||||
## Immediate Goal
|
||||
Render a 32x32 white square through the new render opcode stack on Linux.
|
||||
|
||||
## Architecture (summary)
|
||||
See `.claude/display-refactor.md` for the full design.
|
||||
|
||||
- `src/dusk/render/` -- opcode format + buffer + submission API (the *contract*).
|
||||
- Platform backends (e.g. `src/duskgl/`) consume the buffer and translate to native API calls.
|
||||
- `src/dusk/display/` -- orchestration shell only: `displayInit`, `displayUpdate`, `displayDispose`.
|
||||
- Scenes call `renderSprite(...)`, `renderClear(...)`. The backend executes the intent.
|
||||
|
||||
## Opcode format (32 bytes)
|
||||
Every command starts with a 4-byte `ropheader_t` (opcode, flags, depth). Two commands defined:
|
||||
- `ROP_CLEAR` (32 bytes) -- clear with a color.
|
||||
- `ROP_DRAW_SPRITE` (32 bytes) -- screen-space int16 x/y/w/h + tint color.
|
||||
|
||||
## Milestone 1 -- Archive + strip existing display deps ✓
|
||||
- [x] Old `src/dusk/display/` archived (now deleted from working tree via git).
|
||||
- [x] Old `src/duskgl/display/` removed (new GL renderer replaces it).
|
||||
- [x] `engine.c` stripped to minimal subsystems, set to `SCENE_TYPE_TEST`.
|
||||
- [x] `scene.c` stripped of old display/shader/screen references.
|
||||
- [x] `console.c` stripped of display deps.
|
||||
- [x] `ui/CMakeLists.txt` gutted (re-implementation deferred).
|
||||
- [x] `asset/loader/CMakeLists.txt` -- display loaders disabled.
|
||||
- [x] `asset/loader/assetloader.h` -- display loader types removed.
|
||||
- [x] `rpg/overworld/chunk.h` -- mesh_t / meshvertex_t removed.
|
||||
- [x] `rpg/overworld/map.c` -- mesh/spritebatch calls removed.
|
||||
- [x] `scene/overworld/sceneoverworld.c` -- stubbed to empty callbacks.
|
||||
- [x] Test suite display tests disabled.
|
||||
|
||||
## Milestone 2 -- Render opcode system ✓
|
||||
- [x] `src/dusk/render/rop.h` -- `ropheader_t`, `ropclear_t`, `ropsprite_t`.
|
||||
- [x] `src/dusk/render/ropbuffer.h/.c` -- `ROPBUFFER` global, reset, alloc.
|
||||
- [x] `src/dusk/render/render.h/.c` -- `renderClear()`, `renderSprite()`.
|
||||
- [x] `src/dusk/render/CMakeLists.txt`.
|
||||
|
||||
## Milestone 3 -- New minimal display shell ✓
|
||||
- [x] `src/dusk/display/display.h/.c` -- init/update/dispose, calls platform hooks.
|
||||
- [x] `src/dusk/display/displaystate.h` -- cull/depth/blend flags.
|
||||
- [x] `src/dusk/display/color.csv` + `CMakeLists.txt` -- color generation kept.
|
||||
|
||||
## Milestone 4 -- GL backend ✓
|
||||
- [x] `src/duskgl/render/rendergl.h/.c`:
|
||||
- GL 3.3 core shader (ortho projection, solid color, no texture yet).
|
||||
- `renderGLInit` -- creates VAO/VBO/shader.
|
||||
- `renderGLFlush(buf, w, h)` -- walks ROPBUFFER, GL calls per opcode.
|
||||
- `ROP_CLEAR` → `glClearColor` + `glClear`.
|
||||
- `ROP_DRAW_SPRITE` → 6-vertex quad, `glDrawArrays`.
|
||||
- [x] `src/duskgl/error/errorgl.h/.c` -- `errorGLCheck`.
|
||||
- [x] `src/duskgl/CMakeLists.txt`.
|
||||
- [x] `src/dusksdl2/display/displaysdl2.h/.c` updated:
|
||||
- `displaySDL2Init` -- SDL2 window + GL 3.3 context + `renderGLInit`.
|
||||
- `displaySDL2Flush(ropbuffer_t *)` -- MakeCurrent + `renderGLFlush`.
|
||||
- `displaySDL2Swap` -- SDL_GL_SwapWindow.
|
||||
- [x] `src/dusklinux/display/displayplatform.h` updated with new macros.
|
||||
|
||||
## Milestone 5 -- Test scene ✓
|
||||
- [x] `SCENE_TYPE_TEST` added to `scenetype.h/.c`.
|
||||
- [x] `src/dusk/scene/test/scenetest.h/.c`:
|
||||
- `renderClear(color(32, 32, 48, 255))` -- dark blue-grey background.
|
||||
- `renderSprite(100, 100, 32, 32, COLOR_WHITE)` -- 32x32 white square.
|
||||
- [x] `engine.c` starts with `SCENE_TYPE_TEST`.
|
||||
|
||||
## Milestone 6 -- Verified ✓
|
||||
- [x] Build succeeds with no errors (2026-06-18).
|
||||
- [x] Engine initializes: SDL window + GL context + shader + test scene.
|
||||
- [x] No crashes running for 5+ seconds.
|
||||
- [ ] 32x32 white square visually confirmed on screen.
|
||||
|
||||
---
|
||||
|
||||
## Status: BUILD PASSING -- awaiting visual confirmation
|
||||
|
||||
---
|
||||
|
||||
## Decisions log
|
||||
|
||||
**2026-06-18** -- `color_t = color4b_t` (from generated `display/color.h`). The color generation pipeline (color.csv + Python tool) is kept in the new minimal `src/dusk/display/CMakeLists.txt`.
|
||||
|
||||
**2026-06-18** -- `ROP_SIZE = 32`. All opcodes fixed 32 bytes. 3D quads will be 64 bytes when added later.
|
||||
|
||||
**2026-06-18** -- Depth sort deferred. Buffer stores unsorted commands; painter platforms sort on flush. GL uses Z-buffer.
|
||||
|
||||
**2026-06-18** -- Texture system not yet wired into the opcode pipeline. `ROP_DRAW_SPRITE` with `texture=0` uses solid tint color only (no sampler). Texture handle system comes next.
|
||||
|
||||
**2026-06-18** -- GL backend uses GL 3.3 Core profile. Shader takes screen-space pixel coordinates and converts to clip space using window size queried from SDL each frame.
|
||||
|
||||
**2026-06-18** -- `ROPBUFFER` is a global (4096 slots × 32 bytes = 128 KB). Reset at start of each frame in `displayUpdate`.
|
||||
|
||||
**2026-06-18** -- `ui/`, `rpg/overworld` display code, asset display loaders all temporarily stubbed/disabled. Will be rewritten against the new render API.
|
||||
@@ -1,352 +0,0 @@
|
||||
# Display System
|
||||
|
||||
Source: `src/dusk/display/`
|
||||
|
||||
The display system is the rendering pipeline. It is abstracted across platforms via `displayplatform.h` — see [architecture.md](architecture.md) for the abstraction pattern. The current concrete backends are OpenGL (`src/duskgl/`) and GX/Dolphin (`src/duskdolphin/`).
|
||||
|
||||
For the planned render-queue refactor (required for Saturn), see [display-refactor.md](display-refactor.md).
|
||||
|
||||
---
|
||||
|
||||
## Render / ROP system (`display/render/`)
|
||||
|
||||
The ROP (Render OPcode) system is the low-level, backend-agnostic drawing API. All game drawing goes through this layer; backends (`rendergl.c`, `renderpsp.c`, `renderdolphin.c`) execute the commands at display flush time.
|
||||
|
||||
### API (`display/render/render.h`)
|
||||
|
||||
```c
|
||||
/* Clear the framebuffer */
|
||||
void renderClear(color_t color);
|
||||
|
||||
/* 2D textured quad at pixel coordinates */
|
||||
void renderSprite(
|
||||
int16_t x, int16_t y, int16_t w, int16_t h,
|
||||
int16_t depth, /* 0=front … 32767=back */
|
||||
rtexture_t texture, color_t tint
|
||||
);
|
||||
|
||||
/* Set perspective projection for subsequent 3D draws */
|
||||
void renderSetProjection(
|
||||
fixed_t fovY, fixed_t aspect, fixed_t nearZ, fixed_t farZ
|
||||
);
|
||||
|
||||
/* Set camera position/target for subsequent 3D draws */
|
||||
void renderSetView(
|
||||
int16_t eyeX, int16_t eyeY, int16_t eyeZ,
|
||||
int16_t tgtX, int16_t tgtY, int16_t tgtZ
|
||||
);
|
||||
|
||||
/* World-space quad: center point + right half-extent + up half-extent */
|
||||
void renderQuad3D(
|
||||
int16_t cx, int16_t cy, int16_t cz,
|
||||
int16_t rx, int16_t ry, int16_t rz,
|
||||
int16_t ux, int16_t uy, int16_t uz,
|
||||
int16_t depth,
|
||||
rtexture_t texture, color_t tint
|
||||
);
|
||||
|
||||
/* Create / dispose an 8-bit indexed palette texture */
|
||||
rtexture_t renderTextureCreate(
|
||||
uint16_t w, uint16_t h,
|
||||
const uint8_t *indices, /* w×h pixel indices (0-255) */
|
||||
const color_t *palette /* 256 RGBA colour entries */
|
||||
);
|
||||
void renderTextureDispose(rtexture_t tex);
|
||||
|
||||
/* Mutable pointers to the texture's CPU-side data.
|
||||
* Write directly to these; the next draw call picks up the changes.
|
||||
* GL: dirty flag set on getter call; glTexSubImage2D at next bind.
|
||||
* PSP: re-pads indices and converts palette → ABGR at bind time.
|
||||
* Dolphin: re-tiles CI8 and converts palette → RGB5A3 at bind time. */
|
||||
color_t *renderTextureGetPalette(rtexture_t tex); /* color_t[256] */
|
||||
uint8_t *renderTextureGetIndices(rtexture_t tex); /* uint8_t[w*h] */
|
||||
```
|
||||
|
||||
### Coordinate conventions
|
||||
|
||||
| Domain | Type | Scale | Notes |
|
||||
|---|---|---|---|
|
||||
| 3D world positions | `int16_t` | 1 unit = 1 cm | Matches PS1 GTE / N64 RSP native format |
|
||||
| Camera/projection params | `fixed_t` | Q24.8 | `FIXED(x)` for literals |
|
||||
| 2D screen positions | `int16_t` | pixels | Origin top-left |
|
||||
| UV coords | `uint8_t` | 0–255 → 0.0–1.0 | Stored in ROP structs |
|
||||
|
||||
### Palettized textures
|
||||
|
||||
All textures are 8-bit indexed. `renderTextureCreate` takes:
|
||||
- `indices`: one `uint8_t` per pixel (0–255), row-major
|
||||
- `palette`: exactly **256** `color_t` RGBA entries
|
||||
|
||||
**Per-platform storage:**
|
||||
|
||||
| Platform | CPU source of truth | GPU/native format | When derived |
|
||||
|---|---|---|---|
|
||||
| GL (Linux/Vita) | `color_t palette[256]` + `uint8_t *cpuIndices` in slot | `GL_R8` index tex + `GL_RGBA` 256×1 palette tex | Lazy: dirty flag set by getter, `glTexSubImage2D` at next bind |
|
||||
| PSP | `color_t palette[256]` + unpadded `uint8_t *cpuIndices` | Stride-padded indices (POT ≥ 8) + ABGR8888 CLUT in shared `pspAbgrBuf` | Every `bindTexture` call; dcache-flushed before GU reads |
|
||||
| Dolphin/GC/Wii | `color_t palette[256]` + unpadded `uint8_t *cpuIndices` | CI8 tiled (8×4 tiles, 32 B/tile) + RGB5A3 TLUT in `tlutData` | Every `bindTexture` call; `DCFlushRange` before GX load |
|
||||
|
||||
**GL palette shader detail**: The fragment shader samples the R8 index texture, converts the normalised float back to an exact texel centre with `raw*(255/256) + 0.5/256`, then looks up the 256×1 palette texture. This gives pixel-exact results for all 256 index values and allows independent real-time updates to indices or palette.
|
||||
|
||||
**Dolphin RGB5A3 encoding**:
|
||||
- Opaque (`a == 255`): bit 15 = 1, RGB555
|
||||
- Transparent: bit 15 = 0, A3RGB4 (alpha quantised to 3 bits — dithered transparency is planned for a future pass)
|
||||
|
||||
### ROP buffer (`display/render/ropbuffer.h` / `rop.h`)
|
||||
|
||||
Commands are written into `ROPBUFFER` (a static byte array) then replayed by the backend at flush time. All ops are fixed-size aligned structs:
|
||||
|
||||
| Op | Struct | Size |
|
||||
|---|---|---|
|
||||
| `ROP_CLEAR` | `ropclear_t` | 32 bytes |
|
||||
| `ROP_DRAW_SPRITE` | `ropsprite_t` | 32 bytes |
|
||||
| `ROP_SET_PROJECTION` | `ropprojection_t` | 32 bytes |
|
||||
| `ROP_SET_VIEW` | `ropview_t` | 32 bytes |
|
||||
| `ROP_DRAW_QUAD_3D` | `ropquad3d_t` | 64 bytes |
|
||||
| `ROP_DRAW_TILEMAP_CHUNK` | `roptilemapc_t` | 32 bytes |
|
||||
|
||||
`ropOpSize(op)` returns the byte size for any op. Backends iterate with `offset += ropOpSize(op)`.
|
||||
|
||||
### Texture handles (`display/render/rtexture.h`)
|
||||
|
||||
`rtexture_t` is a `uint16_t` index into the platform's texture table. `RTEXTURE_NONE` (0 or a sentinel) means "white fallback". Tables are platform-static; handles are valid until `renderTextureDispose` is called.
|
||||
|
||||
### Tilemap chunk handles (`display/render/rtilemapchunk.h`)
|
||||
|
||||
`rtilemapchunk_t` is a `uint16_t` index into the platform's chunk table. `RTILEMAPCHUNK_INVALID` (0) means no-op. Chunks are pre-built at map load time; each backend constructs its native draw structure once (VAO+VBO on GL, display list on PSP/GX/N64) and the ROP entry costs only a handle lookup + single native draw call per frame.
|
||||
|
||||
```c
|
||||
/* Build once at map load */
|
||||
rtilemapchunk_t chunk = renderTilemapChunkCreate(
|
||||
chunkW, chunkH, /* size in tiles */
|
||||
tileW, tileH, /* pixels per tile */
|
||||
tileset, /* rtexture_t of the packed tileset */
|
||||
tileIndices /* uint8_t[chunkW*chunkH], row-major tile indices */
|
||||
);
|
||||
|
||||
/* Each frame for visible chunks */
|
||||
renderTilemapChunk(screenX, screenY, depth, chunk);
|
||||
|
||||
/* At map unload */
|
||||
renderTilemapChunkDispose(chunk);
|
||||
```
|
||||
|
||||
Animated tiles should be drawn on top as separate `renderSprite()` calls; the chunk itself is treated as static geometry and never rebuilt at runtime.
|
||||
|
||||
**Per-platform build:**
|
||||
|
||||
| Platform | What's built at create time | Draw cost per frame |
|
||||
|---|---|---|
|
||||
| GL (Linux/Vita) | VAO + VBO (`GL_STATIC_DRAW`), `uOffset` uniform translates to screen pos | 1 `glDrawArrays` |
|
||||
| PSP | GU display list in uncached EDRAM | 1 `sceGuCallList` |
|
||||
| GC/Wii | Compiled GX display list | 1 `GX_CallDispList` |
|
||||
| PS1 | Pre-linked POLY_FT4/SPRT chain | Linked into OT at one slot |
|
||||
| N64 | RDP display list with pre-scheduled `LOAD_TILE` batches (TMEM-aware) | 1 `gSPDisplayList` |
|
||||
| Saturn | VDP2 plane config + VRAM tilemap data | Scroll register write only |
|
||||
|
||||
---
|
||||
|
||||
## Initialization order
|
||||
|
||||
Within the display system, init must follow this order (enforced in `engine.c`):
|
||||
|
||||
```
|
||||
displayInit → uiInit → uiTextboxInit
|
||||
```
|
||||
|
||||
Within `displayInit`, the platform typically initialises: framebuffer → screen → shader list → textures → spritebatch → text system.
|
||||
|
||||
---
|
||||
|
||||
## `display_t` / `displaystate_t`
|
||||
|
||||
`display_t DISPLAY` is the global display instance (type alias for `displayplatform_t`).
|
||||
|
||||
`displaystate_t` carries per-draw-call render state flags:
|
||||
|
||||
```c
|
||||
DISPLAY_STATE_FLAG_CULL // face culling
|
||||
DISPLAY_STATE_FLAG_DEPTH_TEST // depth testing
|
||||
DISPLAY_STATE_FLAG_BLEND // alpha blending
|
||||
```
|
||||
|
||||
Set state before drawing with `displaySetState(state)`.
|
||||
|
||||
---
|
||||
|
||||
## Screen (`display/screen/`)
|
||||
|
||||
`screen_t SCREEN` manages the logical viewport that game content renders into. On dynamic-size platforms (Linux/SDL2) the screen can differ from the native window/framebuffer resolution.
|
||||
|
||||
Screen modes:
|
||||
```
|
||||
SCREEN_MODE_BACKBUFFER — maps 1:1 to backbuffer
|
||||
SCREEN_MODE_FIXED_SIZE — fixed pixel dimensions
|
||||
SCREEN_MODE_ASPECT_RATIO — fixed aspect, scale to fit
|
||||
SCREEN_MODE_FIXED_HEIGHT — fixed height, width scales
|
||||
SCREEN_MODE_FIXED_WIDTH — fixed width, height scales
|
||||
SCREEN_MODE_FIXED_VIEWPORT_HEIGHT — fixed viewport height
|
||||
```
|
||||
|
||||
The linux target defines `DUSK_DISPLAY_SCREEN_HEIGHT=240`, producing a 240p fixed-height viewport.
|
||||
|
||||
Render loop usage:
|
||||
```c
|
||||
screenBind(); // set up viewport, projection
|
||||
// ... draw game content ...
|
||||
screenUnbind();
|
||||
screenRender(); // blit to backbuffer / current framebuffer
|
||||
```
|
||||
|
||||
`SCREEN.width` / `SCREEN.height` are the logical dimensions used for world-to-screen math — always prefer these over the framebuffer dimensions.
|
||||
|
||||
---
|
||||
|
||||
## Framebuffer (`display/framebuffer/`)
|
||||
|
||||
`framebuffer_t FRAMEBUFFER_BACKBUFFER` is the platform backbuffer. `FRAMEBUFFER_BOUND` points to the currently-bound framebuffer (or `NULL` for backbuffer).
|
||||
|
||||
```c
|
||||
frameBufferInitBackBuffer(); // called once at startup
|
||||
frameBufferBind(fb); // NULL → backbuffer
|
||||
frameBufferClear(FRAMEBUFFER_CLEAR_COLOR | FRAMEBUFFER_CLEAR_DEPTH, COLOR_BLACK);
|
||||
frameBufferGetWidth(fb) / frameBufferGetHeight(fb) / frameBufferGetAspect(fb);
|
||||
```
|
||||
|
||||
On platforms with `DUSK_DISPLAY_SIZE_DYNAMIC`, off-screen framebuffers can be created with `frameBufferInit(fb, w, h)` and disposed with `frameBufferDispose(fb)`. Fixed-resolution platforms (PSP, GameCube) only ever use the backbuffer.
|
||||
|
||||
---
|
||||
|
||||
## Mesh (`display/mesh/`)
|
||||
|
||||
`mesh_t` is a vertex buffer. The type is `meshplatform_t` (e.g. a VAO+VBO on GL, a GX display list on Dolphin).
|
||||
|
||||
```c
|
||||
meshInit(&mesh, MESH_PRIMITIVE_TYPE_TRIANGLES, vertexCount, verticesPtr);
|
||||
meshFlush(&mesh, offset, count); // upload CPU vertices → GPU
|
||||
meshDraw(&mesh, offset, count); // draw; pass -1 for count to draw all
|
||||
meshDispose(&mesh);
|
||||
```
|
||||
|
||||
**Key distinction**: `meshFlush` uploads data to GPU memory; `meshDraw` issues the draw call. For static geometry (chunk meshes) you call `meshFlush` once on load, then `meshDraw` every frame. For dynamic geometry (spritebatch) you `meshFlush` + `meshDraw` each frame.
|
||||
|
||||
`meshvertex_t` (`display/mesh/meshvertex.h`) contains:
|
||||
- `float_t uv[2]` — texture coordinates
|
||||
- `float_t pos[3]` — position
|
||||
- Optionally `color_t color` if `MESH_ENABLE_COLOR` is defined (off by default)
|
||||
|
||||
Primitive mesh generators live alongside `mesh.h`: `quad.h`, `plane.h`, `cube.h`, `sphere.h`, `capsule.h`, `triprism.h`.
|
||||
|
||||
---
|
||||
|
||||
## Shader (`display/shader/`)
|
||||
|
||||
`shader_t` is `shaderplatform_t` (GLSL program on GL, TEV state block on Dolphin).
|
||||
|
||||
```c
|
||||
shaderInit(&shader, &definition);
|
||||
shaderBind(&shader);
|
||||
shaderSetMatrix(&shader, "uModel", modelMat);
|
||||
shaderSetTexture(&shader, "uTexture", &texture);
|
||||
shaderSetColor(&shader, "uColor", COLOR_WHITE);
|
||||
shaderSetMaterial(&shader, &material);
|
||||
shaderDispose(&shader);
|
||||
```
|
||||
|
||||
### Shader list (`display/shader/shaderlist.h`)
|
||||
|
||||
The engine maintains a small set of built-in shaders in `SHADER_LIST_DEFS[]`. Currently only one is defined:
|
||||
|
||||
- `SHADER_LIST_SHADER_UNLIT` → `SHADER_UNLIT` — unlit textured/colored rendering, used for all world and entity drawing.
|
||||
|
||||
`shaderListInit()` compiles/uploads all built-in shaders and sets shared projection/view matrices. Call once after display init.
|
||||
|
||||
### Materials (`display/shader/shadermaterial.h`)
|
||||
|
||||
`shadermaterial_t` is a union of all shader-specific material structs. Currently only `shaderunlitmaterial_t`:
|
||||
|
||||
```c
|
||||
shadermaterial_t mat = {
|
||||
.unlit = {
|
||||
.color = COLOR_WHITE,
|
||||
.texture = &myTexture, // NULL for solid color
|
||||
}
|
||||
};
|
||||
shaderSetMaterial(&SHADER_UNLIT, &mat);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Texture (`display/texture/`)
|
||||
|
||||
```c
|
||||
textureInit(&texture, width, height, format, data);
|
||||
textureDispose(&texture);
|
||||
```
|
||||
|
||||
Width and height **must be powers of two** (asserted at init time).
|
||||
|
||||
`textureformat_t` is `textureformatplatform_t`. Supported formats vary by platform; the common ones are `TEXTURE_FORMAT_RGBA` and `TEXTURE_FORMAT_PALETTE`.
|
||||
|
||||
`texturedata_t` is a union:
|
||||
```c
|
||||
// RGBA:
|
||||
data.rgbaColors = colorArray;
|
||||
|
||||
// Paletted:
|
||||
data.paletted.indices = indexArray;
|
||||
data.paletted.palette = &palette; // palette color count must be power of two
|
||||
```
|
||||
|
||||
**Built-in textures** (defined in `texture.c`, no asset loading needed):
|
||||
- `TEXTURE_WHITE` — 4×4 solid white
|
||||
- `TEXTURE_TEST` — 4×4 black/magenta checkerboard
|
||||
|
||||
### Palette (`display/texture/palette.h`)
|
||||
|
||||
Up to `PALETTE_COUNT` (6) global palettes in `PALETTES[]`, each holding up to `PALETTE_COLOR_COUNT` (255) `color_t` entries.
|
||||
|
||||
### Tileset (`display/texture/tileset.h`)
|
||||
|
||||
A tileset slices a texture into a grid of equal-sized tiles. Used by fonts and UI frames. The tileset does not own the texture — it references a `texture_t *`.
|
||||
|
||||
---
|
||||
|
||||
## SpriteBatch (`display/spritebatch/`)
|
||||
|
||||
The primary 2D/billboard drawing primitive. Accumulates `spritebatchsprite_t` quads and flushes them in batches of `SPRITEBATCH_FLUSH_COUNT` (16) sprites at a time.
|
||||
|
||||
```c
|
||||
// Per frame:
|
||||
spriteBatchClear();
|
||||
spriteBatchBuffer(sprites, count, &SHADER_UNLIT, material); // auto-flushes when batch full
|
||||
spriteBatchFlush(); // flush remaining
|
||||
|
||||
// Low-level: write directly to an external mesh (for baking static geometry):
|
||||
spriteBatchBufferToMesh(sprites, count, vertices, verticesSize);
|
||||
```
|
||||
|
||||
`spritebatchsprite_t`:
|
||||
```c
|
||||
typedef struct {
|
||||
vec3 min, max; // 3D bounding box
|
||||
vec2 uvMin, uvMax; // texture region
|
||||
} spritebatchsprite_t;
|
||||
```
|
||||
|
||||
The global `SPRITEBATCH` and its vertex backing array `SPRITEBATCH_VERTICES[]` are defined externally to the struct to satisfy alignment requirements on certain platforms.
|
||||
|
||||
---
|
||||
|
||||
## Text (`display/text/`)
|
||||
|
||||
Text rendering uses `FONT_DEFAULT` (loaded during `textInit()`), which references a texture and a tileset. Characters start at ASCII `!` (`TEXT_CHAR_START`).
|
||||
|
||||
```c
|
||||
textDraw(x, y, "Hello", COLOR_WHITE, &FONT_DEFAULT);
|
||||
textMeasure("Hello", &FONT_DEFAULT, &outWidth, &outHeight);
|
||||
|
||||
// Single-char sprite for manual layout:
|
||||
spritebatchsprite_t s = textGetSprite(pos, 'A', &FONT_DEFAULT);
|
||||
```
|
||||
|
||||
`font_t` holds a `texture_t *` and a `tileset_t *` — both are owned by the asset system, not the font struct.
|
||||
@@ -1,93 +0,0 @@
|
||||
# Input System
|
||||
|
||||
Source: `src/dusk/input/`
|
||||
|
||||
The input system decouples physical hardware buttons from logical game actions via a binding layer. Actions are defined in `src/dusk/input/input.csv` and code-generated into `inputaction_t` enum values — see [architecture.md](architecture.md#code-generation-from-csv).
|
||||
|
||||
---
|
||||
|
||||
## Concepts
|
||||
|
||||
**Button** (`inputbutton_t`) — a physical input source: a keyboard scancode, gamepad button, gamepad axis, or pointer axis. The available button types depend on which `DUSK_INPUT_*` defines are active for the target platform.
|
||||
|
||||
**Action** (`inputaction_t`) — a logical game input (e.g. `INPUT_ACTION_UP`, `INPUT_ACTION_CONFIRM`, `INPUT_ACTION_RAGEQUIT`). Each action accumulates a float value `[0.0, 1.0]` from all buttons bound to it.
|
||||
|
||||
**Binding** — a many-to-one mapping from buttons to actions. Bindings are registered at runtime with `inputBind(button, action)`.
|
||||
|
||||
---
|
||||
|
||||
## Querying actions
|
||||
|
||||
```c
|
||||
// Boolean helpers (current frame):
|
||||
inputIsDown(action) // value > 0 this frame
|
||||
inputPressed(action) // down this frame but not last
|
||||
inputReleased(action) // down last frame but not this
|
||||
|
||||
// Last frame state:
|
||||
inputWasDown(action)
|
||||
|
||||
// Raw float value:
|
||||
inputGetCurrentValue(action) // [0.0, 1.0]
|
||||
inputGetLastValue(action)
|
||||
|
||||
// Axis helpers — combine two opposing actions into a signed float:
|
||||
float_t h = inputAxis(INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT); // -1.0 to 1.0
|
||||
inputAxis2D(negX, posX, negY, posY, result); // fills vec2
|
||||
inputAngle2D(negX, posX, negY, posY, result); // atan2-based normalized direction
|
||||
|
||||
// Deadzone:
|
||||
float_t clean = inputDeadzone(rawValue, 0.1f);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Dynamic values (`DUSK_TIME_DYNAMIC`)
|
||||
|
||||
On platforms with variable frame rates, each action also tracks `dynamicDelta`-scaled values:
|
||||
|
||||
```c
|
||||
inputGetCurrentValueDynamic(action)
|
||||
inputGetLastValueDynamic(action)
|
||||
```
|
||||
|
||||
These account for the actual time elapsed since the last frame, so movement calculated from them is frame-rate independent.
|
||||
|
||||
---
|
||||
|
||||
## Events on actions
|
||||
|
||||
Each `inputactiondata_t` exposes `onPressed` and `onReleased` events:
|
||||
|
||||
```c
|
||||
eventSubscribe(&INPUT.actions[INPUT_ACTION_CONFIRM].onPressed, myCallback, myUser);
|
||||
```
|
||||
|
||||
The callback signature is `void cb(void *params, void *user)`. `params` is always `NULL` for input events.
|
||||
|
||||
---
|
||||
|
||||
## Buttons and bindings
|
||||
|
||||
Physical buttons are typed via `inputbuttontype_t`:
|
||||
|
||||
| Constant | When available | Payload |
|
||||
|---|---|---|
|
||||
| `INPUT_BUTTON_TYPE_KEYBOARD` | `DUSK_INPUT_KEYBOARD` | `inputscancode_t` |
|
||||
| `INPUT_BUTTON_TYPE_GAMEPAD` | `DUSK_INPUT_GAMEPAD` | `inputgamepadbutton_t` |
|
||||
| `INPUT_BUTTON_TYPE_GAMEPAD_AXIS` | `DUSK_INPUT_GAMEPAD` | axis + positive direction flag |
|
||||
| `INPUT_BUTTON_TYPE_POINTER` | `DUSK_INPUT_POINTER` | `inputpointeraxis_t` |
|
||||
|
||||
Button names and default bindings are defined in `input.csv`. Look up a button by name:
|
||||
```c
|
||||
inputbutton_t btn = inputButtonGetByName("keyboard_w");
|
||||
inputBind(btn, INPUT_ACTION_UP);
|
||||
```
|
||||
|
||||
`INPUT_BUTTON_DATA[]` holds runtime state (current/last raw values) for every physical button.
|
||||
|
||||
---
|
||||
|
||||
## Platform platform-specific reads
|
||||
|
||||
`inputButtonGetValuePlatform(button)` is the one required platform function — it returns the current raw `[0.0, 1.0]` value for a button. The platform implementations live in `src/dusk{platform}/input/`.
|
||||
@@ -1,149 +0,0 @@
|
||||
# Cutscenes
|
||||
|
||||
Two distinct layers: a low-level engine sequencer (`src/dusk/cutscene/`) and a higher-level RPG wrapper (`src/dusk/rpg/cutscene/`). Almost all game code works with the RPG layer.
|
||||
|
||||
---
|
||||
|
||||
## Engine sequencer (`src/dusk/cutscene/`)
|
||||
|
||||
`cutscene_t CUTSCENE` is a minimal event runner with up to `CUTSCENE_EVENT_COUNT_MAX` (16) `cutsceneevent_t` slots. Each event has three callbacks:
|
||||
|
||||
```c
|
||||
typedef struct {
|
||||
errorret_t (*onStart)(void);
|
||||
errorret_t (*onUpdate)(void);
|
||||
errorret_t (*onEnd)(void);
|
||||
} cutsceneevent_t;
|
||||
```
|
||||
|
||||
API:
|
||||
```c
|
||||
cutscenePlay(events, count); // copy events array and start from index 0
|
||||
cutsceneAdvance(); // end current event, start next (deactivates after last)
|
||||
cutsceneStop(); // abort immediately
|
||||
cutsceneIsActive(); // bool
|
||||
```
|
||||
|
||||
This layer is primarily used by the RPG cutscene system — game code doesn't normally touch it directly.
|
||||
|
||||
---
|
||||
|
||||
## RPG cutscene layer (`src/dusk/rpg/cutscene/`)
|
||||
|
||||
### Data structures
|
||||
|
||||
A `cutscene_t` is just a pointer to an item array and a count:
|
||||
|
||||
```c
|
||||
typedef struct cutscene_s {
|
||||
const cutsceneitem_t *items;
|
||||
uint8_t itemCount;
|
||||
} cutscene_t;
|
||||
```
|
||||
|
||||
A `cutsceneitem_t` is a tagged union of all item types:
|
||||
|
||||
```c
|
||||
typedef struct cutsceneitem_s {
|
||||
cutsceneitemtype_t type;
|
||||
union {
|
||||
cutscenetext_t text; // display text in textbox
|
||||
cutscenecallback_t callback; // call a void(*)(void) function
|
||||
cutscenewait_t wait; // pause for a fixed_t duration (seconds)
|
||||
const cutscene_t *cutscene; // nest another cutscene
|
||||
};
|
||||
} cutsceneitem_t;
|
||||
```
|
||||
|
||||
### Item types
|
||||
|
||||
| Type constant | Payload | Behaviour |
|
||||
|---|---|---|
|
||||
| `CUTSCENE_ITEM_TYPE_TEXT` | `cutscenetext_t` — `text[256]` + `rpgtextboxpos_t position` | Shows textbox; advances on player confirm input |
|
||||
| `CUTSCENE_ITEM_TYPE_CALLBACK` | `cutscenecallback_t` (function pointer) | Calls the function once, then immediately advances |
|
||||
| `CUTSCENE_ITEM_TYPE_WAIT` | `cutscenewait_t` (a `fixed_t` in seconds) | Counts down `animTime` each frame, then advances |
|
||||
| `CUTSCENE_ITEM_TYPE_CUTSCENE` | `const cutscene_t *` | Plays the nested cutscene before continuing |
|
||||
|
||||
### Runtime state
|
||||
|
||||
`cutscenesystem_t CUTSCENE_SYSTEM` tracks:
|
||||
- `scene` — pointer to the active `cutscene_t`
|
||||
- `currentItem` — index into `scene->items[]`
|
||||
- `data` — per-item runtime data (`cutsceneitemdata_t`, currently just `cutscenewaitdata_t`)
|
||||
- `mode` — the current `cutscenemode_t`
|
||||
|
||||
API:
|
||||
```c
|
||||
cutsceneSystemStartCutscene(cutscene); // begin playing a cutscene
|
||||
cutsceneSystemNext(); // advance to next item
|
||||
cutsceneSystemUpdate(); // called each frame from rpgUpdate
|
||||
cutsceneSystemGetCurrentItem(); // inspect active item
|
||||
```
|
||||
|
||||
### Cutscene mode (`cutscenemode.h`)
|
||||
|
||||
Each item can run in one of three modes:
|
||||
|
||||
```c
|
||||
CUTSCENE_MODE_NONE // no cutscene active
|
||||
CUTSCENE_MODE_FULL_FREEZE // pause everything (not yet used)
|
||||
CUTSCENE_MODE_INPUT_FREEZE // player input blocked (default: CUTSCENE_MODE_INITIAL)
|
||||
CUTSCENE_MODE_GAMEPLAY // player can still move during cutscene
|
||||
```
|
||||
|
||||
`cutsceneModeIsInputAllowed()` is checked by `entityUpdate()` before invoking the movement callback — the player cannot walk when in INPUT_FREEZE mode.
|
||||
|
||||
### Defining a cutscene
|
||||
|
||||
Cutscenes are defined as `static const` arrays in header files under `rpg/cutscene/scene/`. Example (`testcutscene.h`):
|
||||
|
||||
```c
|
||||
static const cutsceneitem_t MY_CUTSCENE_ITEMS[] = {
|
||||
{
|
||||
.type = CUTSCENE_ITEM_TYPE_TEXT,
|
||||
.text = { .text = "Hello!", .position = RPG_TEXTBOX_POS_BOTTOM }
|
||||
},
|
||||
{
|
||||
.type = CUTSCENE_ITEM_TYPE_WAIT,
|
||||
.wait = FIXED(1.5f)
|
||||
},
|
||||
{
|
||||
.type = CUTSCENE_ITEM_TYPE_CUTSCENE,
|
||||
.cutscene = &ANOTHER_CUTSCENE
|
||||
},
|
||||
};
|
||||
|
||||
static const cutscene_t MY_CUTSCENE = {
|
||||
.items = MY_CUTSCENE_ITEMS,
|
||||
.itemCount = sizeof(MY_CUTSCENE_ITEMS) / sizeof(cutsceneitem_t)
|
||||
};
|
||||
```
|
||||
|
||||
Attach to an NPC via its interact component:
|
||||
```c
|
||||
entity->interact.type = ENTITY_INTERACT_CUTSCENE;
|
||||
entity->interact.data.cutscene = &MY_CUTSCENE;
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Textbox (`src/dusk/rpg/rpgtextbox.h`)
|
||||
|
||||
`rpgtextbox_t RPG_TEXTBOX` is the global textbox state:
|
||||
|
||||
```c
|
||||
typedef struct {
|
||||
rpgtextboxpos_t position; // RPG_TEXTBOX_POS_TOP or RPG_TEXTBOX_POS_BOTTOM
|
||||
bool_t visible;
|
||||
char_t text[RPG_TEXTBOX_MAX_CHARS]; // 256 chars
|
||||
} rpgtextbox_t;
|
||||
```
|
||||
|
||||
API:
|
||||
```c
|
||||
rpgTextboxShow(position, text); // copies text, sets visible = true
|
||||
rpgTextboxHide(); // sets visible = false
|
||||
rpgTextboxIsVisible(); // bool
|
||||
```
|
||||
|
||||
The textbox state is read by `ui/uitextbox.c` during the UI render pass to draw the dialogue box on screen. `rpgtextbox.c` itself does no rendering.
|
||||
@@ -1,140 +0,0 @@
|
||||
# Entities
|
||||
|
||||
Source: `src/dusk/rpg/entity/`
|
||||
|
||||
---
|
||||
|
||||
## Storage
|
||||
|
||||
Entities live in a single fixed global array:
|
||||
|
||||
```c
|
||||
entity_t ENTITIES[ENTITY_COUNT]; // ENTITY_COUNT = 64
|
||||
```
|
||||
|
||||
A slot is "empty" when `entity->type == ENTITY_TYPE_NULL`. Never allocate entity memory dynamically — always find a free slot with `entityGetAvailable()`, which returns its index (`0xFF` if none free).
|
||||
|
||||
---
|
||||
|
||||
## `entity_t` structure
|
||||
|
||||
```c
|
||||
typedef struct entity_s {
|
||||
uint8_t id; // index in ENTITIES[]
|
||||
entitytype_t type; // ENTITY_TYPE_NULL / PLAYER / NPC
|
||||
entitytypedata_t data; // union: player_t | npc_t
|
||||
|
||||
entitydir_t direction; // facing direction (N/S/E/W)
|
||||
fixed_t position[3]; // current sub-tile position (x, y, z)
|
||||
fixed_t lastPosition[3]; // position before last move (for interpolation)
|
||||
|
||||
entityanim_t animation; // IDLE / TURN / WALK
|
||||
fixed_t animTime; // countdown timer for current animation
|
||||
|
||||
entityinteract_t interact; // optional interact component
|
||||
} entity_t;
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Type system
|
||||
|
||||
Entity types are defined in `entitytype.h` using the enum+integer-typedef pattern:
|
||||
|
||||
```c
|
||||
typedef enum { ENTITY_TYPE_NULL, ENTITY_TYPE_PLAYER, ENTITY_TYPE_NPC, ENTITY_TYPE_COUNT } entitytype_enum_t;
|
||||
typedef uint8_t entitytype_t;
|
||||
```
|
||||
|
||||
Each type has a `entitycallback_t` entry in the `ENTITY_CALLBACKS[ENTITY_TYPE_COUNT]` static table:
|
||||
|
||||
```c
|
||||
typedef struct {
|
||||
void (*init)(entity_t *entity);
|
||||
void (*movement)(entity_t *entity);
|
||||
bool_t (*interact)(entity_t *player, entity_t *entity);
|
||||
} entitycallback_t;
|
||||
```
|
||||
|
||||
Callbacks not applicable to a type are `NULL`; `entityUpdate()` guards against this before calling.
|
||||
|
||||
Type-specific data sits in `entitytypedata_t` (a union of `player_t` and `npc_t`). Currently both are stubs (`void *nothing`).
|
||||
|
||||
---
|
||||
|
||||
## Direction (`entitydir.h`)
|
||||
|
||||
```c
|
||||
ENTITY_DIR_NORTH / EAST / SOUTH / WEST
|
||||
```
|
||||
|
||||
Aliases: `UP = NORTH`, `DOWN = SOUTH`, `LEFT = WEST`, `RIGHT = EAST`.
|
||||
|
||||
Utilities:
|
||||
- `entityDirGetOpposite(dir)` — returns the opposite direction.
|
||||
- `entityDirGetRelative(dir, &relX, &relY)` — fills in the ±1 XY delta for that direction.
|
||||
- `assertValidEntityDir(dir, msg)` — assertion macro.
|
||||
|
||||
---
|
||||
|
||||
## Animation (`entityanim.h`)
|
||||
|
||||
```c
|
||||
ENTITY_ANIM_IDLE // standing still
|
||||
ENTITY_ANIM_TURN // turning to a new direction (ENTITY_ANIM_TURN_DURATION = FIXED(0.06))
|
||||
ENTITY_ANIM_WALK // mid-step (ENTITY_ANIM_WALK_DURATION = FIXED(0.1))
|
||||
```
|
||||
|
||||
`entityAnimUpdate(entity)` decrements `animTime` each frame and transitions back to `IDLE` when it reaches zero.
|
||||
|
||||
`entityCanWalk(entity)` / `entityCanTurn(entity)` both return true only when `animation == ENTITY_ANIM_IDLE`.
|
||||
|
||||
The renderer interpolates between `lastPosition` and `position` using `animTime / WALK_DURATION` to produce smooth motion even at low frame rates.
|
||||
|
||||
---
|
||||
|
||||
## Movement
|
||||
|
||||
`entityWalk(entity, direction)`:
|
||||
|
||||
1. Converts `entity->position` to a `worldpos_t` (truncates fractional part).
|
||||
2. Applies the directional delta to get `newPos`.
|
||||
3. Checks the current and target tiles for ramp raise/fall logic (see [world.md](world.md)).
|
||||
4. Checks `ENTITIES[]` for another entity occupying `newPos` — blocks if found.
|
||||
5. On success: copies `position` to `lastPosition`, updates `position` to `newPos` (via `worldPosToFixed`), sets `animation = ENTITY_ANIM_WALK`.
|
||||
|
||||
`entityTurn(entity, direction)`: sets `direction` and starts a brief turn animation.
|
||||
|
||||
---
|
||||
|
||||
## Interaction (`entityinteract.h`)
|
||||
|
||||
The `entityinteract_t` component is embedded in every entity. It is optional — set `type = ENTITY_INTERACT_NULL` for non-interactable entities.
|
||||
|
||||
```c
|
||||
typedef enum {
|
||||
ENTITY_INTERACT_NULL,
|
||||
ENTITY_INTERACT_CUTSCENE, // plays a cutscene_t *
|
||||
ENTITY_INTERACT_PRINT, // prints a short message[32]
|
||||
} entityinteracttype_t;
|
||||
```
|
||||
|
||||
`entityInteractWith(player, target)` dispatches:
|
||||
1. If the interact component's `type != NULL`, handles it (starts the cutscene or prints the message).
|
||||
2. Otherwise falls back to `ENTITY_CALLBACKS[type].interact` if set.
|
||||
|
||||
---
|
||||
|
||||
## Player (`player.h` / `player.c`)
|
||||
|
||||
`playerInit()` is called via `ENTITY_CALLBACKS[ENTITY_TYPE_PLAYER].init`.
|
||||
|
||||
`playerInput(entity)` is the movement callback. It reads `PLAYER_INPUT_DIR_MAP[]` — a static table mapping input actions (`INPUT_ACTION_UP/DOWN/LEFT/RIGHT`) to entity directions — and calls `entityWalk` or `entityTurn` accordingly.
|
||||
|
||||
The player entity is normally `ENTITIES[0]` but there is no hardcoded assumption about its index beyond being initialized with `ENTITY_TYPE_PLAYER`.
|
||||
|
||||
---
|
||||
|
||||
## NPC (`npc.h` / `npc.c`)
|
||||
|
||||
`npcInit()`, `npcMovement()`, and `npcInteract()` provide the NPC type callbacks. Currently stubs; movement does nothing, interact returns false.
|
||||
@@ -1,18 +0,0 @@
|
||||
# RPG Layer
|
||||
|
||||
The RPG layer lives in `src/dusk/rpg/` and is the game-logic tier above the engine. It is initialized and ticked by `engine.c` via `rpgInit` / `rpgUpdate` / `rpgDispose`. The `rpg_t` struct is currently a stub; all meaningful state lives in the subsystems below.
|
||||
|
||||
## Contents
|
||||
|
||||
- [world.md](world.md) — scene manager, overworld map, chunks, tiles, coordinate system, camera
|
||||
- [entity.md](entity.md) — entity pool, types, direction, animation, interaction, player, NPC
|
||||
- [cutscene.md](cutscene.md) — cutscene system, item types, mode control, textbox
|
||||
- [story.md](story.md) — story flags, items, inventory, backpack, save system
|
||||
|
||||
## Scene system
|
||||
|
||||
The scene manager (`src/dusk/scene/`) sits above the RPG layer and owns the single active scene. Scenes are identified by `scenetype_t` and registered in `SCENE_TYPES[]` (`scene/scenetype.c`) as `scenecallbacks_t` (init / update / render / dispose).
|
||||
|
||||
`scenedata_t` is a union so all scene structs share memory. `sceneSet(type)` defers the transition — the old scene disposes before the new one inits.
|
||||
|
||||
Currently the only scene is `SCENE_TYPE_OVERWORLD` → `src/dusk/scene/overworld/sceneoverworld.c`.
|
||||
@@ -1,124 +0,0 @@
|
||||
# Story, Items & Save
|
||||
|
||||
---
|
||||
|
||||
## Story flags (`src/dusk/rpg/story/`)
|
||||
|
||||
Story flags are the primary mechanism for tracking game-world state (quest progress, one-time events, unlocks). Each flag is a `uint8_t` value (`storyflagvalue_t`), so they can hold booleans or small counts.
|
||||
|
||||
### Defining flags
|
||||
|
||||
Flags are defined in `src/dusk/rpg/story/storyflag.csv`:
|
||||
|
||||
```
|
||||
id,description,initial
|
||||
test,"Test flag for debugging purposes",1
|
||||
```
|
||||
|
||||
The build tool generates:
|
||||
- A `storyflag_t` enum (e.g. `STORY_FLAG_TEST`) in the generated header.
|
||||
- `STORY_FLAG_VALUES[]` — the runtime array, pre-populated with the `initial` column values.
|
||||
|
||||
To add a flag: add a row to the CSV. The build re-runs the Python tool automatically on the next CMake build.
|
||||
|
||||
### Access
|
||||
|
||||
```c
|
||||
storyflagvalue_t v = storyFlagGet(STORY_FLAG_TEST); // macro: array read
|
||||
storyFlagSet(STORY_FLAG_TEST, 1); // function: also marks save dirty
|
||||
```
|
||||
|
||||
`storyFlagGet` is a macro that directly indexes `STORY_FLAG_VALUES[]` — no function call overhead.
|
||||
|
||||
---
|
||||
|
||||
## Items (`src/dusk/rpg/item/`)
|
||||
|
||||
### Item definitions
|
||||
|
||||
Items are defined in `src/dusk/rpg/item/item.csv`. The build tool generates `itemid_t` enum values and item metadata. `itemid_t` is a generated `uint8_t` typedef.
|
||||
|
||||
### Inventory (`inventory.h`)
|
||||
|
||||
`inventory_t` is a generic container backed by a caller-supplied `inventorystack_t` array:
|
||||
|
||||
```c
|
||||
typedef struct {
|
||||
itemid_t item;
|
||||
uint8_t quantity; // max ITEM_STACK_QUANTITY_MAX (255)
|
||||
} inventorystack_t;
|
||||
|
||||
typedef struct {
|
||||
inventorystack_t *storage;
|
||||
uint8_t storageSize;
|
||||
} inventory_t;
|
||||
```
|
||||
|
||||
Key operations:
|
||||
|
||||
```c
|
||||
inventoryInit(&inv, storageArray, size);
|
||||
inventoryAdd(&inv, ITEM_POTION, 3);
|
||||
inventoryRemove(&inv, ITEM_POTION);
|
||||
inventorySet(&inv, ITEM_POTION, 10);
|
||||
inventoryGetCount(&inv, ITEM_POTION); // returns 0 if not present
|
||||
inventoryItemExists(&inv, ITEM_POTION);
|
||||
inventoryIsFull(&inv);
|
||||
inventorySort(&inv, INVENTORY_SORT_BY_ID, false);
|
||||
```
|
||||
|
||||
`inventory_t` itself holds no data — the backing array is always external. This avoids fixed-size struct limits and lets different inventories (backpack, shop, chest) share the same logic.
|
||||
|
||||
### Backpack (`backpack.h`)
|
||||
|
||||
The player's inventory is the global `BACKPACK` instance:
|
||||
|
||||
```c
|
||||
extern inventorystack_t BACKPACK_STORAGE[BACKPACK_STORAGE_SIZE_MAX]; // 20 slots
|
||||
extern inventory_t BACKPACK;
|
||||
|
||||
backpackInit(); // wires BACKPACK_STORAGE into BACKPACK
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Save system (`src/dusk/save/`)
|
||||
|
||||
The save system is stubbed out — it exists and compiles but is commented out of engine init (`engine.c`). What follows describes the design as implemented.
|
||||
|
||||
### Slots
|
||||
|
||||
`save_t SAVE` holds `SAVE_FILE_COUNT_MAX` slots:
|
||||
|
||||
```c
|
||||
typedef struct {
|
||||
savefile_t files[SAVE_FILE_COUNT_MAX];
|
||||
saveplatform_t platform; // platform-specific state (paths, card handles)
|
||||
} save_t;
|
||||
```
|
||||
|
||||
### Streams
|
||||
|
||||
`savestream_t` (`save/savestream.h`) is a raw byte cursor used to serialize/deserialize `savefile_t`. Platform backends in `src/dusk{platform}/save/` implement the actual I/O:
|
||||
- Linux: filesystem files in a save directory.
|
||||
- GameCube/Wii: memory card via libogc.
|
||||
|
||||
### API
|
||||
|
||||
```c
|
||||
saveInit();
|
||||
saveLoad(slot); // reads platform storage → savefile_t
|
||||
saveWrite(slot); // writes savefile_t → platform storage
|
||||
saveDelete(slot);
|
||||
saveExists(slot); // bool
|
||||
saveGet(slot); // returns savefile_t *
|
||||
saveDispose();
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Locale / i18n (`src/dusk/locale/`)
|
||||
|
||||
Translations are loaded from `.po` files in `assets/locale/` (e.g. `en_US.po`). `localemanager.c` manages the active locale and exposes a key→string lookup. `assetlocaleloader.c` parses the PO format via the asset system.
|
||||
|
||||
All player-visible strings must go through the locale system rather than being hardcoded. The locale is loaded asynchronously via the asset system so it is available before the first scene renders.
|
||||
@@ -1,114 +0,0 @@
|
||||
# World
|
||||
|
||||
Source: `src/dusk/rpg/overworld/`
|
||||
|
||||
---
|
||||
|
||||
## Coordinate system
|
||||
|
||||
Three nested coordinate spaces, each defined in `worldpos.h`:
|
||||
|
||||
| Type | Description | Unit |
|
||||
|---|---|---|
|
||||
| `worldpos_t` | Tile-level absolute position `{x, y, z}` | `worldunit_t` (int16) |
|
||||
| `chunkpos_t` | Chunk-grid position `{x, y, z}` | `chunkunit_t` (int16) |
|
||||
| `fixed_t[3]` | Smooth sub-tile position used by entities | Q24.8 fixed-point |
|
||||
|
||||
One chunk = `CHUNK_WIDTH × CHUNK_HEIGHT × CHUNK_DEPTH` tiles (16 × 16 × 8).
|
||||
The loaded world window = `MAP_CHUNK_WIDTH × MAP_CHUNK_HEIGHT × MAP_CHUNK_DEPTH` chunks (5 × 5 × 3).
|
||||
|
||||
Conversion helpers (all in `worldpos.c`):
|
||||
|
||||
```c
|
||||
worldPosToChunkPos(&worldPos, &chunkPos); // tile → chunk grid
|
||||
chunkPosToWorldPos(&chunkPos, &worldPos); // chunk grid → tile origin
|
||||
worldPosToChunkTileIndex(&worldPos); // tile → index within its chunk
|
||||
chunkPosToIndex(&chunkPos); // chunk grid → linear index in MAP.chunks[]
|
||||
worldPosToFixed(&worldPos, fixedOut); // tile → entity fixed position
|
||||
fixedToWorldPos(fixedPos); // entity fixed → tile (truncates frac)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Tiles
|
||||
|
||||
Defined in `tile.h` as a plain `tile_t` enum:
|
||||
|
||||
```
|
||||
TILE_SHAPE_NULL — empty / unloaded
|
||||
TILE_SHAPE_GROUND — solid flat tile
|
||||
TILE_SHAPE_RAMP_* — directional ramps (N/S/E/W + diagonals NE/NW/SE/SW)
|
||||
```
|
||||
|
||||
Key predicates:
|
||||
- `tileIsWalkable(tile)` — true for GROUND and all ramp shapes.
|
||||
- `tileIsRamp(tile)` — true only for ramp shapes.
|
||||
|
||||
Entity walk code (`entity.c`) checks both the current tile and the target tile to decide whether the entity steps forward flat, raises one Z level (walking up a ramp), or falls one Z level (stepping onto a downward ramp from above).
|
||||
|
||||
---
|
||||
|
||||
## Chunks
|
||||
|
||||
`chunk_t` (`chunk.h`) holds:
|
||||
- `position` — its `chunkpos_t` in the world grid
|
||||
- `tiles[CHUNK_TILE_COUNT]` — flat array of `tile_t`, indexed by `chunkGetTileIndex()`
|
||||
- `vertices[CHUNK_VERTEX_COUNT]` / `mesh` — pre-baked mesh uploaded to GPU on load
|
||||
- `entities[CHUNK_ENTITY_COUNT_MAX]` — indices into `ENTITIES[]` currently in this chunk (sentinel `0xFF`)
|
||||
- `testColor` — temporary debug color (checkerboard), will be replaced by real tileset data
|
||||
|
||||
Tile layout within a chunk is `z * W*H + y * W + x` (Z-major, row-major in XY).
|
||||
|
||||
---
|
||||
|
||||
## Map
|
||||
|
||||
`map_t MAP` (`map.h`) is the single global map instance.
|
||||
|
||||
```c
|
||||
chunk_t chunks[MAP_CHUNK_COUNT]; // flat storage — index is NOT world position
|
||||
chunk_t *chunkOrder[MAP_CHUNK_COUNT]; // draw-order sorted pointers into chunks[]
|
||||
chunkpos_t chunkPosition; // world-grid origin of the loaded window
|
||||
bool_t loaded;
|
||||
```
|
||||
|
||||
### Load / unload
|
||||
|
||||
`mapInit()` allocates chunk meshes and performs the initial load of all chunks in the starting window.
|
||||
|
||||
`mapPositionSet(newPos)` shifts the window:
|
||||
1. Determines which of the `MAP_CHUNK_COUNT` slots remain within the new window vs. fall outside it.
|
||||
2. Calls `mapChunkUnload()` on every chunk that falls outside (nulls its entity slots, zeroes `vertCount`).
|
||||
3. Reuses freed slots for newly-in-range chunks; calls `mapChunkLoad()` on each.
|
||||
4. Rebuilds `chunkOrder[]` in XYZ order for the new position.
|
||||
|
||||
### Chunk load (current stub)
|
||||
|
||||
`mapChunkLoad()` currently:
|
||||
- Fills all tiles with `TILE_SHAPE_GROUND`
|
||||
- Assigns a checkerboard debug color based on chunk XY parity
|
||||
- Bakes a flat sprite-batch quad mesh for the z=0 layer and uploads it via `meshFlush()`
|
||||
- Skips mesh generation for z > 0 chunks (they're empty)
|
||||
|
||||
### Tile lookup
|
||||
|
||||
```c
|
||||
tile_t mapGetTile(const worldpos_t position);
|
||||
```
|
||||
|
||||
Converts `position` to its chunk, looks up the chunk in `chunkOrder`, then indexes into `chunk->tiles[]`. Returns `TILE_SHAPE_NULL` for any out-of-bounds position or when the map is not loaded.
|
||||
|
||||
---
|
||||
|
||||
## Camera
|
||||
|
||||
`rpgcamera_t RPG_CAMERA` (`rpgcamera.h`) has two modes:
|
||||
|
||||
```c
|
||||
RPG_CAMERA_MODE_FREE // free worldpos; camera.free holds the position
|
||||
RPG_CAMERA_MODE_FOLLOW_ENTITY // tracks ENTITIES[followEntityId]
|
||||
```
|
||||
|
||||
`rpgCameraGetPosition()` returns the active world tile position in either mode.
|
||||
|
||||
The scene renderer (`sceneoverworld.c`) uses `rpgCameraGetPosition()` to build the `glm_lookat` view matrix. When following an entity, it sub-tile interpolates between `entity->lastPosition` and `entity->position` using `entity->animTime / ENTITY_ANIM_WALK_DURATION` to smooth movement.
|
||||
@@ -1,96 +0,0 @@
|
||||
# Save & Locale
|
||||
|
||||
---
|
||||
|
||||
## Save system (`src/dusk/save/`)
|
||||
|
||||
Slot-based persistent storage. Currently disabled in engine init (commented out in `engine.c`) — the system is fully implemented but not yet wired up.
|
||||
|
||||
### Slots
|
||||
|
||||
Up to `SAVE_FILE_COUNT_MAX` (3) save slots. The global `SAVE` holds all slots:
|
||||
|
||||
```c
|
||||
saveInit();
|
||||
saveExists(slot); // bool_t — check before load
|
||||
saveLoad(slot); // read from platform storage → SAVE.files[slot]
|
||||
saveWrite(slot); // write SAVE.files[slot] → platform storage
|
||||
saveDelete(slot);
|
||||
savefile_t *f = saveGet(slot);
|
||||
saveDispose();
|
||||
```
|
||||
|
||||
### Save file format
|
||||
|
||||
`savefile_t` is the serialized struct stored per slot. Currently minimal:
|
||||
|
||||
```c
|
||||
typedef struct {
|
||||
char_t header[3]; // "DSK"
|
||||
uint32_t version; // SAVE_FILE_VERSION = 1
|
||||
bool_t exists;
|
||||
} savefile_t;
|
||||
```
|
||||
|
||||
Extend this struct to add game-specific save data (player position, story flags, etc.).
|
||||
|
||||
### Stream serialization (`save/savestream.h`)
|
||||
|
||||
`savestream_t` is a cursor used to read/write a save slot's bytes. It CRC32-checksums all data written through it and verifies the checksum on read.
|
||||
|
||||
Write a save:
|
||||
```c
|
||||
savestream_t stream;
|
||||
// (platform opens stream for slot)
|
||||
saveFileWriteHeader(&stream, SAVE_FILE_HEADER);
|
||||
saveFileWriteVersion(&stream, SAVE_FILE_VERSION);
|
||||
saveFileWriteBool(&stream, myFlag);
|
||||
saveFileWriteInt32(&stream, myInt);
|
||||
saveFileWriteString(&stream, myString, sizeof(myString));
|
||||
saveStreamFinalizeWriteImpl(&stream); // writes CRC
|
||||
```
|
||||
|
||||
Read a save:
|
||||
```c
|
||||
saveFileReadHeader(&stream, headerBuf);
|
||||
saveFileReadVersion(&stream, &version);
|
||||
saveFileReadBool(&stream, &myFlag);
|
||||
saveFileReadInt32(&stream, &myInt);
|
||||
saveFileReadString(&stream, myString, sizeof(myString));
|
||||
saveStreamVerifyChecksumImpl(&stream, slot); // returns error if CRC mismatch
|
||||
```
|
||||
|
||||
All multi-byte values are stored in little-endian byte order. The `saveFile*` macros are thin wrappers over the `*Impl` functions that integrate `errorChain` — always use the macros.
|
||||
|
||||
### Platform backends
|
||||
|
||||
Each `src/dusk{platform}/save/` provides `saveplatform_t` (e.g. a file path on Linux, a memory-card handle on GameCube). The stream implementations (`savestream{platform}.c`) do the actual I/O.
|
||||
|
||||
---
|
||||
|
||||
## Locale / i18n (`src/dusk/locale/`)
|
||||
|
||||
Translations are stored as GNU `.po` files in `assets/locale/`. Only `en_US.po` currently exists.
|
||||
|
||||
### Loading
|
||||
|
||||
`localemanager_t LOCALE` tracks the active locale and its in-progress asset entry:
|
||||
|
||||
```c
|
||||
localeManagerInit(); // loads en_US by default
|
||||
localeManagerSetLocale(&LOCALE_EN_US); // switch locale (async load)
|
||||
localeManagerDispose();
|
||||
```
|
||||
|
||||
`LOCALE_EN_US` is a predefined `localeinfo_t` constant (`name = "en-US"`, `file = "locale/en_US.po"`).
|
||||
|
||||
### Looking up strings
|
||||
|
||||
```c
|
||||
char_t buf[128];
|
||||
localeManagerGetText("my.key", buf, sizeof(buf), 1, /* format args */ );
|
||||
```
|
||||
|
||||
The macro handles plural forms and `printf`-style format arguments. Pass plural `1` for singular, any other value for plural.
|
||||
|
||||
`assetlocaleloader.c` parses the `.po` format (msgid / msgstr pairs) into a key→string table during the async asset load phase.
|
||||
@@ -1,403 +0,0 @@
|
||||
# Coding Style
|
||||
|
||||
All source is C11. Everything below is derived from the existing codebase — match it exactly.
|
||||
|
||||
---
|
||||
|
||||
## File structure
|
||||
|
||||
### Headers (`.h`)
|
||||
|
||||
```c
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "direct/dependency.h"
|
||||
```
|
||||
|
||||
- `#pragma once` always, never `#ifndef` guards.
|
||||
- No blank line between the license block and `#pragma once`.
|
||||
- One blank line between `#pragma once` and the first `#include`.
|
||||
|
||||
### Sources (`.c`)
|
||||
|
||||
```c
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "thisfile.h"
|
||||
#include "assert/assert.h"
|
||||
#include "util/memory.h"
|
||||
```
|
||||
|
||||
- First include is always the matching `.h` for this `.c` file.
|
||||
- Remaining includes follow with no separator unless logically grouped (then one blank line between groups — see [Include order](#include-order)).
|
||||
|
||||
---
|
||||
|
||||
## Include order
|
||||
|
||||
In `.c` files, include in this order with a blank line between each group:
|
||||
|
||||
1. The matching header (e.g. `#include "entity.h"`)
|
||||
2. Core utilities (`assert/assert.h`, `util/memory.h`, `util/math.h`, etc.)
|
||||
3. Engine subsystems (`display/...`, `input/...`, etc.)
|
||||
4. Domain subsystems (`rpg/...`, `scene/...`, etc.)
|
||||
|
||||
In `.h` files, only include what the header directly requires. Never include more than necessary to make the type definitions in that header compile.
|
||||
|
||||
All include paths are relative to `src/dusk/` (the root include directory). Use the full path:
|
||||
```c
|
||||
#include "rpg/overworld/map.h" // correct
|
||||
#include "map.h" // wrong
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Line length
|
||||
|
||||
80-character limit. Break before it, not after.
|
||||
|
||||
Multi-parameter function signatures break one param per line, with 2-space indent, closing `)` on its own line before `{`:
|
||||
|
||||
```c
|
||||
errorret_t textureInit(
|
||||
texture_t *texture,
|
||||
const int32_t width,
|
||||
const int32_t height,
|
||||
const textureformat_t format,
|
||||
const texturedata_t data
|
||||
) {
|
||||
```
|
||||
|
||||
Same rule for calls that don't fit on one line:
|
||||
|
||||
```c
|
||||
assertTrue(
|
||||
data.paletted.palette->count ==
|
||||
mathNextPowTwo(data.paletted.palette->count),
|
||||
"Palette color count must be a power of 2"
|
||||
);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Indentation and spacing
|
||||
|
||||
- **2 spaces** per indent level. No tabs.
|
||||
- No space between a control keyword and its `(`:
|
||||
```c
|
||||
if(x) { // correct
|
||||
if (x) { // wrong
|
||||
```
|
||||
- No space between a function name and its `(` in either declarations or calls.
|
||||
- Opening brace on the same line:
|
||||
```c
|
||||
void entityUpdate(entity_t *entity) {
|
||||
if(x) {
|
||||
for(int i = 0; i < n; i++) {
|
||||
```
|
||||
- Closing brace always on its own line, except `} else {` and `} while(...)`.
|
||||
- One blank line between function definitions in `.c` files.
|
||||
- No trailing whitespace.
|
||||
|
||||
---
|
||||
|
||||
## Naming
|
||||
|
||||
| Kind | Convention | Example |
|
||||
|---|---|---|
|
||||
| Types (struct/union/typedef) | `snake_case_t` | `entity_t`, `worldpos_t` |
|
||||
| Struct tags | `struct name_s` | `struct entity_s` |
|
||||
| Union tags | `union name_u` | `union texturedata_u` |
|
||||
| Enum tags (when typedef'd separately) | `name_enum_t` | `entitytype_enum_t` |
|
||||
| Functions | `subsystemVerb` (camelCase, noun-first) | `entityInit`, `mapGetTile` |
|
||||
| Macro constants | `UPPER_SNAKE_CASE` | `CHUNK_WIDTH`, `FIXED_ONE` |
|
||||
| Function-like macros | `camelCase` (same as functions) | `errorThrow`, `assertNotNull` |
|
||||
| Global subsystem instances | `UPPER_SNAKE_CASE` | `ENGINE`, `MAP`, `ENTITIES` |
|
||||
| Local variables | `camelCase` | `tileNew`, `spriteCount` |
|
||||
| Parameters | `camelCase` | `texture`, `worldPos` |
|
||||
|
||||
Subsystem prefix always comes first in function names: `textureInit`, `shaderBind`, `spriteBatchFlush`. The verb describes the action: `Init`, `Update`, `Dispose`, `Get`, `Set`, `Is`, etc.
|
||||
|
||||
---
|
||||
|
||||
## Typedefs
|
||||
|
||||
### Structs
|
||||
|
||||
```c
|
||||
typedef struct {
|
||||
uint8_t id;
|
||||
entitytype_t type;
|
||||
} entity_t;
|
||||
```
|
||||
|
||||
Use a named tag (`struct entity_s`) only when forward declaration is required:
|
||||
|
||||
```c
|
||||
typedef struct entity_s {
|
||||
// ...
|
||||
} entity_t;
|
||||
```
|
||||
|
||||
### Unions
|
||||
|
||||
```c
|
||||
typedef union texturedata_u {
|
||||
struct {
|
||||
uint8_t *indices;
|
||||
palette_t *palette;
|
||||
} paletted;
|
||||
color_t *rgbaColors;
|
||||
} texturedata_t;
|
||||
```
|
||||
|
||||
### Enums
|
||||
|
||||
When the enum values need to be a compact integer (common for arrays and flags), declare the enum separately and typedef an integer type:
|
||||
|
||||
```c
|
||||
typedef enum {
|
||||
ENTITY_TYPE_NULL,
|
||||
ENTITY_TYPE_PLAYER,
|
||||
ENTITY_TYPE_NPC,
|
||||
ENTITY_TYPE_COUNT
|
||||
} entitytype_enum_t;
|
||||
|
||||
typedef uint8_t entitytype_t; // actual type used everywhere
|
||||
```
|
||||
|
||||
Always include `_NULL` as the first value (zero) and `_COUNT` as the last value.
|
||||
|
||||
---
|
||||
|
||||
## `#define` constants
|
||||
|
||||
All-caps, underscores. Wrap multi-token expressions in parentheses:
|
||||
|
||||
```c
|
||||
#define CHUNK_WIDTH 16
|
||||
#define CHUNK_HEIGHT CHUNK_WIDTH
|
||||
#define CHUNK_TILE_COUNT (CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH)
|
||||
```
|
||||
|
||||
Multi-line macros: backslash continuation, body indented 2 spaces, closing line has no backslash:
|
||||
|
||||
```c
|
||||
#define errorThrow(message, ...) \
|
||||
return errorThrowImpl(\
|
||||
&ERROR_STATE, ERROR_NOT_OK, __FILE__, __func__, __LINE__, (message), \
|
||||
##__VA_ARGS__ \
|
||||
)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## `const` usage
|
||||
|
||||
Mark every pointer and value parameter `const` unless the function modifies it:
|
||||
|
||||
```c
|
||||
void entityTurn(entity_t *entity, const entitydir_t direction);
|
||||
errorret_t textureInit(texture_t *texture, const int32_t width, ...);
|
||||
```
|
||||
|
||||
`entity_t *entity` is non-const because the function writes to it; `direction` is const because it is read-only.
|
||||
|
||||
---
|
||||
|
||||
## `void` in no-argument functions
|
||||
|
||||
Use `(void)` in definitions and declarations of zero-parameter functions:
|
||||
|
||||
```c
|
||||
errorret_t engineUpdate(void);
|
||||
errorret_t spriteBatchFlush(void);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Unused parameters
|
||||
|
||||
Do **not** use `(void)param;` casts to suppress unused-parameter warnings. They are
|
||||
redundant noise. If a callback signature is fixed by a function-pointer type and the
|
||||
parameter is genuinely unused, just leave it — do not suppress:
|
||||
|
||||
```c
|
||||
// correct — parameter unused, no cast
|
||||
errorret_t sceneTestUpdate(scenedata_t *data) {
|
||||
errorOk();
|
||||
}
|
||||
|
||||
// wrong
|
||||
errorret_t sceneTestUpdate(scenedata_t *data) {
|
||||
(void)data;
|
||||
errorOk();
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Global subsystem state
|
||||
|
||||
Each subsystem exposes a single global instance declared `extern` in the header and defined (once) in the `.c` file:
|
||||
|
||||
```c
|
||||
// entity.h
|
||||
extern entity_t ENTITIES[ENTITY_COUNT];
|
||||
|
||||
// entity.c
|
||||
entity_t ENTITIES[ENTITY_COUNT];
|
||||
```
|
||||
|
||||
Never define a subsystem global as `static` in a header.
|
||||
|
||||
---
|
||||
|
||||
## Assertions
|
||||
|
||||
Place assertions at the very top of a function, before any logic:
|
||||
|
||||
```c
|
||||
void entityInit(entity_t *entity, const entitytype_t type) {
|
||||
assertNotNull(entity, "Entity pointer cannot be NULL");
|
||||
assertTrue(type < ENTITY_TYPE_COUNT, "Invalid entity type");
|
||||
// ... actual logic
|
||||
}
|
||||
```
|
||||
|
||||
Available assertion macros (from `assert/assert.h`):
|
||||
- `assertNotNull(ptr, msg)`
|
||||
- `assertNull(ptr, msg)`
|
||||
- `assertTrue(expr, msg)`
|
||||
- `assertFalse(expr, msg)`
|
||||
- `assertUnreachable(msg)`
|
||||
- `assertStringEqual(a, b, msg)`
|
||||
- `assertIsMainThread(msg)` / `assertNotMainThread(msg)`
|
||||
|
||||
---
|
||||
|
||||
## Error handling style
|
||||
|
||||
Functions that can fail return `errorret_t`. Three patterns:
|
||||
|
||||
```c
|
||||
// Propagate a child call's failure and return from this function:
|
||||
errorChain(someCall());
|
||||
|
||||
// Return success:
|
||||
errorOk();
|
||||
|
||||
// Return failure:
|
||||
errorThrow("Descriptive message %s", variable);
|
||||
```
|
||||
|
||||
`errorChain` is used inline — do not capture the result first:
|
||||
```c
|
||||
errorChain(textureInitPlatform(texture, width, height, format, data)); // correct
|
||||
errorret_t r = textureInitPlatform(...); errorChain(r); // wrong
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Struct initialization
|
||||
|
||||
Use C99 designated initializers for any struct literal with more than one field:
|
||||
|
||||
```c
|
||||
static const entitycallback_t ENTITY_CALLBACKS[ENTITY_TYPE_COUNT] = {
|
||||
[ENTITY_TYPE_NULL] = { NULL },
|
||||
|
||||
[ENTITY_TYPE_PLAYER] = {
|
||||
.init = playerInit,
|
||||
.movement = playerInput
|
||||
},
|
||||
};
|
||||
```
|
||||
|
||||
```c
|
||||
shadermaterial_t material = {
|
||||
.unlit = {
|
||||
.color = COLOR_WHITE,
|
||||
.texture = NULL
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Fixed-size array iteration
|
||||
|
||||
Prefer pointer arithmetic with `do/while` over index loops for iterating through fixed global arrays:
|
||||
|
||||
```c
|
||||
entity_t *ent = ENTITIES;
|
||||
do {
|
||||
if(ent->type == ENTITY_TYPE_NULL) continue;
|
||||
// ...
|
||||
} while(++ent, ent < &ENTITIES[ENTITY_COUNT]);
|
||||
```
|
||||
|
||||
Use `for` loops when an index variable is actually needed.
|
||||
|
||||
---
|
||||
|
||||
## Comments
|
||||
|
||||
Comments explain *why*, not *what*. One short inline comment is fine; multi-line block comments for non-obvious invariants only.
|
||||
|
||||
```c
|
||||
// Walking up a ramp — only the direction the ramp faces is valid.
|
||||
if(tileIsRamp(tileCurrent) && ...) {
|
||||
```
|
||||
|
||||
Section labels inside long functions are acceptable:
|
||||
|
||||
```c
|
||||
// Chunks
|
||||
{
|
||||
...
|
||||
}
|
||||
|
||||
// Entities
|
||||
{
|
||||
...
|
||||
}
|
||||
```
|
||||
|
||||
Doc comments on public functions use Javadoc style with `@param` / `@return`:
|
||||
|
||||
```c
|
||||
/**
|
||||
* Gets the tile at the given world position.
|
||||
*
|
||||
* @param position The world position.
|
||||
* @return The tile at that position, or TILE_NULL if the chunk is unloaded.
|
||||
*/
|
||||
tile_t mapGetTile(const worldpos_t position);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Platform-conditional code
|
||||
|
||||
Use the `DUSK_*` compile-definition macros set by `cmake/targets/<target>.cmake`:
|
||||
|
||||
```c
|
||||
#ifdef DUSK_THREAD_PTHREAD
|
||||
#include "thread/thread.h"
|
||||
extern pthread_t ASSERT_MAIN_THREAD_ID;
|
||||
#endif
|
||||
```
|
||||
|
||||
Never use `#ifdef __linux__`, `#ifdef _WIN32`, etc. directly — go through the engine macros.
|
||||
@@ -1,177 +0,0 @@
|
||||
# Engine Systems
|
||||
|
||||
Smaller systems that support the engine but don't warrant their own file each.
|
||||
|
||||
---
|
||||
|
||||
## Time (`src/dusk/time/`)
|
||||
|
||||
`dusktime_t TIME` tracks fixed and dynamic delta time.
|
||||
|
||||
```c
|
||||
TIME.delta // fixed_t: always DUSK_TIME_STEP (16ms default) on fixed-rate platforms
|
||||
TIME.time // fixed_t: total elapsed time in seconds
|
||||
```
|
||||
|
||||
On platforms with `DUSK_TIME_DYNAMIC` (Linux/SDL2):
|
||||
```c
|
||||
TIME.dynamicDelta // fixed_t: actual time since last frame
|
||||
TIME.dynamicTime // fixed_t: total elapsed (dynamic)
|
||||
TIME.dynamicUpdate // bool_t: true when a real tick occurred
|
||||
```
|
||||
|
||||
Call `timeUpdate()` once per frame (before input/logic). `timeGetEpoch()` returns the current wall-clock time as a `dusktimeepoch_t`.
|
||||
|
||||
### Epoch time (`time/timeepoch.h`)
|
||||
|
||||
`dusktimeepoch_t` stores a Unix timestamp (double) with timezone offset. Utilities:
|
||||
|
||||
```c
|
||||
dusktimeepoch_t e = timeGetEpoch();
|
||||
timeEpochGetHours(e) // 0–23
|
||||
timeEpochGetMinutes(e) // 0–59
|
||||
timeEpochGetSeconds(e) // 0–59
|
||||
timeEpochGetDayOfMonth(e) // 0–30
|
||||
timeEpochGetMonth(e) // 0–11
|
||||
timeEpochGetYear(e)
|
||||
|
||||
// Format: %Y year, %m month, %d day, %H hour, %M minute, %S second
|
||||
timeEpochFormat(e, "%Y-%m-%d %H:%M:%S", buf, sizeof(buf));
|
||||
|
||||
// Compare: returns -1, 0, 1
|
||||
timeEpochCompare(a, b);
|
||||
|
||||
// Timezone shift:
|
||||
dusktimeepoch_t local = timeEpochSwitchTimeZone(e, offsetHours);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Thread (`src/dusk/thread/`)
|
||||
|
||||
Currently only the pthread backend (`DUSK_THREAD_PTHREAD`) exists. Thread objects are `thread_t` — used primarily by the asset loader.
|
||||
|
||||
```c
|
||||
threadInit(&thread, myCallback); // myCallback: void (*)(thread_t *)
|
||||
threadStart(&thread); // blocks until thread is RUNNING
|
||||
threadStop(&thread); // requests stop, blocks until STOPPED
|
||||
|
||||
// Inside the thread callback:
|
||||
while(!threadShouldStop(&thread)) { /* work */ }
|
||||
```
|
||||
|
||||
State flow: `STOPPED → STARTING → RUNNING → (STOP_REQUESTED) → STOPPED`.
|
||||
|
||||
### Mutex (`thread/threadmutex.h`)
|
||||
|
||||
```c
|
||||
threadMutexInit(&lock);
|
||||
threadMutexLock(&lock);
|
||||
threadMutexUnlock(&lock);
|
||||
threadMutexTryLock(&lock); // non-blocking; returns false if already held
|
||||
threadMutexWaitLock(&lock); // release lock and sleep until signalled
|
||||
threadMutexSignal(&lock); // wake a thread waiting on this mutex
|
||||
threadMutexDispose(&lock);
|
||||
```
|
||||
|
||||
### Thread-local storage
|
||||
|
||||
`THREAD_LOCAL` expands to `__thread` (GCC) on pthread platforms. Used for the per-thread error state (`ERROR_STATE` in `error/error.h`).
|
||||
|
||||
---
|
||||
|
||||
## Event (`src/dusk/event/`)
|
||||
|
||||
A fixed-capacity multicast callback list.
|
||||
|
||||
```c
|
||||
// Declare backing arrays (choose a size):
|
||||
eventcallback_t cbs[4];
|
||||
void *users[4];
|
||||
event_t myEvent;
|
||||
eventInit(&myEvent, cbs, users, 4);
|
||||
|
||||
eventSubscribe(&myEvent, myCallback, myUser);
|
||||
eventUnsubscribe(&myEvent, myCallback);
|
||||
eventInvoke(&myEvent, params); // calls all subscribers; params passed as-is
|
||||
```
|
||||
|
||||
Callback signature: `void cb(void *params, void *user)`.
|
||||
|
||||
`event_t` does not own its callback/user arrays. Always declare them alongside the event in the same struct or as static arrays.
|
||||
|
||||
---
|
||||
|
||||
## Console (`src/dusk/console/`)
|
||||
|
||||
`CONSOLE` is a scrolling in-game terminal for debug output. On POSIX platforms (`DUSK_CONSOLE_POSIX`) it also polls stdin in a thread so commands can be typed during a running session.
|
||||
|
||||
```c
|
||||
consolePrint("Value is %d", x); // printf-style; thread-safe
|
||||
consoleDraw(); // renders visible history lines to screen
|
||||
```
|
||||
|
||||
Configuration constants (`consoledefs.h`):
|
||||
- `CONSOLE_LINE_MAX` — 512 chars per line
|
||||
- `CONSOLE_HISTORY_MAX` — 16 lines of scrollback
|
||||
- `CONSOLE_EXEC_BUFFER_MAX` — 32 pending exec commands
|
||||
|
||||
`CONSOLE.visible` controls whether `consoleDraw()` actually renders anything.
|
||||
|
||||
---
|
||||
|
||||
## Log (`src/dusk/log/`)
|
||||
|
||||
Two simple output functions, implemented per-platform:
|
||||
|
||||
```c
|
||||
logDebug("format %s", arg); // debug output (stdout on Linux, debug channel on consoles)
|
||||
logError("format %s", arg); // error output; may pause execution on some platforms
|
||||
```
|
||||
|
||||
These go directly to the platform's native output and are not buffered by the console history.
|
||||
|
||||
---
|
||||
|
||||
## System / Platform (`src/dusk/system/`)
|
||||
|
||||
`systemInit()` runs platform-specific startup (e.g. Wii PAD init, PSP kernel setup). Must be the first call in `engineInit()`.
|
||||
|
||||
```c
|
||||
systemplatform_t p = systemGetPlatform(); // SYSTEM_PLATFORM_LINUX, _PSP, etc.
|
||||
systemdialogtype_t d = systemGetActiveDialogType();
|
||||
// SYSTEM_DIALOG_TYPE_NONE / RENDER_BLOCKING / TICK_BLOCKING
|
||||
```
|
||||
|
||||
The full platform list is defined via X-macro in `system/systemplatformlist.h`:
|
||||
|
||||
| Constant | Value |
|
||||
|---|---|
|
||||
| `SYSTEM_PLATFORM_LINUX` | 0 |
|
||||
| `SYSTEM_PLATFORM_KNULLI` | 1 |
|
||||
| `SYSTEM_PLATFORM_PSP` | 2 |
|
||||
| `SYSTEM_PLATFORM_GAMECUBE` | 3 |
|
||||
| `SYSTEM_PLATFORM_WII` | 4 |
|
||||
|
||||
---
|
||||
|
||||
## Network (`src/dusk/network/`)
|
||||
|
||||
`network_t NETWORK` manages platform connection state. The engine calls `networkInit` / `networkUpdate` / `networkDispose`; game code uses the request API:
|
||||
|
||||
```c
|
||||
networkRequestConnection(onConnected, onFailed, onDisconnect, user);
|
||||
networkRequestDisconnection(onComplete, user);
|
||||
networkIsConnected(); // bool_t
|
||||
```
|
||||
|
||||
State machine: `DISCONNECTED → CONNECTING → CONNECTED → DISCONNECTING → DISCONNECTED`.
|
||||
|
||||
Network address info (after connection):
|
||||
```c
|
||||
networkinfo_t info = networkGetInfo();
|
||||
// info.type = NETWORK_TYPE_IPV4 / IPV6
|
||||
// info.ipv4.ip[4] or info.ipv6.ip[16]
|
||||
```
|
||||
|
||||
Platform backends implement `networkPlatformInit/Update/Dispose/IsConnected`. Currently only Linux (socket-based) and PSP/Vita are implemented.
|
||||
-123
@@ -1,123 +0,0 @@
|
||||
# UI System
|
||||
|
||||
Source: `src/dusk/ui/`
|
||||
|
||||
The UI system is an immediate-mode layer drawn on top of the game scene each frame. Elements register themselves; `uiUpdate()` ticks all elements and `uiRender()` draws them. All coordinates are in screen pixels.
|
||||
|
||||
---
|
||||
|
||||
## Lifecycle
|
||||
|
||||
```
|
||||
uiInit() → uiTextboxInit() // init order matters — textbox depends on display being ready
|
||||
uiUpdate() // each frame, before rendering
|
||||
uiRender() // each frame, after scene render
|
||||
uiDispose()
|
||||
uiTextboxDispose()
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Element registration (`ui/uielement.h`)
|
||||
|
||||
Elements are stored in `UI_ELEMENTS[]`. Each has a type and a `draw` callback:
|
||||
|
||||
```c
|
||||
typedef struct {
|
||||
uielementtype_t type;
|
||||
errorret_t (*draw)();
|
||||
} uielement_t;
|
||||
```
|
||||
|
||||
Currently `UI_ELEMENT_TYPE_NATIVE` elements call their `draw` function directly. New debug/HUD elements are registered by adding to this array.
|
||||
|
||||
---
|
||||
|
||||
## Textbox (`ui/uitextbox.h`)
|
||||
|
||||
`UI_TEXTBOX` is the global dialogue box. It word-wraps text, paginates it, and plays a typewriter scroll effect.
|
||||
|
||||
```c
|
||||
uiTextboxSetText("Long dialogue string..."); // wraps to charsPerLine, paginates
|
||||
uiTextboxUpdate(); // each frame: advance scroll, check input
|
||||
uiTextboxDraw(); // draw box + text
|
||||
|
||||
// Pagination:
|
||||
uiTextboxPageIsComplete() // true when all chars of current page are visible
|
||||
uiTextboxHasNextPage()
|
||||
uiTextboxNextPage()
|
||||
|
||||
// Subscibe to page events:
|
||||
eventSubscribe(&UI_TEXTBOX.onPageComplete, cb, user);
|
||||
eventSubscribe(&UI_TEXTBOX.onLastPage, cb, user);
|
||||
```
|
||||
|
||||
`UI_TEXTBOX.advanceAction` defaults to the input action that advances dialogue — set it before calling `uiTextboxInit()` if the default doesn't suit.
|
||||
|
||||
Layout constants:
|
||||
- `UI_TEXTBOX_TEXT_MAX` — 1024 chars
|
||||
- `UI_TEXTBOX_LINES_MAX` — 64 lines
|
||||
- `UI_TEXTBOX_LINES_PER_PAGE_MAX` — 3 lines visible at once
|
||||
- `UI_TEXTBOX_SCROLL_CHARS_PER_TICK` — 1 char per tick (typewriter speed)
|
||||
|
||||
The textbox uses `UI_TEXTBOX.frame` (a `uiframe_t`) for its border rendering and `UI_TEXTBOX.font` for text.
|
||||
|
||||
---
|
||||
|
||||
## UI Frame (`ui/uiframe.h`)
|
||||
|
||||
9-slice bordered box rendered with a tileset:
|
||||
|
||||
```c
|
||||
uiFrameInit(&frame);
|
||||
uiFrameDraw(&frame, x, y, width, height);
|
||||
uiFrameDispose(&frame);
|
||||
```
|
||||
|
||||
The tileset is loaded from the asset system during `uiFrameInit()`. The 9 slices are arranged in the tileset grid as: top-left corner, top edge, top-right corner, left edge, fill, right edge, bottom-left, bottom edge, bottom-right.
|
||||
|
||||
---
|
||||
|
||||
## Loading overlay (`ui/uiloading.h`)
|
||||
|
||||
`UI_LOADING` is a full-screen loading indicator with fade-in/fade-out transitions:
|
||||
|
||||
```c
|
||||
uiLoadingShow(onShownCallback, user); // fade in; calls callback when fully opaque
|
||||
uiLoadingHide(onHiddenCallback, user); // fade out; calls callback when fully transparent
|
||||
uiLoadingUpdate(delta); // each frame
|
||||
uiLoadingDraw(); // each frame, over everything
|
||||
```
|
||||
|
||||
`UI_LOADING_FADE_DURATION` is `FIXED(0.5f)` seconds. Subscribe to `UI_LOADING.onTransitionEnd` for completion events.
|
||||
|
||||
---
|
||||
|
||||
## Full-box overlay (`ui/uifullbox.h`)
|
||||
|
||||
Two global full-screen color overlays: `UI_FULLBOX_UNDER` (drawn before game content) and `UI_FULLBOX_OVER` (drawn after). Used for scene transitions (fade to black, etc.):
|
||||
|
||||
```c
|
||||
uiFullboxTransition(
|
||||
&UI_FULLBOX_OVER,
|
||||
COLOR_TRANSPARENT, COLOR_BLACK,
|
||||
FIXED(0.5f),
|
||||
EASING_IN_OUT_CUBIC
|
||||
);
|
||||
eventSubscribe(&UI_FULLBOX_OVER.onTransitionEnd, myCallback, NULL);
|
||||
|
||||
uiFullboxUnderDraw(); // draw under layer
|
||||
uiFullboxOverDraw(); // draw over layer
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## FPS counter (`ui/uifps.h`)
|
||||
|
||||
`UIFPS` tracks a rolling average FPS. `uiFPSDraw()` renders it in the corner. Currently drawn as part of the debug HUD (not wired to an element slot).
|
||||
|
||||
---
|
||||
|
||||
## Player position HUD (`ui/uiplayerpos.h`)
|
||||
|
||||
`uiplayerpos.c` draws the player's current world tile coordinates. Debug overlay, currently drawn directly in the scene render.
|
||||
-162
@@ -1,162 +0,0 @@
|
||||
# Utilities
|
||||
|
||||
Source: `src/dusk/util/`
|
||||
|
||||
---
|
||||
|
||||
## String (`util/string.h`)
|
||||
|
||||
**Always use these instead of stdlib equivalents** (`strcmp`, `strcpy`, `sprintf`, etc.).
|
||||
|
||||
```c
|
||||
stringCopy(dest, src, destSize); // safe strncpy; always null-terminates
|
||||
stringCompare(a, b); // -1 / 0 / 1
|
||||
stringEquals(a, b); // bool_t
|
||||
stringCompareInsensitive(a, b); // case-insensitive -1 / 0 / 1
|
||||
stringTrim(str); // in-place strip leading/trailing whitespace
|
||||
stringFindLastChar(str, c); // last occurrence pointer or NULL
|
||||
stringFormat(dest, destSize, fmt, ...); // snprintf wrapper; pass NULL dest to get length
|
||||
stringFormatVA(dest, destSize, fmt, args); // va_list version
|
||||
|
||||
stringIsWhitespace(c); // bool_t
|
||||
|
||||
// Parse:
|
||||
stringToI32(str, &out) → bool_t
|
||||
stringToI64(str, &out) → bool_t
|
||||
stringToI16(str, &out) → bool_t
|
||||
stringToU16(str, &out) → bool_t
|
||||
stringToF32(str, &out) → bool_t
|
||||
|
||||
// Suffix checks:
|
||||
stringEndsWith(str, suffix) → bool_t
|
||||
stringEndsWithCaseInsensitive(str, suffix) → bool_t
|
||||
stringIncludesString(haystack, needle) → bool_t
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Memory (`util/memory.h`)
|
||||
|
||||
**Always use these instead of `malloc`/`free`/`memcpy`/`memset` directly.**
|
||||
|
||||
```c
|
||||
memoryAllocate(size) → void * // malloc + tracks pointer count
|
||||
memoryAlign(alignment, size) → void * // aligned malloc
|
||||
memoryFree(ptr) // free + decrements count
|
||||
memoryReallocate(&ptr, size) // realloc
|
||||
memoryResize(&ptr, oldSize, newSize) // realloc + copy (safe reshape)
|
||||
memoryTrack(ptr) // track externally-malloc'd pointer
|
||||
|
||||
memoryCopy(dest, src, size) // memcpy
|
||||
memoryMove(dest, src, size) // memmove
|
||||
memorySet(dest, value, size) // memset
|
||||
memoryZero(dest, size) // memset 0
|
||||
memoryCompare(a, b, size) → int_t // memcmp
|
||||
|
||||
// Useful for uploading vertex data with different source/dest layouts:
|
||||
memoryCopyInterleaved(dest, destStride, src, srcStride, elementSize, count);
|
||||
memoryCopyRangeSafe(dest, start, end, sizeMax); // copy with bounds check
|
||||
|
||||
memoryGetAllocatedCount() → size_t // current malloc'd block count
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Math (`util/math.h`)
|
||||
|
||||
```c
|
||||
mathNextPowTwo(value) → uint32_t // next power of two >= value
|
||||
mathMax(a, b) // macro
|
||||
mathMin(a, b) // macro
|
||||
mathClamp(x, lower, upper) // macro
|
||||
mathAbs(amt) // macro
|
||||
mathModFloat(x, y) → float_t // always non-negative modulo
|
||||
mathLerp(a, b, t) → float_t // linear interpolation (floats)
|
||||
```
|
||||
|
||||
For fixed-point lerp use `fixedLerp(a, b, t)` from `util/fixed.h`.
|
||||
|
||||
`MATH_PI` is defined as `M_PI`.
|
||||
|
||||
---
|
||||
|
||||
## Fixed-point (`util/fixed.h`)
|
||||
|
||||
Q24.8 format: 24-bit integer part, 8-bit fractional part (`int32_t`). See [architecture.md](architecture.md#fixed-point-math) for the full API.
|
||||
|
||||
Quick reference:
|
||||
```c
|
||||
FIXED(1.5f) // compile-time literal
|
||||
fixedFromI32(3) // runtime int → fixed
|
||||
fixedToFloat(f) // fixed → float (only for GL/platform APIs)
|
||||
fixedMul(a, b) // multiplication (not just addition)
|
||||
fixedDiv(a, b) // division
|
||||
fixedLerp(a, b, t) // lerp where t ∈ [0, FIXED_ONE]
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Array (`util/array.h`)
|
||||
|
||||
```c
|
||||
arrayReverse(array, count, size); // in-place reverse; size = sizeof(element)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Sort (`util/sort.h`)
|
||||
|
||||
```c
|
||||
sortQuick(array, count, size, compare); // quicksort
|
||||
sortBubble(array, count, size, compare); // bubble sort (small arrays)
|
||||
sort(array, count, size, compare); // macro alias for sortQuick
|
||||
|
||||
// Convenience uint8_t sorter:
|
||||
sortArrayU8(array, count);
|
||||
int sortArrayU8Compare(const void *a, const void *b); // comparator
|
||||
```
|
||||
|
||||
`sortcompare_t` matches `qsort` comparator signature: `int (*)(const void *, const void *)`.
|
||||
|
||||
---
|
||||
|
||||
## Reference counting (`util/ref.h`)
|
||||
|
||||
```c
|
||||
refInit(&ref, dataPtr, onLock, onUnlock, onAllUnlocked);
|
||||
refLock(&ref); // increments count, calls onLock
|
||||
bool_t hit_zero = refUnlock(&ref); // decrements; calls onAllUnlocked when 0
|
||||
```
|
||||
|
||||
Used internally by the asset entry system to track how many callers hold a reference to a loaded asset entry.
|
||||
|
||||
---
|
||||
|
||||
## CRC32 (`util/crypt.h`)
|
||||
|
||||
```c
|
||||
// One-shot:
|
||||
uint32_t crc = cryptCRC32(data, size);
|
||||
|
||||
// Streaming:
|
||||
uint32_t acc = cryptCRC32Begin();
|
||||
cryptCRC32Update(&acc, chunk1, len1);
|
||||
cryptCRC32Update(&acc, chunk2, len2);
|
||||
uint32_t final = cryptCRC32End(acc);
|
||||
```
|
||||
|
||||
Used by the save stream to checksum save files.
|
||||
|
||||
---
|
||||
|
||||
## Endian (`util/endian.h`)
|
||||
|
||||
All serialized data (save files, asset headers) is little-endian. Convert to/from host byte order:
|
||||
|
||||
```c
|
||||
uint32_t val = endianLittleToHost32(rawU32);
|
||||
uint16_t val = endianLittleToHost16(rawU16);
|
||||
float_t val = endianLittleToHostFloat(rawFloat);
|
||||
```
|
||||
|
||||
`isHostLittleEndian()` returns a bool at runtime. The compile-time defines `DUSK_PLATFORM_ENDIAN_LITTLE` / `DUSK_PLATFORM_ENDIAN_BIG` are set by `cmake/targets/<target>.cmake`.
|
||||
@@ -1,65 +1,432 @@
|
||||
# CLAUDE.md
|
||||
# Dusk — Claude Code rules
|
||||
|
||||
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
|
||||
## File headers
|
||||
Every C, H, and JS file starts with:
|
||||
|
||||
## Project
|
||||
|
||||
Dusk is a C11 RPG game targeting resource-constrained hardware (PSP, GameCube, Wii, PS Vita, Knulli handhelds) and Linux/OpenGL. All game code lives in `src/dusk/`; platform-specific backends live in `src/dusk{platform}/` (e.g. `src/duskgl/`, `src/duskpsp/`, `src/duskdolphin/`).
|
||||
|
||||
Assets are zipped into `dusk.dsk` at build time and loaded at runtime via the asset system.
|
||||
|
||||
## Build
|
||||
|
||||
```bash
|
||||
# Linux (host)
|
||||
./scripts/build-linux.sh # outputs build-linux/Dusk
|
||||
|
||||
# Other targets (require Docker)
|
||||
./scripts/build-psp-docker.sh
|
||||
./scripts/build-gamecube-docker.sh
|
||||
./scripts/build-wii-docker.sh
|
||||
./scripts/build-knulli-docker.sh
|
||||
```c
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
```
|
||||
|
||||
Each script is a thin wrapper around:
|
||||
```bash
|
||||
cmake -S . -B build-<target> -DDUSK_TARGET_SYSTEM=<target>
|
||||
cmake --build build-<target> -- -j$(nproc)
|
||||
JS files use `//` comment style instead.
|
||||
|
||||
---
|
||||
|
||||
## C conventions
|
||||
|
||||
### Types
|
||||
Always use the project-defined aliases instead of bare C primitives:
|
||||
|
||||
| Use | Not |
|
||||
|-----------|--------------|
|
||||
| `bool_t` | `bool` |
|
||||
| `int_t` | `int` |
|
||||
| `float_t` | `float` |
|
||||
| `char_t` | `char` |
|
||||
|
||||
Use `uint8_t`, `uint16_t`, `int32_t`, etc. for fixed-width integers.
|
||||
All struct and enum types end in `_t` (`animation_t`, `errorret_t`, …).
|
||||
|
||||
### Naming
|
||||
- **Functions** — snake_case, prefixed with their module:
|
||||
`assetLock()`, `entityPositionInit()`, `moduleAssetBatchCtor()`
|
||||
- **Struct fields** — camelCase: `keyframeCount`, `localPosition`
|
||||
- **Macros / constants** — UPPER_SNAKE_CASE:
|
||||
`ENTITY_ID_INVALID`, `ERROR_OK`, `COMPONENT_TYPE_COUNT`
|
||||
- **Files** — snake_case matching the primary type: `entityposition.c`,
|
||||
`moduleassetbatch.c`
|
||||
|
||||
### Header files (`.h`)
|
||||
- Use `#pragma once` — no include guards.
|
||||
- Declare every public function, `#define`, and `extern` global.
|
||||
- Write a JSDoc block (`/** … */`) above every declaration explaining
|
||||
purpose, `@param`s, and `@returns`.
|
||||
- Only include headers that the `.h` file itself strictly requires for
|
||||
the types it exposes. Move everything else to the `.c` file.
|
||||
Do not use forward declarations as a workaround — use the real
|
||||
include in the `.c` file instead.
|
||||
|
||||
### Implementation files (`.c`)
|
||||
- Contain function bodies only; no declarations.
|
||||
- Pull in whatever additional includes the implementation needs.
|
||||
- Do not use `static` or `inline` on **functions**. Every function,
|
||||
including internal helpers, must be declared in the matching `.h` and
|
||||
defined in the `.c` file. Internal helpers belong near the bottom of
|
||||
the `.c` file, not at the top with a `static` qualifier.
|
||||
`static` and `inline` on functions are only appropriate when the
|
||||
function body is written directly inside a `.h` file.
|
||||
`static` on **variables** (file-scope state) is fine and expected.
|
||||
|
||||
### Formatting
|
||||
- Hard-wrap all lines at **80 characters**.
|
||||
|
||||
### Error handling
|
||||
Return `errorret_t` from fallible functions. Use these macros:
|
||||
|
||||
```c
|
||||
errorOk(); // return success
|
||||
errorThrow("msg %d", val); // return failure with message
|
||||
errorChain(someCall()); // propagate failure, continue on success
|
||||
errorIsOk(ret) / errorIsNotOk(ret) // test a result
|
||||
errorCatch(ret); // handle + free an error
|
||||
```
|
||||
|
||||
## Tests
|
||||
Never return raw error codes or use `errno` for in-engine errors.
|
||||
|
||||
```bash
|
||||
./scripts/test-linux.sh # builds and runs all tests
|
||||
### Memory
|
||||
Use the project allocator — never raw `malloc`/`free`:
|
||||
|
||||
# Manually run a single test binary after building:
|
||||
./build-tests/test/<module>/test_<name>
|
||||
```c
|
||||
memoryAllocate(size) // allocate
|
||||
memoryFree(ptr) // free
|
||||
memoryZero(dest, size) // zero a block
|
||||
memoryCopy(dest, src, size) // copy
|
||||
```
|
||||
|
||||
Tests use [cmocka](https://cmocka.org/) and are only compiled when `DUSK_BUILD_TESTS=ON`. Test sources live under `test/`.
|
||||
### Asserts
|
||||
Prefer specific assert macros over bare `assert()`:
|
||||
|
||||
## Key conventions
|
||||
```c
|
||||
assertNotNull(ptr, "msg");
|
||||
assertTrue(cond, "msg");
|
||||
assertFalse(cond, "msg");
|
||||
assertUnreachable("msg");
|
||||
assertIsMainThread("msg");
|
||||
```
|
||||
|
||||
- Use `stringCompare`, `stringCopy`, `stringEquals`, etc. from `util/string.h` — never `strcmp`, `strcpy`, and friends directly.
|
||||
- All functions that can fail return `errorret_t`. Use `errorThrow(...)`, `errorChain(call())`, and `errorOk()` macros — see `error/error.h`.
|
||||
- Positions and game-world values use `fixed_t` (Q24.8 fixed-point, `int32_t`) — not `float`. Use `FIXED(x)` for literals and the `fixedFrom*`/`fixedTo*` helpers in `util/fixed.h`.
|
||||
---
|
||||
|
||||
## Build system
|
||||
Each subdirectory has its own `CMakeLists.txt` that adds sources with:
|
||||
|
||||
```cmake
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
myfile.c
|
||||
)
|
||||
```
|
||||
|
||||
Never add source files to the root `CMakeLists.txt` directly.
|
||||
|
||||
---
|
||||
|
||||
## Platform support
|
||||
|
||||
### Targets
|
||||
Set `DUSK_TARGET_SYSTEM` at CMake configure time to select a platform:
|
||||
|
||||
| `DUSK_TARGET_SYSTEM` | Macro defined | Platform |
|
||||
|----------------------|-------------------|------------------|
|
||||
| `linux` | `DUSK_LINUX` | Linux desktop |
|
||||
| `knulli` | `DUSK_KNULLI` | Knulli (handheld)|
|
||||
| `psp` | `DUSK_PSP` | Sony PSP |
|
||||
| `vita` | `DUSK_VITA` | PlayStation Vita |
|
||||
| `gamecube` | `DUSK_GAMECUBE` | Nintendo GameCube|
|
||||
| `wii` | `DUSK_WII` | Nintendo Wii |
|
||||
|
||||
### Layer structure
|
||||
```
|
||||
src/dusk/ core, platform-agnostic game logic
|
||||
src/duskgl/ OpenGL abstraction (Linux, Knulli, PSP, Vita)
|
||||
src/dusksdl2/ SDL2 window + input (Linux, Knulli, PSP, Vita)
|
||||
src/dusklinux/ Linux + Knulli platform impl
|
||||
src/duskpsp/ PSP platform impl
|
||||
src/duskvita/ Vita platform impl
|
||||
src/duskdolphin/ GameCube / Wii platform impl (no SDL2/OpenGL)
|
||||
```
|
||||
|
||||
Dolphin is the only target that bypasses SDL2 and OpenGL entirely —
|
||||
it uses native GameCube/Wii rendering and input APIs.
|
||||
|
||||
### Platform guards
|
||||
Use the compile-time macros for platform-specific code:
|
||||
|
||||
```c
|
||||
#ifdef DUSK_PSP
|
||||
// PSP-only path
|
||||
#elif defined(DUSK_GAMECUBE) || defined(DUSK_WII)
|
||||
// GameCube / Wii path
|
||||
#else
|
||||
// Generic / Linux fallback
|
||||
#endif
|
||||
```
|
||||
|
||||
Additional capability macros set per-target:
|
||||
`DUSK_SDL2`, `DUSK_OPENGL`, `DUSK_OPENGL_ES`, `DUSK_OPENGL_LEGACY`,
|
||||
`DUSK_INPUT_GAMEPAD`, `DUSK_INPUT_KEYBOARD`, `DUSK_INPUT_POINTER`,
|
||||
`DUSK_PLATFORM_ENDIAN_BIG` / `DUSK_PLATFORM_ENDIAN_LITTLE`.
|
||||
|
||||
### Abstraction pattern
|
||||
Platform-specific implementations are wired in via `#define` macros in
|
||||
each platform's `displayplatform.h` / `inputplatform.h` etc., which
|
||||
the core calls through. Functions that a platform does not support are
|
||||
simply left undefined — the core guards calls with `#ifdef`.
|
||||
|
||||
### Adding platform-specific code
|
||||
- Put it under `src/dusk<platform>/` in the matching subsystem folder.
|
||||
- Gate any core call-site with the appropriate `#ifdef DUSK_<PLATFORM>`
|
||||
or capability macro.
|
||||
- Keep the `src/dusk/` core free of platform ifdefs — delegate through
|
||||
the platform header macros instead.
|
||||
|
||||
---
|
||||
|
||||
## Adding a new asset loader type
|
||||
1. Add an enum value to `assetloadertype_t` (before `_COUNT`) in
|
||||
`src/dusk/asset/loader/assetloader.h`.
|
||||
2. Add fields to the input/loading/output unions in `assetloader.h`.
|
||||
3. Implement `assetXxxLoaderSync`, `assetXxxLoaderAsync`, and
|
||||
`assetXxxDispose` in a new `src/dusk/asset/loader/xxx/` directory.
|
||||
4. Register the three callbacks in `ASSET_LOADER_CALLBACKS[]` in
|
||||
`src/dusk/asset/loader/assetloader.c`.
|
||||
5. If user-facing, create a JS module (see below) and a `.d.ts` file.
|
||||
|
||||
---
|
||||
|
||||
## Adding a new entity component
|
||||
1. Create `src/dusk/entity/component/<category>/entityMyComp.h/.c` with
|
||||
struct `entityMyComp_t`, `entityMyCompInit()`, and optionally
|
||||
`entityMyCompDispose()`.
|
||||
2. Add the include to `src/dusk/entity/componentlist.h` header block.
|
||||
3. Add a row to `src/dusk/entity/componentlist.h`:
|
||||
```c
|
||||
X(MYCOMP, entityMyComp_t, myComp, entityMyCompInit, NULL, NULL)
|
||||
```
|
||||
This auto-generates the enum, union field, and definition entry.
|
||||
4. If JS-facing, create the script module and `.d.ts` (see below).
|
||||
|
||||
---
|
||||
|
||||
## Adding a new script (JS) module
|
||||
1. Create `src/dusk/script/module/<category>/moduleMyMod.h/.c`.
|
||||
- Declare `extern scriptproto_t MODULE_MYMOD_PROTO;` in the header.
|
||||
- Use `moduleBaseFunction(name)` to define JS-callable functions.
|
||||
- Register props/funcs in `moduleMyModInit()` with
|
||||
`scriptProtoDefineProp` / `scriptProtoDefineFunc` /
|
||||
`scriptProtoDefineStaticFunc`.
|
||||
2. `#include` the header in
|
||||
`src/dusk/script/module/modulelist.c` and call
|
||||
`moduleMyModInit()` in `moduleListInit()` (and `Dispose` in
|
||||
`moduleListDispose()`).
|
||||
3. For component modules also register in
|
||||
`src/dusk/script/module/entity/component/modulecomponentlist.c`
|
||||
so `entity.add()` returns the typed wrapper.
|
||||
4. Create `types/<category>/mymod.d.ts` and add a
|
||||
`/// <reference path="..." />` line to `types/index.d.ts`.
|
||||
|
||||
---
|
||||
|
||||
## Script module type declarations
|
||||
Whenever a `src/dusk/script/module/**/*.c` file is created or modified,
|
||||
check whether the corresponding `types/**/*.d.ts` needs updating and
|
||||
apply any changes before finishing the task.
|
||||
|
||||
---
|
||||
|
||||
## JavaScript (asset scripts)
|
||||
- Use `var` for module-level state; `const` for values that never
|
||||
change.
|
||||
- Always use semicolons.
|
||||
- Scene objects are plain objects (`var scene = {}`) with assigned
|
||||
methods.
|
||||
- Export via `module.exports = scene`.
|
||||
- Async scene init should use `async function` and `await`.
|
||||
|
||||
---
|
||||
|
||||
## Coding style
|
||||
|
||||
See [`.claude/style.md`](.claude/style.md) for the full style guide: indentation, line length, naming, typedefs, defines, include order, `const` usage, assertion placement, error handling, struct initialization, and platform conditionals.
|
||||
### ASCII only
|
||||
Source files (`.c`, `.h`, `.js`) must contain only ASCII characters (U+0000–U+007F).
|
||||
Non-ASCII characters are banned even in comments and string literals.
|
||||
Use ASCII-only substitutes instead:
|
||||
- `--` or `-` instead of `—` (em dash)
|
||||
- `->` instead of `→` (arrow)
|
||||
- `x` or `*` instead of `×` (multiplication)
|
||||
|
||||
## Architecture & systems
|
||||
Only non-script asset files (e.g. `.po` locale files) may contain non-ASCII text.
|
||||
|
||||
| Doc | Covers |
|
||||
|---|---|
|
||||
| [`.claude/architecture.md`](.claude/architecture.md) | Platform abstraction pattern, subsystem lifecycle, error handling, code-generation pipeline |
|
||||
| [`.claude/display.md`](.claude/display.md) | Rendering pipeline: display state, screen, framebuffer, mesh, shader, texture, spritebatch, text |
|
||||
| [`.claude/input.md`](.claude/input.md) | Input actions, buttons, bindings, axis helpers, events |
|
||||
| [`.claude/asset.md`](.claude/asset.md) | Asset archive, entry lifecycle, loader types, async/sync split, low-level file I/O |
|
||||
| [`.claude/ui.md`](.claude/ui.md) | UI element system, textbox, frames, loading overlay, fullbox transitions, FPS counter |
|
||||
| [`.claude/animation.md`](.claude/animation.md) | Keyframe animation, easing functions |
|
||||
| [`.claude/systems.md`](.claude/systems.md) | Time, threading, mutex, events, console, logging, system/platform, network |
|
||||
| [`.claude/util.md`](.claude/util.md) | String, memory, math, fixed-point, array, sort, ref counting, CRC32, endian |
|
||||
| [`.claude/save.md`](.claude/save.md) | Save slots, stream serialization with CRC, locale/i18n |
|
||||
| [`.claude/rpg/index.md`](.claude/rpg/index.md) | RPG layer overview → [world](.claude/rpg/world.md), [entities](.claude/rpg/entity.md), [cutscenes](.claude/rpg/cutscene.md), [story/items](.claude/rpg/story.md) |
|
||||
| [`.claude/display-refactor.md`](.claude/display-refactor.md) | Planned render-queue refactor (Saturn port context) |
|
||||
### Indentation
|
||||
2 spaces. No tabs.
|
||||
|
||||
### Keyword and operator spacing
|
||||
No space between a keyword or function name and its opening parenthesis:
|
||||
|
||||
```c
|
||||
if(!ptr) return;
|
||||
for(uint8_t i = 0; i < count; i++) {
|
||||
while(entry->state != DONE) {
|
||||
switch(type) {
|
||||
sizeof(assetbatch_t)
|
||||
memoryZero(ptr, size)
|
||||
```
|
||||
|
||||
Spaces around all binary operators and after every comma:
|
||||
|
||||
```c
|
||||
pos->flags |= ENTITY_POSITION_FLAG_WORLD_DIRTY;
|
||||
(size_t)end - (size_t)start
|
||||
foo(a, b, c)
|
||||
```
|
||||
|
||||
### Braces
|
||||
Opening brace on the **same line** as the statement (K&R style) for all
|
||||
constructs — functions, `if`, `else`, `for`, `while`, `switch`:
|
||||
|
||||
```c
|
||||
void assetEntryLock(assetentry_t *entry) {
|
||||
...
|
||||
}
|
||||
|
||||
if(dirty) {
|
||||
...
|
||||
} else {
|
||||
...
|
||||
}
|
||||
```
|
||||
|
||||
### Guard returns
|
||||
Short guards go on one line with no braces:
|
||||
|
||||
```c
|
||||
if(!ptr) return;
|
||||
if(!b || !b->batch) return jerry_undefined();
|
||||
if(!(flags & DIRTY)) return;
|
||||
```
|
||||
|
||||
### Blank lines
|
||||
- One blank line between functions; no blank line at the start or end of
|
||||
a function body.
|
||||
- One blank line between logical blocks inside a function body.
|
||||
- No trailing blank lines at the end of a file.
|
||||
|
||||
### Pointer placement
|
||||
`*` is attached to the variable name, not the type:
|
||||
|
||||
```c
|
||||
assetentry_t *entry
|
||||
const char_t *name
|
||||
void *ptr
|
||||
uint8_t *d = (uint8_t *)dest;
|
||||
```
|
||||
|
||||
### Casts
|
||||
Space between cast and operand:
|
||||
|
||||
```c
|
||||
(assetbatch_t *)user
|
||||
(uint8_t *)dest
|
||||
(textureformat_t)v
|
||||
```
|
||||
|
||||
### Return
|
||||
No parentheses around the return value:
|
||||
|
||||
```c
|
||||
return ptr;
|
||||
return MEMORY_POINTERS_IN_USE;
|
||||
```
|
||||
|
||||
### switch / case
|
||||
`case` indented 2 spaces from `switch`; body indented 2 more from `case`:
|
||||
|
||||
```c
|
||||
switch(type) {
|
||||
case ASSET_LOADER_TYPE_TEXTURE:
|
||||
descs[i].input.texture = (textureformat_t)v;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
```
|
||||
|
||||
### Multi-line function signatures
|
||||
When parameters don't fit on one line, put each on its own line indented
|
||||
2 spaces; the closing `) {` (definition) or `);` (declaration) goes on
|
||||
its own line at column 0:
|
||||
|
||||
```c
|
||||
void assetEntryInit(
|
||||
assetentry_t *entry,
|
||||
const char_t *name,
|
||||
const assetloadertype_t type,
|
||||
assetloaderinput_t *input
|
||||
) {
|
||||
|
||||
errorret_t memoryCompare(
|
||||
const void *a,
|
||||
const void *b,
|
||||
const size_t size
|
||||
);
|
||||
```
|
||||
|
||||
### Structs and enums
|
||||
Anonymous inner struct or enum with a `typedef`, `_t` suffix, closing
|
||||
brace and name on the same line:
|
||||
|
||||
```c
|
||||
typedef struct {
|
||||
errorcode_t code;
|
||||
char_t *message;
|
||||
} errorstate_t;
|
||||
|
||||
typedef enum {
|
||||
ASSET_LOADER_TYPE_NULL,
|
||||
ASSET_LOADER_TYPE_COUNT
|
||||
} assetloadertype_t;
|
||||
```
|
||||
|
||||
### Designated initialisers
|
||||
Spaces inside braces; `.field = value`:
|
||||
|
||||
```c
|
||||
jsassetentry_t e = { .entry = entry };
|
||||
assetbatchloadedpend_t init = { .batch = batch };
|
||||
```
|
||||
|
||||
### Ternary operator
|
||||
Spaces around `?` and `:`:
|
||||
|
||||
```c
|
||||
const float val = psx > 0.0f ? pt[0][0] / psx : 0.0f;
|
||||
```
|
||||
|
||||
### const placement
|
||||
`const` before the type, `*` attached to the variable:
|
||||
|
||||
```c
|
||||
const char_t *name
|
||||
const void *src
|
||||
const size_t size
|
||||
```
|
||||
|
||||
### Comments in `.c` files
|
||||
- Do not use section dividers (`/* ---- ... ---- */`). Just let the
|
||||
functions follow one another with a single blank line between them.
|
||||
- Multi-line explanatory comments inside function bodies use `//` lines:
|
||||
```c
|
||||
// Script modules are freed; orphaned JS wrapper objects now get GC'd
|
||||
// so their finalizers fire before assetDispose() checks ref counts.
|
||||
jerry_heap_gc(JERRY_GC_PRESSURE_HIGH);
|
||||
```
|
||||
- Do not use `/* */` for inline or inline-block comments inside `.c`
|
||||
function bodies.
|
||||
|
||||
### Comments in `.h` files
|
||||
Every public declaration gets a Javadoc block (`/** … */`) with
|
||||
`@param` and `@returns` where relevant. Keep it on the lines immediately
|
||||
above the declaration with no blank line in between.
|
||||
|
||||
---
|
||||
|
||||
## Tests
|
||||
- Tests live in `test/` mirroring `src/dusk/` structure.
|
||||
- Use cmocka; include `dusktest.h`.
|
||||
- Test functions: `static void test_something(void **state)`.
|
||||
- After each test, assert `memoryGetAllocatedCount() == 0` to catch
|
||||
leaks.
|
||||
- Build with `-DDUSK_BUILD_TESTS=ON`.
|
||||
|
||||
@@ -1,12 +0,0 @@
|
||||
import sys, os
|
||||
import argparse
|
||||
|
||||
# Check if the script is run with the correct arguments
|
||||
parser = argparse.ArgumentParser(description="Generate chunk header files")
|
||||
parser.add_argument('--assets', required=True, help='Dir to output built assets')
|
||||
parser.add_argument('--headers-dir', required=True, help='Directory to output individual asset headers (required for header build)')
|
||||
parser.add_argument('--output-headers', help='Output header file for built assets (required for header build)')
|
||||
parser.add_argument('--output-assets', required=True, help='Output directory for built assets')
|
||||
parser.add_argument('--output-file', required=True, help='Output file for built assets (required for wad build)')
|
||||
parser.add_argument('--input', required=True, help='Input assets to process', nargs='+')
|
||||
args = parser.parse_args()
|
||||
@@ -1,66 +0,0 @@
|
||||
import sys, os
|
||||
from tools.asset.args import args
|
||||
from tools.asset.process.asset import processAsset
|
||||
from tools.asset.process.palette import processPaletteList
|
||||
from tools.asset.process.tileset import processTilesetList
|
||||
from tools.asset.process.language import processLanguageList
|
||||
from tools.asset.path import getBuiltAssetsRelativePath
|
||||
import zipfile
|
||||
|
||||
# Parse input file args.
|
||||
inputAssets = []
|
||||
for inputArg in args.input:
|
||||
files = inputArg.split('$')
|
||||
for file in files:
|
||||
if str(file).strip() == '':
|
||||
continue
|
||||
|
||||
pieces = file.split('#')
|
||||
|
||||
if len(pieces) < 2:
|
||||
print(f"Error: Invalid input asset format '{file}'. Expected format: type#path[#option1%option2...]")
|
||||
sys.exit(1)
|
||||
|
||||
options = {}
|
||||
if len(pieces) > 2:
|
||||
optionParts = pieces[2].split('%')
|
||||
for part in optionParts:
|
||||
partSplit = part.split('=')
|
||||
|
||||
if len(partSplit) < 1:
|
||||
continue
|
||||
if len(partSplit) == 2:
|
||||
options[partSplit[0]] = partSplit[1]
|
||||
else:
|
||||
options[partSplit[0]] = True
|
||||
|
||||
inputAssets.append({
|
||||
'type': pieces[0],
|
||||
'path': pieces[1],
|
||||
'options': options
|
||||
})
|
||||
|
||||
if not inputAssets:
|
||||
print("Error: No input assets provided.")
|
||||
sys.exit(1)
|
||||
|
||||
# Process each asset.
|
||||
files = []
|
||||
for asset in inputAssets:
|
||||
asset = processAsset(asset)
|
||||
files.extend(asset['files'])
|
||||
|
||||
# Generate additional files
|
||||
files.extend(processLanguageList()['files'])
|
||||
|
||||
# Take assets and add to a zip archive.
|
||||
outputFileName = args.output_file
|
||||
print(f"Creating output file: {outputFileName}")
|
||||
with zipfile.ZipFile(outputFileName, 'w') as zipf:
|
||||
for file in files:
|
||||
relativeOutputPath = getBuiltAssetsRelativePath(file)
|
||||
zipf.write(file, arcname=relativeOutputPath)
|
||||
|
||||
# Generate additional headers.
|
||||
processPaletteList()
|
||||
processTilesetList()
|
||||
@@ -1,12 +0,0 @@
|
||||
processedAssets = {}
|
||||
|
||||
def assetGetCache(assetPath):
|
||||
if assetPath in processedAssets:
|
||||
return processedAssets[assetPath]
|
||||
return None
|
||||
|
||||
def assetCache(assetPath, processedData):
|
||||
if assetPath in processedAssets:
|
||||
return processedAssets[assetPath]
|
||||
processedAssets[assetPath] = processedData
|
||||
return processedData
|
||||
@@ -1,10 +0,0 @@
|
||||
import os
|
||||
from tools.asset.args import args
|
||||
|
||||
def getAssetRelativePath(fullPath):
|
||||
# Get the relative path to the asset
|
||||
return os.path.relpath(fullPath, start=args.assets).replace('\\', '/')
|
||||
|
||||
def getBuiltAssetsRelativePath(fullPath):
|
||||
# Get the relative path to the built asset
|
||||
return os.path.relpath(fullPath, start=args.output_assets).replace('\\', '/')
|
||||
@@ -1,33 +0,0 @@
|
||||
import sys
|
||||
# from processtileset import processTileset
|
||||
from tools.asset.process.image import processImage
|
||||
from tools.asset.process.palette import processPalette
|
||||
from tools.asset.process.tileset import processTileset
|
||||
from tools.asset.process.map import processMap
|
||||
from tools.asset.process.language import processLanguage
|
||||
from tools.asset.process.script import processScript
|
||||
|
||||
processedAssets = []
|
||||
|
||||
def processAsset(asset):
|
||||
if asset['path'] in processedAssets:
|
||||
return
|
||||
processedAssets.append(asset['path'])
|
||||
|
||||
# Handle tiled tilesets
|
||||
t = asset['type'].lower()
|
||||
if t == 'palette':
|
||||
return processPalette(asset)
|
||||
elif t == 'image':
|
||||
return processImage(asset)
|
||||
elif t == 'tileset':
|
||||
return processTileset(asset)
|
||||
elif t == 'map':
|
||||
return processMap(asset)
|
||||
elif t == 'language':
|
||||
return processLanguage(asset)
|
||||
elif t == 'script':
|
||||
return processScript(asset)
|
||||
else:
|
||||
print(f"Error: Unknown asset type '{asset['type']}' for path '{asset['path']}'")
|
||||
sys.exit(1)
|
||||
@@ -1,134 +0,0 @@
|
||||
import os
|
||||
import sys
|
||||
from PIL import Image
|
||||
from tools.asset.process.palette import extractPaletteFromImage, palettes
|
||||
from tools.asset.args import args
|
||||
from tools.asset.path import getAssetRelativePath
|
||||
from tools.asset.cache import assetGetCache, assetCache
|
||||
|
||||
images = []
|
||||
|
||||
def processImage(asset):
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
type = None
|
||||
if 'type' in asset['options']:
|
||||
type = asset['options'].get('type', 'PALETTIZED').upper()
|
||||
|
||||
if type == 'PALETTIZED' or type is None:
|
||||
return assetCache(asset['path'], processPalettizedImage(asset))
|
||||
elif type == 'ALPHA':
|
||||
return assetCache(asset['path'], processAlphaImage(asset))
|
||||
else:
|
||||
print(f"Error: Unknown image type {type} for asset {asset['path']}")
|
||||
sys.exit(1)
|
||||
|
||||
def processPalettizedImage(asset):
|
||||
assetPath = asset['path']
|
||||
cache = assetGetCache(assetPath)
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
image = Image.open(assetPath)
|
||||
imagePalette = extractPaletteFromImage(image)
|
||||
|
||||
# Find palette that contains every color
|
||||
palette = None
|
||||
for p in palettes:
|
||||
hasAllColors = True
|
||||
for color in imagePalette:
|
||||
for palColor in p['pixels']:
|
||||
if color[0] == palColor[0] and color[1] == palColor[1] and color[2] == palColor[2] and color[3] == palColor[3]:
|
||||
break
|
||||
elif color[3] == 0 and palColor[3] == 0:
|
||||
break
|
||||
else:
|
||||
print('Pallete {} does not contain color #{}'.format(p['paletteName'], '{:02x}{:02x}{:02x}{:02x}'.format(color[0], color[1], color[2], color[3])))
|
||||
hasAllColors = False
|
||||
break
|
||||
if hasAllColors:
|
||||
palette = p
|
||||
break
|
||||
|
||||
if palette is None:
|
||||
palette = palettes[0] # Just to avoid reference error
|
||||
print(f"No matching palette found for {assetPath}!")
|
||||
# Find which pixel is missing
|
||||
for color in imagePalette:
|
||||
if color in palette['pixels']:
|
||||
continue
|
||||
# Convert to hex (with alpha)
|
||||
hexColor = '#{:02x}{:02x}{:02x}{:02x}'.format(color[0], color[1], color[2], color[3])
|
||||
print(f"Missing color: {hexColor} in palette {palette['paletteName']}")
|
||||
sys.exit(1)
|
||||
|
||||
print(f"Converting image {assetPath} to use palette")
|
||||
|
||||
paletteIndexes = []
|
||||
for pixel in list(image.getdata()):
|
||||
if pixel[3] == 0:
|
||||
pixel = (0, 0, 0, 0)
|
||||
paletteIndex = palette['pixels'].index(pixel)
|
||||
paletteIndexes.append(paletteIndex)
|
||||
|
||||
data = bytearray()
|
||||
data.extend(b"DPI") # Dusk Palettized Image
|
||||
data.extend(image.width.to_bytes(4, 'little')) # Width
|
||||
data.extend(image.height.to_bytes(4, 'little')) # Height
|
||||
data.append(palette['paletteIndex']) # Palette index
|
||||
for paletteIndex in paletteIndexes:
|
||||
if paletteIndex > 255 or paletteIndex < 0:
|
||||
print(f"Error: Palette index {paletteIndex} exceeds 255!")
|
||||
sys.exit(1)
|
||||
data.append(paletteIndex.to_bytes(1, 'little')[0]) # Pixel index
|
||||
|
||||
relative = getAssetRelativePath(assetPath)
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(assetPath))[0]
|
||||
outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dpi")
|
||||
outputFilePath = os.path.join(args.output_assets, outputFileRelative)
|
||||
os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
|
||||
with open(outputFilePath, "wb") as f:
|
||||
f.write(data)
|
||||
|
||||
outImage = {
|
||||
"imagePath": outputFileRelative,
|
||||
"files": [ outputFilePath ],
|
||||
'width': image.width,
|
||||
'height': image.height,
|
||||
}
|
||||
return assetCache(assetPath, outImage)
|
||||
|
||||
def processAlphaImage(asset):
|
||||
assetPath = asset['path']
|
||||
cache = assetGetCache(assetPath)
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
print(f"Processing alpha image: {assetPath}")
|
||||
|
||||
data = bytearray()
|
||||
data.extend(b"DAI") # Dusk Alpha Image
|
||||
image = Image.open(assetPath).convert("RGBA")
|
||||
data.extend(image.width.to_bytes(4, 'little')) # Width
|
||||
data.extend(image.height.to_bytes(4, 'little')) # Height
|
||||
for pixel in list(image.getdata()):
|
||||
# Only write alpha channel
|
||||
data.append(pixel[3].to_bytes(1, 'little')[0]) # Pixel alpha
|
||||
|
||||
relative = getAssetRelativePath(assetPath)
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(assetPath))[0]
|
||||
outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dai")
|
||||
outputFilePath = os.path.join(args.output_assets, outputFileRelative)
|
||||
os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
|
||||
with open(outputFilePath, "wb") as f:
|
||||
f.write(data)
|
||||
|
||||
outImage = {
|
||||
"imagePath": outputFileRelative,
|
||||
"files": [ outputFilePath ],
|
||||
'width': image.width,
|
||||
'height': image.height,
|
||||
}
|
||||
return assetCache(assetPath, outImage)
|
||||
@@ -1,228 +0,0 @@
|
||||
import sys
|
||||
import os
|
||||
from tools.asset.args import args
|
||||
from tools.asset.cache import assetCache, assetGetCache
|
||||
from tools.asset.path import getAssetRelativePath
|
||||
from tools.dusk.defs import defs
|
||||
import polib
|
||||
import re
|
||||
|
||||
LANGUAGE_CHUNK_CHAR_COUNT = int(defs.get('ASSET_LANG_CHUNK_CHAR_COUNT'))
|
||||
|
||||
LANGUAGE_DATA = {}
|
||||
LANGUAGE_KEYS = []
|
||||
|
||||
def processLanguageList():
|
||||
# Language keys header data
|
||||
headerKeys = "// Auto-generated language keys header file.\n"
|
||||
headerKeys += "#pragma once\n"
|
||||
headerKeys += "#include \"dusk.h\"\n\n"
|
||||
|
||||
# This is the desired chunk groups list.. if a language key STARTS with any
|
||||
# of the keys in this list we would "like to" put it in that chunk group.
|
||||
# If there is no match, or the list is full then we will add it to the next
|
||||
# available chunk group (that isn't a 'desired' one). If the chunk becomes
|
||||
# full, then we attempt to make another chunk with the same prefix so that
|
||||
# a second batching can occur.
|
||||
desiredChunkGroups = {
|
||||
'ui': 0
|
||||
}
|
||||
|
||||
# Now, for each language key, create the header reference and index.
|
||||
keyIndex = 0
|
||||
languageKeyIndexes = {}
|
||||
languageKeyChunk = {}
|
||||
languageKeyChunkIndexes = {}
|
||||
languageKeyChunkOffsets = {}
|
||||
for key in LANGUAGE_KEYS:
|
||||
headerKeys += f"#define {getLanguageVariableName(key)} {keyIndex}\n"
|
||||
languageKeyIndexes[key] = keyIndex
|
||||
keyIndex += 1
|
||||
|
||||
# Find desired chunk group
|
||||
assignedChunk = None
|
||||
for desiredKey in desiredChunkGroups:
|
||||
if key.lower().startswith(desiredKey):
|
||||
assignedChunk = desiredChunkGroups[desiredKey]
|
||||
break
|
||||
# If no desired chunk group matched, assign to -1
|
||||
if assignedChunk is None:
|
||||
assignedChunk = -1
|
||||
languageKeyChunk[key] = assignedChunk
|
||||
|
||||
# Setup header.
|
||||
for lang in LANGUAGE_DATA:
|
||||
if key not in LANGUAGE_DATA[lang]:
|
||||
print(f"Warning: Missing translation for key '{key}' in language '{lang}'")
|
||||
sys.exit(1)
|
||||
|
||||
# Seal the header.
|
||||
headerKeys += f"\n#define LANG_KEY_COUNT {len(LANGUAGE_KEYS)}\n"
|
||||
|
||||
# Now we can generate the language string chunks.
|
||||
nextChunkIndex = max(desiredChunkGroups.values()) + 1
|
||||
files = []
|
||||
|
||||
for lang in LANGUAGE_DATA:
|
||||
langData = LANGUAGE_DATA[lang]
|
||||
|
||||
# Key = chunkIndex, value = chunkInfo
|
||||
languageChunks = {}
|
||||
for key in LANGUAGE_KEYS:
|
||||
keyIndex = languageKeyIndexes[key]
|
||||
chunkIndex = languageKeyChunk[key]
|
||||
wasSetChunk = chunkIndex != -1
|
||||
|
||||
# This will keep looping until we find a chunk
|
||||
while True:
|
||||
# Determine the next chunkIndex IF chunkIndex is -1
|
||||
if chunkIndex == -1:
|
||||
chunkIndex = nextChunkIndex
|
||||
|
||||
# Is the chunk full?
|
||||
curLen = languageChunks.get(chunkIndex, {'len': 0})['len']
|
||||
newLen = curLen + len(langData[key])
|
||||
if newLen > LANGUAGE_CHUNK_CHAR_COUNT:
|
||||
# Chunk is full, need to create a new chunk.
|
||||
chunkIndex = -1
|
||||
if wasSetChunk:
|
||||
wasSetChunk = False
|
||||
else:
|
||||
nextChunkIndex += 1
|
||||
continue
|
||||
|
||||
# Chunk is not full, we can use it.
|
||||
if chunkIndex not in languageChunks:
|
||||
languageChunks[chunkIndex] = {
|
||||
'len': 0,
|
||||
'keys': []
|
||||
}
|
||||
languageChunks[chunkIndex]['len'] = newLen
|
||||
languageChunks[chunkIndex]['keys'].append(key)
|
||||
languageKeyChunkIndexes[key] = chunkIndex
|
||||
languageKeyChunkOffsets[key] = curLen
|
||||
break
|
||||
|
||||
# We have now chunked all the keys for this language!
|
||||
langBuffer = b""
|
||||
|
||||
# Write header info
|
||||
langBuffer += b'DLF' # Dusk Language File
|
||||
|
||||
for key in LANGUAGE_KEYS:
|
||||
# Write the chunk that this key belongs to as uint32_t
|
||||
chunkIndex = languageKeyChunkIndexes[key]
|
||||
langBuffer += chunkIndex.to_bytes(4, byteorder='little')
|
||||
|
||||
# Write the offset for this key as uint32_t
|
||||
offset = languageKeyChunkOffsets[key]
|
||||
langBuffer += offset.to_bytes(4, byteorder='little')
|
||||
|
||||
# Write the length of the string as uint32_t
|
||||
strData = langData[key].encode('utf-8')
|
||||
langBuffer += len(strData).to_bytes(4, byteorder='little')
|
||||
|
||||
# Now write out each chunk's string data, packed tight and no null term.
|
||||
for chunkIndex in sorted(languageChunks.keys()):
|
||||
chunkInfo = languageChunks[chunkIndex]
|
||||
for key in chunkInfo['keys']:
|
||||
strData = langData[key].encode('utf-8')
|
||||
langBuffer += strData
|
||||
|
||||
# Now pad the chunk to full size
|
||||
curLen = chunkInfo['len']
|
||||
if curLen < LANGUAGE_CHUNK_CHAR_COUNT:
|
||||
padSize = LANGUAGE_CHUNK_CHAR_COUNT - curLen
|
||||
langBuffer += b'\0' * padSize
|
||||
|
||||
# Write out the language data file
|
||||
outputFile = os.path.join(args.output_assets, "language", f"{lang}.dlf")
|
||||
files.append(outputFile)
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, "wb") as f:
|
||||
f.write(langBuffer)
|
||||
|
||||
# Write out the language keys header file
|
||||
outputFile = os.path.join(args.headers_dir, "locale", "language", "keys.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, "w") as f:
|
||||
f.write(headerKeys)
|
||||
|
||||
# Generate language list.
|
||||
langValues = {}
|
||||
headerLocale = "#pragma once\n#include \"locale/localeinfo.h\"\n\n"
|
||||
headerLocale += "typedef enum {\n"
|
||||
count = 0
|
||||
headerLocale += f" DUSK_LOCALE_NULL = {count},\n"
|
||||
count += 1
|
||||
for lang in LANGUAGE_DATA:
|
||||
langKey = lang.replace('-', '_').replace(' ', '_').upper()
|
||||
langValues[lang] = count
|
||||
headerLocale += f" DUSK_LOCALE_{langKey} = {count},\n"
|
||||
count += 1
|
||||
headerLocale += f" DUSK_LOCALE_COUNT = {count}\n"
|
||||
headerLocale += "} dusklocale_t;\n\n"
|
||||
|
||||
headerLocale += f"static const localeinfo_t LOCALE_INFOS[DUSK_LOCALE_COUNT] = {{\n"
|
||||
for lang in LANGUAGE_DATA:
|
||||
langKey = lang.replace('-', '_').replace(' ', '_').upper()
|
||||
headerLocale += f" [DUSK_LOCALE_{langKey}] = {{\n"
|
||||
headerLocale += f" .file = \"{lang}\"\n"
|
||||
headerLocale += f" }},\n"
|
||||
headerLocale += "};\n"
|
||||
|
||||
headerLocale += f"static const char_t *LOCALE_SCRIPT = \n"
|
||||
for lang in LANGUAGE_DATA:
|
||||
langKey = lang.replace('-', '_').replace(' ', '_').upper()
|
||||
langValue = langValues[lang]
|
||||
headerLocale += f" \"DUSK_LOCALE_{langKey} = {langValue}\\n\"\n"
|
||||
headerLocale += ";\n"
|
||||
|
||||
# Write out the locale enum header file
|
||||
outputFile = os.path.join(args.headers_dir, "locale", "locale.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, "w") as f:
|
||||
f.write(headerLocale)
|
||||
|
||||
return {
|
||||
'files': files
|
||||
}
|
||||
|
||||
def getLanguageVariableName(languageKey):
|
||||
# Take the language key, prepend LANG_, uppercase, replace any non symbols
|
||||
# with _
|
||||
key = languageKey.strip().upper()
|
||||
key = re.sub(r'[^A-Z0-9]', '_', key)
|
||||
return f"LANG_{key}"
|
||||
|
||||
def processLanguage(asset):
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
# Load PO File
|
||||
po = polib.pofile(asset['path'])
|
||||
|
||||
langName = po.metadata.get('Language')
|
||||
if langName not in LANGUAGE_DATA:
|
||||
LANGUAGE_DATA[langName] = {}
|
||||
|
||||
for entry in po:
|
||||
key = entry.msgid
|
||||
val = entry.msgstr
|
||||
|
||||
if key not in LANGUAGE_KEYS:
|
||||
LANGUAGE_KEYS.append(key)
|
||||
|
||||
if key not in LANGUAGE_DATA[langName]:
|
||||
LANGUAGE_DATA[langName][key] = val
|
||||
else:
|
||||
print(f"Error: Duplicate translation key '{key}' in language '{langName}'")
|
||||
sys.exit(1)
|
||||
|
||||
outLanguageData = {
|
||||
'data': po,
|
||||
'path': asset['path'],
|
||||
'files': []
|
||||
}
|
||||
return assetCache(asset['path'], outLanguageData)
|
||||
@@ -1,154 +0,0 @@
|
||||
import struct
|
||||
import sys
|
||||
import os
|
||||
import json
|
||||
from tools.asset.args import args
|
||||
from tools.asset.cache import assetCache, assetGetCache
|
||||
from tools.asset.path import getAssetRelativePath
|
||||
from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_TILE_COUNT
|
||||
from tools.dusk.map import Map
|
||||
from tools.dusk.chunk import Chunk
|
||||
|
||||
def convertModelData(modelData):
|
||||
# TLDR; Model data stores things efficiently with indices, but we buffer it
|
||||
# out to 6 vertex quads for simplicity.
|
||||
outVertices = []
|
||||
outUVs = []
|
||||
outColors = []
|
||||
for indice in modelData['indices']:
|
||||
vertex = modelData['vertices'][indice]
|
||||
uv = modelData['uvs'][indice]
|
||||
color = modelData['colors'][indice]
|
||||
outVertices.append(vertex)
|
||||
outUVs.append(uv)
|
||||
outColors.append(color)
|
||||
|
||||
return {
|
||||
'vertices': outVertices,
|
||||
'uvs': outUVs,
|
||||
'colors': outColors
|
||||
}
|
||||
|
||||
def processChunk(chunk):
|
||||
cache = assetGetCache(chunk.getFilename())
|
||||
if cache:
|
||||
return cache
|
||||
|
||||
baseModel = {
|
||||
'vertices': [],
|
||||
'colors': [],
|
||||
'uvs': []
|
||||
}
|
||||
models = [ baseModel ]
|
||||
|
||||
for tileIndex, tile in chunk.tiles.items():
|
||||
tileBase = tile.getBaseTileModel()
|
||||
|
||||
convertedBase = convertModelData(tileBase)
|
||||
baseModel['vertices'].extend(convertedBase['vertices'])
|
||||
baseModel['colors'].extend(convertedBase['colors'])
|
||||
baseModel['uvs'].extend(convertedBase['uvs'])
|
||||
|
||||
# Generate binary buffer for efficient output
|
||||
buffer = bytearray()
|
||||
buffer.extend(b'DMC')# Header
|
||||
buffer.extend(len(chunk.tiles).to_bytes(4, 'little')) # Number of tiles
|
||||
buffer.extend(len(models).to_bytes(1, 'little')) # Number of models
|
||||
buffer.extend(len(chunk.entities).to_bytes(1, 'little')) # Number of entities
|
||||
|
||||
# Buffer tile data as array of uint8_t
|
||||
for tileIndex, tile in chunk.tiles.items():
|
||||
buffer.extend(tile.shape.to_bytes(1, 'little'))
|
||||
|
||||
# # For each model
|
||||
for model in models:
|
||||
vertexCount = len(model['vertices'])
|
||||
buffer.extend(vertexCount.to_bytes(4, 'little'))
|
||||
for i in range(vertexCount):
|
||||
vertex = model['vertices'][i]
|
||||
uv = model['uvs'][i]
|
||||
color = model['colors'][i]
|
||||
|
||||
buffer.extend(color[0].to_bytes(1, 'little'))
|
||||
buffer.extend(color[1].to_bytes(1, 'little'))
|
||||
buffer.extend(color[2].to_bytes(1, 'little'))
|
||||
buffer.extend(color[3].to_bytes(1, 'little'))
|
||||
|
||||
buffer.extend(bytearray(struct.pack('<f', uv[0])))
|
||||
buffer.extend(bytearray(struct.pack('<f', uv[1])))
|
||||
|
||||
buffer.extend(bytearray(struct.pack('<f', vertex[0])))
|
||||
buffer.extend(bytearray(struct.pack('<f', vertex[1])))
|
||||
buffer.extend(bytearray(struct.pack('<f', vertex[2])))
|
||||
|
||||
# For each entity
|
||||
for entity in chunk.entities.values():
|
||||
buffer.extend(entity.type.to_bytes(1, 'little'))
|
||||
buffer.extend(entity.localX.to_bytes(1, 'little'))
|
||||
buffer.extend(entity.localY.to_bytes(1, 'little'))
|
||||
buffer.extend(entity.localZ.to_bytes(1, 'little'))
|
||||
pass
|
||||
|
||||
# Write out map file
|
||||
relative = getAssetRelativePath(chunk.getFilename())
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(relative))[0]
|
||||
outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dmc")
|
||||
outputFilePath = os.path.join(args.output_assets, outputFileRelative)
|
||||
os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
|
||||
with open(outputFilePath, "wb") as f:
|
||||
f.write(buffer)
|
||||
|
||||
outChunk = {
|
||||
'files': [ outputFilePath ],
|
||||
'chunk': chunk
|
||||
}
|
||||
return assetCache(chunk.getFilename(), outChunk)
|
||||
|
||||
def processMap(asset):
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
map = Map(None)
|
||||
map.load(asset['path'])
|
||||
chunksDir = map.getChunkDirectory()
|
||||
|
||||
files = os.listdir(chunksDir)
|
||||
if len(files) == 0:
|
||||
print(f"Error: No chunk files found in {chunksDir}.")
|
||||
sys.exit(1)
|
||||
|
||||
chunkFiles = []
|
||||
for fileName in files:
|
||||
if not fileName.endswith('.json'):
|
||||
continue
|
||||
|
||||
fNameNoExt = os.path.splitext(fileName)[0]
|
||||
fnPieces = fNameNoExt.split('_')
|
||||
if len(fnPieces) != 3:
|
||||
print(f"Error: Chunk filename {fileName} does not contain valid chunk coordinates.")
|
||||
sys.exit(1)
|
||||
chunk = Chunk(map, int(fnPieces[0]), int(fnPieces[1]), int(fnPieces[2]))
|
||||
chunk.load()
|
||||
result = processChunk(chunk)
|
||||
chunkFiles.extend(result['files'])
|
||||
|
||||
# Map file
|
||||
outBuffer = bytearray()
|
||||
outBuffer.extend(b'DMF')
|
||||
outBuffer.extend(len(chunkFiles).to_bytes(4, 'little'))
|
||||
|
||||
# DMF (Dusk Map file)
|
||||
fileRelative = getAssetRelativePath(asset['path'])
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(fileRelative))[0]
|
||||
outputMapRelative = os.path.join(os.path.dirname(fileRelative), f"{fileNameWithoutExt}.dmf")
|
||||
outputMapPath = os.path.join(args.output_assets, outputMapRelative)
|
||||
os.makedirs(os.path.dirname(outputMapPath), exist_ok=True)
|
||||
with open(outputMapPath, "wb") as f:
|
||||
f.write(outBuffer)
|
||||
|
||||
outMap = {
|
||||
'files': chunkFiles
|
||||
}
|
||||
outMap['files'].append(outputMapPath)
|
||||
return assetCache(asset['path'], outMap)
|
||||
@@ -1,96 +0,0 @@
|
||||
import json
|
||||
import os
|
||||
from PIL import Image
|
||||
import datetime
|
||||
from tools.asset.args import args
|
||||
from tools.asset.cache import assetCache, assetGetCache
|
||||
|
||||
palettes = []
|
||||
|
||||
def extractPaletteFromImage(image):
|
||||
# goes through and finds all unique colors in the image
|
||||
if image.mode != 'RGBA':
|
||||
image = image.convert('RGBA')
|
||||
pixels = list(image.getdata())
|
||||
uniqueColors = []
|
||||
for color in pixels:
|
||||
# We treat all alpha 0 as rgba(0,0,0,0) for palette purposes
|
||||
if color[3] == 0:
|
||||
color = (0, 0, 0, 0)
|
||||
if color not in uniqueColors:
|
||||
uniqueColors.append(color)
|
||||
return uniqueColors
|
||||
|
||||
def processPalette(asset):
|
||||
print(f"Processing palette: {asset['path']}")
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
paletteIndex = len(palettes)
|
||||
image = Image.open(asset['path'])
|
||||
pixels = extractPaletteFromImage(image)
|
||||
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(asset['path']))[0]
|
||||
fileNameWithoutPalette = os.path.splitext(fileNameWithoutExt)[0]
|
||||
|
||||
# PSP requires that the palette size be a power of two, so we will pad the
|
||||
# palette with transparent colors if needed.
|
||||
def mathNextPowTwo(x):
|
||||
return 1 << (x - 1).bit_length()
|
||||
|
||||
nextPowTwo = mathNextPowTwo(len(pixels))
|
||||
while len(pixels) < nextPowTwo:
|
||||
pixels.append((0, 0, 0, 0))
|
||||
|
||||
# Header
|
||||
now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
data = f"// Palette Generated for {asset['path']} at {now}\n"
|
||||
data += f"#include \"display/palette/palette.h\"\n\n"
|
||||
data += f"#define PALETTE_{paletteIndex}_COLOR_COUNT {len(pixels)}\n\n"
|
||||
data += f"#pragma pack(push, 1)\n"
|
||||
data += f"static const color_t PALETTE_{paletteIndex}_COLORS[PALETTE_{paletteIndex}_COLOR_COUNT] = {{\n"
|
||||
for pixel in pixels:
|
||||
data += f" {{ 0x{pixel[0]:02X}, 0x{pixel[1]:02X}, 0x{pixel[2]:02X}, 0x{pixel[3]:02X} }},\n"
|
||||
data += f"}};\n"
|
||||
data += f"#pragma pack(pop)\n\n"
|
||||
data += f"static const palette_t PALETTE_{paletteIndex} = {{\n"
|
||||
data += f" .colorCount = PALETTE_{paletteIndex}_COLOR_COUNT,\n"
|
||||
data += f" .colors = PALETTE_{paletteIndex}_COLORS,\n"
|
||||
data += f"}};\n"
|
||||
|
||||
# Write Header
|
||||
outputFile = os.path.join(args.headers_dir, "display", "palette", f"palette_{paletteIndex}.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, "w") as f:
|
||||
f.write(data)
|
||||
|
||||
palette = {
|
||||
"paletteIndex": paletteIndex,
|
||||
"paletteName": fileNameWithoutPalette,
|
||||
"pixels": pixels,
|
||||
"headerFile": os.path.relpath(outputFile, args.headers_dir),
|
||||
"asset": asset,
|
||||
"files": [ ],# No zippable files.
|
||||
}
|
||||
|
||||
palettes.append(palette)
|
||||
return assetCache(asset['path'], palette)
|
||||
|
||||
def processPaletteList():
|
||||
data = f"// Auto-generated palette list\n"
|
||||
print(f"Generating palette list with {len(palettes)} palettes.")
|
||||
for palette in palettes:
|
||||
data += f"#include \"{palette['headerFile']}\"\n"
|
||||
data += f"\n"
|
||||
data += f"#define PALETTE_LIST_COUNT {len(palettes)}\n\n"
|
||||
data += f"static const palette_t* PALETTE_LIST[PALETTE_LIST_COUNT] = {{\n"
|
||||
for palette in palettes:
|
||||
data += f" &PALETTE_{palette['paletteIndex']},\n"
|
||||
data += f"}};\n"
|
||||
|
||||
# Write the palette list to a header file
|
||||
outputFile = os.path.join(args.headers_dir, "display", "palette", "palettelist.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, "w") as f:
|
||||
f.write(data)
|
||||
@@ -1,43 +0,0 @@
|
||||
import sys
|
||||
import os
|
||||
from tools.asset.args import args
|
||||
from tools.asset.cache import assetCache, assetGetCache
|
||||
from tools.asset.path import getAssetRelativePath
|
||||
from tools.dusk.defs import fileDefs
|
||||
|
||||
def processScript(asset):
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
# Load the lua file as a string
|
||||
with open(asset['path'], 'r', encoding='utf-8') as f:
|
||||
luaCode = f.read()
|
||||
|
||||
# TODO: I will precompile or minify the Lua code here in the future
|
||||
|
||||
# Replace all definitions in the code
|
||||
for key, val in fileDefs.items():
|
||||
luaCode = luaCode.replace(key, str(val))
|
||||
|
||||
# Create output Dusk Script File (DSF) data
|
||||
data = ""
|
||||
data += "DSF"
|
||||
data += luaCode
|
||||
|
||||
# Write to relative output file path.
|
||||
relative = getAssetRelativePath(asset['path'])
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(asset['path']))[0]
|
||||
outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dsf")
|
||||
outputFilePath = os.path.join(args.output_assets, outputFileRelative)
|
||||
os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
|
||||
with open(outputFilePath, "wb") as f:
|
||||
f.write(data.encode('utf-8'))
|
||||
|
||||
outScript = {
|
||||
'data': data,
|
||||
'path': asset['path'],
|
||||
'files': [ outputFilePath ],
|
||||
'scriptPath': outputFileRelative,
|
||||
}
|
||||
return assetCache(asset['path'], outScript)
|
||||
@@ -1,178 +0,0 @@
|
||||
import json
|
||||
import sys
|
||||
import os
|
||||
import datetime
|
||||
from xml.etree import ElementTree
|
||||
from tools.asset.process.image import processImage
|
||||
from tools.asset.path import getAssetRelativePath
|
||||
from tools.asset.args import args
|
||||
from tools.asset.cache import assetGetCache, assetCache
|
||||
|
||||
tilesets = []
|
||||
|
||||
def loadTilesetFromTSX(asset):
|
||||
# Load the TSX file
|
||||
tree = ElementTree.parse(asset['path'])
|
||||
root = tree.getroot()
|
||||
|
||||
# Expect tileheight, tilewidth, columns and tilecount attributes
|
||||
if 'tilewidth' not in root.attrib or 'tileheight' not in root.attrib or 'columns' not in root.attrib or 'tilecount' not in root.attrib:
|
||||
print(f"Error: TSX file {asset['path']} is missing required attributes (tilewidth, tileheight, columns, tilecount)")
|
||||
sys.exit(1)
|
||||
|
||||
tileWidth = int(root.attrib['tilewidth'])
|
||||
tileHeight = int(root.attrib['tileheight'])
|
||||
columns = int(root.attrib['columns'])
|
||||
tileCount = int(root.attrib['tilecount'])
|
||||
rows = (tileCount + columns - 1) // columns # Calculate rows based on tileCount and columns
|
||||
|
||||
# Find the image element
|
||||
imageElement = root.find('image')
|
||||
if imageElement is None or 'source' not in imageElement.attrib:
|
||||
print(f"Error: TSX file {asset['path']} is missing an image element with a source attribute")
|
||||
sys.exit(1)
|
||||
|
||||
imagePath = imageElement.attrib['source']
|
||||
|
||||
# Image is relative to the TSX file
|
||||
imageAssetPath = os.path.join(os.path.dirname(asset['path']), imagePath)
|
||||
|
||||
image = processImage({
|
||||
'path': imageAssetPath,
|
||||
'options': asset['options'],
|
||||
})
|
||||
|
||||
return {
|
||||
"image": image,
|
||||
"tileWidth": tileWidth,
|
||||
"tileHeight": tileHeight,
|
||||
"columns": columns,
|
||||
"rows": rows,
|
||||
"originalWidth": tileWidth * columns,
|
||||
"originalHeight": tileHeight * rows,
|
||||
}
|
||||
|
||||
def loadTilesetFromArgs(asset):
|
||||
# We need to determine how big each tile is. This can either be provided as
|
||||
# an arg of tileWidth/tileHeight or as a count of rows/columns.
|
||||
# Additionally, if the image has been factored, then the user can provide both
|
||||
# tile sizes AND cols/rows to indicate the original size of the image.
|
||||
image = processImage(asset)
|
||||
|
||||
tileWidth, tileHeight = None, None
|
||||
columns, rows = None, None
|
||||
originalWidth, originalHeight = image['width'], image['height']
|
||||
|
||||
if 'tileWidth' in asset['options'] and 'columns' in asset['options']:
|
||||
tileWidth = int(asset['options']['tileWidth'])
|
||||
columns = int(asset['options']['columns'])
|
||||
originalWidth = tileWidth * columns
|
||||
elif 'tileWidth' in asset['options']:
|
||||
tileWidth = int(asset['options']['tileWidth'])
|
||||
columns = image['width'] // tileWidth
|
||||
elif 'columns' in asset['options']:
|
||||
columns = int(asset['options']['columns'])
|
||||
tileWidth = image['width'] // columns
|
||||
else:
|
||||
print(f"Error: Tileset {asset['path']} must specify either tileWidth or columns")
|
||||
sys.exit(1)
|
||||
|
||||
if 'tileHeight' in asset['options'] and 'rows' in asset['options']:
|
||||
tileHeight = int(asset['options']['tileHeight'])
|
||||
rows = int(asset['options']['rows'])
|
||||
originalHeight = tileHeight * rows
|
||||
elif 'tileHeight' in asset['options']:
|
||||
tileHeight = int(asset['options']['tileHeight'])
|
||||
rows = image['height'] // tileHeight
|
||||
elif 'rows' in asset['options']:
|
||||
rows = int(asset['options']['rows'])
|
||||
tileHeight = image['height'] // rows
|
||||
else:
|
||||
print(f"Error: Tileset {asset['path']} must specify either tileHeight or rows")
|
||||
sys.exit(1)
|
||||
|
||||
return {
|
||||
"image": image,
|
||||
"tileWidth": tileWidth,
|
||||
"tileHeight": tileHeight,
|
||||
"columns": columns,
|
||||
"rows": rows,
|
||||
"originalWidth": originalWidth,
|
||||
"originalHeight": originalHeight,
|
||||
}
|
||||
|
||||
def processTileset(asset):
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
print(f"Processing tileset: {asset['path']}")
|
||||
tilesetData = None
|
||||
if asset['path'].endswith('.tsx'):
|
||||
tilesetData = loadTilesetFromTSX(asset)
|
||||
else:
|
||||
tilesetData = loadTilesetFromArgs(asset)
|
||||
|
||||
fileNameWithoutExtension = os.path.splitext(os.path.basename(asset['path']))[0]
|
||||
now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
tilesetName = fileNameWithoutExtension
|
||||
tilesetNameUpper = tilesetName.upper()
|
||||
|
||||
widthScale = tilesetData['originalWidth'] / tilesetData['image']['width']
|
||||
heightScale = tilesetData['originalHeight'] / tilesetData['image']['height']
|
||||
|
||||
# Create header
|
||||
data = f"// Tileset Generated for {asset['path']} at {now}\n"
|
||||
data += f"#pragma once\n"
|
||||
data += f"#include \"display/tileset/tileset.h\"\n\n"
|
||||
data += f"static const tileset_t TILESET_{tilesetNameUpper} = {{\n"
|
||||
data += f" .name = {json.dumps(tilesetName)},\n"
|
||||
data += f" .tileWidth = {tilesetData['tileWidth']},\n"
|
||||
data += f" .tileHeight = {tilesetData['tileHeight']},\n"
|
||||
data += f" .tileCount = {tilesetData['columns'] * tilesetData['rows']},\n"
|
||||
data += f" .columns = {tilesetData['columns']},\n"
|
||||
data += f" .rows = {tilesetData['rows']},\n"
|
||||
data += f" .uv = {{ {widthScale / tilesetData['columns']}f, {heightScale / tilesetData['rows']}f }},\n"
|
||||
data += f" .image = {json.dumps(tilesetData['image']['imagePath'])},\n"
|
||||
data += f"}};\n"
|
||||
|
||||
|
||||
# Write Header
|
||||
outputFile = os.path.join(args.headers_dir, "display", "tileset", f"tileset_{tilesetName}.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, 'w') as f:
|
||||
f.write(data)
|
||||
|
||||
print(f"Write header for tileset: {outputFile}")
|
||||
|
||||
tileset = {
|
||||
"files": [],
|
||||
"image": tilesetData['image'],
|
||||
"headerFile": os.path.relpath(outputFile, args.headers_dir),
|
||||
"tilesetName": tilesetName,
|
||||
"tilesetNameUpper": tilesetNameUpper,
|
||||
"tilesetIndex": len(tilesets),
|
||||
"tilesetData": tilesetData,
|
||||
"files": tilesetData['image']['files'],
|
||||
}
|
||||
|
||||
tilesets.append(tileset)
|
||||
return assetCache(asset['path'], tileset)
|
||||
|
||||
def processTilesetList():
|
||||
data = f"// Tileset List Generated at {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
|
||||
data += f"#pragma once\n"
|
||||
for tileset in tilesets:
|
||||
data += f"#include \"{tileset['headerFile']}\"\n"
|
||||
data += f"\n"
|
||||
data += f"#define TILESET_LIST_COUNT {len(tilesets)}\n\n"
|
||||
data += f"static const tileset_t* TILESET_LIST[TILESET_LIST_COUNT] = {{\n"
|
||||
for tileset in tilesets:
|
||||
data += f" &TILESET_{tileset['tilesetNameUpper']},\n"
|
||||
data += f"}};\n"
|
||||
|
||||
# Write header.
|
||||
outputFile = os.path.join(args.headers_dir, "display", "tileset", f"tilesetlist.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, 'w') as f:
|
||||
f.write(data)
|
||||
@@ -1,47 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "assetpalette.h"
|
||||
#include "asset/assettype.h"
|
||||
#include "assert/assert.h"
|
||||
|
||||
errorret_t assetPaletteLoad(assetentire_t entire) {
|
||||
assertNotNull(entire.data, "Data pointer cannot be NULL.");
|
||||
assertNotNull(entire.output, "Output pointer cannot be NULL.");
|
||||
|
||||
assetpalette_t *assetData = (assetpalette_t *)entire.data;
|
||||
palette_t *palette = (palette_t *)entire.output;
|
||||
|
||||
// Read header and version (first 4 bytes)
|
||||
if(
|
||||
assetData->header[0] != 'D' ||
|
||||
assetData->header[1] != 'P' ||
|
||||
assetData->header[2] != 'F'
|
||||
) {
|
||||
errorThrow("Invalid palette header");
|
||||
}
|
||||
|
||||
// Version (can only be 1 atm)
|
||||
if(assetData->version != 0x01) {
|
||||
errorThrow("Unsupported palette version");
|
||||
}
|
||||
|
||||
// Check color count.
|
||||
if(
|
||||
assetData->colorCount == 0 ||
|
||||
assetData->colorCount > PALETTE_COLOR_COUNT_MAX
|
||||
) {
|
||||
errorThrow("Invalid palette color count");
|
||||
}
|
||||
|
||||
paletteInit(
|
||||
palette,
|
||||
assetData->colorCount,
|
||||
assetData->colors
|
||||
);
|
||||
errorOk();
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "error/error.h"
|
||||
#include "display/texture/palette.h"
|
||||
|
||||
typedef struct assetentire_s assetentire_t;
|
||||
|
||||
#pragma pack(push, 1)
|
||||
typedef struct {
|
||||
char_t header[3];
|
||||
uint8_t version;
|
||||
|
||||
uint8_t colorCount;
|
||||
color_t colors[PALETTE_COLOR_COUNT_MAX];
|
||||
} assetpalette_t;
|
||||
#pragma pack(pop)
|
||||
|
||||
/**
|
||||
* Loads a palette from the given data pointer into the output palette.
|
||||
*
|
||||
* @param entire Data received from the asset loader system.
|
||||
* @return An error code.
|
||||
*/
|
||||
errorret_t assetPaletteLoad(assetentire_t entire);
|
||||
@@ -1,107 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "camera.h"
|
||||
#include "display/display.h"
|
||||
#include "assert/assert.h"
|
||||
#include "display/framebuffer/framebuffer.h"
|
||||
#include "display/screen/screen.h"
|
||||
|
||||
void cameraInit(camera_t *camera) {
|
||||
cameraInitPerspective(camera);
|
||||
}
|
||||
|
||||
void cameraInitPerspective(camera_t *camera) {
|
||||
assertNotNull(camera, "Not a camera component");
|
||||
|
||||
camera->projType = CAMERA_PROJECTION_TYPE_PERSPECTIVE;
|
||||
camera->perspective.fov = glm_rad(45.0f);
|
||||
camera->nearClip = 0.1f;
|
||||
camera->farClip = 10000.0f;
|
||||
|
||||
camera->viewType = CAMERA_VIEW_TYPE_LOOKAT;
|
||||
glm_vec3_copy((vec3){ 5.0f, 5.0f, 5.0f }, camera->lookat.position);
|
||||
glm_vec3_copy((vec3){ 0.0f, 1.0f, 0.0f }, camera->lookat.up);
|
||||
glm_vec3_copy((vec3){ 0.0f, 0.0f, 0.0f }, camera->lookat.target);
|
||||
}
|
||||
|
||||
void cameraInitOrthographic(camera_t *camera) {
|
||||
assertNotNull(camera, "Not a camera component");
|
||||
|
||||
camera->projType = CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC;
|
||||
camera->orthographic.left = 0.0f;
|
||||
camera->orthographic.right = SCREEN.width;
|
||||
camera->orthographic.top = SCREEN.height;
|
||||
camera->orthographic.bottom = 0.0f;
|
||||
camera->nearClip = 0.1f;
|
||||
camera->farClip = 1.0f;
|
||||
|
||||
camera->viewType = CAMERA_VIEW_TYPE_2D;
|
||||
glm_vec2_copy((vec2){ 0.0f, 0.0f }, camera->_2d.position);
|
||||
camera->_2d.zoom = 1.0f;
|
||||
}
|
||||
|
||||
void cameraGetProjectionMatrix(camera_t *camera, mat4 dest) {
|
||||
assertNotNull(camera, "Not a camera component");
|
||||
assertNotNull(dest, "Destination matrix must not be null");
|
||||
|
||||
if(
|
||||
camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE ||
|
||||
camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED
|
||||
) {
|
||||
glm_mat4_identity(dest);
|
||||
glm_perspective(
|
||||
camera->perspective.fov,
|
||||
SCREEN.aspect,
|
||||
camera->nearClip,
|
||||
camera->farClip,
|
||||
dest
|
||||
);
|
||||
|
||||
if(camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED) {
|
||||
dest[1][1] *= -1.0f;
|
||||
}
|
||||
} else if(camera->projType == CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
|
||||
glm_mat4_identity(dest);
|
||||
glm_ortho(
|
||||
camera->orthographic.left,
|
||||
camera->orthographic.right,
|
||||
camera->orthographic.top,
|
||||
camera->orthographic.bottom,
|
||||
camera->nearClip,
|
||||
camera->farClip,
|
||||
dest
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
void cameraGetViewMatrix(camera_t *camera, mat4 dest) {
|
||||
assertNotNull(camera, "Not a camera component");
|
||||
assertNotNull(dest, "Destination matrix must not be null");
|
||||
|
||||
if(camera->viewType == CAMERA_VIEW_TYPE_MATRIX) {
|
||||
glm_mat4_ucopy(camera->view, dest);
|
||||
} else if(camera->viewType == CAMERA_VIEW_TYPE_LOOKAT) {
|
||||
glm_mat4_identity(dest);
|
||||
glm_lookat(
|
||||
camera->lookat.position,
|
||||
camera->lookat.target,
|
||||
camera->lookat.up,
|
||||
dest
|
||||
);
|
||||
} else if(camera->viewType == CAMERA_VIEW_TYPE_2D) {
|
||||
glm_mat4_identity(dest);
|
||||
glm_lookat(
|
||||
(vec3){ camera->_2d.position[0], camera->_2d.position[1], 0.5f },
|
||||
(vec3){ camera->_2d.position[0], camera->_2d.position[1], 0.0f },
|
||||
(vec3){ 0.0f, 1.0f, 0.0f },
|
||||
dest
|
||||
);
|
||||
} else if(camera->viewType == CAMERA_VIEW_TYPE_LOOKAT_PIXEL_PERFECT) {
|
||||
assertUnreachable("LOOKAT_PIXEL_PERFECT view type is not implemented yet");
|
||||
}
|
||||
}
|
||||
@@ -1,97 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "dusk.h"
|
||||
#include "display/color.h"
|
||||
#include "display/camera/cameraplatform.h"
|
||||
|
||||
#ifndef cameraPushMatrixPlatform
|
||||
#error "cameraPushMatrixPlatform must be defined"
|
||||
#endif
|
||||
|
||||
|
||||
typedef enum {
|
||||
CAMERA_VIEW_TYPE_MATRIX,
|
||||
CAMERA_VIEW_TYPE_LOOKAT,
|
||||
CAMERA_VIEW_TYPE_2D,
|
||||
CAMERA_VIEW_TYPE_LOOKAT_PIXEL_PERFECT
|
||||
} cameraviewtype_t;
|
||||
|
||||
typedef struct camera_s {
|
||||
union {
|
||||
mat4 view;
|
||||
|
||||
struct {
|
||||
vec3 position;
|
||||
vec3 target;
|
||||
vec3 up;
|
||||
} lookat;
|
||||
|
||||
struct {
|
||||
vec3 offset;
|
||||
vec3 target;
|
||||
vec3 up;
|
||||
float_t pixelsPerUnit;
|
||||
} lookatPixelPerfect;
|
||||
|
||||
struct {
|
||||
vec2 position;
|
||||
float_t zoom;
|
||||
} _2d;
|
||||
};
|
||||
|
||||
union {
|
||||
struct {
|
||||
float_t fov;
|
||||
} perspective;
|
||||
|
||||
struct {
|
||||
float_t left;
|
||||
float_t right;
|
||||
float_t top;
|
||||
float_t bottom;
|
||||
} orthographic;
|
||||
};
|
||||
|
||||
float_t nearClip;
|
||||
float_t farClip;
|
||||
|
||||
cameraprojectiontype_t projType;
|
||||
cameraviewtype_t viewType;
|
||||
} camera_t;
|
||||
|
||||
/**
|
||||
* Initializes a camera to default values. This calls cameraInitPerspective.
|
||||
*/
|
||||
void cameraInit(camera_t *camera);
|
||||
|
||||
/**
|
||||
* Initializes a camera for perspective projection.
|
||||
*/
|
||||
void cameraInitPerspective(camera_t *camera);
|
||||
|
||||
/**
|
||||
* Initializes a camera for orthographic projection.
|
||||
*/
|
||||
void cameraInitOrthographic(camera_t *camera);
|
||||
|
||||
/**
|
||||
* Gets the projection matrix for a camera.
|
||||
*
|
||||
* @param camera Camera to get the projection matrix for
|
||||
* @param dest Matrix to store the projection matrix in
|
||||
*/
|
||||
void cameraGetProjectionMatrix(camera_t *camera, mat4 dest);
|
||||
|
||||
/**
|
||||
* Gets the view matrix for a camera.
|
||||
*
|
||||
* @param camera Camera to get the view matrix for
|
||||
* @param dest Matrix to store the view matrix in
|
||||
*/
|
||||
void cameraGetViewMatrix(camera_t *camera, mat4 dest);
|
||||
@@ -1,158 +0,0 @@
|
||||
import json
|
||||
import os
|
||||
from tools.dusk.event import Event
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_VERTEX_COUNT_MAX, TILE_SHAPE_NULL
|
||||
from tools.dusk.tile import Tile
|
||||
from tools.dusk.entity import Entity
|
||||
from tools.dusk.region import Region
|
||||
from tools.editor.map.vertexbuffer import VertexBuffer
|
||||
from OpenGL.GL import *
|
||||
|
||||
class Chunk:
|
||||
def __init__(self, map, x, y, z):
|
||||
self.map = map
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.z = z
|
||||
self.current = {}
|
||||
self.original = {}
|
||||
self.entities = {}
|
||||
self.regions = {}
|
||||
self.onChunkData = Event()
|
||||
self.dirty = False
|
||||
|
||||
self.tiles = {}
|
||||
self.vertexBuffer = VertexBuffer()
|
||||
|
||||
# Test Region
|
||||
region = self.regions[0] = Region(self)
|
||||
region.minX = 0
|
||||
region.minY = 0
|
||||
region.minZ = 0
|
||||
region.maxX = 32
|
||||
region.maxY = 32
|
||||
region.maxZ = 32
|
||||
region.updateVertexs()
|
||||
|
||||
# Gen tiles.
|
||||
tileIndex = 0
|
||||
for tz in range(CHUNK_DEPTH):
|
||||
for ty in range(CHUNK_HEIGHT):
|
||||
for tx in range(CHUNK_WIDTH):
|
||||
self.tiles[tileIndex] = Tile(self, tx, ty, tz, tileIndex)
|
||||
tileIndex += 1
|
||||
|
||||
# Update vertices
|
||||
self.tileUpdateVertices()
|
||||
|
||||
def reload(self, newX, newY, newZ):
|
||||
self.x = newX
|
||||
self.y = newY
|
||||
self.z = newZ
|
||||
self.entities = {}
|
||||
for tile in self.tiles.values():
|
||||
tile.chunkReload(newX, newY, newZ)
|
||||
self.load()
|
||||
|
||||
def tileUpdateVertices(self):
|
||||
self.vertexBuffer.clear()
|
||||
for tile in self.tiles.values():
|
||||
tile.buffer(self.vertexBuffer)
|
||||
self.vertexBuffer.buildData()
|
||||
|
||||
def load(self):
|
||||
fname = self.getFilename()
|
||||
if not fname or not os.path.exists(fname):
|
||||
self.new()
|
||||
return
|
||||
try:
|
||||
with open(fname, 'r') as f:
|
||||
data = json.load(f)
|
||||
|
||||
if not 'shapes' in data:
|
||||
data['shapes'] = []
|
||||
|
||||
# For each tile.
|
||||
for tile in self.tiles.values():
|
||||
tile.load(data)
|
||||
|
||||
# For each entity.
|
||||
self.entities = {}
|
||||
if 'entities' in data:
|
||||
for id, entData in enumerate(data['entities']):
|
||||
ent = Entity(self)
|
||||
ent.load(entData)
|
||||
self.entities[id] = ent
|
||||
|
||||
self.tileUpdateVertices()
|
||||
self.dirty = False
|
||||
self.onChunkData.invoke(self)
|
||||
self.map.onEntityData.invoke()
|
||||
except Exception as e:
|
||||
raise RuntimeError(f"Failed to load chunk file: {e}")
|
||||
|
||||
def save(self):
|
||||
if not self.isDirty():
|
||||
return
|
||||
|
||||
dataOut = {
|
||||
'shapes': [],
|
||||
'entities': []
|
||||
}
|
||||
|
||||
for tile in self.tiles.values():
|
||||
dataOut['shapes'].append(tile.shape)
|
||||
|
||||
for ent in self.entities.values():
|
||||
entData = {}
|
||||
ent.save(entData)
|
||||
dataOut['entities'].append(entData)
|
||||
|
||||
fname = self.getFilename()
|
||||
if not fname:
|
||||
raise ValueError("No filename specified for saving chunk.")
|
||||
try:
|
||||
with open(fname, 'w') as f:
|
||||
json.dump(dataOut, f)
|
||||
self.dirty = False
|
||||
self.onChunkData.invoke(self)
|
||||
except Exception as e:
|
||||
raise RuntimeError(f"Failed to save chunk file: {e}")
|
||||
|
||||
def new(self):
|
||||
for tile in self.tiles.values():
|
||||
tile.shape = TILE_SHAPE_NULL
|
||||
|
||||
self.tileUpdateVertices()
|
||||
self.dirty = False
|
||||
self.onChunkData.invoke(self)
|
||||
|
||||
def isDirty(self):
|
||||
return self.dirty
|
||||
|
||||
def getFilename(self):
|
||||
if not self.map or not hasattr(self.map, 'getChunkDirectory'):
|
||||
return None
|
||||
dirPath = self.map.getChunkDirectory()
|
||||
if dirPath is None:
|
||||
return None
|
||||
return f"{dirPath}/{self.x}_{self.y}_{self.z}.json"
|
||||
|
||||
def draw(self):
|
||||
self.vertexBuffer.draw()
|
||||
|
||||
def addEntity(self, localX=0, localY=0, localZ=0):
|
||||
ent = Entity(self, localX, localY, localZ)
|
||||
self.entities[len(self.entities)] = ent
|
||||
self.map.onEntityData.invoke()
|
||||
self.dirty = True
|
||||
return ent
|
||||
|
||||
def removeEntity(self, entity):
|
||||
for key, val in list(self.entities.items()):
|
||||
if val == entity:
|
||||
del self.entities[key]
|
||||
self.map.onEntityData.invoke()
|
||||
self.dirty = True
|
||||
return True
|
||||
return False
|
||||
@@ -1,49 +0,0 @@
|
||||
from dotenv import load_dotenv, dotenv_values
|
||||
import os
|
||||
import sys
|
||||
|
||||
current_file_path = os.path.abspath(__file__)
|
||||
duskDefsPath = os.path.join(os.path.dirname(current_file_path), "..", "..", "src", "duskdefs.env")
|
||||
|
||||
# Ensure the .env file exists
|
||||
if not os.path.isfile(duskDefsPath):
|
||||
print(f"Error: .env file not found at {duskDefsPath}")
|
||||
sys.exit(1)
|
||||
|
||||
load_dotenv(dotenv_path=duskDefsPath)
|
||||
defs = {key: os.getenv(key) for key in os.environ.keys()}
|
||||
|
||||
fileDefs = dotenv_values(dotenv_path=duskDefsPath)
|
||||
|
||||
# Parsed out definitions
|
||||
CHUNK_WIDTH = int(defs.get('CHUNK_WIDTH'))
|
||||
CHUNK_HEIGHT = int(defs.get('CHUNK_HEIGHT'))
|
||||
CHUNK_DEPTH = int(defs.get('CHUNK_DEPTH'))
|
||||
CHUNK_TILE_COUNT = CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH
|
||||
CHUNK_VERTEX_COUNT_MAX = int(defs.get('CHUNK_VERTEX_COUNT_MAX'))
|
||||
|
||||
TILE_WIDTH = float(defs.get('TILE_WIDTH'))
|
||||
TILE_HEIGHT = float(defs.get('TILE_HEIGHT'))
|
||||
TILE_DEPTH = float(defs.get('TILE_DEPTH'))
|
||||
|
||||
RPG_CAMERA_PIXELS_PER_UNIT = float(defs.get('RPG_CAMERA_PIXELS_PER_UNIT'))
|
||||
RPG_CAMERA_Z_OFFSET = float(defs.get('RPG_CAMERA_Z_OFFSET'))
|
||||
RPG_CAMERA_FOV = float(defs.get('RPG_CAMERA_FOV'))
|
||||
|
||||
MAP_WIDTH = 5
|
||||
MAP_HEIGHT = 5
|
||||
MAP_DEPTH = 3
|
||||
MAP_CHUNK_COUNT = MAP_WIDTH * MAP_HEIGHT * MAP_DEPTH
|
||||
|
||||
TILE_SHAPES = {}
|
||||
for key in defs.keys():
|
||||
if key.startswith('TILE_SHAPE_'):
|
||||
globals()[key] = int(defs.get(key))
|
||||
TILE_SHAPES[key] = int(defs.get(key))
|
||||
|
||||
ENTITY_TYPES = {}
|
||||
for key in defs.keys():
|
||||
if key.startswith('ENTITY_TYPE_'):
|
||||
globals()[key] = int(defs.get(key))
|
||||
if key != 'ENTITY_TYPE_COUNT':
|
||||
ENTITY_TYPES[key] = int(defs.get(key))
|
||||
@@ -1,90 +0,0 @@
|
||||
from tools.dusk.defs import ENTITY_TYPE_NULL, ENTITY_TYPE_NPC, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
|
||||
from tools.editor.map.vertexbuffer import VertexBuffer
|
||||
|
||||
class Entity:
|
||||
def __init__(self, chunk, localX=0, localY=0, localZ=0):
|
||||
self.type = ENTITY_TYPE_NPC
|
||||
self.name = "Unititled"
|
||||
self.localX = localX % CHUNK_WIDTH
|
||||
self.localY = localY % CHUNK_HEIGHT
|
||||
self.localZ = localZ % CHUNK_DEPTH
|
||||
|
||||
self.chunk = chunk
|
||||
self.vertexBuffer = VertexBuffer()
|
||||
pass
|
||||
|
||||
def load(self, obj):
|
||||
self.type = obj.get('type', ENTITY_TYPE_NULL)
|
||||
self.localX = obj.get('x', 0)
|
||||
self.localY = obj.get('y', 0)
|
||||
self.localZ = obj.get('z', 0)
|
||||
self.name = obj.get('name', "Untitled")
|
||||
pass
|
||||
|
||||
def save(self, obj):
|
||||
obj['type'] = self.type
|
||||
obj['name'] = self.name
|
||||
obj['x'] = self.localX
|
||||
obj['y'] = self.localY
|
||||
obj['z'] = self.localZ
|
||||
pass
|
||||
|
||||
def setType(self, entityType):
|
||||
if self.type == entityType:
|
||||
return
|
||||
self.type = entityType
|
||||
self.chunk.dirty = True
|
||||
self.chunk.map.onEntityData.invoke()
|
||||
|
||||
def setName(self, name):
|
||||
if self.name == name:
|
||||
return
|
||||
self.name = name
|
||||
self.chunk.dirty = True
|
||||
self.chunk.map.onEntityData.invoke()
|
||||
|
||||
def draw(self):
|
||||
self.vertexBuffer.clear()
|
||||
|
||||
startX = (self.chunk.x * CHUNK_WIDTH + self.localX) * TILE_WIDTH
|
||||
startY = (self.chunk.y * CHUNK_HEIGHT + self.localY) * TILE_HEIGHT
|
||||
startZ = (self.chunk.z * CHUNK_DEPTH + self.localZ) * TILE_DEPTH
|
||||
w = TILE_WIDTH
|
||||
h = TILE_HEIGHT
|
||||
d = TILE_DEPTH
|
||||
|
||||
# Center
|
||||
startX -= w / 2
|
||||
startY -= h / 2
|
||||
startZ -= d / 2
|
||||
|
||||
# Offset upwards a little
|
||||
startZ += 1
|
||||
|
||||
# Buffer simple quad at current position (need 6 positions)
|
||||
self.vertexBuffer.vertices = [
|
||||
startX, startY, startZ,
|
||||
startX + w, startY, startZ,
|
||||
startX + w, startY + h, startZ,
|
||||
startX, startY, startZ,
|
||||
startX + w, startY + h, startZ,
|
||||
startX, startY + h, startZ,
|
||||
]
|
||||
self.vertexBuffer.colors = [
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
]
|
||||
self.vertexBuffer.uvs = [
|
||||
0.0, 0.0,
|
||||
1.0, 0.0,
|
||||
1.0, 1.0,
|
||||
0.0, 0.0,
|
||||
1.0, 1.0,
|
||||
0.0, 1.0,
|
||||
]
|
||||
self.vertexBuffer.buildData()
|
||||
self.vertexBuffer.draw()
|
||||
@@ -1,18 +0,0 @@
|
||||
class Event:
|
||||
def __init__(self):
|
||||
self._subscribers = []
|
||||
|
||||
def sub(self, callback):
|
||||
"""Subscribe a callback to the event."""
|
||||
if callback not in self._subscribers:
|
||||
self._subscribers.append(callback)
|
||||
|
||||
def unsub(self, callback):
|
||||
"""Unsubscribe a callback from the event."""
|
||||
if callback in self._subscribers:
|
||||
self._subscribers.remove(callback)
|
||||
|
||||
def invoke(self, *args, **kwargs):
|
||||
"""Invoke all subscribers with the given arguments."""
|
||||
for callback in self._subscribers:
|
||||
callback(*args, **kwargs)
|
||||
@@ -1,259 +0,0 @@
|
||||
import json
|
||||
import sys
|
||||
from tools.dusk.event import Event
|
||||
from PyQt5.QtWidgets import QFileDialog, QMessageBox
|
||||
from PyQt5.QtCore import QTimer
|
||||
import os
|
||||
from tools.dusk.chunk import Chunk
|
||||
from tools.dusk.defs import MAP_WIDTH, MAP_HEIGHT, MAP_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
|
||||
import traceback
|
||||
|
||||
MAP_DEFAULT_PATH = os.path.join(os.path.dirname(__file__), '../../assets/map/')
|
||||
EDITOR_CONFIG_PATH = os.path.join(os.path.dirname(__file__), '.editor')
|
||||
|
||||
class Map:
|
||||
def __init__(self, parent):
|
||||
self.parent = parent
|
||||
self.data = {}
|
||||
self.dataOriginal = {}
|
||||
self.position = [None, None, None] # x, y, z
|
||||
self.topLeftX = None
|
||||
self.topLeftY = None
|
||||
self.topLeftZ = None
|
||||
self.chunks = {}
|
||||
self.onMapData = Event()
|
||||
self.onPositionChange = Event()
|
||||
self.onEntityData = Event()
|
||||
self.mapFileName = None
|
||||
self.lastFile = None
|
||||
self.firstLoad = True
|
||||
|
||||
index = 0
|
||||
for x in range(MAP_WIDTH):
|
||||
for y in range(MAP_HEIGHT):
|
||||
for z in range(MAP_DEPTH):
|
||||
self.chunks[index] = Chunk(self, x, y, z)
|
||||
index += 1
|
||||
|
||||
# Only in editor instances:
|
||||
self.moveTo(0, 0, 0)
|
||||
if parent is not None:
|
||||
QTimer.singleShot(16, self.loadLastFile)
|
||||
|
||||
def loadLastFile(self):
|
||||
if not os.path.exists(EDITOR_CONFIG_PATH):
|
||||
return
|
||||
try:
|
||||
with open(EDITOR_CONFIG_PATH, 'r') as f:
|
||||
config = json.load(f)
|
||||
lastFile = config.get('lastFile')
|
||||
lastPosition = config.get('lastPosition')
|
||||
leftPanelIndex = config.get('leftPanelIndex')
|
||||
if lastFile and os.path.exists(lastFile):
|
||||
self.load(lastFile)
|
||||
if lastPosition and isinstance(lastPosition, list) and len(lastPosition) == 3:
|
||||
self.moveTo(*lastPosition)
|
||||
if leftPanelIndex is not None:
|
||||
self.parent.leftPanel.tabs.setCurrentIndex(leftPanelIndex)
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
|
||||
def updateEditorConfig(self):
|
||||
if self.parent is None:
|
||||
return
|
||||
try:
|
||||
mapFileName = self.getMapFilename()
|
||||
config = {
|
||||
'lastFile': mapFileName if mapFileName else "",
|
||||
'lastPosition': self.position,
|
||||
'leftPanelIndex': self.parent.leftPanel.tabs.currentIndex()
|
||||
}
|
||||
config_dir = os.path.dirname(EDITOR_CONFIG_PATH)
|
||||
if not os.path.exists(config_dir):
|
||||
os.makedirs(config_dir, exist_ok=True)
|
||||
with open(EDITOR_CONFIG_PATH, 'w') as f:
|
||||
json.dump(config, f, indent=2)
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
|
||||
def newFile(self):
|
||||
self.data = {}
|
||||
self.dataOriginal = {}
|
||||
self.mapFileName = None
|
||||
self.lastFile = None
|
||||
for chunk in self.chunks.values():
|
||||
chunk.new()
|
||||
self.moveTo(0, 0, 0)
|
||||
self.onMapData.invoke(self.data)
|
||||
self.updateEditorConfig()
|
||||
|
||||
def save(self, fname=None):
|
||||
if not self.getMapFilename() and fname is None:
|
||||
filePath, _ = QFileDialog.getSaveFileName(None, "Save Map File", MAP_DEFAULT_PATH, "Map Files (*.json)")
|
||||
if not filePath:
|
||||
return
|
||||
self.mapFileName = filePath
|
||||
if fname:
|
||||
self.mapFileName = fname
|
||||
try:
|
||||
with open(self.getMapFilename(), 'w') as f:
|
||||
json.dump(self.data, f, indent=2)
|
||||
self.dataOriginal = json.loads(json.dumps(self.data)) # Deep copy
|
||||
for chunk in self.chunks.values():
|
||||
chunk.save()
|
||||
self.updateEditorConfig()
|
||||
except Exception as e:
|
||||
traceback.print_exc()
|
||||
QMessageBox.critical(None, "Save Error", f"Failed to save map file:\n{e}")
|
||||
|
||||
def load(self, fileName):
|
||||
try:
|
||||
with open(fileName, 'r') as f:
|
||||
self.data = json.load(f)
|
||||
self.mapFileName = fileName
|
||||
self.dataOriginal = json.loads(json.dumps(self.data)) # Deep copy
|
||||
for chunk in self.chunks.values():
|
||||
chunk.load()
|
||||
self.onMapData.invoke(self.data)
|
||||
self.updateEditorConfig()
|
||||
except Exception as e:
|
||||
traceback.print_exc()
|
||||
QMessageBox.critical(None, "Load Error", f"Failed to load map file:\n{e}")
|
||||
|
||||
def isMapFileDirty(self):
|
||||
return json.dumps(self.data, sort_keys=True) != json.dumps(self.dataOriginal, sort_keys=True)
|
||||
|
||||
def isDirty(self):
|
||||
return self.isMapFileDirty() or self.anyChunksDirty()
|
||||
|
||||
def getMapFilename(self):
|
||||
return self.mapFileName if self.mapFileName and os.path.exists(self.mapFileName) else None
|
||||
|
||||
def getMapDirectory(self):
|
||||
if self.mapFileName is None:
|
||||
return None
|
||||
dirname = os.path.dirname(self.mapFileName)
|
||||
return dirname
|
||||
|
||||
def getChunkDirectory(self):
|
||||
dirName = self.getMapDirectory()
|
||||
if dirName is None:
|
||||
return None
|
||||
return os.path.join(dirName, 'chunks')
|
||||
|
||||
def anyChunksDirty(self):
|
||||
for chunk in self.chunks.values():
|
||||
if chunk.isDirty():
|
||||
return True
|
||||
return False
|
||||
|
||||
def moveTo(self, x, y, z):
|
||||
if self.position == [x, y, z]:
|
||||
return
|
||||
|
||||
# We need to decide if the chunks should be unloaded here or not.
|
||||
newTopLeftChunkX = x // CHUNK_WIDTH - (MAP_WIDTH // 2)
|
||||
newTopLeftChunkY = y // CHUNK_HEIGHT - (MAP_HEIGHT // 2)
|
||||
newTopLeftChunkZ = z // CHUNK_DEPTH - (MAP_DEPTH // 2)
|
||||
|
||||
if(newTopLeftChunkX != self.topLeftX or
|
||||
newTopLeftChunkY != self.topLeftY or
|
||||
newTopLeftChunkZ != self.topLeftZ):
|
||||
|
||||
chunksToUnload = []
|
||||
chunksToKeep = []
|
||||
for chunk in self.chunks.values():
|
||||
chunkWorldX = chunk.x
|
||||
chunkWorldY = chunk.y
|
||||
chunkWorldZ = chunk.z
|
||||
if(chunkWorldX < newTopLeftChunkX or
|
||||
chunkWorldX >= newTopLeftChunkX + MAP_WIDTH or
|
||||
chunkWorldY < newTopLeftChunkY or
|
||||
chunkWorldY >= newTopLeftChunkY + MAP_HEIGHT or
|
||||
chunkWorldZ < newTopLeftChunkZ or
|
||||
chunkWorldZ >= newTopLeftChunkZ + MAP_DEPTH):
|
||||
chunksToUnload.append(chunk)
|
||||
else:
|
||||
chunksToKeep.append(chunk)
|
||||
|
||||
# Unload chunks that are out of the new bounds.
|
||||
for chunk in chunksToUnload:
|
||||
if chunk.isDirty():
|
||||
print(f"Can't move map, some chunks are dirty: ({chunk.x}, {chunk.y}, {chunk.z})")
|
||||
return
|
||||
|
||||
# Now we can safely unload the chunks.
|
||||
chunkIndex = 0
|
||||
newChunks = {}
|
||||
for chunk in chunksToKeep:
|
||||
newChunks[chunkIndex] = chunk
|
||||
chunkIndex += 1
|
||||
|
||||
for xPos in range(newTopLeftChunkX, newTopLeftChunkX + MAP_WIDTH):
|
||||
for yPos in range(newTopLeftChunkY, newTopLeftChunkY + MAP_HEIGHT):
|
||||
for zPos in range(newTopLeftChunkZ, newTopLeftChunkZ + MAP_DEPTH):
|
||||
# Check if we already have this chunk.
|
||||
found = False
|
||||
for chunk in chunksToKeep:
|
||||
if chunk.x == xPos and chunk.y == yPos and chunk.z == zPos:
|
||||
found = True
|
||||
break
|
||||
if not found:
|
||||
# Create a new chunk.
|
||||
newChunk = chunksToUnload.pop()
|
||||
newChunk.reload(xPos, yPos, zPos)
|
||||
newChunks[chunkIndex] = newChunk
|
||||
chunkIndex += 1
|
||||
|
||||
self.chunks = newChunks
|
||||
self.topLeftX = newTopLeftChunkX
|
||||
self.topLeftY = newTopLeftChunkY
|
||||
self.topLeftZ = newTopLeftChunkZ
|
||||
|
||||
self.position = [x, y, z]
|
||||
self.onPositionChange.invoke(self.position)
|
||||
if not self.firstLoad:
|
||||
self.updateEditorConfig()
|
||||
self.firstLoad = False
|
||||
|
||||
def moveRelative(self, x, y, z):
|
||||
self.moveTo(
|
||||
self.position[0] + x,
|
||||
self.position[1] + y,
|
||||
self.position[2] + z
|
||||
)
|
||||
|
||||
def draw(self):
|
||||
for chunk in self.chunks.values():
|
||||
chunk.draw()
|
||||
|
||||
for chunk in self.chunks.values():
|
||||
for entity in chunk.entities.values():
|
||||
entity.draw()
|
||||
|
||||
# Only render on Region tab
|
||||
if self.parent.leftPanel.tabs.currentWidget() == self.parent.leftPanel.regionPanel:
|
||||
for chunk in self.chunks.values():
|
||||
for region in chunk.regions.values():
|
||||
region.draw()
|
||||
|
||||
def getChunkAtWorldPos(self, x, y, z):
|
||||
chunkX = x // CHUNK_WIDTH
|
||||
chunkY = y // CHUNK_HEIGHT
|
||||
chunkZ = z // CHUNK_DEPTH
|
||||
for chunk in self.chunks.values():
|
||||
if chunk.x == chunkX and chunk.y == chunkY and chunk.z == chunkZ:
|
||||
return chunk
|
||||
return None
|
||||
|
||||
def getTileAtWorldPos(self, x, y, z):
|
||||
chunk = self.getChunkAtWorldPos(x, y, z)
|
||||
if not chunk:
|
||||
print("No chunk found at position:", (x, y, z))
|
||||
return None
|
||||
|
||||
tileX = x % CHUNK_WIDTH
|
||||
tileY = y % CHUNK_HEIGHT
|
||||
tileZ = z % CHUNK_DEPTH
|
||||
tileIndex = tileX + tileY * CHUNK_WIDTH + tileZ * CHUNK_WIDTH * CHUNK_HEIGHT
|
||||
return chunk.tiles.get(tileIndex)
|
||||
@@ -1,141 +0,0 @@
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
|
||||
from tools.editor.map.vertexbuffer import VertexBuffer
|
||||
from OpenGL.GL import *
|
||||
from OpenGL.GLU import *
|
||||
|
||||
class Region:
|
||||
def __init__(self, chunk):
|
||||
self.minX = 0
|
||||
self.minY = 0
|
||||
self.minZ = 0
|
||||
self.maxX = 0
|
||||
self.maxY = 0
|
||||
self.maxZ = 0
|
||||
self.chunk = chunk
|
||||
self.vertexBuffer = VertexBuffer()
|
||||
self.color = (1.0, 0.0, 0.0)
|
||||
self.updateVertexs()
|
||||
pass
|
||||
|
||||
def updateVertexs(self):
|
||||
# Draw a quad, semi transparent with solid outlines
|
||||
vminX = (self.minX * CHUNK_WIDTH) * TILE_WIDTH
|
||||
vminY = (self.minY * CHUNK_HEIGHT) * TILE_HEIGHT
|
||||
vminZ = (self.minZ * CHUNK_DEPTH) * TILE_DEPTH
|
||||
vmaxX = (self.maxX * CHUNK_WIDTH) * TILE_WIDTH
|
||||
vmaxY = (self.maxY * CHUNK_HEIGHT) * TILE_HEIGHT
|
||||
vmaxZ = (self.maxZ * CHUNK_DEPTH) * TILE_DEPTH
|
||||
alpha = 0.25
|
||||
|
||||
# Move back half a tile width
|
||||
vminX -= TILE_WIDTH / 2
|
||||
vmaxX -= TILE_WIDTH / 2
|
||||
vminY -= TILE_HEIGHT / 2
|
||||
vmaxY -= TILE_HEIGHT / 2
|
||||
vminZ -= TILE_DEPTH / 2
|
||||
vmaxZ -= TILE_DEPTH / 2
|
||||
|
||||
# Cube (6 verts per face)
|
||||
self.vertexBuffer.vertices = [
|
||||
# Front face
|
||||
vminX, vminY, vmaxZ,
|
||||
vmaxX, vminY, vmaxZ,
|
||||
vmaxX, vmaxY, vmaxZ,
|
||||
vminX, vminY, vmaxZ,
|
||||
vmaxX, vmaxY, vmaxZ,
|
||||
vminX, vmaxY, vmaxZ,
|
||||
|
||||
# Back face
|
||||
vmaxX, vminY, vminZ,
|
||||
vminX, vminY, vminZ,
|
||||
vminX, vmaxY, vminZ,
|
||||
vmaxX, vminY, vminZ,
|
||||
vminX, vmaxY, vminZ,
|
||||
vmaxX, vmaxY, vminZ,
|
||||
|
||||
# Left face
|
||||
vminX, vminY, vminZ,
|
||||
vminX, vminY, vmaxZ,
|
||||
vminX, vmaxY, vmaxZ,
|
||||
vminX, vminY, vminZ,
|
||||
vminX, vmaxY, vmaxZ,
|
||||
vminX, vmaxY, vminZ,
|
||||
|
||||
# Right face
|
||||
vmaxX, vminY, vmaxZ,
|
||||
vmaxX, vminY, vminZ,
|
||||
vmaxX, vmaxY, vminZ,
|
||||
vmaxX, vminY, vmaxZ,
|
||||
vmaxX, vmaxY, vminZ,
|
||||
vmaxX, vmaxY, vmaxZ,
|
||||
|
||||
# Top face
|
||||
vminX, vmaxY, vmaxZ,
|
||||
vmaxX, vmaxY, vmaxZ,
|
||||
vmaxX, vmaxY, vminZ,
|
||||
vminX, vmaxY, vmaxZ,
|
||||
vmaxX, vmaxY, vminZ,
|
||||
vminX, vmaxY, vminZ,
|
||||
|
||||
# Bottom face
|
||||
vminX, vminY, vminZ,
|
||||
vmaxX, vminY, vminZ,
|
||||
vmaxX, vminY, vmaxZ,
|
||||
vminX, vminY, vminZ,
|
||||
vmaxX, vminY, vmaxZ,
|
||||
vminX, vminY, vmaxZ,
|
||||
]
|
||||
|
||||
self.vertexBuffer.colors = [
|
||||
# Front face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
|
||||
# Back face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
|
||||
# Left face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
|
||||
# Right face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
|
||||
# Top face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
|
||||
# Bottom face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
]
|
||||
self.vertexBuffer.buildData()
|
||||
|
||||
def draw(self):
|
||||
self.vertexBuffer.draw()
|
||||
@@ -1,206 +0,0 @@
|
||||
from OpenGL.GL import *
|
||||
from tools.dusk.defs import (
|
||||
TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH,
|
||||
CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH,
|
||||
TILE_SHAPE_NULL, TILE_SHAPE_FLOOR,
|
||||
TILE_SHAPE_RAMP_NORTH, TILE_SHAPE_RAMP_SOUTH,
|
||||
TILE_SHAPE_RAMP_EAST, TILE_SHAPE_RAMP_WEST,
|
||||
TILE_SHAPE_RAMP_SOUTHWEST, TILE_SHAPE_RAMP_SOUTHEAST,
|
||||
TILE_SHAPE_RAMP_NORTHWEST, TILE_SHAPE_RAMP_NORTHEAST
|
||||
)
|
||||
|
||||
def getItem(arr, index, default):
|
||||
if index < len(arr):
|
||||
return arr[index]
|
||||
return default
|
||||
|
||||
class Tile:
|
||||
def __init__(self, chunk, x, y, z, tileIndex):
|
||||
self.shape = TILE_SHAPE_NULL
|
||||
|
||||
self.chunk = chunk
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.z = z
|
||||
self.index = tileIndex
|
||||
|
||||
self.posX = x * TILE_WIDTH + chunk.x * CHUNK_WIDTH * TILE_WIDTH
|
||||
self.posY = y * TILE_HEIGHT + chunk.y * CHUNK_HEIGHT * TILE_HEIGHT
|
||||
self.posZ = z * TILE_DEPTH + chunk.z * CHUNK_DEPTH * TILE_DEPTH
|
||||
|
||||
def chunkReload(self, newX, newY, newZ):
|
||||
self.posX = self.x * TILE_WIDTH + newX * CHUNK_WIDTH * TILE_WIDTH
|
||||
self.posY = self.y * TILE_HEIGHT + newY * CHUNK_HEIGHT * TILE_HEIGHT
|
||||
self.posZ = self.z * TILE_DEPTH + newZ * CHUNK_DEPTH * TILE_DEPTH
|
||||
|
||||
def load(self, chunkData):
|
||||
self.shape = getItem(chunkData['shapes'], self.index, TILE_SHAPE_NULL)
|
||||
|
||||
def setShape(self, shape):
|
||||
if shape == self.shape:
|
||||
return
|
||||
|
||||
self.shape = shape
|
||||
self.chunk.dirty = True
|
||||
self.chunk.tileUpdateVertices()
|
||||
self.chunk.onChunkData.invoke(self.chunk)
|
||||
|
||||
def getBaseTileModel(self):
|
||||
vertices = []
|
||||
indices = []
|
||||
uvs = []
|
||||
colors = []
|
||||
|
||||
if self.shape == TILE_SHAPE_NULL:
|
||||
pass
|
||||
|
||||
elif self.shape == TILE_SHAPE_FLOOR:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (255, 255, 255, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_NORTH:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (255, 0, 0, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_SOUTH:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (0, 255, 0, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_EAST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (0, 0, 255, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_WEST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (255, 255, 0, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_SOUTHWEST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (255, 128, 0, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_NORTHWEST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (128, 255, 0, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_NORTHEAST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (0, 255, 128, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_SOUTHEAST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (255, 128, 255, 255) ] * 4
|
||||
|
||||
else:
|
||||
# Solid black cube for unknown shape
|
||||
x0, y0, z0 = self.posX, self.posY, self.posZ
|
||||
x1, y1, z1 = self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH
|
||||
vertices = [
|
||||
(x0, y0, z0), (x1, y0, z0), (x1, y1, z0), (x0, y1, z0), # bottom
|
||||
(x0, y0, z1), (x1, y0, z1), (x1, y1, z1), (x0, y1, z1) # top
|
||||
]
|
||||
indices = [
|
||||
0,1,2, 0,2,3, # bottom
|
||||
4,5,6, 4,6,7, # top
|
||||
0,1,5, 0,5,4, # front
|
||||
2,3,7, 2,7,6, # back
|
||||
1,2,6, 1,6,5, # right
|
||||
3,0,4, 3,4,7 # left
|
||||
]
|
||||
uvs = [ (0,0) ] * 8
|
||||
colors = [ (0,0,0,255) ] * 8
|
||||
|
||||
return {
|
||||
'vertices': vertices,
|
||||
'indices': indices,
|
||||
'uvs': uvs,
|
||||
'colors': colors
|
||||
}
|
||||
|
||||
def buffer(self, vertexBuffer):
|
||||
if self.shape == TILE_SHAPE_NULL:
|
||||
return
|
||||
|
||||
# New code:
|
||||
baseData = self.getBaseTileModel()
|
||||
|
||||
# Base data is indiced but we need to buffer unindiced data
|
||||
for index in baseData['indices']:
|
||||
verts = baseData['vertices'][index]
|
||||
uv = baseData['uvs'][index]
|
||||
color = baseData['colors'][index]
|
||||
|
||||
vertexBuffer.vertices.extend([
|
||||
verts[0] - (TILE_WIDTH / 2.0),
|
||||
verts[1] - (TILE_HEIGHT / 2.0),
|
||||
verts[2] - (TILE_DEPTH / 2.0)
|
||||
])
|
||||
|
||||
vertexBuffer.colors.extend([
|
||||
color[0] / 255.0,
|
||||
color[1] / 255.0,
|
||||
color[2] / 255.0,
|
||||
color[3] / 255.0
|
||||
])
|
||||
@@ -1,57 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
import sys
|
||||
from PyQt5.QtWidgets import (
|
||||
QApplication, QVBoxLayout, QPushButton,
|
||||
QDialog
|
||||
)
|
||||
from OpenGL.GL import *
|
||||
from OpenGL.GLU import *
|
||||
from tools.editor.maptool import MapWindow
|
||||
from tools.editor.langtool import LangToolWindow
|
||||
from tools.editor.cutscenetool import CutsceneToolWindow
|
||||
|
||||
DEFAULT_TOOL = None
|
||||
DEFAULT_TOOL = "map"
|
||||
# DEFAULT_TOOL = "cutscene"
|
||||
|
||||
TOOLS = [
|
||||
("Map Editor", "map", MapWindow),
|
||||
("Language Editor", "language", LangToolWindow),
|
||||
("Cutscene Editor", "cutscene", CutsceneToolWindow),
|
||||
]
|
||||
|
||||
class EditorChoiceDialog(QDialog):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.setWindowTitle("Choose Tool")
|
||||
layout = QVBoxLayout(self)
|
||||
self.selected = None
|
||||
for label, key, win_cls in TOOLS:
|
||||
btn = QPushButton(label)
|
||||
btn.clicked.connect(lambda checked, w=win_cls: self.choose_tool(w))
|
||||
layout.addWidget(btn)
|
||||
|
||||
def choose_tool(self, win_cls):
|
||||
self.selected = win_cls
|
||||
self.accept()
|
||||
|
||||
def get_choice(self):
|
||||
return self.selected
|
||||
|
||||
def main():
|
||||
app = QApplication(sys.argv)
|
||||
tool_map = { key: win_cls for _, key, win_cls in TOOLS }
|
||||
if DEFAULT_TOOL in tool_map:
|
||||
win_cls = tool_map[DEFAULT_TOOL]
|
||||
else:
|
||||
choice_dialog = EditorChoiceDialog()
|
||||
if choice_dialog.exec_() == QDialog.Accepted:
|
||||
win_cls = choice_dialog.get_choice()
|
||||
else:
|
||||
sys.exit(0)
|
||||
win = win_cls()
|
||||
win.show()
|
||||
sys.exit(app.exec_())
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,58 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLineEdit, QLabel, QSizePolicy, QComboBox, QHBoxLayout, QSpacerItem
|
||||
from PyQt5.QtCore import Qt, pyqtSignal
|
||||
from .cutscenewait import CutsceneWaitEditor
|
||||
from .cutscenetext import CutsceneTextEditor
|
||||
|
||||
EDITOR_MAP = (
|
||||
( "wait", "Wait", CutsceneWaitEditor ),
|
||||
( "text", "Text", CutsceneTextEditor )
|
||||
)
|
||||
|
||||
class CutsceneItemEditor(QWidget):
|
||||
def __init__(self, parent=None):
|
||||
super().__init__(parent)
|
||||
self.layout = QVBoxLayout(self)
|
||||
self.layout.setAlignment(Qt.AlignTop | Qt.AlignLeft)
|
||||
self.layout.addWidget(QLabel("Item Properties:"))
|
||||
|
||||
rowLayout = QHBoxLayout()
|
||||
rowLayout.setSpacing(8)
|
||||
|
||||
rowLayout.addWidget(QLabel("Name:"))
|
||||
self.nameInput = QLineEdit()
|
||||
rowLayout.addWidget(self.nameInput)
|
||||
|
||||
rowLayout.addWidget(QLabel("Type:"))
|
||||
self.typeDropdown = QComboBox()
|
||||
self.typeDropdown.addItems([typeName for typeKey, typeName, editorClass in EDITOR_MAP])
|
||||
rowLayout.addWidget(self.typeDropdown)
|
||||
self.layout.addLayout(rowLayout)
|
||||
|
||||
self.activeEditor = None
|
||||
|
||||
# Events
|
||||
self.nameInput.textChanged.connect(self.onNameChanged)
|
||||
self.typeDropdown.currentTextChanged.connect(self.onTypeChanged)
|
||||
|
||||
# First load
|
||||
self.onNameChanged(self.nameInput.text())
|
||||
self.onTypeChanged(self.typeDropdown.currentText())
|
||||
|
||||
def onNameChanged(self, nameText):
|
||||
pass
|
||||
|
||||
def onTypeChanged(self, typeText):
|
||||
typeKey = typeText.lower()
|
||||
|
||||
# Remove existing editor
|
||||
if self.activeEditor:
|
||||
self.layout.removeWidget(self.activeEditor)
|
||||
self.activeEditor.deleteLater()
|
||||
self.activeEditor = None
|
||||
|
||||
# Create new editor
|
||||
for key, name, editorClass in EDITOR_MAP:
|
||||
if key == typeKey:
|
||||
self.activeEditor = editorClass()
|
||||
self.layout.addWidget(self.activeEditor)
|
||||
break
|
||||
@@ -1,54 +0,0 @@
|
||||
from PyQt5.QtWidgets import QMenuBar, QAction, QFileDialog, QMessageBox
|
||||
from PyQt5.QtGui import QKeySequence
|
||||
|
||||
class CutsceneMenuBar(QMenuBar):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
fileMenu = self.addMenu("File")
|
||||
|
||||
self.newAction = QAction("New", self)
|
||||
self.newAction.setShortcut(QKeySequence.New)
|
||||
self.newAction.triggered.connect(self.newFile)
|
||||
fileMenu.addAction(self.newAction)
|
||||
|
||||
self.openAction = QAction("Open", self)
|
||||
self.openAction.setShortcut(QKeySequence.Open)
|
||||
self.openAction.triggered.connect(self.openFile)
|
||||
fileMenu.addAction(self.openAction)
|
||||
|
||||
self.saveAction = QAction("Save", self)
|
||||
self.saveAction.setShortcut(QKeySequence.Save)
|
||||
self.saveAction.triggered.connect(self.saveFile)
|
||||
fileMenu.addAction(self.saveAction)
|
||||
|
||||
self.saveAsAction = QAction("Save As", self)
|
||||
self.saveAsAction.setShortcut(QKeySequence.SaveAs)
|
||||
self.saveAsAction.triggered.connect(self.saveFileAs)
|
||||
fileMenu.addAction(self.saveAsAction)
|
||||
|
||||
def newFile(self):
|
||||
self.parent.clearCutscene()
|
||||
|
||||
def openFile(self):
|
||||
path, _ = QFileDialog.getOpenFileName(self.parent, "Open Cutscene File", "", "JSON Files (*.json);;All Files (*)")
|
||||
if not path:
|
||||
return
|
||||
|
||||
# TODO: Load file contents into timeline
|
||||
self.parent.currentFile = path
|
||||
pass
|
||||
|
||||
def saveFile(self):
|
||||
if not self.parent.currentFile:
|
||||
self.saveFileAs()
|
||||
return
|
||||
|
||||
# TODO: Save timeline to self.parent.currentFile
|
||||
pass
|
||||
|
||||
def saveFileAs(self):
|
||||
path, _ = QFileDialog.getSaveFileName(self.parent, "Save Cutscene File As", "", "JSON Files (*.json);;All Files (*)")
|
||||
if path:
|
||||
self.parent.currentFile = path
|
||||
self.saveFile()
|
||||
@@ -1,21 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QTextEdit
|
||||
from PyQt5.QtCore import Qt
|
||||
|
||||
class CutsceneTextEditor(QWidget):
|
||||
def __init__(self, parent=None):
|
||||
super().__init__(parent)
|
||||
layout = QVBoxLayout(self)
|
||||
layout.setContentsMargins(0, 0, 0, 0)
|
||||
layout.setSpacing(0)
|
||||
label = QLabel("Text:")
|
||||
label.setSizePolicy(label.sizePolicy().Expanding, label.sizePolicy().Fixed)
|
||||
layout.addWidget(label)
|
||||
self.textInput = QTextEdit()
|
||||
self.textInput.setSizePolicy(self.textInput.sizePolicy().Expanding, self.textInput.sizePolicy().Expanding)
|
||||
layout.addWidget(self.textInput, stretch=1)
|
||||
|
||||
def setText(self, text):
|
||||
self.textInput.setPlainText(text)
|
||||
|
||||
def getText(self):
|
||||
return self.textInput.toPlainText()
|
||||
@@ -1,20 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QFormLayout, QDoubleSpinBox, QLabel
|
||||
|
||||
class CutsceneWaitEditor(QWidget):
|
||||
def __init__(self, parent=None):
|
||||
super().__init__(parent)
|
||||
layout = QFormLayout(self)
|
||||
layout.setContentsMargins(0, 0, 0, 0)
|
||||
layout.setSpacing(0)
|
||||
self.waitTimeInput = QDoubleSpinBox()
|
||||
self.waitTimeInput.setMinimum(0.0)
|
||||
self.waitTimeInput.setMaximum(9999.0)
|
||||
self.waitTimeInput.setDecimals(2)
|
||||
self.waitTimeInput.setSingleStep(0.1)
|
||||
layout.addRow(QLabel("Wait Time (seconds):"), self.waitTimeInput)
|
||||
|
||||
def setWaitTime(self, value):
|
||||
self.waitTimeInput.setValue(value)
|
||||
|
||||
def getWaitTime(self):
|
||||
return self.waitTimeInput.value()
|
||||
@@ -1,101 +0,0 @@
|
||||
from PyQt5.QtWidgets import QMainWindow, QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QListWidget, QListWidgetItem, QMenuBar, QAction, QFileDialog, QMessageBox
|
||||
from PyQt5.QtGui import QKeySequence
|
||||
from tools.editor.cutscene.cutsceneitemeditor import CutsceneItemEditor
|
||||
from tools.editor.cutscene.cutscenemenubar import CutsceneMenuBar
|
||||
import sys
|
||||
|
||||
class CutsceneToolWindow(QMainWindow):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.setWindowTitle("Dusk Cutscene Editor")
|
||||
self.setGeometry(100, 100, 800, 600)
|
||||
self.nextItemNumber = 1 # Track next available number
|
||||
self.currentFile = None
|
||||
self.dirty = False # Track unsaved changes
|
||||
|
||||
# File menu (handled by CutsceneMenuBar)
|
||||
menubar = CutsceneMenuBar(self)
|
||||
self.setMenuBar(menubar)
|
||||
|
||||
# Main layout: horizontal split
|
||||
central = QWidget()
|
||||
mainLayout = QHBoxLayout(central)
|
||||
self.setCentralWidget(central)
|
||||
|
||||
# Timeline
|
||||
leftPanel = QWidget()
|
||||
leftLayout = QVBoxLayout(leftPanel)
|
||||
|
||||
self.timelineList = QListWidget()
|
||||
self.timelineList.setSelectionMode(QListWidget.SingleSelection)
|
||||
leftLayout.addWidget(QLabel("Cutscene Timeline"))
|
||||
leftLayout.addWidget(self.timelineList)
|
||||
|
||||
btnLayout = QHBoxLayout()
|
||||
self.addBtn = QPushButton("Add")
|
||||
self.removeBtn = QPushButton("Remove")
|
||||
btnLayout.addWidget(self.addBtn)
|
||||
btnLayout.addWidget(self.removeBtn)
|
||||
leftLayout.addLayout(btnLayout)
|
||||
mainLayout.addWidget(leftPanel, 2)
|
||||
|
||||
# Property editor
|
||||
self.editorPanel = QWidget()
|
||||
self.editorLayout = QVBoxLayout(self.editorPanel)
|
||||
self.itemEditor = None # Only create when needed
|
||||
mainLayout.addWidget(self.editorPanel, 3)
|
||||
|
||||
# Events
|
||||
self.timelineList.currentItemChanged.connect(self.onItemSelected)
|
||||
self.addBtn.clicked.connect(self.addCutsceneItem)
|
||||
self.removeBtn.clicked.connect(self.removeCutsceneItem)
|
||||
|
||||
def addCutsceneItem(self):
|
||||
name = f"Cutscene item {self.nextItemNumber}"
|
||||
timelineItem = QListWidgetItem(name)
|
||||
self.timelineList.addItem(timelineItem)
|
||||
self.timelineList.setCurrentItem(timelineItem)
|
||||
self.nextItemNumber += 1
|
||||
self.dirty = True
|
||||
|
||||
def removeCutsceneItem(self):
|
||||
row = self.timelineList.currentRow()
|
||||
if row < 0:
|
||||
return
|
||||
self.timelineList.takeItem(row)
|
||||
self.dirty = True
|
||||
|
||||
# Remove editor if nothing selected
|
||||
if self.timelineList.currentItem() is None or self.itemEditor is None:
|
||||
return
|
||||
|
||||
self.editorLayout.removeWidget(self.itemEditor)
|
||||
self.itemEditor.deleteLater()
|
||||
self.itemEditor = None
|
||||
|
||||
def clearCutscene(self):
|
||||
self.timelineList.clear()
|
||||
self.nextItemNumber = 1
|
||||
self.currentFile = None
|
||||
self.dirty = False
|
||||
if self.itemEditor:
|
||||
self.editorLayout.removeWidget(self.itemEditor)
|
||||
|
||||
def onItemSelected(self, current, previous):
|
||||
if current:
|
||||
if not self.itemEditor:
|
||||
self.itemEditor = CutsceneItemEditor()
|
||||
self.editorLayout.addWidget(self.itemEditor)
|
||||
return
|
||||
|
||||
if not self.itemEditor:
|
||||
return
|
||||
self.editorLayout.removeWidget(self.itemEditor)
|
||||
self.itemEditor.deleteLater()
|
||||
self.itemEditor = None
|
||||
|
||||
if __name__ == "__main__":
|
||||
app = QApplication(sys.argv)
|
||||
window = CutsceneToolWindow()
|
||||
window.show()
|
||||
sys.exit(app.exec_())
|
||||
@@ -1,202 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
from PyQt5.QtWidgets import QMainWindow, QApplication, QAction, QMenuBar, QMessageBox, QFileDialog, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit, QTableWidget, QTableWidgetItem, QHeaderView, QPushButton, QTabWidget, QFormLayout
|
||||
from PyQt5.QtCore import Qt
|
||||
import sys
|
||||
import os
|
||||
import polib
|
||||
|
||||
class LangToolWindow(QMainWindow):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.setWindowTitle("Dusk Language Editor")
|
||||
self.setGeometry(100, 100, 800, 600)
|
||||
self.current_file = None
|
||||
self.dirty = False
|
||||
self.init_menu()
|
||||
self.init_ui()
|
||||
|
||||
def init_ui(self):
|
||||
central = QWidget()
|
||||
layout = QVBoxLayout(central)
|
||||
|
||||
tabs = QTabWidget()
|
||||
# Header Tab
|
||||
header_tab = QWidget()
|
||||
header_layout = QFormLayout(header_tab)
|
||||
self.language_edit = QLineEdit()
|
||||
self.language_edit.setMaximumWidth(220)
|
||||
header_layout.addRow(QLabel("Language:"), self.language_edit)
|
||||
self.plural_edit = QLineEdit()
|
||||
self.plural_edit.setMaximumWidth(320)
|
||||
header_layout.addRow(QLabel("Plural-Forms:"), self.plural_edit)
|
||||
self.content_type_edit = QLineEdit("text/plain; charset=UTF-8")
|
||||
self.content_type_edit.setMaximumWidth(320)
|
||||
header_layout.addRow(QLabel("Content-Type:"), self.content_type_edit)
|
||||
tabs.addTab(header_tab, "Header")
|
||||
|
||||
# Strings Tab
|
||||
strings_tab = QWidget()
|
||||
strings_layout = QVBoxLayout(strings_tab)
|
||||
self.po_table = QTableWidget()
|
||||
self.po_table.setColumnCount(2)
|
||||
self.po_table.setHorizontalHeaderLabels(["msgid", "msgstr"])
|
||||
self.po_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
|
||||
self.po_table.verticalHeader().setMinimumWidth(22)
|
||||
self.po_table.verticalHeader().setDefaultAlignment(Qt.AlignRight | Qt.AlignVCenter)
|
||||
strings_layout.addWidget(self.po_table)
|
||||
row_btn_layout = QHBoxLayout()
|
||||
add_row_btn = QPushButton("Add Row")
|
||||
remove_row_btn = QPushButton("Remove Row")
|
||||
row_btn_layout.addWidget(add_row_btn)
|
||||
row_btn_layout.addWidget(remove_row_btn)
|
||||
strings_layout.addLayout(row_btn_layout)
|
||||
tabs.addTab(strings_tab, "Strings")
|
||||
|
||||
layout.addWidget(tabs)
|
||||
|
||||
add_row_btn.clicked.connect(self.add_row)
|
||||
remove_row_btn.clicked.connect(self.remove_row)
|
||||
self.add_row_btn = add_row_btn
|
||||
self.remove_row_btn = remove_row_btn
|
||||
|
||||
self.setCentralWidget(central)
|
||||
|
||||
# Connect edits to dirty flag
|
||||
self.language_edit.textChanged.connect(self.set_dirty)
|
||||
self.plural_edit.textChanged.connect(self.set_dirty)
|
||||
self.content_type_edit.textChanged.connect(self.set_dirty)
|
||||
self.po_table.itemChanged.connect(self.set_dirty)
|
||||
|
||||
def set_dirty(self):
|
||||
self.dirty = True
|
||||
self.update_save_action()
|
||||
|
||||
def init_menu(self):
|
||||
menubar = self.menuBar()
|
||||
file_menu = menubar.addMenu("File")
|
||||
|
||||
new_action = QAction("New", self)
|
||||
open_action = QAction("Open", self)
|
||||
save_action = QAction("Save", self)
|
||||
save_as_action = QAction("Save As", self)
|
||||
|
||||
new_action.triggered.connect(lambda: self.handle_file_action("new"))
|
||||
open_action.triggered.connect(lambda: self.handle_file_action("open"))
|
||||
save_action.triggered.connect(self.handle_save)
|
||||
save_as_action.triggered.connect(self.handle_save_as)
|
||||
|
||||
file_menu.addAction(new_action)
|
||||
file_menu.addAction(open_action)
|
||||
file_menu.addAction(save_action)
|
||||
file_menu.addAction(save_as_action)
|
||||
|
||||
self.save_action = save_action # Store reference for enabling/disabling
|
||||
self.update_save_action()
|
||||
|
||||
def update_save_action(self):
|
||||
self.save_action.setEnabled(self.current_file is not None)
|
||||
|
||||
def handle_file_action(self, action):
|
||||
if self.dirty:
|
||||
reply = QMessageBox.question(self, "Save Changes?", "Do you want to save changes before proceeding?", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
|
||||
if reply == QMessageBox.Cancel:
|
||||
return
|
||||
elif reply == QMessageBox.Yes:
|
||||
self.handle_save()
|
||||
if action == "new":
|
||||
self.new_file()
|
||||
elif action == "open":
|
||||
default_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../assets/locale"))
|
||||
file_path, _ = QFileDialog.getOpenFileName(self, "Open Language File", default_dir, "PO Files (*.po)")
|
||||
if file_path:
|
||||
self.open_file(file_path)
|
||||
|
||||
def new_file(self):
|
||||
self.current_file = None
|
||||
self.dirty = False
|
||||
self.language_edit.setText("")
|
||||
self.plural_edit.setText("")
|
||||
self.po_table.setRowCount(0)
|
||||
self.update_save_action()
|
||||
|
||||
def open_file(self, file_path):
|
||||
self.current_file = file_path
|
||||
self.dirty = False
|
||||
self.update_save_action()
|
||||
self.load_po_file(file_path)
|
||||
|
||||
def load_po_file(self, file_path):
|
||||
po = polib.pofile(file_path)
|
||||
language = po.metadata.get('Language', '')
|
||||
plural = po.metadata.get('Plural-Forms', '')
|
||||
content_type = po.metadata.get('Content-Type', 'text/plain; charset=UTF-8')
|
||||
self.language_edit.setText(language)
|
||||
self.plural_edit.setText(plural)
|
||||
self.content_type_edit.setText(content_type)
|
||||
self.po_table.setRowCount(len(po))
|
||||
for row, entry in enumerate(po):
|
||||
self.po_table.setItem(row, 0, QTableWidgetItem(entry.msgid))
|
||||
self.po_table.setItem(row, 1, QTableWidgetItem(entry.msgstr))
|
||||
|
||||
def save_file(self, file_path):
|
||||
po = polib.POFile()
|
||||
po.metadata = {
|
||||
'Language': self.language_edit.text(),
|
||||
'Content-Type': self.content_type_edit.text(),
|
||||
'Plural-Forms': self.plural_edit.text(),
|
||||
}
|
||||
for row in range(self.po_table.rowCount()):
|
||||
msgid_item = self.po_table.item(row, 0)
|
||||
msgstr_item = self.po_table.item(row, 1)
|
||||
msgid = msgid_item.text() if msgid_item else ''
|
||||
msgstr = msgstr_item.text() if msgstr_item else ''
|
||||
if msgid or msgstr:
|
||||
entry = polib.POEntry(msgid=msgid, msgstr=msgstr)
|
||||
po.append(entry)
|
||||
po.save(file_path)
|
||||
self.dirty = False
|
||||
self.update_save_action()
|
||||
|
||||
def handle_save(self):
|
||||
if self.current_file:
|
||||
self.save_file(self.current_file)
|
||||
else:
|
||||
self.handle_save_as()
|
||||
|
||||
def handle_save_as(self):
|
||||
default_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../assets/locale"))
|
||||
file_path, _ = QFileDialog.getSaveFileName(self, "Save Language File As", default_dir, "PO Files (*.po)")
|
||||
if file_path:
|
||||
self.current_file = file_path
|
||||
self.update_save_action()
|
||||
self.save_file(file_path)
|
||||
|
||||
def add_row(self):
|
||||
row = self.po_table.rowCount()
|
||||
self.po_table.insertRow(row)
|
||||
self.po_table.setItem(row, 0, QTableWidgetItem(""))
|
||||
self.po_table.setItem(row, 1, QTableWidgetItem(""))
|
||||
self.po_table.setCurrentCell(row, 0)
|
||||
self.set_dirty()
|
||||
|
||||
def remove_row(self):
|
||||
row = self.po_table.currentRow()
|
||||
if row >= 0:
|
||||
self.po_table.removeRow(row)
|
||||
self.set_dirty()
|
||||
|
||||
def closeEvent(self, event):
|
||||
if self.dirty:
|
||||
reply = QMessageBox.question(self, "Save Changes?", "Do you want to save changes before exiting?", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
|
||||
if reply == QMessageBox.Cancel:
|
||||
event.ignore()
|
||||
return
|
||||
elif reply == QMessageBox.Yes:
|
||||
self.handle_save()
|
||||
event.accept()
|
||||
|
||||
if __name__ == "__main__":
|
||||
app = QApplication(sys.argv)
|
||||
window = LangToolWindow()
|
||||
window.show()
|
||||
sys.exit(app.exec_())
|
||||
@@ -1,55 +0,0 @@
|
||||
import math
|
||||
import time
|
||||
from OpenGL.GL import *
|
||||
from OpenGL.GLU import *
|
||||
from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH, RPG_CAMERA_PIXELS_PER_UNIT, RPG_CAMERA_Z_OFFSET, RPG_CAMERA_FOV
|
||||
|
||||
class Camera:
|
||||
def __init__(self, parent):
|
||||
self.parent = parent
|
||||
self.pixelsPerUnit = RPG_CAMERA_PIXELS_PER_UNIT
|
||||
self.yOffset = RPG_CAMERA_Z_OFFSET
|
||||
self.fov = RPG_CAMERA_FOV
|
||||
self.scale = 8.0
|
||||
self.lastTime = time.time()
|
||||
self.lookAtTarget = [0.0, 0.0, 0.0]
|
||||
|
||||
def setup(self, vw, vh, duration=0.1):
|
||||
now = time.time()
|
||||
delta = now - self.lastTime
|
||||
self.lastTime = now
|
||||
# Calculate ease factor for exponential smoothing over 'duration' seconds
|
||||
ease = 1 - math.exp(-delta / duration)
|
||||
|
||||
z = (vh / 2.0) / (
|
||||
(self.pixelsPerUnit * self.scale) * math.tan(math.radians(self.fov / 2.0))
|
||||
)
|
||||
lookAt = [
|
||||
self.parent.map.position[0] * TILE_WIDTH,
|
||||
self.parent.map.position[1] * TILE_HEIGHT,
|
||||
self.parent.map.position[2] * TILE_DEPTH,
|
||||
]
|
||||
aspectRatio = vw / vh
|
||||
|
||||
# Ease the lookAt target
|
||||
for i in range(3):
|
||||
self.lookAtTarget[i] += (lookAt[i] - self.lookAtTarget[i]) * ease
|
||||
|
||||
# Camera position is now based on the eased lookAtTarget
|
||||
cameraPosition = (
|
||||
self.lookAtTarget[0],
|
||||
self.lookAtTarget[1] + self.yOffset,
|
||||
self.lookAtTarget[2] + z
|
||||
)
|
||||
|
||||
glMatrixMode(GL_PROJECTION)
|
||||
glLoadIdentity()
|
||||
gluPerspective(self.fov, aspectRatio, 0.1, 1000.0)
|
||||
glScalef(1.0, -1.0, 1.0) # Flip the projection matrix upside down
|
||||
glMatrixMode(GL_MODELVIEW)
|
||||
glLoadIdentity()
|
||||
gluLookAt(
|
||||
cameraPosition[0], cameraPosition[1], cameraPosition[2],
|
||||
self.lookAtTarget[0], self.lookAtTarget[1], self.lookAtTarget[2],
|
||||
0.0, 1.0, 0.0
|
||||
)
|
||||
@@ -1,80 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QGridLayout, QTreeWidget, QTreeWidgetItem, QComboBox
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPES
|
||||
|
||||
class ChunkPanel(QWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
layout = QVBoxLayout(self)
|
||||
|
||||
# Tile shape dropdown
|
||||
self.tileShapeDropdown = QComboBox()
|
||||
self.tileShapeDropdown.addItems(TILE_SHAPES.keys())
|
||||
self.tileShapeDropdown.setToolTip("Tile Shape")
|
||||
layout.addWidget(self.tileShapeDropdown)
|
||||
|
||||
# Add expandable tree list
|
||||
self.tree = QTreeWidget()
|
||||
self.tree.setHeaderLabel("Chunks")
|
||||
self.tree.expandAll() # Expand by default, remove if you want collapsed
|
||||
layout.addWidget(self.tree) # Removed invalid stretch factor
|
||||
|
||||
# Add stretch so tree expands
|
||||
layout.setStretchFactor(self.tree, 1)
|
||||
|
||||
# Event subscriptions
|
||||
self.parent.map.onMapData.sub(self.onMapData)
|
||||
self.parent.map.onPositionChange.sub(self.onPositionChange)
|
||||
self.tileShapeDropdown.currentTextChanged.connect(self.onTileShapeChanged)
|
||||
|
||||
# For each chunk
|
||||
for chunk in self.parent.map.chunks.values():
|
||||
# Create tree element
|
||||
item = QTreeWidgetItem(self.tree, ["Chunk ({}, {}, {})".format(chunk.x, chunk.y, chunk.z)])
|
||||
chunk.chunkPanelTree = item
|
||||
chunk.chunkPanelTree.setExpanded(True)
|
||||
item.setData(0, 0, chunk) # Store chunk reference
|
||||
|
||||
chunk.onChunkData.sub(self.onChunkData)
|
||||
|
||||
def onMapData(self, data):
|
||||
pass
|
||||
|
||||
def onPositionChange(self, pos):
|
||||
self.updateChunkList()
|
||||
|
||||
tile = self.parent.map.getTileAtWorldPos(*self.parent.map.position)
|
||||
if tile is None:
|
||||
return
|
||||
|
||||
key = "TILE_SHAPE_NULL"
|
||||
for k, v in TILE_SHAPES.items():
|
||||
if v != tile.shape:
|
||||
continue
|
||||
key = k
|
||||
break
|
||||
self.tileShapeDropdown.setCurrentText(key)
|
||||
|
||||
def onTileShapeChanged(self, shape_key):
|
||||
tile = self.parent.map.getTileAtWorldPos(*self.parent.map.position)
|
||||
|
||||
if tile is None or shape_key not in TILE_SHAPES:
|
||||
return
|
||||
tile.setShape(TILE_SHAPES[shape_key])
|
||||
|
||||
def updateChunkList(self):
|
||||
# Clear existing items
|
||||
currentChunk = self.parent.map.getChunkAtWorldPos(*self.parent.map.position)
|
||||
|
||||
# Example tree items
|
||||
for chunk in self.parent.map.chunks.values():
|
||||
title = "Chunk ({}, {}, {})".format(chunk.x, chunk.y, chunk.z)
|
||||
if chunk == currentChunk:
|
||||
title += " [C]"
|
||||
if chunk.isDirty():
|
||||
title += " *"
|
||||
item = chunk.chunkPanelTree
|
||||
item.setText(0, title)
|
||||
|
||||
def onChunkData(self, chunk):
|
||||
self.updateChunkList()
|
||||
@@ -1,154 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QComboBox, QHBoxLayout, QPushButton, QLineEdit, QListWidget, QListWidgetItem
|
||||
from PyQt5.QtCore import Qt
|
||||
from tools.dusk.entity import Entity
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, ENTITY_TYPES, ENTITY_TYPE_NULL
|
||||
|
||||
class EntityPanel(QWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
layout = QVBoxLayout(self)
|
||||
self.setLayout(layout)
|
||||
|
||||
# Top panel placeholder
|
||||
topWidget = QLabel("Entity Editor")
|
||||
layout.addWidget(topWidget)
|
||||
|
||||
# Name input
|
||||
nameLayout = QHBoxLayout()
|
||||
nameLabel = QLabel("Name:")
|
||||
self.nameInput = QLineEdit()
|
||||
nameLayout.addWidget(nameLabel)
|
||||
nameLayout.addWidget(self.nameInput)
|
||||
layout.addLayout(nameLayout)
|
||||
|
||||
# Entity Type dropdown (single selection)
|
||||
typeLayout = QHBoxLayout()
|
||||
typeLabel = QLabel("Type:")
|
||||
self.typeDropdown = QComboBox()
|
||||
self.typeDropdown.addItems(ENTITY_TYPES)
|
||||
typeLayout.addWidget(typeLabel)
|
||||
typeLayout.addWidget(self.typeDropdown)
|
||||
layout.addLayout(typeLayout)
|
||||
|
||||
# Entity list and buttons
|
||||
self.entityList = QListWidget()
|
||||
self.entityList.addItems([])
|
||||
layout.addWidget(self.entityList, stretch=1)
|
||||
|
||||
btnLayout = QHBoxLayout()
|
||||
self.btnAdd = QPushButton("Add")
|
||||
self.btnRemove = QPushButton("Remove")
|
||||
btnLayout.addWidget(self.btnAdd)
|
||||
btnLayout.addWidget(self.btnRemove)
|
||||
layout.addLayout(btnLayout)
|
||||
|
||||
# Events
|
||||
self.btnAdd.clicked.connect(self.onAddEntity)
|
||||
self.btnRemove.clicked.connect(self.onRemoveEntity)
|
||||
self.parent.map.onEntityData.sub(self.onEntityData)
|
||||
self.parent.map.onPositionChange.sub(self.onPositionChange)
|
||||
self.entityList.itemClicked.connect(self.onEntityClicked)
|
||||
self.entityList.itemDoubleClicked.connect(self.onEntityDoubleClicked)
|
||||
self.typeDropdown.currentIndexChanged.connect(self.onTypeSelected)
|
||||
self.nameInput.textChanged.connect(self.onNameChanged)
|
||||
|
||||
# Call once to populate
|
||||
self.onEntityData()
|
||||
self.onEntityUnselect()
|
||||
|
||||
def onEntityUnselect(self):
|
||||
self.entityList.setCurrentItem(None)
|
||||
self.nameInput.setText("")
|
||||
self.typeDropdown.setCurrentIndex(ENTITY_TYPE_NULL)
|
||||
|
||||
def onEntitySelect(self, entity):
|
||||
self.entityList.setCurrentItem(entity.item)
|
||||
self.nameInput.setText(entity.name)
|
||||
self.typeDropdown.setCurrentIndex(entity.type)
|
||||
|
||||
def onEntityDoubleClicked(self, item):
|
||||
entity = item.data(Qt.UserRole)
|
||||
chunk = entity.chunk
|
||||
worldX = (chunk.x * CHUNK_WIDTH) + entity.localX
|
||||
worldY = (chunk.y * CHUNK_HEIGHT) + entity.localY
|
||||
worldZ = (chunk.z * CHUNK_DEPTH) + entity.localZ
|
||||
self.parent.map.moveTo(worldX, worldY, worldZ)
|
||||
|
||||
def onEntityClicked(self, item):
|
||||
pass
|
||||
|
||||
def onAddEntity(self):
|
||||
chunk = self.parent.map.getChunkAtWorldPos(*self.parent.map.position)
|
||||
if chunk is None:
|
||||
return
|
||||
|
||||
localX = (self.parent.map.position[0] - (chunk.x * CHUNK_WIDTH)) % CHUNK_WIDTH
|
||||
localY = (self.parent.map.position[1] - (chunk.y * CHUNK_HEIGHT)) % CHUNK_HEIGHT
|
||||
localZ = (self.parent.map.position[2] - (chunk.z * CHUNK_DEPTH)) % CHUNK_DEPTH
|
||||
|
||||
# Make sure there's not already an entity here
|
||||
for ent in chunk.entities.values():
|
||||
if ent.localX == localX and ent.localY == localY and ent.localZ == localZ:
|
||||
print("Entity already exists at this location")
|
||||
return
|
||||
|
||||
ent = chunk.addEntity(localX, localY, localZ)
|
||||
|
||||
def onRemoveEntity(self):
|
||||
item = self.entityList.currentItem()
|
||||
if item is None:
|
||||
return
|
||||
entity = item.data(Qt.UserRole)
|
||||
if entity:
|
||||
chunk = entity.chunk
|
||||
chunk.removeEntity(entity)
|
||||
pass
|
||||
|
||||
def onEntityData(self):
|
||||
self.onEntityUnselect()
|
||||
self.entityList.clear()
|
||||
for chunk in self.parent.map.chunks.values():
|
||||
for id, entity in chunk.entities.items():
|
||||
item = QListWidgetItem(entity.name)
|
||||
item.setData(Qt.UserRole, entity) # Store the entity object
|
||||
entity.item = item
|
||||
self.entityList.addItem(item)
|
||||
|
||||
# Select if there is something at current position
|
||||
self.onPositionChange(self.parent.map.position)
|
||||
|
||||
def onPositionChange(self, position):
|
||||
self.onEntityUnselect()
|
||||
|
||||
# Get Entity at..
|
||||
chunk = self.parent.map.getChunkAtWorldPos(*position)
|
||||
if chunk is None:
|
||||
return
|
||||
|
||||
localX = (position[0] - (chunk.x * CHUNK_WIDTH)) % CHUNK_WIDTH
|
||||
localY = (position[1] - (chunk.y * CHUNK_HEIGHT)) % CHUNK_HEIGHT
|
||||
localZ = (position[2] - (chunk.z * CHUNK_DEPTH)) % CHUNK_DEPTH
|
||||
|
||||
for ent in chunk.entities.values():
|
||||
if ent.localX != localX or ent.localY != localY or ent.localZ != localZ:
|
||||
continue
|
||||
self.onEntitySelect(ent)
|
||||
self.entityList.setCurrentItem(ent.item)
|
||||
break
|
||||
|
||||
def onTypeSelected(self, index):
|
||||
item = self.entityList.currentItem()
|
||||
if item is None:
|
||||
return
|
||||
entity = item.data(Qt.UserRole)
|
||||
if entity:
|
||||
entity.setType(index)
|
||||
|
||||
def onNameChanged(self, text):
|
||||
item = self.entityList.currentItem()
|
||||
if item is None:
|
||||
return
|
||||
entity = item.data(Qt.UserRole)
|
||||
if entity:
|
||||
entity.setName(text)
|
||||
@@ -1,41 +0,0 @@
|
||||
from PyQt5.QtCore import QTimer
|
||||
from PyQt5.QtWidgets import QOpenGLWidget
|
||||
from OpenGL.GL import *
|
||||
from OpenGL.GLU import *
|
||||
|
||||
class GLWidget(QOpenGLWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
self.timer = QTimer(self)
|
||||
self.timer.timeout.connect(self.update)
|
||||
self.timer.start(16) # ~60 FPS
|
||||
|
||||
def initializeGL(self):
|
||||
glClearColor(0.392, 0.584, 0.929, 1.0)
|
||||
glEnable(GL_DEPTH_TEST)
|
||||
glEnable(GL_BLEND)
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
|
||||
glEnable(GL_POLYGON_OFFSET_FILL)
|
||||
glPolygonOffset(1.0, 1.0)
|
||||
glDisable(GL_POLYGON_OFFSET_FILL)
|
||||
|
||||
def resizeGL(self, w, h):
|
||||
pass
|
||||
|
||||
def paintGL(self):
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
|
||||
glLoadIdentity()
|
||||
|
||||
w = self.width()
|
||||
h = self.height()
|
||||
if h <= 0:
|
||||
h = 1
|
||||
if w <= 0:
|
||||
w = 1
|
||||
|
||||
glViewport(0, 0, w, h)
|
||||
self.parent.camera.setup(w, h)
|
||||
self.parent.grid.draw()
|
||||
self.parent.map.draw()
|
||||
self.parent.selectBox.draw()
|
||||
@@ -1,46 +0,0 @@
|
||||
from OpenGL.GL import *
|
||||
from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
|
||||
|
||||
class Grid:
|
||||
def __init__(self, lines=1000):
|
||||
self.cellWidth = TILE_WIDTH
|
||||
self.cellHeight = TILE_HEIGHT
|
||||
self.lines = lines
|
||||
self.enabled = True
|
||||
|
||||
def draw(self):
|
||||
if not self.enabled:
|
||||
return
|
||||
center = [0.01,0.01,0.01]
|
||||
halfWidth = self.cellWidth * self.lines // 2
|
||||
halfHeight = self.cellHeight * self.lines // 2
|
||||
# Draw origin axes
|
||||
glBegin(GL_LINES)
|
||||
|
||||
# X axis - RED
|
||||
glColor3f(1.0, 0.0, 0.0)
|
||||
glVertex3f(center[0] - halfWidth, center[1], center[2])
|
||||
glVertex3f(center[0] + halfWidth, center[1], center[2])
|
||||
|
||||
# Y axis - GREEN
|
||||
glColor3f(0.0, 1.0, 0.0)
|
||||
glVertex3f(center[0], center[1] - halfHeight, center[2])
|
||||
glVertex3f(center[0], center[1] + halfHeight, center[2])
|
||||
|
||||
# Z axis - BLUE
|
||||
glColor3f(0.0, 0.0, 1.0)
|
||||
glVertex3f(center[0], center[1], center[2] - halfWidth)
|
||||
glVertex3f(center[0], center[1], center[2] + halfWidth)
|
||||
glEnd()
|
||||
|
||||
# Draw grid
|
||||
glColor3f(0.8, 0.8, 0.8)
|
||||
glBegin(GL_LINES)
|
||||
for i in range(-self.lines // 2, self.lines // 2 + 1):
|
||||
# Vertical lines
|
||||
glVertex3f(center[0] + i * self.cellWidth, center[1] - halfHeight, center[2])
|
||||
glVertex3f(center[0] + i * self.cellWidth, center[1] + halfHeight, center[2])
|
||||
# Horizontal lines
|
||||
glVertex3f(center[0] - halfWidth, center[1] + i * self.cellHeight, center[2])
|
||||
glVertex3f(center[0] + halfWidth, center[1] + i * self.cellHeight, center[2])
|
||||
glEnd()
|
||||
@@ -1,83 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QLineEdit, QPushButton, QHBoxLayout, QMessageBox
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
|
||||
|
||||
class MapInfoPanel(QWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
|
||||
# Components
|
||||
layout = QVBoxLayout()
|
||||
|
||||
mapTitleLabel = QLabel("Map Title")
|
||||
self.mapTitleInput = QLineEdit()
|
||||
layout.addWidget(mapTitleLabel)
|
||||
layout.addWidget(self.mapTitleInput)
|
||||
|
||||
tilePositionLabel = QLabel("Tile Position")
|
||||
layout.addWidget(tilePositionLabel)
|
||||
tilePositionRow = QHBoxLayout()
|
||||
self.tileXInput = QLineEdit()
|
||||
self.tileXInput.setPlaceholderText("X")
|
||||
tilePositionRow.addWidget(self.tileXInput)
|
||||
self.tileYInput = QLineEdit()
|
||||
self.tileYInput.setPlaceholderText("Y")
|
||||
tilePositionRow.addWidget(self.tileYInput)
|
||||
self.tileZInput = QLineEdit()
|
||||
self.tileZInput.setPlaceholderText("Z")
|
||||
tilePositionRow.addWidget(self.tileZInput)
|
||||
self.tileGo = QPushButton("Go")
|
||||
tilePositionRow.addWidget(self.tileGo)
|
||||
layout.addLayout(tilePositionRow)
|
||||
|
||||
self.chunkPosLabel = QLabel()
|
||||
layout.addWidget(self.chunkPosLabel)
|
||||
self.chunkLabel = QLabel()
|
||||
layout.addWidget(self.chunkLabel)
|
||||
|
||||
layout.addStretch()
|
||||
self.setLayout(layout)
|
||||
|
||||
# Events
|
||||
self.tileGo.clicked.connect(self.goToPosition)
|
||||
self.tileXInput.returnPressed.connect(self.goToPosition)
|
||||
self.tileYInput.returnPressed.connect(self.goToPosition)
|
||||
self.tileZInput.returnPressed.connect(self.goToPosition)
|
||||
self.parent.map.onPositionChange.sub(self.updatePositionLabels)
|
||||
self.parent.map.onMapData.sub(self.onMapData)
|
||||
self.mapTitleInput.textChanged.connect(self.onMapNameChange)
|
||||
|
||||
# Initial label setting
|
||||
self.updatePositionLabels(self.parent.map.position)
|
||||
|
||||
def goToPosition(self):
|
||||
try:
|
||||
x = int(self.tileXInput.text())
|
||||
y = int(self.tileYInput.text())
|
||||
z = int(self.tileZInput.text())
|
||||
self.parent.map.moveTo(x, y, z)
|
||||
except ValueError:
|
||||
QMessageBox.warning(self, "Invalid Input", "Please enter valid integer coordinates.")
|
||||
|
||||
def updatePositionLabels(self, pos):
|
||||
self.tileXInput.setText(str(pos[0]))
|
||||
self.tileYInput.setText(str(pos[1]))
|
||||
self.tileZInput.setText(str(pos[2]))
|
||||
|
||||
chunkTileX = pos[0] % CHUNK_WIDTH
|
||||
chunkTileY = pos[1] % CHUNK_HEIGHT
|
||||
chunkTileZ = pos[2] % CHUNK_DEPTH
|
||||
chunkTileIndex = chunkTileX + chunkTileY * CHUNK_WIDTH + chunkTileZ * CHUNK_WIDTH * CHUNK_HEIGHT
|
||||
self.chunkPosLabel.setText(f"Chunk Position: {chunkTileX}, {chunkTileY}, {chunkTileZ} ({chunkTileIndex})")
|
||||
|
||||
chunkX = pos[0] // CHUNK_WIDTH
|
||||
chunkY = pos[1] // CHUNK_HEIGHT
|
||||
chunkZ = pos[2] // CHUNK_DEPTH
|
||||
self.chunkLabel.setText(f"Chunk: {chunkX}, {chunkY}, {chunkZ}")
|
||||
|
||||
def onMapData(self, data):
|
||||
self.updatePositionLabels(self.parent.map.position)
|
||||
self.mapTitleInput.setText(data.get("mapName", ""))
|
||||
|
||||
def onMapNameChange(self, text):
|
||||
self.parent.map.data['mapName'] = text
|
||||
@@ -1,51 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QGridLayout, QPushButton, QTabWidget, QLabel
|
||||
from tools.editor.map.chunkpanel import ChunkPanel
|
||||
from tools.editor.map.entitypanel import EntityPanel
|
||||
from tools.editor.map.regionpanel import RegionPanel
|
||||
|
||||
class MapLeftPanel(QWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
layout = QVBoxLayout(self)
|
||||
self.setLayout(layout)
|
||||
|
||||
# Nav buttons
|
||||
self.chunkInfoLabel = QLabel("Tile Information")
|
||||
layout.addWidget(self.chunkInfoLabel)
|
||||
grid = QGridLayout()
|
||||
self.btnUp = QPushButton("U")
|
||||
self.btnN = QPushButton("N")
|
||||
self.btnDown = QPushButton("D")
|
||||
self.btnW = QPushButton("W")
|
||||
self.btnS = QPushButton("S")
|
||||
self.btnE = QPushButton("E")
|
||||
|
||||
grid.addWidget(self.btnUp, 0, 0)
|
||||
grid.addWidget(self.btnN, 0, 1)
|
||||
grid.addWidget(self.btnDown, 0, 2)
|
||||
grid.addWidget(self.btnW, 1, 0)
|
||||
grid.addWidget(self.btnS, 1, 1)
|
||||
grid.addWidget(self.btnE, 1, 2)
|
||||
layout.addLayout(grid)
|
||||
|
||||
# Panels
|
||||
self.chunkPanel = ChunkPanel(self.parent)
|
||||
self.entityPanel = EntityPanel(self.parent)
|
||||
self.regionPanel = RegionPanel(self.parent)
|
||||
|
||||
# Tabs
|
||||
self.tabs = QTabWidget()
|
||||
self.tabs.addTab(self.chunkPanel, "Tiles")
|
||||
self.tabs.addTab(self.entityPanel, "Entities")
|
||||
self.tabs.addTab(self.regionPanel, "Regions")
|
||||
self.tabs.addTab(None, "Triggers")
|
||||
layout.addWidget(self.tabs)
|
||||
|
||||
# Event subscriptions
|
||||
self.btnN.clicked.connect(lambda: self.parent.map.moveRelative(0, -1, 0))
|
||||
self.btnS.clicked.connect(lambda: self.parent.map.moveRelative(0, 1, 0))
|
||||
self.btnE.clicked.connect(lambda: self.parent.map.moveRelative(1, 0, 0))
|
||||
self.btnW.clicked.connect(lambda: self.parent.map.moveRelative(-1, 0, 0))
|
||||
self.btnUp.clicked.connect(lambda: self.parent.map.moveRelative(0, 0, 1))
|
||||
self.btnDown.clicked.connect(lambda: self.parent.map.moveRelative(0, 0, -1))
|
||||
@@ -1,46 +0,0 @@
|
||||
import os
|
||||
from PyQt5.QtWidgets import QAction, QMenuBar, QFileDialog
|
||||
from PyQt5.QtGui import QKeySequence
|
||||
from tools.dusk.map import MAP_DEFAULT_PATH
|
||||
|
||||
class MapMenubar:
|
||||
def __init__(self, parent):
|
||||
self.parent = parent
|
||||
self.menubar = QMenuBar(parent)
|
||||
parent.setMenuBar(self.menubar)
|
||||
|
||||
self.fileMenu = self.menubar.addMenu("File")
|
||||
self.actionNew = QAction("New", parent)
|
||||
self.actionOpen = QAction("Open", parent)
|
||||
self.actionSave = QAction("Save", parent)
|
||||
self.actionSaveAs = QAction("Save As", parent)
|
||||
|
||||
self.actionNew.setShortcut(QKeySequence("Ctrl+N"))
|
||||
self.actionOpen.setShortcut(QKeySequence("Ctrl+O"))
|
||||
self.actionSave.setShortcut(QKeySequence("Ctrl+S"))
|
||||
self.actionSaveAs.setShortcut(QKeySequence("Ctrl+Shift+S"))
|
||||
|
||||
self.actionNew.triggered.connect(self.newFile)
|
||||
self.actionOpen.triggered.connect(self.openFile)
|
||||
self.actionSave.triggered.connect(self.saveFile)
|
||||
self.actionSaveAs.triggered.connect(self.saveAsFile)
|
||||
self.fileMenu.addAction(self.actionNew)
|
||||
self.fileMenu.addAction(self.actionOpen)
|
||||
self.fileMenu.addAction(self.actionSave)
|
||||
self.fileMenu.addAction(self.actionSaveAs)
|
||||
|
||||
def newFile(self):
|
||||
self.parent.map.newFile()
|
||||
|
||||
def openFile(self):
|
||||
filePath, _ = QFileDialog.getOpenFileName(self.menubar, "Open Map File", MAP_DEFAULT_PATH, "Map Files (*.json)")
|
||||
if filePath:
|
||||
self.parent.map.load(filePath)
|
||||
|
||||
def saveFile(self):
|
||||
self.parent.map.save()
|
||||
|
||||
def saveAsFile(self):
|
||||
filePath, _ = QFileDialog.getSaveFileName(self.menubar, "Save Map File As", MAP_DEFAULT_PATH, "Map Files (*.json)")
|
||||
if filePath:
|
||||
self.parent.map.save(filePath)
|
||||
@@ -1,15 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QComboBox, QHBoxLayout, QPushButton, QLineEdit, QListWidget, QListWidgetItem
|
||||
from PyQt5.QtCore import Qt
|
||||
from tools.dusk.entity import Entity
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, ENTITY_TYPES, ENTITY_TYPE_NULL
|
||||
|
||||
class RegionPanel(QWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
layout = QVBoxLayout(self)
|
||||
self.setLayout(layout)
|
||||
|
||||
# Top panel placeholder
|
||||
topWidget = QLabel("Region Editor")
|
||||
layout.addWidget(topWidget)
|
||||
@@ -1,44 +0,0 @@
|
||||
import OpenGL.GL as gl
|
||||
from tools.dusk.defs import defs
|
||||
import colorsys
|
||||
from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
|
||||
|
||||
class SelectBox:
|
||||
def __init__(self, parent):
|
||||
self.parent = parent
|
||||
self.hue = 0.0
|
||||
|
||||
def draw(self):
|
||||
position = [
|
||||
self.parent.map.position[0] * TILE_WIDTH - (TILE_WIDTH / 2.0),
|
||||
self.parent.map.position[1] * TILE_HEIGHT - (TILE_HEIGHT / 2.0),
|
||||
self.parent.map.position[2] * TILE_DEPTH - (TILE_DEPTH / 2.0)
|
||||
]
|
||||
|
||||
vertices = [
|
||||
(position[0], position[1], position[2]),
|
||||
(position[0]+TILE_WIDTH, position[1], position[2]),
|
||||
(position[0]+TILE_WIDTH, position[1]+TILE_HEIGHT, position[2]),
|
||||
(position[0], position[1]+TILE_HEIGHT, position[2]),
|
||||
(position[0], position[1], position[2]+TILE_DEPTH),
|
||||
(position[0]+TILE_WIDTH, position[1], position[2]+TILE_DEPTH),
|
||||
(position[0]+TILE_WIDTH, position[1]+TILE_HEIGHT, position[2]+TILE_DEPTH),
|
||||
(position[0], position[1]+TILE_HEIGHT, position[2]+TILE_DEPTH)
|
||||
]
|
||||
edges = [
|
||||
(0, 1), (1, 2), (2, 3), (3, 0), # bottom face
|
||||
(4, 5), (5, 6), (6, 7), (7, 4), # top face
|
||||
(4, 5), (5, 6), (6, 7), (7, 4), # top face
|
||||
(0, 4), (1, 5), (2, 6), (3, 7) # vertical edges
|
||||
]
|
||||
|
||||
# Cycle hue
|
||||
self.hue = (self.hue + 0.01) % 1.0
|
||||
r, g, b = colorsys.hsv_to_rgb(self.hue, 1.0, 1.0)
|
||||
gl.glColor3f(r, g, b)
|
||||
gl.glLineWidth(2.0)
|
||||
gl.glBegin(gl.GL_LINES)
|
||||
for edge in edges:
|
||||
for vertex in edge:
|
||||
gl.glVertex3f(*vertices[vertex])
|
||||
gl.glEnd()
|
||||
@@ -1,18 +0,0 @@
|
||||
from PyQt5.QtWidgets import QStatusBar, QLabel
|
||||
|
||||
class StatusBar(QStatusBar):
|
||||
def __init__(self, parent=None):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
self.leftLabel = QLabel("")
|
||||
self.rightLabel = QLabel("")
|
||||
self.addWidget(self.leftLabel, 1)
|
||||
self.addPermanentWidget(self.rightLabel)
|
||||
|
||||
parent.map.onMapData.sub(self.onMapData)
|
||||
|
||||
def setStatus(self, message):
|
||||
self.leftLabel.setText(message)
|
||||
|
||||
def onMapData(self, data):
|
||||
self.rightLabel.setText(self.parent.map.mapFileName if self.parent.map.mapFileName else "Untitled.json")
|
||||
@@ -1,80 +0,0 @@
|
||||
from OpenGL.GL import *
|
||||
import array
|
||||
|
||||
class VertexBuffer:
|
||||
def __init__(self, componentsPerVertex=3):
|
||||
self.componentsPerVertex = componentsPerVertex
|
||||
self.vertices = []
|
||||
self.colors = []
|
||||
self.uvs = []
|
||||
self.data = None
|
||||
self.colorData = None
|
||||
self.uvData = None
|
||||
|
||||
def buildData(self):
|
||||
hasColors = len(self.colors) > 0
|
||||
hasUvs = len(self.uvs) > 0
|
||||
|
||||
vertexCount = len(self.vertices) // self.componentsPerVertex
|
||||
|
||||
dataList = []
|
||||
colorList = []
|
||||
uvList = []
|
||||
|
||||
for i in range(vertexCount):
|
||||
vStart = i * self.componentsPerVertex
|
||||
dataList.extend(self.vertices[vStart:vStart+self.componentsPerVertex])
|
||||
|
||||
if hasColors:
|
||||
cStart = i * 4 # Assuming RGBA
|
||||
colorList.extend(self.colors[cStart:cStart+4])
|
||||
|
||||
if hasUvs:
|
||||
uStart = i * 2 # Assuming UV
|
||||
uvList.extend(self.uvs[uStart:uStart+2])
|
||||
|
||||
self.data = array.array('f', dataList)
|
||||
|
||||
if hasColors:
|
||||
self.colorData = array.array('f', colorList)
|
||||
else:
|
||||
self.colorData = None
|
||||
|
||||
if hasUvs:
|
||||
self.uvData = array.array('f', uvList)
|
||||
else:
|
||||
self.uvData = None
|
||||
|
||||
def draw(self, mode=GL_TRIANGLES, count=-1):
|
||||
if count == -1:
|
||||
count = len(self.data) // self.componentsPerVertex
|
||||
|
||||
if count == 0:
|
||||
return
|
||||
|
||||
glEnableClientState(GL_VERTEX_ARRAY)
|
||||
glVertexPointer(self.componentsPerVertex, GL_FLOAT, 0, self.data.tobytes())
|
||||
|
||||
if self.colorData:
|
||||
glEnableClientState(GL_COLOR_ARRAY)
|
||||
glColorPointer(4, GL_FLOAT, 0, self.colorData.tobytes())
|
||||
|
||||
if self.uvData:
|
||||
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
|
||||
glTexCoordPointer(2, GL_FLOAT, 0, self.uvData.tobytes())
|
||||
|
||||
glDrawArrays(mode, 0, count)
|
||||
|
||||
glDisableClientState(GL_VERTEX_ARRAY)
|
||||
if self.colorData:
|
||||
glDisableClientState(GL_COLOR_ARRAY)
|
||||
if self.uvData:
|
||||
glDisableClientState(GL_TEXTURE_COORD_ARRAY)
|
||||
|
||||
def clear(self):
|
||||
self.vertices = []
|
||||
self.colors = []
|
||||
self.uvs = []
|
||||
self.data = array.array('f')
|
||||
self.colorData = None
|
||||
self.uvData = None
|
||||
@@ -1,143 +0,0 @@
|
||||
import os
|
||||
from PyQt5.QtWidgets import QMainWindow, QWidget, QHBoxLayout, QMessageBox
|
||||
from PyQt5.QtCore import Qt
|
||||
from tools.editor.map.glwidget import GLWidget
|
||||
from tools.editor.map.mapleftpanel import MapLeftPanel
|
||||
from tools.editor.map.mapinfopanel import MapInfoPanel
|
||||
from tools.editor.map.menubar import MapMenubar
|
||||
from tools.editor.map.statusbar import StatusBar
|
||||
from tools.dusk.map import Map
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPE_NULL, TILE_SHAPE_FLOOR
|
||||
from tools.editor.map.selectbox import SelectBox
|
||||
from tools.editor.map.camera import Camera
|
||||
from tools.editor.map.grid import Grid
|
||||
|
||||
class MapWindow(QMainWindow):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
|
||||
self.insertPressed = False
|
||||
self.deletePressed = False
|
||||
|
||||
# Subclasses
|
||||
self.map = Map(self)
|
||||
self.camera = Camera(self)
|
||||
self.grid = Grid()
|
||||
self.selectBox = SelectBox(self)
|
||||
|
||||
# Window setup
|
||||
self.setWindowTitle("Dusk Map Editor")
|
||||
self.resize(1600, 900)
|
||||
|
||||
# Menubar (TESTING)
|
||||
self.menubar = MapMenubar(self)
|
||||
|
||||
central = QWidget()
|
||||
self.setCentralWidget(central)
|
||||
mainLayout = QHBoxLayout(central)
|
||||
|
||||
# Left panel (tabs + nav buttons)
|
||||
self.leftPanel = MapLeftPanel(self)
|
||||
self.leftPanel.setFixedWidth(350)
|
||||
mainLayout.addWidget(self.leftPanel)
|
||||
|
||||
# Center panel (GLWidget + controls)
|
||||
self.glWidget = GLWidget(self)
|
||||
mainLayout.addWidget(self.glWidget, stretch=3)
|
||||
|
||||
# Right panel (MapInfoPanel)
|
||||
self.mapInfoPanel = MapInfoPanel(self)
|
||||
rightWidget = self.mapInfoPanel
|
||||
rightWidget.setFixedWidth(250)
|
||||
mainLayout.addWidget(rightWidget)
|
||||
|
||||
# Status bar
|
||||
self.statusBar = StatusBar(self)
|
||||
self.setStatusBar(self.statusBar)
|
||||
|
||||
self.installEventFilter(self)
|
||||
self.installEventFilterRecursively(self)
|
||||
|
||||
def installEventFilterRecursively(self, widget):
|
||||
for child in widget.findChildren(QWidget):
|
||||
child.installEventFilter(self)
|
||||
self.installEventFilterRecursively(child)
|
||||
|
||||
def closeEvent(self, event):
|
||||
if not self.map.isDirty():
|
||||
event.accept()
|
||||
return
|
||||
|
||||
reply = QMessageBox.question(
|
||||
self,
|
||||
"Unsaved Changes",
|
||||
"You have unsaved changes. Do you want to save before closing?",
|
||||
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel,
|
||||
QMessageBox.Save
|
||||
)
|
||||
if reply == QMessageBox.Save:
|
||||
self.map.save()
|
||||
elif reply == QMessageBox.Cancel:
|
||||
event.ignore()
|
||||
return
|
||||
event.accept()
|
||||
|
||||
def eventFilter(self, obj, event):
|
||||
if event.type() == event.KeyPress:
|
||||
amtX, amtY, amtZ = 0, 0, 0
|
||||
|
||||
key = event.key()
|
||||
if key == Qt.Key_Left:
|
||||
amtX = -1
|
||||
elif key == Qt.Key_Right:
|
||||
amtX = 1
|
||||
elif key == Qt.Key_Up:
|
||||
amtY = -1
|
||||
elif key == Qt.Key_Down:
|
||||
amtY = 1
|
||||
elif key == Qt.Key_PageUp:
|
||||
amtZ = 1
|
||||
elif key == Qt.Key_PageDown:
|
||||
amtZ = -1
|
||||
|
||||
if event.modifiers() & Qt.ShiftModifier:
|
||||
amtX *= CHUNK_WIDTH
|
||||
amtY *= CHUNK_HEIGHT
|
||||
amtZ *= CHUNK_DEPTH
|
||||
|
||||
if amtX != 0 or amtY != 0 or amtZ != 0:
|
||||
self.map.moveRelative(amtX, amtY, amtZ)
|
||||
if self.insertPressed:
|
||||
tile = self.map.getTileAtWorldPos(*self.map.position)
|
||||
if tile is not None and tile.shape == TILE_SHAPE_NULL:
|
||||
tile.setShape(TILE_SHAPE_FLOOR)
|
||||
if self.deletePressed:
|
||||
tile = self.map.getTileAtWorldPos(*self.map.position)
|
||||
if tile is not None:
|
||||
tile.setShape(TILE_SHAPE_NULL)
|
||||
event.accept()
|
||||
return True
|
||||
|
||||
if key == Qt.Key_Delete:
|
||||
tile = self.map.getTileAtWorldPos(*self.map.position)
|
||||
self.deletePressed = True
|
||||
if tile is not None:
|
||||
tile.setShape(TILE_SHAPE_NULL)
|
||||
event.accept()
|
||||
return True
|
||||
if key == Qt.Key_Insert:
|
||||
tile = self.map.getTileAtWorldPos(*self.map.position)
|
||||
self.insertPressed = True
|
||||
if tile is not None and tile.shape == TILE_SHAPE_NULL:
|
||||
tile.setShape(TILE_SHAPE_FLOOR)
|
||||
event.accept()
|
||||
elif event.type() == event.KeyRelease:
|
||||
key = event.key()
|
||||
if key == Qt.Key_Delete:
|
||||
self.deletePressed = False
|
||||
event.accept()
|
||||
return True
|
||||
if key == Qt.Key_Insert:
|
||||
self.insertPressed = False
|
||||
event.accept()
|
||||
return super().eventFilter(obj, event)
|
||||
@@ -1,13 +0,0 @@
|
||||
# Copyright (c) 2025 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# Sources
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
assettexture.c
|
||||
assettileset.c
|
||||
assetlanguage.c
|
||||
assetscript.c
|
||||
)
|
||||
@@ -1,45 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "asset/asset.h"
|
||||
#include "assert/assert.h"
|
||||
#include "locale/localemanager.h"
|
||||
|
||||
errorret_t assetLanguageHandler(assetcustom_t custom) {
|
||||
assertNotNull(custom.zipFile, "Custom asset zip file cannot be NULL");
|
||||
assertNotNull(custom.output, "Custom asset output cannot be NULL");
|
||||
|
||||
assetlanguage_t *lang = (assetlanguage_t *)custom.output;
|
||||
errorChain(assetLanguageInit(lang, custom.zipFile));
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetLanguageInit(
|
||||
assetlanguage_t *lang,
|
||||
zip_file_t *zipFile
|
||||
) {
|
||||
errorThrow("Language asset initialization is not yet implemented.");
|
||||
}
|
||||
|
||||
errorret_t assetLanguageRead(
|
||||
assetlanguage_t *lang,
|
||||
const uint32_t key,
|
||||
char_t *buffer,
|
||||
const uint32_t bufferSize,
|
||||
uint32_t *outLength
|
||||
) {
|
||||
errorThrow("Language string reading is not yet implemented.");
|
||||
}
|
||||
|
||||
void assetLanguageDispose(assetlanguage_t *lang) {
|
||||
assertNotNull(lang, "Language asset cannot be NULL");
|
||||
|
||||
if(lang->zip) {
|
||||
zip_fclose(lang->zip);
|
||||
}
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "error/error.h"
|
||||
#include "duskdefs.h"
|
||||
#include <zip.h>
|
||||
|
||||
typedef struct {
|
||||
zip_file_t *zip;
|
||||
zip_int64_t chunksOffset;
|
||||
} assetlanguage_t;
|
||||
|
||||
typedef struct assetcustom_s assetcustom_t;
|
||||
|
||||
/**
|
||||
* Receiving function from the asset manager to handle language assets.
|
||||
*
|
||||
* @param custom Custom asset loading data.
|
||||
* @return Error code.
|
||||
*/
|
||||
errorret_t assetLanguageHandler(assetcustom_t custom);
|
||||
|
||||
/**
|
||||
* Initializes a language asset and loads the header data into memory.
|
||||
*
|
||||
* @param lang Language asset to initialize.
|
||||
* @param zipFile Zip file handle for the language asset.
|
||||
* @return Error code.
|
||||
*/
|
||||
errorret_t assetLanguageInit(assetlanguage_t *lang, zip_file_t *zipFile);
|
||||
|
||||
/**
|
||||
* Reads a string from the language asset into the provided buffer.
|
||||
*
|
||||
* @param lang Language asset to read from.
|
||||
* @param key Language key to read.
|
||||
* @param buffer Buffer to read the string into.
|
||||
* @param bufferSize Size of the provided buffer.
|
||||
* @param outLength Pointer to store the length of the string read.
|
||||
* @return Error code.
|
||||
*/
|
||||
errorret_t assetLanguageRead(
|
||||
assetlanguage_t *lang,
|
||||
const uint32_t key,
|
||||
char_t *buffer,
|
||||
const uint32_t bufferSize,
|
||||
uint32_t *outLength
|
||||
);
|
||||
|
||||
/**
|
||||
* Disposes of language asset resources.
|
||||
*
|
||||
* @param custom Custom asset loading data.
|
||||
* @return Error code.
|
||||
*/
|
||||
void assetLanguageDispose(assetlanguage_t *lang);
|
||||
@@ -1,58 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "asset/asset.h"
|
||||
#include "assert/assert.h"
|
||||
|
||||
errorret_t assetScriptHandler(assetcustom_t custom) {
|
||||
assertNotNull(custom.zipFile, "Custom asset zip file cannot be NULL");
|
||||
assertNotNull(custom.output, "Custom asset output cannot be NULL");
|
||||
|
||||
assetscript_t *script = (assetscript_t *)custom.output;
|
||||
errorChain(assetScriptInit(script, custom.zipFile));
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetScriptInit(
|
||||
assetscript_t *script,
|
||||
zip_file_t *zipFile
|
||||
) {
|
||||
assertNotNull(script, "Script asset cannot be NULL");
|
||||
assertNotNull(zipFile, "Zip file cannot be NULL");
|
||||
|
||||
// We now own the zip file handle.
|
||||
script->zip = zipFile;
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
const char_t * assetScriptReader(lua_State* lState, void* data, size_t* size) {
|
||||
assetscript_t *script = (assetscript_t *)data;
|
||||
zip_int64_t bytesRead = zip_fread(
|
||||
script->zip, script->buffer, sizeof(script->buffer)
|
||||
);
|
||||
|
||||
if(bytesRead < 0) {
|
||||
*size = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
*size = (size_t)bytesRead;
|
||||
return script->buffer;
|
||||
}
|
||||
|
||||
errorret_t assetScriptDispose(assetscript_t *script) {
|
||||
assertNotNull(script, "Script asset cannot be NULL");
|
||||
|
||||
if(script->zip != NULL) {
|
||||
zip_fclose(script->zip);
|
||||
script->zip = NULL;
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "error/error.h"
|
||||
#include "duskdefs.h"
|
||||
#include <zip.h>
|
||||
#include "script/scriptcontext.h"
|
||||
|
||||
#define ASSET_SCRIPT_BUFFER_SIZE 1024
|
||||
|
||||
typedef struct assetscript_s {
|
||||
zip_file_t *zip;
|
||||
char_t buffer[ASSET_SCRIPT_BUFFER_SIZE];
|
||||
} assetscript_t;
|
||||
|
||||
typedef struct assetcustom_s assetcustom_t;
|
||||
|
||||
/**
|
||||
* Receiving function from the asset manager to handle script assets.
|
||||
*
|
||||
* @param custom Custom asset loading data.
|
||||
* @return Error code.
|
||||
*/
|
||||
errorret_t assetScriptHandler(assetcustom_t custom);
|
||||
|
||||
/**
|
||||
* Initializes a script asset.
|
||||
*
|
||||
* @param script Script asset to initialize.
|
||||
* @param zipFile Zip file handle for the script asset.
|
||||
* @return Error code.
|
||||
*/
|
||||
errorret_t assetScriptInit(assetscript_t *script, zip_file_t *zipFile);
|
||||
|
||||
/**
|
||||
* Reader function for Lua to read script data from the asset.
|
||||
*
|
||||
* @param L Lua state.
|
||||
* @param data Pointer to the assetscript_t structure.
|
||||
* @param size Pointer to store the size of the read data.
|
||||
* @return Pointer to the read data buffer.
|
||||
*/
|
||||
const char_t * assetScriptReader(lua_State* L, void* data, size_t* size);
|
||||
|
||||
/**
|
||||
* Disposes of a script asset, freeing any allocated resources.
|
||||
*
|
||||
* @param script Script asset to dispose of.
|
||||
* @return Error code.
|
||||
*/
|
||||
errorret_t assetScriptDispose(assetscript_t *script);
|
||||
|
||||
@@ -1,78 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "assettexture.h"
|
||||
#include "asset/assettype.h"
|
||||
#include "assert/assert.h"
|
||||
#include "display/texture/texture.h"
|
||||
#include "util/endian.h"
|
||||
|
||||
errorret_t assetTextureLoad(assetentire_t entire) {
|
||||
assertNotNull(entire.data, "Data pointer cannot be NULL.");
|
||||
assertNotNull(entire.output, "Output pointer cannot be NULL.");
|
||||
|
||||
assettexture_t *assetData = (assettexture_t *)entire.data;
|
||||
texture_t *texture = (texture_t *)entire.output;
|
||||
|
||||
// Read header and version (first 4 bytes)
|
||||
if(
|
||||
assetData->header[0] != 'D' ||
|
||||
assetData->header[1] != 'T' ||
|
||||
assetData->header[2] != 'X'
|
||||
) {
|
||||
errorThrow("Invalid texture header");
|
||||
}
|
||||
|
||||
// Version (can only be 1 atm)
|
||||
if(assetData->version != 0x01) {
|
||||
errorThrow("Unsupported texture version");
|
||||
}
|
||||
|
||||
// Fix endian
|
||||
assetData->width = endianLittleToHost32(assetData->width);
|
||||
assetData->height = endianLittleToHost32(assetData->height);
|
||||
|
||||
// Check dimensions.
|
||||
if(
|
||||
assetData->width == 0 || assetData->width > ASSET_TEXTURE_WIDTH_MAX ||
|
||||
assetData->height == 0 || assetData->height > ASSET_TEXTURE_HEIGHT_MAX
|
||||
) {
|
||||
errorThrow("Invalid texture dimensions");
|
||||
}
|
||||
|
||||
// Validate format
|
||||
textureformat_t format;
|
||||
texturedata_t data;
|
||||
|
||||
switch(assetData->type) {
|
||||
case 0x00: // RGBA8888
|
||||
format = TEXTURE_FORMAT_RGBA;
|
||||
data.rgbaColors = (color_t *)assetData->data;
|
||||
break;
|
||||
|
||||
// case 0x01:
|
||||
// format = TEXTURE_FORMAT_RGB;
|
||||
// break;
|
||||
|
||||
// case 0x02:
|
||||
// format = TEXTURE_FORMAT_RGB565;
|
||||
// break;
|
||||
|
||||
// case 0x03:
|
||||
// format = TEXTURE_FORMAT_RGB5A3;
|
||||
// break;
|
||||
|
||||
default:
|
||||
errorThrow("Unsupported texture format");
|
||||
}
|
||||
|
||||
errorChain(textureInit(
|
||||
texture, assetData->width, assetData->height, format, data
|
||||
));
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "error/error.h"
|
||||
#include "display/color.h"
|
||||
|
||||
#define ASSET_TEXTURE_WIDTH_MAX 2048
|
||||
#define ASSET_TEXTURE_HEIGHT_MAX 2048
|
||||
#define ASSET_TEXTURE_SIZE_MAX ( \
|
||||
ASSET_TEXTURE_WIDTH_MAX * ASSET_TEXTURE_HEIGHT_MAX \
|
||||
)
|
||||
|
||||
typedef struct assetentire_s assetentire_t;
|
||||
|
||||
#pragma pack(push, 1)
|
||||
typedef struct {
|
||||
char_t header[3];
|
||||
uint8_t version;
|
||||
uint8_t type;
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
uint8_t data[ASSET_TEXTURE_SIZE_MAX * sizeof(color4b_t)];
|
||||
} assettexture_t;
|
||||
#pragma pack(pop)
|
||||
|
||||
/**
|
||||
* Loads a palettized texture from the given data pointer into the output
|
||||
* texture.
|
||||
*
|
||||
* @param data Pointer to the raw assettexture_t data.
|
||||
* @param output Pointer to the texture_t to load the image into.
|
||||
* @return An error code.
|
||||
*/
|
||||
errorret_t assetTextureLoad(assetentire_t entire);
|
||||
@@ -1,70 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "asset/asset.h"
|
||||
#include "assert/assert.h"
|
||||
#include "display/texture/tileset.h"
|
||||
#include "util/memory.h"
|
||||
#include "util/endian.h"
|
||||
|
||||
errorret_t assetTilesetLoad(assetentire_t entire) {
|
||||
assertNotNull(entire.data, "Asset data cannot be null");
|
||||
assertNotNull(entire.output, "Asset output cannot be null");
|
||||
|
||||
assettileset_t *tilesetData = (assettileset_t *)entire.data;
|
||||
tileset_t *tileset = (tileset_t *)entire.output;
|
||||
|
||||
if(
|
||||
tilesetData->header[0] != 'D' ||
|
||||
tilesetData->header[1] != 'T' ||
|
||||
tilesetData->header[2] != 'F'
|
||||
) {
|
||||
errorThrow("Invalid tileset header");
|
||||
}
|
||||
|
||||
if(tilesetData->version != 0x00) {
|
||||
errorThrow("Unsupported tileset version");
|
||||
}
|
||||
|
||||
// Fix endianness
|
||||
tilesetData->tileWidth = endianLittleToHost16(tilesetData->tileWidth);
|
||||
tilesetData->tileHeight = endianLittleToHost16(tilesetData->tileHeight);
|
||||
tilesetData->columnCount = endianLittleToHost16(tilesetData->columnCount);
|
||||
tilesetData->rowCount = endianLittleToHost16(tilesetData->rowCount);
|
||||
tilesetData->right = endianLittleToHost16(tilesetData->right);
|
||||
tilesetData->bottom = endianLittleToHost16(tilesetData->bottom);
|
||||
|
||||
if(tilesetData->tileWidth == 0) {
|
||||
errorThrow("Tile width cannot be 0");
|
||||
}
|
||||
if(tilesetData->tileHeight == 0) {
|
||||
errorThrow("Tile height cannot be 0");
|
||||
}
|
||||
if(tilesetData->columnCount == 0) {
|
||||
errorThrow("Column count cannot be 0");
|
||||
}
|
||||
if(tilesetData->rowCount == 0) {
|
||||
errorThrow("Row count cannot be 0");
|
||||
}
|
||||
|
||||
tilesetData->u0 = endianLittleToHostFloat(tilesetData->u0);
|
||||
tilesetData->v0 = endianLittleToHostFloat(tilesetData->v0);
|
||||
|
||||
if(tilesetData->v0 < 0.0f || tilesetData->v0 > 1.0f) {
|
||||
errorThrow("Invalid v0 value in tileset");
|
||||
}
|
||||
|
||||
// Setup tileset
|
||||
tileset->tileWidth = tilesetData->tileWidth;
|
||||
tileset->tileHeight = tilesetData->tileHeight;
|
||||
tileset->tileCount = tilesetData->columnCount * tilesetData->rowCount;
|
||||
tileset->columns = tilesetData->columnCount;
|
||||
tileset->rows = tilesetData->rowCount;
|
||||
tileset->uv[0] = tilesetData->u0;
|
||||
tileset->uv[1] = tilesetData->v0;
|
||||
errorOk();
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "error/error.h"
|
||||
|
||||
#pragma pack(push, 1)
|
||||
typedef struct {
|
||||
char_t header[3];
|
||||
uint8_t version;
|
||||
uint16_t tileWidth;
|
||||
uint16_t tileHeight;
|
||||
uint16_t columnCount;
|
||||
uint16_t rowCount;
|
||||
uint16_t right;
|
||||
uint16_t bottom;
|
||||
float_t u0;
|
||||
float_t v0;
|
||||
} assettileset_t;
|
||||
#pragma pack(pop)
|
||||
|
||||
/**
|
||||
* Loads a tileset from the given data pointer into the output tileset.
|
||||
*
|
||||
* @param entire Data received from the asset loader system.
|
||||
* @return An error code.
|
||||
*/
|
||||
errorret_t assetTilesetLoad(assetentire_t entire);
|
||||
@@ -1,6 +0,0 @@
|
||||
# Copyright (c) 2025 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
add_subdirectory(testmap)
|
||||
@@ -1,6 +0,0 @@
|
||||
# Copyright (c) 2025 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
add_asset(MAP testmap.json)
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 2, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
|
||||
@@ -1 +0,0 @@
|
||||
{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}
|
||||
@@ -1,3 +0,0 @@
|
||||
{
|
||||
"name": "Test"
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "script/scriptcontext.h"
|
||||
#include "debug/debug.h"
|
||||
#include "assert/assert.h"
|
||||
#include "rpg/overworld/map.h"
|
||||
|
||||
int moduleMapLoad(lua_State *L) {
|
||||
assertNotNull(L, "Lua state cannot be NULL");
|
||||
|
||||
if(!lua_isstring(L, 1)) {
|
||||
luaL_error(L, "Expected string map filename");
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Potentially provide up to 3 params
|
||||
chunkpos_t initial = { .x = 0, .y = 0, .z = 0 };
|
||||
if(lua_isnumber(L, 2)) {
|
||||
initial.x = (chunkunit_t)lua_tonumber(L, 2);
|
||||
}
|
||||
if(lua_isnumber(L, 3)) {
|
||||
initial.y = (chunkunit_t)lua_tonumber(L, 3);
|
||||
}
|
||||
if(lua_isnumber(L, 4)) {
|
||||
initial.z = (chunkunit_t)lua_tonumber(L, 4);
|
||||
}
|
||||
|
||||
// Load the map.
|
||||
errorret_t ret = mapLoad(luaL_checkstring(L, 1), initial);
|
||||
if(ret.code != ERROR_OK) {
|
||||
luaL_error(L, "Failed to load map");
|
||||
errorCatch(errorPrint(ret));
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void moduleMapSystem(scriptcontext_t *context) {
|
||||
assertNotNull(context, "Script context cannot be NULL");
|
||||
|
||||
lua_register(context->luaState, "mapLoad", moduleMapLoad);
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
# Copyright (c) 2025 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# Sources
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
display.c
|
||||
)
|
||||
|
||||
# Subdirectories
|
||||
add_subdirectory(framebuffer)
|
||||
add_subdirectory(mesh)
|
||||
add_subdirectory(screen)
|
||||
add_subdirectory(shader)
|
||||
add_subdirectory(spritebatch)
|
||||
add_subdirectory(text)
|
||||
add_subdirectory(texture)
|
||||
|
||||
# Color definitions
|
||||
dusk_run_python(
|
||||
dusk_color_defs
|
||||
tools.color.csv
|
||||
--csv ${CMAKE_CURRENT_SOURCE_DIR}/color.csv
|
||||
--output ${DUSK_GENERATED_HEADERS_DIR}/display/color.h
|
||||
)
|
||||
add_dependencies(${DUSK_LIBRARY_TARGET_NAME} dusk_color_defs)
|
||||
@@ -1,23 +0,0 @@
|
||||
name,r,g,b,a
|
||||
black,0,0,0,1
|
||||
white,1,1,1,1
|
||||
red,1,0,0,1
|
||||
green,0,1,0,1
|
||||
blue,0,0,1,1
|
||||
yellow,1,1,0,1
|
||||
cyan,0,1,1,1
|
||||
magenta,1,0,1,1
|
||||
transparent,0,0,0,0
|
||||
transparent_white,1,1,1,0
|
||||
transparent_black,0,0,0,0
|
||||
gray,0.5,0.5,0.5,1
|
||||
light_gray,0.75,0.75,0.75,1
|
||||
dark_gray,0.25,0.25,0.25,1
|
||||
orange,1,0.65,0,1
|
||||
purple,0.5,0,0.5,1
|
||||
brown,0.6,0.4,0.2,1
|
||||
pink,1,0.75,0.8,1
|
||||
lime,0.75,1,0,1
|
||||
navy,0,0,0.5,1
|
||||
teal,0,0.5,0.5,1
|
||||
cornflower_blue,0.39,0.58,0.93,1
|
||||
|
@@ -1,116 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "display/display.h"
|
||||
#include "display/framebuffer/framebuffer.h"
|
||||
#include "scene/scene.h"
|
||||
#include "display/spritebatch/spritebatch.h"
|
||||
#include "display/mesh/quad.h"
|
||||
#include "display/mesh/cube.h"
|
||||
#include "display/mesh/sphere.h"
|
||||
#include "display/mesh/plane.h"
|
||||
#include "display/mesh/capsule.h"
|
||||
#include "display/mesh/triprism.h"
|
||||
#include "display/screen/screen.h"
|
||||
#include "ui/ui.h"
|
||||
#include "display/text/text.h"
|
||||
#include "assert/assert.h"
|
||||
#include "util/memory.h"
|
||||
#include "util/string.h"
|
||||
#include "asset/asset.h"
|
||||
#include "display/shader/shaderlist.h"
|
||||
#include "time/time.h"
|
||||
|
||||
display_t DISPLAY = { 0 };
|
||||
|
||||
errorret_t displayInit(void) {
|
||||
memoryZero(&DISPLAY, sizeof(DISPLAY));
|
||||
|
||||
#ifdef displayPlatformInit
|
||||
errorChain(displayPlatformInit());
|
||||
#endif
|
||||
errorChain(displaySetState((displaystate_t){ .flags = 0 }));
|
||||
errorChain(textureInit(
|
||||
&TEXTURE_WHITE, 4, 4,
|
||||
TEXTURE_FORMAT_RGBA, (texturedata_t){ .rgbaColors = TEXTURE_WHITE_PIXELS }
|
||||
));
|
||||
errorChain(textureInit(
|
||||
&TEXTURE_TEST, 4, 4,
|
||||
TEXTURE_FORMAT_RGBA, (texturedata_t){ .rgbaColors = TEXTURE_TEST_PIXELS }
|
||||
));
|
||||
|
||||
// Standard meshes
|
||||
errorChain(quadInit());
|
||||
errorChain(cubeInit());
|
||||
errorChain(sphereInit());
|
||||
errorChain(planeInit());
|
||||
errorChain(capsuleInit());
|
||||
errorChain(triPrismInit());
|
||||
|
||||
errorChain(frameBufferInitBackBuffer());
|
||||
errorChain(spriteBatchInit());
|
||||
errorChain(textInit());
|
||||
errorChain(screenInit());
|
||||
|
||||
// Setup initial shader with default values
|
||||
|
||||
errorChain(shaderListInit());
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t displayUpdate(void) {
|
||||
#ifdef displayPlatformUpdate
|
||||
errorChain(displayPlatformUpdate());
|
||||
#endif
|
||||
|
||||
// Reset state
|
||||
spriteBatchClear();
|
||||
errorChain(frameBufferBind(NULL));
|
||||
|
||||
// Bind screen and render scene
|
||||
errorChain(screenBind());
|
||||
frameBufferClear(
|
||||
FRAMEBUFFER_CLEAR_COLOR | FRAMEBUFFER_CLEAR_DEPTH,
|
||||
SCREEN.background
|
||||
);
|
||||
|
||||
errorChain(sceneRender());
|
||||
|
||||
// Finish up
|
||||
screenUnbind();
|
||||
screenRender();
|
||||
|
||||
// Swap and return.
|
||||
#ifdef displayPlatformSwap
|
||||
errorChain(displayPlatformSwap());
|
||||
#endif
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t displaySetState(displaystate_t state) {
|
||||
#ifdef displayPlatformSetState
|
||||
errorChain(displayPlatformSetState(state));
|
||||
#endif
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t displayDispose(void) {
|
||||
errorChain(shaderListDispose());
|
||||
errorChain(spriteBatchDispose());
|
||||
screenDispose();
|
||||
errorChain(textDispose());
|
||||
errorChain(textureDispose(&TEXTURE_WHITE));
|
||||
errorChain(textureDispose(&TEXTURE_TEST));
|
||||
|
||||
#ifdef displayPlatformDispose
|
||||
displayPlatformDispose();
|
||||
#endif
|
||||
|
||||
// For now, we just return an OK error.
|
||||
errorOk();
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "display/displayplatform.h"
|
||||
|
||||
// Expecting some definitions to be provided
|
||||
#ifndef DUSK_DISPLAY_SIZE_DYNAMIC
|
||||
#ifndef DUSK_DISPLAY_WIDTH
|
||||
#error "DUSK_DISPLAY_WIDTH must be defined."
|
||||
#endif
|
||||
#ifndef DUSK_DISPLAY_HEIGHT
|
||||
#error "DUSK_DISPLAY_HEIGHT must be defined"
|
||||
#endif
|
||||
#define DUSK_DISPLAY_WIDTH_DEFAULT DUSK_DISPLAY_WIDTH
|
||||
#define DUSK_DISPLAY_HEIGHT_DEFAULT DUSK_DISPLAY_HEIGHT
|
||||
#else
|
||||
#ifndef DUSK_DISPLAY_WIDTH_DEFAULT
|
||||
#error "DUSK_DISPLAY_WIDTH_DEFAULT must be defined."
|
||||
#endif
|
||||
#ifndef DUSK_DISPLAY_HEIGHT_DEFAULT
|
||||
#error "DUSK_DISPLAY_HEIGHT_DEFAULT must be defined."
|
||||
#endif
|
||||
#ifdef DUSK_DISPLAY_WIDTH
|
||||
#error "DUSK_DISPLAY_WIDTH should not be defined."
|
||||
#endif
|
||||
#ifdef DUSK_DISPLAY_HEIGHT
|
||||
#error "DUSK_DISPLAY_HEIGHT should not be defined."
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Main Display Struct, platform-speicifc
|
||||
typedef displayplatform_t display_t;
|
||||
|
||||
extern display_t DISPLAY;
|
||||
|
||||
/**
|
||||
* Initializes the display system.
|
||||
* @return An errorret_t indicating success or failure.
|
||||
*/
|
||||
errorret_t displayInit(void);
|
||||
|
||||
/**
|
||||
* Tells the display system to actually draw the frame.
|
||||
* @return An errorret_t indicating success or failure.
|
||||
*/
|
||||
errorret_t displayUpdate(void);
|
||||
|
||||
/**
|
||||
* Sets the display state.
|
||||
*
|
||||
* @param state The state to set.
|
||||
* @return An errorret_t indicating success or failure.
|
||||
*/
|
||||
errorret_t displaySetState(displaystate_t state);
|
||||
|
||||
/**
|
||||
* Disposes of the display system.
|
||||
* @return An errorret_t indicating success or failure.
|
||||
*/
|
||||
errorret_t displayDispose(void);
|
||||
@@ -1,17 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "dusk.h"
|
||||
|
||||
#define DISPLAY_STATE_FLAG_CULL (1 << 0)
|
||||
#define DISPLAY_STATE_FLAG_DEPTH_TEST (1 << 1)
|
||||
#define DISPLAY_STATE_FLAG_BLEND (1 << 2)
|
||||
|
||||
typedef struct {
|
||||
uint8_t flags;
|
||||
} displaystate_t;
|
||||
@@ -1,12 +0,0 @@
|
||||
# Copyright (c) 2025 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# Sources
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
sdl2.c
|
||||
psp.c
|
||||
dolphin.c
|
||||
)
|
||||
@@ -1,92 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "dolphin.h"
|
||||
|
||||
void displayInitDolphin(void) {
|
||||
VIDEO_Init();
|
||||
DISPLAY.screenMode = VIDEO_GetPreferredMode(NULL);
|
||||
DISPLAY.frameBuffer[0] = MEM_K0_TO_K1(
|
||||
SYS_AllocateFramebuffer(DISPLAY.screenMode)
|
||||
);
|
||||
DISPLAY.frameBuffer[1] = MEM_K0_TO_K1(
|
||||
SYS_AllocateFramebuffer(DISPLAY.screenMode)
|
||||
);
|
||||
VIDEO_Configure(DISPLAY.screenMode);
|
||||
|
||||
VIDEO_SetNextFramebuffer(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer]);
|
||||
// VIDEO_SetPostRetraceCallback(copy_buffers);
|
||||
VIDEO_SetBlack(FALSE);
|
||||
VIDEO_Flush();
|
||||
VIDEO_WaitVSync();
|
||||
if(DISPLAY.screenMode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();
|
||||
|
||||
DISPLAY.fifoBuffer = memalign(32, DISPLAY_FIFO_SIZE);
|
||||
memoryZero(DISPLAY.fifoBuffer, DISPLAY_FIFO_SIZE);
|
||||
|
||||
GX_Init(DISPLAY.fifoBuffer, DISPLAY_FIFO_SIZE);
|
||||
|
||||
// This seems to be mostly related to interlacing vs progressive
|
||||
GX_SetViewport(
|
||||
0, 0,
|
||||
DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight,
|
||||
0, 1
|
||||
);
|
||||
float_t yscale = GX_GetYScaleFactor(
|
||||
DISPLAY.screenMode->efbHeight, DISPLAY.screenMode->xfbHeight
|
||||
);
|
||||
uint32_t xfbHeight = GX_SetDispCopyYScale(yscale);
|
||||
GX_SetScissor(
|
||||
0, 0,
|
||||
DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight
|
||||
);
|
||||
GX_SetDispCopySrc(
|
||||
0, 0,
|
||||
DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight
|
||||
);
|
||||
GX_SetDispCopyDst(DISPLAY.screenMode->fbWidth, xfbHeight);
|
||||
GX_SetCopyFilter(
|
||||
DISPLAY.screenMode->aa,
|
||||
DISPLAY.screenMode->sample_pattern,
|
||||
GX_TRUE,
|
||||
DISPLAY.screenMode->vfilter
|
||||
);
|
||||
GX_SetFieldMode(
|
||||
DISPLAY.screenMode->field_rendering,
|
||||
(
|
||||
(DISPLAY.screenMode->viHeight == 2 * DISPLAY.screenMode->xfbHeight) ?
|
||||
GX_ENABLE :
|
||||
GX_DISABLE
|
||||
)
|
||||
);
|
||||
|
||||
// Setup cull modes
|
||||
GX_SetCullMode(GX_CULL_NONE);
|
||||
GX_SetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
|
||||
GX_CopyDisp(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer], GX_TRUE);
|
||||
GX_SetDispCopyGamma(GX_GM_1_0);
|
||||
|
||||
GX_ClearVtxDesc();
|
||||
GX_SetVtxDesc(GX_VA_POS, GX_INDEX16);
|
||||
GX_SetVtxDesc(GX_VA_CLR0, GX_INDEX16);
|
||||
GX_SetVtxDesc(GX_VA_TEX0, GX_INDEX16);
|
||||
GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
|
||||
GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_U8, 0);
|
||||
GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
|
||||
}
|
||||
|
||||
void displayDolphinSwap(void) {
|
||||
GX_DrawDone();
|
||||
|
||||
DISPLAY.whichFrameBuffer ^= 1;
|
||||
GX_SetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
|
||||
GX_SetColorUpdate(GX_TRUE);
|
||||
GX_CopyDisp(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer], GX_TRUE);
|
||||
VIDEO_SetNextFramebuffer(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer]);
|
||||
VIDEO_Flush();
|
||||
VIDEO_WaitVSync();
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "dusk.h"
|
||||
#include "display/displaydefs.h"
|
||||
|
||||
typedef struct {
|
||||
void *frameBuffer[2];// Double-Bufferred
|
||||
int whichFrameBuffer;
|
||||
GXRModeObj *screenMode;
|
||||
void *fifoBuffer;
|
||||
} displaydolphin_t;
|
||||
|
||||
/**
|
||||
* Initializes the display for Dolphin.
|
||||
*/
|
||||
void displayDolphinInit(void);
|
||||
|
||||
/**
|
||||
* Swaps the back buffer to the front for Dolphin.
|
||||
*/
|
||||
void displayDolphinSwap(void);
|
||||
@@ -1,12 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "psp.h"
|
||||
|
||||
void displayInitPSP(void) {
|
||||
DISPLAY.usingShaderedPalettes = false;
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
/**
|
||||
* Initializes the display for PSP.
|
||||
*/
|
||||
void displayInitPSP(void);
|
||||
@@ -1,32 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "sdl2.h"
|
||||
|
||||
void displaySDL2Update(void) {
|
||||
}
|
||||
|
||||
void displaySDL2Swap(void) {
|
||||
SDL_GL_SwapWindow(DISPLAY.window);
|
||||
|
||||
GLenum err;
|
||||
while((err = glGetError()) != GL_NO_ERROR) {
|
||||
debugPrint("GL Error: %d\n", err);
|
||||
}
|
||||
}
|
||||
|
||||
void displaySDL2Dispose(void) {
|
||||
if(DISPLAY.glContext) {
|
||||
SDL_GL_DeleteContext(DISPLAY.glContext);
|
||||
DISPLAY.glContext = NULL;
|
||||
}
|
||||
if(DISPLAY.window) {
|
||||
SDL_DestroyWindow(DISPLAY.window);
|
||||
DISPLAY.window = NULL;
|
||||
}
|
||||
SDL_Quit();
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "dusk.h"
|
||||
|
||||
typedef struct {
|
||||
SDL_Window *window;
|
||||
SDL_GLContext glContext;
|
||||
bool_t usingShaderedPalettes;
|
||||
} displaysdl2_t;
|
||||
|
||||
/**
|
||||
* Initializes the display for SDL2.
|
||||
*/
|
||||
void displaySDL2Init(void);
|
||||
|
||||
/**
|
||||
* Updates the display for SDL2.
|
||||
*/
|
||||
void displaySDL2Update(void);
|
||||
|
||||
/**
|
||||
* Swaps the display buffers for SDL2.
|
||||
*/
|
||||
void displaySDL2Swap(void);
|
||||
|
||||
/**
|
||||
* Disposes of the display for SDL2.
|
||||
*/
|
||||
void displaySDL2Dispose(void);
|
||||
@@ -1,17 +0,0 @@
|
||||
# Copyright (c) 2025 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# Sources
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
rpg.c
|
||||
rpgcamera.c
|
||||
rpgtextbox.c
|
||||
)
|
||||
|
||||
# Subdirs
|
||||
add_subdirectory(cutscene)
|
||||
add_subdirectory(entity)
|
||||
add_subdirectory(overworld)
|
||||
@@ -1,14 +0,0 @@
|
||||
# Copyright (c) 2025 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# Sources
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
cutscenesystem.c
|
||||
cutscenemode.c
|
||||
)
|
||||
|
||||
# Subdirs
|
||||
add_subdirectory(item)
|
||||
@@ -1,14 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "rpg/cutscene/item/cutsceneitem.h"
|
||||
|
||||
typedef struct cutscene_s {
|
||||
const cutsceneitem_t *items;
|
||||
uint8_t itemCount;
|
||||
} cutscene_t;
|
||||
@@ -1,19 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2025 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "rpg/cutscene/cutscenesystem.h"
|
||||
|
||||
bool_t cutsceneModeIsInputAllowed() {
|
||||
switch(CUTSCENE_SYSTEM.mode) {
|
||||
case CUTSCENE_MODE_FULL_FREEZE:
|
||||
case CUTSCENE_MODE_INPUT_FREEZE:
|
||||
return false;
|
||||
|
||||
default:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user