internal static void RenderChild(int childID)
{
State.CurrentContextID = childID;
RenderFrame?.Invoke(null, State);
TextureManager.CheckForPurge();
}
//public override void Refresh()
//{
// this.Context.MakeCurrent();
// OnDrawFrame();
//}
protected virtual void OnDrawFrame()
{
GL.glClearColor(0, 0, 0, 1);
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
RenderFrame?.Invoke();
Context.SwapBuffers();
}
protected override void OnOpenGlRender(GlInterface gl, int fb)
{
var elapsed = _stopwatch.ElapsedMilliseconds / 1000.0;
if (elapsed <= 0)
{
if (!_stopwatch.IsRunning)
{
_stopwatch.Start();
Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
}
return;
}
_stopwatch.Restart();
try
{
UpdateFrame?.Invoke(new FrameEventArgs(elapsed));
RenderFrame?.Invoke(new FrameEventArgs(elapsed));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
}
protected void OnRenderFrame(out double duration, out bool shouldStop)
{
RenderFrameEventArgs ea = new RenderFrameEventArgs();
RenderFrame?.Invoke(this, ea);
duration = ea.Duration;
shouldStop = ea.ShouldStop;
}
/// <summary>Raises the System.Windows.Forms.Control.Paint event.</summary>
/// <param name="e">A System.Windows.Forms.PaintEventArgs that contains the event data.</param>
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
if (!DesignMode && IsHandleCreated)
{
RenderFrame?.Invoke(this, new FrameEventArgs());
}
}
public void Invoke(string EventName, Game CurrentGame, EventArguments Args)
{
if (EventName == "Closing")
{
Closing.Invoke(CurrentGame, Args);
}
if (EventName == "KeyDown")
{
KeyDown.Invoke(CurrentGame, Args);
}
if (EventName == "KeyUp")
{
KeyUp.Invoke(CurrentGame, Args);
}
if (EventName == "KeyPress")
{
KeyPress.Invoke(CurrentGame, Args);
}
if (EventName == "Load")
{
Load.Invoke(CurrentGame, Args);
}
if (EventName == "MouseDown")
{
MouseDown.Invoke(CurrentGame, Args);
}
if (EventName == "MouseUp")
{
MouseUp.Invoke(CurrentGame, Args);
}
if (EventName == "MouseClick")
{
MouseClick.Invoke(CurrentGame, Args);
}
if (EventName == "MouseMove")
{
MouseMove.Invoke(CurrentGame, Args);
}
if (EventName == "MouseWheel")
{
MouseWheel.Invoke(CurrentGame, Args);
}
if (EventName == "RenderFrame")
{
RenderFrame.Invoke(CurrentGame, Args);
}
if (EventName == "Resize")
{
Resize.Invoke(CurrentGame, Args);
}
if (EventName == "TimerTick")
{
TimerTick.Invoke(CurrentGame, Args);
}
}
/// <summary>
/// Runs the game loop, until the window receives a quit event or GameLoop.Quit() is called.
/// </summary>
/// <param name="window">The window for which to run the game loop.</param>
public void Run(GameWindow window)
{
lock (_mutex)
{
if (_isRunning)
{
throw new InvalidOperationException();
}
_isRunning = true;
_shouldQuit = false;
_loopThread = Thread.CurrentThread;
}
var oldSynchronizationContext = SynchronizationContext.Current;
SynchronizationContext.SetSynchronizationContext(new GameSynchronizationContext(this));
try
{
while (true)
{
ProcessWindowEvents(window);
RenderFrame?.Invoke(new RenderInfo {
Width = window.Width, Height = window.Height
});
ProcessWindowEvents(window);
window.SwapBuffers();
}
}
catch (GameLoopExitException)
{
}
finally
{
SynchronizationContext.SetSynchronizationContext(oldSynchronizationContext);
List <QueuedAction> actionsToAbort;
lock (_mutex)
{
_loopThread = null;
_shouldQuit = true;
_isRunning = false;
actionsToAbort = new List <QueuedAction>(_queuedActions);
_queuedActions.Clear();
}
foreach (var queuedAction in actionsToAbort)
{
queuedAction.Abort();
}
}
}
public AndroidPlatformGameWindow(AndroidPlatformGameView gameView)
{
this.gameView = gameView;
gameView.Load += (o, e) => Load?.Invoke(o, e);
gameView.Unload += (o, e) => Unload?.Invoke(o, e);
gameView.UpdateFrame += (o, e) => UpdateFrame?.Invoke(o, e);
gameView.RenderFrame += (o, e) => RenderFrame?.Invoke(o, e);
gameView.Resize += (o, e) => Resize?.Invoke(o, e);
gameView.Closed += (o, e) => Closed?.Invoke(o, e);
gameView.Disposed += (o, e) => Disposed?.Invoke(o, e);
gameView.TitleChanged += (o, e) => TitleChanged?.Invoke(o, e);
gameView.VisibleChanged += (o, e) => VisibleChanged?.Invoke(o, e);
gameView.WindowStateChanged += (o, e) => WindowStateChanged?.Invoke(o, e);
}
/// <summary>
/// コンストラクタ。
/// </summary>
public CanvasContext(TextEditorControl control)
{
_control = control;
_control.HandleCreated += (_, __) =>
{
_control.Resize += (s, e) => Resize?.Invoke(new Size2D(_control.ClientSize.Width, _control.ClientSize.Height));
_control.GotFocus += (s, e) => GotFocus?.Invoke();
_control.LostFocus += (s, e) => LostFocus?.Invoke();
_control.Paint += (s, e) => RenderFrame?.Invoke(new RenderingContext(e.Graphics));
_control.MouseDown += (s, e) => MouseDown?.Invoke(ToMouseEventInfo(e));
_control.MouseUp += (s, e) => MouseUp?.Invoke(ToMouseEventInfo(e));
_control.MouseMove += (s, e) => MouseMove?.Invoke(ToMouseEventInfo(e));
_control.MouseWheel += (s, e) => MouseWheel?.Invoke(ToMouseEventInfo(e));
Created?.Invoke(new Size2D(_control.ClientSize.Width, _control.ClientSize.Height));
};
}
private void RunIteration(NSTimer timer)
{
var curUpdateTime = stopwatch.Elapsed;
if (prevUpdateTime == TimeSpan.Zero)
{
prevUpdateTime = curUpdateTime;
}
var delta = (float)(curUpdateTime - prevUpdateTime).TotalSeconds;
UpdateFrame?.Invoke(delta);
prevUpdateTime = curUpdateTime;
GL.BindFramebuffer(FramebufferTarget.Framebuffer, framebuffer);
renderContext.Begin(framebuffer);
RenderFrame?.Invoke();
renderContext.End();
}
private void OnInternalRender(object sender, OpenTK.FrameEventArgs e)
{
if (!_fpsTimer.IsRunning)
{
_fpsTimer.Start();
}
RenderFrameEventArgs args = new RenderFrameEventArgs(e.Time * 1000D);
OnRenderFrame(this, args);
RenderFrame?.Invoke(this, args);
if (!_isEventPolled && _isStarted)
{
_fps++;
CheckWindowFPS();
}
}
/// <summary>
/// コンストラクタ。
/// </summary>
public CanvasContext(TextEditorComponent textEditorComponent, IJSInProcessRuntime jsRuntime, JSEvent jsEvent)
{
_textEditorComponent = textEditorComponent;
_jsRuntime = jsRuntime;
_textEditorComponent.Created += size =>
{
jsEvent.RegisterActionListener("TextEditorComponent.resize", args => Resize?.Invoke(ToSize(args)));
jsEvent.RegisterActionListener("TextEditorComponent.mousedown", args => MouseDown?.Invoke(ToMouseState(args)));
jsEvent.RegisterActionListener("TextEditorComponent.mouseup", args => MouseUp?.Invoke(ToMouseState(args)));
jsEvent.RegisterActionListener("TextEditorComponent.mousemove", args => MouseMove?.Invoke(ToMouseState(args)));
jsEvent.RegisterActionListener("TextEditorComponent.mousewheel", args => MouseWheel?.Invoke(ToMouseState(args)));
jsEvent.RegisterActionListener("TextEditorComponent.render", _ => RenderFrame?.Invoke(new RenderingContext(_textEditorComponent)));
jsEvent.RegisterActionListener("InputMethod.focusin", args => GotFocus?.Invoke());
jsEvent.RegisterActionListener("InputMethod.focusout", args => LostFocus?.Invoke());
Created?.Invoke(size);
};
}
public void Draw(MTKView view)
{
if (vkContext == null)
{
vkContext = new Graphics.Platform.Vulkan.PlatformRenderContext();
PlatformRenderer.Initialize(vkContext);
}
if (vkSwapChain == null)
{
shouldUpdateMetalLayerSize = true;
}
if (shouldUpdateMetalLayerSize)
{
var screen = Window?.Screen ?? UIScreen.MainScreen;
var drawableSize = Bounds.Size;
drawableSize.Width *= screen.NativeScale;
drawableSize.Height *= screen.NativeScale;
metalLayer.DrawableSize = drawableSize;
if (vkSwapChain == null)
{
vkSwapChain = new Graphics.Platform.Vulkan.Swapchain(vkContext, this.Handle, (int)metalLayer.DrawableSize.Width, (int)metalLayer.DrawableSize.Height);
}
else
{
vkSwapChain.Resize((int)metalLayer.DrawableSize.Width, (int)metalLayer.DrawableSize.Height);
}
shouldUpdateMetalLayerSize = false;
}
shouldUpdateMetalLayerSize = false;
var curUpdateTime = stopwatch.Elapsed;
if (prevUpdateTime == TimeSpan.Zero)
{
prevUpdateTime = curUpdateTime;
}
var delta = (float)(curUpdateTime - prevUpdateTime).TotalSeconds;
UpdateFrame?.Invoke(delta);
prevUpdateTime = curUpdateTime;
RenderFrame?.Invoke();
}
protected override void OnRenderFrame()
{
// create the contexts if not done already
if (grContext == null)
{
var glInterface = GRGlInterface.Create();
grContext = GRContext.CreateGl(glInterface);
}
// manage the drawing surface
var alloc = Allocation;
var res = (int)Math.Max(1.0, Gdk.Screen.Default.Resolution / 96.0);
var w = Math.Max(0, alloc.Width * res);
var h = Math.Max(0, alloc.Height * res);
if (renderTarget == null || surface == null || renderTarget.Width != w || renderTarget.Height != h)
{
// create or update the dimensions
renderTarget?.Dispose();
GL.GetInteger(GetPName.FramebufferBinding, out var framebuffer);
GL.GetInteger(GetPName.StencilBits, out var stencil);
GL.GetInteger(GetPName.Samples, out var samples);
var maxSamples = grContext.GetMaxSurfaceSampleCount(COLOR_TYPE);
if (samples > maxSamples)
{
samples = maxSamples;
}
var glInfo = new GRGlFramebufferInfo((uint)framebuffer, COLOR_TYPE.ToGlSizedFormat());
renderTarget = new GRBackendRenderTarget(w, h, samples, stencil, glInfo);
// create the surface
surface?.Dispose();
surface = SKSurface.Create(grContext, renderTarget, SURFACE_ORIGIN, COLOR_TYPE);
}
using (new SKAutoCanvasRestore(surface.Canvas, true))
{
RenderFrame?.Invoke(this, surface);
}
// update the control
surface.Canvas.Flush();
grContext.Flush();
}
private void OnRenderFrameInternal(FrameEventArgs e)
{
if (!RenderInitialized)
{
Log.Verbose("Init OpenGL Bindings");
Log.Verbose("Grab Context");
Window.MakeCurrent();
Log.Verbose("Load OpenGL Bindings");
GL.LoadBindings(new GLFWBindingsContext());
var vendor = GL.GetString(StringName.Vendor);
var version = GL.GetString(StringName.Version);
var shadingLanguageVersion = GL.GetString(StringName.ShadingLanguageVersion);
var renderer = GL.GetString(StringName.Renderer);
Log.Info($"Vendor: {vendor}, version: {version}, shadinglangVersion: {shadingLanguageVersion}, renderer: {renderer}");
EnableDebugCallback();
RenderInitialized = true;
}
if (!RenderThreadHasContext)
{
Window.MakeCurrent();
RenderThreadHasContext = true;
}
SetRenderThread();
RenderReady = true;
if (Enabled)
{
RenderFrame?.Invoke(e);
}
}
public void ProcessEvents()
{
RenderFrame?.Invoke(30f);
PrivateWindow.ProcessEvents();
}
/// <summary>
/// Invokes the <see cref="RenderFrame"/> event.
/// </summary>
protected virtual void OnRenderFrame()
{
RenderFrame?.Invoke(this, EventArgs.Empty);
}
