mirror of
https://github.com/ryujinx-mirror/ryujinx.git
synced 2024-12-25 02:45:45 +00:00
40b21cc3c4
* 3D engine now uses DeviceState too, plus new state modification tracking * Remove old methods code * Remove GpuState and friends * Optimize DeviceState, force inline some functions * This change was not supposed to go in * Proper channel initialization * Optimize state read/write methods even more * Fix debug build * Do not dirty state if the write is redundant * The YControl register should dirty either the viewport or front face state too, to update the host origin * Avoid redundant vertex buffer updates * Move state and get rid of the Ryujinx.Graphics.Gpu.State namespace * Comments and nits * Fix rebase * PR feedback * Move changed = false to improve codegen * PR feedback * Carry RyuJIT a bit more
95 lines
3.8 KiB
C#
95 lines
3.8 KiB
C#
using Ryujinx.Graphics.Device;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
namespace Ryujinx.Graphics.Gpu.Engine
|
|
{
|
|
/// <summary>
|
|
/// State interface with a shadow memory control register.
|
|
/// </summary>
|
|
interface IShadowState
|
|
{
|
|
/// <summary>
|
|
/// MME shadow ram control mode.
|
|
/// </summary>
|
|
SetMmeShadowRamControlMode SetMmeShadowRamControlMode { get; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents a device's state, with a additional shadow state.
|
|
/// </summary>
|
|
/// <typeparam name="TState">Type of the state</typeparam>
|
|
class DeviceStateWithShadow<TState> : IDeviceState where TState : unmanaged, IShadowState
|
|
{
|
|
private readonly DeviceState<TState> _state;
|
|
private readonly DeviceState<TState> _shadowState;
|
|
|
|
/// <summary>
|
|
/// Current device state.
|
|
/// </summary>
|
|
public ref TState State => ref _state.State;
|
|
|
|
/// <summary>
|
|
/// Creates a new instance of the device state, with shadow state.
|
|
/// </summary>
|
|
/// <param name="callbacks">Optional that will be called if a register specified by name is read or written</param>
|
|
/// <param name="debugLogCallback">Optional callback to be used for debug log messages</param>
|
|
public DeviceStateWithShadow(IReadOnlyDictionary<string, RwCallback> callbacks = null, Action<string> debugLogCallback = null)
|
|
{
|
|
_state = new DeviceState<TState>(callbacks, debugLogCallback);
|
|
_shadowState = new DeviceState<TState>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads a value from a register.
|
|
/// </summary>
|
|
/// <param name="offset">Register offset in bytes</param>
|
|
/// <returns>Value stored on the register</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public int Read(int offset)
|
|
{
|
|
return _state.Read(offset);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes a value to a register.
|
|
/// </summary>
|
|
/// <param name="offset">Register offset in bytes</param>
|
|
/// <param name="value">Value to be written</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public void Write(int offset, int value)
|
|
{
|
|
WriteWithRedundancyCheck(offset, value, out _);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes a value to a register, returning a value indicating if <paramref name="value"/>
|
|
/// is different from the current value on the register.
|
|
/// </summary>
|
|
/// <param name="offset">Register offset in bytes</param>
|
|
/// <param name="value">Value to be written</param>
|
|
/// <param name="changed">True if the value was changed, false otherwise</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public void WriteWithRedundancyCheck(int offset, int value, out bool changed)
|
|
{
|
|
var shadowRamControl = _state.State.SetMmeShadowRamControlMode;
|
|
if (shadowRamControl == SetMmeShadowRamControlMode.MethodPassthrough || offset < 0x200)
|
|
{
|
|
_state.WriteWithRedundancyCheck(offset, value, out changed);
|
|
}
|
|
else if (shadowRamControl == SetMmeShadowRamControlMode.MethodTrack ||
|
|
shadowRamControl == SetMmeShadowRamControlMode.MethodTrackWithFilter)
|
|
{
|
|
_shadowState.Write(offset, value);
|
|
_state.WriteWithRedundancyCheck(offset, value, out changed);
|
|
}
|
|
else /* if (shadowRamControl == SetMmeShadowRamControlMode.MethodReplay) */
|
|
{
|
|
Debug.Assert(shadowRamControl == SetMmeShadowRamControlMode.MethodReplay);
|
|
_state.WriteWithRedundancyCheck(offset, _shadowState.Read(offset), out changed);
|
|
}
|
|
}
|
|
}
|
|
}
|