emu-mirrors/ryujinx-fork
0
0
Fork 0
mirror of https://github.com/ryujinx-mirror/ryujinx.git synced 2024-12-22 18:25:46 +00:00
Code Activity

Some small sync primitive fixes, logging fixes, started to implement the 2D engine on the GPU, fixed DrawArrays, implemented a few more shader instructions, made a start on nvdrv refactor, etc...

Browse source
This commit is contained in:
gdkchan 2018-04-25 23:11:26 -03:00
parent 211f7f69db
commit a38a72b062
27 changed files with 816 additions and 199 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

168
Ryujinx.Core/OsHle/Handles/KProcessScheduler.cs
View file

@ -14,23 +14,23 @@ namespace Ryujinx.Core.OsHle.Handles
{
public KThread Thread { get; private set; }
public ManualResetEvent SyncWaitEvent { get; private set; }
public AutoResetEvent SchedWaitEvent { get; private set; }
public bool IsActive { get; set; }
public bool Active { get; set; }
public int SyncTimeout { get; set; }
public AutoResetEvent WaitSync { get; private set; }
public ManualResetEvent WaitActivity { get; private set; }
public AutoResetEvent WaitSched { get; private set; }
public SchedulerThread(KThread Thread)
{
this.Thread = Thread;
SyncWaitEvent = new ManualResetEvent(true);
SchedWaitEvent = new AutoResetEvent(false);
IsActive = true;
Active = true;
WaitSync = new AutoResetEvent(false);
SyncTimeout = 0;
WaitActivity = new ManualResetEvent(true);
WaitSched = new AutoResetEvent(false);
}
public void Dispose()
@ -42,8 +42,11 @@ namespace Ryujinx.Core.OsHle.Handles
{
if (Disposing)
{
SyncWaitEvent.Dispose();
SchedWaitEvent.Dispose();
WaitSync.Dispose();
WaitActivity.Dispose();
WaitSched.Dispose();
}
}
}
@ -206,25 +209,46 @@ namespace Ryujinx.Core.OsHle.Handles
throw new InvalidOperationException();
}
SchedThread.Active = Active;
SchedThread.IsActive = Active;
UpdateSyncWaitEvent(SchedThread);
WaitIfNeeded(SchedThread);
if (Active)
{
SchedThread.WaitActivity.Set();
}
else
{
SchedThread.WaitActivity.Reset();
}
}
public bool EnterWait(KThread Thread, int Timeout = -1)
public void EnterWait(KThread Thread)
{
if (!AllThreads.TryGetValue(Thread, out SchedulerThread SchedThread))
{
throw new InvalidOperationException();
}
SchedThread.SyncTimeout = Timeout;
Suspend(Thread.ProcessorId);
UpdateSyncWaitEvent(SchedThread);
SchedThread.WaitSync.WaitOne();
return WaitIfNeeded(SchedThread);
TryResumingExecution(SchedThread);
}
public bool EnterWait(KThread Thread, int Timeout)
{
if (!AllThreads.TryGetValue(Thread, out SchedulerThread SchedThread))
{
throw new InvalidOperationException();
}
Suspend(Thread.ProcessorId);
bool Result = SchedThread.WaitSync.WaitOne(Timeout);
TryResumingExecution(SchedThread);
return Result;
}
public void WakeUp(KThread Thread)
@ -234,39 +258,7 @@ namespace Ryujinx.Core.OsHle.Handles
throw new InvalidOperationException();
}
SchedThread.SyncTimeout = 0;
UpdateSyncWaitEvent(SchedThread);
WaitIfNeeded(SchedThread);
}
private void UpdateSyncWaitEvent(SchedulerThread SchedThread)
{
if (SchedThread.Active && SchedThread.SyncTimeout == 0)
{
SchedThread.SyncWaitEvent.Set();
}
else
{
SchedThread.SyncWaitEvent.Reset();
}
}
private bool WaitIfNeeded(SchedulerThread SchedThread)
{
KThread Thread = SchedThread.Thread;
if (!IsActive(SchedThread) && Thread.Thread.IsCurrentThread())
{
Suspend(Thread.ProcessorId);
return Resume(Thread);
}
else
{
return false;
}
SchedThread.WaitSync.Set();
}
public void Suspend(int ProcessorId)
@ -292,53 +284,52 @@ namespace Ryujinx.Core.OsHle.Handles
{
PrintDbgThreadInfo(Thread, "yielded execution.");
lock (SchedLock)
if (IsActive(Thread))
{
SchedulerThread SchedThread = WaitingToRun[Thread.ProcessorId].Pop(Thread.ActualPriority);
if (IsActive(Thread) && SchedThread == null)
lock (SchedLock)
{
PrintDbgThreadInfo(Thread, "resumed because theres nothing better to run.");
SchedulerThread SchedThread = WaitingToRun[Thread.ProcessorId].Pop(Thread.ActualPriority);
return;
}
if (SchedThread == null)
{
PrintDbgThreadInfo(Thread, "resumed because theres nothing better to run.");
if (SchedThread != null)
{
RunThread(SchedThread);
return;
}
if (SchedThread != null)
{
RunThread(SchedThread);
}
}
}
else
{
//Just stop running the thread if it's not active,
//and run whatever is waiting to run with the higuest priority.
Suspend(Thread.ProcessorId);
}
Resume(Thread);
}
public bool Resume(KThread Thread)
public void Resume(KThread Thread)
{
if (!AllThreads.TryGetValue(Thread, out SchedulerThread SchedThread))
{
throw new InvalidOperationException();
}
return TryResumingExecution(SchedThread);
TryResumingExecution(SchedThread);
}
private bool TryResumingExecution(SchedulerThread SchedThread)
private void TryResumingExecution(SchedulerThread SchedThread)
{
KThread Thread = SchedThread.Thread;
if (!SchedThread.Active || SchedThread.SyncTimeout != 0)
{
PrintDbgThreadInfo(Thread, "entering inactive wait state...");
}
PrintDbgThreadInfo(Thread, "trying to resume...");
bool Result = false;
if (SchedThread.SyncTimeout != 0)
{
Result = SchedThread.SyncWaitEvent.WaitOne(SchedThread.SyncTimeout);
SchedThread.SyncTimeout = 0;
}
SchedThread.WaitActivity.WaitOne();
lock (SchedLock)
{
@ -346,7 +337,7 @@ namespace Ryujinx.Core.OsHle.Handles
{
PrintDbgThreadInfo(Thread, "resuming execution...");
return Result;
return;
}
WaitingToRun[Thread.ProcessorId].Push(SchedThread);
@ -354,18 +345,16 @@ namespace Ryujinx.Core.OsHle.Handles
PrintDbgThreadInfo(Thread, "entering wait state...");
}
SchedThread.SchedWaitEvent.WaitOne();
SchedThread.WaitSched.WaitOne();
PrintDbgThreadInfo(Thread, "resuming execution...");
return Result;
}
private void RunThread(SchedulerThread SchedThread)
{
if (!SchedThread.Thread.Thread.Execute())
{
SchedThread.SchedWaitEvent.Set();
SchedThread.WaitSched.Set();
}
else
{
@ -380,21 +369,16 @@ namespace Ryujinx.Core.OsHle.Handles
throw new InvalidOperationException();
}
return IsActive(SchedThread);
}
private bool IsActive(SchedulerThread SchedThread)
{
return SchedThread.Active && SchedThread.SyncTimeout == 0;
return SchedThread.IsActive;
}
private void PrintDbgThreadInfo(KThread Thread, string Message)
{
Log.PrintDebug(LogClass.KernelScheduler, "(" +
"ThreadId: " + Thread.ThreadId + ", " +
"ProcessorId: " + Thread.ProcessorId + ", " +
"ActualPriority: " + Thread.ActualPriority + ", " +
"WantedPriority: " + Thread.WantedPriority + ") " + Message);
"ThreadId = " + Thread.ThreadId + ", " +
"ProcessorId = " + Thread.ProcessorId + ", " +
"ActualPriority = " + Thread.ActualPriority + ", " +
"WantedPriority = " + Thread.WantedPriority + ") " + Message);
}
public void Dispose()

