mirror of
https://github.com/ryujinx-mirror/ryujinx.git
synced 2024-12-23 11:05:45 +00:00
b2b736abc2
* Fix typos * Remove unneeded using statements * Enforce var style more * Remove redundant qualifiers * Fix some indentation * Disable naming warnings on files with external enum names * Fix build * Mass find & replace for comments with no spacing * Standardize todo capitalization and for/if spacing
408 lines
15 KiB
C#
408 lines
15 KiB
C#
using OpenTK.Graphics.OpenGL;
|
|
using Ryujinx.Graphics.Texture;
|
|
using System;
|
|
|
|
namespace Ryujinx.Graphics.Gal.OpenGL
|
|
{
|
|
class OglTexture : IGalTexture
|
|
{
|
|
private const long MaxTextureCacheSize = 768 * 1024 * 1024;
|
|
|
|
private OglCachedResource<ImageHandler> _textureCache;
|
|
|
|
public EventHandler<int> TextureDeleted { get; set; }
|
|
|
|
public OglTexture()
|
|
{
|
|
_textureCache = new OglCachedResource<ImageHandler>(DeleteTexture, MaxTextureCacheSize);
|
|
}
|
|
|
|
public void LockCache()
|
|
{
|
|
_textureCache.Lock();
|
|
}
|
|
|
|
public void UnlockCache()
|
|
{
|
|
_textureCache.Unlock();
|
|
}
|
|
|
|
private void DeleteTexture(ImageHandler cachedImage)
|
|
{
|
|
TextureDeleted?.Invoke(this, cachedImage.Handle);
|
|
|
|
GL.DeleteTexture(cachedImage.Handle);
|
|
}
|
|
|
|
public void Create(long key, int size, GalImage image)
|
|
{
|
|
int handle = GL.GenTexture();
|
|
|
|
TextureTarget target = ImageUtils.GetTextureTarget(image.TextureTarget);
|
|
|
|
GL.BindTexture(target, handle);
|
|
|
|
const int level = 0; //TODO: Support mipmap textures.
|
|
const int border = 0;
|
|
|
|
_textureCache.AddOrUpdate(key, new ImageHandler(handle, image), (uint)size);
|
|
|
|
if (ImageUtils.IsCompressed(image.Format))
|
|
{
|
|
throw new InvalidOperationException("Surfaces with compressed formats are not supported!");
|
|
}
|
|
|
|
(PixelInternalFormat internalFmt,
|
|
PixelFormat format,
|
|
PixelType type) = OglEnumConverter.GetImageFormat(image.Format);
|
|
|
|
switch (target)
|
|
{
|
|
case TextureTarget.Texture1D:
|
|
GL.TexImage1D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
border,
|
|
format,
|
|
type,
|
|
IntPtr.Zero);
|
|
break;
|
|
|
|
case TextureTarget.Texture2D:
|
|
GL.TexImage2D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
border,
|
|
format,
|
|
type,
|
|
IntPtr.Zero);
|
|
break;
|
|
case TextureTarget.Texture3D:
|
|
GL.TexImage3D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
image.Depth,
|
|
border,
|
|
format,
|
|
type,
|
|
IntPtr.Zero);
|
|
break;
|
|
// Cube map arrays are just 2D texture arrays with 6 entries
|
|
// per cube map so we can handle them in the same way
|
|
case TextureTarget.TextureCubeMapArray:
|
|
case TextureTarget.Texture2DArray:
|
|
GL.TexImage3D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
image.LayerCount,
|
|
border,
|
|
format,
|
|
type,
|
|
IntPtr.Zero);
|
|
break;
|
|
default:
|
|
throw new NotImplementedException($"Unsupported texture target type: {target}");
|
|
}
|
|
}
|
|
|
|
public void Create(long key, byte[] data, GalImage image)
|
|
{
|
|
int handle = GL.GenTexture();
|
|
|
|
TextureTarget target = ImageUtils.GetTextureTarget(image.TextureTarget);
|
|
|
|
GL.BindTexture(target, handle);
|
|
|
|
const int level = 0; //TODO: Support mipmap textures.
|
|
const int border = 0;
|
|
|
|
_textureCache.AddOrUpdate(key, new ImageHandler(handle, image), (uint)data.Length);
|
|
|
|
if (ImageUtils.IsCompressed(image.Format) && !IsAstc(image.Format))
|
|
{
|
|
InternalFormat internalFmt = OglEnumConverter.GetCompressedImageFormat(image.Format);
|
|
|
|
switch (target)
|
|
{
|
|
case TextureTarget.Texture1D:
|
|
GL.CompressedTexImage1D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
border,
|
|
data.Length,
|
|
data);
|
|
break;
|
|
case TextureTarget.Texture2D:
|
|
GL.CompressedTexImage2D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
border,
|
|
data.Length,
|
|
data);
|
|
break;
|
|
case TextureTarget.Texture3D:
|
|
GL.CompressedTexImage3D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
image.Depth,
|
|
border,
|
|
data.Length,
|
|
data);
|
|
break;
|
|
// Cube map arrays are just 2D texture arrays with 6 entries
|
|
// per cube map so we can handle them in the same way
|
|
case TextureTarget.TextureCubeMapArray:
|
|
case TextureTarget.Texture2DArray:
|
|
GL.CompressedTexImage3D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
image.LayerCount,
|
|
border,
|
|
data.Length,
|
|
data);
|
|
break;
|
|
case TextureTarget.TextureCubeMap:
|
|
Span<byte> array = new Span<byte>(data);
|
|
|
|
int faceSize = ImageUtils.GetSize(image) / 6;
|
|
|
|
for (int Face = 0; Face < 6; Face++)
|
|
{
|
|
GL.CompressedTexImage2D(
|
|
TextureTarget.TextureCubeMapPositiveX + Face,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
border,
|
|
faceSize,
|
|
array.Slice(Face * faceSize, faceSize).ToArray());
|
|
}
|
|
break;
|
|
default:
|
|
throw new NotImplementedException($"Unsupported texture target type: {target}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// TODO: Use KHR_texture_compression_astc_hdr when available
|
|
if (IsAstc(image.Format))
|
|
{
|
|
int textureBlockWidth = ImageUtils.GetBlockWidth(image.Format);
|
|
int textureBlockHeight = ImageUtils.GetBlockHeight(image.Format);
|
|
int textureBlockDepth = ImageUtils.GetBlockDepth(image.Format);
|
|
|
|
data = AstcDecoder.DecodeToRgba8888(
|
|
data,
|
|
textureBlockWidth,
|
|
textureBlockHeight,
|
|
textureBlockDepth,
|
|
image.Width,
|
|
image.Height,
|
|
image.Depth);
|
|
|
|
image.Format = GalImageFormat.Rgba8 | (image.Format & GalImageFormat.TypeMask);
|
|
}
|
|
|
|
(PixelInternalFormat internalFmt,
|
|
PixelFormat format,
|
|
PixelType type) = OglEnumConverter.GetImageFormat(image.Format);
|
|
|
|
|
|
switch (target)
|
|
{
|
|
case TextureTarget.Texture1D:
|
|
GL.TexImage1D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
border,
|
|
format,
|
|
type,
|
|
data);
|
|
break;
|
|
case TextureTarget.Texture2D:
|
|
GL.TexImage2D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
border,
|
|
format,
|
|
type,
|
|
data);
|
|
break;
|
|
case TextureTarget.Texture3D:
|
|
GL.TexImage3D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
image.Depth,
|
|
border,
|
|
format,
|
|
type,
|
|
data);
|
|
break;
|
|
// Cube map arrays are just 2D texture arrays with 6 entries
|
|
// per cube map so we can handle them in the same way
|
|
case TextureTarget.TextureCubeMapArray:
|
|
case TextureTarget.Texture2DArray:
|
|
GL.TexImage3D(
|
|
target,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
image.LayerCount,
|
|
border,
|
|
format,
|
|
type,
|
|
data);
|
|
break;
|
|
case TextureTarget.TextureCubeMap:
|
|
Span<byte> array = new Span<byte>(data);
|
|
|
|
int faceSize = ImageUtils.GetSize(image) / 6;
|
|
|
|
for (int face = 0; face < 6; face++)
|
|
{
|
|
GL.TexImage2D(
|
|
TextureTarget.TextureCubeMapPositiveX + face,
|
|
level,
|
|
internalFmt,
|
|
image.Width,
|
|
image.Height,
|
|
border,
|
|
format,
|
|
type,
|
|
array.Slice(face * faceSize, faceSize).ToArray());
|
|
}
|
|
break;
|
|
default:
|
|
throw new NotImplementedException($"Unsupported texture target type: {target}");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool IsAstc(GalImageFormat format)
|
|
{
|
|
format &= GalImageFormat.FormatMask;
|
|
|
|
return format > GalImageFormat.Astc2DStart && format < GalImageFormat.Astc2DEnd;
|
|
}
|
|
|
|
public bool TryGetImage(long key, out GalImage image)
|
|
{
|
|
if (_textureCache.TryGetValue(key, out ImageHandler cachedImage))
|
|
{
|
|
image = cachedImage.Image;
|
|
|
|
return true;
|
|
}
|
|
|
|
image = default(GalImage);
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool TryGetImageHandler(long key, out ImageHandler cachedImage)
|
|
{
|
|
if (_textureCache.TryGetValue(key, out cachedImage))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
cachedImage = null;
|
|
|
|
return false;
|
|
}
|
|
|
|
public void Bind(long key, int index, GalImage image)
|
|
{
|
|
if (_textureCache.TryGetValue(key, out ImageHandler cachedImage))
|
|
{
|
|
GL.ActiveTexture(TextureUnit.Texture0 + index);
|
|
|
|
TextureTarget target = ImageUtils.GetTextureTarget(image.TextureTarget);
|
|
|
|
GL.BindTexture(target, cachedImage.Handle);
|
|
|
|
int[] swizzleRgba = new int[]
|
|
{
|
|
(int)OglEnumConverter.GetTextureSwizzle(image.XSource),
|
|
(int)OglEnumConverter.GetTextureSwizzle(image.YSource),
|
|
(int)OglEnumConverter.GetTextureSwizzle(image.ZSource),
|
|
(int)OglEnumConverter.GetTextureSwizzle(image.WSource)
|
|
};
|
|
|
|
GL.TexParameter(target, TextureParameterName.TextureSwizzleRgba, swizzleRgba);
|
|
}
|
|
}
|
|
|
|
public void SetSampler(GalImage image, GalTextureSampler sampler)
|
|
{
|
|
int wrapS = (int)OglEnumConverter.GetTextureWrapMode(sampler.AddressU);
|
|
int wrapT = (int)OglEnumConverter.GetTextureWrapMode(sampler.AddressV);
|
|
int wrapR = (int)OglEnumConverter.GetTextureWrapMode(sampler.AddressP);
|
|
|
|
int minFilter = (int)OglEnumConverter.GetTextureMinFilter(sampler.MinFilter, sampler.MipFilter);
|
|
int magFilter = (int)OglEnumConverter.GetTextureMagFilter(sampler.MagFilter);
|
|
|
|
TextureTarget target = ImageUtils.GetTextureTarget(image.TextureTarget);
|
|
|
|
GL.TexParameter(target, TextureParameterName.TextureWrapS, wrapS);
|
|
GL.TexParameter(target, TextureParameterName.TextureWrapT, wrapT);
|
|
GL.TexParameter(target, TextureParameterName.TextureWrapR, wrapR);
|
|
|
|
GL.TexParameter(target, TextureParameterName.TextureMinFilter, minFilter);
|
|
GL.TexParameter(target, TextureParameterName.TextureMagFilter, magFilter);
|
|
|
|
float[] color = new float[]
|
|
{
|
|
sampler.BorderColor.Red,
|
|
sampler.BorderColor.Green,
|
|
sampler.BorderColor.Blue,
|
|
sampler.BorderColor.Alpha
|
|
};
|
|
|
|
GL.TexParameter(target, TextureParameterName.TextureBorderColor, color);
|
|
|
|
if (sampler.DepthCompare)
|
|
{
|
|
GL.TexParameter(target, TextureParameterName.TextureCompareMode, (int)All.CompareRToTexture);
|
|
GL.TexParameter(target, TextureParameterName.TextureCompareFunc, (int)OglEnumConverter.GetDepthCompareFunc(sampler.DepthCompareFunc));
|
|
}
|
|
else
|
|
{
|
|
GL.TexParameter(target, TextureParameterName.TextureCompareMode, (int)All.None);
|
|
GL.TexParameter(target, TextureParameterName.TextureCompareFunc, (int)All.Never);
|
|
}
|
|
}
|
|
}
|
|
}
|