SCWindow.cs

using Silk.NET.Input;
using Silk.NET.OpenGL;
using Silk.NET.Windowing;
using System.Numerics;

namespace OpenSC
{
    using OpenSC.Game;
    using OpenSC.Audio;
    using OpenSC.Game.Proxy;

    public class SCWindow : IDisposable
    {
        private GL _gl;
        private IWindow _window;
        private IInputContext _inputContext;

        private IKeyboard _primaryKeyboard;
        private IMouse _primaryMouse;
        private IGamepad _primaryGamepad;

        private Cursor _cursor;
        private Camera _camera;
        private Scene _scene;

        private EngineContext _context;
        private readonly StateManager _stateManager;
        private readonly AudioManager _audioManager;
        private readonly LuaProxy _proxy;

        private string _execArg = String.Empty;

        public SCWindow()
        {
            var size = new Vector2(1920, 1080);
            SCEnvironment.ViewportSize = size;

            var options = WindowOptions.Default;
            options.VSync = true;
            options.Size = new Silk.NET.Maths.Vector2D<int>((int)size.X, (int)size.Y);
            options.Title = "OpenSC";

            _window = Window.Create(options);

            _window.Load += OnLoad;
            _window.Update += OnUpdate;
            _window.Render += OnRender;
            _window.Closing += OnClosing;
            _window.FramebufferResize += OnFramebufferResize;

            _stateManager = new StateManager();
            _audioManager = new AudioManager();
            _proxy = new LuaProxy(_stateManager);

        }

        public void Run(string execArg)
        {
            _execArg = execArg;
            _window.Run();
        }

        private void OnMouseMove(IMouse mouse, Vector2 position)
        {
            _camera.Rotate(position);
            _cursor.MoveTo(position); // Free-mode only
        }

        private void OnClosing()
        {

        }

        private void OnFramebufferResize(Silk.NET.Maths.Vector2D<int> newSize)
        {
            _gl.Viewport(newSize);

            var viewport = new Vector2(_window.FramebufferSize.X, _window.FramebufferSize.Y);
            SCEnvironment.ViewportSize = viewport;
            _context.Viewport = viewport;
            _camera.SetViewport(viewport);
            _cursor.SetViewport(viewport);
        }

        private void KeyDown(IKeyboard arg1, Key arg2, int arg3)
        {
            if (arg2 == Key.Escape)
            {
                _window.Close();
            }

            if (arg2 == Key.Space)
            {
                _scene.Skip();

                // _proxy.Exec("scChoiceGo(\"phone\")");
                // _proxy.Exec("is_door_locked = 0");
                // _proxy.ExecCoroutine("enterGarden");
                // _proxy.ExecCoroutine("enterHouse");
                // _proxy.Exec("scSwitch(SC_ROOM, \"house-lobby\")");
            }
        }

        public void Dispose()
        {
            _window.Dispose();
        }

        private void InitializeInput()
        {
            _inputContext = _window.CreateInput();
            _inputContext.ConnectionChanged += ConnectionChanged;

            _primaryKeyboard = _inputContext.Keyboards.FirstOrDefault();
            if (_primaryKeyboard != null)
            {
                _primaryKeyboard.KeyDown += KeyDown;
            }

            _primaryMouse = _inputContext.Mice.FirstOrDefault();
            if (_primaryMouse != null)
            {
                _primaryMouse.Cursor.CursorMode = CursorMode.Raw;
                _primaryMouse.MouseMove += OnMouseMove;

                // FUCK THIS:
                // _primaryMouse.Click += OnMouseClick;
            }

            _primaryGamepad = _inputContext.Gamepads.FirstOrDefault();
            if (_primaryGamepad != null)
            {
                _primaryGamepad.ThumbstickMoved += ThumbstickMoved;
            }
        }

        private void ConnectionChanged(IInputDevice device, bool connected)
        {
            if (connected && device is IGamepad gamepad)
            {
                _primaryGamepad = gamepad;
                _primaryGamepad.ThumbstickMoved += ThumbstickMoved;
            }
        }

        private void ThumbstickMoved(IGamepad gamepad, Thumbstick stick)
        {
            var pos = new Vector2(stick.X, stick.Y);
        }

        private void OnLoad()
        {
            _gl = GL.GetApi(_window);
            _gl.Enable(EnableCap.DepthTest);
            _gl.DepthFunc(DepthFunction.Lequal);

            InitializeInput();

            var viewport = new Vector2(_window.FramebufferSize.X, _window.FramebufferSize.Y);
            _cursor = new Cursor(_gl, viewport);
            _camera = new Camera(viewport);

            _context = new EngineContext()
            {
                GL = _gl,
                Cursor = _cursor,
                Camera = _camera,
                Proxy = _proxy,
                AudioManager = _audioManager,
                StateManager = _stateManager,
                Viewport = viewport
            };

            _scene = new Scene(_context);

            if (!String.IsNullOrEmpty(_execArg))
            {
                _proxy.ExecCoroutine(_execArg);
            }
        }

        private void OnRender(double deltaTime)
        {
            _gl.ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
            _gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

            float delta = (float) deltaTime;

             _scene?.Draw(delta);
             _cursor.Draw(delta);
        }

        private void OnUpdate(double deltaTime)
        {
            var delta = (float)deltaTime;

            _scene?.Update(delta);

            // We poll the mouse click state in the update loop because the event system
            // decided to take a coffee break every time we needed a click.
            MouseClickTrigger();
        }

        private bool _wasLeftMousePressed = false;
        private bool _wasRightMousePressed = false;
        public void MouseClickTrigger()
        {
            if (_primaryMouse != null) 
            {
                bool isLeftMousePressed = _primaryMouse.IsButtonPressed(MouseButton.Left);
                bool isRightMousePressed = _primaryMouse.IsButtonPressed(MouseButton.Right);

                if (!_wasLeftMousePressed && isLeftMousePressed)
                {
                    _scene.Click(MouseButton.Left);
                }

                if (!_wasRightMousePressed && isRightMousePressed)
                {
                    _scene.Click(MouseButton.Right);
                }

                _wasLeftMousePressed = isLeftMousePressed;
                _wasRightMousePressed = isRightMousePressed;
            }
        }

    }
}