30
Ryujinx.Core/OsHle/Ipc/IpcMessage.cs
View file

@ -198,5 +198,35 @@ namespace Ryujinx.Core.OsHle.Ipc
return -1;
}
public long GetBufferType0x21Position()
{
if (PtrBuff.Count > 0 && PtrBuff[0].Position != 0)
{
return PtrBuff[0].Position;
}
if (SendBuff.Count > 0)
{
return SendBuff[0].Position;
}
return 0;
}
public long GetBufferType0x22Position()
{
if (RecvListBuff.Count > 0 && RecvListBuff[0].Position != 0)
{
return RecvListBuff[0].Position;
}
if (ReceiveBuff.Count > 0)
{
return ReceiveBuff[0].Position;
}
return 0;
}
}
}

2
Ryujinx.Core/OsHle/Kernel/SvcHandler.cs
View file

@ -86,6 +86,8 @@ namespace Ryujinx.Core.OsHle.Kernel
if (SvcFuncs.TryGetValue(e.Id, out SvcFunc Func))
{
Ns.Log.PrintDebug(LogClass.KernelSvc, $"{Func.Method.Name} called.");
Func(ThreadState);
Ns.Log.PrintDebug(LogClass.KernelSvc, $"{Func.Method.Name} ended.");

52
Ryujinx.Core/OsHle/Kernel/SvcThreadSync.cs
View file

@ -18,6 +18,11 @@ namespace Ryujinx.Core.OsHle.Kernel
long MutexAddress = (long)ThreadState.X1;
int WaitThreadHandle = (int)ThreadState.X2;
Ns.Log.PrintDebug(LogClass.KernelSvc,
"OwnerThreadHandle = " + OwnerThreadHandle.ToString("x8") + ", " +
"MutexAddress = " + MutexAddress .ToString("x16") + ", " +
"WaitThreadHandle = " + WaitThreadHandle .ToString("x8"));
if (IsPointingInsideKernel(MutexAddress))
{
Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid mutex address 0x{MutexAddress:x16}!");
@ -38,6 +43,8 @@ namespace Ryujinx.Core.OsHle.Kernel
KThread OwnerThread = Process.HandleTable.GetData<KThread>(OwnerThreadHandle);
Ns.Log.PrintDebug(LogClass.KernelSvc, "lock tid: " + OwnerThread.ThreadId.ToString());
if (OwnerThread == null)
{
Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid owner thread handle 0x{OwnerThreadHandle:x8}!");
@ -69,6 +76,8 @@ namespace Ryujinx.Core.OsHle.Kernel
{
long MutexAddress = (long)ThreadState.X0;
Ns.Log.PrintDebug(LogClass.KernelSvc, "MutexAddress = " + MutexAddress.ToString("x16"));
if (IsPointingInsideKernel(MutexAddress))
{
Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid mutex address 0x{MutexAddress:x16}!");
@ -102,6 +111,12 @@ namespace Ryujinx.Core.OsHle.Kernel
int ThreadHandle = (int)ThreadState.X2;
ulong Timeout = ThreadState.X3;
Ns.Log.PrintDebug(LogClass.KernelSvc,
"OwnerThreadHandle = " + MutexAddress .ToString("x16") + ", " +
"MutexAddress = " + CondVarAddress.ToString("x16") + ", " +
"WaitThreadHandle = " + ThreadHandle .ToString("x8") + ", " +
"Timeout = " + Timeout .ToString("x16"));
if (IsPointingInsideKernel(MutexAddress))
{
Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid mutex address 0x{MutexAddress:x16}!");
@ -166,6 +181,8 @@ namespace Ryujinx.Core.OsHle.Kernel
{
int MutexValue = Process.Memory.ReadInt32(MutexAddress);
Ns.Log.PrintDebug(LogClass.KernelSvc, "MutexValue = " + MutexValue.ToString("x8"));
if (MutexValue != (OwnerThreadHandle | MutexHasListenersMask))
{
return;
@ -176,7 +193,7 @@ namespace Ryujinx.Core.OsHle.Kernel
InsertWaitingMutexThread(OwnerThreadHandle, WaitThread);
Process.Scheduler.EnterWait(WaitThread);
Process.Scheduler.EnterWait(CurrThread);
}
private bool MutexUnlock(KThread CurrThread, long MutexAddress)
@ -199,8 +216,12 @@ namespace Ryujinx.Core.OsHle.Kernel
OwnerThread = OwnerThread.NextMutexThread;
}
UpdateMutexOwner(CurrThread, OwnerThread, MutexAddress);
CurrThread.NextMutexThread = null;
CurrThread.UpdatePriority();
if (OwnerThread != null)
{
int HasListeners = OwnerThread.NextMutexThread != null ? MutexHasListenersMask : 0;
@ -284,7 +305,9 @@ namespace Ryujinx.Core.OsHle.Kernel
}
else
{
return Process.Scheduler.EnterWait(WaitThread);
Process.Scheduler.EnterWait(WaitThread);
return true;
}
}
@ -314,8 +337,6 @@ namespace Ryujinx.Core.OsHle.Kernel
int MutexValue = Process.Memory.ReadInt32(CurrThread.MutexAddress);
MutexValue &= ~MutexHasListenersMask;
if (MutexValue == 0)
{
//Give the lock to this thread.
@ -325,15 +346,17 @@ namespace Ryujinx.Core.OsHle.Kernel
CurrThread.MutexAddress = 0;
CurrThread.CondVarAddress = 0;
CurrThread.MutexOwner = null;
CurrThread.MutexOwner?.UpdatePriority();
CurrThread.UpdatePriority();
CurrThread.MutexOwner = null;
Process.Scheduler.WakeUp(CurrThread);
}
else
{
//Wait until the lock is released.
MutexValue &= ~MutexHasListenersMask;
InsertWaitingMutexThread(MutexValue, CurrThread);
MutexValue |= MutexHasListenersMask;
@ -399,6 +422,23 @@ namespace Ryujinx.Core.OsHle.Kernel
OwnerThread.UpdatePriority();
}
private void UpdateMutexOwner(KThread CurrThread, KThread NewOwner, long MutexAddress)
{
//Go through all threads waiting for the mutex,
//and update the MutexOwner field to point to the new owner.
CurrThread = CurrThread.NextMutexThread;
while (CurrThread != null)
{
if (CurrThread.MutexAddress == MutexAddress)
{
CurrThread.MutexOwner = NewOwner;
}
CurrThread = CurrThread.NextMutexThread;
}
}
private void AcquireMutexValue(long MutexAddress)
{
while (!Process.Memory.AcquireAddress(MutexAddress))

27
Ryujinx.Core/OsHle/Services/Nv/INvDrvServices.cs
View file

@ -44,6 +44,7 @@ namespace Ryujinx.Core.OsHle.Services.Nv
{
{ ("/dev/nvhost-as-gpu", 0x4101), NvGpuAsIoctlBindChannel },
{ ("/dev/nvhost-as-gpu", 0x4102), NvGpuAsIoctlAllocSpace },
{ ("/dev/nvhost-as-gpu", 0x4105), NvGpuAsIoctlUnmap },
{ ("/dev/nvhost-as-gpu", 0x4106), NvGpuAsIoctlMapBufferEx },
{ ("/dev/nvhost-as-gpu", 0x4108), NvGpuAsIoctlGetVaRegions },
{ ("/dev/nvhost-as-gpu", 0x4109), NvGpuAsIoctlInitializeEx },
@ -201,6 +202,19 @@ namespace Ryujinx.Core.OsHle.Services.Nv
return 0;
}
private long NvGpuAsIoctlUnmap(ServiceCtx Context)
{
long Position = Context.Request.GetSendBuffPtr();
MemReader Reader = new MemReader(Context.Memory, Position);
long Offset = Reader.ReadInt64();
Context.Ns.Gpu.MemoryMgr.Unmap(Offset, 0x10000);
return 0;
}
private long NvGpuAsIoctlMapBufferEx(ServiceCtx Context)
{
long Position = Context.Request.GetSendBuffPtr();
@ -319,6 +333,19 @@ namespace Ryujinx.Core.OsHle.Services.Nv
int Padding = Reader.ReadInt32();
int Offset = Reader.ReadInt32();
int Pages = Reader.ReadInt32();
NvMap Map = NvMaps.GetData<NvMap>(Context.Process, Handle);
if (Map == null)
{
Context.Ns.Log.PrintWarning(LogClass.ServiceNv, $"invalid NvMap Handle {Handle}!");
return -1; //TODO: Corrent error code.
}
Context.Ns.Gpu.MapMemory(Map.CpuAddress,
(long)(uint)Offset << 16,
(long)(uint)Pages << 16);
}
//TODO

31
Ryujinx.Core/OsHle/Services/Nv/NvChNvMap.cs Normal file
View file

@ -0,0 +1,31 @@
using System.Collections.Concurrent;
namespace Ryujinx.Core.OsHle.Services.Nv
{
class NvChNvMap
{
private static ConcurrentDictionary<Process, IdDictionary> NvMaps;
public void Create(ServiceCtx Context)
{
long InputPosition = Context.Request.GetBufferType0x21Position();
long OutputPosition = Context.Request.GetBufferType0x22Position();
int Size = Context.Memory.ReadInt32(InputPosition);
int Handle = AddNvMap(Context, new NvMap(Size));
Context.Memory.WriteInt32(OutputPosition, Handle);
}
private int AddNvMap(ServiceCtx Context, NvMap Map)
{
return NvMaps[Context.Process].Add(Map);
}
public NvMap GetNvMap(ServiceCtx Context, int Handle)
{
return NvMaps[Context.Process].GetData<NvMap>(Handle);
}
}
}

7
Ryujinx.Core/OsHle/Services/Nv/NvMap.cs
View file

@ -9,5 +9,12 @@ namespace Ryujinx.Core.OsHle.Services.Nv
public int Kind;
public long CpuAddress;
public long GpuAddress;
public NvMap() { }
public NvMap(int Size)
{
this.Size = Size;
}
}
}

4
Ryujinx.Graphics/Gal/IGalRenderer.cs
View file

@ -44,6 +44,8 @@ namespace Ryujinx.Graphics.Gal
void SetViewport(int X, int Y, int Width, int Height);
void GetFrameBufferData(long Tag, Action<byte[]> Callback);
//Rasterizer
void ClearBuffers(int RtIndex, GalClearBufferFlags Flags);
@ -51,7 +53,7 @@ namespace Ryujinx.Graphics.Gal
void SetIndexArray(byte[] Buffer, GalIndexFormat Format);
void DrawArrays(int VbIndex, GalPrimitiveType PrimType);
void DrawArrays(int VbIndex, int First, int PrimCount, GalPrimitiveType PrimType);
void DrawElements(int VbIndex, int First, GalPrimitiveType PrimType);

25
Ryujinx.Graphics/Gal/OpenGL/OGLFrameBuffer.cs
View file

@ -270,6 +270,31 @@ namespace Ryujinx.Graphics.Gal.OpenGL
}
}
public void GetBufferData(long Tag, Action<byte[]> Callback)
{
if (Fbs.TryGetValue(Tag, out FrameBuffer Fb))
{
GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, Fb.Handle);
byte[] Data = new byte[Fb.Width * Fb.Height * 4];
(PixelFormat Format, PixelType Type) = OGLEnumConverter.GetTextureFormat(GalTextureFormat.A8B8G8R8);
GL.ReadPixels(
0,
0,
Fb.Width,
Fb.Height,
Format,
Type,
Data);
Callback(Data);
GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, CurrFbHandle);
}
}
private void SetViewport(Rect Viewport)
{
GL.Viewport(

19
Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs
View file

@ -48,8 +48,6 @@ namespace Ryujinx.Graphics.Gal.OpenGL
{
public int VaoHandle;
public int VboHandle;
public int PrimCount;
}
private struct IbInfo
@ -102,8 +100,6 @@ namespace Ryujinx.Graphics.Gal.OpenGL
{
EnsureVbInitialized(VbIndex);
VertexBuffers[VbIndex].PrimCount = Buffer.Length / Stride;
VbInfo Vb = VertexBuffers[VbIndex];
IntPtr Length = new IntPtr(Buffer.Length);
@ -171,29 +167,24 @@ namespace Ryujinx.Graphics.Gal.OpenGL
GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
}
public void DrawArrays(int VbIndex, GalPrimitiveType PrimType)
public void DrawArrays(int VbIndex, int First, int PrimCount, GalPrimitiveType PrimType)
{
VbInfo Vb = VertexBuffers[VbIndex];
if (Vb.PrimCount == 0)
if (PrimCount == 0)
{
return;
}
VbInfo Vb = VertexBuffers[VbIndex];
GL.BindVertexArray(Vb.VaoHandle);
GL.DrawArrays(OGLEnumConverter.GetPrimitiveType(PrimType), 0, Vb.PrimCount);
GL.DrawArrays(OGLEnumConverter.GetPrimitiveType(PrimType), First, PrimCount);
}
public void DrawElements(int VbIndex, int First, GalPrimitiveType PrimType)
{
VbInfo Vb = VertexBuffers[VbIndex];
if (Vb.PrimCount == 0)
{
return;
}
PrimitiveType Mode = OGLEnumConverter.GetPrimitiveType(PrimType);
GL.BindVertexArray(Vb.VaoHandle);

9
Ryujinx.Graphics/Gal/OpenGL/OpenGLRenderer.cs
View file

@ -146,6 +146,11 @@ namespace Ryujinx.Graphics.Gal.OpenGL
ActionsQueue.Enqueue(() => FrameBuffer.SetViewport(X, Y, Width, Height));
}
public void GetFrameBufferData(long Tag, Action<byte[]> Callback)
{
ActionsQueue.Enqueue(() => FrameBuffer.GetBufferData(Tag, Callback));
}
public void ClearBuffers(int RtIndex, GalClearBufferFlags Flags)
{
ActionsQueue.Enqueue(() => Rasterizer.ClearBuffers(RtIndex, Flags));
@ -173,14 +178,14 @@ namespace Ryujinx.Graphics.Gal.OpenGL
ActionsQueue.Enqueue(() => Rasterizer.SetIndexArray(Buffer, Format));
}
public void DrawArrays(int VbIndex, GalPrimitiveType PrimType)
public void DrawArrays(int VbIndex, int First, int PrimCount, GalPrimitiveType PrimType)
{
if ((uint)VbIndex > 31)
{
throw new ArgumentOutOfRangeException(nameof(VbIndex));
}
ActionsQueue.Enqueue(() => Rasterizer.DrawArrays(VbIndex, PrimType));
ActionsQueue.Enqueue(() => Rasterizer.DrawArrays(VbIndex, First, PrimCount, PrimType));
}
public void DrawElements(int VbIndex, int First, GalPrimitiveType PrimType)

108
Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs
View file

@ -31,51 +31,53 @@ namespace Ryujinx.Graphics.Gal.Shader
{
InstsExpr = new Dictionary<ShaderIrInst, GetInstExpr>()
{
{ ShaderIrInst.And, GetAndExpr },
{ ShaderIrInst.Asr, GetAsrExpr },
{ ShaderIrInst.Band, GetBandExpr },
{ ShaderIrInst.Bnot, GetBnotExpr },
{ ShaderIrInst.Ceil, GetCeilExpr },
{ ShaderIrInst.Ceq, GetCeqExpr },
{ ShaderIrInst.Cge, GetCgeExpr },
{ ShaderIrInst.Cgt, GetCgtExpr },
{ ShaderIrInst.Clamp, GetClampExpr },
{ ShaderIrInst.Cle, GetCleExpr },
{ ShaderIrInst.Clt, GetCltExpr },
{ ShaderIrInst.Cne, GetCneExpr },
{ ShaderIrInst.Exit, GetExitExpr },
{ ShaderIrInst.Fabs, GetFabsExpr },
{ ShaderIrInst.Fadd, GetFaddExpr },
{ ShaderIrInst.Fceq, GetCeqExpr },
{ ShaderIrInst.Fcge, GetCgeExpr },
{ ShaderIrInst.Fcgt, GetCgtExpr },
{ ShaderIrInst.Fcle, GetCleExpr },
{ ShaderIrInst.Fclt, GetCltExpr },
{ ShaderIrInst.Fcne, GetCneExpr },
{ ShaderIrInst.Fcos, GetFcosExpr },
{ ShaderIrInst.Fex2, GetFex2Expr },
{ ShaderIrInst.Ffma, GetFfmaExpr },
{ ShaderIrInst.Flg2, GetFlg2Expr },
{ ShaderIrInst.Floor, GetFloorExpr },
{ ShaderIrInst.Fmul, GetFmulExpr },
{ ShaderIrInst.Fneg, GetFnegExpr },
{ ShaderIrInst.Frcp, GetFrcpExpr },
{ ShaderIrInst.Frsq, GetFrsqExpr },
{ ShaderIrInst.Fsin, GetFsinExpr },
{ ShaderIrInst.Ftos, GetFtosExpr },
{ ShaderIrInst.Ftou, GetFtouExpr },
{ ShaderIrInst.Ipa, GetIpaExpr },
{ ShaderIrInst.Kil, GetKilExpr },
{ ShaderIrInst.Lsr, GetLsrExpr },
{ ShaderIrInst.Not, GetNotExpr },
{ ShaderIrInst.Or, GetOrExpr },
{ ShaderIrInst.Stof, GetStofExpr },
{ ShaderIrInst.Texq, GetTexqExpr },
{ ShaderIrInst.Texs, GetTexsExpr },
{ ShaderIrInst.Trunc, GetTruncExpr },
{ ShaderIrInst.Txlf, GetTxlfExpr },
{ ShaderIrInst.Utof, GetUtofExpr },
{ ShaderIrInst.Xor, GetXorExpr }
{ ShaderIrInst.And, GetAndExpr },
{ ShaderIrInst.Asr, GetAsrExpr },
{ ShaderIrInst.Band, GetBandExpr },
{ ShaderIrInst.Bnot, GetBnotExpr },
{ ShaderIrInst.Ceil, GetCeilExpr },
{ ShaderIrInst.Ceq, GetCeqExpr },
{ ShaderIrInst.Cge, GetCgeExpr },
{ ShaderIrInst.Cgt, GetCgtExpr },
{ ShaderIrInst.Clamps, GetClampsExpr },
{ ShaderIrInst.Clampu, GetClampuExpr },
{ ShaderIrInst.Cle, GetCleExpr },
{ ShaderIrInst.Clt, GetCltExpr },
{ ShaderIrInst.Cne, GetCneExpr },
{ ShaderIrInst.Exit, GetExitExpr },
{ ShaderIrInst.Fabs, GetFabsExpr },
{ ShaderIrInst.Fadd, GetFaddExpr },
{ ShaderIrInst.Fceq, GetCeqExpr },
{ ShaderIrInst.Fcge, GetCgeExpr },
{ ShaderIrInst.Fcgt, GetCgtExpr },
{ ShaderIrInst.Fclamp, GetFclampExpr },
{ ShaderIrInst.Fcle, GetCleExpr },
{ ShaderIrInst.Fclt, GetCltExpr },
{ ShaderIrInst.Fcne, GetCneExpr },
{ ShaderIrInst.Fcos, GetFcosExpr },
{ ShaderIrInst.Fex2, GetFex2Expr },
{ ShaderIrInst.Ffma, GetFfmaExpr },
{ ShaderIrInst.Flg2, GetFlg2Expr },
{ ShaderIrInst.Floor, GetFloorExpr },
{ ShaderIrInst.Fmul, GetFmulExpr },
{ ShaderIrInst.Fneg, GetFnegExpr },
{ ShaderIrInst.Frcp, GetFrcpExpr },
{ ShaderIrInst.Frsq, GetFrsqExpr },
{ ShaderIrInst.Fsin, GetFsinExpr },
{ ShaderIrInst.Ftos, GetFtosExpr },
{ ShaderIrInst.Ftou, GetFtouExpr },
{ ShaderIrInst.Ipa, GetIpaExpr },
{ ShaderIrInst.Kil, GetKilExpr },
{ ShaderIrInst.Lsr, GetLsrExpr },
{ ShaderIrInst.Not, GetNotExpr },
{ ShaderIrInst.Or, GetOrExpr },
{ ShaderIrInst.Stof, GetStofExpr },
{ ShaderIrInst.Texq, GetTexqExpr },
{ ShaderIrInst.Texs, GetTexsExpr },
{ ShaderIrInst.Trunc, GetTruncExpr },
{ ShaderIrInst.Txlf, GetTxlfExpr },
{ ShaderIrInst.Utof, GetUtofExpr },
{ ShaderIrInst.Xor, GetXorExpr }
};
}
@ -478,7 +480,19 @@ namespace Ryujinx.Graphics.Gal.Shader
private string GetCeilExpr(ShaderIrOp Op) => GetUnaryCall(Op, "ceil");
private string GetClampExpr(ShaderIrOp Op) => GetTernaryCall(Op, "clamp");
private string GetClampsExpr(ShaderIrOp Op)
{
return "clamp(" + GetOperExpr(Op, Op.OperandA) + ", " +
GetOperExpr(Op, Op.OperandB) + ", " +
GetOperExpr(Op, Op.OperandC) + ")";
}
private string GetClampuExpr(ShaderIrOp Op)
{
return "int(clamp(uint(" + GetOperExpr(Op, Op.OperandA) + "), " +
"uint(" + GetOperExpr(Op, Op.OperandB) + "), " +
"uint(" + GetOperExpr(Op, Op.OperandC) + ")))";
}
private string GetCltExpr(ShaderIrOp Op) => GetBinaryExpr(Op, "<");
private string GetCeqExpr(ShaderIrOp Op) => GetBinaryExpr(Op, "==");
@ -499,6 +513,8 @@ namespace Ryujinx.Graphics.Gal.Shader
private string GetFfmaExpr(ShaderIrOp Op) => GetTernaryExpr(Op, "*", "+");
private string GetFclampExpr(ShaderIrOp Op) => GetTernaryCall(Op, "clamp");
private string GetFlg2Expr(ShaderIrOp Op) => GetUnaryCall(Op, "log2");
private string GetFloorExpr(ShaderIrOp Op) => GetUnaryCall(Op, "floor");

87
Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs
View file

@ -66,6 +66,21 @@ namespace Ryujinx.Graphics.Gal.Shader
EmitAluBinaryF(Block, OpCode, ShaderOper.RR, ShaderIrInst.Fmul);
}
public static void Fset_C(ShaderIrBlock Block, long OpCode)
{
EmitFset(Block, OpCode, ShaderOper.CR);
}
public static void Fset_I(ShaderIrBlock Block, long OpCode)
{
EmitFset(Block, OpCode, ShaderOper.Immf);
}
public static void Fset_R(ShaderIrBlock Block, long OpCode)
{
EmitFset(Block, OpCode, ShaderOper.RR);
}
public static void Fsetp_C(ShaderIrBlock Block, long OpCode)
{
EmitFsetp(Block, OpCode, ShaderOper.CR);
@ -279,6 +294,78 @@ namespace Ryujinx.Graphics.Gal.Shader
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode));
}
private static void EmitFset(ShaderIrBlock Block, long OpCode, ShaderOper Oper)
{
EmitSet(Block, OpCode, true, Oper);
}
private static void EmitIset(ShaderIrBlock Block, long OpCode, ShaderOper Oper)
{
EmitSet(Block, OpCode, false, Oper);
}
private static void EmitSet(ShaderIrBlock Block, long OpCode, bool IsFloat, ShaderOper Oper)
{
bool Na = ((OpCode >> 43) & 1) != 0;
bool Ab = ((OpCode >> 44) & 1) != 0;
bool Nb = ((OpCode >> 53) & 1) != 0;
bool Aa = ((OpCode >> 54) & 1) != 0;
ShaderIrNode OperA = GetOperGpr8(OpCode), OperB;
switch (Oper)
{
case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break;
case ShaderOper.Imm: OperB = GetOperImm19_20 (OpCode); break;
case ShaderOper.Immf: OperB = GetOperImmf19_20(OpCode); break;
case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break;
default: throw new ArgumentException(nameof(Oper));
}
ShaderIrInst CmpInst;
if (IsFloat)
{
OperA = GetAluAbsNeg(OperA, Aa, Na);
OperB = GetAluAbsNeg(OperB, Ab, Nb);
CmpInst = GetCmpF(OpCode);
}
else
{
CmpInst = GetCmp(OpCode);
}
ShaderIrOp Op = new ShaderIrOp(CmpInst, OperA, OperB);
ShaderIrInst LopInst = GetBLop(OpCode);
ShaderIrOperPred PNode = GetOperPred39(OpCode);
ShaderIrOperImmf Imm0 = new ShaderIrOperImmf(0);
ShaderIrOperImmf Imm1 = new ShaderIrOperImmf(1);
ShaderIrNode Asg0 = new ShaderIrAsg(GetOperGpr0(OpCode), Imm0);
ShaderIrNode Asg1 = new ShaderIrAsg(GetOperGpr0(OpCode), Imm1);
if (LopInst != ShaderIrInst.Band || !PNode.IsConst)
{
ShaderIrOp Op2 = new ShaderIrOp(LopInst, Op, PNode);
Asg0 = new ShaderIrCond(Op2, Asg0, Not: true);
Asg1 = new ShaderIrCond(Op2, Asg1, Not: false);
}
else
{
Asg0 = new ShaderIrCond(Op, Asg0, Not: true);
Asg1 = new ShaderIrCond(Op, Asg1, Not: false);
}
Block.AddNode(GetPredNode(Asg0, OpCode));
Block.AddNode(GetPredNode(Asg1, OpCode));
}
private static void EmitFsetp(ShaderIrBlock Block, long OpCode, ShaderOper Oper)
{
EmitSetp(Block, OpCode, true, Oper);

92
Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs
View file

@ -70,6 +70,21 @@ namespace Ryujinx.Graphics.Gal.Shader
EmitI2f(Block, OpCode, ShaderOper.RR);
}
public static void I2i_C(ShaderIrBlock Block, long OpCode)
{
EmitI2i(Block, OpCode, ShaderOper.CR);
}
public static void I2i_I(ShaderIrBlock Block, long OpCode)
{
EmitI2i(Block, OpCode, ShaderOper.Imm);
}
public static void I2i_R(ShaderIrBlock Block, long OpCode)
{
EmitI2i(Block, OpCode, ShaderOper.RR);
}
public static void Mov_C(ShaderIrBlock Block, long OpCode)
{
ShaderIrOperCbuf Cbuf = GetOperCbuf34(OpCode);
@ -183,7 +198,7 @@ namespace Ryujinx.Graphics.Gal.Shader
ShaderIrOperImmf IMin = new ShaderIrOperImmf(CMin);
ShaderIrOperImmf IMax = new ShaderIrOperImmf(CMax);
OperA = new ShaderIrOp(ShaderIrInst.Clamp, OperA, IMin, IMax);
OperA = new ShaderIrOp(ShaderIrInst.Fclamp, OperA, IMin, IMax);
}
ShaderIrInst Inst = Signed
@ -252,6 +267,81 @@ namespace Ryujinx.Graphics.Gal.Shader
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode));
}
private static void EmitI2i(ShaderIrBlock Block, long OpCode, ShaderOper Oper)
{
IntType Type = GetIntType(OpCode);
if (Type == IntType.U64 ||
Type == IntType.S64)
{
//TODO: 64-bits support.
//Note: GLSL doesn't support 64-bits integers.
throw new NotImplementedException();
}
int Sel = (int)(OpCode >> 41) & 3;
bool NegA = ((OpCode >> 45) & 1) != 0;
bool AbsA = ((OpCode >> 49) & 1) != 0;
bool SatA = ((OpCode >> 50) & 1) != 0;
ShaderIrNode OperA;
switch (Oper)
{
case ShaderOper.CR: OperA = GetOperCbuf34 (OpCode); break;
case ShaderOper.Immf: OperA = GetOperImmf19_20(OpCode); break;
case ShaderOper.RR: OperA = GetOperGpr20 (OpCode); break;
default: throw new ArgumentException(nameof(Oper));
}
OperA = GetAluAbsNeg(OperA, AbsA, NegA);
bool Signed = Type >= IntType.S8;
int Shift = Sel * 8;
int Size = 8 << ((int)Type & 3);
if (Shift != 0)
{
OperA = new ShaderIrOp(ShaderIrInst.Asr, OperA, new ShaderIrOperImm(Shift));
}
if (Size < 32)
{
uint Mask = uint.MaxValue >> (32 - Size);
if (SatA)
{
uint CMin = 0;
uint CMax = Mask;
if (Signed)
{
uint HalfMask = Mask >> 1;
CMin -= HalfMask + 1;
CMax = HalfMask;
}
ShaderIrOperImm IMin = new ShaderIrOperImm((int)CMin);
ShaderIrOperImm IMax = new ShaderIrOperImm((int)CMax);
OperA = new ShaderIrOp(Signed
? ShaderIrInst.Clamps
: ShaderIrInst.Clampu, OperA, IMin, IMax);
}
else
{
OperA = new ShaderIrOp(ShaderIrInst.And, OperA, new ShaderIrOperImm((int)Mask));
}
}
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), OperA), OpCode));
}
private static IntType GetIntType(long OpCode)
{
bool Signed = ((OpCode >> 13) & 1) != 0;

5
Ryujinx.Graphics/Gal/Shader/ShaderIrInst.cs
View file

@ -13,7 +13,7 @@ namespace Ryujinx.Graphics.Gal.Shader
F_Start,
Ceil,
Clamp,
Fabs,
Fadd,
Fceq,
@ -22,6 +22,7 @@ namespace Ryujinx.Graphics.Gal.Shader
Fcgeu,
Fcgt,
Fcgtu,
Fclamp,
Fcle,
Fcleu,
Fclt,
@ -53,6 +54,8 @@ namespace Ryujinx.Graphics.Gal.Shader
Ceq,
Cge,
Cgt,
Clamps,
Clampu,
Cle,
Clt,
Cne,

32
Ryujinx.Graphics/Gal/Shader/ShaderOpCodeTable.cs
View file

@ -6,11 +6,24 @@ namespace Ryujinx.Graphics.Gal.Shader
{
private const int EncodingBits = 14;
private static ShaderDecodeFunc[] OpCodes;
private class ShaderDecodeEntry
{
public ShaderDecodeFunc Func;
public int XBits;
public ShaderDecodeEntry(ShaderDecodeFunc Func, int XBits)
{
this.Func = Func;
this.XBits = XBits;
}
}
private static ShaderDecodeEntry[] OpCodes;
static ShaderOpCodeTable()
{
OpCodes = new ShaderDecodeFunc[1 << EncodingBits];
OpCodes = new ShaderDecodeEntry[1 << EncodingBits];
#region Instructions
Set("111000110000xx", ShaderDecode.Exit);
@ -31,12 +44,18 @@ namespace Ryujinx.Graphics.Gal.Shader
Set("0100110001101x", ShaderDecode.Fmul_C);
Set("0011100x01101x", ShaderDecode.Fmul_I);
Set("0101110001101x", ShaderDecode.Fmul_R);
Set("0100100xxxxxxx", ShaderDecode.Fset_C);
Set("0011000xxxxxxx", ShaderDecode.Fset_I);
Set("01011000xxxxxx", ShaderDecode.Fset_R);
Set("010010111011xx", ShaderDecode.Fsetp_C);
Set("0011011x1011xx", ShaderDecode.Fsetp_I);
Set("010110111011xx", ShaderDecode.Fsetp_R);
Set("0100110010111x", ShaderDecode.I2f_C);
Set("0011100x10111x", ShaderDecode.I2f_I);
Set("0101110010111x", ShaderDecode.I2f_R);
Set("0100110011100x", ShaderDecode.I2i_C);
Set("0011100x11100x", ShaderDecode.I2i_I);
Set("0101110011100x", ShaderDecode.I2i_R);
Set("11100000xxxxxx", ShaderDecode.Ipa);
Set("010010110110xx", ShaderDecode.Isetp_C);
Set("0011011x0110xx", ShaderDecode.Isetp_I);
@ -91,6 +110,8 @@ namespace Ryujinx.Graphics.Gal.Shader
XMask = ~XMask;
ShaderDecodeEntry Entry = new ShaderDecodeEntry(Func, XBits);
for (int Index = 0; Index < (1 << XBits); Index++)
{
Value &= XMask;
@ -100,13 +121,16 @@ namespace Ryujinx.Graphics.Gal.Shader
Value |= ((Index >> X) & 1) << XPos[X];
}
OpCodes[Value] = Func;
if (OpCodes[Value] == null || OpCodes[Value].XBits > XBits)
{
OpCodes[Value] = Entry;
}
}
}
public static ShaderDecodeFunc GetDecoder(long OpCode)
{
return OpCodes[(ulong)OpCode >> (64 - EncodingBits)];
return OpCodes[(ulong)OpCode >> (64 - EncodingBits)]?.Func;
}
}
}

