private void RenderThreadStart(object param)
{
// TODO: OP! Initialize render log file
ProfilerShort.Autocommit = false;
var startParams = (StartParams)param;
m_renderWindow = startParams.InitHandler();
var control = System.Windows.Forms.Control.FromHandle(m_renderWindow.Handle);
m_settings = MyRenderProxy.CreateDevice(this, m_renderWindow.Handle, startParams.SettingsToTry);
MyRenderProxy.SendCreatedDeviceSettings(m_settings);
m_currentQuality = startParams.RenderQuality;
m_form = control;
LoadContent();
UpdateSize();
//RenderLoop.UseCustomDoEvents = true;
RenderLoop.Run(m_form, RenderCallback);
UnloadContent();
MyRenderProxy.DisposeDevice();
}
private void ApplySettingsChanges()
{
if (MyRenderProxy.TestDeviceCooperativeLevel() == MyRenderDeviceCooperativeLevel.Ok)
{
var quality = Interlocked.Exchange(ref m_newQuality, -1);
if (quality != -1)
{
m_currentQuality = (MyRenderQualityEnum)quality;
}
if (m_newSettings.HasValue && MyRenderProxy.SettingsChanged(m_newSettings.Value))
{
m_settings = m_newSettings.Value;
m_newSettings = null;
UnloadContent();
MyRenderProxy.ApplySettings(m_settings);
LoadContent();
UpdateSize();
}
else if (quality != -1)
{
// Quality has changed, but not settings
ProfilerShort.Begin("ReloadContent");
MyRenderProxy.ReloadContent(m_currentQuality);
ProfilerShort.End();
}
}
}
// Call this at the application start. It will look into config file and get video parameters. If not found, default will be chosen. Then video mode will be initialized.
static void InitFromConfig()
{
MyMwcLog.WriteLine("MyVideoModeManager.InitFromConfig START");
// Here we store width/height of windows desktop - becuase later they can
// change after we switch to fullscreen and we want to have these original values.
m_originalWindowsDesktopWidth = GraphicsAdapter.Default.CurrentDisplayMode.Width;
m_originalWindowsDesktopHeight = GraphicsAdapter.Default.CurrentDisplayMode.Height;
// Read from config or use default/recommended values
bool configFullscreen = MyConfig.FullScreen;
int configVideoAdapter = MyConfig.VideoAdapter;
MyVideoModeEx configVideoMode = MyConfig.VideoMode;
bool configVerticalSync = MyConfig.VerticalSync;
bool configHardwareCursor = MyConfig.HardwareCursor;
MyRenderQualityEnum configRenderQuality = MyConfig.RenderQuality;
float configFieldOfView = MyConfig.FieldOfView;
// Save values to config
MyConfig.VideoAdapter = configVideoAdapter;
MyConfig.VideoMode = configVideoMode;
MyConfig.FullScreen = configFullscreen;
MyConfig.VerticalSync = configVerticalSync;
MyConfig.HardwareCursor = configHardwareCursor;
MyConfig.RenderQuality = configRenderQuality;
MyConfig.FieldOfView = configFieldOfView;
MyConfig.Save();
// Finally change/init the video mode
BeginChangeVideoMode(true, configVideoAdapter, configVideoMode, configFullscreen, configVerticalSync, configHardwareCursor, configRenderQuality, configFieldOfView, true, null);
ApplyChanges();
MyMwcLog.WriteLine("MyVideoModeManager.InitFromConfig END");
}
/// <summary>
/// This should be called only from LoadContent
/// </summary>
public static void SwitchRenderQuality(MyRenderQualityEnum renderQuality)
{
RenderQualityProfile = m_renderQualityProfiles[(int)renderQuality];
if (OnRenderQualityChange != null)
{
OnRenderQualityChange(renderQuality, null);
}
}
internal static void LoadContent(MyRenderQualityEnum quality)
{
MyRender.Log.WriteLine("MyRender.LoadContent(...) - START");
GraphicsDevice = Device;
MyRenderConstants.SwitchRenderQuality(quality);
MyRenderTexturePool.RenderQualityChanged(quality);
//Log.WriteLine("Viewport: " + GraphicsDevice.Viewport.ToString());
LoadContent();
MyRender.Log.WriteLine("MyRender.LoadContent(...) - END");
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public MyVideoModeChangeOperation(bool callApplyChanges, bool fullScreen, bool verticalSync, bool hardwareCursor,
float fieldOfView,
int videoAdapter, MyVideoModeEx videoMode,
MyRenderQualityEnum renderQuality, bool first, Action <MyVideoModeChangeOperation> requestCallback)
{
this.callApplyChanges = callApplyChanges;
this.fullScreen = fullScreen;
this.verticalSync = verticalSync;
this.hardwareCursor = hardwareCursor;
this.fieldOfView = fieldOfView;
this.videoAdapter = videoAdapter;
this.videoMode = videoMode;
this.renderQuality = renderQuality;
this.first = first;
this.requestCallback = requestCallback;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public MyVideoModeChangeOperation(bool callApplyChanges, bool fullScreen, bool verticalSync, bool hardwareCursor,
float fieldOfView,
int videoAdapter, MyVideoModeEx videoMode,
MyRenderQualityEnum renderQuality, bool first, Action<MyVideoModeChangeOperation> requestCallback)
{
this.callApplyChanges = callApplyChanges;
this.fullScreen = fullScreen;
this.verticalSync = verticalSync;
this.hardwareCursor = hardwareCursor;
this.fieldOfView = fieldOfView;
this.videoAdapter = videoAdapter;
this.videoMode = videoMode;
this.renderQuality = renderQuality;
this.first = first;
this.requestCallback = requestCallback;
}
static public void RenderQualityChanged(MyRenderQualityEnum newSettings)
{
switch (newSettings)
{
case MyRenderQualityEnum.NORMAL:
m_renderQualityScale = 0.5f;
break;
case MyRenderQualityEnum.HIGH:
m_renderQualityScale = 1.0f;
break;
case MyRenderQualityEnum.EXTREME:
m_renderQualityScale = 2.0f;
break;
}
}
private void RenderThreadStart(object param)
{
// TODO: OP! Initialize render log file
ProfilerShort.Autocommit = false;
var startParams = (StartParams)param;
m_renderWindow = startParams.InitHandler();
#if !XB1
var control = System.Windows.Forms.Control.FromHandle(m_renderWindow.Handle);
#endif
m_settings = MyRenderProxy.CreateDevice(this, m_renderWindow.Handle, startParams.SettingsToTry);
if (m_settings.AdapterOrdinal == -1)
{
return;
}
MyRenderProxy.SendCreatedDeviceSettings(m_settings);
m_currentQuality = startParams.RenderQuality;
#if !XB1
m_form = control;
#else
m_form = m_renderWindow as RenderForm;
#endif
LoadContent();
UpdateSize();
//RenderLoop.UseCustomDoEvents = true;
//RenderLoop.Run(m_form, RenderCallback);
m_form.Show();
while (m_form.Visible)
{
Application.DoEvents();
if (m_form.Visible)
{
RenderCallback();
}
}
UnloadContent();
MyRenderProxy.DisposeDevice();
}
public bool IsSetToLowQuality()
{
MyTextureAnisoFiltering?anisotropicFiltering = this.AnisotropicFiltering;
MyTextureAnisoFiltering nONE = MyTextureAnisoFiltering.NONE;
if ((((MyTextureAnisoFiltering)anisotropicFiltering.GetValueOrDefault()) == nONE) & (anisotropicFiltering != null))
{
MyAntialiasingMode?antialiasingMode = this.AntialiasingMode;
MyAntialiasingMode mode = MyAntialiasingMode.NONE;
if ((((MyAntialiasingMode)antialiasingMode.GetValueOrDefault()) == mode) & (antialiasingMode != null))
{
MyShadowsQuality?shadowQuality = this.ShadowQuality;
MyShadowsQuality lOW = MyShadowsQuality.LOW;
if ((((MyShadowsQuality)shadowQuality.GetValueOrDefault()) == lOW) & (shadowQuality != null))
{
MyTextureQuality?textureQuality = this.TextureQuality;
MyTextureQuality quality2 = MyTextureQuality.LOW;
if ((((MyTextureQuality)textureQuality.GetValueOrDefault()) == quality2) & (textureQuality != null))
{
MyRenderQualityEnum?modelQuality = this.ModelQuality;
MyRenderQualityEnum enum2 = MyRenderQualityEnum.LOW;
if ((((MyRenderQualityEnum)modelQuality.GetValueOrDefault()) == enum2) & (modelQuality != null))
{
modelQuality = this.VoxelQuality;
enum2 = MyRenderQualityEnum.LOW;
if ((((MyRenderQualityEnum)modelQuality.GetValueOrDefault()) == enum2) & (modelQuality != null))
{
float?grassDrawDistance = this.GrassDrawDistance;
float num = 0f;
return((grassDrawDistance.GetValueOrDefault() == num) & (grassDrawDistance != null));
}
}
}
}
}
}
return(false);
}
static public void RenderQualityChanged(MyRenderQualityEnum newSettings)
{
switch (newSettings)
{
case MyRenderQualityEnum.NORMAL:
m_renderQualityScale = 0.5f;
break;
case MyRenderQualityEnum.HIGH:
m_renderQualityScale = 1.0f;
break;
case MyRenderQualityEnum.EXTREME:
m_renderQualityScale = 2.0f;
break;
}
// Update available resources according to new render quality
var newMaxResources = (int)(POOL_RESOURCES * m_renderQualityScale * m_renderQualityScale);
m_currentFreeResources += newMaxResources - m_maxFreeResources;
m_maxFreeResources = newMaxResources;
}
/// <summary>
/// Creates and starts render thread
/// </summary>
public void Start(MyGameTimer timer, InitHandler windowInitializer, MyRenderDeviceSettings?settingsToTry, MyRenderQualityEnum renderQuality, float maxFrameRate)
{
RenderThread = MyRenderThread.Start(timer, windowInitializer, settingsToTry, renderQuality, maxFrameRate);
}
public static void SwitchRenderSettings(MyRenderQualityEnum quality, bool enableInterpolation)
{
var message = MessagePool.Get<MyRenderMessageSwitchRenderSettings>(MyRenderMessageEnum.SwitchRenderSettings);
message.Quality = quality;
message.EnableInterpolation = enableInterpolation;
EnqueueMessage(message);
}
/// <summary>
/// Begins the change video mode.
/// </summary>
/// <param name="callApplyChanges">if set to <c>true</c> [call apply changes].</param>
/// <param name="videoMode">The video mode.</param>
/// <param name="fullScreen">if set to <c>true</c> [full screen].</param>
/// <param name="verticalSync">if set to <c>true</c> [vertical sync].</param>
/// <param name="hardwareCursor">if set to <c>true</c> [hardware cursor].</param>
/// <param name="renderQuality">The render quality.</param>
/// <param name="fieldOfView">The field of view.</param>
/// <param name="requestCallback">The request callback.</param>
/// <param name="state">The state.</param>
/// <returns></returns>
public static void BeginChangeVideoMode(bool callApplyChanges, int videoAdapter, MyVideoModeEx videoMode, bool fullScreen, bool verticalSync, bool hardwareCursor, MyRenderQualityEnum renderQuality, float fieldOfView, bool first, Action <MyVideoModeChangeOperation> requestCallback)
{
var result = new MyVideoModeChangeOperation(callApplyChanges, fullScreen, verticalSync, hardwareCursor, fieldOfView,
videoAdapter, videoMode, renderQuality, first, requestCallback);
m_changeOperations.Enqueue(result);
}
public static void UpdateRenderQuality(
MyRenderQualityEnum renderQuality,
bool enableCascadeBlending)
{
var message = MessagePool.Get<MyRenderMessageUpdateRenderQuality>(MyRenderMessageEnum.UpdateRenderQuality);
message.RenderQuality = renderQuality;
message.EnableCascadeBlending = enableCascadeBlending;
EnqueueMessage(message);
}
public void LoadContent(MyRenderQualityEnum quality)
{
}
public void SwitchQuality(MyRenderQualityEnum quality)
{
Debug.Assert(Thread.CurrentThread == SystemThread);
m_newQuality = (int)quality;
}
static public void RenderQualityChanged(MyRenderQualityEnum newSettings)
{
switch (newSettings)
{
case MyRenderQualityEnum.NORMAL :
m_renderQualityScale = 0.5f;
break;
case MyRenderQualityEnum.HIGH:
m_renderQualityScale = 1.0f;
break;
case MyRenderQualityEnum.EXTREME :
m_renderQualityScale = 2.0f;
break;
}
// Update available resources according to new render quality
var newMaxResources = (int)(POOL_RESOURCES * m_renderQualityScale * m_renderQualityScale);
m_currentFreeResources += newMaxResources - m_maxFreeResources;
m_maxFreeResources = newMaxResources;
}
public void SwitchQuality(MyRenderQualityEnum quality)
{
Debug.Assert(Thread.CurrentThread == SystemThread);
m_newQuality = (int)quality;
}
public void ReloadContent(MyRenderQualityEnum quality)
{
MyRender.ReloadContent(quality);
}
internal static void LoadContent(MyRenderQualityEnum quality)
{
MyRender.Log.WriteLine("MyRender.LoadContent(...) - START");
GraphicsDevice = Device;
MyRenderConstants.SwitchRenderQuality(quality);
MyRenderTexturePool.RenderQualityChanged(quality);
//Log.WriteLine("Viewport: " + GraphicsDevice.Viewport.ToString());
LoadContent();
MyRender.Log.WriteLine("MyRender.LoadContent(...) - END");
}
internal static void ReloadContent(MyRenderQualityEnum quality)
{
UnloadContent();
LoadContent(quality);
}
public void LoadContent(MyRenderQualityEnum quality)
{
}
static public void RenderQualityChanged(MyRenderQualityEnum newSettings)
{
switch (newSettings)
{
case MyRenderQualityEnum.NORMAL :
m_renderQualityScale = 0.5f;
break;
case MyRenderQualityEnum.HIGH:
m_renderQualityScale = 1.0f;
break;
case MyRenderQualityEnum.EXTREME :
m_renderQualityScale = 2.0f;
break;
}
}
public void StartSync(MyGameTimer timer, IMyRenderWindow window, MyRenderDeviceSettings? settings, MyRenderQualityEnum renderQuality, float maxFrameRate)
{
RenderThread = MyRenderThread.StartSync(timer, window, settings, renderQuality, maxFrameRate);
}
public void StartSync(MyGameTimer timer, IMyRenderWindow window, MyRenderDeviceSettings?settings, MyRenderQualityEnum renderQuality, float maxFrameRate)
{
RenderThread = MyRenderThread.StartSync(timer, window, settings, renderQuality, maxFrameRate);
}
/// <summary>
/// Creates and starts render thread
/// </summary>
public void Start(MyGameTimer timer, InitHandler windowInitializer, MyRenderDeviceSettings? settingsToTry, MyRenderQualityEnum renderQuality, float maxFrameRate)
{
RenderThread = MyRenderThread.Start(timer, windowInitializer, settingsToTry, renderQuality, maxFrameRate);
}
public static MyRenderThread StartSync(MyGameTimer timer, IMyRenderWindow renderWindow, MyRenderDeviceSettings?settingsToTry, MyRenderQualityEnum renderQuality)
{
var result = new MyRenderThread(timer, false);
result.m_renderWindow = renderWindow;
result.m_settings = MyRenderProxy.CreateDevice(result, renderWindow.Handle, settingsToTry);
MyRenderProxy.SendCreatedDeviceSettings(result.m_settings);
result.m_currentQuality = renderQuality;
result.m_form = Control.FromHandle(renderWindow.Handle);
result.LoadContent();
result.UpdateSize();
return(result);
}
public static MyRenderThread Start(MyGameTimer timer, InitHandler initHandler, MyRenderDeviceSettings? settingsToTry, MyRenderQualityEnum renderQuality)
{
var result = new MyRenderThread(timer, true);
result.SystemThread.Start(new StartParams() { InitHandler = initHandler, SettingsToTry = settingsToTry, RenderQuality = renderQuality });
return result;
}
public void SelectQuality(MyRenderQualityEnum quality)
{
m_isActiveUserSettings = false;
m_selectedModelQuality = quality;
Apply();
}
public static MyRenderThread StartSync(MyGameTimer timer, IMyRenderWindow renderWindow, MyRenderDeviceSettings? settingsToTry, MyRenderQualityEnum renderQuality)
{
var result = new MyRenderThread(timer, false);
result.m_renderWindow = renderWindow;
result.m_settings = MyRenderProxy.CreateDevice(result, renderWindow.Handle, settingsToTry);
MyRenderProxy.SendCreatedDeviceSettings(result.m_settings);
result.m_currentQuality = renderQuality;
result.m_form = System.Windows.Forms.Control.FromHandle(renderWindow.Handle);
result.LoadContent();
result.UpdateSize();
return result;
}
public static MyRenderThread Start(MyGameTimer timer, InitHandler initHandler, MyRenderDeviceSettings?settingsToTry, MyRenderQualityEnum renderQuality)
{
var result = new MyRenderThread(timer, true);
result.SystemThread.Start(new StartParams()
{
InitHandler = initHandler, SettingsToTry = settingsToTry, RenderQuality = renderQuality
});
return(result);
}
public static void UpdateRenderQuality(
MyRenderQualityEnum renderQuality,
float lodTransitionDistanceNear,
float lodTransitionDistanceFar,
float lodTransitionDistanceBackgroundStart,
float lodTransitionDistanceBackgroundEnd,
float environmentLodTransitionDistance,
float environmentLodTransitionDistanceBackground,
bool enableCascadeBlending)
{
var message = MessagePool.Get<MyRenderMessageUpdateRenderQuality>(MyRenderMessageEnum.UpdateRenderQuality);
message.RenderQuality = renderQuality;
message.LodTransitionDistanceNear = lodTransitionDistanceNear;
message.LodTransitionDistanceFar = lodTransitionDistanceFar;
message.LodTransitionDistanceBackgroundStart = lodTransitionDistanceBackgroundStart;
message.LodTransitionDistanceBackgroundEnd = lodTransitionDistanceBackgroundEnd;
message.EnvironmentLodTransitionDistance = environmentLodTransitionDistance;
message.EnvironmentLodTransitionDistanceBackground = environmentLodTransitionDistanceBackground;
message.EnableCascadeBlending = enableCascadeBlending;
EnqueueMessage(message);
}
public static void LoadContent(MyRenderQualityEnum quality)
{
GetRenderProfiler().StartProfilingBlock("Load Content");
m_render.LoadContent(quality);
GetRenderProfiler().EndProfilingBlock();
}
/// <summary>
/// Begins the change video mode.
/// </summary>
/// <param name="callApplyChanges">if set to <c>true</c> [call apply changes].</param>
/// <param name="videoMode">The video mode.</param>
/// <param name="fullScreen">if set to <c>true</c> [full screen].</param>
/// <param name="verticalSync">if set to <c>true</c> [vertical sync].</param>
/// <param name="hardwareCursor">if set to <c>true</c> [hardware cursor].</param>
/// <param name="renderQuality">The render quality.</param>
/// <param name="fieldOfView">The field of view.</param>
/// <param name="requestCallback">The request callback.</param>
/// <param name="state">The state.</param>
/// <returns></returns>
public static void BeginChangeVideoMode(bool callApplyChanges, int videoAdapter, MyVideoModeEx videoMode, bool fullScreen, bool verticalSync, bool hardwareCursor, MyRenderQualityEnum renderQuality, float fieldOfView, bool first, Action<MyVideoModeChangeOperation> requestCallback)
{
var result = new MyVideoModeChangeOperation(callApplyChanges, fullScreen, verticalSync, hardwareCursor, fieldOfView,
videoAdapter, videoMode, renderQuality, first, requestCallback);
m_changeOperations.Enqueue(result);
}
public void ReloadContent(MyRenderQualityEnum quality)
{
MyRender.ReloadContent(quality);
}
internal static void ReloadContent(MyRenderQualityEnum quality)
{
UnloadContent();
LoadContent(quality);
}
private void RenderThreadStart(object param)
{
// TODO: OP! Initialize render log file
ProfilerShort.Autocommit = false;
var startParams = (StartParams)param;
m_renderWindow = startParams.InitHandler();
var control = System.Windows.Forms.Control.FromHandle(m_renderWindow.Handle);
m_settings = MyRenderProxy.CreateDevice(this, m_renderWindow.Handle, startParams.SettingsToTry);
MyRenderProxy.SendCreatedDeviceSettings(m_settings);
m_currentQuality = startParams.RenderQuality;
m_form = control;
LoadContent();
UpdateSize();
//RenderLoop.UseCustomDoEvents = true;
RenderLoop.Run(m_form, RenderCallback);
UnloadContent();
MyRenderProxy.DisposeDevice();
}
public static void SwitchRenderQuality(MyRenderQualityEnum renderQuality)
{
RenderQualityProfile = m_renderQualityProfiles[(int)renderQuality];
if (OnRenderQualityChange != null)
OnRenderQualityChange(renderQuality, null);
}
internal void Synchronize(MyRenderSettings settings)
{
CheckArrays(settings);
EnableHWOcclusionQueries = settings.EnableHWOcclusionQueries;
SkipLOD_NEAR = settings.SkipLOD_NEAR;
SkipLOD_0 = settings.SkipLOD_0;
SkipLOD_1 = settings.SkipLOD_1;
SkipVoxels = settings.SkipVoxels;
VoxelQuality = settings.VoxelQuality;
//Debug properties
ShowEnvironmentScreens = settings.ShowEnvironmentScreens;
ShowBlendedScreens = settings.ShowBlendedScreens;
ShowGreenBackground = settings.ShowGreenBackground;
ShowLod1WithRedOverlay = settings.ShowLod1WithRedOverlay;
EnableLightsRuntime = settings.EnableLightsRuntime;
ShowEnhancedRenderStatsEnabled = settings.ShowEnhancedRenderStatsEnabled;
ShowResourcesStatsEnabled = settings.ShowResourcesStatsEnabled;
ShowTexturesStatsEnabled = settings.ShowTexturesStatsEnabled;
EnableSun = settings.EnableSun;
EnableShadows = settings.EnableShadows;
EnableAsteroidShadows = settings.EnableAsteroidShadows;
EnableFog = settings.EnableFog;
DebugRenderClipmapCells = settings.DebugRenderClipmapCells;
EnableVoxelMerging = settings.EnableVoxelMerging;
DebugRenderMergedCells = settings.DebugRenderMergedCells;
EnableEnvironmentMapAmbient = settings.EnableEnvironmentMapAmbient;
EnableEnvironmentMapReflection = settings.EnableEnvironmentMapReflection;
ShadowCascadeCount = settings.ShadowCascadeCount;
ShowShadowCascadeSplits = settings.ShowShadowCascadeSplits;
EnableShadowBlur = settings.EnableShadowBlur;
ShadowInterleaving = settings.ShadowInterleaving;
UpdateCascadesEveryFrame = settings.UpdateCascadesEveryFrame;
ShadowCascadeMaxDistanceMultiplierMedium = settings.ShadowCascadeMaxDistanceMultiplierMedium;
ShadowCascadeMaxDistanceMultiplierHigh = settings.ShadowCascadeMaxDistanceMultiplierHigh;
ShadowCascadeZOffset = settings.ShadowCascadeZOffset;
ShadowCascadeSpreadFactor = settings.ShadowCascadeSpreadFactor;
ShadowFadeoutMultiplier = settings.ShadowFadeoutMultiplier;
ShadowCascadeMaxDistance = settings.ShadowCascadeMaxDistance;
//for (int index = 0; index < settings.ShadowCascadeCount; ++index)
//{
// ShadowCascadeFrozen[index] = settings.ShadowCascadeFrozen[index];
// ShadowCascadeSmallSkipThresholds[index] = settings.ShadowCascadeSmallSkipThresholds[index];
//}
Wireframe = settings.Wireframe;
EnableStencilOptimization = settings.EnableStencilOptimization;
EnableStencilOptimizationLOD1 = settings.EnableStencilOptimizationLOD1;
ShowStencilOptimization = settings.ShowStencilOptimization;
CheckDiffuseTextures = settings.CheckDiffuseTextures;
CheckNormalTextures = settings.CheckNormalTextures;
ShowSpecularIntensity = settings.ShowSpecularIntensity;
ShowSpecularPower = settings.ShowSpecularPower;
ShowEmissivity = settings.ShowEmissivity;
ShowReflectivity = settings.ShowReflectivity;
EnableSpotShadows = settings.EnableSpotShadows;
VisualizeOverdraw = settings.VisualizeOverdraw;
MultimonTest = settings.MultimonTest;
EnableCameraInterpolation = settings.EnableCameraInterpolation;
EnableObjectInterpolation = settings.EnableObjectInterpolation;
InterpolationLagMs = settings.InterpolationLagMs;
LagFeedbackMult = settings.LagFeedbackMult;
DisplayGbufferColor = settings.DisplayGbufferColor;
DisplayGbufferColorLinear = settings.DisplayGbufferColorLinear;
DisplayGbufferNormal = settings.DisplayGbufferNormal;
DisplayGbufferGlossiness = settings.DisplayGbufferGlossiness;
DisplayGbufferMetalness = settings.DisplayGbufferMetalness;
DisplayGbufferMaterialID = settings.DisplayGbufferMaterialID;
DisplayGbufferAO = settings.DisplayGbufferAO;
DisplayEmissive = settings.DisplayEmissive;
DisplayEdgeMask = settings.DisplayEdgeMask;
DisplayDepth = settings.DisplayDepth;
DisplayStencil = settings.DisplayStencil;
RgbMultiplier = settings.RgbMultiplier;
MetalnessMultiplier = settings.MetalnessMultiplier;
GlossMultiplier = settings.GlossMultiplier;
AoMultiplier = settings.AoMultiplier;
EmissiveMultiplier = settings.EmissiveMultiplier;
ColorMaskMultiplier = settings.ColorMaskMultiplier;
DisplayAmbientDiffuse = settings.DisplayAmbientDiffuse;
DisplayAmbientSpecular = settings.DisplayAmbientSpecular;
DrawParticleRenderTarget = settings.DrawParticleRenderTarget;
DisplayIDs = settings.DisplayIDs;
DisplayAabbs = settings.DisplayAabbs;
DrawMergeInstanced = settings.DrawMergeInstanced;
DrawNonMergeInstanced = settings.DrawNonMergeInstanced;
TerrainDetailD0 = settings.TerrainDetailD0;
TerrainDetailD1 = settings.TerrainDetailD1;
TerrainDetailD2 = settings.TerrainDetailD2;
TerrainDetailD3 = settings.TerrainDetailD3;
FreezeTerrainQueries = settings.FreezeTerrainQueries;
GrassPostprocess = settings.GrassPostprocess;
GrassPostprocessCloseDistance = settings.GrassPostprocessCloseDistance;
GrassGeometryClippingDistance = settings.GrassGeometryClippingDistance;
GrassGeometryScalingNearDistance = settings.GrassGeometryScalingNearDistance;
GrassGeometryScalingFarDistance = settings.GrassGeometryScalingFarDistance;
GrassGeometryDistanceScalingFactor = settings.GrassGeometryDistanceScalingFactor;
GrassDensityFactor = settings.GrassDensityFactor;
WindStrength = settings.WindStrength;
WindAzimuth = settings.WindAzimuth;
DisplayShadowsWithDebug = settings.DisplayShadowsWithDebug;
DrawCascadeTextures = settings.DrawCascadeTextures;
DisplayNDotL = settings.DisplayNDotL;
EnableParallelRendering = settings.EnableParallelRendering;
ForceImmediateContext = settings.ForceImmediateContext;
RenderBatchSize = settings.RenderBatchSize;
AmortizeBatchWork = settings.AmortizeBatchWork;
LoopObjectThenPass = settings.LoopObjectThenPass;
RenderThreadAsWorker = settings.RenderThreadAsWorker;
//EnableTonemapping = settings.EnableTonemapping;
DisplayHdrDebug = settings.DisplayHdrDebug;
AdaptationTau = settings.AdaptationTau;
LuminanceExposure = settings.LuminanceExposure;
Contrast = settings.Contrast;
Brightness = settings.Brightness;
MiddleGrey = settings.MiddleGrey;
BloomExposure = settings.BloomExposure;
BloomMult = settings.BloomMult;
MiddleGreyCurveSharpness = settings.MiddleGreyCurveSharpness;
MiddleGreyAt0 = settings.MiddleGreyAt0;
BlueShiftRapidness = settings.BlueShiftRapidness;
BlueShiftScale = settings.BlueShiftScale;
BacklightMult = settings.BacklightMult;
EnvMult = settings.EnvMult;
FogDensity = settings.FogDensity;
FogMult = settings.FogMult;
FogYOffset = settings.FogYOffset;
FogColor = settings.FogColor;
FoliageLod0Distance = settings.FoliageLod0Distance;
FoliageLod1Distance = settings.FoliageLod1Distance;
FoliageLod2Distance = settings.FoliageLod2Distance;
FoliageLod3Distance = settings.FoliageLod3Distance;
EnableFoliageDebug = settings.EnableFoliageDebug;
FreezeFoliageViewer = settings.FreezeFoliageViewer;
}
private void ApplySettingsChanges()
{
if(MyRenderProxy.TestDeviceCooperativeLevel() == MyRenderDeviceCooperativeLevel.Ok)
{
var quality = Interlocked.Exchange(ref m_newQuality, -1);
if (quality != -1)
{
m_currentQuality = (MyRenderQualityEnum)quality;
}
if (m_newSettings.HasValue && MyRenderProxy.SettingsChanged(m_newSettings.Value))
{
m_settings = m_newSettings.Value;
m_newSettings = null;
UnloadContent();
MyRenderProxy.ApplySettings(m_settings);
LoadContent();
UpdateSize();
}
else if (quality != -1)
{
// Quality has changed, but not settings
ProfilerShort.Begin("ReloadContent");
MyRenderProxy.ReloadContent(m_currentQuality);
ProfilerShort.End();
}
}
}
