Filter System and then Add Component to Entity?

[Shadowblitz16]

How would I do something like this?

using Flecs.NET.Core;
using Silk.NET.Input;
using Silk.NET.Maths;
using Silk.NET.OpenGL;
using Silk.NET.Windowing;
using SpaceTest.Engine.Components;
using Window = SpaceTest.Engine.Components.Window;

namespace SpaceTest.Engine.Systems;

public struct WindowModule : IFlecsModule
{
    public void InitModule(World world)
    {
        var entity1 = WindowCreate(world, new(640, 480), new("SpaceTest 1"));
        var entity2 = WindowCreate(world, new(640, 480), new("SpaceTest 2"));
    }

    public static Entity WindowCreate(World world, Size size, Title title)
    {
        world.Observer<Window, Size, Position>().Event((Ecs.OnAdd)).Each((Entity entity, ref Window window, ref Size size, ref Position position) =>
        {
            var silkWindow = Silk.NET.Windowing.Window.Create(WindowOptions.Default with
            {
                Size          = new Vector2D<int>((int)size.H, (int)size.W),
                Position      = new Vector2D<int>(position.X, position.Y),
                IsEventDriven = true,
            });
            silkWindow.Initialize();
            silkWindow.Move   += (v) => {
                // Cannot use ref parameter inside lambda expression.
                position = new Position(v.X, v.Y);
            };
            silkWindow.Resize += (v) => {
                // Cannot use ref parameter inside lambda expression.
                size = new Size((uint)v.X, (uint)v.Y);
            };

            // The type 'SpaceTest.Engine.Systems.WindowModule.WindowHandle' must be convertible to 'System.Enum' in order to use it as parameter 'T' in the generic method 'ref Entity Flecs.NET.Core.Entity.Add<T>(T)'
            entity.Add(new WindowHandle(silkWindow, silkWindow.CreateOpenGL(), silkWindow.CreateInput()));
            
        });

        world.Observer<Window, WindowHandle>().Event((Ecs.OnRemove)).Each((Entity entity, ref Window window, ref WindowHandle windowHandle) =>
        {
            windowHandle.Input.Dispose();
            windowHandle.Graphics.Dispose();
            windowHandle.Window.Dispose();
            
            world.Remove<WindowHandle>();
            world.Remove<Window>();
            
        });

        world.Each(static (Entity entity, ref WindowHandle handle) =>
        {
            handle.Window.DoEvents();
            handle.Window.DoUpdate();
            handle.Window.DoRender();
            
            handle.Graphics.ClearColor(0,0,0,0);
            handle.Graphics.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit | ClearBufferMask.StencilBufferBit);
        });
        
        var entity = world.Entity().Set(size ).Set(title).Set(new Window());
        return entity;
    }
    
    private record struct WindowHandle(IWindow Window, GL Graphics, IInputContext Input);
    
}

[BeanCheeseBurrito]

The above error can be fixed by changing .Add to .Set.

// The type 'SpaceTest.Engine.Systems.WindowModule.WindowHandle' must be convertible to 'System.Enum' in order to use it as parameter 'T' in the generic method 'ref Entity Flecs.NET.Core.Entity.Add<T>(T)'
entity.Add(new WindowHandle(silkWindow, silkWindow.CreateOpenGL(), silkWindow.CreateInput()));

The position and size references provided by the observer are not valid after the observer callback finishes. Your .Move and .Resize callbacks will be attempting to reference invalid objects when the events are signaled.

silkWindow.Move  += (v) => {
    // Cannot use ref parameter inside lambda expression.
     position = new Position(v.X, v.Y);
};
silkWindow.Resize += (v) => {
    // Cannot use ref parameter inside lambda expression.
    size = new Size((uint)v.X, (uint)v.Y);
};

In my opinion, I think a better idea would be to update the window position and size every frame using a system.