4
Ryujinx.Graphics/Gpu/NsGpu.cs
View file

@ -7,10 +7,11 @@ namespace Ryujinx.Graphics.Gpu
{
public IGalRenderer Renderer { get; private set; }
internal NsGpuMemoryMgr MemoryMgr { get; private set; }
public NsGpuMemoryMgr MemoryMgr { get; private set; }
public NvGpuFifo Fifo { get; private set; }
public NvGpuEngine2d Engine2d { get; private set; }
public NvGpuEngine3d Engine3d { get; private set; }
private Thread FifoProcessing;
@ -25,6 +26,7 @@ namespace Ryujinx.Graphics.Gpu
Fifo = new NvGpuFifo(this);
Engine2d = new NvGpuEngine2d(this);
Engine3d = new NvGpuEngine3d(this);
KeepRunning = true;

12
Ryujinx.Graphics/Gpu/NsGpuMemoryMgr.cs
View file

@ -1,6 +1,6 @@
namespace Ryujinx.Graphics.Gpu
{
class NsGpuMemoryMgr
public class NsGpuMemoryMgr
{
private const long AddrSize = 1L << 40;
@ -50,12 +50,20 @@ namespace Ryujinx.Graphics.Gpu
return GpuAddr;
}
public void Unmap(long Position, long Size)
{
for (long Offset = 0; Offset < Size; Offset += PageSize)
{
SetPTAddr(Position + Offset, PteUnmapped);
}
}
public long Map(long CpuAddr, long Size)
{
CpuAddr &= ~PageMask;
long Position = GetFreePosition(Size);
if (Position != -1)
{
for (long Offset = 0; Offset < Size; Offset += PageSize)

158
Ryujinx.Graphics/Gpu/NvGpuEngine2d.cs Normal file
View file

@ -0,0 +1,158 @@
using ChocolArm64.Memory;
using Ryujinx.Graphics.Gal;
using System.Collections.Generic;
namespace Ryujinx.Graphics.Gpu
{
public class NvGpuEngine2d : INvGpuEngine
{
private enum CopyOperation
{
SrcCopyAnd,
RopAnd,
Blend,
SrcCopy,
Rop,
SrcCopyPremult,
BlendPremult
}
public int[] Registers { get; private set; }
private NsGpu Gpu;
private Dictionary<int, NvGpuMethod> Methods;
public NvGpuEngine2d(NsGpu Gpu)
{
this.Gpu = Gpu;
Registers = new int[0xe00];
Methods = new Dictionary<int, NvGpuMethod>();
void AddMethod(int Meth, int Count, int Stride, NvGpuMethod Method)
{
while (Count-- > 0)
{
Methods.Add(Meth, Method);
Meth += Stride;
}
}
AddMethod(0xb5, 1, 1, TextureCopy);
}
public void CallMethod(AMemory Memory, NsGpuPBEntry PBEntry)
{
if (Methods.TryGetValue(PBEntry.Method, out NvGpuMethod Method))
{
Method(Memory, PBEntry);
}
else
{
WriteRegister(PBEntry);
}
}
private void TextureCopy(AMemory Memory, NsGpuPBEntry PBEntry)
{
CopyOperation Operation = (CopyOperation)ReadRegister(NvGpuEngine2dReg.CopyOperation);
bool SrcLinear = ReadRegister(NvGpuEngine2dReg.SrcLinear) != 0;
int SrcWidth = ReadRegister(NvGpuEngine2dReg.SrcWidth);
int SrcHeight = ReadRegister(NvGpuEngine2dReg.SrcHeight);
bool DstLinear = ReadRegister(NvGpuEngine2dReg.DstLinear) != 0;
int DstWidth = ReadRegister(NvGpuEngine2dReg.DstWidth);
int DstHeight = ReadRegister(NvGpuEngine2dReg.DstHeight);
int DstPitch = ReadRegister(NvGpuEngine2dReg.DstPitch);
int DstBlkDim = ReadRegister(NvGpuEngine2dReg.DstBlockDimensions);
TextureSwizzle DstSwizzle = DstLinear
? TextureSwizzle.Pitch
: TextureSwizzle.BlockLinear;
int DstBlockHeight = 1 << ((DstBlkDim >> 4) & 0xf);
long Tag = MakeInt64From2xInt32(NvGpuEngine2dReg.SrcAddress);
TryGetCpuAddr(NvGpuEngine2dReg.SrcAddress, out long SrcAddress);
TryGetCpuAddr(NvGpuEngine2dReg.DstAddress, out long DstAddress);
bool IsFbTexture = Gpu.Engine3d.IsFrameBufferPosition(Tag);
if (IsFbTexture && DstLinear)
{
DstSwizzle = TextureSwizzle.BlockLinear;
}
Texture DstTexture = new Texture(
DstAddress,
DstWidth,
DstHeight,
DstBlockHeight,
DstBlockHeight,
DstSwizzle,
GalTextureFormat.A8B8G8R8);
if (IsFbTexture)
{
Gpu.Renderer.GetFrameBufferData(Tag, (byte[] Buffer) =>
{
CopyTexture(Memory, DstTexture, Buffer);
});
}
else
{
long Size = SrcWidth * SrcHeight * 4;
byte[] Buffer = AMemoryHelper.ReadBytes(Memory, SrcAddress, Size);
CopyTexture(Memory, DstTexture, Buffer);
}
}
private void CopyTexture(AMemory Memory, Texture Texture, byte[] Buffer)
{
TextureWriter.Write(Memory, Texture, Buffer);
}
private bool TryGetCpuAddr(NvGpuEngine2dReg Reg, out long Position)
{
Position = MakeInt64From2xInt32(Reg);
Position = Gpu.GetCpuAddr(Position);
return Position != -1;
}
private long MakeInt64From2xInt32(NvGpuEngine2dReg Reg)
{
return
(long)Registers[(int)Reg + 0] << 32 |
(uint)Registers[(int)Reg + 1];
}
private void WriteRegister(NsGpuPBEntry PBEntry)
{
int ArgsCount = PBEntry.Arguments.Count;
if (ArgsCount > 0)
{
Registers[PBEntry.Method] = PBEntry.Arguments[ArgsCount - 1];
}
}
private int ReadRegister(NvGpuEngine2dReg Reg)
{
return Registers[(int)Reg];
}
private void WriteRegister(NvGpuEngine2dReg Reg, int Value)
{
Registers[(int)Reg] = Value;
}
}
}

25
Ryujinx.Graphics/Gpu/NvGpuEngine2dReg.cs Normal file
View file

@ -0,0 +1,25 @@
namespace Ryujinx.Graphics.Gpu
{
enum NvGpuEngine2dReg
{
DstFormat = 0x80,
DstLinear = 0x81,
DstBlockDimensions = 0x82,
DstDepth = 0x83,
DstLayer = 0x84,
DstPitch = 0x85,
DstWidth = 0x86,
DstHeight = 0x87,
DstAddress = 0x88,
SrcFormat = 0x8c,
SrcLinear = 0x8d,
SrcBlockDimensions = 0x8e,
SrcDepth = 0x8f,
SrcLayer = 0x90,
SrcPitch = 0x91,
SrcWidth = 0x92,
SrcHeight = 0x93,
SrcAddress = 0x94,
CopyOperation = 0xab
}
}

5
Ryujinx.Graphics/Gpu/NvGpuEngine3d.cs
View file

@ -360,6 +360,9 @@ namespace Ryujinx.Graphics.Gpu
for (int Index = 0; Index < 32; Index++)
{
int VertexFirst = ReadRegister(NvGpuEngine3dReg.VertexArrayFirst);
int VertexCount = ReadRegister(NvGpuEngine3dReg.VertexArrayCount);
int Control = ReadRegister(NvGpuEngine3dReg.VertexArrayNControl + Index * 4);
bool Enable = (Control & 0x1000) != 0;
@ -394,7 +397,7 @@ namespace Ryujinx.Graphics.Gpu
}
else
{
Gpu.Renderer.DrawArrays(Index, PrimType);
Gpu.Renderer.DrawArrays(Index, VertexFirst, VertexCount, PrimType);
}
}
}

2
Ryujinx.Graphics/Gpu/NvGpuEngine3dReg.cs
View file

@ -12,6 +12,8 @@ namespace Ryujinx.Graphics.Gpu
ViewportTranslateX = 0x283,
ViewportTranslateY = 0x284,
ViewportTranslateZ = 0x285,
VertexArrayFirst = 0x35d,
VertexArrayCount = 0x35e,
VertexAttribNFormat = 0x458,
IBlendEnable = 0x4b9,
BlendSeparateAlpha = 0x4cf,

6
Ryujinx.Graphics/Gpu/NvGpuFifo.cs
View file

@ -139,11 +139,17 @@ namespace Ryujinx.Graphics.Gpu
{
switch (SubChannels[PBEntry.SubChannel])
{
case NvGpuEngine._2d: Call2dMethod(Memory, PBEntry); break;
case NvGpuEngine._3d: Call3dMethod(Memory, PBEntry); break;
}
}
}
private void Call2dMethod(AMemory Memory, NsGpuPBEntry PBEntry)
{
Gpu.Engine2d.CallMethod(Memory, PBEntry);
}
private void Call3dMethod(AMemory Memory, NsGpuPBEntry PBEntry)
{
if (PBEntry.Method < 0xe00)

23
Ryujinx.Graphics/Gpu/TextureHelper.cs Normal file
View file

@ -0,0 +1,23 @@
using System;
namespace Ryujinx.Graphics.Gpu
{
static class TextureHelper
{
public static ISwizzle GetSwizzle(Texture Texture, int Width, int Bpp)
{
switch (Texture.Swizzle)
{
case TextureSwizzle.Pitch:
case TextureSwizzle.PitchColorKey:
return new LinearSwizzle(Texture.Pitch, Bpp);
case TextureSwizzle.BlockLinear:
case TextureSwizzle.BlockLinearColorKey:
return new BlockLinearSwizzle(Width, Bpp, Texture.BlockHeight);
}
throw new NotImplementedException(Texture.Swizzle.ToString());
}
}
}

24
Ryujinx.Graphics/Gpu/TextureReader.cs
View file

@ -30,7 +30,7 @@ namespace Ryujinx.Graphics.Gpu
byte[] Output = new byte[Width * Height * 2];
ISwizzle Swizzle = GetSwizzle(Texture, Width, 2);
ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, Width, 2);
fixed (byte* BuffPtr = Output)
{
@ -59,7 +59,7 @@ namespace Ryujinx.Graphics.Gpu
byte[] Output = new byte[Width * Height * 4];
ISwizzle Swizzle = GetSwizzle(Texture, Width, 4);
ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, Width, 4);
fixed (byte* BuffPtr = Output)
{
@ -88,7 +88,7 @@ namespace Ryujinx.Graphics.Gpu
byte[] Output = new byte[Width * Height * 8];
ISwizzle Swizzle = GetSwizzle(Texture, Width, 8);
ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, Width, 8);
fixed (byte* BuffPtr = Output)
{
@ -117,7 +117,7 @@ namespace Ryujinx.Graphics.Gpu
byte[] Output = new byte[Width * Height * 16];
ISwizzle Swizzle = GetSwizzle(Texture, Width, 16);
ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, Width, 16);
fixed (byte* BuffPtr = Output)
{
@ -140,21 +140,5 @@ namespace Ryujinx.Graphics.Gpu
return Output;
}
private static ISwizzle GetSwizzle(Texture Texture, int Width, int Bpp)
{
switch (Texture.Swizzle)
{
case TextureSwizzle.Pitch:
case TextureSwizzle.PitchColorKey:
return new LinearSwizzle(Texture.Pitch, Bpp);
case TextureSwizzle.BlockLinear:
case TextureSwizzle.BlockLinearColorKey:
return new BlockLinearSwizzle(Width, Bpp, Texture.BlockHeight);
}
throw new NotImplementedException(Texture.Swizzle.ToString());
}
}
}

