/// <summary>
/// Initilize all commands in this viewmodel
/// </summary>
private void InitializeCommands()
{
ModifyResolutionCommand = new RelayCommand(p =>
{
lastEditedX = this.OriginalX.ToString();
lastEditedY = this.OriginalY.ToString();
IsResolutionModify = true;
});
CancelResolutionChangedCommand = new RelayCommand(p =>
{
try
{
this.OriginalX = int.Parse(lastEditedX);
this.OriginalY = int.Parse(lastEditedY);
}
catch { }
OnPropertyChanged("OriginalX");
OnPropertyChanged("OriginalY");
IsResolutionModify = false;
});
ApplyResolutionChangedCommand = new RelayCommand(p => {
IsResolutionModify = false;
ResolutionChanged?.Invoke(this, null);
});
}
public void ActivateAmendment(ResaAmendment amendment, bool active = true)
{
var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.ActivateAmendment(amendment, active);
if (amendment is ResaDeleteAmendment delAmendment)
{
OperativeParagraphChanged?.Invoke(this, delAmendment.TargetParagraph);
}
else if (amendment is ResaChangeAmendment changeAmendment)
{
OperativeParagraphChanged?.Invoke(this, changeAmendment.TargetParagraph);
}
else if (amendment is ResaMoveAmendment moveAmendment)
{
OperativeParagraphChanged?.Invoke(this, moveAmendment.SourceParagraph);
OperativeParagraphChanged?.Invoke(this, moveAmendment.VirtualParagraph);
ResolutionChanged?.Invoke(this, Resolution);
}
else if (amendment is ResaAddAmendment addAmendment)
{
ResolutionChanged?.Invoke(this, Resolution);
OperativeParagraphChanged?.Invoke(this, addAmendment.VirtualParagraph);
}
}
public unsafe void ChangeResolution(int width, int height)
{
_width = width;
_height = height;
//Clear the current render target
DeviceContext.OMSetRenderTargets(_context, 0, null, IntPtr.Zero);
//Release all target objects, including _defaultRenderTarget
ReleaseRenderTargets?.Invoke();
//Release the default render view (containing reference to the back buffer)
NativeHelper.Dispose(ref _defaultRenderView);
//Resize swapchain
SwapChain.ResizeBuffers(_swapchain, 1, (uint)width, (uint)height, 28 /*R8G8B8A8_UNorm*/, 0).Check();
//Get the new back buffer and create default view
RebuildBackBuffer();
//Rebuild all target objects
RebuildRenderTargets?.Invoke();
//Apply current RenderTarget
CurrentTarget.Apply();
//Invoke external event
ResolutionChanged?.Invoke(this, EventArgs.Empty);
}
private void SafeInvokeChangeResolution(ResolutionChangeEventArgs resolutionChangeEventArgs)
{
if (ResolutionChanged == null)
{
return; //No Listeners
}
ResolutionChangeEvent listener = null;
Delegate[] dels = ResolutionChanged.GetInvocationList();
foreach (Delegate del in dels)
{
try
{
listener = (ResolutionChangeEvent)del;
listener.Invoke(resolutionChangeEventArgs);
}
catch (Exception)
{
//Could not reach the destination, so remove it
//from the list
ResolutionChanged -= listener;
}
}
}
public void ApplyGraphicsSettings()
{
GraphicsWidth = Config.GraphicsWidth;
GraphicsHeight = Config.GraphicsHeight;
switch (Config.WindowMode)
{
case WindowMode.BorderlessWindowed:
GraphicsWidth = GraphicsDevice.DisplayMode.Width;
GraphicsHeight = GraphicsDevice.DisplayMode.Height;
break;
case WindowMode.Windowed:
GraphicsWidth = Math.Min(GraphicsDevice.DisplayMode.Width, GraphicsWidth);
GraphicsHeight = Math.Min(GraphicsDevice.DisplayMode.Height, GraphicsHeight);
break;
}
GraphicsDeviceManager.GraphicsProfile = GfxProfile;
GraphicsDeviceManager.PreferredBackBufferFormat = SurfaceFormat.Color;
GraphicsDeviceManager.PreferMultiSampling = false;
GraphicsDeviceManager.SynchronizeWithVerticalRetrace = Config.VSyncEnabled;
SetWindowMode(Config.WindowMode);
defaultViewport = GraphicsDevice.Viewport;
ResolutionChanged?.Invoke();
}
public void SubmitAmendment(ResaAmendment amendment)
{
if (amendment is ResaDeleteAmendment deleteAmendment)
{
var resolution = amendment.Resolution;
var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.SubmitDeleteAmendment(deleteAmendment);
ResolutionChanged?.Invoke(this, resolution);
}
else if (amendment is ResaChangeAmendment changeAmendment)
{
var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.SubmitChangeAmendment(changeAmendment);
OperativeParagraphChanged?.Invoke(this, changeAmendment.TargetParagraph);
}
else if (amendment is ResaMoveAmendment moveAmendment)
{
var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.SubmitMoveAmendment(moveAmendment);
ResolutionChanged?.Invoke(this, Resolution);
}
else if (amendment is ResaAddAmendment addAmendment)
{
var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.SubmitAddAmendment(addAmendment);
ResolutionChanged?.Invoke(this, Resolution);
}
}
private void PeerConnection_OnTrack(IRTCTrackEvent Event)
{
if (Event.Track.Kind == "video")
{
_peerVideoTrack = Event.Track;
if (_peerVideoTrack != null)
{
_peerVideoTrack.Element = MediaElementMaker.Bind(Devices.Instance.PeerVideo);
((MediaStreamTrack)_peerVideoTrack).OnFrameRateChanged += (float frameRate) =>
{
FramesPerSecondChanged?.Invoke("PEER", frameRate.ToString("0.0"));
};
((MediaStreamTrack)_peerVideoTrack).OnResolutionChanged += (uint width, uint height) =>
{
ResolutionChanged?.Invoke("PEER", width, height);
};
}
}
else if (Event.Track.Kind == "audio")
{
_peerAudioTrack = Event.Track;
}
OnAddRemoteTrack?.Invoke(Event.Track);
}
public void UpdateResaElement()
{
using var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.UpdateResaElement(this.Resolution);
ResolutionChanged?.Invoke(this, Resolution);
}
private void Update()
{
if (_screen.x != Screen.width)
{
_screen.x = Screen.width;
ResolutionChanged?.Invoke();
}
}
public void RevokeSupport(ResaElement resolution, int roleId)
{
var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.RevokeSupport(resolution, roleId);
ResolutionChanged?.Invoke(this, resolution);
}
public void RevokeAddAmendment(ResaAddAmendment amendment)
{
using var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.RevokeAddAmendment(amendment);
ResolutionChanged?.Invoke(this, Resolution);
}
public void AddAddAmendment(int roleId, string newText)
{
using var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.AddAddAmendment(this.Resolution, roleId, newText);
ResolutionChanged?.Invoke(this, this.Resolution);
}
public override async Task Refresh( )
{
await base.Refresh( );
AppearanceChanged.OnNext(RawAppearance);
ParametersChanged.OnNext(RawParameters);
ResolutionChanged.OnNext(RawResolution);
DeviceNameChanged.OnNext(RawDeviceName);
}
public void RemoveOperativeParagraph(ResaOperativeParagraph paragraph)
{
using var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.RemoveOperativeParagraph(paragraph);
ResolutionChanged?.Invoke(this, Resolution);
}
public void AddMoveAmendment(ResaOperativeParagraph paragraph, int roleId, int newIndex)
{
using var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.AddMoveAmendment(paragraph, roleId, newIndex);
OperativeParagraphChanged?.Invoke(this, paragraph);
ResolutionChanged?.Invoke(this, Resolution);
}
private void OnResolutionChange(object sender, EventArgs e)
{
updateTransformMatrix();
if (ResolutionChanged != null)
{
ResolutionChanged.Invoke();
}
applyChanges();
}
private static void CheckResolution()
{
var width = BlzGetLocalClientWidth();
var height = BlzGetLocalClientHeight();
if (width != _resolutionWidth || height != _resolutionHeight)
{
RefreshResolution(width, height);
RefreshDefaultFrames();
ResolutionChanged?.Invoke(null, null);
}
}
public void RemovePreambleParagraph(ResaPreambleParagraph paragraph)
{
// Make update in database
using var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.RemovePreambleParagraph(paragraph);
this.Resolution.PreambleParagraphs.Remove(paragraph);
PreambleParagraphChanged?.Invoke(this, paragraph);
ResolutionChanged?.Invoke(this, Resolution);
}
public static void ApplyToScreen(this Resolution resolution, FullScreenMode fullScreenMode)
{
Screen.SetResolution(resolution.width, resolution.height, fullScreenMode, resolution.refreshRate);
#if UNITY_EDITOR
if (ResolutionChanged != null)
{
((Action)(() => ResolutionChanged(resolution))).PerformAfterCoroutine <WaitForEndOfFrame>(2);
}
#else
ResolutionChanged?.Invoke(resolution);
#endif
}
/// <summary>
/// Changes the resolution of the screen.
/// </summary>
/// <param name="resolution">The resolution to change to</param>
public static void ChangeScreenResolution(Point resolution)
{
var gdm = GameBase.Game.Graphics;
var oldResolution = new Point(gdm.PreferredBackBufferWidth, gdm.PreferredBackBufferHeight);
gdm.PreferredBackBufferWidth = resolution.X;
gdm.PreferredBackBufferHeight = resolution.Y;
gdm.ApplyChanges();
// Raise an event to let everyone know that the window has changed.
ResolutionChanged?.Invoke(typeof(WindowManager), new WindowResolutionChangedEventArgs(resolution, oldResolution));
}
private void BindSelfVideo()
{
if (_selfVideoTrack != null)
{
_selfVideoTrack.Element = MediaElementMaker.Bind(Devices.Instance.SelfVideo);
((MediaStreamTrack)_selfVideoTrack).OnFrameRateChanged += (float frameRate) =>
{
FramesPerSecondChanged?.Invoke("SELF", frameRate.ToString("0.0"));
};
((MediaStreamTrack)_selfVideoTrack).OnResolutionChanged += (uint width, uint height) =>
{
ResolutionChanged?.Invoke("SELF", width, height);
};
}
}
void presets_ListChangePosition(Widget source, EventArgs e)
{
uint selectedIndex = presets.getIndexSelected();
if (selectedIndex != uint.MaxValue)
{
RenderPreset preset = (RenderPreset)presets.getItemDataAt(selectedIndex);
ImageWidth = preset.Width;
ImageHeight = preset.Height;
if (ResolutionChanged != null)
{
ResolutionChanged.Invoke(this, EventArgs.Empty);
}
}
}
public void MovePreambleParagraphUp(ResaPreambleParagraph paragraph)
{
// Make update in database
using var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.MovePreambleParagraphUp(paragraph);
// Make update in exchange
var oldIndex = this.Resolution.PreambleParagraphs.IndexOf(paragraph);
this.Resolution.PreambleParagraphs.Swap(oldIndex, oldIndex - 1);
PreambleParagraphChanged?.Invoke(this, paragraph);
ResolutionChanged?.Invoke(this, Resolution);
}
/// <summary>
/// Detects resolution changes by comparing the last known resolution and the current one.
/// </summary>
private void DetectResolutionChanges()
{
// Get the current resolution
#if SHVDN2
SizeF resolution = Game.ScreenResolution;
#else
SizeF resolution = Screen.Resolution;
#endif
// If the old res does not matches the current one
if (lastKnownResolution != resolution)
{
// Trigger the event
ResolutionChanged?.Invoke(this, new ResolutionChangedEventArgs(lastKnownResolution, resolution));
// Refresh everything
RefreshAll();
// And save the new resolution
lastKnownResolution = resolution;
}
}
private void UpdateCurrentFrame(IRTCStats stats)
{
switch (stats.StatsType)
{
case RTCStatsType.Track:
var mediaStreamTrackStats = RTCMediaStreamTrackStats.Cast(stats);
if (mediaStreamTrackStats != null && !mediaStreamTrackStats.TrackId.Contains("audio"))
{
if (mediaStreamTrackStats.RemoteSource)
{
FramesPerSecondChanged?.Invoke("PEER", mediaStreamTrackStats.FramesPerSecond.ToString("0.#"));
ResolutionChanged?.Invoke("PEER", mediaStreamTrackStats.FrameWidth, mediaStreamTrackStats.FrameHeight);
}
else
{
FramesPerSecondChanged?.Invoke("SELF", mediaStreamTrackStats.FramesPerSecond.ToString("0.#"));
ResolutionChanged?.Invoke("SELF", mediaStreamTrackStats.FrameWidth, mediaStreamTrackStats.FrameHeight);
}
}
break;
}
}
public void MoveOperativeParagraphUp(ResaOperativeParagraph paragraph)
{
// Make update in database
using var scope = serviceScopeFactory.CreateScope();
var resolutionService = scope.ServiceProvider.GetRequiredService <ResolutionService>();
resolutionService.MoveOperativeParagraphUp(paragraph);
// Make update in exchange
if (paragraph.Parent == null)
{
var oldIndex = this.Resolution.OperativeParagraphs.IndexOf(paragraph);
this.Resolution.OperativeParagraphs.Swap(oldIndex, oldIndex - 1);
OperativeParagraphChanged?.Invoke(this, paragraph);
ResolutionChanged?.Invoke(this, Resolution);
}
else
{
var oldIndex = paragraph.Parent.Children.IndexOf(paragraph);
paragraph.Parent.Children.Swap(oldIndex, oldIndex - 1);
OperativeParagraphChanged?.Invoke(this, paragraph);
ResolutionChanged?.Invoke(this, Resolution);
}
}
private void ParseStats(IRTCStats stats, StatsData statsData)
{
try
{
switch (stats.StatsType)
{
case RTCStatsType.InboundRtp:
//Debug.WriteLine("RTCStatsType.InboundRtp:" + statId);
var inboundRtpStreamStats = RTCInboundRtpStreamStats.Cast(stats);
if (inboundRtpStreamStats != null)
{
TrackStatsData tsd =
statsData.GetTrackStatsData(inboundRtpStreamStats.MediaTrackId, false);
if (tsd != null)
{
if (statsData.TimeToSetupCall.Milliseconds == 0 && inboundRtpStreamStats.PacketsReceived > 0)
{
statsData.TimeToSetupCall = DateTime.Now - statsData.StarTime;
}
//if (!tsd.IsAudio)
// TestReceivedBytes.Add(inboundRtpStreamStats.BytesReceived);
tsd.AddAverage(RtcStatsValueName.StatsValueNameBytesReceived,
inboundRtpStreamStats.BytesReceived);
//if (!tsd.IsAudio)
//TestReceivedPackets.Add(inboundRtpStreamStats.PacketsReceived);
tsd.AddAverage(RtcStatsValueName.StatsValueNamePacketsReceived,
inboundRtpStreamStats.PacketsReceived);
tsd.AddAverage(RtcStatsValueName.StatsValueNamePacketsLost, inboundRtpStreamStats.PacketsLost);
tsd.AddData(RtcStatsValueName.StatsValueNameCurrentEndToEndDelayMs,
inboundRtpStreamStats.EndToEndDelay.TotalMilliseconds);
}
}
break;
case RTCStatsType.OutboundRtp:
var outboundRtpStreamStats = RTCOutboundRtpStreamStats.Cast(stats);
if (outboundRtpStreamStats != null)
{
TrackStatsData tsd =
statsData.GetTrackStatsData(outboundRtpStreamStats.MediaTrackId);
if (tsd != null)
{
tsd.AddAverage(RtcStatsValueName.StatsValueNameBytesSent, outboundRtpStreamStats.BytesSent);
tsd.AddAverage(RtcStatsValueName.StatsValueNamePacketsSent, outboundRtpStreamStats.PacketsSent);
}
}
break;
case RTCStatsType.Track:
var mediaStreamTrackStats = RTCMediaStreamTrackStats.Cast(stats);
if (mediaStreamTrackStats != null)
{
try
{
TrackStatsData tsd =
statsData.GetTrackStatsData(mediaStreamTrackStats.TrackId, !mediaStreamTrackStats.RemoteSource);
if (tsd != null && !tsd.IsAudio)
{
if (mediaStreamTrackStats.RemoteSource)
{
tsd.AddData(RtcStatsValueName.StatsValueNameFrameRateReceived,
mediaStreamTrackStats.FramesPerSecond);
tsd.AddData(RtcStatsValueName.StatsValueNameFrameWidthReceived,
mediaStreamTrackStats.FrameWidth);
tsd.AddData(RtcStatsValueName.StatsValueNameFrameHeightReceived,
mediaStreamTrackStats.FrameHeight);
FramesPerSecondChanged?.Invoke("PEER", mediaStreamTrackStats.FramesPerSecond.ToString("0.#"));
ResolutionChanged?.Invoke("PEER", mediaStreamTrackStats.FrameWidth, mediaStreamTrackStats.FrameHeight);
}
else
{
tsd.AddData(RtcStatsValueName.StatsValueNameFrameRateSent,
mediaStreamTrackStats.FramesPerSecond);
tsd.AddData(RtcStatsValueName.StatsValueNameFrameWidthSent,
mediaStreamTrackStats.FrameWidth);
tsd.AddData(RtcStatsValueName.StatsValueNameFrameHeightSent,
mediaStreamTrackStats.FrameHeight);
FramesPerSecondChanged?.Invoke("SELF", mediaStreamTrackStats.FramesPerSecond.ToString("0.#"));
ResolutionChanged?.Invoke("SELF", mediaStreamTrackStats.FrameWidth, mediaStreamTrackStats.FrameHeight);
}
}
}
catch (Exception e)
{
Debug.Write(e);
}
}
break;
}
}
catch (Exception e)
{
Debug.Write(e);
}
}
/// <summary>
/// Resolves final component settings based on the desired values, quality settings and hardware limitations.
/// </summary>
internal void ResolveFinalSettings(WaterQualityLevel quality)
{
CreateObjects();
var wavesMode = quality.wavesMode;
if (wavesMode == WaterWavesMode.DisallowAll)
{
enabled = false;
return;
}
bool supportsFloats = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBFloat) || SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBHalf);
int finalResolution = Mathf.Min(resolution, quality.maxSpectrumResolution, SystemInfo.maxTextureSize);
bool finalHighPrecision = highPrecision && quality.allowHighPrecisionTextures && SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBFloat);
if (renderMode == WaveSpectrumRenderMode.FullFFT && wavesMode == WaterWavesMode.AllowAll && supportsFloats)
{
finalRenderMode = WaveSpectrumRenderMode.FullFFT;
}
else if (renderMode <= WaveSpectrumRenderMode.GerstnerAndFFTSlope && wavesMode <= WaterWavesMode.AllowSlopeFFT && supportsFloats)
{
finalRenderMode = WaveSpectrumRenderMode.GerstnerAndFFTSlope;
}
else
{
finalRenderMode = WaveSpectrumRenderMode.Gerstner;
}
if (this.finalResolution != finalResolution)
{
lock (this)
{
this.finalResolution = finalResolution;
this.finalHighPrecision = finalHighPrecision;
if (spectrumResolver != null)
{
spectrumResolver.OnMapsFormatChanged(true);
}
if (ResolutionChanged != null)
{
ResolutionChanged.Invoke(this);
}
}
}
else if (this.finalHighPrecision != finalHighPrecision)
{
lock (this)
{
this.finalHighPrecision = finalHighPrecision;
if (spectrumResolver != null)
{
spectrumResolver.OnMapsFormatChanged(false);
}
}
}
switch (finalRenderMode)
{
case WaveSpectrumRenderMode.FullFFT:
{
waterWavesFFT.RenderedMaps = WavesRendererFFT.MapType.Displacement | WavesRendererFFT.MapType.Slope;
waterWavesFFT.Enable(this);
waterWavesGerstner.Disable();
break;
}
case WaveSpectrumRenderMode.GerstnerAndFFTSlope:
{
waterWavesFFT.RenderedMaps = WavesRendererFFT.MapType.Slope;
waterWavesFFT.Enable(this);
waterWavesGerstner.Enable(this);
break;
}
case WaveSpectrumRenderMode.Gerstner:
{
waterWavesFFT.Disable();
waterWavesGerstner.Enable(this);
break;
}
}
}
private void OnResolutionChanged(ResolutionEventArgs args)
{
ResolutionChanged?.Invoke(this, args);
}
internal static void RaiseResolutionChanged(int oldPixelWidth, int oldPixelHeight, float oldWidth, float oldHeight)
{
ResolutionChanged?.SafeInvoke(HudManager.Instance, new ResolutionChangedEventArgs(oldPixelWidth, oldPixelHeight, oldWidth, oldHeight), nameof(ResolutionChanged));
}
