Hello all,

I'm migrating some of my games to MAUI and I'm looking for a Graphics engine to work on.

I was going to ask if Orbit is available as NuGet package and if this graphics library is free to use.

Also how is its performance and can we use 3D graphics.

What about inputs like touch and slides.

I'm having issues running the 3 tests found in the repo. Syntax error and deploy configuration error. Can we have a look at?

Cheers

Something along the lines should work but we need to find a way to wrap it up nicely for use:

[Test]
public void SceneShouldRenderAsExpected()
{
    var scenery = new Scenery();
    var canvas = new SkiaCanvas();
    var bitmap = new SKBitmap(new SKImageInfo(1000, 1000));
    canvas.Canvas = new SKCanvas(bitmap);

    // Test our Render implementation
    scenery.Render(canvas, new Microsoft.Maui.Graphics.RectF(0, 0, 1000, 1000));

    using var stream = File.Create("snapshot.png");
    bitmap.Encode(stream, SKEncodedImageFormat.Png, 100);
}

public class Scenery : GameScene
{
    public override void Render(Canvas canvas, RectF dimensions)
    {
        base.Render(canvas, dimensions);

        canvas.FillColor = Colors.PaleGoldenrod;
        canvas.FillRectangle(new Rect(0, 0, 100, 100));
    }
}

This currently just involves a GameScene implementation that simply draws a rectangle on screen.

When invoking "new W2DImageLoadingService().FromStream(stream)" I see this exception:

System.Exception: 'No resource creator has been registered globally or for this thread.'

I found the following open issue:
IImageLoadingServcie cannot load image on Windows

The suggested workaround to connect a GlobalCreator after the GraphicsView is loaded partially solves this issue.

Exception will be thrown until the GraphicView "Loaded" handler workaround is invoked, so you would need to defer resource loading until after Loaded is triggered.

I used a Lazy to load the resources on the first Render call to the GameObject.

Originally posted by @aluitink in #4 (comment)

Current options are:

• Orbit
• MAGE - Multi-platform App Game Engine

Consider letting GameScene and GameObject know when child objects are added/removed. Also allow for objects to know when they have been added/removed.

And finally GameScene should know when it is loaded/unloaded.

Something like:

public class GameScene
{
    public void OnGameObjectAdded(IGameObject gameObject);

    public void OnGameObjectRemoved(IGameObject gameObject);

    public void OnLoaded();

    public void OnUnloaded();
}

public class GameObject
{
    public void OnGameObjectAdded(IGameObject gameObject);

    public void OnGameObjectRemoved(IGameObject gameObject);

    public void OnAdded(); // TODO: Parent?

    public void OnRemoved();
}

As a kind of bonus option allow the player to unlock sketch/prototype mode so they can see how it was designed.

Hi

Trying to teach my kids programming and I need really simple sample.

Something like:

https://www.ponggame.org/

Just few tasks:

1. setup scene (MAUI template + Button click + 2nd page with "game")
2. draw/render object[s]
3. move/animate object[s]
4. advanced (collision, logic, etc)

Is there something like that?

Thanks

Are you considering to use an image resource container to manage the image load following the flyweight pattern?

I developed a first aproach in the following branch where you can see the idea. Following the flyweight pattern allow you save memory when you use the same image in several game objects.

If you think that this can be useful for the project, I can create a Pull Request to one of your branches.

Given there are multiple game projects on the go along with the engine development I currently propose the following structure:

• assets - any media for the repo/readme files
• engine - the main source code for the engine + tests
• games - the source code for multiple games - possibly one folder per game project to house tests and assets

Compiling Orbit for windows machine gives theses errors.

The pragmatic approach would be to make use of GitHub Actions given this is hosted on GitHub but Azure DevOps is another possible option

Perhaps something like registering a scene name with the type so then when calling gameSceneManager.LoadScene the user could just pass in the name and have a new instance created.

Investigate some level of physics based functionality for the engine. This could either be as part of the main engine or a separate package.

First key functionality to address would be collision detection.

Scoped lifetimes around the lifetime of a GameScene feels like it could have some merit. It shouldn't be the only way to use the system though and will require some investigation.

Perhaps some extension to the UseOrbitEngine to accept options like:

.UseOrbitEngine(options =>
{
    options.ScopedLifetimesByScene = true;
});

Due to the fact that the engine relies on .NET MAUI Graphics and also IDispatcher it would be ideal to ship mocks that would aid in the testing phase of any development project

Currently LoadImage is hard coded to load from a specific namespace, I would like to find a way to make this as easy to use but also consider avoiding things like Reflection to get there.

This should also result in adding docs to explain how it could be used.