System<WindowHandle, Size, Position> system = world.System<WindowHandle, Size, Position>()
    .Each((ref WindowHandle handle, ref Size size, ref Position position) =>
    {
        size = new Size(handle.SilkWindow.Size.X, handle.SilkWindow.Size.Y);
        position = new Size(handle.SilkWindow.Position.X, handle.SilkWindow.Position.Y);
    });

[Shadowblitz16]

The above error can be fixed by changing .Add to .Set.

// The type 'SpaceTest.Engine.Systems.WindowModule.WindowHandle' must be convertible to 'System.Enum' in order to use it as parameter 'T' in the generic method 'ref Entity Flecs.NET.Core.Entity.Add<T>(T)'
entity.Add(new WindowHandle(silkWindow, silkWindow.CreateOpenGL(), silkWindow.CreateInput()));

The position and size references provided by the observer are not valid after the observer callback finishes. Your .Move and .Resize callbacks will be attempting to reference invalid objects when the events are signaled.

silkWindow.Move  += (v) => {
    // Cannot use ref parameter inside lambda expression.
     position = new Position(v.X, v.Y);
};
silkWindow.Resize += (v) => {
    // Cannot use ref parameter inside lambda expression.
    size = new Size((uint)v.X, (uint)v.Y);
};

In my opinion, I think a better idea would be to update the window position and size every frame using a system.

System<WindowHandle, Size, Position> system = world.System<WindowHandle, Size, Position>()
    .Each((ref WindowHandle handle, ref Size size, ref Position position) =>
    {
        size = new Size(handle.SilkWindow.Size.X, handle.SilkWindow.Size.Y);
        position = new Size(handle.SilkWindow.Position.X, handle.SilkWindow.Position.Y);
    });

Ty.
The reason I did not update them directly and used events instead was because I wanted to sync them both ways

If the window changed I wanted to update the components,
And if the components changed I wanted to update the window.

I could in thoery have Last* versions of the components and keep track of the changes that way.

[Shadowblitz16]

@BeanCheeseBurrito so this is my attempt at doing it without events.
And it doesn't work.

I made Last Component and tried to make a Sync Component the Sync one failed, I couldn't figure out how to actually do it's api.

Anyways here is the code.

using Flecs.NET.Core;
using Silk.NET.Input;
using Silk.NET.Maths;
using Silk.NET.OpenGL;
using Silk.NET.Windowing;
using SpaceTest.Engine.Components;
using SpaceTest.Engine.Tags;
using Window = SpaceTest.Engine.Tags.Window;

namespace SpaceTest.Engine.Modules;

public class WindowModule : IFlecsModule
{
    public void InitModule(World world)
    {
        world.Observer<Window>().Each((Entity entity, ref Window window) =>
        {
            WindowCreate(world, entity, new Size(640, 480), new Title("SpaceTest"));
        });
    }

