public void CallMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) { if (Methods.TryGetValue(MethCall.Method, out NvGpuMethod Method)) { Method(Vmm, MethCall); } else { WriteRegister(MethCall); } }
public void CallMethod(NvGpuVmm vmm, GpuMethodCall methCall) { if (_methods.TryGetValue(methCall.Method, out NvGpuMethod method)) { method(vmm, methCall); } else { WriteRegister(methCall); } }
private void CbData(NvGpuVmm vmm, GpuMethodCall methCall) { long position = MakeInt64From2xInt32(NvGpuEngine3dReg.ConstBufferAddress); int offset = ReadRegister(NvGpuEngine3dReg.ConstBufferOffset); vmm.WriteInt32(position + offset, methCall.Argument); WriteRegister(NvGpuEngine3dReg.ConstBufferOffset, offset + 4); _gpu.ResourceManager.ClearPbCache(NvGpuBufferType.ConstBuffer); }
private void VertexEndGl(NvGpuVmm vmm, GpuMethodCall methCall) { Profile.Begin(Profiles.GPU.Engine3d.VertexEnd); LockCaches(); Profile.Begin(Profiles.GPU.Engine3d.ConfigureState); GalPipelineState state = new GalPipelineState(); // Framebuffer must be run configured because viewport dimensions may be used in other methods SetFrameBuffer(state); Profile.End(Profiles.GPU.Engine3d.ConfigureState); for (int fbIndex = 0; fbIndex < 8; fbIndex++) { SetFrameBuffer(vmm, fbIndex); } SetFrontFace(state); SetCullFace(state); SetDepth(state); SetStencil(state); SetScissor(state); SetBlending(state); SetColorMask(state); SetPrimitiveRestart(state); SetZeta(vmm); SetRenderTargets(); long[] keys = UploadShaders(vmm); _gpu.Renderer.Shader.BindProgram(); UploadTextures(vmm, state, keys); UploadConstBuffers(vmm, state, keys); UploadVertexArrays(vmm, state); DispatchRender(vmm, state); UnlockCaches(); Profile.End(Profiles.GPU.Engine3d.VertexEnd); }
public void CallMethod(NvGpuVmm vmm, GpuMethodCall methCall) { if (_methods.TryGetValue(methCall.Method, out NvGpuMethod method)) { ProfileConfig profile = Profiles.GPU.EngineM2mf.CallMethod; profile.SessionItem = method.Method.Name; Profile.Begin(profile); method(vmm, methCall); Profile.End(profile); } else { WriteRegister(methCall); } }
private void PushData(NvGpuVmm vmm, GpuMethodCall methCall) { if (_buffer == null) { return; } Profile.Begin(Profiles.GPU.EngineP2mf.PushData); for (int shift = 0; shift < 32 && _copyOffset < _copySize; shift += 8, _copyOffset++) { _buffer[_copyOffset] = (byte)(methCall.Argument >> shift); } if (methCall.IsLastCall) { if (_copyLinear) { vmm.WriteBytes(_copyAddress, _buffer); } else { BlockLinearSwizzle swizzle = new BlockLinearSwizzle( _copyWidth, _copyHeight, 1, _copyGobBlockHeight, 1, 1); int srcOffset = 0; for (int y = _copyStartY; y < _copyHeight && srcOffset < _copySize; y++) { for (int x = _copyStartX; x < _copyWidth && srcOffset < _copySize; x++) { int dstOffset = swizzle.GetSwizzleOffset(x, y, 0); vmm.WriteByte(_copyAddress + dstOffset, _buffer[srcOffset++]); } } } _buffer = null; } Profile.End(Profiles.GPU.EngineP2mf.PushData); }
private void Execute(NvGpuVmm vmm, GpuMethodCall methCall) { Profile.Begin(Profiles.GPU.EngineP2mf.Execute); //TODO: Some registers and copy modes are still not implemented. int control = methCall.Argument; long dstAddress = MakeInt64From2xInt32(NvGpuEngineP2mfReg.DstAddress); int dstPitch = ReadRegister(NvGpuEngineP2mfReg.DstPitch); int dstBlkDim = ReadRegister(NvGpuEngineP2mfReg.DstBlockDim); int dstX = ReadRegister(NvGpuEngineP2mfReg.DstX); int dstY = ReadRegister(NvGpuEngineP2mfReg.DstY); int dstWidth = ReadRegister(NvGpuEngineP2mfReg.DstWidth); int dstHeight = ReadRegister(NvGpuEngineP2mfReg.DstHeight); int lineLengthIn = ReadRegister(NvGpuEngineP2mfReg.LineLengthIn); int lineCount = ReadRegister(NvGpuEngineP2mfReg.LineCount); _copyLinear = (control & 1) != 0; _copyGobBlockHeight = 1 << ((dstBlkDim >> 4) & 0xf); _copyStartX = dstX; _copyStartY = dstY; _copyWidth = dstWidth; _copyHeight = dstHeight; _copyAddress = dstAddress; _copyOffset = 0; _copySize = lineLengthIn * lineCount; _buffer = new byte[_copySize]; Profile.End(Profiles.GPU.EngineP2mf.Execute); }
public void CallMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) { if ((NvGpuFifoMeth)MethCall.Method == NvGpuFifoMeth.BindChannel) { NvGpuEngine Engine = (NvGpuEngine)MethCall.Argument; SubChannels[MethCall.SubChannel] = Engine; } else { switch (SubChannels[MethCall.SubChannel]) { case NvGpuEngine._2d: Call2dMethod(Vmm, MethCall); break; case NvGpuEngine._3d: Call3dMethod(Vmm, MethCall); break; case NvGpuEngine.P2mf: CallP2mfMethod(Vmm, MethCall); break; case NvGpuEngine.M2mf: CallM2mfMethod(Vmm, MethCall); break; } } }
public void CallMethod(NvGpuVmm vmm, GpuMethodCall methCall) { if ((NvGpuFifoMeth)methCall.Method == NvGpuFifoMeth.BindChannel) { NvGpuEngine engine = (NvGpuEngine)methCall.Argument; _subChannels[methCall.SubChannel] = engine; } else { switch (_subChannels[methCall.SubChannel]) { case NvGpuEngine._2d: Call2dMethod(vmm, methCall); break; case NvGpuEngine._3d: Call3dMethod(vmm, methCall); break; case NvGpuEngine.P2mf: CallP2mfMethod(vmm, methCall); break; case NvGpuEngine.M2mf: CallM2mfMethod(vmm, methCall); break; } } }
private void PushData(NvGpuVmm Vmm, GpuMethodCall MethCall) { if (Buffer == null) { return; } for (int Shift = 0; Shift < 32 && CopyOffset < CopySize; Shift += 8, CopyOffset++) { Buffer[CopyOffset] = (byte)(MethCall.Argument >> Shift); } if (MethCall.IsLastCall) { if (CopyLinear) { Vmm.WriteBytes(CopyAddress, Buffer); } else { BlockLinearSwizzle Swizzle = new BlockLinearSwizzle(CopyWidth, 1, CopyGobBlockHeight); int SrcOffset = 0; for (int Y = CopyStartY; Y < CopyHeight && SrcOffset < CopySize; Y++) { for (int X = CopyStartX; X < CopyWidth && SrcOffset < CopySize; X++) { int DstOffset = Swizzle.GetSwizzleOffset(X, Y); Vmm.WriteByte(CopyAddress + DstOffset, Buffer[SrcOffset++]); } } } Buffer = null; } }
private void VertexEndGl(NvGpuVmm Vmm, GpuMethodCall MethCall) { LockCaches(); GalPipelineState State = new GalPipelineState(); SetFrameBuffer(State); SetFrontFace(State); SetCullFace(State); SetDepth(State); SetStencil(State); SetScissor(State); SetBlending(State); SetColorMask(State); SetPrimitiveRestart(State); for (int FbIndex = 0; FbIndex < 8; FbIndex++) { SetFrameBuffer(Vmm, FbIndex); } SetZeta(Vmm); SetRenderTargets(); long[] Keys = UploadShaders(Vmm); Gpu.Renderer.Shader.BindProgram(); UploadTextures(Vmm, State, Keys); UploadConstBuffers(Vmm, State, Keys); UploadVertexArrays(Vmm, State); DispatchRender(Vmm, State); UnlockCaches(); }
private void Execute(NvGpuVmm Vmm, GpuMethodCall MethCall) { //TODO: Some registers and copy modes are still not implemented. int Control = MethCall.Argument; long DstAddress = MakeInt64From2xInt32(NvGpuEngineP2mfReg.DstAddress); int DstPitch = ReadRegister(NvGpuEngineP2mfReg.DstPitch); int DstBlkDim = ReadRegister(NvGpuEngineP2mfReg.DstBlockDim); int DstX = ReadRegister(NvGpuEngineP2mfReg.DstX); int DstY = ReadRegister(NvGpuEngineP2mfReg.DstY); int DstWidth = ReadRegister(NvGpuEngineP2mfReg.DstWidth); int DstHeight = ReadRegister(NvGpuEngineP2mfReg.DstHeight); int LineLengthIn = ReadRegister(NvGpuEngineP2mfReg.LineLengthIn); int LineCount = ReadRegister(NvGpuEngineP2mfReg.LineCount); CopyLinear = (Control & 1) != 0; CopyGobBlockHeight = 1 << ((DstBlkDim >> 4) & 0xf); CopyStartX = DstX; CopyStartY = DstY; CopyWidth = DstWidth; CopyHeight = DstHeight; CopyAddress = DstAddress; CopyOffset = 0; CopySize = LineLengthIn * LineCount; Buffer = new byte[CopySize]; }
private void WriteRegister(GpuMethodCall MethCall) { Registers[MethCall.Method] = MethCall.Argument; }
private void Execute(NvGpuVmm Vmm, GpuMethodCall MethCall) { //TODO: Some registers and copy modes are still not implemented. int Control = MethCall.Argument; bool SrcLinear = ((Control >> 7) & 1) != 0; bool DstLinear = ((Control >> 8) & 1) != 0; bool Copy2d = ((Control >> 9) & 1) != 0; long SrcAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.SrcAddress); long DstAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.DstAddress); int SrcPitch = ReadRegister(NvGpuEngineM2mfReg.SrcPitch); int DstPitch = ReadRegister(NvGpuEngineM2mfReg.DstPitch); int XCount = ReadRegister(NvGpuEngineM2mfReg.XCount); int YCount = ReadRegister(NvGpuEngineM2mfReg.YCount); int Swizzle = ReadRegister(NvGpuEngineM2mfReg.Swizzle); int DstBlkDim = ReadRegister(NvGpuEngineM2mfReg.DstBlkDim); int DstSizeX = ReadRegister(NvGpuEngineM2mfReg.DstSizeX); int DstSizeY = ReadRegister(NvGpuEngineM2mfReg.DstSizeY); int DstSizeZ = ReadRegister(NvGpuEngineM2mfReg.DstSizeZ); int DstPosXY = ReadRegister(NvGpuEngineM2mfReg.DstPosXY); int DstPosZ = ReadRegister(NvGpuEngineM2mfReg.DstPosZ); int SrcBlkDim = ReadRegister(NvGpuEngineM2mfReg.SrcBlkDim); int SrcSizeX = ReadRegister(NvGpuEngineM2mfReg.SrcSizeX); int SrcSizeY = ReadRegister(NvGpuEngineM2mfReg.SrcSizeY); int SrcSizeZ = ReadRegister(NvGpuEngineM2mfReg.SrcSizeZ); int SrcPosXY = ReadRegister(NvGpuEngineM2mfReg.SrcPosXY); int SrcPosZ = ReadRegister(NvGpuEngineM2mfReg.SrcPosZ); int SrcCpp = ((Swizzle >> 20) & 7) + 1; int DstCpp = ((Swizzle >> 24) & 7) + 1; int DstPosX = (DstPosXY >> 0) & 0xffff; int DstPosY = (DstPosXY >> 16) & 0xffff; int SrcPosX = (SrcPosXY >> 0) & 0xffff; int SrcPosY = (SrcPosXY >> 16) & 0xffff; int SrcBlockHeight = 1 << ((SrcBlkDim >> 4) & 0xf); int DstBlockHeight = 1 << ((DstBlkDim >> 4) & 0xf); long SrcPA = Vmm.GetPhysicalAddress(SrcAddress); long DstPA = Vmm.GetPhysicalAddress(DstAddress); if (Copy2d) { if (SrcLinear) { SrcPosX = SrcPosY = SrcPosZ = 0; } if (DstLinear) { DstPosX = DstPosY = DstPosZ = 0; } if (SrcLinear && DstLinear) { for (int Y = 0; Y < YCount; Y++) { int SrcOffset = (SrcPosY + Y) * SrcPitch + SrcPosX * SrcCpp; int DstOffset = (DstPosY + Y) * DstPitch + DstPosX * DstCpp; long Src = SrcPA + (uint)SrcOffset; long Dst = DstPA + (uint)DstOffset; Vmm.Memory.CopyBytes(Src, Dst, XCount * SrcCpp); } } else { ISwizzle SrcSwizzle; if (SrcLinear) { SrcSwizzle = new LinearSwizzle(SrcPitch, SrcCpp); } else { SrcSwizzle = new BlockLinearSwizzle(SrcSizeX, SrcCpp, SrcBlockHeight); } ISwizzle DstSwizzle; if (DstLinear) { DstSwizzle = new LinearSwizzle(DstPitch, DstCpp); } else { DstSwizzle = new BlockLinearSwizzle(DstSizeX, DstCpp, DstBlockHeight); } for (int Y = 0; Y < YCount; Y++) { for (int X = 0; X < XCount; X++) { int SrcOffset = SrcSwizzle.GetSwizzleOffset(SrcPosX + X, SrcPosY + Y); int DstOffset = DstSwizzle.GetSwizzleOffset(DstPosX + X, DstPosY + Y); long Src = SrcPA + (uint)SrcOffset; long Dst = DstPA + (uint)DstOffset; Vmm.Memory.CopyBytes(Src, Dst, SrcCpp); } } } } else { Vmm.Memory.CopyBytes(SrcPA, DstPA, XCount); } }
private void Execute(NvGpuVmm vmm, GpuMethodCall methCall) { //TODO: Some registers and copy modes are still not implemented. int control = methCall.Argument; bool srcLinear = ((control >> 7) & 1) != 0; bool dstLinear = ((control >> 8) & 1) != 0; bool copy2D = ((control >> 9) & 1) != 0; long srcAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.SrcAddress); long dstAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.DstAddress); int srcPitch = ReadRegister(NvGpuEngineM2mfReg.SrcPitch); int dstPitch = ReadRegister(NvGpuEngineM2mfReg.DstPitch); int xCount = ReadRegister(NvGpuEngineM2mfReg.XCount); int yCount = ReadRegister(NvGpuEngineM2mfReg.YCount); int swizzle = ReadRegister(NvGpuEngineM2mfReg.Swizzle); int dstBlkDim = ReadRegister(NvGpuEngineM2mfReg.DstBlkDim); int dstSizeX = ReadRegister(NvGpuEngineM2mfReg.DstSizeX); int dstSizeY = ReadRegister(NvGpuEngineM2mfReg.DstSizeY); int dstSizeZ = ReadRegister(NvGpuEngineM2mfReg.DstSizeZ); int dstPosXY = ReadRegister(NvGpuEngineM2mfReg.DstPosXY); int dstPosZ = ReadRegister(NvGpuEngineM2mfReg.DstPosZ); int srcBlkDim = ReadRegister(NvGpuEngineM2mfReg.SrcBlkDim); int srcSizeX = ReadRegister(NvGpuEngineM2mfReg.SrcSizeX); int srcSizeY = ReadRegister(NvGpuEngineM2mfReg.SrcSizeY); int srcSizeZ = ReadRegister(NvGpuEngineM2mfReg.SrcSizeZ); int srcPosXY = ReadRegister(NvGpuEngineM2mfReg.SrcPosXY); int srcPosZ = ReadRegister(NvGpuEngineM2mfReg.SrcPosZ); int srcCpp = ((swizzle >> 20) & 7) + 1; int dstCpp = ((swizzle >> 24) & 7) + 1; int dstPosX = (dstPosXY >> 0) & 0xffff; int dstPosY = (dstPosXY >> 16) & 0xffff; int srcPosX = (srcPosXY >> 0) & 0xffff; int srcPosY = (srcPosXY >> 16) & 0xffff; int srcBlockHeight = 1 << ((srcBlkDim >> 4) & 0xf); int dstBlockHeight = 1 << ((dstBlkDim >> 4) & 0xf); long srcPa = vmm.GetPhysicalAddress(srcAddress); long dstPa = vmm.GetPhysicalAddress(dstAddress); if (copy2D) { if (srcLinear) { srcPosX = srcPosY = srcPosZ = 0; } if (dstLinear) { dstPosX = dstPosY = dstPosZ = 0; } if (srcLinear && dstLinear) { for (int y = 0; y < yCount; y++) { int srcOffset = (srcPosY + y) * srcPitch + srcPosX * srcCpp; int dstOffset = (dstPosY + y) * dstPitch + dstPosX * dstCpp; long src = srcPa + (uint)srcOffset; long dst = dstPa + (uint)dstOffset; vmm.Memory.CopyBytes(src, dst, xCount * srcCpp); } } else { ISwizzle srcSwizzle; if (srcLinear) { srcSwizzle = new LinearSwizzle(srcPitch, srcCpp, srcSizeX, srcSizeY); } else { srcSwizzle = new BlockLinearSwizzle( srcSizeX, srcSizeY, 1, srcBlockHeight, 1, srcCpp); } ISwizzle dstSwizzle; if (dstLinear) { dstSwizzle = new LinearSwizzle(dstPitch, dstCpp, srcSizeX, srcSizeY); } else { dstSwizzle = new BlockLinearSwizzle( dstSizeX, dstSizeY, 1, dstBlockHeight, 1, dstCpp); } for (int y = 0; y < yCount; y++) { for (int x = 0; x < xCount; x++) { int srcOffset = srcSwizzle.GetSwizzleOffset(srcPosX + x, srcPosY + y, 0); int dstOffset = dstSwizzle.GetSwizzleOffset(dstPosX + x, dstPosY + y, 0); long src = srcPa + (uint)srcOffset; long dst = dstPa + (uint)dstOffset; vmm.Memory.CopyBytes(src, dst, srcCpp); } } } } else { vmm.Memory.CopyBytes(srcPa, dstPa, xCount); } }
private void CallM2mfMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) { Gpu.EngineM2mf.CallMethod(Vmm, MethCall); }
private void Call3dMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) { if (MethCall.Method < 0x80) { switch ((NvGpuFifoMeth)MethCall.Method) { case NvGpuFifoMeth.SetMacroUploadAddress: { CurrMacroPosition = MethCall.Argument; break; } case NvGpuFifoMeth.SendMacroCodeData: { Mme[CurrMacroPosition++] = MethCall.Argument; break; } case NvGpuFifoMeth.SetMacroBindingIndex: { CurrMacroBindIndex = MethCall.Argument; break; } case NvGpuFifoMeth.BindMacro: { int Position = MethCall.Argument; Macros[CurrMacroBindIndex] = new CachedMacro(this, Gpu.Engine3d, Position); break; } default: CallP2mfMethod(Vmm, MethCall); break; } } else if (MethCall.Method < 0xe00) { Gpu.Engine3d.CallMethod(Vmm, MethCall); } else { int MacroIndex = (MethCall.Method >> 1) & MacroIndexMask; if ((MethCall.Method & 1) != 0) { Macros[MacroIndex].PushArgument(MethCall.Argument); } else { Macros[MacroIndex].StartExecution(MethCall.Argument); } if (MethCall.IsLastCall) { Macros[MacroIndex].Execute(Vmm, Mme); } } }
private void Call2dMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) { Gpu.Engine2d.CallMethod(Vmm, MethCall); }
private void Execute(NvGpuVmm vmm, GpuMethodCall methCall) { Profile.Begin(Profiles.GPU.EngineM2mf.Execute); //TODO: Some registers and copy modes are still not implemented. int control = methCall.Argument; bool srcLinear = ((control >> 7) & 1) != 0; bool dstLinear = ((control >> 8) & 1) != 0; bool copy2D = ((control >> 9) & 1) != 0; long srcAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.SrcAddress); long dstAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.DstAddress); int srcPitch = ReadRegister(NvGpuEngineM2mfReg.SrcPitch); int dstPitch = ReadRegister(NvGpuEngineM2mfReg.DstPitch); int xCount = ReadRegister(NvGpuEngineM2mfReg.XCount); int yCount = ReadRegister(NvGpuEngineM2mfReg.YCount); int swizzle = ReadRegister(NvGpuEngineM2mfReg.Swizzle); int dstBlkDim = ReadRegister(NvGpuEngineM2mfReg.DstBlkDim); int dstSizeX = ReadRegister(NvGpuEngineM2mfReg.DstSizeX); int dstSizeY = ReadRegister(NvGpuEngineM2mfReg.DstSizeY); int dstSizeZ = ReadRegister(NvGpuEngineM2mfReg.DstSizeZ); int dstPosXY = ReadRegister(NvGpuEngineM2mfReg.DstPosXY); int dstPosZ = ReadRegister(NvGpuEngineM2mfReg.DstPosZ); int srcBlkDim = ReadRegister(NvGpuEngineM2mfReg.SrcBlkDim); int srcSizeX = ReadRegister(NvGpuEngineM2mfReg.SrcSizeX); int srcSizeY = ReadRegister(NvGpuEngineM2mfReg.SrcSizeY); int srcSizeZ = ReadRegister(NvGpuEngineM2mfReg.SrcSizeZ); int srcPosXY = ReadRegister(NvGpuEngineM2mfReg.SrcPosXY); int srcPosZ = ReadRegister(NvGpuEngineM2mfReg.SrcPosZ); int srcCpp = ((swizzle >> 20) & 7) + 1; int dstCpp = ((swizzle >> 24) & 7) + 1; int dstPosX = (dstPosXY >> 0) & 0xffff; int dstPosY = (dstPosXY >> 16) & 0xffff; int srcPosX = (srcPosXY >> 0) & 0xffff; int srcPosY = (srcPosXY >> 16) & 0xffff; int srcBlockHeight = 1 << ((srcBlkDim >> 4) & 0xf); int dstBlockHeight = 1 << ((dstBlkDim >> 4) & 0xf); long srcPa = vmm.GetPhysicalAddress(srcAddress); long dstPa = vmm.GetPhysicalAddress(dstAddress); if (copy2D) { if (srcLinear) { srcPosX = srcPosY = srcPosZ = 0; } if (dstLinear) { dstPosX = dstPosY = dstPosZ = 0; } if (srcLinear && dstLinear) { for (int y = 0; y < yCount; y++) { int srcOffset = (srcPosY + y) * srcPitch + srcPosX * srcCpp; int dstOffset = (dstPosY + y) * dstPitch + dstPosX * dstCpp; long src = srcPa + (uint)srcOffset; long dst = dstPa + (uint)dstOffset; vmm.Memory.CopyBytes(src, dst, xCount * srcCpp); } } else { ISwizzle srcSwizzle; if (srcLinear) { srcSwizzle = new LinearSwizzle(srcPitch, srcCpp, srcSizeX, srcSizeY); } else { srcSwizzle = new BlockLinearSwizzle( srcSizeX, srcSizeY, 1, srcBlockHeight, 1, srcCpp); } ISwizzle dstSwizzle; if (dstLinear) { dstSwizzle = new LinearSwizzle(dstPitch, dstCpp, srcSizeX, srcSizeY); } else { dstSwizzle = new BlockLinearSwizzle( dstSizeX, dstSizeY, 1, dstBlockHeight, 1, dstCpp); } // Calculate the bits per pixel int bpp = srcPitch / xCount; // Copying all the bits at the same time corrupts the texture, unknown why but probably because the texture isn't linear // To avoid this we will simply loop more times to cover all the bits, // this allows up to recalculate the memory locations for each iteration around the loop xCount *= bpp / srcCpp; for (int y = 0; y < yCount; y++) { for (int x = 0; x < xCount; x++) { int srcOffset = srcSwizzle.GetSwizzleOffset(srcPosX + x, srcPosY + y, 0); int dstOffset = dstSwizzle.GetSwizzleOffset(dstPosX + x, dstPosY + y, 0); long src = srcPa + (uint)srcOffset; long dst = dstPa + (uint)dstOffset; vmm.Memory.CopyBytes(src, dst, srcCpp); } } } } else { vmm.Memory.CopyBytes(srcPa, dstPa, xCount); } Profile.End(Profiles.GPU.EngineM2mf.Execute); }
private void Call2dMethod(NvGpuVmm vmm, GpuMethodCall methCall) { _gpu.Engine2d.CallMethod(vmm, methCall); }
private void Call3dMethod(NvGpuVmm vmm, GpuMethodCall methCall) { if (methCall.Method < 0x80) { switch ((NvGpuFifoMeth)methCall.Method) { case NvGpuFifoMeth.SetMacroUploadAddress: { _currMacroPosition = methCall.Argument; break; } case NvGpuFifoMeth.SendMacroCodeData: { _mme[_currMacroPosition++] = methCall.Argument; break; } case NvGpuFifoMeth.SetMacroBindingIndex: { _currMacroBindIndex = methCall.Argument; break; } case NvGpuFifoMeth.BindMacro: { int position = methCall.Argument; _macros[_currMacroBindIndex++] = new CachedMacro(this, _gpu.Engine3d, position); break; } default: CallP2mfMethod(vmm, methCall); break; } } else if (methCall.Method < 0xe00) { _gpu.Engine3d.CallMethod(vmm, methCall); } else { int macroIndex = (methCall.Method >> 1) & MacroIndexMask; if ((methCall.Method & 1) != 0) { _macros[macroIndex].PushArgument(methCall.Argument); } else { _macros[macroIndex].StartExecution(methCall.Argument); } if (methCall.IsLastCall) { _macros[macroIndex].Execute(vmm, _mme); } } }
private void CallM2mfMethod(NvGpuVmm vmm, GpuMethodCall methCall) { _gpu.EngineM2mf.CallMethod(vmm, methCall); }