ImageSection defines a section of an Image to be seen used where an Image is expected.

Quadrant sprite takes an image that will be mirrored in all quadrants of the Cartesian Coordinate system. A corner size is given, and the edges and center will automatically be repeated to fill any rectangular size set for the object - similar to NinePatchRect in Godot.

Finally add NinePatchSprite, the same as in Godot.

Add conceptual anchor points to all classes which exist in the 2D space, and have them be extendable in subclasses.

You should be able to set and get anchor points, such that the following is possible:

val rect = RectSdf(
  width = 100
  height = 30
)
val text = Text()

// The MyCustomPlayer class is an imaginary user defined class which sets its 
// gun position based on player aim and player character behavior. This is added
// as an anchor point to the class.
val player = MyCustomPlayer(
  health = 10
  radius = 22.3
)

def loop(): Unit = 
  // player has already been updated at this point...
  
  // Have the rect's bottom left corner be moved onto the gun position with an offset added to it
  rect.anchor.bottomLeft = player.anchor.gunPos + Vector2(10,10)
  
  // Display the ammo count and move the text
  text.content = s"${player.ammo}/${player.maxAmmo}"
  text.anchor.center = rect.anchor.center

Some global anchors to consider:

• bottomRight
• center
• bottomLeft
• topLeft
• topRight

Currently, with an immutable RenderData class, its unnecessarily difficult for users to work with it.

Since the intended purpose for these types of classes are for users to change their properties over time, making them immutable adds unnecessary overhead to the development process.

They will then be processed with the risks of their mutable states considered.

Currently setting for a Game before the init call it doesn't do anything.

With smaller numbers, nearEquals(...) can have inaccurate results because of floating point errors. For example, nearEquals(1.0001, 1.0000, 0.0001) returns false when it should return true.

Overview

If there are RenderManager and RenderedElement classes, the render pipeline can use the managers to render the elements that belong to them. This can be used to do batch rendering, e.g. a PolygonRenderManager could group PolygonRenderedElement instances by layer and then render groups by writing all vertices and indices for the polygons into single buffers and render them in one draw-call.

The RenderManager and RenderedElement should also be extendable by user classes, so users have the potential to render anything the way they want to and optimize it for their specific use cases.

Engine Performance

Batch rendering should then be implemented for all out-of-the-box elements that are included in the engine: polygons, lines, textures etc.

References

The following old commit contains an rough implementation of this system:

24bd3c2

Hide all classes and methods that aren't needed by users by making them as private as possible.

Make possible:

Vector2(10) // res0: Vector2 = Vector2(10, 10)

This would be easier to read and write.

Thoroughly test constructors.

Note: Make sure to check for duplicate entries to 'uniforms' and make sure uniforms are checked when passed to sub-classes, and check in super is not skipped.

Overview of LineRenderedElement

Class that contains all the data needed to render a 2D line with some nice features.

By default the engine should render this line class as a sequence of rectangles with the flat color provided by the 'tint' shader uniform.

Optional features:

• 'segment' RenderedElement for line segment (renders rects by default with tint color)
• 'corner' RenderedElement to render on corners (defaults to rendering flat circles with same 'tint' and 'width' as the line). Can be replaced by anything, could render a polygon or custom element. Passes a 'angle
• 'end', 'start' RenderedElement (use same RenderedElement for both if desired, or use distinct ones)

Overview of ColoredLineRenderedElement

Create 'ColoredLineRenderedElement' which extends 'LineRenderedElement' but hides its features and has the following properties:

• 'endStyle' - none, sharp, round (enum) | Ngon
• 'startStyle' - none, sharp, round (enum) | Ngon
• 'cornerStyle' - none, sharp, round (enum) | Ngon

Make argument order be 'lower' > 'value' > 'upper', not 'value' > 'lower' > 'upper'.

The following leaves an unfilled triangle:

val p1 = RenderedMesh(
      shader = shader,
      transform = Matrix3
        .transform(
          translation = Vector2(
            cos(1.7f * Time.current + 5f) * .2,
            sin(3f * Time.current + 3f) * .11
          ),
          rotation = cos(.8f * Time.current + 3f) * 2f * pi,
          scale = Vector2(1f, 1f) * (.2f + .1f * (cos(.8f * Time.current) + 1))
        ),
      mesh = Mesh(
        Polygon(
          Vector(
            Vector2(0, 0),
            Vector2(1, 0),
            Vector2(1, 1),
            Vector2(0, 1),
            Vector2(0, .8),
            Vector2(0.35, 0.5),
            Vector2(0, .2)
          ).map(v => Vector2(v.x - .5, v.y - .5))
        )
      ),
      tint = Color.YELLOW * .75
    )

I assume this happens since the first and last line segments found distinct valid points, and their triangles don't share an edge.

Screenshots:

Currently, to render a polygon to the screen, you pass a Polygon instance to one of the RenderData constructor overloads and it processes that data into vertices and indices which will be passed to OpenGl. But since we intend to make RenderData mutable in #29, splitting the single RenderData class into sub-classes and making those classes non-reliable on classes from the math package` will make the most sense.

When using the 'color_fill' shader, objects with an alpha of less than 1 do not become transparent.

Make an Image class that will handle loading images of different file types via STB Loader.

E.g. there is no way to upload a texture via that method.

Extend String to support these methods.

The Sprite class can not render this image correctly:

Note: The only problems are that the image is skewed and rendered without color, the upside down render was a different problem which was fixed.

Maybe it is since it is a JPEG, but this needs further investigation.

Only have the bare necessary parameters in constructors, have other properties be edited after construction!

E.g.

