littlektframework / littlekt Goto Github PK

Sometimes the InternalResources load after the ContextListener is intialized and causes an Assets not prepared yet exception.

Enable support for streaming longer pieces of audios such as music in mp3 format vs loading all at once.

Attempting to tint a originally white text with black text causes the first letter to render transparent within a FontCache.

Currently, it feels very odd checking the version of OpenGL by determining if its 3.0 or higher. Perhaps we could do something similar to setting the versions based on a list of booleans for each major version or a helper class / function / extension that can check it.

Need a batch, preferably the existing Sprite batch, to be able to render shapes such as rectangles, ovals, triangles, and other polygons.

Bitmap fonts currently only support a single page and should be expanded to support as many as needed.

A system that allows any type to be used to determine the currently input based on a list of inputs given from multiple control sources.

Pseudo:

interface GameInput {
    JUMP,
    RUN,
    ATTACK
}

...
input.registerType<GameInput>()
input.addBindings(GameInput.JUMP, Keys.SPACE, Gamepad.A)
...

Loading the exact same image as standalone Texture. using the exact same margins, renders perfectly. Rendering the TextureSlice atlas separately renders perfectly fine as well.

LDtkWorld just have a map of the entity definitions that can be accessed similarly to the enums map.

The UI scene graph calculates and fits children controls from the bottom up.

paddedContainer {
    minWidth = 200f

    centerContainer {
        label {
             text = "test"
        }
    }
}

The Label minimum size will be calculated first, then the CenterContainer and then lastly the PaddedContainer.
If the Label minimum width is 40f that means the CenterContainer minimum width will be 40f. The CenterContainer is then fitted into the PaddedContainer at 200f but doesn't update the Label to recenter itself. The Label will only be centered on that 40f width instead of the 200f width.

This happens for all Control and Container components. We need to update it so these updates propagate back down to the children to be fitted again.

Kernings are read and created but never made use of when laying out the glyphs.

Currently, we have controls that require textures, texture slices, and ninepatches. It would be nice to have a single interface type that can be implemented for specific items that needed rendered so that UI controls can utilize them for rendering.

Example: The Button class requires a texture slice currently, but would be great to use a NinePatch as well to render the background.

interface Drawable {
    // determine fields
}

class TextureDrawable(val texture: Texture): Drawable {
    // impl drawable functions
}

class NinePatchDrawable(val ninepatch: NinePatch): Drawable {
    // impl drawable functions
}

// with ninepatch
val texture = readTexture()
val ninepatch = NinePatch(texture, 2, 2, 2, 2)

button {
    backgroundDrawable = NinePatchDrawable(ninepatch)
}

button {
    backgroundDrawable = TextureDrawable(texture)
}

Currently, only able to read and write asynchronously using coroutines. Would be nice to be able to use coroutines or just load on the currently thread synchronously.

Base work off of rune UI work done previously for Libgdx. Should be able to port pretty easily.

Some glyphs slightly extend further then others.

Requires #34 to be implemented first.

The n in the FreeSerif font does not render at all.

Since LittleKt is based on OpenGL and there are no plans to create a Metal renderer, we can look into integrating ANGLE somehow into the project to work with Metal.

Related #6.

Working being done in pull request: #20

Some glyphs still end up being rendered even though the string has changed to something else. Reproducible with longer stringers.

Should be able to automatically pack images of a specified directory into a JSON based atlas file and placed into resources on compile or triggered via task.

https://en.wikipedia.org/wiki/Bin_packing_problem

Suggested features:

• Uses a MaxRects packing algorithm
• Rotate images 90 degrees for efficient packing
• De-duplication of images that are the same
• Add padding between each image
• Adds borders to each image to prevent bleeding
• Output as the default JSON types
• Able to specify input and output directories
• Specify the maximum width and height of each page / texture that is outputted

If a theme changes on Control, then that theme needs to propagate down throughout the child Control nodes to update their sizes, due to Drawable components in the theme most likely having different sizes.

The default font and atlas is unable to be loaded on the web platform due to the resources not being copied into the public directory.

Allow a Control node to consume / filter mouse clicks.

If a Panel or PanelContainer is clicked or hovered over, then a button beneath that node should be be able to be pressed.

Consume mouse:

• Button
• Panel
• PanelContainer