public override List <GraphicsDeviceInformation> FindBestDevices(GameGraphicsParameters preferredParameters)
{
var graphicsDeviceInfos = base.FindBestDevices(preferredParameters);
// Special case where the default FindBestDevices is not working
if (graphicsDeviceInfos.Count == 0)
{
var graphicsAdapter = GraphicsAdapterFactory.Adapters[0];
// Iterate on each preferred graphics profile
foreach (var featureLevel in preferredParameters.PreferredGraphicsProfile)
{
// Check if this profile is supported.
if (graphicsAdapter.IsProfileSupported(featureLevel))
{
var deviceInfo = new GraphicsDeviceInformation
{
Adapter = graphicsAdapter,
GraphicsProfile = featureLevel,
PresentationParameters =
{
MultisampleCount = preferredParameters.PreferredMultisampleCount,
IsFullScreen = preferredParameters.IsFullScreen,
PresentationInterval = preferredParameters.SynchronizeWithVerticalRetrace ? PresentInterval.One : PresentInterval.Immediate,
DeviceWindowHandle = MainWindow.NativeWindow,
}
};
// Hardcoded format and refresh rate...
// This is a workaround to allow this code to work inside the emulator
// but this is not really robust
// TODO: Check how to handle this case properly
var displayMode = new DisplayMode(PixelFormat.B8G8R8A8_UNorm, gameWindow.ClientBounds.Width, gameWindow.ClientBounds.Height, new Rational(60, 1));
AddDevice(displayMode, deviceInfo, preferredParameters, graphicsDeviceInfos);
// If the profile is supported, we are just using the first best one
break;
}
}
}
return(graphicsDeviceInfos);
}
public override List <GraphicsDeviceInformation> FindBestDevices(GameGraphicsParameters preferredParameters)
{
var gameWindowiOS = gameWindow as GameWindowiOS;
if (gameWindowiOS != null)
{
var graphicsAdapter = GraphicsAdapterFactory.Default;
var graphicsDeviceInfos = new List <GraphicsDeviceInformation>();
var preferredGraphicsProfiles = preferredParameters.PreferredGraphicsProfile;
foreach (var featureLevel in preferredGraphicsProfiles)
{
// Check if this profile is supported.
if (graphicsAdapter.IsProfileSupported(featureLevel))
{
// Everything is already created at this point, just transmit what has been done
var deviceInfo = new GraphicsDeviceInformation
{
Adapter = GraphicsAdapterFactory.Default,
GraphicsProfile = featureLevel,
PresentationParameters = new PresentationParameters(preferredParameters.PreferredBackBufferWidth,
preferredParameters.PreferredBackBufferHeight,
gameWindowiOS.NativeWindow)
{
// TODO: PDX-364: Transmit what was actually created
BackBufferFormat = preferredParameters.PreferredBackBufferFormat,
DepthStencilFormat = preferredParameters.PreferredDepthStencilFormat,
}
};
graphicsDeviceInfos.Add(deviceInfo);
// If the profile is supported, we are just using the first best one
break;
}
}
return(graphicsDeviceInfos);
}
return(base.FindBestDevices(preferredParameters));
}
private void CreateDevice(GraphicsDeviceInformation newInfo)
{
newInfo.PresentationParameters.IsFullScreen = isFullScreen;
newInfo.PresentationParameters.PresentationInterval = SynchronizeWithVerticalRetrace ? PresentInterval.One : PresentInterval.Immediate;
newInfo.DeviceCreationFlags = DeviceCreationFlags;
// this.ValidateGraphicsDeviceInformation(newInfo);
bool deviceRecreate = GraphicsDevice != null;
// Notify device is resetting (usually this should result in graphics resources being destroyed)
if (deviceRecreate)
{
OnDeviceResetting(this, EventArgs.Empty);
}
// Create (or recreate) the graphics device
GraphicsDevice = graphicsDeviceFactory.ChangeOrCreateDevice(GraphicsDevice, newInfo);
// Notify device is reset (usually this should result in graphics resources being recreated/reloaded)
if (deviceRecreate)
{
OnDeviceReset(this, EventArgs.Empty);
}
// Use the shader profile returned by the GraphicsDeviceInformation otherwise use the one coming from the GameSettings
GraphicsDevice.ShaderProfile = ShaderProfile;
// TODO HANDLE Device Resetting/Reset/Lost
//GraphicsDevice.DeviceResetting += GraphicsDevice_DeviceResetting;
//GraphicsDevice.DeviceReset += GraphicsDevice_DeviceReset;
//GraphicsDevice.DeviceLost += GraphicsDevice_DeviceLost;
if (!deviceRecreate)
{
GraphicsDevice.Disposing += GraphicsDevice_Disposing;
}
OnDeviceCreated(this, EventArgs.Empty);
}
public virtual List <GraphicsDeviceInformation> FindBestDevices(GameGraphicsParameters preferredParameters)
{
var graphicsDeviceInfos = new List <GraphicsDeviceInformation>();
// Iterate on each adapter
foreach (var graphicsAdapter in GraphicsAdapterFactory.Adapters)
{
if (!string.IsNullOrEmpty(preferredParameters.RequiredAdapterUid) && graphicsAdapter.AdapterUid != preferredParameters.RequiredAdapterUid)
{
continue;
}
// Skip adapeters that don't have graphics output
// but only if no RequiredAdapterUid is provided (OculusVR at init time might be in a device with no outputs)
if (graphicsAdapter.Outputs.Length == 0 && string.IsNullOrEmpty(preferredParameters.RequiredAdapterUid))
{
continue;
}
var preferredGraphicsProfiles = preferredParameters.PreferredGraphicsProfile;
// Iterate on each preferred graphics profile
foreach (var featureLevel in preferredGraphicsProfiles)
{
// Check if this profile is supported.
if (graphicsAdapter.IsProfileSupported(featureLevel))
{
var deviceInfo = new GraphicsDeviceInformation
{
Adapter = graphicsAdapter,
GraphicsProfile = featureLevel,
PresentationParameters =
{
MultisampleCount = preferredParameters.PreferredMultisampleCount,
IsFullScreen = preferredParameters.IsFullScreen,
PreferredFullScreenOutputIndex = preferredParameters.PreferredFullScreenOutputIndex,
PresentationInterval = preferredParameters.SynchronizeWithVerticalRetrace ? PresentInterval.One : PresentInterval.Immediate,
DeviceWindowHandle = MainWindow.NativeWindow,
ColorSpace = preferredParameters.ColorSpace,
},
};
var preferredMode = new DisplayMode(preferredParameters.PreferredBackBufferFormat,
preferredParameters.PreferredBackBufferWidth,
preferredParameters.PreferredBackBufferHeight,
preferredParameters.PreferredRefreshRate);
// if we want to switch to fullscreen, try to find only needed output, otherwise check them all
if (preferredParameters.IsFullScreen)
{
if (preferredParameters.PreferredFullScreenOutputIndex < graphicsAdapter.Outputs.Length)
{
var output = graphicsAdapter.Outputs[preferredParameters.PreferredFullScreenOutputIndex];
var displayMode = output.FindClosestMatchingDisplayMode(preferredGraphicsProfiles, preferredMode);
AddDevice(displayMode, deviceInfo, preferredParameters, graphicsDeviceInfos);
}
}
else
{
AddDevice(preferredMode, deviceInfo, preferredParameters, graphicsDeviceInfos);
}
// If the profile is supported, we are just using the first best one
break;
}
}
}
return(graphicsDeviceInfos);
}
public virtual void DeviceChanged(GraphicsDevice currentDevice, GraphicsDeviceInformation deviceInformation)
{
// TODO: Check when it needs to be disabled on iOS (OpenGL)?
// Force to resize the gameWindow
//gameWindow.Resize(deviceInformation.PresentationParameters.BackBufferWidth, deviceInformation.PresentationParameters.BackBufferHeight);
}
/// <summary>
/// Determines whether this instance is compatible with the the specified new <see cref="GraphicsDeviceInformation"/>.
/// </summary>
/// <param name="newDeviceInfo">The new device info.</param>
/// <returns><c>true</c> if this instance this instance is compatible with the the specified new <see cref="GraphicsDeviceInformation"/>; otherwise, <c>false</c>.</returns>
protected virtual bool CanResetDevice(GraphicsDeviceInformation newDeviceInfo)
{
// By default, a reset is compatible when we stay under the same graphics profile.
return(GraphicsDevice.Features.RequestedProfile == newDeviceInfo.GraphicsProfile);
}
/// <summary>
/// Initializes a new instance of the <see cref="PreparingDeviceSettingsEventArgs" /> class.
/// </summary>
/// <param name="graphicsDeviceInformation">The graphics device information.</param>
public PreparingDeviceSettingsEventArgs(GraphicsDeviceInformation graphicsDeviceInformation)
{
GraphicsDeviceInformation = graphicsDeviceInformation;
}
public virtual GraphicsDevice ChangeOrCreateDevice(GraphicsDevice currentDevice, GraphicsDeviceInformation deviceInformation)
{
if (currentDevice == null)
{
currentDevice = CreateDevice(deviceInformation);
}
else
{
RecreateDevice(currentDevice, deviceInformation);
}
DeviceChanged(currentDevice, deviceInformation);
return(currentDevice);
}
public virtual void DeviceChanged(GraphicsDevice currentDevice, GraphicsDeviceInformation deviceInformation)
{
// Force to resize the gameWindow
gameWindow.Resize(deviceInformation.PresentationParameters.BackBufferWidth, deviceInformation.PresentationParameters.BackBufferHeight);
}
public virtual void RecreateDevice(GraphicsDevice currentDevice, GraphicsDeviceInformation deviceInformation)
{
currentDevice.ColorSpace = deviceInformation.PresentationParameters.ColorSpace;
currentDevice.Recreate(deviceInformation.Adapter ?? GraphicsAdapterFactory.Default, new[] { deviceInformation.GraphicsProfile }, deviceInformation.DeviceCreationFlags, gameWindow.NativeWindow);
}