void graphics_PreparingDeviceSettings(object sender,
PreparingDeviceSettingsEventArgs e)
{
e.GraphicsDeviceInformation.PresentationParameters.DeviceWindowHandle = drawSurface;
}
private void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
DisplayMode displayMode = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode;
e.GraphicsDeviceInformation.PresentationParameters.BackBufferFormat = displayMode.Format;
e.GraphicsDeviceInformation.PresentationParameters.BackBufferWidth = displayMode.Width;
e.GraphicsDeviceInformation.PresentationParameters.BackBufferHeight = displayMode.Height;
}
void CBeroGraphicsDeviceManager_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
if (m_WndHndl != IntPtr.Zero)
{
e.GraphicsDeviceInformation.PresentationParameters.DeviceWindowHandle = m_WndHndl;
}
}
private void PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
PresentationParameters presentationParams = e.GraphicsDeviceInformation.PresentationParameters;
presentationParams.BackBufferWidth = RenderWidth;
presentationParams.BackBufferHeight = RenderHeight;
presentationParams.DeviceWindowHandle = _windowHandle;
presentationParams.RenderTargetUsage = RenderTargetUsage.PreserveContents;
}
private void Graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
Graphics.PreferredBackBufferWidth = DefaultResolution.X;
Graphics.PreferredBackBufferHeight = DefaultResolution.Y;
//Graphics.GraphicsProfile = GraphicsProfile.HiDef;
Graphics.SynchronizeWithVerticalRetrace = true;
//Graphics.PreferredDepthStencilFormat = DepthFormat.Depth24Stencil8;
}
private void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
//graphics.IsFullScreen = true;
graphics.PreferredBackBufferWidth = 1280;
graphics.PreferredBackBufferHeight = 720;
graphics.PreferMultiSampling = true;
graphics.GraphicsProfile = GraphicsProfile.HiDef;
graphics.PreferredDepthStencilFormat = DepthFormat.Depth24Stencil8;
graphics.ApplyChanges();
}
protected override void OnPreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
e.GraphicsDeviceInformation.PresentationParameters.PresentationInterval = PresentInterval.One;
// use 4-bit (per channel) color format for WP7. Atleast Omnia 7 has a horrible banding with SurfaceFormat.Color.
// Lumia's don't probably have but whatever
if (OperatingSystemHelper.Version == WindowsPhoneVersion.WP7)
{
e.GraphicsDeviceInformation.PresentationParameters.BackBufferFormat = SurfaceFormat.Bgra4444;
}
}
void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
try
{
e.GraphicsDeviceInformation.PresentationParameters.PresentationInterval = PresentInterval.Two;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void GraphicsPreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e) {
var pp = e.GraphicsDeviceInformation.PresentationParameters;
var adapter = e.GraphicsDeviceInformation.Adapter;
var dispFormat = adapter.CurrentDisplayMode.Format;
var dephFormat = pp.DepthStencilFormat;
SurfaceFormat selectedFormat;
DepthFormat selectedDepthFormat;
int selectedMultiSampleCount;
if (adapter.QueryRenderTargetFormat(GraphicsProfile.HiDef, dispFormat, dephFormat, 4, out selectedFormat, out selectedDepthFormat, out selectedMultiSampleCount)) {
pp.MultiSampleCount = 4;
} else if (adapter.QueryRenderTargetFormat(GraphicsProfile.HiDef, dispFormat, dephFormat, 2, out selectedFormat, out selectedDepthFormat, out selectedMultiSampleCount)) {
pp.MultiSampleCount = 2;
}
}
/// <summary>
/// This populates a GraphicsDeviceInformation instance and invokes PreparingDeviceSettings to
/// allow users to change the settings. Then returns that GraphicsDeviceInformation.
/// Throws NullReferenceException if users set GraphicsDeviceInformation.PresentationParameters to null.
/// </summary>
private GraphicsDeviceInformation DoPreparingDeviceSettings()
{
var gdi = new GraphicsDeviceInformation();
PrepareGraphicsDeviceInformation(gdi);
if (PreparingDeviceSettings != null)
{
// this allows users to overwrite settings through the argument
var args = new PreparingDeviceSettingsEventArgs(gdi);
PreparingDeviceSettings(this, args);
if (gdi.PresentationParameters == null || gdi.Adapter == null)
{
throw new NullReferenceException("Members should not be set to null in PreparingDeviceSettingsEventArgs");
}
}
return(gdi);
}
private void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
nativeScreenWidth = graphics.PreferredBackBufferWidth;
nativeScreenHeight = graphics.PreferredBackBufferHeight;
if (nativeScreenWidth == 1920)
{
graphics.PreferredBackBufferWidth = 1920;
graphics.PreferredBackBufferHeight = 1080;
}
else
{
//graphics.PreferredBackBufferWidth = 1920;
//graphics.PreferredBackBufferHeight = 1080;
graphics.PreferredBackBufferWidth = 1280;
graphics.PreferredBackBufferHeight = 720;
//graphics.IsFullScreen = true;
}
graphics.PreferMultiSampling = true;
graphics.PreferredDepthStencilFormat = DepthFormat.Depth24Stencil8;
graphics.ApplyChanges();
}
private void OnPreparingDeviceSettings(object sender, Xna.PreparingDeviceSettingsEventArgs e)
{
var pp = e.GraphicsDeviceInformation.PresentationParameters;
var desktopDisplayMode = e.GraphicsDeviceInformation.Adapter.CurrentDisplayMode;
pp.RenderTargetUsage = RenderTargetUsage.PreserveContents;
pp.IsFullScreen = true;
if (pp.IsFullScreen)
{
pp.BackBufferWidth = desktopDisplayMode.Width;
pp.BackBufferHeight = desktopDisplayMode.Height;
}
else
{
var form = (System.Windows.Forms.Form)System.Windows.Forms.Form.FromHandle(this.game.Window.Handle);
int borderX = form.Size.Width - form.ClientSize.Width;
int borderY = form.Size.Height - form.ClientSize.Height;
pp.BackBufferWidth = desktopDisplayMode.Width - borderX;
pp.BackBufferHeight = desktopDisplayMode.Height - borderY;
}
}
private void Initialize()
{
_game.Window.SetSupportedOrientations(_supportedOrientations);
var presentationParameters = new PresentationParameters();
PreparePresentationParameters(presentationParameters);
// Allow for any per-platform changes to the presentation.
PlatformInitialize(presentationParameters);
// TODO: Implement multisampling (aka anti-alising) for all platforms!
if (PreparingDeviceSettings != null)
{
var gdi = new GraphicsDeviceInformation();
gdi.GraphicsProfile = GraphicsProfile; // Microsoft defaults this to Reach.
gdi.Adapter = GraphicsAdapter.DefaultAdapter;
gdi.PresentationParameters = presentationParameters;
var pe = new PreparingDeviceSettingsEventArgs(gdi);
PreparingDeviceSettings(this, pe);
presentationParameters = pe.GraphicsDeviceInformation.PresentationParameters;
GraphicsProfile = pe.GraphicsDeviceInformation.GraphicsProfile;
}
// Create and initialize the graphics device.
_graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile, presentationParameters);
// Set the new display size on the touch panel.
//
// TODO: In XNA this seems to be done as part of the
// GraphicsDevice.DeviceReset event... we need to get
// those working.
//
TouchPanel.DisplayWidth = _graphicsDevice.PresentationParameters.BackBufferWidth;
TouchPanel.DisplayHeight = _graphicsDevice.PresentationParameters.BackBufferHeight;
TouchPanel.DisplayOrientation = _graphicsDevice.PresentationParameters.DisplayOrientation;
}
private void InitialiseDevice(object sender, PreparingDeviceSettingsEventArgs e)
{
PresentationParameters pp =
e.GraphicsDeviceInformation.PresentationParameters;
foreach (GraphicsAdapter adapter in GraphicsAdapter.Adapters)
{
if (adapter.Description.Contains("NVIDIA PerfHUD"))
{
GraphicsAdapter.UseReferenceDevice = true;
e.GraphicsDeviceInformation.Adapter = adapter;
break;
}
}
GraphicsAdapter defaultAdapter = GraphicsAdapter.DefaultAdapter;
//if ( defaultAdapter.IsWideScreen )
RenderManager.Instance.BaseResolution = new Vector2(1280, 720);
// else
// RenderManager.Instance.BaseResolution = new Vector2(1024, 768);
}
void graphics_PreparingDeviceSettings(object sender,
PreparingDeviceSettingsEventArgs e)
{
foreach (Microsoft.Xna.Framework.Graphics.DisplayMode displayMode
in GraphicsAdapter.DefaultAdapter.SupportedDisplayModes)
{
if (displayMode.Width == 800 && displayMode.Height == 600)
{
e.GraphicsDeviceInformation.PresentationParameters.
BackBufferFormat = displayMode.Format;
e.GraphicsDeviceInformation.PresentationParameters.
BackBufferHeight = displayMode.Height;
e.GraphicsDeviceInformation.PresentationParameters.
BackBufferWidth = displayMode.Width;
}
}
}
protected virtual void GraphicsPreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
e.GraphicsDeviceInformation.PresentationParameters.RenderTargetUsage = RenderTargetUsage.PreserveContents;
e.GraphicsDeviceInformation.PresentationParameters.DepthStencilFormat = DepthFormat.Depth24Stencil8;
e.GraphicsDeviceInformation.PresentationParameters.BackBufferFormat = SurfaceFormat.Color;
}
/// <summary>
/// Event capturing the construction of a draw surface and makes sure this gets redirected to
/// a predesignated drawsurface marked by pointer _drawSurface
/// </summary>
private void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
e.GraphicsDeviceInformation.PresentationParameters.DeviceWindowHandle = this._drawSurface;
e.GraphicsDeviceInformation.PresentationParameters.BackBufferWidth = Simulation3D.Form.pictureBoxSurface.Width;
e.GraphicsDeviceInformation.PresentationParameters.BackBufferHeight = Simulation3D.Form.pictureBoxSurface.Height;
}
void _graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
PresentationParameters pp = e.GraphicsDeviceInformation.PresentationParameters;
pp.RenderTargetUsage = RenderTargetUsage.PreserveContents;
e.GraphicsDeviceInformation.PresentationParameters = pp;
}
/// <summary>
/// We need to override this device settings callback so that the correct back buffer it set.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected override void GraphicsPreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
base.GraphicsPreparingDeviceSettings(sender, e);
// e.GraphicsDeviceInformation.PresentationParameters.BackBufferHeight = 960;
// e.GraphicsDeviceInformation.PresentationParameters.BackBufferWidth = 800;
}
private void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
var currentDisplayMode = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode;
var width = currentDisplayMode.Width;
var height = currentDisplayMode.Height;
graphics.PreferredBackBufferWidth = Math.Min(width, 4096);
graphics.PreferredBackBufferHeight = Math.Min(height, 4096);
graphics.PreferMultiSampling = true;
resolutionSet = false;
graphics.PreparingDeviceSettings -= graphicsPreparedHandler;
CanLoadContent = true;
}
void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
e.GraphicsDeviceInformation.PresentationParameters.MultiSampleCount = 4;
}
private void Initialize()
{
var presentationParameters = new PresentationParameters();
presentationParameters.DepthStencilFormat = DepthFormat.Depth24;
#if (WINDOWS || WINRT) && !DESKTOPGL
_game.Window.SetSupportedOrientations(_supportedOrientations);
presentationParameters.BackBufferFormat = _preferredBackBufferFormat;
presentationParameters.BackBufferWidth = _preferredBackBufferWidth;
presentationParameters.BackBufferHeight = _preferredBackBufferHeight;
presentationParameters.DepthStencilFormat = _preferredDepthStencilFormat;
presentationParameters.IsFullScreen = false;
#if WINDOWS_UAP
presentationParameters.DeviceWindowHandle = IntPtr.Zero;
presentationParameters.SwapChainPanel = this.SwapChainPanel;
#else
presentationParameters.DeviceWindowHandle = _game.Window.Handle;
#endif
#else
#if MONOMAC || DESKTOPGL
presentationParameters.IsFullScreen = _wantFullScreen;
#elif WEB
presentationParameters.IsFullScreen = false;
#else
// Set "full screen" as default
presentationParameters.IsFullScreen = true;
#endif // MONOMAC
#endif // WINDOWS || WINRT
// TODO: Implement multisampling (aka anti-alising) for all platforms!
var preparingDeviceSettingsHandler = PreparingDeviceSettings;
if (preparingDeviceSettingsHandler != null)
{
GraphicsDeviceInformation gdi = new GraphicsDeviceInformation();
gdi.GraphicsProfile = GraphicsProfile; // Microsoft defaults this to Reach.
gdi.Adapter = GraphicsAdapter.DefaultAdapter;
gdi.PresentationParameters = presentationParameters;
PreparingDeviceSettingsEventArgs pe = new PreparingDeviceSettingsEventArgs(gdi);
preparingDeviceSettingsHandler(this, pe);
presentationParameters = pe.GraphicsDeviceInformation.PresentationParameters;
GraphicsProfile = pe.GraphicsDeviceInformation.GraphicsProfile;
}
// Needs to be before ApplyChanges()
_graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile, this.PreferHalfPixelOffset, presentationParameters);
#if !MONOMAC
ApplyChanges();
#endif
// Set the new display size on the touch panel.
//
// TODO: In XNA this seems to be done as part of the
// GraphicsDevice.DeviceReset event... we need to get
// those working.
//
TouchPanel.DisplayWidth = _graphicsDevice.PresentationParameters.BackBufferWidth;
TouchPanel.DisplayHeight = _graphicsDevice.PresentationParameters.BackBufferHeight;
TouchPanel.DisplayOrientation = _graphicsDevice.PresentationParameters.DisplayOrientation;
}
private void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
nativeScreenWidth = graphics.PreferredBackBufferWidth;
nativeScreenHeight = graphics.PreferredBackBufferHeight;
graphics.PreferredBackBufferWidth = 1280;
graphics.PreferredBackBufferHeight = 720;
graphics.PreferMultiSampling = true;
graphics.GraphicsProfile = GraphicsProfile.HiDef;
graphics.SynchronizeWithVerticalRetrace = true;
graphics.PreferredDepthStencilFormat = DepthFormat.Depth24Stencil8;
e.GraphicsDeviceInformation.PresentationParameters.MultiSampleCount = 16;
}
private void Initialize()
{
var presentationParameters = new PresentationParameters();
presentationParameters.DepthStencilFormat = DepthFormat.Depth24;
#if WINDOWS || WINRT
_game.Window.SetSupportedOrientations(_supportedOrientations);
presentationParameters.BackBufferFormat = _preferredBackBufferFormat;
presentationParameters.BackBufferWidth = _preferredBackBufferWidth;
presentationParameters.BackBufferHeight = _preferredBackBufferHeight;
presentationParameters.DepthStencilFormat = _preferredDepthStencilFormat;
presentationParameters.IsFullScreen = false;
#if WINDOWS_PHONE
// Nothing to do!
#elif WINDOWS_UAP
presentationParameters.DeviceWindowHandle = IntPtr.Zero;
presentationParameters.SwapChainPanel = this.SwapChainPanel;
#elif WINDOWS_STORE
// The graphics device can use a XAML panel or a window
// to created the default swapchain target.
if (this.SwapChainBackgroundPanel != null)
{
presentationParameters.DeviceWindowHandle = IntPtr.Zero;
presentationParameters.SwapChainBackgroundPanel = this.SwapChainBackgroundPanel;
}
else
{
presentationParameters.DeviceWindowHandle = _game.Window.Handle;
presentationParameters.SwapChainBackgroundPanel = null;
}
#else
presentationParameters.DeviceWindowHandle = _game.Window.Handle;
#endif
#else
#if MONOMAC
presentationParameters.IsFullScreen = _wantFullScreen;
#elif LINUX
presentationParameters.IsFullScreen = _wantFullScreen;
#else
// Set "full screen" as default
presentationParameters.IsFullScreen = true;
#endif // MONOMAC
#endif // WINDOWS || WINRT
// TODO: Implement multisampling (aka anti-alising) for all platforms!
if (PreparingDeviceSettings != null)
{
GraphicsDeviceInformation gdi = new GraphicsDeviceInformation();
gdi.GraphicsProfile = GraphicsProfile; // Microsoft defaults this to Reach.
gdi.Adapter = GraphicsAdapter.DefaultAdapter;
gdi.PresentationParameters = presentationParameters;
PreparingDeviceSettingsEventArgs pe = new PreparingDeviceSettingsEventArgs(gdi);
PreparingDeviceSettings(this, pe);
presentationParameters = pe.GraphicsDeviceInformation.PresentationParameters;
GraphicsProfile = pe.GraphicsDeviceInformation.GraphicsProfile;
}
// Needs to be before ApplyChanges()
_graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile, presentationParameters);
#if !MONOMAC
ApplyChanges();
#endif
// Set the new display size on the touch panel.
//
// TODO: In XNA this seems to be done as part of the
// GraphicsDevice.DeviceReset event... we need to get
// those working.
//
TouchPanel.DisplayWidth = _graphicsDevice.PresentationParameters.BackBufferWidth;
TouchPanel.DisplayHeight = _graphicsDevice.PresentationParameters.BackBufferHeight;
TouchPanel.DisplayOrientation = _graphicsDevice.PresentationParameters.DisplayOrientation;
}
protected virtual void OnPreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs args)
{
if (this.PreparingDeviceSettings != null)
{
this.PreparingDeviceSettings(sender, args);
}
}
private void GraphicsDevicePreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
e.GraphicsDeviceInformation.PresentationParameters.RenderTargetUsage = RenderTargetUsage.PreserveContents;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
public DeviceEventArgs(PreparingDeviceSettingsEventArgs deviceSettings)
{
DeviceSettings = deviceSettings;
}
/// <summary>
/// When a graphics device is being created, we need to ensure swap effect copy is enabled
/// so that the contents of the back buffer are not lost after multiple present calls.
/// </summary>
protected virtual void OnGraphicsDevicePrepareSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
e.GraphicsDeviceInformation.PresentationParameters.SwapEffect = SwapEffect.Copy;
}
/// <summary>
/// Delegate for the GraphicsDeviceManager, which is used to change the resolution
/// and the output window handle of the GraphicsDevice.
/// </summary>
void PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
// Set the resolution
e.GraphicsDeviceInformation.PresentationParameters.BackBufferWidth = ResolutionWidth;
e.GraphicsDeviceInformation.PresentationParameters.BackBufferHeight = ResolutionHeight;
// This is the most important part!
// An XNA game which is triggered by Game.Run() creates it's own hosting window and uses
// it's handle for defining the render output window of the GraphicsDeviceManager.
// In this case there is no hosting window, so the output window handle has to be redirect!
e.GraphicsDeviceInformation.PresentationParameters.DeviceWindowHandle = this.m_windowHandle;
e.GraphicsDeviceInformation.PresentationParameters.RenderTargetUsage = RenderTargetUsage.PreserveContents;
e.GraphicsDeviceInformation.PresentationParameters.IsFullScreen = false;
e.GraphicsDeviceInformation.PresentationParameters.MultiSampleCount = 8;
m_bLoaded = true;
}
void PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
#if DEBUG
foreach (GraphicsAdapter curAdapter in GraphicsAdapter.Adapters)
{
if (curAdapter.Description.Contains("PerfHUD"))
{
e.GraphicsDeviceInformation.Adapter = curAdapter;
break;
}
}
#endif
e.GraphicsDeviceInformation.PresentationParameters.RenderTargetUsage = presentation;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Method used as an event handler for the GraphicsDeviceManager.PreparingDeviceSettings event.
/// </summary>
protected virtual void PrepareGraphicsDevice(object sender, PreparingDeviceSettingsEventArgs e)
{
e.GraphicsDeviceInformation.PresentationParameters.RenderTargetUsage = _RenderTargetUsage;
int w = e.GraphicsDeviceInformation.PresentationParameters.BackBufferWidth;
int h = e.GraphicsDeviceInformation.PresentationParameters.BackBufferHeight;
foreach (Control c in Controls)
{
SetMaxSize(c, w, h);
}
if (DeviceSettingsChanged != null) DeviceSettingsChanged.Invoke(new DeviceEventArgs(e));
}
protected virtual void OnPreparingDeviceSettings(Object sender, PreparingDeviceSettingsEventArgs args)
{
//TODO
}
/// <summary>
/// This method ensures that we can render to the back buffer without
/// losing the data we already had in our previous back buffer. This
/// is necessary for the SkeletonStreamRenderer.
/// </summary>
/// <param name="sender">The sending object.</param>
/// <param name="e">The event args.</param>
private void GraphicsDevicePreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
// This is necessary because we are rendering to back buffer/render targets and we need to preserve the data
e.GraphicsDeviceInformation.PresentationParameters.RenderTargetUsage = RenderTargetUsage.PreserveContents;
}
// TODO: Fullscreen does not work in current Mono?
//public void SetFullscreenEnabled(bool enabled)
//{
// if (enabled && graphicsDeviceManager.IsFullScreen == false ||
// enabled == false && graphicsDeviceManager.IsFullScreen)
// {
// // TODO: This does not work in the current MonoGame version.
// graphicsDeviceManager.ToggleFullScreen();
// }
//}
//public void ToggleFullscren()
//{
// graphicsDeviceManager.ToggleFullScreen();
// graphicsDeviceManager.ApplyChanges();
//}
// TODO: PreparingDeviceSettings does only fire the first time applychanges is called (or maybe only before game started).
private void PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
this.SetScreenSize(new MPoint2(e.GraphicsDeviceInformation.PresentationParameters.BackBufferWidth, e.GraphicsDeviceInformation.PresentationParameters.BackBufferHeight));
//Vector2DInteger value = new Vector2DInteger(
// e.GraphicsDeviceInformation.PresentationParameters.BackBufferWidth,
// e.GraphicsDeviceInformation.PresentationParameters.BackBufferHeight
// );
//ScreenSize = value;
//ScreenCenter = value / 2;
}
/// <summary>
/// Called when the GPU is getting new settings
/// </summary>
/// <param name="sender">The object requesting new device settings</param>
/// <param name="e">The device settings that are getting set</param>
private void GraphicsPreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
{
PresentationParameters pp = e.GraphicsDeviceInformation.PresentationParameters;
GraphicsAdapter adapter = e.GraphicsDeviceInformation.Adapter;
SurfaceFormat format = adapter.CurrentDisplayMode.Format;
if (MultiSamples > 0 && MultiSamples != pp.MultiSampleCount)
{
pp.MultiSampleCount = MultiSamples;
}
else if (MultiSamples <= 0 && MultiSamples != pp.MultiSampleCount)
{
pp.MultiSampleCount = 0;
}
if (bloom != null)
{
bloom.sceneRenderTarget = new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight,
false,
format, pp.DepthStencilFormat, pp.MultiSampleCount,
RenderTargetUsage.DiscardContents);
}
}
void graphics_PrepareDevice(object sender, PreparingDeviceSettingsEventArgs e)
{
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
{
PresentationParameters presentParams =
e.GraphicsDeviceInformation.PresentationParameters;
presentParams.RenderTargetUsage = RenderTargetUsage.PlatformContents;
if (graphicsManager.PreferredBackBufferHeight == 720)
{
presentParams.MultiSampleCount = 4;
#if !DEBUG
presentParams.PresentationInterval = PresentInterval.One;
#endif
}
else
{
presentParams.MultiSampleCount = 2;
#if !DEBUG
presentParams.PresentationInterval = PresentInterval.Two;
#endif
}
}
}
