mirror of
https://git.naxdy.org/Mirror/Ryujinx.git
synced 2025-01-08 00:43:04 +00:00
Update Fork
This commit is contained in:
John Clemis
GitHub
commit
2e8c26117f
15 changed files with 437 additions and 251 deletions
|
|
@ -641,106 +641,34 @@ namespace ChocolArm64.Instruction
|
|||
|
||||
public static void Frecpe_S(AILEmitterCtx Context)
|
||||
{
|
||||
EmitFrecpe(Context, 0, Scalar: true);
|
||||
EmitScalarUnaryOpF(Context, () =>
|
||||
{
|
||||
EmitUnarySoftFloatCall(Context, nameof(ASoftFloat.RecipEstimate));
|
||||
});
|
||||
}
|
||||
|
||||
public static void Frecpe_V(AILEmitterCtx Context)
|
||||
{
|
||||
AOpCodeSimd Op = (AOpCodeSimd)Context.CurrOp;
|
||||
|
||||
int SizeF = Op.Size & 1;
|
||||
|
||||
int Bytes = Context.CurrOp.GetBitsCount() >> 3;
|
||||
|
||||
for (int Index = 0; Index < Bytes >> SizeF + 2; Index++)
|
||||
EmitVectorUnaryOpF(Context, () =>
|
||||
{
|
||||
EmitFrecpe(Context, Index, Scalar: false);
|
||||
}
|
||||
|
||||
if (Op.RegisterSize == ARegisterSize.SIMD64)
|
||||
{
|
||||
EmitVectorZeroUpper(Context, Op.Rd);
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitFrecpe(AILEmitterCtx Context, int Index, bool Scalar)
|
||||
{
|
||||
AOpCodeSimd Op = (AOpCodeSimd)Context.CurrOp;
|
||||
|
||||
int SizeF = Op.Size & 1;
|
||||
|
||||
if (SizeF == 0)
|
||||
{
|
||||
Context.EmitLdc_R4(1);
|
||||
}
|
||||
else /* if (SizeF == 1) */
|
||||
{
|
||||
Context.EmitLdc_R8(1);
|
||||
}
|
||||
|
||||
EmitVectorExtractF(Context, Op.Rn, Index, SizeF);
|
||||
|
||||
Context.Emit(OpCodes.Div);
|
||||
|
||||
if (Scalar)
|
||||
{
|
||||
EmitVectorZeroAll(Context, Op.Rd);
|
||||
}
|
||||
|
||||
EmitVectorInsertF(Context, Op.Rd, Index, SizeF);
|
||||
EmitUnarySoftFloatCall(Context, nameof(ASoftFloat.RecipEstimate));
|
||||
});
|
||||
}
|
||||
|
||||
public static void Frecps_S(AILEmitterCtx Context)
|
||||
{
|
||||
EmitFrecps(Context, 0, Scalar: true);
|
||||
EmitScalarBinaryOpF(Context, () =>
|
||||
{
|
||||
EmitBinarySoftFloatCall(Context, nameof(ASoftFloat.RecipStep));
|
||||
});
|
||||
}
|
||||
|
||||
public static void Frecps_V(AILEmitterCtx Context)
|
||||
{
|
||||
AOpCodeSimd Op = (AOpCodeSimd)Context.CurrOp;
|
||||
|
||||
int SizeF = Op.Size & 1;
|
||||
|
||||
int Bytes = Context.CurrOp.GetBitsCount() >> 3;
|
||||
|
||||
for (int Index = 0; Index < Bytes >> SizeF + 2; Index++)
|
||||
EmitVectorBinaryOpF(Context, () =>
|
||||
{
|
||||
EmitFrecps(Context, Index, Scalar: false);
|
||||
}
|
||||
|
||||
if (Op.RegisterSize == ARegisterSize.SIMD64)
|
||||
{
|
||||
EmitVectorZeroUpper(Context, Op.Rd);
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitFrecps(AILEmitterCtx Context, int Index, bool Scalar)
|
||||
{
|
||||
AOpCodeSimdReg Op = (AOpCodeSimdReg)Context.CurrOp;
|
||||
|
||||
int SizeF = Op.Size & 1;
|
||||
|
||||
if (SizeF == 0)
|
||||
{
|
||||
Context.EmitLdc_R4(2);
|
||||
}
|
||||
else /* if (SizeF == 1) */
|
||||
{
|
||||
Context.EmitLdc_R8(2);
|
||||
}
|
||||
|
||||
EmitVectorExtractF(Context, Op.Rn, Index, SizeF);
|
||||
EmitVectorExtractF(Context, Op.Rm, Index, SizeF);
|
||||
|
||||
Context.Emit(OpCodes.Mul);
|
||||
Context.Emit(OpCodes.Sub);
|
||||
|
||||
if (Scalar)
|
||||
{
|
||||
EmitVectorZeroAll(Context, Op.Rd);
|
||||
}
|
||||
|
||||
EmitVectorInsertF(Context, Op.Rd, Index, SizeF);
|
||||
EmitBinarySoftFloatCall(Context, nameof(ASoftFloat.RecipStep));
|
||||
});
|
||||
}
|
||||
|
||||
public static void Frinta_S(AILEmitterCtx Context)
|
||||
|
|
|
|||
|
|
@ -253,6 +253,26 @@ namespace ChocolArm64.Instruction
|
|||
Context.EmitCall(MthdInfo);
|
||||
}
|
||||
|
||||
public static void EmitBinarySoftFloatCall(AILEmitterCtx Context, string Name)
|
||||
{
|
||||
IAOpCodeSimd Op = (IAOpCodeSimd)Context.CurrOp;
|
||||
|
||||
int SizeF = Op.Size & 1;
|
||||
|
||||
MethodInfo MthdInfo;
|
||||
|
||||
if (SizeF == 0)
|
||||
{
|
||||
MthdInfo = typeof(ASoftFloat).GetMethod(Name, new Type[] { typeof(float), typeof(float) });
|
||||
}
|
||||
else /* if (SizeF == 1) */
|
||||
{
|
||||
MthdInfo = typeof(ASoftFloat).GetMethod(Name, new Type[] { typeof(double), typeof(double) });
|
||||
}
|
||||
|
||||
Context.EmitCall(MthdInfo);
|
||||
}
|
||||
|
||||
public static void EmitScalarBinaryOpByElemF(AILEmitterCtx Context, Action Emit)
|
||||
{
|
||||
AOpCodeSimdRegElemF Op = (AOpCodeSimdRegElemF)Context.CurrOp;
|
||||
|
|
|
|||
|
|
@ -7,8 +7,10 @@ namespace ChocolArm64.Instruction
|
|||
static ASoftFloat()
|
||||
{
|
||||
InvSqrtEstimateTable = BuildInvSqrtEstimateTable();
|
||||
RecipEstimateTable = BuildRecipEstimateTable();
|
||||
}
|
||||
|
||||
private static readonly byte[] RecipEstimateTable;
|
||||
private static readonly byte[] InvSqrtEstimateTable;
|
||||
|
||||
private static byte[] BuildInvSqrtEstimateTable()
|
||||
|
|
@ -38,6 +40,22 @@ namespace ChocolArm64.Instruction
|
|||
return Table;
|
||||
}
|
||||
|
||||
private static byte[] BuildRecipEstimateTable()
|
||||
{
|
||||
byte[] Table = new byte[256];
|
||||
for (ulong index = 0; index < 256; index++)
|
||||
{
|
||||
ulong a = index | 0x100;
|
||||
|
||||
a = (a << 1) + 1;
|
||||
ulong b = 0x80000 / a;
|
||||
b = (b + 1) >> 1;
|
||||
|
||||
Table[index] = (byte)(b & 0xFF);
|
||||
}
|
||||
return Table;
|
||||
}
|
||||
|
||||
public static float InvSqrtEstimate(float x)
|
||||
{
|
||||
return (float)InvSqrtEstimate((double)x);
|
||||
|
|
@ -50,14 +68,8 @@ namespace ChocolArm64.Instruction
|
|||
long x_exp = (long)((x_bits >> 52) & 0x7FF);
|
||||
ulong scaled = x_bits & ((1ul << 52) - 1);
|
||||
|
||||
if (x_exp == 0x7ff)
|
||||
if (x_exp == 0x7FF && scaled != 0)
|
||||
{
|
||||
if (scaled == 0)
|
||||
{
|
||||
// Infinity -> Zero
|
||||
return BitConverter.Int64BitsToDouble((long)x_sign);
|
||||
}
|
||||
|
||||
// NaN
|
||||
return BitConverter.Int64BitsToDouble((long)(x_bits | 0x0008000000000000));
|
||||
}
|
||||
|
|
@ -79,6 +91,18 @@ namespace ChocolArm64.Instruction
|
|||
scaled <<= 1;
|
||||
}
|
||||
|
||||
if (x_sign != 0)
|
||||
{
|
||||
// Negative -> NaN
|
||||
return BitConverter.Int64BitsToDouble((long)0x7ff8000000000000);
|
||||
}
|
||||
|
||||
if (x_exp == 0x7ff && scaled == 0)
|
||||
{
|
||||
// Infinity -> Zero
|
||||
return BitConverter.Int64BitsToDouble((long)x_sign);
|
||||
}
|
||||
|
||||
if (((ulong)x_exp & 1) == 1)
|
||||
{
|
||||
scaled >>= 45;
|
||||
|
|
@ -99,5 +123,107 @@ namespace ChocolArm64.Instruction
|
|||
ulong result = x_sign | (result_exp << 52) | fraction;
|
||||
return BitConverter.Int64BitsToDouble((long)result);
|
||||
}
|
||||
|
||||
public static float RecipEstimate(float x)
|
||||
{
|
||||
return (float)RecipEstimate((double)x);
|
||||
}
|
||||
|
||||
public static double RecipEstimate(double x)
|
||||
{
|
||||
ulong x_bits = (ulong)BitConverter.DoubleToInt64Bits(x);
|
||||
ulong x_sign = x_bits & 0x8000000000000000;
|
||||
ulong x_exp = (x_bits >> 52) & 0x7FF;
|
||||
ulong scaled = x_bits & ((1ul << 52) - 1);
|
||||
|
||||
if (x_exp >= 2045)
|
||||
{
|
||||
if (x_exp == 0x7ff && scaled != 0)
|
||||
{
|
||||
// NaN
|
||||
return BitConverter.Int64BitsToDouble((long)(x_bits | 0x0008000000000000));
|
||||
}
|
||||
|
||||
// Infinity, or Out of range -> Zero
|
||||
return BitConverter.Int64BitsToDouble((long)x_sign);
|
||||
}
|
||||
|
||||
if (x_exp == 0)
|
||||
{
|
||||
if (scaled == 0)
|
||||
{
|
||||
// Zero -> Infinity
|
||||
return BitConverter.Int64BitsToDouble((long)(x_sign | 0x7ff0000000000000));
|
||||
}
|
||||
|
||||
// Denormal
|
||||
if ((scaled & (1ul << 51)) == 0)
|
||||
{
|
||||
x_exp = ~0ul;
|
||||
scaled <<= 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
scaled <<= 1;
|
||||
}
|
||||
}
|
||||
|
||||
scaled >>= 44;
|
||||
scaled &= 0xFF;
|
||||
|
||||
ulong result_exp = (2045 - x_exp) & 0x7FF;
|
||||
ulong estimate = (ulong)RecipEstimateTable[scaled];
|
||||
ulong fraction = estimate << 44;
|
||||
|
||||
if (result_exp == 0)
|
||||
{
|
||||
fraction >>= 1;
|
||||
fraction |= 1ul << 51;
|
||||
}
|
||||
else if (result_exp == 0x7FF)
|
||||
{
|
||||
result_exp = 0;
|
||||
fraction >>= 2;
|
||||
fraction |= 1ul << 50;
|
||||
}
|
||||
|
||||
ulong result = x_sign | (result_exp << 52) | fraction;
|
||||
return BitConverter.Int64BitsToDouble((long)result);
|
||||
}
|
||||
|
||||
public static float RecipStep(float op1, float op2)
|
||||
{
|
||||
return (float)RecipStep((double)op1, (double)op2);
|
||||
}
|
||||
|
||||
public static double RecipStep(double op1, double op2)
|
||||
{
|
||||
op1 = -op1;
|
||||
|
||||
ulong op1_bits = (ulong)BitConverter.DoubleToInt64Bits(op1);
|
||||
ulong op2_bits = (ulong)BitConverter.DoubleToInt64Bits(op2);
|
||||
|
||||
ulong op1_sign = op1_bits & 0x8000000000000000;
|
||||
ulong op2_sign = op2_bits & 0x8000000000000000;
|
||||
ulong op1_other = op1_bits & 0x7FFFFFFFFFFFFFFF;
|
||||
ulong op2_other = op2_bits & 0x7FFFFFFFFFFFFFFF;
|
||||
|
||||
bool inf1 = op1_other == 0x7ff0000000000000;
|
||||
bool inf2 = op2_other == 0x7ff0000000000000;
|
||||
bool zero1 = op1_other == 0;
|
||||
bool zero2 = op2_other == 0;
|
||||
|
||||
if ((inf1 && zero2) || (zero1 && inf2))
|
||||
{
|
||||
return 2.0;
|
||||
}
|
||||
else if (inf1 || inf2)
|
||||
{
|
||||
// Infinity
|
||||
return BitConverter.Int64BitsToDouble((long)(0x7ff0000000000000 | (op1_sign ^ op2_sign)));
|
||||
}
|
||||
|
||||
return 2.0 + op1 * op2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -33,19 +33,25 @@ namespace ChocolArm64.Memory
|
|||
|
||||
private byte* RamPtr;
|
||||
|
||||
private int HostPageSize;
|
||||
|
||||
public AMemory()
|
||||
{
|
||||
Manager = new AMemoryMgr();
|
||||
|
||||
Monitors = new Dictionary<int, ArmMonitor>();
|
||||
|
||||
IntPtr Size = (IntPtr)AMemoryMgr.RamSize + AMemoryMgr.PageSize;
|
||||
|
||||
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
|
||||
{
|
||||
Ram = AMemoryWin32.Allocate((IntPtr)AMemoryMgr.RamSize + AMemoryMgr.PageSize);
|
||||
Ram = AMemoryWin32.Allocate(Size);
|
||||
|
||||
HostPageSize = AMemoryWin32.GetPageSize(Ram, Size);
|
||||
}
|
||||
else
|
||||
{
|
||||
Ram = Marshal.AllocHGlobal((IntPtr)AMemoryMgr.RamSize + AMemoryMgr.PageSize);
|
||||
Ram = Marshal.AllocHGlobal(Size);
|
||||
}
|
||||
|
||||
RamPtr = (byte*)Ram;
|
||||
|
|
@ -149,49 +155,53 @@ namespace ChocolArm64.Memory
|
|||
}
|
||||
}
|
||||
|
||||
public long GetHostPageSize()
|
||||
public int GetHostPageSize()
|
||||
{
|
||||
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
|
||||
{
|
||||
return AMemoryMgr.PageSize;
|
||||
}
|
||||
|
||||
IntPtr MemAddress = new IntPtr(RamPtr);
|
||||
IntPtr MemSize = new IntPtr(AMemoryMgr.RamSize);
|
||||
|
||||
long PageSize = AMemoryWin32.IsRegionModified(MemAddress, MemSize, Reset: false);
|
||||
|
||||
if (PageSize < 1)
|
||||
{
|
||||
throw new InvalidOperationException();
|
||||
}
|
||||
|
||||
return PageSize;
|
||||
return HostPageSize;
|
||||
}
|
||||
|
||||
public bool IsRegionModified(long Position, long Size)
|
||||
public bool[] IsRegionModified(long Position, long Size)
|
||||
{
|
||||
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
|
||||
{
|
||||
return true;
|
||||
return null;
|
||||
}
|
||||
|
||||
long EndPos = Position + Size;
|
||||
|
||||
if ((ulong)EndPos < (ulong)Position)
|
||||
{
|
||||
return false;
|
||||
return null;
|
||||
}
|
||||
|
||||
if ((ulong)EndPos > AMemoryMgr.RamSize)
|
||||
{
|
||||
return false;
|
||||
return null;
|
||||
}
|
||||
|
||||
IntPtr MemAddress = new IntPtr(RamPtr + Position);
|
||||
IntPtr MemSize = new IntPtr(Size);
|
||||
|
||||
return AMemoryWin32.IsRegionModified(MemAddress, MemSize, Reset: true) != 0;
|
||||
int HostPageMask = HostPageSize - 1;
|
||||
|
||||
Position &= ~HostPageMask;
|
||||
|
||||
Size = EndPos - Position;
|
||||
|
||||
IntPtr[] Addresses = new IntPtr[(Size + HostPageMask) / HostPageSize];
|
||||
|
||||
AMemoryWin32.IsRegionModified(MemAddress, MemSize, Addresses, out int Count);
|
||||
|
||||
bool[] Modified = new bool[Addresses.Length];
|
||||
|
||||
for (int Index = 0; Index < Count; Index++)
|
||||
{
|
||||
long VA = Addresses[Index].ToInt64() - Ram.ToInt64();
|
||||
|
||||
Modified[(VA - Position) / HostPageSize] = true;
|
||||
}
|
||||
|
||||
return Modified;
|
||||
}
|
||||
|
||||
public sbyte ReadSByte(long Position)
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ namespace ChocolArm64.Memory
|
|||
VirtualFree(Address, IntPtr.Zero, MEM_RELEASE);
|
||||
}
|
||||
|
||||
public unsafe static long IsRegionModified(IntPtr Address, IntPtr Size, bool Reset)
|
||||
public unsafe static int GetPageSize(IntPtr Address, IntPtr Size)
|
||||
{
|
||||
IntPtr[] Addresses = new IntPtr[1];
|
||||
|
||||
|
|
@ -57,17 +57,36 @@ namespace ChocolArm64.Memory
|
|||
|
||||
long Granularity;
|
||||
|
||||
int Flags = Reset ? WRITE_WATCH_FLAG_RESET : 0;
|
||||
|
||||
GetWriteWatch(
|
||||
Flags,
|
||||
0,
|
||||
Address,
|
||||
Size,
|
||||
Addresses,
|
||||
&Count,
|
||||
&Granularity);
|
||||
|
||||
return Count != 0 ? Granularity : 0;
|
||||
return (int)Granularity;
|
||||
}
|
||||
|
||||
public unsafe static void IsRegionModified(
|
||||
IntPtr Address,
|
||||
IntPtr Size,
|
||||
IntPtr[] Addresses,
|
||||
out int AddrCount)
|
||||
{
|
||||
long Count = Addresses.Length;
|
||||
|
||||
long Granularity;
|
||||
|
||||
GetWriteWatch(
|
||||
WRITE_WATCH_FLAG_RESET,
|
||||
Address,
|
||||
Size,
|
||||
Addresses,
|
||||
&Count,
|
||||
&Granularity);
|
||||
|
||||
AddrCount = (int)Count;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -36,6 +36,12 @@ namespace Ryujinx.Graphics.Gal
|
|||
|
||||
void SetClearStencil(int Stencil);
|
||||
|
||||
void EnablePrimitiveRestart();
|
||||
|
||||
void DisablePrimitiveRestart();
|
||||
|
||||
void SetPrimitiveRestartIndex(uint Index);
|
||||
|
||||
void CreateVbo(long Key, byte[] Buffer);
|
||||
|
||||
void CreateIbo(long Key, byte[] Buffer);
|
||||
|
|
|
|||
|
|
@ -184,6 +184,21 @@ namespace Ryujinx.Graphics.Gal.OpenGL
|
|||
GL.ClearStencil(Stencil);
|
||||
}
|
||||
|
||||
public void EnablePrimitiveRestart()
|
||||
{
|
||||
GL.Enable(EnableCap.PrimitiveRestart);
|
||||
}
|
||||
|
||||
public void DisablePrimitiveRestart()
|
||||
{
|
||||
GL.Disable(EnableCap.PrimitiveRestart);
|
||||
}
|
||||
|
||||
public void SetPrimitiveRestartIndex(uint Index)
|
||||
{
|
||||
GL.PrimitiveRestartIndex(Index);
|
||||
}
|
||||
|
||||
public void CreateVbo(long Key, byte[] Buffer)
|
||||
{
|
||||
int Handle = GL.GenBuffer();
|
||||
|
|
|
|||
|
|
@ -85,6 +85,7 @@ namespace Ryujinx.HLE.Gpu.Engines
|
|||
SetDepth();
|
||||
SetStencil();
|
||||
SetAlphaBlending();
|
||||
SetPrimitiveRestart();
|
||||
|
||||
UploadTextures(Vmm, Keys);
|
||||
UploadUniforms(Vmm);
|
||||
|
|
@ -389,6 +390,29 @@ namespace Ryujinx.HLE.Gpu.Engines
|
|||
}
|
||||
}
|
||||
|
||||
private void SetPrimitiveRestart()
|
||||
{
|
||||
bool Enable = (ReadRegister(NvGpuEngine3dReg.PrimRestartEnable) & 1) != 0;
|
||||
|
||||
if (Enable)
|
||||
{
|
||||
Gpu.Renderer.Rasterizer.EnablePrimitiveRestart();
|
||||
}
|
||||
else
|
||||
{
|
||||
Gpu.Renderer.Rasterizer.DisablePrimitiveRestart();
|
||||
}
|
||||
|
||||
if (!Enable)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
uint Index = (uint)ReadRegister(NvGpuEngine3dReg.PrimRestartIndex);
|
||||
|
||||
Gpu.Renderer.Rasterizer.SetPrimitiveRestartIndex(Index);
|
||||
}
|
||||
|
||||
private void UploadTextures(NvGpuVmm Vmm, long[] Keys)
|
||||
{
|
||||
long BaseShPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.ShaderAddress);
|
||||
|
|
@ -440,19 +464,17 @@ namespace Ryujinx.HLE.Gpu.Engines
|
|||
|
||||
GalTextureSampler Sampler = TextureFactory.MakeSampler(Gpu, Vmm, TscPosition);
|
||||
|
||||
long TextureAddress = Vmm.ReadInt64(TicPosition + 4) & 0xffffffffffff;
|
||||
long Key = Vmm.ReadInt64(TicPosition + 4) & 0xffffffffffff;
|
||||
|
||||
long Key = TextureAddress;
|
||||
Key = Vmm.GetPhysicalAddress(Key);
|
||||
|
||||
TextureAddress = Vmm.GetPhysicalAddress(TextureAddress);
|
||||
|
||||
if (IsFrameBufferPosition(TextureAddress))
|
||||
if (IsFrameBufferPosition(Key))
|
||||
{
|
||||
//This texture is a frame buffer texture,
|
||||
//we shouldn't read anything from memory and bind
|
||||
//the frame buffer texture instead, since we're not
|
||||
//really writing anything to memory.
|
||||
Gpu.Renderer.FrameBuffer.BindTexture(TextureAddress, TexIndex);
|
||||
Gpu.Renderer.FrameBuffer.BindTexture(Key, TexIndex);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -520,6 +542,8 @@ namespace Ryujinx.HLE.Gpu.Engines
|
|||
{
|
||||
long IndexPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.IndexArrayAddress);
|
||||
|
||||
long IboKey = Vmm.GetPhysicalAddress(IndexPosition);
|
||||
|
||||
int IndexEntryFmt = ReadRegister(NvGpuEngine3dReg.IndexArrayFormat);
|
||||
int IndexFirst = ReadRegister(NvGpuEngine3dReg.IndexBatchFirst);
|
||||
int IndexCount = ReadRegister(NvGpuEngine3dReg.IndexBatchCount);
|
||||
|
|
@ -537,16 +561,16 @@ namespace Ryujinx.HLE.Gpu.Engines
|
|||
{
|
||||
int IbSize = IndexCount * IndexEntrySize;
|
||||
|
||||
bool IboCached = Gpu.Renderer.Rasterizer.IsIboCached(IndexPosition, (uint)IbSize);
|
||||
bool IboCached = Gpu.Renderer.Rasterizer.IsIboCached(IboKey, (uint)IbSize);
|
||||
|
||||
if (!IboCached || Vmm.IsRegionModified(IndexPosition, (uint)IbSize, NvGpuBufferType.Index))
|
||||
if (!IboCached || Vmm.IsRegionModified(IboKey, (uint)IbSize, NvGpuBufferType.Index))
|
||||
{
|
||||
byte[] Data = Vmm.ReadBytes(IndexPosition, (uint)IbSize);
|
||||
|
||||
Gpu.Renderer.Rasterizer.CreateIbo(IndexPosition, Data);
|
||||
Gpu.Renderer.Rasterizer.CreateIbo(IboKey, Data);
|
||||
}
|
||||
|
||||
Gpu.Renderer.Rasterizer.SetIndexArray(IndexPosition, IbSize, IndexFormat);
|
||||
Gpu.Renderer.Rasterizer.SetIndexArray(IboKey, IbSize, IndexFormat);
|
||||
}
|
||||
|
||||
List<GalVertexAttrib>[] Attribs = new List<GalVertexAttrib>[32];
|
||||
|
|
@ -595,20 +619,22 @@ namespace Ryujinx.HLE.Gpu.Engines
|
|||
continue;
|
||||
}
|
||||
|
||||
long VboKey = Vmm.GetPhysicalAddress(VertexPosition);
|
||||
|
||||
int Stride = Control & 0xfff;
|
||||
|
||||
long VbSize = (VertexEndPos - VertexPosition) + 1;
|
||||
|
||||
bool VboCached = Gpu.Renderer.Rasterizer.IsVboCached(VertexPosition, VbSize);
|
||||
bool VboCached = Gpu.Renderer.Rasterizer.IsVboCached(VboKey, VbSize);
|
||||
|
||||
if (!VboCached || Vmm.IsRegionModified(VertexPosition, VbSize, NvGpuBufferType.Vertex))
|
||||
if (!VboCached || Vmm.IsRegionModified(VboKey, VbSize, NvGpuBufferType.Vertex))
|
||||
{
|
||||
byte[] Data = Vmm.ReadBytes(VertexPosition, VbSize);
|
||||
|
||||
Gpu.Renderer.Rasterizer.CreateVbo(VertexPosition, Data);
|
||||
Gpu.Renderer.Rasterizer.CreateVbo(VboKey, Data);
|
||||
}
|
||||
|
||||
Gpu.Renderer.Rasterizer.SetVertexArray(Index, Stride, VertexPosition, Attribs[Index].ToArray());
|
||||
Gpu.Renderer.Rasterizer.SetVertexArray(Index, Stride, VboKey, Attribs[Index].ToArray());
|
||||
}
|
||||
|
||||
GalPrimitiveType PrimType = (GalPrimitiveType)(PrimCtrl & 0xffff);
|
||||
|
|
@ -617,7 +643,7 @@ namespace Ryujinx.HLE.Gpu.Engines
|
|||
{
|
||||
int VertexBase = ReadRegister(NvGpuEngine3dReg.VertexArrayElemBase);
|
||||
|
||||
Gpu.Renderer.Rasterizer.DrawElements(IndexPosition, IndexFirst, VertexBase, PrimType);
|
||||
Gpu.Renderer.Rasterizer.DrawElements(IboKey, IndexFirst, VertexBase, PrimType);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
|||
|
|
@ -50,6 +50,8 @@ namespace Ryujinx.HLE.Gpu.Engines
|
|||
StencilBackFuncFunc = 0x569,
|
||||
ShaderAddress = 0x582,
|
||||
VertexBeginGl = 0x586,
|
||||
PrimRestartEnable = 0x591,
|
||||
PrimRestartIndex = 0x592,
|
||||
IndexArrayAddress = 0x5f2,
|
||||
IndexArrayEndAddr = 0x5f4,
|
||||
IndexArrayFormat = 0x5f6,
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ namespace Ryujinx.HLE.Gpu.Memory
|
|||
{
|
||||
Index,
|
||||
Vertex,
|
||||
Texture
|
||||
Texture,
|
||||
Count
|
||||
}
|
||||
}
|
||||
|
|
@ -274,11 +274,9 @@ namespace Ryujinx.HLE.Gpu.Memory
|
|||
PageTable[L0][L1] = TgtAddr;
|
||||
}
|
||||
|
||||
public bool IsRegionModified(long Position, long Size, NvGpuBufferType BufferType)
|
||||
public bool IsRegionModified(long PA, long Size, NvGpuBufferType BufferType)
|
||||
{
|
||||
long PA = GetPhysicalAddress(Position);
|
||||
|
||||
return Cache.IsRegionModified(Memory, BufferType, Position, PA, Size);
|
||||
return Cache.IsRegionModified(Memory, BufferType, PA, Size);
|
||||
}
|
||||
|
||||
public byte ReadByte(long Position)
|
||||
|
|
|
|||
|
|
@ -11,43 +11,53 @@ namespace Ryujinx.HLE.Gpu.Memory
|
|||
|
||||
private class CachedPage
|
||||
{
|
||||
private List<(long Start, long End)> Regions;
|
||||
private struct Range
|
||||
{
|
||||
public long Start;
|
||||
public long End;
|
||||
|
||||
public Range(long Start, long End)
|
||||
{
|
||||
this.Start = Start;
|
||||
this.End = End;
|
||||
}
|
||||
}
|
||||
|
||||
private List<Range>[] Regions;
|
||||
|
||||
public LinkedListNode<long> Node { get; set; }
|
||||
|
||||
public int Count => Regions.Count;
|
||||
|
||||
public int Timestamp { get; private set; }
|
||||
|
||||
public long PABase { get; private set; }
|
||||
|
||||
public NvGpuBufferType BufferType { get; private set; }
|
||||
|
||||
public CachedPage(long PABase, NvGpuBufferType BufferType)
|
||||
public CachedPage()
|
||||
{
|
||||
this.PABase = PABase;
|
||||
this.BufferType = BufferType;
|
||||
Regions = new List<Range>[(int)NvGpuBufferType.Count];
|
||||
|
||||
Regions = new List<(long, long)>();
|
||||
for (int Index = 0; Index < Regions.Length; Index++)
|
||||
{
|
||||
Regions[Index] = new List<Range>();
|
||||
}
|
||||
}
|
||||
|
||||
public bool AddRange(long Start, long End)
|
||||
public bool AddRange(long Start, long End, NvGpuBufferType BufferType)
|
||||
{
|
||||
for (int Index = 0; Index < Regions.Count; Index++)
|
||||
{
|
||||
(long RgStart, long RgEnd) = Regions[Index];
|
||||
List<Range> BtRegions = Regions[(int)BufferType];
|
||||
|
||||
if (Start >= RgStart && End <= RgEnd)
|
||||
for (int Index = 0; Index < BtRegions.Count; Index++)
|
||||
{
|
||||
Range Rg = BtRegions[Index];
|
||||
|
||||
if (Start >= Rg.Start && End <= Rg.End)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (Start <= RgEnd && RgStart <= End)
|
||||
if (Start <= Rg.End && Rg.Start <= End)
|
||||
{
|
||||
long MinStart = Math.Min(RgStart, Start);
|
||||
long MaxEnd = Math.Max(RgEnd, End);
|
||||
long MinStart = Math.Min(Rg.Start, Start);
|
||||
long MaxEnd = Math.Max(Rg.End, End);
|
||||
|
||||
Regions[Index] = (MinStart, MaxEnd);
|
||||
BtRegions[Index] = new Range(MinStart, MaxEnd);
|
||||
|
||||
Timestamp = Environment.TickCount;
|
||||
|
||||
|
|
@ -55,12 +65,24 @@ namespace Ryujinx.HLE.Gpu.Memory
|
|||
}
|
||||
}
|
||||
|
||||
Regions.Add((Start, End));
|
||||
BtRegions.Add(new Range(Start, End));
|
||||
|
||||
Timestamp = Environment.TickCount;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public int GetTotalCount()
|
||||
{
|
||||
int Count = 0;
|
||||
|
||||
for (int Index = 0; Index < Regions.Length; Index++)
|
||||
{
|
||||
Count += Regions[Index].Count;
|
||||
}
|
||||
|
||||
return Count;
|
||||
}
|
||||
}
|
||||
|
||||
private Dictionary<long, CachedPage> Cache;
|
||||
|
|
@ -76,71 +98,61 @@ namespace Ryujinx.HLE.Gpu.Memory
|
|||
SortedCache = new LinkedList<long>();
|
||||
}
|
||||
|
||||
public bool IsRegionModified(
|
||||
AMemory Memory,
|
||||
NvGpuBufferType BufferType,
|
||||
long VA,
|
||||
long PA,
|
||||
long Size)
|
||||
public bool IsRegionModified(AMemory Memory, NvGpuBufferType BufferType, long PA, long Size)
|
||||
{
|
||||
bool[] Modified = Memory.IsRegionModified(PA, Size);
|
||||
|
||||
if (Modified == null)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
ClearCachedPagesIfNeeded();
|
||||
|
||||
long PageSize = Memory.GetHostPageSize();
|
||||
|
||||
long Mask = PageSize - 1;
|
||||
|
||||
long VAEnd = VA + Size;
|
||||
long PAEnd = PA + Size;
|
||||
|
||||
bool RegMod = false;
|
||||
|
||||
while (VA < VAEnd)
|
||||
{
|
||||
long Key = VA & ~Mask;
|
||||
long PABase = PA & ~Mask;
|
||||
int Index = 0;
|
||||
|
||||
while (PA < PAEnd)
|
||||
{
|
||||
long Key = PA & ~Mask;
|
||||
|
||||
long VAPgEnd = Math.Min((VA + PageSize) & ~Mask, VAEnd);
|
||||
long PAPgEnd = Math.Min((PA + PageSize) & ~Mask, PAEnd);
|
||||
|
||||
bool IsCached = Cache.TryGetValue(Key, out CachedPage Cp);
|
||||
|
||||
bool PgReset = false;
|
||||
|
||||
if (!IsCached)
|
||||
if (IsCached)
|
||||
{
|
||||
Cp = new CachedPage(PABase, BufferType);
|
||||
CpCount -= Cp.GetTotalCount();
|
||||
|
||||
Cache.Add(Key, Cp);
|
||||
SortedCache.Remove(Cp.Node);
|
||||
}
|
||||
else
|
||||
{
|
||||
CpCount -= Cp.Count;
|
||||
Cp = new CachedPage();
|
||||
|
||||
SortedCache.Remove(Cp.Node);
|
||||
|
||||
if (Cp.PABase != PABase ||
|
||||
Cp.BufferType != BufferType)
|
||||
{
|
||||
PgReset = true;
|
||||
}
|
||||
Cache.Add(Key, Cp);
|
||||
}
|
||||
|
||||
PgReset |= Memory.IsRegionModified(PA, PAPgEnd - PA) && IsCached;
|
||||
|
||||
if (PgReset)
|
||||
if (Modified[Index++] && IsCached)
|
||||
{
|
||||
Cp = new CachedPage(PABase, BufferType);
|
||||
Cp = new CachedPage();
|
||||
|
||||
Cache[Key] = Cp;
|
||||
}
|
||||
|
||||
Cp.Node = SortedCache.AddLast(Key);
|
||||
|
||||
RegMod |= Cp.AddRange(VA, VAPgEnd);
|
||||
RegMod |= Cp.AddRange(PA, PAPgEnd, BufferType);
|
||||
|
||||
CpCount += Cp.Count;
|
||||
CpCount += Cp.GetTotalCount();
|
||||
|
||||
VA = VAPgEnd;
|
||||
PA = PAPgEnd;
|
||||
}
|
||||
|
||||
|
|
@ -169,7 +181,7 @@ namespace Ryujinx.HLE.Gpu.Memory
|
|||
|
||||
Cache.Remove(Key);
|
||||
|
||||
CpCount -= Cp.Count;
|
||||
CpCount -= Cp.GetTotalCount();
|
||||
|
||||
TimeDelta = RingDelta(Cp.Timestamp, Timestamp);
|
||||
}
|
||||
|
|
|
|||
8
Ryujinx.HLE/OsHle/Services/Aud/AudErr.cs
Normal file
8
Ryujinx.HLE/OsHle/Services/Aud/AudErr.cs
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
namespace Ryujinx.HLE.OsHle.Services.Aud
|
||||
{
|
||||
static class AudErr
|
||||
{
|
||||
public const int DeviceNotFound = 1;
|
||||
public const int UnsupportedSampleRate = 3;
|
||||
}
|
||||
}
|
||||
|
|
@ -6,6 +6,8 @@ using Ryujinx.HLE.OsHle.Ipc;
|
|||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
using static Ryujinx.HLE.OsHle.ErrorCode;
|
||||
|
||||
namespace Ryujinx.HLE.OsHle.Services.Aud
|
||||
{
|
||||
class IAudioOutManager : IpcService
|
||||
|
|
@ -28,36 +30,44 @@ namespace Ryujinx.HLE.OsHle.Services.Aud
|
|||
}
|
||||
|
||||
public long ListAudioOuts(ServiceCtx Context)
|
||||
{
|
||||
ListAudioOutsMethod(Context, Context.Request.ReceiveBuff[0].Position, Context.Request.ReceiveBuff[0].Size);
|
||||
|
||||
return 0;
|
||||
{
|
||||
return ListAudioOutsImpl(
|
||||
Context,
|
||||
Context.Request.ReceiveBuff[0].Position,
|
||||
Context.Request.ReceiveBuff[0].Size);
|
||||
}
|
||||
|
||||
public long OpenAudioOut(ServiceCtx Context)
|
||||
{
|
||||
OpenAudioOutMethod(Context, Context.Request.SendBuff[0].Position, Context.Request.SendBuff[0].Size,
|
||||
Context.Request.ReceiveBuff[0].Position, Context.Request.ReceiveBuff[0].Size);
|
||||
|
||||
return 0;
|
||||
return OpenAudioOutImpl(
|
||||
Context,
|
||||
Context.Request.SendBuff[0].Position,
|
||||
Context.Request.SendBuff[0].Size,
|
||||
Context.Request.ReceiveBuff[0].Position,
|
||||
Context.Request.ReceiveBuff[0].Size);
|
||||
}
|
||||
|
||||
|
||||
public long ListAudioOutsAuto(ServiceCtx Context)
|
||||
{
|
||||
ListAudioOutsMethod(Context, Context.Request.GetBufferType0x22().Position, Context.Request.GetBufferType0x22().Size);
|
||||
{
|
||||
(long RecvPosition, long RecvSize) = Context.Request.GetBufferType0x22();
|
||||
|
||||
return 0;
|
||||
return ListAudioOutsImpl(Context, RecvPosition, RecvSize);
|
||||
}
|
||||
|
||||
|
||||
public long OpenAudioOutAuto(ServiceCtx Context)
|
||||
{
|
||||
OpenAudioOutMethod(Context, Context.Request.GetBufferType0x21().Position, Context.Request.GetBufferType0x21().Size,
|
||||
Context.Request.GetBufferType0x22().Position, Context.Request.GetBufferType0x22().Size);
|
||||
(long SendPosition, long SendSize) = Context.Request.GetBufferType0x21();
|
||||
(long RecvPosition, long RecvSize) = Context.Request.GetBufferType0x22();
|
||||
|
||||
return 0;
|
||||
return OpenAudioOutImpl(
|
||||
Context,
|
||||
SendPosition,
|
||||
SendSize,
|
||||
RecvPosition,
|
||||
RecvSize);
|
||||
}
|
||||
|
||||
public void ListAudioOutsMethod(ServiceCtx Context, long Position, long Size)
|
||||
|
||||
private long ListAudioOutsImpl(ServiceCtx Context, long Position, long Size)
|
||||
{
|
||||
int NameCount = 0;
|
||||
|
||||
|
|
@ -75,23 +85,29 @@ namespace Ryujinx.HLE.OsHle.Services.Aud
|
|||
}
|
||||
|
||||
Context.ResponseData.Write(NameCount);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
public void OpenAudioOutMethod(ServiceCtx Context, long SendPosition, long SendSize, long ReceivePosition, long ReceiveSize)
|
||||
|
||||
private long OpenAudioOutImpl(ServiceCtx Context, long SendPosition, long SendSize, long ReceivePosition, long ReceiveSize)
|
||||
{
|
||||
IAalOutput AudioOut = Context.Ns.AudioOut;
|
||||
|
||||
string DeviceName = AMemoryHelper.ReadAsciiString(
|
||||
Context.Memory,
|
||||
SendPosition,
|
||||
SendSize
|
||||
);
|
||||
|
||||
SendSize);
|
||||
|
||||
if (DeviceName == string.Empty)
|
||||
{
|
||||
DeviceName = DefaultAudioOutput;
|
||||
}
|
||||
|
||||
if (DeviceName != DefaultAudioOutput)
|
||||
{
|
||||
Context.Ns.Log.PrintWarning(LogClass.Audio, "Invalid device name!");
|
||||
|
||||
return MakeError(ErrorModule.Audio, AudErr.DeviceNotFound);
|
||||
}
|
||||
|
||||
byte[] DeviceNameBuffer = Encoding.ASCII.GetBytes(DeviceName + "\0");
|
||||
|
||||
if ((ulong)DeviceNameBuffer.Length <= (ulong)ReceiveSize)
|
||||
|
|
@ -101,19 +117,21 @@ namespace Ryujinx.HLE.OsHle.Services.Aud
|
|||
else
|
||||
{
|
||||
Context.Ns.Log.PrintError(LogClass.ServiceAudio, $"Output buffer size {ReceiveSize} too small!");
|
||||
}
|
||||
}
|
||||
|
||||
int SampleRate = Context.RequestData.ReadInt32();
|
||||
int Channels = Context.RequestData.ReadInt32();
|
||||
|
||||
Channels = (ushort)(Channels >> 16);
|
||||
|
||||
if (SampleRate == 0)
|
||||
if (SampleRate != 48000)
|
||||
{
|
||||
SampleRate = 48000;
|
||||
Context.Ns.Log.PrintWarning(LogClass.Audio, "Invalid sample rate!");
|
||||
|
||||
return MakeError(ErrorModule.Audio, AudErr.UnsupportedSampleRate);
|
||||
}
|
||||
|
||||
if (Channels < 1 || Channels > 2)
|
||||
Channels = (ushort)Channels;
|
||||
|
||||
if (Channels == 0)
|
||||
{
|
||||
Channels = 2;
|
||||
}
|
||||
|
|
@ -125,7 +143,9 @@ namespace Ryujinx.HLE.OsHle.Services.Aud
|
|||
ReleaseEvent.WaitEvent.Set();
|
||||
};
|
||||
|
||||
int Track = AudioOut.OpenTrack(SampleRate, Channels, Callback, out AudioFormat Format);
|
||||
IAalOutput AudioOut = Context.Ns.AudioOut;
|
||||
|
||||
int Track = AudioOut.OpenTrack(SampleRate, 2, Callback, out AudioFormat Format);
|
||||
|
||||
MakeObject(Context, new IAudioOut(AudioOut, ReleaseEvent, Track));
|
||||
|
||||
|
|
@ -133,6 +153,8 @@ namespace Ryujinx.HLE.OsHle.Services.Aud
|
|||
Context.ResponseData.Write(Channels);
|
||||
Context.ResponseData.Write((int)Format);
|
||||
Context.ResponseData.Write((int)PlaybackState.Stopped);
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -163,26 +163,18 @@ namespace Ryujinx.Tests.Cpu
|
|||
Assert.That(Sse41.Extract(ThreadState.V6, (byte)0), Is.EqualTo(A * B));
|
||||
}
|
||||
|
||||
[Test, Description("FRECPE D0, D1")]
|
||||
public void Frecpe_S([Random(100)] double A)
|
||||
[TestCase(0x00000000u, 0x7F800000u)]
|
||||
[TestCase(0x80000000u, 0xFF800000u)]
|
||||
[TestCase(0x00FFF000u, 0x7E000000u)]
|
||||
[TestCase(0x41200000u, 0x3DCC8000u)]
|
||||
[TestCase(0xC1200000u, 0xBDCC8000u)]
|
||||
[TestCase(0x001FFFFFu, 0x7F800000u)]
|
||||
[TestCase(0x007FF000u, 0x7E800000u)]
|
||||
public void Frecpe_S(uint A, uint Result)
|
||||
{
|
||||
AThreadState ThreadState = SingleOpcode(0x5EE1D820, V1: MakeVectorE0(A));
|
||||
|
||||
Assert.That(VectorExtractDouble(ThreadState.V0, 0), Is.EqualTo(1 / A));
|
||||
}
|
||||
|
||||
[Test, Description("FRECPE V2.4S, V0.4S")]
|
||||
public void Frecpe_V([Random(100)] float A)
|
||||
{
|
||||
AThreadState ThreadState = SingleOpcode(0x4EA1D802, V0: Sse.SetAllVector128(A));
|
||||
|
||||
Assert.Multiple(() =>
|
||||
{
|
||||
Assert.That(Sse41.Extract(ThreadState.V2, (byte)0), Is.EqualTo(1 / A));
|
||||
Assert.That(Sse41.Extract(ThreadState.V2, (byte)1), Is.EqualTo(1 / A));
|
||||
Assert.That(Sse41.Extract(ThreadState.V2, (byte)2), Is.EqualTo(1 / A));
|
||||
Assert.That(Sse41.Extract(ThreadState.V2, (byte)3), Is.EqualTo(1 / A));
|
||||
});
|
||||
Vector128<float> V1 = MakeVectorE0(A);
|
||||
AThreadState ThreadState = SingleOpcode(0x5EA1D820, V1: V1);
|
||||
Assert.AreEqual(Result, GetVectorE0(ThreadState.V0));
|
||||
}
|
||||
|
||||
[Test, Description("FRECPS D0, D1, D2")]
|
||||
|
|
@ -202,12 +194,13 @@ namespace Ryujinx.Tests.Cpu
|
|||
V2: Sse.SetAllVector128(A),
|
||||
V0: Sse.SetAllVector128(B));
|
||||
|
||||
float Result = (float)(2 - ((double)A * (double)B));
|
||||
Assert.Multiple(() =>
|
||||
{
|
||||
Assert.That(Sse41.Extract(ThreadState.V4, (byte)0), Is.EqualTo(2 - (A * B)));
|
||||
Assert.That(Sse41.Extract(ThreadState.V4, (byte)1), Is.EqualTo(2 - (A * B)));
|
||||
Assert.That(Sse41.Extract(ThreadState.V4, (byte)2), Is.EqualTo(2 - (A * B)));
|
||||
Assert.That(Sse41.Extract(ThreadState.V4, (byte)3), Is.EqualTo(2 - (A * B)));
|
||||
Assert.That(Sse41.Extract(ThreadState.V4, (byte)0), Is.EqualTo(Result));
|
||||
Assert.That(Sse41.Extract(ThreadState.V4, (byte)1), Is.EqualTo(Result));
|
||||
Assert.That(Sse41.Extract(ThreadState.V4, (byte)2), Is.EqualTo(Result));
|
||||
Assert.That(Sse41.Extract(ThreadState.V4, (byte)3), Is.EqualTo(Result));
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue