1837 lines
73 KiB
C
1837 lines
73 KiB
C
|
// in-game editor
|
||
|
|
// - rlyeh, public domain.
|
||
|
|
|
||
|
|
// ## Design
|
||
|
|
// ### editor (v1)
|
||
|
|
// The v1 editor is a tool that understands Assets and is able to *edit the details of such Assets*.
|
||
|
|
// This understanding is configured via reflection fields in .ini files. Can be reflected from C as well.
|
||
|
|
// The reflected properties will enable loading, saving and creating generic widget views to edit the Assets.
|
||
|
|
// Because we load and save the state of Assets, we can also undo and redo changes by simulating load/saves from/into memory.
|
||
|
|
// And we can also dump the contents into disk, and create diffs and patches from them.
|
||
|
|
// - [x] Load Assets
|
||
|
|
// - [x] Edit Assets
|
||
|
|
// - [x] Save Assets
|
||
|
|
// - [x] Undo Assets (automatic, via loading older state)
|
||
|
|
// - [x] Redo Assets (automatic, via loading newer state)
|
||
|
|
// - [x] Diff Assets (from two states)
|
||
|
|
// - [x] Mend Assets (from two states)
|
||
|
|
//
|
||
|
|
// Note that the editor is dumb and does not tick/draw your GameObjects. It does not handle the Scene/World either.
|
||
|
|
// Those are game-driven systems. Your game should provide the meanings to actually:
|
||
|
|
// - [?] Spawn Assets
|
||
|
|
// - [?] Delete Assets
|
||
|
|
// - [x] Draw Assets
|
||
|
|
// - [x] Tick Assets
|
||
|
|
// - [*] Scene Traversals (parent->children*, visibility, collisions and such)
|
||
|
|
//
|
||
|
|
// PS: Asset pipeline is external to the editor. Exotic assets could use some fancy plugins to deal with the import/export; eg, Substance 3D.
|
||
|
|
// PS: Asset versioning is also external to the editor. We could integrate a few VCS plugins within the editor: p4, git, svn, ...
|
||
|
|
//
|
||
|
|
// ### editor (v2)
|
||
|
|
// The v2 editor adds container support and modding features from previous editor.
|
||
|
|
//
|
||
|
|
// Your game could use fancy containers everywhere now. However, for simplicity purposes, Editor would be ignorant about them as well.
|
||
|
|
// Editor can only use containers that can decay to vectors and strides. Examples:
|
||
|
|
// - [x] Vectors: already supported in the Editor.
|
||
|
|
// - [?] Arrays: can decay to a fixed/immutable vector.
|
||
|
|
// - [?] Sparse/Unordered/Ordered Sets: can decay to vector of values.
|
||
|
|
// - [?] Sparse/Unordered/Ordered Maps: can decay to vector of keys + vector of values.
|
||
|
|
// - [?] Other fancy containers: can iterate on elements and send each item to editor individually; might be slow.
|
||
|
|
//
|
||
|
|
// We also allow here for others to extend or *override the behavior and look of each window and/or widget* by using .lua and .dll plugins:
|
||
|
|
// - [ ] Draw Windows --> Custom overrides to alter or enhance the renderer while editing. Via C/C++/dll/lua plugins
|
||
|
|
// - [ ] Tick Windows --> Custom overrides to alter or enhance the behavior while editing. Via C/C++/dll/lua plugins
|
||
|
|
//
|
||
|
|
// ### editor (v3)
|
||
|
|
// v3 brings in data driven control; ie, be able to parse & interpret text commands from any input stream.
|
||
|
|
// This would allow for remote control (via OSC), extending scripts, offline commands, Telnet sessions or external tools; like GDB does.
|
||
|
|
// - [ ] Data driven
|
||
|
|
//
|
||
|
|
// The v3 editor is also a bootstrapped v2 editor with tons of .luas. The C skeleton is only a window manager at this point.
|
||
|
|
// The intention here is to *leverage editing workflow purely into data-driven files*, so the engine can grow up exponentially from here.
|
||
|
|
// Data-driven on steroids. It would be totally a success if the editor could be bootstrapped to include these kind of sub-editors without much work on the C codebase:
|
||
|
|
// - [ ] Level 2D/Blockout editor
|
||
|
|
// - [ ] Level 3D/Blockout editor
|
||
|
|
// - [*] World outliner
|
||
|
|
// - [ ] Nodegraph editor (ShaderGraph, AnimGraph, AudioGraph, MaterialGraph, DialogGraph, AIGraph, QuestGraph, ...)
|
||
|
|
// - [ ] Sequencer
|
||
|
|
// - [ ] Tracker (music tracker)
|
||
|
|
// - [ ] Etc...
|
||
|
|
//
|
||
|
|
// ### editor (v4)
|
||
|
|
// Bring in remote datas into the editor.
|
||
|
|
// Go social & marketplace. Allow others to expand, share, publish, subscribe, discuss their sub-editors within a small community.
|
||
|
|
// I really like the way the way OpenFrameworks.cc does their addons, and I think we should do same: just discover and monitor github repos, and list everything on a website (fwk- prefix?).
|
||
|
|
// Wishlist for a github-based community flow: discovery, transparent installs, publish on github, star there, watch commits & releases, track issues+discussions, etc
|
||
|
|
//
|
||
|
|
// We should have a generic, extensible, script/plugin-driven, working editor at this point (hopefully) that does not require maintenance.
|
||
|
|
|
||
|
|
// ## Roadmaps
|
||
|
|
// ### v1 roadmap (current)
|
||
|
|
// - [*] menu: open, save, save as, save all, reload
|
||
|
|
// - [x] basic gizmos (@todo: fixed screen size, snapping)
|
||
|
|
// - [ ] add/rem entities, add/rem components, add/rem/pause/resume systems
|
||
|
|
// - [ ] cut/copy/paste (ctrl-c to serialize)
|
||
|
|
// - [ ] F1, detach from game (long press will send F1 key to game)
|
||
|
|
// - [ ] TAB, isolated view of selected entity on/off. (long press will send TAB key to game)
|
||
|
|
// - [ ] standardise binary format. msgpack(<->json)? go .ini instead? .ini+blob? .kvdb?
|
||
|
|
// - [*] object processing from game: tick,draw*,spawn,delete,un/load from bvh stream,
|
||
|
|
// - [ ] cut/copy/paste <--> add/del events into game (ctrl-c to serialize)
|
||
|
|
// - [x] multiple selections/select all
|
||
|
|
// - [x] tree traversal from game (parent->child)
|
||
|
|
// - [ ] operations on trees: load/save -> as filesystem or .zipped level
|
||
|
|
//
|
||
|
|
// ### v2 roadmap (mid-term)
|
||
|
|
// - [ ] add keyboard shortcuts
|
||
|
|
// - [ ] tree traversal from game
|
||
|
|
// - [ ] bvh and collision queries
|
||
|
|
// - [ ] visibility and pvs queries
|
||
|
|
// - [ ] art/ vs prefabs/ discrimination: prefabs/ are archetypes (composed types); ie, data-classes. art/ contains data files.
|
||
|
|
// - [ ] can prefabs be done with ecs maybe?
|
||
|
|
// - [ ] example: levels are prefabs, composed of other sub-prefabs or art assets.
|
||
|
|
// - [ ] example: hitboxes+events. girl=pivot(p,r,s)+model(mesh,tex)+curframe
|
||
|
|
// - [ ] extend widgets vec3 as range;customized mesh,texture,audio,any other asset,combo of anything)
|
||
|
|
//
|
||
|
|
// ### v3 roadmap (long-term)
|
||
|
|
// ### v4 roadmap (long-term)
|
||
|
|
// - [ ] osc server for properties and editor behavior
|
||
|
|
//
|
||
|
|
|
||
|
|
// ## Implementation ideas
|
||
|
|
// ### editor
|
||
|
|
// - [x] editor = tree of nodes. world, levels and objects are nodes, and even widgets are also nodes.
|
||
|
|
// - [ ] you can perform actions on some or all of these nodes, with or without descendants, from any top-bottom or bottom-top directions.
|
||
|
|
// - [ ] these actions include load/save, reset, undo/redo, play/render, toggle vis:on/off/alpha logic:on/off/other ddraw:on/off log:on/off, etc.
|
||
|
|
// and that's all.
|
||
|
|
//
|
||
|
|
// ### organization: world as a filesystem
|
||
|
|
// - [ ] anything can be serialized into disk. any object, any entity, any property or any widget can be serialized into disk.
|
||
|
|
// - [ ] groups of them as well. the whole world state can be serialized into disk as a filesystem snapshot:
|
||
|
|
// - [ ] - entities are folders. you can attach nodes on nodes (ie, create folders inside folders).
|
||
|
|
// - [ ] - systems are dlls/scripts. you can modify them on the fly and they should reload.
|
||
|
|
// - [ ] - components are data files. each component is a file. some components may be pure datas (ie, raw textures) but some others can be human-readable and editable.
|
||
|
|
// inside of that, every line is a JSON/INI property that you can tweak, modify or inspect.
|
||
|
|
//
|
||
|
|
// ### replication: diffing zips
|
||
|
|
// - [ ] the whole world/filesystem will be compressed into a zipfile and delivered to the network when sharding/replicating in a network scenario.
|
||
|
|
// - [ ] clients will be diffing/patching their filesystems on every received packet. there will be 3 operations to support internally that will reflect what the E/C/S world is doing behind the curtains:
|
||
|
|
// - [ ] - added files/folders [+] : when creating entities/components/systems
|
||
|
|
// - [ ] - deleted files/folders [-] : when removing entities/components/systems
|
||
|
|
// - [ ] - modifying files/folders [*] : when altering entities/components/systems
|
||
|
|
//
|
||
|
|
// ### communication: osc messages
|
||
|
|
// - [ ] any living entity in the game, or within the editor, can be inspected, debugged or tweaked from external tools.
|
||
|
|
// - [ ] in order to achieve that, an opensoundserver is listening on a binding IP and you can send UDP packets to every node in the world.
|
||
|
|
// - [ ] the UDP port number matches current year (2021, 2022, 2023...)
|
||
|
|
//
|
||
|
|
// ### augmentation: widgets escalate from bottom
|
||
|
|
// - [x] there are only a few basic supplied widgets.
|
||
|
|
// - [x] and they correlate to C types: bool, u/int 8/16/32/64, float/double, strings and enums.
|
||
|
|
// - [x] structs are covered by reflecting and editing all members separately.
|
||
|
|
// - [ ] optionally, you can extend some basic types to have better visualization widgets.
|
||
|
|
// ie, you could alias x4 float widgets together into a new shiny vec4 widget that is more compact, fancy and convenient to use.
|
||
|
|
// then you can also alias that very same vec4 into a color picker for example; or maybe convert that vec3 into a position gizmo.
|
||
|
|
// then maybe alias x2 color pickers and create a gradient widget. and so on...
|
||
|
|
|
||
|
|
// ## old notes below
|
||
|
|
// ==================
|
||
|
|
// - [ ] editor (json level): load/save jsons, property editor for anything (remote osc server/client)
|
||
|
|
// - gizmo: proportional, orbit/arcball XY (+shift for Z/tilt)
|
||
|
|
// - scene: scenegraph, obj naming, ~~obj picking, obj bounds,~~ obj collisions, obj/scene streaming
|
||
|
|
// - placeholders google
|
||
|
|
// - vcs
|
||
|
|
// - [ ] Level objects: ~~volumes, triggers, platforms, streaming~~.
|
||
|
|
// - level: emitters: particles, lights, lightmaps, sound sources, triggers, etc
|
||
|
|
// - level: box triggers, start/end, spawn, streaming, checkpoints,
|
||
|
|
// - level: jump, shoots, platforms, collisions
|
||
|
|
// - level: 60s, 70s, 80s, 90s
|
||
|
|
// - [ ] Core: wecs+replication
|
||
|
|
// - modules: script or dll + ram load/save/diff/patch + play/stop/init/ + attach/detach
|
||
|
|
// - logic tree/ << [] |> || >>
|
||
|
|
// - - scene |>
|
||
|
|
// - - enemies
|
||
|
|
// - ecs: sys are modules, ecs: char *messaging, ecs: filesystem (e/dir,c/files,s/dll)
|
||
|
|
// - world: streaming, migration
|
||
|
|
|
||
|
|
#include "fwk.h"
|
||
|
|
|
||
|
|
// #include "labs.vm/ecs.c"
|
||
|
|
|
||
|
|
#define EDITOR_VERSION "2022.7"
|
||
|
|
|
||
|
|
#if 1
|
||
|
|
#define EDITOR_PRINTF PRINTF
|
||
|
|
#else
|
||
|
|
#define EDITOR_PRINTF(...) do {} while(0)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// editor controls
|
||
|
|
|
||
|
|
//static int editor_attached = 1;
|
||
|
|
static int editor_enabled = 1;
|
||
|
|
static void* editor_selected_obj = 0;
|
||
|
|
static int editor_key = 0;
|
||
|
|
static vec2 editor_mouse = {0}; // 2d coord for ray/picking
|
||
|
|
static bool editor_gamepad = 1;
|
||
|
|
static int editor_hz = 60;
|
||
|
|
static int editor_hz_mid = 18;
|
||
|
|
static int editor_hz_low = 5;
|
||
|
|
static bool editor_power_saving = 0;
|
||
|
|
static double editor_t = 0, editor_dt = 0;
|
||
|
|
static bool editor_lit = 1;
|
||
|
|
static bool editor_ddraw = 1;
|
||
|
|
|
||
|
|
static
|
||
|
|
void editor_init_variables() {
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor_active() {
|
||
|
|
return ui_hover() || ui_active() || gizmo_active() ? editor_enabled : 0;
|
||
|
|
}
|
||
|
|
double editor_ss() {
|
||
|
|
return 1000 + editor_t;
|
||
|
|
}
|
||
|
|
double editor_delta() {
|
||
|
|
return editor_dt;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
enum editor_keys {
|
||
|
|
key_none,
|
||
|
|
key_pause,
|
||
|
|
key_reload,
|
||
|
|
key_browser,
|
||
|
|
key_recording,
|
||
|
|
key_fullscreen,
|
||
|
|
key_screenshot, // @todo: add meta-info in exif or invisibile pixels (cam details, player details, map level, map location, level state, etc)
|
||
|
|
key_quit,
|
||
|
|
key_mute,
|
||
|
|
key_battery,
|
||
|
|
key_profiler,
|
||
|
|
key_stop,
|
||
|
|
key_outliner,
|
||
|
|
key_undo,
|
||
|
|
key_redo,
|
||
|
|
key_save_mem,
|
||
|
|
key_save_disk,
|
||
|
|
key_load_disk,
|
||
|
|
key_reset,
|
||
|
|
key_debugger,
|
||
|
|
key_gamepad,
|
||
|
|
key_lit,
|
||
|
|
key_ddraw,
|
||
|
|
};
|
||
|
|
|
||
|
|
// editor core
|
||
|
|
|
||
|
|
typedef void* obj_t;
|
||
|
|
typedef array(obj_t) objs_t;
|
||
|
|
|
||
|
|
typedef struct property { // meta: "vec3 namespace.position = {1,2,3}; // minv=(0,0,0) key1=value1 key2=value2 [...] @this is a tooltip @@this is a comment"
|
||
|
|
char *mark; // namespace
|
||
|
|
char *name; // display name
|
||
|
|
char *type; // pointed type
|
||
|
|
char *hint; // name@tooltip
|
||
|
|
char *minv; // min value
|
||
|
|
char *maxv; // max value
|
||
|
|
#if 0 // @todo: implement me
|
||
|
|
char *incv; // inc value
|
||
|
|
char *defv; // default value
|
||
|
|
char *isro; // is read-only/enabled
|
||
|
|
char *issv; // is save pending
|
||
|
|
#endif
|
||
|
|
void *value;
|
||
|
|
unsigned typebits;
|
||
|
|
unsigned flags;
|
||
|
|
} property;
|
||
|
|
|
||
|
|
|
||
|
|
// low-level operations
|
||
|
|
int save1(bool apply, array(char) *buffer, array(property) arrp) {
|
||
|
|
// iterate and save
|
||
|
|
unsigned total = 0;
|
||
|
|
for each_array_ptr(arrp, property, p) {
|
||
|
|
unsigned bytes = 0;
|
||
|
|
/**/ if( p->type[0] == 'f') bytes = sizeof(float);
|
||
|
|
else if( p->type[0] == 'v') bytes = sizeof(vec3);
|
||
|
|
else if( p->type[0] == 'i') bytes = sizeof(int);
|
||
|
|
else if( p->type[0] == 'b') bytes = sizeof(bool);
|
||
|
|
|
||
|
|
if( !apply ) continue;
|
||
|
|
|
||
|
|
if( bytes ) {
|
||
|
|
array_resize(*buffer, array_count(*buffer) + bytes);
|
||
|
|
memcpy( &(*buffer)[array_count(*buffer) - bytes], p->value, bytes);
|
||
|
|
total += bytes;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
EDITOR_PRINTF("%d bytes written\n", total);
|
||
|
|
return total;
|
||
|
|
}
|
||
|
|
int load1(bool apply, const char *buffer, unsigned buflen, array(property) arrp, unsigned skip_bytes) {
|
||
|
|
// iterate and load properties
|
||
|
|
unsigned cursor = 0, loaded = 0, limit = buflen;
|
||
|
|
|
||
|
|
while( cursor <= skip_bytes )
|
||
|
|
for each_array_ptr(arrp, property, p) {
|
||
|
|
unsigned bytes = 0;
|
||
|
|
/**/ if( p->type[0] == 'f') bytes = sizeof(float);
|
||
|
|
else if( p->type[0] == 'v') bytes = sizeof(vec3);
|
||
|
|
else if( p->type[0] == 'i') bytes = sizeof(int);
|
||
|
|
else if( p->type[0] == 'b') bytes = sizeof(bool);
|
||
|
|
|
||
|
|
if( (cursor + bytes) > limit ) {
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if( apply && cursor >= skip_bytes ) {
|
||
|
|
memcpy( p->value, &buffer[cursor], bytes);
|
||
|
|
loaded += bytes;
|
||
|
|
}
|
||
|
|
|
||
|
|
cursor += bytes;
|
||
|
|
}
|
||
|
|
|
||
|
|
EDITOR_PRINTF("%d bytes read, %d bytes loaded\n", cursor, loaded);
|
||
|
|
return cursor;
|
||
|
|
}
|
||
|
|
|
||
|
|
int diff1( array(char) src, array(char) dst, array(char) *patch ) { // @testme
|
||
|
|
int slen = array_count(src);
|
||
|
|
int dlen = array_count(dst);
|
||
|
|
if( dlen != slen ) return -1;
|
||
|
|
|
||
|
|
for( int i = 0; i < slen; ++i ) {
|
||
|
|
int diff = dst[i] - src[i];
|
||
|
|
array_push(*patch, (char)diff);
|
||
|
|
}
|
||
|
|
|
||
|
|
EDITOR_PRINTF("%d bytes diff\n", slen);
|
||
|
|
return slen;
|
||
|
|
}
|
||
|
|
|
||
|
|
int patch1( array(char) src, array(char) dst, array(char) patch ) { // @testme
|
||
|
|
int slen = array_count(src);
|
||
|
|
int dlen = array_count(dst);
|
||
|
|
if( dlen != slen ) return -1;
|
||
|
|
|
||
|
|
int plen = array_count(patch);
|
||
|
|
if( plen != dlen ) return -1;
|
||
|
|
|
||
|
|
for( int i = 0; i < plen; ++i ) {
|
||
|
|
dst[i] += patch[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
EDITOR_PRINTF("%d bytes patched\n", plen);
|
||
|
|
return plen;
|
||
|
|
}
|
||
|
|
|
||
|
|
// syntax sugars for collections/containers
|
||
|
|
// #define bulk_load(obj_min,obj_max,objs,...) for( unsigned i = 0; i < array_count(objs); ++i ) { bool apply = obj_min >= i && i < obj_max; load1(apply, objs[i], __VA_ARGS__); }
|
||
|
|
// #define bulk_save(obj_min,obj_max,objs,...) for( unsigned i = 0; i < array_count(objs); ++i ) { bool apply = obj_min >= i && i < obj_max; save1(apply, objs[i], __VA_ARGS__); }
|
||
|
|
|
||
|
|
|
||
|
|
// state - retained mode
|
||
|
|
|
||
|
|
typedef struct editor_state_t {
|
||
|
|
array(property) properties;
|
||
|
|
array(char) buffer;
|
||
|
|
array(vec2i) history;
|
||
|
|
unsigned cursor;
|
||
|
|
} editor_state_t;
|
||
|
|
|
||
|
|
typedef map(char*, char*) editor_dict_t;
|
||
|
|
|
||
|
|
typedef struct editor_call_t {
|
||
|
|
void* (*call)();
|
||
|
|
unsigned bound;
|
||
|
|
void *vargs[4];
|
||
|
|
} editor_call_t;
|
||
|
|
|
||
|
|
typedef struct editor_module_t {
|
||
|
|
enum {
|
||
|
|
fn_init,
|
||
|
|
fn_load,
|
||
|
|
fn_tick,
|
||
|
|
fn_draw,
|
||
|
|
fn_aabb, // hitboxes
|
||
|
|
fn_debug, // call for debug ui (like loggers and sliders)
|
||
|
|
fn_save,
|
||
|
|
fn_quit,
|
||
|
|
|
||
|
|
fn_num_,
|
||
|
|
} dummy;
|
||
|
|
|
||
|
|
editor_call_t methods[fn_num_];
|
||
|
|
|
||
|
|
} editor_module_t;
|
||
|
|
|
||
|
|
static map(void*, editor_state_t) editor_state; // world
|
||
|
|
static map(void*, array(void*)) editor_children; // groups for stacking, bvh and visibility
|
||
|
|
static map(void*, array(void*)) editor_children_tick; // groups for ticking
|
||
|
|
static map(void*, array(void*)) editor_children_draw; // groups for drawing
|
||
|
|
static map(void*, editor_module_t) editor_module;
|
||
|
|
static map(void*, editor_dict_t) editor_dicts;
|
||
|
|
static set(void*) editor_world;
|
||
|
|
static set(void*) editor_selection; // objects selected in scene
|
||
|
|
|
||
|
|
void editor_init_states() {
|
||
|
|
do_once map_init_ptr(editor_state);
|
||
|
|
do_once map_init_ptr(editor_module);
|
||
|
|
do_once map_init_ptr(editor_children);
|
||
|
|
do_once map_init_ptr(editor_children_tick);
|
||
|
|
do_once map_init_ptr(editor_children_draw);
|
||
|
|
do_once map_init_ptr(editor_dicts);
|
||
|
|
do_once set_init_ptr(editor_world);
|
||
|
|
do_once set_init_ptr(editor_selection);
|
||
|
|
}
|
||
|
|
|
||
|
|
// handle selection
|
||
|
|
|
||
|
|
void editor_select(void *obj, bool multi) {
|
||
|
|
do_once editor_init_states();
|
||
|
|
|
||
|
|
editor_selected_obj = NULL;
|
||
|
|
|
||
|
|
if(!multi) {
|
||
|
|
set_clear(editor_selection);
|
||
|
|
if( obj ) set_find_or_add(editor_selection, editor_selected_obj = obj);
|
||
|
|
} else {
|
||
|
|
if( !obj ) return;
|
||
|
|
bool on = !!set_find(editor_selection, obj);
|
||
|
|
if(on) set_erase(editor_selection, obj);
|
||
|
|
else set_find_or_add(editor_selection, editor_selected_obj = obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
bool editor_is_selected(void *obj) {
|
||
|
|
do_once editor_init_states();
|
||
|
|
|
||
|
|
return !!set_find(editor_selection, obj);
|
||
|
|
}
|
||
|
|
void editor_select_none(void) {
|
||
|
|
editor_select(NULL, false);
|
||
|
|
}
|
||
|
|
void editor_select_all(void) {
|
||
|
|
editor_select_none();
|
||
|
|
for each_set_ptr(editor_world, void*, o) {
|
||
|
|
void *obj = *o;
|
||
|
|
editor_select(obj, true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// obj/scene: load/save, undo/redo,
|
||
|
|
|
||
|
|
bool editor_clear_redo(void *obj) {
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, obj, (editor_state_t){0});
|
||
|
|
|
||
|
|
if( ed->cursor >= array_count(ed->history) )
|
||
|
|
return false;
|
||
|
|
|
||
|
|
array_resize(ed->buffer, ed->history[ed->cursor].to);
|
||
|
|
array_resize(ed->history, ed->cursor + 1);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor_save_disk(const void *obj, const char *outfile) {
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, (void*)obj, (editor_state_t){0});
|
||
|
|
|
||
|
|
static __thread array(char) buffer = 0;
|
||
|
|
array_resize(buffer, 0); // <-- reused as an optimization
|
||
|
|
|
||
|
|
bool ok = 0;
|
||
|
|
if( save1(true, &buffer, ed->properties) > 0 ) {
|
||
|
|
ok = file_write(outfile, buffer, array_count(buffer));
|
||
|
|
}
|
||
|
|
|
||
|
|
ui_notify("Save", ok ? "OK" : ICON_MD_WARNING " Failed!");
|
||
|
|
return ok;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor_load_disk(void *obj, const char *infile) {
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, obj, (editor_state_t){0});
|
||
|
|
|
||
|
|
int buflen;
|
||
|
|
char *buffer = file_load(infile, &buflen);
|
||
|
|
if( buffer && buflen ) {
|
||
|
|
if( load1(true, buffer, buflen, ed->properties, 0) > 0 ) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor_save_mem(void *obj) {
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, obj, (editor_state_t){0});
|
||
|
|
|
||
|
|
static array(char) buffer = 0;
|
||
|
|
array_resize(buffer, 0);
|
||
|
|
|
||
|
|
// save
|
||
|
|
int bytes = save1(true, &buffer, ed->properties);
|
||
|
|
if( bytes <= 0 ) return false;
|
||
|
|
|
||
|
|
// discard save if same size + same content (ie, no changes between this save and previous one)
|
||
|
|
if( array_count(ed->history) > 1 ) {
|
||
|
|
vec2i before = *array_back(ed->history);
|
||
|
|
if( bytes == (before.to - before.from) ) {
|
||
|
|
if( !memcmp(buffer, ed->buffer + array_count(ed->buffer) - bytes, bytes ) ) {
|
||
|
|
return false; // puts("discarding save...");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
// discard redo
|
||
|
|
if( ed->cursor < array_count(ed->history) ) {
|
||
|
|
array_resize(ed->buffer, ed->history[ed->cursor].to);
|
||
|
|
array_resize(ed->history, ed->cursor + 1);
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
editor_clear_redo(obj);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// append
|
||
|
|
int checkpoint = array_count(ed->buffer);
|
||
|
|
array_resize(ed->buffer, array_count(ed->buffer) + bytes);
|
||
|
|
memcpy(ed->buffer + checkpoint, buffer, bytes);
|
||
|
|
|
||
|
|
// proceed
|
||
|
|
array_push(ed->history, vec2i(checkpoint, array_count(ed->buffer)));
|
||
|
|
|
||
|
|
// move cursor to latest
|
||
|
|
ed->cursor = array_count(ed->history) - 1;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor_load_mem(void *obj) {
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, obj, (editor_state_t){0});
|
||
|
|
|
||
|
|
// load latest & update history
|
||
|
|
int slots = array_count(ed->history);
|
||
|
|
if( slots )
|
||
|
|
if( load1(true, ed->buffer, array_count(ed->buffer), ed->properties, ed->history[slots - 1].from) > 0 )
|
||
|
|
return ed->cursor = slots - 1, true;
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor_reset(void *obj) { // load first checkpoint
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, obj, (editor_state_t){0});
|
||
|
|
|
||
|
|
// load first slot
|
||
|
|
if( load1(true, ed->buffer, array_count(ed->buffer), ed->properties, ed->history[0].from) > 0 ) {
|
||
|
|
// discard redo
|
||
|
|
array_resize(ed->buffer, ed->history[0].to);
|
||
|
|
// update history
|
||
|
|
array_resize(ed->history, 1);
|
||
|
|
// move cursor to latest
|
||
|
|
ed->cursor = array_count(ed->history) - 1;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor_undo(void *obj) {
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, obj, (editor_state_t){0});
|
||
|
|
|
||
|
|
// load previous & rewind history by -1
|
||
|
|
if( ed->cursor > 0 )
|
||
|
|
if( load1(true, ed->buffer, array_count(ed->buffer), ed->properties, ed->history[ed->cursor - 1].from) >= 0 )
|
||
|
|
return ed->cursor -= 1, true;
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor_redo(void *obj) {
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, obj, (editor_state_t){0});
|
||
|
|
|
||
|
|
// load next & forward history by +1
|
||
|
|
if( ed->cursor < (array_count(ed->history)-1) )
|
||
|
|
if( load1(true, ed->buffer, array_count(ed->buffer), ed->properties, ed->history[ed->cursor + 1].from) >= 0 )
|
||
|
|
return ed->cursor += 1, true;
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor_diff(const void *obj1, const void *obj2, array(char) patch) { // @todo
|
||
|
|
// @todo check: if both valid && both same type
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
bool editor_patch(void *obj1, array(char) patch) { // @todo
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// obj/module: persist
|
||
|
|
|
||
|
|
char *editor_obj_intern(void *obj, const char *quark, const char *value) {
|
||
|
|
editor_init_states();
|
||
|
|
|
||
|
|
editor_dict_t *dict = map_find_or_add(editor_dicts, obj, 0);
|
||
|
|
if( *dict == 0 ) map_init_str(*dict);
|
||
|
|
|
||
|
|
char **key = map_find_or_add_allocated_key(*dict, STRDUP(quark), 0);
|
||
|
|
if(*key) FREE(*key);
|
||
|
|
*key = STRDUP(value);
|
||
|
|
|
||
|
|
return *key;
|
||
|
|
}
|
||
|
|
|
||
|
|
char *editor_obj_string(const void *obj, const char *quark) {
|
||
|
|
editor_dict_t *dict = map_find_or_add(editor_dicts, (void*)obj, 0);
|
||
|
|
if( *dict == 0 ) map_init_str(*dict);
|
||
|
|
|
||
|
|
char **key = map_find_or_add_allocated_key(*dict, STRDUP(quark), 0);
|
||
|
|
return *key ? *key : "";
|
||
|
|
}
|
||
|
|
|
||
|
|
// obj/module: hierarchy
|
||
|
|
|
||
|
|
void editor_obj_childof_tick(void *obj, void *parent) {
|
||
|
|
array(void*) *found = map_find(editor_children_tick, parent);
|
||
|
|
if(!found) found = map_insert(editor_children_tick, parent, 0);
|
||
|
|
if( obj && obj != parent ) { // dont recurse
|
||
|
|
for( int i = 0; i < array_count(*found); ++i ) {
|
||
|
|
if( (*found)[i] == obj ) return; // child was already added
|
||
|
|
}
|
||
|
|
array_push(*found, obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void editor_obj_childof_draw(void *obj, void *parent) {
|
||
|
|
array(void*) *found = map_find(editor_children_draw, parent);
|
||
|
|
if(!found) found = map_insert(editor_children_draw, parent, 0);
|
||
|
|
if( obj && obj != parent ) { // dont recurse
|
||
|
|
for( int i = 0; i < array_count(*found); ++i ) {
|
||
|
|
if( (*found)[i] == obj ) return; // child was already added
|
||
|
|
}
|
||
|
|
array_push(*found, obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void editor_obj_childof(void *obj, void *parent) {
|
||
|
|
array(void*) *found = map_find(editor_children, parent);
|
||
|
|
if(!found) found = map_insert(editor_children, parent, 0);
|
||
|
|
if( obj && obj != parent ) { // dont recurse
|
||
|
|
for( int i = 0; i < array_count(*found); ++i ) {
|
||
|
|
if( (*found)[i] == obj ) return; // child was already added
|
||
|
|
}
|
||
|
|
array_push(*found, obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// obj/module: methods
|
||
|
|
|
||
|
|
typedef void* (*generic_method)();
|
||
|
|
|
||
|
|
void editor_obj_bind0(const void *obj, unsigned method, generic_method func ) {
|
||
|
|
do_once editor_init_states();
|
||
|
|
editor_call_t *m = &(map_find_or_add(editor_module, (void*)obj, (editor_module_t){0})->methods[method]);
|
||
|
|
m->call = func;
|
||
|
|
m->bound = 0;
|
||
|
|
|
||
|
|
set_find_or_add(editor_world, (void*)obj);
|
||
|
|
}
|
||
|
|
void editor_obj_bind1(const void *obj, unsigned method, generic_method func, void *arg1 ) {
|
||
|
|
do_once editor_init_states();
|
||
|
|
editor_call_t *m = &(map_find_or_add(editor_module, (void*)obj, (editor_module_t){0})->methods[method]);
|
||
|
|
m->call = func;
|
||
|
|
m->vargs[0] = arg1;
|
||
|
|
m->bound = 1;
|
||
|
|
|
||
|
|
set_find_or_add(editor_world, (void*)obj);
|
||
|
|
}
|
||
|
|
void editor_obj_bind2(const void *obj, unsigned method, generic_method func, void *arg1, void *arg2 ) {
|
||
|
|
do_once editor_init_states();
|
||
|
|
editor_call_t *m = &(map_find_or_add(editor_module, (void*)obj, (editor_module_t){0})->methods[method]);
|
||
|
|
m->call = func;
|
||
|
|
m->vargs[0] = arg1;
|
||
|
|
m->vargs[1] = arg2;
|
||
|
|
m->bound = 2;
|
||
|
|
|
||
|
|
set_find_or_add(editor_world, (void*)obj);
|
||
|
|
}
|
||
|
|
void editor_obj_bind3(const void *obj, unsigned method, generic_method func, void *arg1, void *arg2, void *arg3 ) {
|
||
|
|
do_once editor_init_states();
|
||
|
|
editor_call_t *m = &(map_find_or_add(editor_module, (void*)obj, (editor_module_t){0})->methods[method]);
|
||
|
|
m->call = func;
|
||
|
|
m->vargs[0] = arg1;
|
||
|
|
m->vargs[1] = arg2;
|
||
|
|
m->vargs[2] = arg3;
|
||
|
|
m->bound = 3;
|
||
|
|
|
||
|
|
set_find_or_add(editor_world, (void*)obj);
|
||
|
|
}
|
||
|
|
void editor_obj_bind4(const void *obj, unsigned method, generic_method func, void *arg1, void *arg2, void *arg3, void *arg4 ) {
|
||
|
|
do_once editor_init_states();
|
||
|
|
editor_call_t *m = &(map_find_or_add(editor_module, (void*)obj, (editor_module_t){0})->methods[method]);
|
||
|
|
m->call = func;
|
||
|
|
m->vargs[0] = arg1;
|
||
|
|
m->vargs[1] = arg2;
|
||
|
|
m->vargs[2] = arg3;
|
||
|
|
m->vargs[3] = arg4;
|
||
|
|
m->bound = 4;
|
||
|
|
|
||
|
|
set_find_or_add(editor_world, (void*)obj);
|
||
|
|
}
|
||
|
|
void *editor_obj_call0(const void *obj, unsigned method ) {
|
||
|
|
editor_call_t *m = &(map_find_or_add(editor_module, (void*)obj, (editor_module_t){0})->methods[method]);
|
||
|
|
if( !m->call ) return 0;
|
||
|
|
if( m->bound == 1 ) return (m->call)(obj, m->vargs[0]);
|
||
|
|
if( m->bound == 2 ) return (m->call)(obj, m->vargs[0], m->vargs[1]);
|
||
|
|
if( m->bound == 3 ) return (m->call)(obj, m->vargs[0], m->vargs[1], m->vargs[2]);
|
||
|
|
if( m->bound == 4 ) return (m->call)(obj, m->vargs[0], m->vargs[1], m->vargs[2], m->vargs[3]);
|
||
|
|
return (m->call)(obj);
|
||
|
|
}
|
||
|
|
void *editor_obj_call1(const void *obj, unsigned method, void *arg1 ) {
|
||
|
|
editor_call_t *m = &(map_find_or_add(editor_module, (void*)obj, (editor_module_t){0})->methods[method]);
|
||
|
|
return m->call ? m->call(obj, arg1) : 0;
|
||
|
|
}
|
||
|
|
void *editor_obj_call2(const void *obj, unsigned method, void *arg1, void *arg2 ) {
|
||
|
|
editor_call_t *m = &(map_find_or_add(editor_module, (void*)obj, (editor_module_t){0})->methods[method]);
|
||
|
|
return m->call ? m->call(obj, arg1, arg2) : 0;
|
||
|
|
}
|
||
|
|
void *editor_obj_call3(const void *obj, unsigned method, void *arg1, void *arg2, void *arg3 ) {
|
||
|
|
editor_call_t *m = &(map_find_or_add(editor_module, (void*)obj, (editor_module_t){0})->methods[method]);
|
||
|
|
return m->call ? m->call(obj, arg1, arg2, arg3) : 0;
|
||
|
|
}
|
||
|
|
void *editor_obj_call4(const void *obj, unsigned method, void *arg1, void *arg2, void *arg3, void *arg4 ) {
|
||
|
|
editor_call_t *m = &(map_find_or_add(editor_module, (void*)obj, (editor_module_t){0})->methods[method]);
|
||
|
|
return m->call ? m->call(obj, arg1, arg2, arg3, arg4) : 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// obj/module: ui/property
|
||
|
|
|
||
|
|
void editor_obj_property(void *obj, void *value, const char *metas) {
|
||
|
|
do_once editor_init_states();
|
||
|
|
|
||
|
|
ASSERT( obj );
|
||
|
|
ASSERT( value );
|
||
|
|
ASSERT( metas );
|
||
|
|
char *meta = va("%s", metas);
|
||
|
|
|
||
|
|
struct property p = {0};
|
||
|
|
|
||
|
|
// parse tooltip, if present
|
||
|
|
for( char *tooltip = strstr(meta, " @"); tooltip; *tooltip = 0, tooltip = 0) {
|
||
|
|
p.hint = STRDUP(tooltip + 2);
|
||
|
|
}
|
||
|
|
|
||
|
|
// parse metas, if present
|
||
|
|
for( char *metas = strstr(meta, "//"); metas; *metas = 0, metas = 0) {
|
||
|
|
for each_substring(metas + 2, " ", token) {
|
||
|
|
/**/ if(strbegi(token, "hint=")) token = token + 5 + strspn(token + 5, " "), p.hint = STRDUP(token);
|
||
|
|
else if(strbegi(token, "minv=")) token = token + 5 + strspn(token + 5, " "), p.minv = STRDUP(token);
|
||
|
|
else if(strbegi(token, "maxv=")) token = token + 5 + strspn(token + 5, " "), p.maxv = STRDUP(token);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// parse declaration
|
||
|
|
unsigned field = ~0u;
|
||
|
|
for each_substring(meta, "={,}(); ", token) {
|
||
|
|
// next field
|
||
|
|
++field;
|
||
|
|
// parse fields
|
||
|
|
/**/ if(field == 0) p.type = STRDUP(token);
|
||
|
|
else if(field == 1) { // either name or namespace.name
|
||
|
|
p.name = strchr(token, '.');
|
||
|
|
if( !p.name ) p.name = STRDUP(token);
|
||
|
|
else p.name = STRDUP(p.name + 1), p.mark = STRDUP(token), *strchr(p.mark, '.') = '\0';
|
||
|
|
}
|
||
|
|
else {} // any initialization values here
|
||
|
|
}
|
||
|
|
|
||
|
|
// required fields
|
||
|
|
ASSERT(p.name);
|
||
|
|
ASSERT(p.type);
|
||
|
|
|
||
|
|
// combine name+hint together
|
||
|
|
if( p.hint ) {
|
||
|
|
char *combined = va("%s@%s", p.name, p.hint);
|
||
|
|
FREE(p.hint), p.hint = 0;
|
||
|
|
strcatf(&p.hint, "%s", combined);
|
||
|
|
} else {
|
||
|
|
p.hint = p.name;
|
||
|
|
}
|
||
|
|
|
||
|
|
// defaults
|
||
|
|
p.value = value;
|
||
|
|
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, obj, (editor_state_t){0});
|
||
|
|
array_push( ed->properties, p );
|
||
|
|
}
|
||
|
|
|
||
|
|
void* editor_obj_get_property_by_index(const void *obj, unsigned property_no) {
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, (void*)obj, (editor_state_t){0});
|
||
|
|
return property_no < array_count(ed->properties) ? ed->properties[property_no].value : 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void* editor_obj_get_property_by_name(const void *obj, const char *property_name) {
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, (void*)obj, (editor_state_t){0});
|
||
|
|
for each_array(ed->properties, struct property, p) {
|
||
|
|
if( !strmatchi(p.name, property_name) ) continue;
|
||
|
|
return p.value;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor_obj_render_min_properties(const void *obj, const char *mask) {
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, (void*)obj, (editor_state_t){0});
|
||
|
|
|
||
|
|
if(!mask) return false;
|
||
|
|
|
||
|
|
const char *section = 0;
|
||
|
|
for each_array(ed->properties, struct property, p) {
|
||
|
|
if( p.mark ) {
|
||
|
|
if( section == 0 || strcmp(section, p.mark) ) {
|
||
|
|
if( section != 0 ) ui_separator();
|
||
|
|
section = p.mark;
|
||
|
|
ui_label(va("*%s", section)); // '*' adds bold style in labels
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if( !strmatchi(p.name, mask) ) continue;
|
||
|
|
|
||
|
|
/**/ if( p.type[0] == 'l') ui_label(p.hint);
|
||
|
|
else if( p.type[0] == 'f') ui_float(p.hint, p.value);
|
||
|
|
else if( p.type[0] == 'v') ui_float3(p.hint, p.value);
|
||
|
|
else if( p.type[0] == 'i') ui_int(p.hint, p.value);
|
||
|
|
else if( p.type[0] == 'b') ui_bool(p.hint, p.value);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void editor_obj_render_max_properties(void *obj, const char *mask) { // headless, needs layout (window/panel)
|
||
|
|
const char *toolbar_text = va(
|
||
|
|
ICON_MD_LOOP ";" ICON_MD_SD_CARD ";" ICON_MD_UNDO ";" ICON_MD_REDO ";Save;Load;%s",
|
||
|
|
va(ICON_MD_BUG_REPORT "@Raise breakpoint (%sebugger detected).", has_debugger() ? "D":"No d")); // ICON_MD_FRONT_HAND
|
||
|
|
|
||
|
|
int button = ui_toolbar(toolbar_text);
|
||
|
|
if( button ) {
|
||
|
|
if( button == 1 ) editor_key = key_load_disk; // key_reset;
|
||
|
|
if( button == 2 ) editor_key = key_save_disk;
|
||
|
|
if( button == 3 ) editor_key = key_undo;
|
||
|
|
if( button == 4 ) editor_key = key_redo;
|
||
|
|
if( button == 5 ) editor_key = key_save_disk;
|
||
|
|
if( button == 6 ) editor_key = key_load_disk;
|
||
|
|
if( button == 7 ) editor_key = key_debugger;
|
||
|
|
}
|
||
|
|
|
||
|
|
ui_separator();
|
||
|
|
|
||
|
|
editor_obj_render_min_properties(obj, mask);
|
||
|
|
|
||
|
|
ui_separator();
|
||
|
|
ui_label("*Debug");
|
||
|
|
|
||
|
|
editor_state_t *ed = map_find_or_add(editor_state, obj, (editor_state_t){0});
|
||
|
|
|
||
|
|
static char *s = 0; if(s) *s = 0;
|
||
|
|
for( int i = 0; i < array_count(ed->history); ++i ) strcatf(&s, ",%s%d..%d", ed->cursor == i ? "->":"", (int)ed->history[i].from, (int)ed->history[i].to);
|
||
|
|
if(s) ui_label(va("Object Savepoints: %s", s+1));
|
||
|
|
|
||
|
|
ui_buffer("Object console", va("%s","(empty)"), 7+1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// main editor interface
|
||
|
|
|
||
|
|
void editor_render_menubar() {
|
||
|
|
int alts = input(KEY_LALT) || input(KEY_RALT); // @todo: move to fwk.c
|
||
|
|
int ctrls = input(KEY_LCTRL) || input(KEY_RCTRL); // @todo: move to fwk.c
|
||
|
|
int shifts = input(KEY_LSHIFT) || input(KEY_RSHIFT); // @todo: move to fwk.c
|
||
|
|
int mods = alts || ctrls || shifts; // @todo: move to fwk.c
|
||
|
|
if( input_down(KEY_F5) ) editor_key = key_reload;
|
||
|
|
if( input_down(KEY_F11) ) editor_key = key_fullscreen;
|
||
|
|
if( input_down(KEY_PAUSE) ) editor_key = key_pause;
|
||
|
|
if( input_down(KEY_PRINT) ) editor_key = (mods ? key_recording : key_screenshot);
|
||
|
|
// if( input_down(KEY_W) && input_held(KEY_LCTRL) ) editor_key = key_quit;
|
||
|
|
|
||
|
|
if( ctrls ) {
|
||
|
|
/**/ if( input_down(KEY_Z) ) editor_key = key_undo;
|
||
|
|
else if( input_down(KEY_Y) ) editor_key = key_redo;
|
||
|
|
else if( input_down(KEY_S) ) editor_key = key_save_disk;
|
||
|
|
else if( input_down(KEY_A) ) editor_select_all();
|
||
|
|
else if( input_down(KEY_D) ) editor_select_none();
|
||
|
|
}
|
||
|
|
|
||
|
|
if( !editor_key /*&& !input_anykey()*/ && editor_selected_obj ) {
|
||
|
|
if( input_up(MOUSE_L) ) editor_key = key_save_mem;
|
||
|
|
if( input_down(MOUSE_R) ) ui_show("Properties", true);
|
||
|
|
#if 0
|
||
|
|
{
|
||
|
|
vec2 dims = { 200, 400 };
|
||
|
|
if( nk_tooltip_begin(ui_ctx, dims.w)) {
|
||
|
|
nk_layout_row_dynamic(ui_ctx, dims.h, 1);
|
||
|
|
editor_obj_render_min_properties(editor_selected_obj);
|
||
|
|
nk_tooltip_end(ui_ctx);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
// @fixme: send all editor keys to game?
|
||
|
|
// if( input_repeat(KEY_ESC, 300)) {}
|
||
|
|
// if( input_repeat(KEY_F1, 300)) {}
|
||
|
|
// etc...
|
||
|
|
|
||
|
|
// menubar
|
||
|
|
|
||
|
|
if( ui_menu( ICON_MD_SETTINGS "@Preferences;"
|
||
|
|
ICON_MD_G_TRANSLATE " Language;"
|
||
|
|
ICON_MD_FACE " Profile;" // editor account, but also fake profile and 1st party credentials
|
||
|
|
ICON_MD_MESSAGE " Social;"
|
||
|
|
ICON_MD_ROCKET_LAUNCH " Game;" //
|
||
|
|
ICON_MD_KEYBOARD " Keyboard;"
|
||
|
|
ICON_MD_MOUSE " Mouse;"
|
||
|
|
ICON_MD_GAMEPAD " Gamepad;"
|
||
|
|
ICON_MD_MONITOR " Display;" // @todo: RENDER settings, AUDIO settings
|
||
|
|
ICON_MD_WIFI " Network;"
|
||
|
|
ICON_MD_SAVINGS " Budget;" // mem,gfx,net,hdd,... also logging
|
||
|
|
ICON_MD_CREATE_NEW_FOLDER " Folders;" // including project folders
|
||
|
|
ICON_MD_EXTENSION " Plugins;" // including VCS
|
||
|
|
ICON_MD_REPLAY " Restart;"
|
||
|
|
ICON_MD_CLOSE " Quit;"
|
||
|
|
"-" ICON_MD_RECYCLING " Reset all preferences;" ICON_MD_SAVE_AS " Save all preferences"
|
||
|
|
) ) {
|
||
|
|
if( ui_item() == 3 ) {} // key mappings
|
||
|
|
if( ui_item() == 4 ) {} // sensitivity, invert xylrw
|
||
|
|
if( ui_item() == 5 ) {} // sensitivity, invert xy,ab, deadzones
|
||
|
|
if( ui_item() == 7 ) {} // name,email,icon,link,github
|
||
|
|
if( ui_item() == 13) editor_key = key_reload;
|
||
|
|
if( ui_item() == 14) editor_key = key_quit;
|
||
|
|
}
|
||
|
|
|
||
|
|
if( ui_menu( window_has_pause() ? ICON_MD_PLAY_ARROW "@Tap to Play Game" : ICON_MD_PAUSE "@Tap to Pause Game" )) editor_key = key_pause;
|
||
|
|
if( ui_menu( ICON_MD_STOP "@Stop game" )) editor_key = key_stop;
|
||
|
|
if( ui_menu( ICON_MD_CLOSE "@Close game" ) ) {}
|
||
|
|
static char game_args[16] = "--game-args"; // @fixme @todo remove '_' special char to signal that ui_menu() is writeable (inputbox)
|
||
|
|
if( ui_menu_editbox( game_args, 16 ) ) {}
|
||
|
|
|
||
|
|
// ICON_MD_TROUBLESHOOT -> PROFILER
|
||
|
|
// ICON_MD_SCHEMA -> GRAPHNODES
|
||
|
|
// ICON_MD_ACCOUNT_TREE -> GRAPHNODES
|
||
|
|
// ICON_MD_TIPS_AND_UPDATES -> BULB
|
||
|
|
// if( ui_menu( ICON_MD_MENU )) {}
|
||
|
|
|
||
|
|
if( ui_menu( ICON_MD_FOLDER_SPECIAL "@Content browser" )) editor_key = key_browser;
|
||
|
|
if( ui_menu( va(ICON_MD_VIEW_IN_AR " %d/%d@World outliner", set_count(editor_selection), map_count(editor_state) ))) editor_key = key_outliner;
|
||
|
|
|
||
|
|
if( ui_menu( va(ICON_MD_BUILD "@Build game"))) ui_notify("Build", ICON_MD_WARNING " Not implemented.");
|
||
|
|
|
||
|
|
if( ui_menu( ICON_MD_PHOTO_CAMERA "@Take Screenshot" )) editor_key = key_screenshot; // MD_SCREENSHOT_MONITOR
|
||
|
|
if( ui_menu( record_active() ? ICON_MD_VIDEOCAM_OFF "@Stop video recording" : ICON_MD_VIDEOCAM "@Start video recording" )) { if(record_active()) record_stop(); else editor_key = key_recording; }
|
||
|
|
if( ui_menu( editor_gamepad ? ICON_MD_VIDEOGAME_ASSET "@Gamepad is enabled. Tap to disable." : ICON_MD_VIDEOGAME_ASSET_OFF "@Gamepad is disabled. Tap to enable." )) editor_key = key_gamepad;
|
||
|
|
if( ui_menu( audio_volume_master(-1) > 0 ? ICON_MD_VOLUME_UP "@Audio is enabled. Tap to mute." : ICON_MD_VOLUME_OFF "@Audio is muted. Tap to enable." )) editor_key = key_mute;
|
||
|
|
if( ui_menu( window_has_fullscreen() ? ICON_MD_FULLSCREEN_EXIT "@Fullscreen. Tap to go Windowed." : ICON_MD_FULLSCREEN "@Windowed. Tap to go Fullscreen." )) editor_key = key_fullscreen;
|
||
|
|
|
||
|
|
if( ui_menu( editor_ddraw ? ICON_MD_IMAGE_SEARCH "@Debug renderer. Tap to go Retail Renderer." : ICON_MD_INSERT_PHOTO "@Retail renderer. Tap to go Debug Renderer." )) editor_key = key_ddraw; // ICON_MD_ADD_PHOTO_ALTERNATE
|
||
|
|
if( ui_menu( editor_lit ? ICON_MD_LIGHTBULB "@Lit. Tap to disable lighting." : ICON_MD_LIGHTBULB_OUTLINE "@Unlit. Tap to enable lighting." )) editor_key = key_lit;
|
||
|
|
|
||
|
|
// logic: either plug icon (power saving off) or one of the following ones (power saving on):
|
||
|
|
// if 0% batt (no batt): battery alert
|
||
|
|
// if discharging: battery levels [alert,0..6,full]
|
||
|
|
// if charging: battery charging
|
||
|
|
int battery_read = app_battery();
|
||
|
|
int battery_level = abs(battery_read);
|
||
|
|
int battery_discharging = battery_read < 0 && battery_level < 100;
|
||
|
|
const char *battery_levels[9] = { // @todo: remap [7%..100%] -> [0..1] ?
|
||
|
|
ICON_MD_BATTERY_ALERT,
|
||
|
|
ICON_MD_BATTERY_0_BAR,ICON_MD_BATTERY_1_BAR,
|
||
|
|
ICON_MD_BATTERY_2_BAR,ICON_MD_BATTERY_3_BAR,
|
||
|
|
ICON_MD_BATTERY_4_BAR,ICON_MD_BATTERY_5_BAR,
|
||
|
|
ICON_MD_BATTERY_6_BAR,ICON_MD_BATTERY_FULL,
|
||
|
|
};
|
||
|
|
if( ui_menu( !editor_power_saving ? ICON_MD_POWER"@Full power. Tap to save power." :
|
||
|
|
va("%s@Power saving. Tap to go full power. %3d%% battery.",
|
||
|
|
battery_read == 0 ? ICON_MD_BATTERY_ALERT :
|
||
|
|
battery_discharging ? battery_levels[(int)((9-1)*clampf(battery_level/100.f,0,1))] :
|
||
|
|
ICON_MD_BATTERY_CHARGING_FULL, battery_level) ))
|
||
|
|
editor_key = key_battery;
|
||
|
|
|
||
|
|
// @todo: combine-in-1? cycle mem -> cpu/profiler -> network mon -> debugger
|
||
|
|
if( ui_menu(va(ICON_MD_SIGNAL_CELLULAR_ALT " 0/0KiB" ))) {} // SIGNAL_CELLULAR_1_BAR SIGNAL_CELLULAR_2_BAR
|
||
|
|
if( ui_menu(va(ICON_MD_STORAGE " %s", xstats() ))) {} // 012/136MB
|
||
|
|
if( ui_menu(va(ICON_MD_SPEED " %5.2f/%d", window_fps(), (int)window_fps_target()))) editor_key = key_profiler; // 012/136MB
|
||
|
|
|
||
|
|
// @todo: alarm/snooze, chrono, time (calendar?)
|
||
|
|
{
|
||
|
|
static double base = 0, tap = 0, delta = 0, enabled = 0;
|
||
|
|
double timer = base + delta;
|
||
|
|
if( ui_menu( !enabled ?
|
||
|
|
va(ICON_MD_TODAY "%02d:%02d@Tap to start chrono.", (int)((date() / 10000) % 100), (int)((date() / 100) % 100))
|
||
|
|
:
|
||
|
|
va(ICON_MD_TIMELAPSE "%02dh:%02dm:%02ds:%02df@Tap to reset chrono.",((int)(timer/3600))%24,((int)(timer/60))%60,((int)timer)%60,(int)((timer - (int)timer)*window_fps_target())))) {
|
||
|
|
base = 0, tap = time_ss(), delta = 0;
|
||
|
|
enabled = 1;
|
||
|
|
}
|
||
|
|
if( editor_key == key_stop ) enabled = 0;
|
||
|
|
if( enabled ) {
|
||
|
|
if( !window_has_pause() ) delta = time_ss() - tap;
|
||
|
|
else base += delta, tap = time_ss(), delta = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for each_map_ptr(editor_state, void *, o, editor_state_t, ed) {
|
||
|
|
profile_incstat("Editor.num_objects", +1);
|
||
|
|
|
||
|
|
void *obj = *o;
|
||
|
|
|
||
|
|
// auto-load from disk during init. @fixme kvdb database
|
||
|
|
if( array_count(ed->history) == 0 )
|
||
|
|
if( editor_load_disk(obj, editor_obj_string(obj, ".path")) )
|
||
|
|
{}
|
||
|
|
|
||
|
|
// auto-save in-mem during first edit
|
||
|
|
if( array_count(ed->history) == 0 )
|
||
|
|
editor_save_mem(obj);
|
||
|
|
|
||
|
|
// @todo: continue if obj not found in selection set
|
||
|
|
if( obj != editor_selected_obj )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if( editor_key == key_debugger ) { breakpoint("User requested breakpoint on this object"); }
|
||
|
|
if( editor_key == key_reset ) { const char *ok = editor_reset(obj) ? "ok" : "err"; EDITOR_PRINTF("reset: %s\n", ok); }
|
||
|
|
if( editor_key == key_save_mem ) { const char *ok = editor_save_mem(obj) ? "ok" : "err"; EDITOR_PRINTF("mem saved: %s\n", ok); }
|
||
|
|
if( editor_key == key_undo ) { const char *ok = editor_undo(obj) ? "ok" : "err"; EDITOR_PRINTF("undo: %s\n", ok); }
|
||
|
|
if( editor_key == key_redo ) { const char *ok = editor_redo(obj) ? "ok" : "err"; EDITOR_PRINTF("redo: %s\n", ok); }
|
||
|
|
if( editor_key == key_save_disk ) { const char *ok = editor_save_disk(obj, editor_obj_string(obj, ".path")) ? "ok" : "err"; EDITOR_PRINTF("save: %s\n", ok); }
|
||
|
|
if( editor_key == key_load_disk ) { const char *ok = editor_load_disk(obj, editor_obj_string(obj, ".path")) ? "ok" : "err"; EDITOR_PRINTF("load: %s\n", ok); }
|
||
|
|
}
|
||
|
|
|
||
|
|
char *name;
|
||
|
|
switch( editor_key ) {
|
||
|
|
default:
|
||
|
|
break; case key_quit: record_stop(), exit(0);
|
||
|
|
break; case key_stop: window_pause(1);
|
||
|
|
break; case key_mute: audio_volume_master( 1 ^ !!audio_volume_master(-1) );
|
||
|
|
break; case key_pause: window_pause( window_has_pause() ^ 1 );
|
||
|
|
break; case key_reload: window_reload();
|
||
|
|
break; case key_battery: editor_power_saving ^= 1;
|
||
|
|
break; case key_browser: ui_show("File Browser", ui_visible("File Browser") ^ true);
|
||
|
|
break; case key_outliner: ui_show("Outliner", ui_visible("Outliner") ^ true);
|
||
|
|
break; case key_recording: name = file_counter(va("%s.mp4",app_name())), window_record(name), ui_notify(va("Video capturing: %s", name), date_string());
|
||
|
|
break; case key_screenshot: name = file_counter(va("%s.png",app_name())), window_screenshot(name), ui_notify(va("Screenshot: %s", name), date_string());
|
||
|
|
break; case key_profiler: ui_show("Profiler", profile_enable(ui_visible("Profiler") ^ true));
|
||
|
|
break; case key_fullscreen: record_stop(), window_fullscreen( window_has_fullscreen() ^ 1 ); // framebuffer resizing corrupts video stream, so stop any recording beforehand
|
||
|
|
break; case key_gamepad: editor_gamepad ^= 1;
|
||
|
|
break; case key_lit: editor_lit ^= 1;
|
||
|
|
break; case key_ddraw: editor_ddraw ^= 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int do_context_cmd = 0;
|
||
|
|
void *do_context_obj = 0;
|
||
|
|
|
||
|
|
void editor_obj_render_properties_recursively(void *obj, const char *mask) {
|
||
|
|
array(void*) *found = map_find(editor_children, obj);
|
||
|
|
int num_subobjects = found ? array_count(*found) : 0;
|
||
|
|
|
||
|
|
char *name = editor_obj_string(obj,".name"); name = name[0] ? name : va("%p", obj);
|
||
|
|
char *title = va("%s%s/ (%d)",
|
||
|
|
editor_is_selected(obj) ? ICON_MD_CHECK_BOX : ICON_MD_CHECK_BOX_OUTLINE_BLANK, name, num_subobjects);
|
||
|
|
// if( !strmatchi(title, mask) ) return;
|
||
|
|
char *id = va("LVL%p",obj);
|
||
|
|
|
||
|
|
int clicked_or_toggled, open; // 1|clicked, 2|toggled
|
||
|
|
for( int p = (open = ui_collapse(title, id)), dummy = (clicked_or_toggled = ui_collapse_clicked()); p; ui_collapse_end(), p = 0) {
|
||
|
|
|
||
|
|
// contextual menu (open)
|
||
|
|
if( ui_contextual() ) {
|
||
|
|
if( ui_button_transparent("<Load" ) ) do_context_obj = obj, do_context_cmd = cc4(load);
|
||
|
|
if( ui_button_transparent("<Save" ) ) do_context_obj = obj, do_context_cmd = cc4(save);
|
||
|
|
if( ui_button_transparent("<Merge") ) do_context_obj = obj, do_context_cmd = cc4(merge);
|
||
|
|
if( ui_button_transparent("<Cut" ) ) do_context_obj = obj, do_context_cmd = cc4(cut);
|
||
|
|
if( ui_button_transparent("<Copy" ) ) do_context_obj = obj, do_context_cmd = cc4(copy);
|
||
|
|
if( ui_button_transparent("<Paste") ) do_context_obj = obj, do_context_cmd = cc4(paste);
|
||
|
|
ui_contextual_end();
|
||
|
|
}
|
||
|
|
|
||
|
|
for( int i = 0; i < num_subobjects; ++i ) {
|
||
|
|
editor_obj_render_properties_recursively((*found)[i], mask);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( num_subobjects == 0 ) {
|
||
|
|
// if( (mask[0] == '*' && !mask[1]) || strmatchi(title, mask) )
|
||
|
|
editor_obj_render_min_properties(obj, mask);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// contextual menu (close)
|
||
|
|
if( !open && ui_contextual() ) {
|
||
|
|
if( ui_button_transparent("<Load" ) ) do_context_obj = obj, do_context_cmd = cc4(load);
|
||
|
|
if( ui_button_transparent("<Save" ) ) do_context_obj = obj, do_context_cmd = cc4(save);
|
||
|
|
if( ui_button_transparent("<Merge") ) do_context_obj = obj, do_context_cmd = cc4(merge);
|
||
|
|
if( ui_button_transparent("<Cut" ) ) do_context_obj = obj, do_context_cmd = cc4(cut);
|
||
|
|
if( ui_button_transparent("<Copy" ) ) do_context_obj = obj, do_context_cmd = cc4(copy);
|
||
|
|
if( ui_button_transparent("<Paste") ) do_context_obj = obj, do_context_cmd = cc4(paste);
|
||
|
|
ui_contextual_end();
|
||
|
|
}
|
||
|
|
|
||
|
|
if( clicked_or_toggled & 1 ) {
|
||
|
|
if( input_down(MOUSE_L) && (input(KEY_LCTRL) || input(KEY_RCTRL)) )
|
||
|
|
editor_select(obj, true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
enum {
|
||
|
|
TICK_ENABLED = 1,
|
||
|
|
TICK_DO_UI = 4,
|
||
|
|
|
||
|
|
DRAW_ENABLED = 1,
|
||
|
|
DRAW_DO_UI = 4,
|
||
|
|
};
|
||
|
|
|
||
|
|
void editor_tick_objs_recursively(void *obj, unsigned flags) {
|
||
|
|
array(void*) *found = map_find(editor_children_tick, obj);
|
||
|
|
int num_subobjects = found ? array_count(*found) : 0;
|
||
|
|
|
||
|
|
if( flags & TICK_ENABLED ) editor_obj_call0(obj, fn_tick);
|
||
|
|
|
||
|
|
if( flags & TICK_DO_UI ) {
|
||
|
|
char *name = editor_obj_string(obj,".name"); name = name[0] ? name : va("%p", obj);
|
||
|
|
char *title = va("%s%s/ (%d)", editor_is_selected(obj) ? ICON_MD_CHECK_BOX : ICON_MD_CHECK_BOX_OUTLINE_BLANK, name, num_subobjects);
|
||
|
|
// if( !strmatchi(title, mask) ) return;
|
||
|
|
char *id = va("CPU%p",obj);
|
||
|
|
|
||
|
|
int clicked;
|
||
|
|
for( int p = ui_collapse(title, id), dummy = (clicked = ui_collapse_clicked()); p; ui_collapse_end(), p = 0) {
|
||
|
|
|
||
|
|
int choice = ui_submenu("<A;B;>C");
|
||
|
|
if( choice ) printf("%d\n", choice);
|
||
|
|
|
||
|
|
for( int i = 0; i < num_subobjects; ++i ) {
|
||
|
|
editor_tick_objs_recursively((*found)[i], flags);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for( int i = 0; i < num_subobjects; ++i ) {
|
||
|
|
editor_tick_objs_recursively((*found)[i], flags);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void editor_draw_objs_recursively(void *obj, unsigned flags) {
|
||
|
|
array(void*) *found = map_find(editor_children_draw, obj);
|
||
|
|
int num_subobjects = found ? array_count(*found) : 0;
|
||
|
|
|
||
|
|
if( flags & DRAW_ENABLED ) editor_obj_call0(obj, fn_draw);
|
||
|
|
|
||
|
|
if( flags & DRAW_DO_UI ) {
|
||
|
|
char *name = editor_obj_string(obj,".name"); name = name[0] ? name : va("%p", obj);
|
||
|
|
char *title = va("%s%s/ (%d)", editor_is_selected(obj) ? ICON_MD_CHECK_BOX : ICON_MD_CHECK_BOX_OUTLINE_BLANK, name, num_subobjects);
|
||
|
|
// if( !strmatchi(title, mask) ) return;
|
||
|
|
char *id = va("GPU%p",obj);
|
||
|
|
|
||
|
|
int clicked;
|
||
|
|
for( int p = ui_collapse(title, id), dummy = (clicked = ui_collapse_clicked()); p; ui_collapse_end(), p = 0) {
|
||
|
|
|
||
|
|
int choice = ui_submenu("<A;<B;=C;>D");
|
||
|
|
if( choice ) printf("%d\n", choice);
|
||
|
|
|
||
|
|
for( int i = 0; i < num_subobjects; ++i ) {
|
||
|
|
editor_draw_objs_recursively((*found)[i], flags);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
for( int i = 0; i < num_subobjects; ++i ) {
|
||
|
|
editor_draw_objs_recursively((*found)[i], flags);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void editor_render_windows() {
|
||
|
|
// content browser
|
||
|
|
if( ui_window("File Browser", 0) ) {
|
||
|
|
const char *file = 0;
|
||
|
|
if( ui_browse(&file, NULL) ) {
|
||
|
|
const char *sep = ifdef(win32, "\"", "'");
|
||
|
|
app_exec(va("%s %s%s%s", ifdef(win32, "start \"\"", ifdef(osx, "open", "xdg-open")), sep, file, sep));
|
||
|
|
}
|
||
|
|
ui_window_end();
|
||
|
|
}
|
||
|
|
|
||
|
|
// console/terminal window
|
||
|
|
if( 0 && ui_window("Console", 0) ) {
|
||
|
|
ui_console();
|
||
|
|
ui_window_end();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Scene/nodes
|
||
|
|
if( ui_window("Outliner", 0) ) {
|
||
|
|
// @todo: keys up,down,left,right -> tree nav
|
||
|
|
// @todo: tab -> cycle next node of matching highlighted type
|
||
|
|
|
||
|
|
static int do_filter = 0;
|
||
|
|
|
||
|
|
int choice = ui_toolbar(ICON_MD_SEARCH"@Filter;"ICON_MD_UPLOAD"@Load;"ICON_MD_DOWNLOAD"@Save;"ICON_MD_REFRESH"@Reset;"ICON_MD_UNDO"@Undo;"ICON_MD_REDO"@Redo;");
|
||
|
|
if( choice == 1 ) do_filter ^= 1;
|
||
|
|
|
||
|
|
static char filter[128] = {0};
|
||
|
|
if( do_filter ) {
|
||
|
|
ui_buffer(ICON_MD_SEARCH " Filter", filter, 128);
|
||
|
|
} else {
|
||
|
|
filter[0] = '\0';
|
||
|
|
}
|
||
|
|
char *mask = filter[0] ? va("*%s*", filter) : "*";
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
static unsigned tabs = 0xFF;
|
||
|
|
int choice = ui_toolbar(
|
||
|
|
"LV@Level tree: hierarchical logic datas used when ticking game.;"
|
||
|
|
"RN@Rendering tree: hierarchical rendering datas used when drawing game.;"
|
||
|
|
"VS@Visibility tree: hierarchical visibility datas used when ticking game and editor. Also collisions.;"
|
||
|
|
"ST@Streaming tree: hierarchical streaming datas used when streaming content off disk.;"
|
||
|
|
"PS@Persist tree: hierarchical storage datas within different game sessions.;"
|
||
|
|
"PR@Prefabs tree: hierarchical datas of prefabs definitions.;"
|
||
|
|
"ED@Editor tree: hierarchical datas used when ticking editor.;"
|
||
|
|
);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
for( int c = ui_collapse(ICON_MD_FOLDER_SPECIAL " Art/", "ART"); c; ui_collapse_end(), c = 0) {
|
||
|
|
static const char *file;
|
||
|
|
static bool show_browser = 1;
|
||
|
|
if( ui_browse(&file, &show_browser) ) {
|
||
|
|
app_exec(va("%s %s", ifdef(win32, "start", ifdef(osx, "open", "xdg-open")), file));
|
||
|
|
//puts(file);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
for( int c = ui_collapse(va(ICON_MD_FACTORY " Prefabs/ (%d)", map_count(editor_state)), "PRF"); c; ui_collapse_end(), c = 0)
|
||
|
|
for each_map_ptr(editor_state, void*, o, editor_state_t, ed) {
|
||
|
|
void *k = *o;
|
||
|
|
for( int p = ui_collapse(va("%s",strrchr(editor_obj_string(k,".path"),'/')+1), va("PF#%p",k)); p; ui_collapse_end(), p = 0) {
|
||
|
|
editor_obj_render_min_properties(k, mask);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// dynamic/static bounds: depth + bounds + visibility
|
||
|
|
do_context_cmd = 0;
|
||
|
|
do_context_obj = 0;
|
||
|
|
for( int c = ui_collapse(va(ICON_MD_ACCOUNT_TREE " Levels/ (%d)", map_count(editor_children)), "LVL"); c; ui_collapse_end(), c = 0)
|
||
|
|
for each_map_ptr(editor_children, void*, o, array(void*), objs) {
|
||
|
|
void *k = *o;
|
||
|
|
editor_obj_render_properties_recursively(k, mask);
|
||
|
|
}
|
||
|
|
if( do_context_cmd == cc4(list) && do_context_obj ) {
|
||
|
|
printf("list [%p]\n", do_context_obj);
|
||
|
|
}
|
||
|
|
// draw: depth + state (alpha0=off)
|
||
|
|
// @fixme: make it a tree
|
||
|
|
for( int c = ui_collapse(va(ICON_MD_PALETTE " Rendering/ (%d)", map_count(editor_children_draw)), "GPU"); c; ui_collapse_end(), c = 0)
|
||
|
|
for each_map_ptr(editor_children_draw, void*, o, array(void*), objs) {
|
||
|
|
void *k = *o;
|
||
|
|
editor_draw_objs_recursively(k, DRAW_DO_UI);
|
||
|
|
}
|
||
|
|
// tick: depth + rate (00=off) --> logic
|
||
|
|
// @todo: physics tick group? anim tick group? any other tick group?
|
||
|
|
// @fixme: make it a tree
|
||
|
|
for( int c = ui_collapse(va(ICON_MD_FLAG " Ticking/ (%d)", map_count(editor_children_tick)), "CPU"); c; ui_collapse_end(), c = 0)
|
||
|
|
for each_map_ptr(editor_children_tick, void*, o, array(void*), objs) {
|
||
|
|
void *k = *o;
|
||
|
|
editor_tick_objs_recursively(k, TICK_DO_UI);
|
||
|
|
}
|
||
|
|
// init/quit: depth + prio
|
||
|
|
// @fixme: make it a tree
|
||
|
|
for( int c = ui_collapse(ICON_MD_CLOUD " Streaming/", "BVH"); c; ui_collapse_end(), c = 0) {}
|
||
|
|
// save/load: depth + savetomem?yn + savetodisk?yn + quant + lossy/lossless
|
||
|
|
// @fixme: make it a tree
|
||
|
|
for( int c = ui_collapse(va(ICON_MD_SD_CARD " Storage/ (%d)", map_count(editor_dicts)), "DSK"); c; ui_collapse_end(), c = 0)
|
||
|
|
for each_map_ptr(editor_dicts, void*, o, editor_dict_t, d) {
|
||
|
|
void *k = *o;
|
||
|
|
for( int p = ui_collapse(editor_obj_string(k,".name"), va("DSK%p",k)); p; ui_collapse_end(), p = 0) {
|
||
|
|
for each_map(*d, char*, s, char *, v) {
|
||
|
|
ui_label(va("%s: %s", s, v));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// others
|
||
|
|
for( int c = ui_collapse(ICON_MD_PRECISION_MANUFACTURING " Editors/", "EDT"); c; ui_collapse_end(), c = 0) {
|
||
|
|
// @todo: add settings here as well?
|
||
|
|
}
|
||
|
|
|
||
|
|
for( int c = ui_collapse(ICON_MD_INFO " Help", "NFO"); c; ui_collapse_end(), c = 0) {
|
||
|
|
ui_label("=*General");
|
||
|
|
ui_label2("*ESC", ">Editor on/off");
|
||
|
|
ui_label2("*F11", ">Fullscreen on/off");
|
||
|
|
ui_label2("*F5", ">Refresh");
|
||
|
|
ui_separator();
|
||
|
|
ui_label("=*Edit");
|
||
|
|
ui_label2("*^Z, ^Y", ">Undo, Redo");
|
||
|
|
ui_label2("*^X, ^C, ^V", ">Cut, Copy, Paste");
|
||
|
|
ui_label2("*^S, ^L, ^R", ">Save, Load*, Restart*");
|
||
|
|
ui_separator();
|
||
|
|
ui_label("=*Select");
|
||
|
|
ui_label2("*LMB, ^A, ^D", ">Select, All, None");
|
||
|
|
ui_label2("*RMB", ">Contextual menu*");
|
||
|
|
ui_label2("*SPACE@Cycle transform gizmo: position, rotation, scale.", ">Cycle transform gizmo");
|
||
|
|
ui_separator();
|
||
|
|
ui_label("=*Camera");
|
||
|
|
ui_label2("*Q,E,C", ">Camera elevation");
|
||
|
|
ui_label2("*W,A,S,D", ">Camera move");
|
||
|
|
ui_label2("*LMB/RMB+drag", ">Camera view");
|
||
|
|
ui_label2("*WMB", ">Camera speed");
|
||
|
|
}
|
||
|
|
|
||
|
|
ui_window_end();
|
||
|
|
}
|
||
|
|
|
||
|
|
// UI properties
|
||
|
|
if( ui_window("Properties", NULL) ) {
|
||
|
|
if( editor_selected_obj )
|
||
|
|
editor_obj_render_max_properties(editor_selected_obj, "*");
|
||
|
|
ui_window_end();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Icon browser
|
||
|
|
if( ui_window("Icon Palette", 0 )) {
|
||
|
|
static const char *icons[] = {
|
||
|
|
#define ICON(x) ICON_MD_##x
|
||
|
|
#include "editor"
|
||
|
|
};
|
||
|
|
static const char *titles[] = {
|
||
|
|
#define ICON(x) #x
|
||
|
|
#include "editor"
|
||
|
|
};
|
||
|
|
|
||
|
|
for( int i = 0, cols = 8; i < countof(icons); i += cols ) {
|
||
|
|
char buf[256], *p = buf;
|
||
|
|
for( int j = i, jmax = mini(i+cols, countof(icons)); j < jmax; ++j ) p += sprintf(p, "%s%03d@%s;", icons[j], j, titles[j]);
|
||
|
|
ui_toolbar(buf);
|
||
|
|
}
|
||
|
|
|
||
|
|
ui_window_end();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ray *editor_pickup() {
|
||
|
|
// if(!window_has_cursor()) return NULL;
|
||
|
|
|
||
|
|
// pick entity
|
||
|
|
bool any_active = ui_active() || ui_hover() || gizmo_active() || gizmo_hover() || input_touch_active();
|
||
|
|
if( editor_enabled && !any_active && input_down(MOUSE_L) ) {
|
||
|
|
editor_mouse = vec2(input(MOUSE_X), input(MOUSE_Y));
|
||
|
|
vec3 out = editor_pick(editor_mouse.x, editor_mouse.y); // unprj 2d as 3d coord
|
||
|
|
vec3 from = camera_get_active()->position, to = out;
|
||
|
|
static ray last_ray;
|
||
|
|
last_ray = ray(from, to);
|
||
|
|
return &last_ray;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static
|
||
|
|
void editor_init() {
|
||
|
|
// enable outlines
|
||
|
|
do_once fx_load("editor/art/fx/fxOutline.fs");
|
||
|
|
do_once fx_enable(0, 1);
|
||
|
|
|
||
|
|
// init editor
|
||
|
|
do_once editor_init_states();
|
||
|
|
do_once editor_init_variables();
|
||
|
|
}
|
||
|
|
|
||
|
|
bool editor() {
|
||
|
|
do_once editor_init();
|
||
|
|
|
||
|
|
// timing
|
||
|
|
editor_dt = window_delta() * !window_has_pause(); if(editor_dt > 1/60.f) editor_dt = 1/60.f;
|
||
|
|
editor_t += editor_dt;
|
||
|
|
|
||
|
|
// enabled?
|
||
|
|
if( input_up(KEY_ESC) ) editor_enabled ^= 1; // editor on/off
|
||
|
|
if( !editor_enabled ) return false;
|
||
|
|
|
||
|
|
// rendering + logic
|
||
|
|
editor_key = 0;
|
||
|
|
editor_render_windows();
|
||
|
|
editor_render_menubar(); // must be last
|
||
|
|
|
||
|
|
// adaptive framerate
|
||
|
|
int app_on_background = !window_has_focus();
|
||
|
|
int hz = app_on_background ? editor_hz_low : editor_power_saving ? editor_hz_mid : editor_hz;
|
||
|
|
window_fps_lock( hz < 5 ? 5 : hz );
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void editor_camera_fps(void) {
|
||
|
|
static camera_t cam = {0};
|
||
|
|
cam = *camera_get_active();
|
||
|
|
|
||
|
|
vec3 move = {0};
|
||
|
|
vec2 view = {0};
|
||
|
|
|
||
|
|
// show/hide cursor
|
||
|
|
bool dragging = input(MOUSE_L) || input(MOUSE_M) || input(MOUSE_R);
|
||
|
|
bool any_active = ui_active() || ui_hover() || gizmo_active() || input_touch_active();
|
||
|
|
if( any_active ) dragging = false;
|
||
|
|
window_cursor( !dragging );
|
||
|
|
|
||
|
|
// keyboard/mouse
|
||
|
|
if( dragging ) cam.speed = clampf(cam.speed + input_diff(MOUSE_W) / 10, 0.05f, 5.0f);
|
||
|
|
vec3 wasdec = scale3(vec3(input(KEY_D)-input(KEY_A),input(KEY_E)-(input(KEY_Q)||input(KEY_C)),input(KEY_W)-input(KEY_S)), cam.speed * !any_active);
|
||
|
|
vec2 mouse = scale2(vec2(input_diff(MOUSE_X), -input_diff(MOUSE_Y)), 0.2f * dragging * !any_active);
|
||
|
|
if( !input(KEY_LCTRL) && !input(KEY_RCTRL) ) // invalidate keys if pressing ctrl (ie, when saving CTRL-S)
|
||
|
|
move = add3(move, wasdec);
|
||
|
|
view = add2(view, mouse);
|
||
|
|
|
||
|
|
// gamepad
|
||
|
|
if(0) {
|
||
|
|
vec2 filtered_lpad = input_filter_deadzone(input2(GAMEPAD_LPAD), 0.15f /*15% deadzone*/);
|
||
|
|
vec2 filtered_rpad = input_filter_deadzone(input2(GAMEPAD_RPAD), 0.15f /*15% deadzone*/);
|
||
|
|
vec3 gamepad_move = scale3(vec3(filtered_lpad.x, input(GAMEPAD_LT) - input(GAMEPAD_RT), filtered_lpad.y), 1.0f);
|
||
|
|
vec2 gamepad_view = scale2(filtered_rpad, 1.0f);
|
||
|
|
move = add3(move, gamepad_move);
|
||
|
|
view = add2(view, gamepad_view);
|
||
|
|
}
|
||
|
|
|
||
|
|
// multi-touch
|
||
|
|
vec2 touch_move = input_touch_delta_from_origin(0, 0.0125f /*sensitivityFwd*/); // button #0 (left border)
|
||
|
|
vec2 touch_view = input_touch_delta(1, 0.125f /*sensitivityRot*/); // button #1 (right border)
|
||
|
|
move = add3(move, vec3(touch_move.x, 0, -touch_move.y));
|
||
|
|
view = add2(view, vec2(touch_view.x, -touch_view.y));
|
||
|
|
|
||
|
|
// apply inputs
|
||
|
|
camera_move(&cam, move.x,move.y,move.z);
|
||
|
|
camera_fps(&cam, view.x,view.y);
|
||
|
|
}
|
||
|
|
|
||
|
|
// sugars
|
||
|
|
static void *editor_with = 0;
|
||
|
|
#define editor_obj(x) (editor_with = (x))
|
||
|
|
#define editor_obj_childof(...) editor_obj_childof(editor_with, __VA_ARGS__)
|
||
|
|
#define editor_obj_childof_tick(...) editor_obj_childof_tick(editor_with, __VA_ARGS__)
|
||
|
|
#define editor_obj_childof_draw(...) editor_obj_childof_draw(editor_with, __VA_ARGS__)
|
||
|
|
#define editor_obj_intern(...) editor_obj_intern(editor_with, __VA_ARGS__)
|
||
|
|
#define editor_obj_property(...) editor_obj_property(editor_with, __VA_ARGS__)
|
||
|
|
#define editor_obj_bind1(...) editor_obj_bind1(editor_with, __VA_ARGS__)
|
||
|
|
#define editor_obj_bind2(...) editor_obj_bind2(editor_with, __VA_ARGS__)
|
||
|
|
#define editor_obj_bind3(...) editor_obj_bind3(editor_with, __VA_ARGS__)
|
||
|
|
#define editor_obj_bind4(...) editor_obj_bind4(editor_with, __VA_ARGS__)
|
||
|
|
|
||
|
|
|
||
|
|
// my game
|
||
|
|
|
||
|
|
void* mygrid_draw(void *singleton, float *ground_size) {
|
||
|
|
ddraw_ontop_push(0);
|
||
|
|
ddraw_grid(*ground_size);
|
||
|
|
ddraw_ontop_pop();
|
||
|
|
ddraw_flush();
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
void* mymodel_draw(model_t *m, float pivot[16]) {
|
||
|
|
camera_t *cam = camera_get_active();
|
||
|
|
model_render(*m, cam->proj, cam->view, pivot, 0);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
void* mymodel_tick(model_t *m, float pivot[16], vec3 *p, vec3 *r, vec3 *s) {
|
||
|
|
rotationq44(pivot, eulerq(*r));
|
||
|
|
scale44(pivot, s->x,s->y,s->z);
|
||
|
|
relocate44(pivot,p->x,p->y,p->z);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
void* mymodel_aabb(model_t *m, float pivot[16]) {
|
||
|
|
static __thread struct aabb aabb[64];
|
||
|
|
static __thread int counter = 0; counter = (counter + 1) % 64;
|
||
|
|
aabb[counter] = model_aabb(*m, pivot);
|
||
|
|
return &aabb[counter];
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int main() {
|
||
|
|
// 80% window, MSAAx2 flag
|
||
|
|
window_create(80, WINDOW_MSAA2);
|
||
|
|
window_title("Editor " EDITOR_VERSION " (wip)");
|
||
|
|
window_icon("logo.png");
|
||
|
|
|
||
|
|
// @fixme
|
||
|
|
camera_t x = camera();
|
||
|
|
|
||
|
|
// config ground floor
|
||
|
|
float ground_size = 0;
|
||
|
|
editor_obj(&ground_size);
|
||
|
|
editor_obj_intern(".name", "ground");
|
||
|
|
editor_obj_intern(".path", editor_path("ground.ini"));
|
||
|
|
editor_obj_property(&ground_size, "float Size");
|
||
|
|
editor_obj_bind1(fn_draw, mygrid_draw, &ground_size);
|
||
|
|
|
||
|
|
// config 3d model #1
|
||
|
|
mat44 witch_pivot;
|
||
|
|
vec3 witch_p = {-5,0,-5}, witch_r={-180,180,0}, witch_s={0.1,-0.1,0.1};
|
||
|
|
model_t witch = model("witch/witch.obj", 0);
|
||
|
|
model_set_texture(witch, texture("witch/witch_diffuse.tga.png", 0));
|
||
|
|
|
||
|
|
editor_obj(&witch);
|
||
|
|
editor_obj_childof(&ground_size);
|
||
|
|
editor_obj_childof_tick(&ground_size);
|
||
|
|
editor_obj_childof_draw(&ground_size);
|
||
|
|
editor_obj_intern(".name", "witch");
|
||
|
|
editor_obj_intern(".path", editor_path("witch.ini"));
|
||
|
|
editor_obj_property(&witch_p, "vec3 Position"); // property #0
|
||
|
|
editor_obj_property(&witch_r, "vec3 Rotation"); // property #1
|
||
|
|
editor_obj_property(&witch_s, "vec3 Scale"); // property #2
|
||
|
|
editor_obj_bind1(fn_draw, mymodel_draw, witch_pivot);
|
||
|
|
editor_obj_bind1(fn_aabb, mymodel_aabb, witch_pivot);
|
||
|
|
editor_obj_bind4(fn_tick, mymodel_tick, witch_pivot, &witch_p, &witch_r, &witch_s);
|
||
|
|
|
||
|
|
// config 3d model #2
|
||
|
|
mat44 girl_pivot; id44(girl_pivot);
|
||
|
|
model_t girl = model("kgirl/kgirls01.fbx", 0);
|
||
|
|
vec3 girl_p = {0,0,0}, girl_r = {270,0,0}, girl_s = {2,2,2};
|
||
|
|
|
||
|
|
editor_obj(&girl);
|
||
|
|
editor_obj_childof(&ground_size);
|
||
|
|
editor_obj_childof_tick(&ground_size);
|
||
|
|
editor_obj_childof_draw(&ground_size);
|
||
|
|
editor_obj_intern(".name", "girl");
|
||
|
|
editor_obj_intern(".path", editor_path("girl.ini"));
|
||
|
|
editor_obj_property(&girl_p, "vec3 Transform.Position; // @Position in world units");
|
||
|
|
editor_obj_property(&girl_r, "vec3 Transform.Rotation; // @Rotation in degrees");
|
||
|
|
editor_obj_property(&girl_s, "vec3 Transform.Scale; // @Scale factor (decimal)");
|
||
|
|
editor_obj_bind1(fn_draw, mymodel_draw, girl_pivot);
|
||
|
|
editor_obj_bind1(fn_aabb, mymodel_aabb, girl_pivot);
|
||
|
|
editor_obj_bind4(fn_tick, mymodel_tick, girl_pivot, &girl_p, &girl_r, &girl_s);
|
||
|
|
|
||
|
|
// meta(&girl_frame, "float Animation.Frame; // @Animation frame");
|
||
|
|
|
||
|
|
editor_select(&girl, false);
|
||
|
|
|
||
|
|
ui_notify("Hint", "Keys I/J/K/L + Z/X to control the girl");
|
||
|
|
|
||
|
|
// editor loop
|
||
|
|
while( window_swap() ) {
|
||
|
|
|
||
|
|
// editor tick
|
||
|
|
profile("Editor") {
|
||
|
|
editor();
|
||
|
|
//ui_demo();
|
||
|
|
}
|
||
|
|
|
||
|
|
// fps camera
|
||
|
|
if( /*editor_attached ||*/ editor_enabled ) {
|
||
|
|
profile("Editor.Camera") {
|
||
|
|
editor_camera_fps();
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
profile("Game.Camera") {
|
||
|
|
camera_t *cam = camera_get_active();
|
||
|
|
|
||
|
|
static vec3 source;
|
||
|
|
do_once source = cam->position;
|
||
|
|
|
||
|
|
vec3 target = add3(girl_p, vec3(0,10,0));
|
||
|
|
target = add3(target, scale3(norm3(sub3(source, target)), 10.0));
|
||
|
|
source = mix3(source, target, 1-0.99f);
|
||
|
|
|
||
|
|
camera_teleport(cam, source);
|
||
|
|
camera_lookat(cam, vec3(girl_p.x,0,girl_p.z));
|
||
|
|
|
||
|
|
// @todo: orbit cam w/ right pad
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
double GAME_JUMP_DOWN = input_down(KEY_Z);
|
||
|
|
double GAME_FIRE_DOWN = input_down(KEY_X);
|
||
|
|
double GAME_JUMP = input(KEY_Z);
|
||
|
|
double GAME_FIRE = input(KEY_X);
|
||
|
|
double GAME_LEFT = input(KEY_J);
|
||
|
|
double GAME_RIGHT = input(KEY_L);
|
||
|
|
double GAME_UP = input(KEY_I);
|
||
|
|
double GAME_DOWN = input(KEY_K);
|
||
|
|
double GAME_AXISX = input(KEY_L) - input(KEY_J);
|
||
|
|
double GAME_AXISY = input(KEY_I) - input(KEY_K);
|
||
|
|
|
||
|
|
if( editor_gamepad && !input_anykey() ) {
|
||
|
|
if( input(GAMEPAD_CONNECTED) ) {
|
||
|
|
vec2 filtered_lpad = input_filter_deadzone(input2(GAMEPAD_LPAD), 0.15f /*15% deadzone*/);
|
||
|
|
GAME_JUMP_DOWN = input_down(GAMEPAD_A);
|
||
|
|
GAME_FIRE_DOWN = input_down(GAMEPAD_B) || input_down(GAMEPAD_X) || input_down(GAMEPAD_Y);
|
||
|
|
GAME_JUMP = input(GAMEPAD_A);
|
||
|
|
GAME_FIRE = input(GAMEPAD_B) || input(GAMEPAD_X) || input(GAMEPAD_Y);
|
||
|
|
GAME_AXISX = filtered_lpad.x;
|
||
|
|
GAME_AXISY = filtered_lpad.y;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
profile("Game.Animate scene") if( editor_delta() ) {
|
||
|
|
float delta = editor_delta() * 30; // 30fps anim
|
||
|
|
|
||
|
|
// animate girl
|
||
|
|
girl.curframe = model_animate(girl, girl.curframe + delta);
|
||
|
|
|
||
|
|
// jump controller: jump duration=1.5s, jump height=6 units, anims (expo->circ)
|
||
|
|
float jump_delta = 1.0;
|
||
|
|
static double jump_timer = 0, jump_ss = 1.5, jump_h = 6;
|
||
|
|
if( GAME_JUMP_DOWN ) if( jump_timer == 0 ) jump_timer = editor_ss();
|
||
|
|
jump_delta = clampf(editor_ss() - jump_timer, 0, jump_ss) * (1.0/jump_ss);
|
||
|
|
if( jump_delta >= 1 ) { jump_timer = 0; }
|
||
|
|
float y = ease_ping_pong( jump_delta, ease_out_expo, ease_out_circ);
|
||
|
|
girl_p.y = y * jump_h;
|
||
|
|
|
||
|
|
// punch controller
|
||
|
|
float punch_delta = 1;
|
||
|
|
if( jump_delta >= 1 ) {
|
||
|
|
static vec3 origin;
|
||
|
|
static double punch_timer = 0, punch_ss = 0.5;
|
||
|
|
if( GAME_FIRE_DOWN ) if( punch_timer == 0 ) punch_timer = editor_ss(), origin = girl_p;
|
||
|
|
punch_delta = clampf(editor_ss() - punch_timer, 0, punch_ss) * (1.0/punch_ss);
|
||
|
|
if( punch_delta >= 1 ) { punch_timer = 0; }
|
||
|
|
else {
|
||
|
|
float x = ease_out_expo( punch_delta );
|
||
|
|
vec3 fwd = rotate3q(vec3(0,0,1), eulerq(vec3(girl_r.x - 170,girl_r.y,girl_r.z)));
|
||
|
|
vec3 mix = mix3(girl_p, add3(origin,scale3(fwd,x*2)), x);
|
||
|
|
girl_p.x = mix.x, girl_p.z = mix.z;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int modern_controller = 1;
|
||
|
|
int running = 0;
|
||
|
|
|
||
|
|
// girl controller
|
||
|
|
|
||
|
|
// locomotion vars
|
||
|
|
float speed = 0.2f * delta;
|
||
|
|
float yaw_boost = GAME_AXISY > 0 ? 1.0 : 1.75;
|
||
|
|
if(punch_delta < 1) yaw_boost = 0.0; // if firing...
|
||
|
|
else if(punch_delta <= 0.1) yaw_boost = 4.0; // unless initial punch chaining, extra yaw
|
||
|
|
|
||
|
|
// old fashioned locomotion controller (boat controller)
|
||
|
|
if(!modern_controller) {
|
||
|
|
running = GAME_AXISY > 0;
|
||
|
|
|
||
|
|
girl_r.x -= 170;
|
||
|
|
quat q = eulerq(girl_r); // += custom.pivot
|
||
|
|
vec3 rgt = rotate3q(vec3(1,0,0), q);
|
||
|
|
vec3 up = rotate3q(vec3(0,1,0), q);
|
||
|
|
vec3 fwd = rotate3q(vec3(0,0,1), q);
|
||
|
|
vec3 dir = scale3(fwd, speed * GAME_AXISY * (GAME_AXISY > 0 ? 2.0 : 0.5));
|
||
|
|
girl_r.x += speed * 20.0 * yaw_boost * GAME_AXISX; // yaw
|
||
|
|
girl_p = add3(girl_p, dir);
|
||
|
|
girl_r.x += 170;
|
||
|
|
}
|
||
|
|
|
||
|
|
// modern locomotion controller (mario 3d)
|
||
|
|
if(modern_controller) {
|
||
|
|
running = GAME_AXISX != 0 || GAME_AXISY != 0;
|
||
|
|
|
||
|
|
camera_t *cam = camera_get_active();
|
||
|
|
vec3 fwd = sub3(girl_p, cam->position); fwd.y = 0; fwd = norm3(fwd);
|
||
|
|
vec3 rgt = norm3(cross3(fwd, vec3(0,1,0)));
|
||
|
|
|
||
|
|
// target
|
||
|
|
vec3 dir = add3(
|
||
|
|
scale3(fwd, GAME_AXISY),
|
||
|
|
scale3(rgt, GAME_AXISX)
|
||
|
|
); dir.y = 0; dir = norm3(dir);
|
||
|
|
|
||
|
|
// smoothing
|
||
|
|
static vec3 olddir; do_once olddir = dir;
|
||
|
|
dir = mix3(dir, olddir, 1 - (yaw_boost / 4.0) * 0.85);
|
||
|
|
olddir = dir;
|
||
|
|
|
||
|
|
// vis
|
||
|
|
// ddraw_arrow(girl_p, add3(girl_p,scale3(dir,10)));
|
||
|
|
|
||
|
|
// apply direction
|
||
|
|
girl_p = add3(girl_p, scale3(dir, speed * 2));
|
||
|
|
|
||
|
|
// apply rotation
|
||
|
|
{
|
||
|
|
girl_r.x -= 170;
|
||
|
|
quat q = eulerq(girl_r);
|
||
|
|
vec3 fwdg = rotate3q(vec3(0,0,1), q);
|
||
|
|
girl_r.x += 170;
|
||
|
|
|
||
|
|
//float cosAngle = dot3(dir,fwdg);
|
||
|
|
//float angle = acos(cosAngle) * TO_DEG;
|
||
|
|
float angle = TO_DEG * ( atan2(fwdg.z, fwdg.x) - atan2(dir.z, dir.x));
|
||
|
|
|
||
|
|
if( !isnan(angle) ) {
|
||
|
|
girl_r.x -= angle;
|
||
|
|
while(girl_r.x> 180) girl_r.x-=360;
|
||
|
|
while(girl_r.x<-180) girl_r.x+=360;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// anim loops
|
||
|
|
if( jump_delta < 1 ) { // jump/kick anim
|
||
|
|
#if 0
|
||
|
|
girl.curframe = clampf(girl.curframe, 184, 202);
|
||
|
|
if( girl.curframe > 202-4 && GAME_FIRE_DOWN ) girl.curframe = 184+4;
|
||
|
|
#else
|
||
|
|
#define loopf(frame, min, max) (frame < min ? min : frame > max ? min + frame - max : frame)
|
||
|
|
if(girl.curframe >= 203)
|
||
|
|
girl.curframe = loopf(girl.curframe, 203, 220);
|
||
|
|
else
|
||
|
|
girl.curframe = clampf(girl.curframe, 184, 202);
|
||
|
|
if( girl.curframe > 202-4 && girl.curframe < 208 && GAME_FIRE_DOWN ) girl.curframe = 203;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
else if( punch_delta < 1 ) { // punch anim
|
||
|
|
girl.curframe = clampf(girl.curframe, 90, 101);
|
||
|
|
if( girl.curframe > 101-6 && GAME_FIRE_DOWN ) girl.curframe = 101-6;
|
||
|
|
}
|
||
|
|
else if( running ) {
|
||
|
|
// loop running anim
|
||
|
|
if( girl.curframe < 65 ) girl.curframe = 65;
|
||
|
|
if( girl.curframe > 85 ) girl.curframe = 65;
|
||
|
|
}
|
||
|
|
else { // loop idle anim
|
||
|
|
if( girl.curframe > 59 ) girl.curframe = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
profile("Game.collisions") {
|
||
|
|
bool punching = girl.curframe >= 90 && girl.curframe < 101;
|
||
|
|
bool air_kicking = girl.curframe >= 184 && girl.curframe < 202;
|
||
|
|
bool jump_kicking = girl.curframe >= 203 && girl.curframe < 220;
|
||
|
|
bool attacking = punching || air_kicking || jump_kicking;
|
||
|
|
|
||
|
|
if( attacking ) {
|
||
|
|
aabb boxg = model_aabb(girl, girl_pivot);
|
||
|
|
aabb boxw = model_aabb(witch, witch_pivot);
|
||
|
|
#if 0 // halve aabb. ok
|
||
|
|
{
|
||
|
|
vec3 diag = sub3(boxg.max, boxg.min);
|
||
|
|
vec3 halve = scale3(diag, 0.25);
|
||
|
|
vec3 center = scale3(add3(boxg.min, boxg.max), 0.5);
|
||
|
|
boxg.min = sub3(center, halve);
|
||
|
|
boxg.max = add3(center, halve);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
hit* h = aabb_hit_aabb(boxg, boxw);
|
||
|
|
if( h && GAME_FIRE ) {
|
||
|
|
vec3 dir = norm3(sub3(witch_p, girl_p));
|
||
|
|
witch_p = add3(witch_p, mul3(dir,vec3(1,0,1)));
|
||
|
|
}
|
||
|
|
|
||
|
|
if( editor_enabled && editor_ddraw ) {
|
||
|
|
ddraw_color_push(h ? RED : GREEN);
|
||
|
|
ddraw_aabb(boxw.min, boxw.max);
|
||
|
|
ddraw_aabb(boxg.min, boxg.max);
|
||
|
|
ddraw_color_pop();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
camera_t *cam = camera_get_active();
|
||
|
|
|
||
|
|
profile("Game.Draw scene") {
|
||
|
|
// draw grid/axis
|
||
|
|
editor_obj_call0(&ground_size, fn_draw);
|
||
|
|
|
||
|
|
// tick+draw girl
|
||
|
|
editor_obj_call0(&girl, fn_tick);
|
||
|
|
editor_obj_call0(&girl, fn_draw);
|
||
|
|
|
||
|
|
// tick+draw witch
|
||
|
|
editor_obj_call0(&witch, fn_tick);
|
||
|
|
editor_obj_call0(&witch, fn_draw);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(!editor_enabled) continue;
|
||
|
|
|
||
|
|
profile("Editor.Draw outline") {
|
||
|
|
|
||
|
|
// handle (multi-)selection
|
||
|
|
ray *r = editor_pickup();
|
||
|
|
if( r ) {
|
||
|
|
bool found = false;
|
||
|
|
bool multi_selection = input(KEY_LCTRL) || input(KEY_RCTRL);
|
||
|
|
for each_map_ptr(editor_state, void*, o, editor_state_t, ed) {
|
||
|
|
void *obj = *o;
|
||
|
|
if( obj == &ground_size ) continue; // @fixme: add ray+plane. also, bvh
|
||
|
|
|
||
|
|
aabb *box = editor_obj_call0(obj, fn_aabb);
|
||
|
|
if( ray_hit_aabb(*r, *box)) {
|
||
|
|
editor_select(obj, multi_selection);
|
||
|
|
found = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if( !found )
|
||
|
|
if( ray_hit_plane(*r, plane(vec3(0,0,0), vec3(0,1,0)) )) {
|
||
|
|
editor_select(&ground_size, multi_selection);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(!set_count(editor_selection)) continue;
|
||
|
|
|
||
|
|
// draw silhouettes
|
||
|
|
fx_begin();
|
||
|
|
for each_set_ptr(editor_selection, void*, o) {
|
||
|
|
void *obj = *o;
|
||
|
|
|
||
|
|
editor_obj_call0(obj, fn_draw);
|
||
|
|
}
|
||
|
|
fx_end();
|
||
|
|
|
||
|
|
// draw gizmos, aabbs, markers, etc
|
||
|
|
for each_set_ptr(editor_selection, void*, o) {
|
||
|
|
void *obj = *o;
|
||
|
|
|
||
|
|
// get transform
|
||
|
|
vec3 *p = editor_obj_get_property_by_name(obj, "position");
|
||
|
|
vec3 *r = p ? editor_obj_get_property_by_name(obj, "rotation") : NULL;
|
||
|
|
vec3 *s = r ? editor_obj_get_property_by_name(obj, "scale") : NULL;
|
||
|
|
|
||
|
|
// debugdraw
|
||
|
|
ddraw_ontop_push(0);
|
||
|
|
|
||
|
|
// bounding box
|
||
|
|
aabb *box = editor_obj_call0(obj, fn_aabb);
|
||
|
|
if( box ) {
|
||
|
|
ddraw_color_push(YELLOW);
|
||
|
|
ddraw_aabb(box->min, box->max);
|
||
|
|
ddraw_color_pop();
|
||
|
|
}
|
||
|
|
|
||
|
|
// skeleton anim
|
||
|
|
// model_render_skeleton(model, pivot);
|
||
|
|
|
||
|
|
// position marker
|
||
|
|
if( p ) {
|
||
|
|
static map(void*, vec3) prev_dir = 0;
|
||
|
|
do_once map_init_ptr(prev_dir);
|
||
|
|
vec3* dir = map_find_or_add(prev_dir, obj, vec3(1,0,0));
|
||
|
|
|
||
|
|
static map(void*, vec3) prev_pos = 0;
|
||
|
|
do_once map_init_ptr(prev_pos);
|
||
|
|
vec3* found = map_find_or_add(prev_pos, obj, *p), fwd = sub3(*p, *found);
|
||
|
|
if( (fwd.y = 0, len3sq(fwd)) ) {
|
||
|
|
*found = *p;
|
||
|
|
*dir = norm3(fwd);
|
||
|
|
}
|
||
|
|
|
||
|
|
// float diameter = len2( sub2(vec2(box->max.x,box->max.z), vec2(box->min.x,box->min.z) ));
|
||
|
|
// float radius = diameter * 0.5;
|
||
|
|
ddraw_position_dir(*p, *dir, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
ddraw_ontop(1);
|
||
|
|
|
||
|
|
// transform gizmo
|
||
|
|
if( p && r && s ) {
|
||
|
|
gizmo(p,r,s);
|
||
|
|
}
|
||
|
|
|
||
|
|
ddraw_ontop_pop();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// @todo
|
||
|
|
// editor_add_tick_before()
|
||
|
|
// editor_add_tick_after()
|
||
|
|
// editor_add_draw_before()
|
||
|
|
// editor_add_draw_after()
|