mirror of
https://github.com/GreemDev/Ryujinx.git
synced 2024-12-25 19:35:47 +00:00
1f554c1093
* Renaming part 1 * Renaming part 2 * Renaming part 3 * Renaming part 4 * Renaming part 5 * Renaming part 6 * Renaming part 7 * Renaming part 8 * Renaming part 9 * Renaming part 10 * General cleanup * Thought I got all of these * Apply #595 * Additional renaming * Tweaks from feedback * Rename files
549 lines
No EOL
17 KiB
C#
549 lines
No EOL
17 KiB
C#
using OpenTK.Graphics.OpenGL;
|
|
using Ryujinx.Graphics.Texture;
|
|
using System;
|
|
|
|
namespace Ryujinx.Graphics.Gal.OpenGL
|
|
{
|
|
class OglRenderTarget : IGalRenderTarget
|
|
{
|
|
private const int NativeWidth = 1280;
|
|
private const int NativeHeight = 720;
|
|
|
|
private const int RenderTargetsCount = GalPipelineState.RenderTargetsCount;
|
|
|
|
private struct Rect
|
|
{
|
|
public int X { get; private set; }
|
|
public int Y { get; private set; }
|
|
public int Width { get; private set; }
|
|
public int Height { get; private set; }
|
|
|
|
public Rect(int x, int y, int width, int height)
|
|
{
|
|
X = x;
|
|
Y = y;
|
|
Width = width;
|
|
Height = height;
|
|
}
|
|
}
|
|
|
|
private class FrameBufferAttachments
|
|
{
|
|
public int MapCount { get; set; }
|
|
|
|
public DrawBuffersEnum[] Map { get; private set; }
|
|
|
|
public long[] Colors { get; private set; }
|
|
|
|
public long Zeta { get; set; }
|
|
|
|
public FrameBufferAttachments()
|
|
{
|
|
Colors = new long[RenderTargetsCount];
|
|
|
|
Map = new DrawBuffersEnum[RenderTargetsCount];
|
|
}
|
|
|
|
public void Update(FrameBufferAttachments source)
|
|
{
|
|
for (int index = 0; index < RenderTargetsCount; index++)
|
|
{
|
|
Map[index] = source.Map[index];
|
|
|
|
Colors[index] = source.Colors[index];
|
|
}
|
|
|
|
MapCount = source.MapCount;
|
|
Zeta = source.Zeta;
|
|
}
|
|
}
|
|
|
|
private int[] _colorHandles;
|
|
private int _zetaHandle;
|
|
|
|
private OglTexture _texture;
|
|
|
|
private ImageHandler _readTex;
|
|
|
|
private Rect _window;
|
|
|
|
private float[] _viewports;
|
|
|
|
private bool _flipX;
|
|
private bool _flipY;
|
|
|
|
private int _cropTop;
|
|
private int _cropLeft;
|
|
private int _cropRight;
|
|
private int _cropBottom;
|
|
|
|
//This framebuffer is used to attach guest rendertargets,
|
|
//think of it as a dummy OpenGL VAO
|
|
private int _dummyFrameBuffer;
|
|
|
|
//These framebuffers are used to blit images
|
|
private int _srcFb;
|
|
private int _dstFb;
|
|
|
|
private FrameBufferAttachments _attachments;
|
|
private FrameBufferAttachments _oldAttachments;
|
|
|
|
private int _copyPbo;
|
|
|
|
public bool FramebufferSrgb { get; set; }
|
|
|
|
public OglRenderTarget(OglTexture texture)
|
|
{
|
|
_attachments = new FrameBufferAttachments();
|
|
|
|
_oldAttachments = new FrameBufferAttachments();
|
|
|
|
_colorHandles = new int[RenderTargetsCount];
|
|
|
|
_viewports = new float[RenderTargetsCount * 4];
|
|
|
|
_texture = texture;
|
|
|
|
texture.TextureDeleted += TextureDeletionHandler;
|
|
}
|
|
|
|
private void TextureDeletionHandler(object sender, int handle)
|
|
{
|
|
//Texture was deleted, the handle is no longer valid, so
|
|
//reset all uses of this handle on a render target.
|
|
for (int attachment = 0; attachment < RenderTargetsCount; attachment++)
|
|
{
|
|
if (_colorHandles[attachment] == handle)
|
|
{
|
|
_colorHandles[attachment] = 0;
|
|
}
|
|
}
|
|
|
|
if (_zetaHandle == handle)
|
|
{
|
|
_zetaHandle = 0;
|
|
}
|
|
}
|
|
|
|
public void Bind()
|
|
{
|
|
if (_dummyFrameBuffer == 0)
|
|
{
|
|
_dummyFrameBuffer = GL.GenFramebuffer();
|
|
}
|
|
|
|
GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, _dummyFrameBuffer);
|
|
|
|
ImageHandler cachedImage;
|
|
|
|
for (int attachment = 0; attachment < RenderTargetsCount; attachment++)
|
|
{
|
|
long key = _attachments.Colors[attachment];
|
|
|
|
int handle = 0;
|
|
|
|
if (key != 0 && _texture.TryGetImageHandler(key, out cachedImage))
|
|
{
|
|
handle = cachedImage.Handle;
|
|
}
|
|
|
|
if (handle == _colorHandles[attachment])
|
|
{
|
|
continue;
|
|
}
|
|
|
|
GL.FramebufferTexture(
|
|
FramebufferTarget.DrawFramebuffer,
|
|
FramebufferAttachment.ColorAttachment0 + attachment,
|
|
handle,
|
|
0);
|
|
|
|
_colorHandles[attachment] = handle;
|
|
}
|
|
|
|
if (_attachments.Zeta != 0 && _texture.TryGetImageHandler(_attachments.Zeta, out cachedImage))
|
|
{
|
|
if (cachedImage.Handle != _zetaHandle)
|
|
{
|
|
if (cachedImage.HasDepth && cachedImage.HasStencil)
|
|
{
|
|
GL.FramebufferTexture(
|
|
FramebufferTarget.DrawFramebuffer,
|
|
FramebufferAttachment.DepthStencilAttachment,
|
|
cachedImage.Handle,
|
|
0);
|
|
}
|
|
else if (cachedImage.HasDepth)
|
|
{
|
|
GL.FramebufferTexture(
|
|
FramebufferTarget.DrawFramebuffer,
|
|
FramebufferAttachment.DepthAttachment,
|
|
cachedImage.Handle,
|
|
0);
|
|
|
|
GL.FramebufferTexture(
|
|
FramebufferTarget.DrawFramebuffer,
|
|
FramebufferAttachment.StencilAttachment,
|
|
0,
|
|
0);
|
|
}
|
|
else
|
|
{
|
|
throw new InvalidOperationException("Invalid image format \"" + cachedImage.Format + "\" used as Zeta!");
|
|
}
|
|
|
|
_zetaHandle = cachedImage.Handle;
|
|
}
|
|
}
|
|
else if (_zetaHandle != 0)
|
|
{
|
|
GL.FramebufferTexture(
|
|
FramebufferTarget.DrawFramebuffer,
|
|
FramebufferAttachment.DepthStencilAttachment,
|
|
0,
|
|
0);
|
|
|
|
_zetaHandle = 0;
|
|
}
|
|
|
|
if (OglExtension.ViewportArray)
|
|
{
|
|
GL.ViewportArray(0, RenderTargetsCount, _viewports);
|
|
}
|
|
else
|
|
{
|
|
GL.Viewport(
|
|
(int)_viewports[0],
|
|
(int)_viewports[1],
|
|
(int)_viewports[2],
|
|
(int)_viewports[3]);
|
|
}
|
|
|
|
if (_attachments.MapCount > 1)
|
|
{
|
|
GL.DrawBuffers(_attachments.MapCount, _attachments.Map);
|
|
}
|
|
else if (_attachments.MapCount == 1)
|
|
{
|
|
GL.DrawBuffer((DrawBufferMode)_attachments.Map[0]);
|
|
}
|
|
else
|
|
{
|
|
GL.DrawBuffer(DrawBufferMode.None);
|
|
}
|
|
|
|
_oldAttachments.Update(_attachments);
|
|
}
|
|
|
|
public void BindColor(long key, int attachment)
|
|
{
|
|
_attachments.Colors[attachment] = key;
|
|
}
|
|
|
|
public void UnbindColor(int attachment)
|
|
{
|
|
_attachments.Colors[attachment] = 0;
|
|
}
|
|
|
|
public void BindZeta(long key)
|
|
{
|
|
_attachments.Zeta = key;
|
|
}
|
|
|
|
public void UnbindZeta()
|
|
{
|
|
_attachments.Zeta = 0;
|
|
}
|
|
|
|
public void Present(long key)
|
|
{
|
|
_texture.TryGetImageHandler(key, out _readTex);
|
|
}
|
|
|
|
public void SetMap(int[] map)
|
|
{
|
|
if (map != null)
|
|
{
|
|
_attachments.MapCount = map.Length;
|
|
|
|
for (int attachment = 0; attachment < _attachments.MapCount; attachment++)
|
|
{
|
|
_attachments.Map[attachment] = DrawBuffersEnum.ColorAttachment0 + map[attachment];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_attachments.MapCount = 0;
|
|
}
|
|
}
|
|
|
|
public void SetTransform(bool flipX, bool flipY, int top, int left, int right, int bottom)
|
|
{
|
|
_flipX = flipX;
|
|
_flipY = flipY;
|
|
|
|
_cropTop = top;
|
|
_cropLeft = left;
|
|
_cropRight = right;
|
|
_cropBottom = bottom;
|
|
}
|
|
|
|
public void SetWindowSize(int width, int height)
|
|
{
|
|
_window = new Rect(0, 0, width, height);
|
|
}
|
|
|
|
public void SetViewport(int attachment, int x, int y, int width, int height)
|
|
{
|
|
int offset = attachment * 4;
|
|
|
|
_viewports[offset + 0] = x;
|
|
_viewports[offset + 1] = y;
|
|
_viewports[offset + 2] = width;
|
|
_viewports[offset + 3] = height;
|
|
}
|
|
|
|
public void Render()
|
|
{
|
|
if (_readTex == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int srcX0, srcX1, srcY0, srcY1;
|
|
|
|
if (_cropLeft == 0 && _cropRight == 0)
|
|
{
|
|
srcX0 = 0;
|
|
srcX1 = _readTex.Width;
|
|
}
|
|
else
|
|
{
|
|
srcX0 = _cropLeft;
|
|
srcX1 = _cropRight;
|
|
}
|
|
|
|
if (_cropTop == 0 && _cropBottom == 0)
|
|
{
|
|
srcY0 = 0;
|
|
srcY1 = _readTex.Height;
|
|
}
|
|
else
|
|
{
|
|
srcY0 = _cropTop;
|
|
srcY1 = _cropBottom;
|
|
}
|
|
|
|
float ratioX = MathF.Min(1f, (_window.Height * (float)NativeWidth) / ((float)NativeHeight * _window.Width));
|
|
float ratioY = MathF.Min(1f, (_window.Width * (float)NativeHeight) / ((float)NativeWidth * _window.Height));
|
|
|
|
int dstWidth = (int)(_window.Width * ratioX);
|
|
int dstHeight = (int)(_window.Height * ratioY);
|
|
|
|
int dstPaddingX = (_window.Width - dstWidth) / 2;
|
|
int dstPaddingY = (_window.Height - dstHeight) / 2;
|
|
|
|
int dstX0 = _flipX ? _window.Width - dstPaddingX : dstPaddingX;
|
|
int dstX1 = _flipX ? dstPaddingX : _window.Width - dstPaddingX;
|
|
|
|
int dstY0 = _flipY ? dstPaddingY : _window.Height - dstPaddingY;
|
|
int dstY1 = _flipY ? _window.Height - dstPaddingY : dstPaddingY;
|
|
|
|
GL.Viewport(0, 0, _window.Width, _window.Height);
|
|
|
|
if (_srcFb == 0)
|
|
{
|
|
_srcFb = GL.GenFramebuffer();
|
|
}
|
|
|
|
GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, _srcFb);
|
|
GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, 0);
|
|
|
|
GL.FramebufferTexture(FramebufferTarget.ReadFramebuffer, FramebufferAttachment.ColorAttachment0, _readTex.Handle, 0);
|
|
|
|
GL.ReadBuffer(ReadBufferMode.ColorAttachment0);
|
|
|
|
GL.Clear(ClearBufferMask.ColorBufferBit);
|
|
|
|
GL.Disable(EnableCap.FramebufferSrgb);
|
|
|
|
GL.BlitFramebuffer(
|
|
srcX0,
|
|
srcY0,
|
|
srcX1,
|
|
srcY1,
|
|
dstX0,
|
|
dstY0,
|
|
dstX1,
|
|
dstY1,
|
|
ClearBufferMask.ColorBufferBit,
|
|
BlitFramebufferFilter.Linear);
|
|
|
|
if (FramebufferSrgb)
|
|
{
|
|
GL.Enable(EnableCap.FramebufferSrgb);
|
|
}
|
|
}
|
|
|
|
public void Copy(
|
|
GalImage srcImage,
|
|
GalImage dstImage,
|
|
long srcKey,
|
|
long dstKey,
|
|
int srcLayer,
|
|
int dstLayer,
|
|
int srcX0,
|
|
int srcY0,
|
|
int srcX1,
|
|
int srcY1,
|
|
int dstX0,
|
|
int dstY0,
|
|
int dstX1,
|
|
int dstY1)
|
|
{
|
|
if (_texture.TryGetImageHandler(srcKey, out ImageHandler srcTex) &&
|
|
_texture.TryGetImageHandler(dstKey, out ImageHandler dstTex))
|
|
{
|
|
if (srcTex.HasColor != dstTex.HasColor ||
|
|
srcTex.HasDepth != dstTex.HasDepth ||
|
|
srcTex.HasStencil != dstTex.HasStencil)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
if (_srcFb == 0)
|
|
{
|
|
_srcFb = GL.GenFramebuffer();
|
|
}
|
|
|
|
if (_dstFb == 0)
|
|
{
|
|
_dstFb = GL.GenFramebuffer();
|
|
}
|
|
|
|
GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, _srcFb);
|
|
GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, _dstFb);
|
|
|
|
FramebufferAttachment attachment = GetAttachment(srcTex);
|
|
|
|
if (ImageUtils.IsArray(srcImage.TextureTarget) && srcLayer > 0)
|
|
{
|
|
GL.FramebufferTextureLayer(FramebufferTarget.ReadFramebuffer, attachment, srcTex.Handle, 0, srcLayer);
|
|
}
|
|
else
|
|
{
|
|
GL.FramebufferTexture(FramebufferTarget.ReadFramebuffer, attachment, srcTex.Handle, 0);
|
|
}
|
|
|
|
if (ImageUtils.IsArray(dstImage.TextureTarget) && dstLayer > 0)
|
|
{
|
|
GL.FramebufferTextureLayer(FramebufferTarget.DrawFramebuffer, attachment, dstTex.Handle, 0, dstLayer);
|
|
}
|
|
else
|
|
{
|
|
GL.FramebufferTexture(FramebufferTarget.DrawFramebuffer, attachment, dstTex.Handle, 0);
|
|
}
|
|
|
|
|
|
BlitFramebufferFilter filter = BlitFramebufferFilter.Nearest;
|
|
|
|
if (srcTex.HasColor)
|
|
{
|
|
GL.DrawBuffer(DrawBufferMode.ColorAttachment0);
|
|
|
|
filter = BlitFramebufferFilter.Linear;
|
|
}
|
|
|
|
ClearBufferMask mask = GetClearMask(srcTex);
|
|
|
|
GL.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
|
|
}
|
|
}
|
|
|
|
public void Reinterpret(long key, GalImage newImage)
|
|
{
|
|
if (!_texture.TryGetImage(key, out GalImage oldImage))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (newImage.Format == oldImage.Format &&
|
|
newImage.Width == oldImage.Width &&
|
|
newImage.Height == oldImage.Height &&
|
|
newImage.Depth == oldImage.Depth &&
|
|
newImage.LayerCount == oldImage.LayerCount &&
|
|
newImage.TextureTarget == oldImage.TextureTarget)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_copyPbo == 0)
|
|
{
|
|
_copyPbo = GL.GenBuffer();
|
|
}
|
|
|
|
GL.BindBuffer(BufferTarget.PixelPackBuffer, _copyPbo);
|
|
|
|
//The buffer should be large enough to hold the largest texture.
|
|
int bufferSize = Math.Max(ImageUtils.GetSize(oldImage),
|
|
ImageUtils.GetSize(newImage));
|
|
|
|
GL.BufferData(BufferTarget.PixelPackBuffer, bufferSize, IntPtr.Zero, BufferUsageHint.StreamCopy);
|
|
|
|
if (!_texture.TryGetImageHandler(key, out ImageHandler cachedImage))
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
|
|
(_, PixelFormat format, PixelType type) = OglEnumConverter.GetImageFormat(cachedImage.Format);
|
|
|
|
TextureTarget target = ImageUtils.GetTextureTarget(newImage.TextureTarget);
|
|
|
|
GL.BindTexture(target, cachedImage.Handle);
|
|
|
|
GL.GetTexImage(target, 0, format, type, IntPtr.Zero);
|
|
|
|
GL.BindBuffer(BufferTarget.PixelPackBuffer, 0);
|
|
GL.BindBuffer(BufferTarget.PixelUnpackBuffer, _copyPbo);
|
|
|
|
GL.PixelStore(PixelStoreParameter.UnpackRowLength, oldImage.Width);
|
|
|
|
_texture.Create(key, ImageUtils.GetSize(newImage), newImage);
|
|
|
|
GL.PixelStore(PixelStoreParameter.UnpackRowLength, 0);
|
|
|
|
GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0);
|
|
}
|
|
|
|
private static FramebufferAttachment GetAttachment(ImageHandler cachedImage)
|
|
{
|
|
if (cachedImage.HasColor)
|
|
{
|
|
return FramebufferAttachment.ColorAttachment0;
|
|
}
|
|
else if (cachedImage.HasDepth && cachedImage.HasStencil)
|
|
{
|
|
return FramebufferAttachment.DepthStencilAttachment;
|
|
}
|
|
else if (cachedImage.HasDepth)
|
|
{
|
|
return FramebufferAttachment.DepthAttachment;
|
|
}
|
|
else if (cachedImage.HasStencil)
|
|
{
|
|
return FramebufferAttachment.StencilAttachment;
|
|
}
|
|
else
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
|
|
private static ClearBufferMask GetClearMask(ImageHandler cachedImage)
|
|
{
|
|
return (cachedImage.HasColor ? ClearBufferMask.ColorBufferBit : 0) |
|
|
(cachedImage.HasDepth ? ClearBufferMask.DepthBufferBit : 0) |
|
|
(cachedImage.HasStencil ? ClearBufferMask.StencilBufferBit : 0);
|
|
}
|
|
}
|
|
} |