stefanmielke/libdragon-extensions

List of structs and functions to help on Libdragon development.

libdragon-extensions's Issues

Add layer manager

Perhaps this should be a structure with a function callback for rendering, render behavior at the edges (whether or not it should render out of bounds tiles as empty or as a set tile), position, etc. . Then we could have a structure (maybe called LayerManager) that contains an array of layer objects and is responsible for rendering them in order, disabling given layers, etc.

Better Sprite Animation

We want to have better support for sprite animation. The current code we have in place is not really good for having multiple sprites in place.

Ideally we should have single and multiple spritesheet support, so that the same entity can have a single spritesheet with everything, or one spritesheets per animation it has.

A simple but decent animation system is anim8 for Love2d.

Use S, T coordinates for more tiles per load

Currently a single texture load is performed for every tile variant that needs to be drawn in Tiled. This system could be improved using S, T coordinates by loading a batch of tiles into TMEM, then drawing each tile as a part of that load, and repeating this process until the entire tilemap is covered.

Particles

We should have a simple particle system that users can add on their ROMs.

The system should allow simple actions, like moving and re-sizing, and also have rendering associated with them (we'll probably need to have a 2d and a 3d version of this).

Localization System

We want to have a way to manage different languages on a ROM.

Each language configuration should have:

• Language Id (for when changing languages)
• Types of fonts (eg.: Big, Small, Title, etc). The amount should be configured by the user.
• SpriteFonts used (one per type needed)
• Texts needed
• Sounds needed (just the filepath)

Functions needed should include:

• GetText (gets the text from the language or the default language if it's not there)
• GetSound (same as GetText, but returns the filepath for the sound)
• SetLanguage

Pre-Compiled Library

We should add a pipeline to generate a lib that can be used directly by the users, the same way libdragon is linked to a user's ROM but not compiled during the process.

Support CI4 tilesets & multiple palettes

When Libdragon transitions to rdpq, CI4 formatted textures can be used. In combination with many palettes, this could offer the advantage of twice as many texels loaded into TMEM at once compared to RGBA16, while retaining a lot of the color depth.

Font Rendering for Rdpq

We want to have font rendering using the RDPQ.

It should have the same set of functions that exists on the current Libdragon font rendering today.

Mirroring support

When we decide to support mirroring, we'll need to rework the current tile format to encode this information. In addition, the way Tiled treats mirrored tiles requires some bit manipulation to extract.

Enabling mirroring will also require selective disabling of copy mode per tile, so this will need to be integrated into the renderer.

Add Size_int, perhaps consolidate position_int and position headers?

I've been looking over position and position_int and I think it would be less confusing for users if position_int was in the same header as the floating point version. I'm probably going to be adding a size_int type, and I think it should follow the same pattern.

Let me know what you think

Overflow issue in animated_sprite_tick

We need to be able to detect overflows and edge conditions in our animated_sprite_tick function. Currently the timer will eventually overflow and cause a floating point exception after a couple minutes.

Input System

We want to create an input system that has support for:

• Input Mapping/Remapping (bind/rebind a button to an action)
• Setting deadzone for axis
• Setting sensivity for axis
• Function callbacks for button actions
  • OnPressed
  • OnReleased
  • OnGoing
• Function callback for axis actions
• Serialization/Deserialization for Saving/Loading mappings

One good example of what is need is the UE4/5 input system.

Scene Graph

We need a easy way to create a scene graph, where entities with custom logic can be added and handled by the scene automatically (so you only need to implement the logic on the entity itself, not everything else).

An example of such system is the Actors on UE4/5.

The main functions it should have are:

• Begin
• Update/Tick
• End/Destroyed

After the base implementation, we should implement some basic entities that other implementations could use as a base, with examples being "2d Sprite" and "2d Character".

State Machine

We should look into actual use-cases to make sure those are supported by the lib.

Tiled JSON map parsing

I'd like to add better support for Tiled features like objects and multiple layers in the future. This should allow users more flexibility in adding custom objects to levels without being confined to the tile system. Also, I think that we should consider parsing JSON Tiled formats instead of XML, since Tiled appears to be moving away from XML and most of the newer and planned features are coming to JSON instead.