    public static void WindowCreate(World world, Entity currentEntity, Size size, Title title)
    {
        var silkWindow = Silk.NET.Windowing.Window.Create(WindowOptions.Default with
        {
            Size = new((int)size.Width, (int)size.Height),
            Title = title.Text
        });
        silkWindow.Initialize();
        
        // Sync
        world.Observer<Handle, Last<Size>          , Size          >().Each((Entity _, ref Handle handle, ref Last<Size          > last, ref Size           curr) => {
            if (handle.Width != last.Component.Width || handle.Height != last.Component.Height)
            {
                curr.Width   = handle.Width;
                curr.Height  = handle.Height;
                last         = new(curr);
            }
        
            if (curr.Width != last.Component.Width || curr.Height != last.Component.Height)
            {
                handle.Width  = curr.Width;
                handle.Height = curr.Height;
                last          = new(curr);
            }
        });
        world.Observer<Handle, Last<Position>      , Position      >().Each((Entity _, ref Handle handle, ref Last<Position      > last, ref Position       curr) => {
            if (handle.X != last.Component.X || handle.Y != last.Component.Y)
            {
                curr.X   = handle.X;
                curr.Y   = handle.Y;
                last     = new(curr);
            }
        
            if (curr.X != last.Component.X || curr.Y != last.Component.Y)
            {
                handle.X = curr.X;
                handle.Y = curr.Y;
                last     = new(curr);
            }
            
        });
        world.Observer<Handle, Last<Seeable>       , Seeable       >().Each((Entity _, ref Handle handle, ref Last<Seeable       > last, ref Seeable        curr) => {
            if (!handle.Visible != last.Component.Visible)
            {
                curr.Visible = handle.Visible;
                last         = new(curr);
            }
        
            if (curr.Visible != last.Component.Visible)
            {
                handle.Visible = curr.Visible;
                last           = new(curr);
            }
        });
        world.Observer<Handle, Last<Minimizable>   , Minimizable   >().Each((Entity _, ref Handle handle, ref Last<Minimizable   > last, ref Minimizable    curr) => {
            if (handle.Minimized != last.Component.Minimized)
            {
                curr.Minimized = handle.Minimized;
                last           = new(curr);
            }
        
            if (curr.Minimized != last.Component.Minimized)
            {
                handle.Minimized = curr.Minimized;
                last             = new(curr);
            }
        });
        world.Observer<Handle, Last<Maximizable>   , Maximizable   >().Each((Entity _, ref Handle handle, ref Last<Maximizable   > last, ref Maximizable    curr) => {
            if (handle.Maximized != last.Component.Maximized)
            {
                curr.Maximized = handle.Maximized;
                last = new(curr);
            }
        
            if (curr.Maximized != last.Component.Maximized)
            {
                handle.Maximized = curr.Maximized;
                last             = new(curr);
            }
        });
        world.Observer<Handle, Last<FullScreenable>, FullScreenable>().Each((Entity _, ref Handle handle, ref Last<FullScreenable> last, ref FullScreenable curr) => {
            if (handle.Fullscreen != last.Component.Fullscreen)
            {
                curr.Fullscreen = handle.Fullscreen;
                last            = new(curr);
            }
        
            if (curr.Fullscreen != last.Component.Fullscreen)
            {
                handle.Fullscreen = curr.Fullscreen;
                last              = new(curr);
            }
        });
        
        // Visible
        world.Observer<Seeable>().Without<Visible>().Each((Entity entity, ref Seeable curr) => {
            if (curr.Visible) entity.Set(new Visible());
        });
        world.Observer<Seeable>().With   <Visible>().Each((Entity entity, ref Seeable curr) => {
            if (!curr.Visible) entity.Remove<Visible>();
        });

        // Minimized
        world.Observer<Minimizable>().Without<Minimized>().Each((Entity entity, ref Minimizable curr) => {
            if (curr.Minimized) entity.Set(new Minimized());
        });
        world.Observer<Minimizable>().With   <Minimized>().Each((Entity entity, ref Minimizable curr) => {
            if (!curr.Minimized) entity.Remove<Minimized>();
        });
        
        // Maximized
        world.Observer<Maximizable>().Without<Maximized>().Each((Entity entity, ref Maximizable curr) => {
            if (curr.Maximized) entity.Set(new Maximized());
        });
        world.Observer<Maximizable>().With   <Maximized>().Each((Entity entity, ref Maximizable curr) => {
            if (!curr.Maximized) entity.Remove<Maximized>();
        });
        
        // Fullscreen
        world.Observer<FullScreenable>().Without<Fullscreen>().Each((Entity entity, ref FullScreenable curr) => {
            if (curr.Fullscreen) entity.Set(new Fullscreen());
        });
        world.Observer<FullScreenable>().With   <Fullscreen>().Each((Entity entity, ref FullScreenable curr) => {
            if (!curr.Fullscreen) entity.Remove<Fullscreen>();
        });
        
        world.Observer<Handle>().Each((Entity entity, ref Handle handle) =>
        {
            if (!WindowPoll(ref handle))
            {
                entity.Remove<Last<Position>>();
                entity.Remove<Last<Size>>();
                entity.Remove<Last<Seeable>>();
                entity.Remove<Last<Minimizable>>();
                entity.Remove<Last<Maximizable>>();
                entity.Remove<Last<FullScreenable>>();
                entity.Remove<Position>();
                entity.Remove<Size>();
                entity.Remove<Seeable>();
                entity.Remove<Minimizable>();
                entity.Remove<Maximizable>();
                entity.Remove<FullScreenable>();
                entity.Remove<Handle>();
            };
        });
        
        var handle = new Handle(silkWindow, silkWindow.CreateOpenGL(), silkWindow.CreateInput());
        currentEntity
            // Sync stuff
            .Set(new Last<Position>(new(handle.X, handle.Y)))
            .Set(new Last<Size>(new(handle.Width, handle.Height)))
            .Set(new Last<Seeable>(new Seeable(true)))
            .Set(new Last<Minimizable>(new Minimizable(false)))
            .Set(new Last<Maximizable>(new Maximizable(true)))
            .Set(new Last<FullScreenable>(new FullScreenable(true)))
            .Set(new Position(handle.X, handle.Y))
            .Set(new Size(handle.Width, handle.Height))
            .Set(new Seeable(true))
            .Set(new Minimizable(false))
            .Set(new Maximizable(true))
            .Set(new FullScreenable(true))

            // Public Components
            .Set(new Position(handle.X, handle.Y))
            .Set(size)
            .Set(title)
            .Add<Visible>();
    }

