DirectDrawingMovableBase.cs

using System.Drawing;
using System.Numerics;
using Gondwana.Physics.Movement;
using Gondwana.Rendering;
using Gondwana.Rendering.Views;
using Gondwana.Scenes;
using Gondwana.Timers;
 
namespace Gondwana.Drawing.Direct;

public abstract class DirectDrawingMovableBase : DirectDrawingBase, IDirectCompositeChild
{
    private Vector2 _posPx;

    protected DirectDrawingMovableBase(RenderSurfaceHostBase renderSurfaceHost,
                                       DirectDrawingMode mode,
                                       SceneLayer? sceneLayer,
                                       View? view,
                                       Rectangle? screenBounds,
                                       Rectangle? worldBounds,
                                       string? name = null)
        : base(renderSurfaceHost, mode, sceneLayer, view, screenBounds, worldBounds, name)
    {
        Rectangle bounds = (mode == DirectDrawingMode.SceneLayer ? worldBounds : screenBounds)!.Value;
        _posPx = new Vector2(bounds.X, bounds.Y);
 
        var movementState = MovementState.ForPixel();
        Movement = new MovementController(this, movementState);
    }

    public MovementController Movement { get; }

    public MovementSpace PositionSpace => MovementSpace.Pixel;

    public Vector2 GetPosition() => _posPx;

    public void SetPosition(Vector2 p)
    {
        // mark old area dirty
        ForceRefresh();
 
        // keep precise position for movement math
        _posPx = p;
 
        // pixel-align only for rendering bounds
        int x = (int)MathF.Round(p.X);
        int y = (int)MathF.Round(p.Y);
 
        if (Mode == DirectDrawingMode.SceneLayer)
        {
            var r = WorldBounds;
            WorldBounds = new Rectangle(x, y, r.Width, r.Height);
        }
        else
        {
            var r = ScreenBounds;
            ScreenBounds = new Rectangle(x, y, r.Width, r.Height);
        }
 
        // mark new area dirty
        ForceRefresh();
    }
 
    void IDirectCompositeChild.SetIsVisible(bool visible)
    {
        Visible = visible;
    }
 
    void IDirectCompositeChild.SetZOrder(int zOrder)
    {
        ZOrder = zOrder;
    }
 
    void IDirectCompositeChild.SetOpacity(float opacity)
    {
        Opacity = opacity;
    }
 
    void IDirectCompositeChild.FadeTo(float targetOpacity, float durationSec)
    {
        base.FadeTo(
            targetOpacity,
            durationSec);
    }

    public override void Update(long tick)
    {
        // DirectDrawingBase registers the instance with DirectDrawingManager from
        // its constructor. The update thread can therefore observe this derived
        // instance before this constructor has assigned Movement.
        if (Movement is null)
        {
            base.Update(tick);
            return;
        }
 
        if (tick <= _lastTick)
            return;
 
        float dt =
            HighResTimer.GetDuration(_lastTick, tick);
 
        Movement.AdvanceMovement(dt);
 
        base.Update(tick);
    }
}