mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-17 14:18:44 +02:00
OpenGL game overlays and hooks tend to make a lot of assumptions about how games present frames to the screen, since presentation in OpenGL kind of sucks and they would like to have info such as the size of the screen, or if the contents are SRGB rather than linear. There are two ways of getting this. OBS hooks swap buffers to get a frame for video capture, but it actually checks the bound framebuffer at the time. I made sure that this matches the output framebuffer (the window) so that the output matches the size. RTSS checks the viewport size by default, but this was actually set to the last used viewport by the game, causing the OSD to fly all across the screen depending on how it was used (or res scale). The viewport is now manually set to match the output framebuffer size. In the case of RTSS, it also loads its resources by destructively setting a pixel pack parameter without regard to what it was set to by the guest application. OpenGL state can be set for a long period of time and is not expected to be set before each call to a method, so randomly changing it isn't great practice. To fix this, I've added a line to set the pixel unpack alignment back to 4 after presentation, which should cover RTSS loading its incredibly ugly font. - RTSS and overlays that use it should no longer cause certain textures to load incorrectly. (mario kart 8, pokemon legends arceus) - OBS Game Capture should no longer crop the game output incorrectly, flicker randomly, or capture with incorrect gamma. This doesn't fix issues with how RTSS reports our frame timings.
206 lines
6.8 KiB
C#
206 lines
6.8 KiB
C#
using OpenTK.Graphics.OpenGL;
|
|
using Ryujinx.Graphics.GAL;
|
|
using Ryujinx.Graphics.OpenGL.Image;
|
|
using System;
|
|
|
|
namespace Ryujinx.Graphics.OpenGL
|
|
{
|
|
class Window : IWindow, IDisposable
|
|
{
|
|
private readonly Renderer _renderer;
|
|
|
|
private int _width;
|
|
private int _height;
|
|
|
|
private int _copyFramebufferHandle;
|
|
|
|
internal BackgroundContextWorker BackgroundContext { get; private set; }
|
|
|
|
internal bool ScreenCaptureRequested { get; set; }
|
|
|
|
public Window(Renderer renderer)
|
|
{
|
|
_renderer = renderer;
|
|
}
|
|
|
|
public void Present(ITexture texture, ImageCrop crop, Action swapBuffersCallback)
|
|
{
|
|
GL.Disable(EnableCap.FramebufferSrgb);
|
|
|
|
CopyTextureToFrameBufferRGB(0, GetCopyFramebufferHandleLazy(), (TextureView)texture, crop, swapBuffersCallback);
|
|
|
|
GL.Enable(EnableCap.FramebufferSrgb);
|
|
|
|
// Restore unpack alignment to 4, as performance overlays such as RTSS may change this to load their resources.
|
|
GL.PixelStore(PixelStoreParameter.UnpackAlignment, 4);
|
|
}
|
|
|
|
public void SetSize(int width, int height)
|
|
{
|
|
_width = width;
|
|
_height = height;
|
|
}
|
|
|
|
private void CopyTextureToFrameBufferRGB(int drawFramebuffer, int readFramebuffer, TextureView view, ImageCrop crop, Action swapBuffersCallback)
|
|
{
|
|
(int oldDrawFramebufferHandle, int oldReadFramebufferHandle) = ((Pipeline)_renderer.Pipeline).GetBoundFramebuffers();
|
|
|
|
GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, drawFramebuffer);
|
|
GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, readFramebuffer);
|
|
|
|
TextureView viewConverted = view.Format.IsBgr() ? _renderer.TextureCopy.BgraSwap(view) : view;
|
|
|
|
GL.FramebufferTexture(
|
|
FramebufferTarget.ReadFramebuffer,
|
|
FramebufferAttachment.ColorAttachment0,
|
|
viewConverted.Handle,
|
|
0);
|
|
|
|
GL.ReadBuffer(ReadBufferMode.ColorAttachment0);
|
|
|
|
GL.Disable(EnableCap.RasterizerDiscard);
|
|
GL.Disable(IndexedEnableCap.ScissorTest, 0);
|
|
|
|
GL.Clear(ClearBufferMask.ColorBufferBit);
|
|
|
|
int srcX0, srcX1, srcY0, srcY1;
|
|
float scale = view.ScaleFactor;
|
|
|
|
if (crop.Left == 0 && crop.Right == 0)
|
|
{
|
|
srcX0 = 0;
|
|
srcX1 = (int)(view.Width / scale);
|
|
}
|
|
else
|
|
{
|
|
srcX0 = crop.Left;
|
|
srcX1 = crop.Right;
|
|
}
|
|
|
|
if (crop.Top == 0 && crop.Bottom == 0)
|
|
{
|
|
srcY0 = 0;
|
|
srcY1 = (int)(view.Height / scale);
|
|
}
|
|
else
|
|
{
|
|
srcY0 = crop.Top;
|
|
srcY1 = crop.Bottom;
|
|
}
|
|
|
|
if (scale != 1f)
|
|
{
|
|
srcX0 = (int)(srcX0 * scale);
|
|
srcY0 = (int)(srcY0 * scale);
|
|
srcX1 = (int)Math.Ceiling(srcX1 * scale);
|
|
srcY1 = (int)Math.Ceiling(srcY1 * scale);
|
|
}
|
|
|
|
float ratioX = crop.IsStretched ? 1.0f : MathF.Min(1.0f, _height * crop.AspectRatioX / (_width * crop.AspectRatioY));
|
|
float ratioY = crop.IsStretched ? 1.0f : MathF.Min(1.0f, _width * crop.AspectRatioY / (_height * crop.AspectRatioX));
|
|
|
|
int dstWidth = (int)(_width * ratioX);
|
|
int dstHeight = (int)(_height * ratioY);
|
|
|
|
int dstPaddingX = (_width - dstWidth) / 2;
|
|
int dstPaddingY = (_height - dstHeight) / 2;
|
|
|
|
int dstX0 = crop.FlipX ? _width - dstPaddingX : dstPaddingX;
|
|
int dstX1 = crop.FlipX ? dstPaddingX : _width - dstPaddingX;
|
|
|
|
int dstY0 = crop.FlipY ? dstPaddingY : _height - dstPaddingY;
|
|
int dstY1 = crop.FlipY ? _height - dstPaddingY : dstPaddingY;
|
|
|
|
if (ScreenCaptureRequested)
|
|
{
|
|
CaptureFrame(srcX0, srcY0, srcX1, srcY1, view.Format.IsBgr(), crop.FlipX, crop.FlipY);
|
|
|
|
ScreenCaptureRequested = false;
|
|
}
|
|
|
|
GL.BlitFramebuffer(
|
|
srcX0,
|
|
srcY0,
|
|
srcX1,
|
|
srcY1,
|
|
dstX0,
|
|
dstY0,
|
|
dstX1,
|
|
dstY1,
|
|
ClearBufferMask.ColorBufferBit,
|
|
BlitFramebufferFilter.Linear);
|
|
|
|
// Remove Alpha channel
|
|
GL.ColorMask(false, false, false, true);
|
|
GL.ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
|
GL.Clear(ClearBufferMask.ColorBufferBit);
|
|
|
|
for (int i = 0; i < Constants.MaxRenderTargets; i++)
|
|
{
|
|
((Pipeline)_renderer.Pipeline).RestoreComponentMask(i);
|
|
}
|
|
|
|
// Set clip control, viewport and the framebuffer to the output to placate overlays and OBS capture.
|
|
GL.ClipControl(ClipOrigin.LowerLeft, ClipDepthMode.NegativeOneToOne);
|
|
GL.Viewport(0, 0, _width, _height);
|
|
GL.BindFramebuffer(FramebufferTarget.Framebuffer, drawFramebuffer);
|
|
|
|
swapBuffersCallback();
|
|
|
|
GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, oldReadFramebufferHandle);
|
|
GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, oldDrawFramebufferHandle);
|
|
|
|
((Pipeline)_renderer.Pipeline).RestoreClipControl();
|
|
((Pipeline)_renderer.Pipeline).RestoreScissor0Enable();
|
|
((Pipeline)_renderer.Pipeline).RestoreRasterizerDiscard();
|
|
((Pipeline)_renderer.Pipeline).RestoreViewport0();
|
|
|
|
if (viewConverted != view)
|
|
{
|
|
viewConverted.Dispose();
|
|
}
|
|
}
|
|
|
|
private int GetCopyFramebufferHandleLazy()
|
|
{
|
|
int handle = _copyFramebufferHandle;
|
|
|
|
if (handle == 0)
|
|
{
|
|
handle = GL.GenFramebuffer();
|
|
|
|
_copyFramebufferHandle = handle;
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
public void InitializeBackgroundContext(IOpenGLContext baseContext)
|
|
{
|
|
BackgroundContext = new BackgroundContextWorker(baseContext);
|
|
}
|
|
|
|
public void CaptureFrame(int x, int y, int width, int height, bool isBgra, bool flipX, bool flipY)
|
|
{
|
|
long size = Math.Abs(4 * width * height);
|
|
byte[] bitmap = new byte[size];
|
|
|
|
GL.ReadPixels(x, y, width, height, isBgra ? PixelFormat.Bgra : PixelFormat.Rgba, PixelType.UnsignedByte, bitmap);
|
|
|
|
_renderer.OnScreenCaptured(new ScreenCaptureImageInfo(width, height, isBgra, bitmap, flipX, flipY));
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
BackgroundContext.Dispose();
|
|
|
|
if (_copyFramebufferHandle != 0)
|
|
{
|
|
GL.DeleteFramebuffer(_copyFramebufferHandle);
|
|
|
|
_copyFramebufferHandle = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|