    private static bool WindowPoll(ref Handle handle)
    {
        if (!handle.SilkWindow.IsClosing)
        {
            handle.SilkWindow.DoEvents();

            if (!handle.SilkWindow.IsClosing)
            {
                handle.SilkWindow.DoUpdate();
            }

            if (!handle.SilkWindow.IsClosing)
            {
                handle.SilkWindow.DoRender();
            }
            return true;
        }
        handle.SilkWindow.DoEvents();
        handle.SilkWindow.Reset();
        return false;
    }
    
    public record struct Seeable            (bool Visible);
    public record struct Minimizable        (bool Minimized);
    public record struct Maximizable        (bool Maximized);
    public record struct FullScreenable     (bool Fullscreen);

    private readonly record struct Handle(IWindow SilkWindow, GL SilkGraphics, IInputContext SilkInput)
    {
        public int X
        {
            get => SilkWindow.Position.X;
            set => SilkWindow.Position = new Vector2D<int>(value, Y);
        }

        public int Y
        {
            get => SilkWindow.Position.Y;
            set => SilkWindow.Position = new Vector2D<int>(X, value);
        }

        public uint Width
        {
            get => (uint)SilkWindow.Size.X;
            set => SilkWindow.Size = new Vector2D<int>((int)value, (int)Height);
        }

        public uint Height
        {
            get => (uint)SilkWindow.Size.Y;
            set => SilkWindow.Size = new Vector2D<int>((int)Width, (int)value);
        }
        
        
        public bool Visible
        {
            get => SilkWindow.IsVisible;
            set => SilkWindow.IsVisible = value;
        }

        public bool Minimized
        {
            get => SilkWindow.WindowState == WindowState.Minimized;
            set => SilkWindow.WindowState = (value ? WindowState.Minimized : WindowState.Normal);
        }
        
        public bool Maximized
        {
            get => SilkWindow.WindowState == WindowState.Maximized;
            set => SilkWindow.WindowState = (value ? WindowState.Maximized : WindowState.Normal);
        }
        public bool Fullscreen
        {
            get => SilkWindow.WindowState == WindowState.Fullscreen;
            set => SilkWindow.WindowState = (value ? WindowState.Fullscreen : WindowState.Normal);
        }
    }
}

[BeanCheeseBurrito]

You need to add an event for the observer to react to with .Event(). Observers will fail to be made without at least one event.