45
Ryujinx.Graphics/Gpu/TextureWriter.cs Normal file
View file

@ -0,0 +1,45 @@
using ChocolArm64.Memory;
using Ryujinx.Graphics.Gal;
using System;
namespace Ryujinx.Graphics.Gpu
{
public static class TextureWriter
{
public static void Write(AMemory Memory, Texture Texture, byte[] Data)
{
switch (Texture.Format)
{
case GalTextureFormat.A8B8G8R8: Write4Bpp(Memory, Texture, Data); break;
default:
throw new NotImplementedException(Texture.Format.ToString());
}
}
private unsafe static void Write4Bpp(AMemory Memory, Texture Texture, byte[] Data)
{
int Width = Texture.Width;
int Height = Texture.Height;
ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, Width, 4);
fixed (byte* BuffPtr = Data)
{
long InOffs = 0;
for (int Y = 0; Y < Height; Y++)
for (int X = 0; X < Width; X++)
{
long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
int Pixel = *(int*)(BuffPtr + InOffs);
Memory.WriteInt32Unchecked(Texture.Position + Offset, Pixel);
InOffs += 4;
}
}
}
}
}

13
Ryujinx/Config.cs
View file

@ -22,14 +22,11 @@ namespace Ryujinx
AOptimizations.DisableMemoryChecks = !Convert.ToBoolean(Parser.Value("Enable_Memory_Checks"));
Console.WriteLine(Parser.Value("Logging_Enable_Warn"));
bool LoggingEnableDebug = Convert.ToBoolean(Parser.Value("Logging_Enable_Debug"));
bool LoggingEnableStub = Convert.ToBoolean(Parser.Value("Logging_Enable_Stub"));
bool LoggingEnableInfo = Convert.ToBoolean(Parser.Value("Logging_Enable_Info"));
bool LoggingEnableTrace = Convert.ToBoolean(Parser.Value("Logging_Enable_Trace"));
bool LoggingEnableWarn = Convert.ToBoolean(Parser.Value("Logging_Enable_Warn"));
bool LoggingEnableError = Convert.ToBoolean(Parser.Value("Logging_Enable_Error"));
Log.SetEnable(LogLevel.Debug, Convert.ToBoolean(Parser.Value("Logging_Enable_Debug")));
Log.SetEnable(LogLevel.Stub, Convert.ToBoolean(Parser.Value("Logging_Enable_Stub")));
Log.SetEnable(LogLevel.Info, Convert.ToBoolean(Parser.Value("Logging_Enable_Info")));
Log.SetEnable(LogLevel.Warning, Convert.ToBoolean(Parser.Value("Logging_Enable_Warn")));
Log.SetEnable(LogLevel.Error, Convert.ToBoolean(Parser.Value("Logging_Enable_Error")));
string[] FilteredLogClasses = Parser.Value("Logging_Filtered_Classes").Split(',', StringSplitOptions.RemoveEmptyEntries);