val b = Button(text="MyButton", style=....

Rather:

val b = Button("MyButton")
b.style=...

Note: This is just a rough idea for now. Still to be considered.

Change the Polygon.grow method to have a rounding_interval parameter. This parameter will specify the maximum distance on an equidistance arche on a corner of a polygon when inflated. Since, when inflating polygons, the points end up being further from their original positions as the edges of the polygon. New edges should be made on what would be a perfectly rounded mathematical corner for a polygon inflated exactly.

Note: The perimeter length of the arche formed on a corner should be pre-calculated, then only should points be placed in equal spacing of one another, while being under the grow amount.

Quote from Copilot:

When closing a game or any application, it's important to perform cleanup operations to ensure that all resources are properly released and to prevent memory leaks. Here are some typical cleanup tasks you might need to perform:

Freeing Graphics Resources: This includes deleting any textures, buffers, and shaders you've created. In the context of your code, you might need to delete the shader and any meshes you've created.

Stopping any Running Threads: If your game has any background threads running, you should ensure they are stopped properly.

Saving Game State: If your game has any state that needs to be persisted (like player progress or high scores), you should save this to disk.

Releasing Windowing Resources: If you're using a library like GLFW to create your game window, you should call the appropriate function to destroy the window and release any associated resources.

Closing any Open Files: If your game has any files open, you should close them.

Releasing any Network Resources: If your game uses any network resources (like sockets), you should ensure they are properly closed.

Remember, the specific cleanup operations you need to perform will depend on what resources your game uses.

Overview

This class would track all existing shaders and serve as a shader factory, providing references to existing shaders instead of creating duplicates. Causing shaders to only be compiled and created once and be used by all instances needing them.

'ShaderCompileManager' must have a 'keepAlive' list of shaders which the user can add and remove from at will. Adding to this list should return an async result which can be waited for. This can then, for example, be used to pre-compile shaders for scenes in their loading screens.

Look at: https://github.com/accmltr/scala-games/blob/main/CONTRIBUTING.md#mutable-interface-design-pattern

This renderer simply adds a shader in at various points in the render pipeline which output the current frame to a frame buffer object, and then into an image local variable.

These images can be read every frame for the purposes of testing.

Add some SDF rendered elements for primitives in new package render.render_element.sdf. This would be great for making the UI package look nice down the line.

SDFs to include:

• Circle
• Square
• Capsule

Overview

Remove the system for batch rendering and render all RenderedElements individually without concern for performance.

Reasoning

This over complicates the project while its still in early stages and is undergoing constant change.

It will make it easier to test and clean.

Add the following to render.window.Window:

• cursor setter and getter
• clearCursor()
• A default cursor for the engine.

Remove the need to add and remove 'RenderedElement' in order to track and render them. Instead, 'RenderMaster' should be passed all the elements it should rendered every 'render' call.

However, internally, 'RenderMaster', 'RenderManager' and 'RenderedElement' may still store data about previous render calls for optimization.

Classes that use local state for optimization should explain this in their docs, so that users may know which of these classes are best to keep around for reuse, and which can be terminated after a single 'render' call.

Make sure all Renderer inheritors upload default uniforms.

Maybe add a test-mode listener inside Shader.uploadUniforms and all other uniform upload methods and test Renderers.

OR

Find a new way to streamline uploading uniforms so that all Renderers cannot avoid uploading defaults.

Code:

//... some other code ...
var sprite: Sprite = Sprite(
    "res/sample_image.png"
  )
  sprite.color = Color.GREEN
  sprite.position = Vector2(50, 50)
  sprite.width = 100
  sprite.height = 100
//... some other code ...
onUpdate += { (delta: Float) =>

    //... some other code ...

    if (input.justPressed(KeyCode.s)) {
      sprite.width += 10
      sprite.height += 10
      sprite.rotation += 0.1f
      sprite.color += Color(0.1f, 0.1f, 0.1f)
    }
    if (input.justPressed(KeyCode.d)) {
      sprite.width -= 10
      sprite.height -= 10
      sprite.rotation -= 0.1f
      sprite.color -= Color(0.1f, 0.1f, 0.1f)
    }

    if (input.justPressed(KeyCode.v)) {
      window.vsync = !window.vsync
    }

    if (input.justReleased(KeyCode.escape)) {
      quit()
    }
  }

Error when pressing 'S':

Node(name: MyFirstNode, position: (0.000, 0.000), children: 4, components: 0)
Running Scala Games on LWJGL 3.3.3+5!
Exception in thread "main" java.lang.ExceptionInInitializerError
        at MyGame.main(Main.scala)
Caused by: java.lang.IllegalArgumentException: 'g' out of bounds: [0,1]
        at engine.render.Color.<init>(Color.scala:16)
        at engine.render.Color$.apply(Color.scala:6)
        at engine.render.Color.$plus(Color.scala:52)
        at MyGame$.$init$$$anonfun$2(Main.scala:100)
        at scala.runtime.java8.JFunction1$mcVF$sp.apply(JFunction1$mcVF$sp.scala:18)
        at engine.scene.Signal.emit$$anonfun$1(Signal.scala:13)
        at scala.runtime.function.JProcedure1.apply(JProcedure1.java:15)
        at scala.runtime.function.JProcedure1.apply(JProcedure1.java:10)
        at scala.collection.immutable.List.foreach(List.scala:333)
        at engine.scene.Signal.emit(Signal.scala:13)
        at engine.Game.updateCallback(Game.scala:79)
        at engine.Game.$init$$$anonfun$2(Game.scala:41)
        at engine.render.window.Window._runLoop(Window.scala:236)
        at engine.render.window.Window.run(Window.scala:85)
        at engine.Game.run(Game.scala:53)
        at MyGame$.<clinit>(Main.scala:118)
        ... 1 more

No error when pressing 'D', but sprite completely disappears.

You should be able to set width or height (in pixels) that you want to render to, and have it fill the screen on your window, even when the window doesn't match the output resolution. Or you can have no streching, then the window resolution is always the output resolution.

Make this work:

val f: Float = 0.23413229812341
val d: Double = 0.23413229812341
println(s"float 'math.abs' result: ${engine.math.abs(f)}")
println(s"double 'math.abs' result: ${engine.math.abs(d)}")

Then users and engine devs can seamlessly switch to higher precision for operations that require it.