Add logic to ensure inactive and disabled InteractiveGUI components (via InputGUI) do not handle input events.
Add support for ordered JSON and ordered entity tree serialisation
Implement relative file paths
[Editor] Setup entity hierarchy view
Setup reference counting in resource controller (for automatically destroying resource when no longer in use)
[Editor] Drag-and-drop object reference fields
Refactor the ECS - heavily simplify and optimise scenes
Implement a proper transform matrix tree for the ECS
Add b2Fixture to colliders; these will only be instantiated in a physics body is attached to the same entity.
Backlog - Top Priority
[Editor] Fix issues with window layout resizing
[Editor] Make editor windows, EditorLayout and EditorController serializable
Generate codeblocks project file when creating an Ossium project, or even combine them.
Serialise the entity tree of a scene as a JSON array such that order is maintained.
Improve text fields by supporting copy, cut and paste along with highlighting. Also add support for newlines!
Make context menus scrollable if they contain too many options to fit on screen.
Refactor TextInputHandler such that it should not be a type of InputHandler but a specialised input type that should be cached for each text input field, and get rid of the SetText() method which is highly inefficient to use.
Add support for handling scancodes in addition to keycodes for keyboard input handling
Backlog - Low Priority
Refactor Image and Renderer such that Image controls only a single software surface, while the Renderer controls all GPU textures. SDL 2 doesn't support shared textures across renderers natively, so I will revisit this in future; I will likely integrate OpenGL in future so I can support multiple renderers properly.
[Editor] Implement dockable window/viewport system This is on hold until I solve the problem of sharing textures between renderers (see above task). For now I'm just gonna try and implement resizable panels or something, but not support multiple renderers or windows.
[Editor] Implement theme customisation
Implement data structures for linear transformations
Minor refactor of logging system (maybe rename Logger to Log, also consider scrapping EngineLog() and just making methods static? Will need to consider how to allow for separate logging 'channels' however). Also implement a Log::Once() method such that recurring messages are not logged (handy for debugging).
Implement a proper text layout engine (see HarfBuzz and ICU libraries). This is required for some languages to display properly!
Improve usability of SchemaReferable (such that types can be configured for reference mapping)
Make internal API bits static (internal to translation unit) where possible.
Write up documentation for engine core.
Create some general purpose UI components such as buttons, drop-down lists, text fields etc.
Add rudimentary performance profiling support, i.e. time how long certain function calls take (like rendering).
Consider implementing handles as an alternative to pointers (potentially wrapped in a helper class) for object references.
Implement ToString() and FromString() for unordered maps (test if this works now).
Input system: 'analog' states (e.g. gamepad joystick axis values).
Investigate implementation and use of CVars in quake-based game engines; would it be beneficial to use a similar system?
Modify the audio system to support linear volume and dB levels in addition to the current normalised logarithmic scale
Refactor binary serialisation
Debug drawing of primitives (this in addition to the current Draw() methods); requires some sort of caching system so they are always drawn on top.
Refactor: reduce the number of necessary macros in favor of templates where possible.
JSON file streaming support.
Basic localisation system for strings and OSS_Text (explore Unicode support), probably using CSV files
Deprecate current Finite State Machine code, replace it with a better system.
Implement generic colliders Integrate the Box2D physics engine into Ossium (static linking has been setup now)
Implement a global crash handler (see std::signal() and std::set_terminate(); beware of multi-threaded signal handling!).
Implement audio mixer state 'snapshots' with tweening.
Extend the Logger class such that it can log to a file.
Find a way to ensure schemas can work with irregular memory layouts (i.e. such that member offsets always work however complex a class/struct hierarchy may be).
Remove DECLARE_ANIMATION and REGISTER_ANIMATION macros, use CRTP instead
In future, maybe think about refactoring schemas using something like the visitor pattern and variadic macro arguments instead of statics? See https://github.com/cbeck88/visit_struct
Make sure both big-endian and little-endian systems are supported properly, especially anywhere bitmasks are used
Implement a more generic Tree type that accepts custom node types
Rename ALL files in pascal-case (remember to rename the includes too!)
Post Alpha release
Improve the Text class by implementing multi-line (text wrapping) support as well as Right-To-Left text support
Composite animations/animator clips; animations consisting of multiple individual animations.
Feature: Flat 2D texture mapping to any polygon
Feature: Bezier-curve based tweening system
Optimisations
[Warning: consider how this task affects entity active states before implementing!] Refactor ECS such that entities are NOT stored in a tree/scene graph, but instead an array (note: I might use a slot map to make things more efficient.).
Stretch Goals
Memory manager with pool allocation; although technically an optimisation, I love the idea of seeing exactly how much memory everything is using because that's pretty rad. note: not important enough to do right now
Continuous-Tasks
Create unit tests for all modules
Use more namespaces!
Replace pointers with const references where appropriate, e.g. Render() methods that require a Renderer instance
Completed tasks:
Replace OSS_Timer and OSS_TimeLine - either combine functionality of the two or place in a single file
Remove all 'OSS_' prefixes and implement namespace ossium {} instead
Create a renderer class supporting rendering layers and culling
Add copy constructors where needed and refactor code
Serialization system
Texture atlas import and export
Implement basic ECS
Implement a game event broadcasting/messaging system
Implement CSV spreadsheet import/export
Implement game events generator (maybe a GUI utility... or maybe not! Pure CSV possible?) note: I went with a pure CSV format, but I will likely make further changes
Configurable aspect ratio of the render viewport
Implement control mapping and player I/O interface
Investigate audio streaming with pure SDL as SDL_mixer only supports a single music channel, and smooth crossfades without intensive memory consumption would be nice.
Note: I will continue to use SDL_mixer due it's simplicity; true dynamic crossfading will require loading of music into memory rather than streaming however.
Implement a sound controller class for music and SFX
Refactor ECS to support multiple instances
Major Refactor: Renderer and all graphic classes (Texture, StateSprite, TexturePack, Primitives etc.). I'd advise myself to use a similar pattern to that which I used for the ECS and Input systems perhaps, unless there is a better way of allowing expansion. note: I went with a pure virtual method to keep things simple but flexible
Basic animation system (timeline, state transitions?)
Refactor the input system to allow definition of methods that can be used as actions, rather than plain old functions.
Normalise naming conventions in terms of capitalisation (PascalCase for classes and methods, camelCase for members and variables). note: exceptions include CircularBuffer, Tree, and some functions declared in basics.h.
Create a functor class for implementing generic callbacks
Basic string compression/hashing/interning + follow up refactor where string ids are used
Move aspect ratio / viewport code over to Renderer, rather than handling it in Window!
Ensure that components cannot be inadvertantly copied (i.e. only allowed to be referenced or use pointers)
Create some simple random utility classes/functions
Refactor the event system to make it nicer to use (perhaps add methods for getting values by their actual data type) and add JSON serialisation support.
Standardise spellings of colour -> color (because that's what SDL uses)
Refactor: Service locator? Idea scrapped. I want to reduce static dependencies in the core engine where possible, with exceptions only when appropriate. Implemented in non-static form per ECS instance (individual service instances must be passed to the ECS constructor).
Setup debug drawing system (including debug text)
Implement ToString() and FromString() in schemas, components and entities.
Implement a data-driven GameEntity system (with spawners and schemas). note: while most value types can be serialised the only pointers that can be serialised must be either entity or component-derived pointers (all other pointers are serialised as "null").
Move away from statically generated UIDs for ECS serialisation, instead utilise type names (though UIDs should still be used at runtime for optimal performance)
Decouple the schema system from the ECS.
Refactor or deprecate ResourceController and related code (e.g. Init() methods in resource classes such as Font)
Resource controller overhaul.
Create a simple audio controller
Split up basics.h into smaller files
Setup a simple logging system
Decouple the Renderer and other unrelated subsystems from the ECS system.
Create an EngineSystem class that contains a game loop and controls core game systems such as an ECS, the physics engine, renderer, audio and resource loader. note: core services (e.g. ResourceController) must be passed into the constructor
Minor modifications to component setup methods (OnCreate, OnInit etc.), make sure GraphicsComponent cannot be overridden.note: made setup methods virtual so they should be called up the inheritance hierarchy if you override them.
Make the InputController a service.
Setup a build chain, e.g. premake support and test linking Ossium as a dynamic library (core engine only). note: build tool chain pushed back for alpha release. Cross-platform dynamic library support is too complicated to implement at present due to lack of standardization, so will stick to static library builds.
Re-structure the source files hierarchy so it's easier to navigate the codebase.
Implement a rudimentary hierarchy/scene graph for Transforms. Consider making this work in a way that allows for custom structures (e.g. quad trees). note: implemented via ECS entity tree at present. May refactor this so it has it's own hierarchy in future.
Investigate ways to efficiently "fake" hot-swapping, i.e. without using a dynamic library. note: will likely compile & run as a separate process via the future editor application.
Add support for schema member string attributes e.g. M("Hidden", string, version_number) which provide meta information about particular members for use in dev tools. note: rather than strings, I've opted for 32-bit integer enumerated attributes.
Implement a dynamic font atlas system like fontstash but using SDL_ttf instead.
Fix advance width of some glyphs e.g. Japanese characters (note: this is dependent on SDL_TTF i did a bug oopsy)
Implement proper text styling support for fonts
Implement up-scaling support for glyphs that don't fit in a font atlas cell note: it's not pretty scaling but it does the job fine
Implement automatic font atlas creation (auto-detect maximum texture size and attempt to use that, see SDL_GetRendererInfo()).
Begin work on a basic text renderer
Refactor Font such that glyphs are not directly coupled to their cached image or the font atlas.
Refactor TextLayout such that it computes layout separately to rendering.
Major TextLayout refactor, make it extendable (consider custom function pointers) that control the logic instead of embedding it all within the class. The goal is to make text layout simple yet extremely flexible for a variety of text layout use cases.TextLayout has been refactored so the code is a bit nicer, but it's feature set will remain limited to what I've hardcoded for now. Maybe I'll revisit this when implementing a localisation system.
Fix issue#14 note: lazy fix was to use OpenGL instead of Direct3D
Implement input handler for native window events REVERTED; it's better to use callbacks as that allows for multiple listeners.
Refactor Font such that it doesn't rely on a single renderer instance (build atlas directly in memory instead using surfaces). This is necessary to support multiple renderers (e.g. multiple viewports, multiple windows).
Improve NeuronGUI slider input (take input control until mouse release, this functionality is also needed for dropdowns).
[Editor] Implement resizable editor window panels (using a single renderer/viewport).
[Editor] Fix issue where clicking in the window while it is not in focus discards the input event.
[Editor] Context menu (use a borderless window)
Implement a text rendering subsystem to optimise text drawing (if we draw the same text multiple times, we shouldn't create a texture for each individual instance where we use it. In fact, we could optimise this further by not rendering coloured text, instead rendering text in white and then colour modulating the texture as necessary). note: this was implemented as the font rendering system
[Editor] Setup menu bar in main window
Make game engine lambda-safe (i.e. double check everywhere I casually capture everything by reference)
[Editor] Implement fundamental immediate-mode UI elements including:
text labels [DONE],
text fields [DONE (to an extent - see improvements task under main focus)],
buttons [DONE],
toggles [DONE],
selection fields (radio buttons) [SCRAPPED],
drop-down lists [DONE],
horizontal + vertical layout switching [DONE],
slider [DONE]
Custom schema property serialization (basically allowing custom equivalents to the standard ToString() methods but can be used for any purpose, e.g. custom GUI representation of a property)
Add virtual component method that is exclusively called in editor only when manual changes are made to the component.
Create a lightweight UI layout system
Scroll bars for NeuronGUI windows and layout elements.