private void CreateDevice(IntPtr windowHandle, int width, int height)
{
try
{
parameters = new PresentationParameters();
parameters.BackBufferWidth = Math.Max(width, 1);
parameters.BackBufferHeight = Math.Max(height, 1);
parameters.BackBufferFormat = SurfaceFormat.Color;
parameters.DepthStencilFormat = DepthFormat.Depth24;
parameters.DeviceWindowHandle = windowHandle;
parameters.PresentationInterval = PresentInterval.Immediate;
parameters.IsFullScreen = false;
graphicsDevice = new GraphicsDevice(
GraphicsAdapter.DefaultAdapter,
GraphicsProfile.Reach,
parameters);
if (DeviceCreated != null)
DeviceCreated(this, EventArgs.Empty);
}
catch (Exception ex)
{
throw new ApplicationException("Failed to initialize GraphicsDeviceService. See inner exception for details.", ex);
}
}
private XNAGraphicsDeviceService(IntPtr windowHandle, int width, int height)
{
parameters = new PresentationParameters();
parameters.BackBufferWidth = Math.Max(width, 1);
parameters.BackBufferHeight = Math.Max(height, 1);
parameters.BackBufferFormat = SurfaceFormat.Color;
parameters.DepthStencilFormat = DepthFormat.Depth16;
parameters.DeviceWindowHandle = windowHandle;
parameters.PresentationInterval = PresentInterval.Immediate;
parameters.IsFullScreen = false;
if (GraphicsAdapter.DefaultAdapter.IsProfileSupported(GraphicsProfile.HiDef))
graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter,
GraphicsProfile.HiDef,
parameters);
else
{
MessageBox.Show(
"WARNING: Your graphics device does not support the HiDef Profile, switching to the Reach profile.",
"Rose");
graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter,
GraphicsProfile.Reach,
parameters);
}
XnaResourceManager.Instance.DeviceCreate(graphicsDevice);
}
private void InitializeMainScrn()
{
mainScreen = new MainScreen();
PresentationParameters pp = new PresentationParameters();
pp.BackBufferCount = 1;
pp.IsFullScreen = false;
pp.SwapEffect = SwapEffect.Discard;
pp.BackBufferWidth = mainScreen.canvas.Width;
pp.BackBufferHeight = mainScreen.canvas.Height;
pp.AutoDepthStencilFormat = DepthFormat.Depth24Stencil8;
pp.EnableAutoDepthStencil = true;
pp.PresentationInterval = PresentInterval.Default;
pp.BackBufferFormat = SurfaceFormat.Unknown;
pp.MultiSampleType = MultiSampleType.None;
mainDevice = new GraphicsDevice( GraphicsAdapter.DefaultAdapter,
DeviceType.Hardware, this.mainScreen.canvas.Handle,
pp );
mainScreen.canvas.SizeChanged += new EventHandler( mainScreen_canvas_SizeChanged );
mainScreen.canvas.Paint += new EventHandler( mainScreen_canvas_Paint );
mainDevice.Reset();
mainScreen.Show( dockPanel, DockState.Document );
mainScrnBatch = new SpriteBatch( mainDevice );
//BasicGraphics.Initial( mainDevice );
}
/// <summary>
/// Constructor is private, because this is a singleton class:
/// client controls should use the public AddRef method instead.
/// </summary>
GraphicsDeviceService(IntPtr windowHandle, int width, int height)
{
//parameters = new PresentationParameters();
//parameters.BackBufferWidth = Math.Max(width, 1);
//parameters.BackBufferHeight = Math.Max(height, 1);
//parameters.BackBufferFormat = SurfaceFormat.Color;
//parameters.EnableAutoDepthStencil = true;
//parameters.AutoDepthStencilFormat = DepthFormat.Depth24;
this.Parameters = new PresentationParameters()
{
BackBufferWidth = Math.Max(width, 1),
BackBufferHeight = Math.Max(height, 1),
BackBufferFormat = SurfaceFormat.Color,
DepthStencilFormat = DepthFormat.Depth24,
DeviceWindowHandle = windowHandle,
PresentationInterval = PresentInterval.Immediate,
IsFullScreen = false,
MultiSampleCount = 4
};
//graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter,
// DeviceType.Hardware,
// windowHandle,
// parameters);
this.graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.Reach, this.Parameters);
if (this.DeviceCreated != null)
{
this.DeviceCreated(this, EventArgs.Empty);
}
}
public static unsafe void Reset(GraphicsDevice graphicsDevice, PresentationParameters parameters)
{
var fi = typeof(GraphicsDevice).GetField("pComPtr", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
var ptr = fi.GetValue(graphicsDevice);
var pComPtr = new IntPtr(System.Reflection.Pointer.Unbox(ptr));
if (g_mdxAssembly == null) throw new ApplicationException("GraphicsDevice.Reset failed. Please install Managed DirectX from the Assault Wing web site.");
var mdxDeviceType = g_mdxAssembly.GetType("Microsoft.DirectX.Direct3D.Device");
var mdxPresentParametersType = g_mdxAssembly.GetType("Microsoft.DirectX.Direct3D.PresentParameters");
var dev = Activator.CreateInstance(mdxDeviceType, pComPtr);
dynamic dxParameters = new MDXPresentParameters(Activator.CreateInstance(mdxPresentParametersType));
dxParameters.AutoDepthStencilFormat = parameters.DepthStencilFormat.ToD3D();
dxParameters.BackBufferCount = 1;
dxParameters.BackBufferFormat = parameters.BackBufferFormat.ToD3D();
dxParameters.BackBufferHeight = parameters.BackBufferHeight;
dxParameters.BackBufferWidth = parameters.BackBufferWidth;
dxParameters.DeviceWindow = null;
dxParameters.DeviceWindowHandle = parameters.DeviceWindowHandle;
dxParameters.EnableAutoDepthStencil = false; // ???
dxParameters.ForceNoMultiThreadedFlag = false; // ???
dxParameters.FullScreenRefreshRateInHz = 0; // ??? should be 0 for windowed mode; in fullscreen mode take value from DisplayModeCollection
dxParameters.MultiSample = GetMDXEnumValue("MultiSampleType", "None");
dxParameters.MultiSampleQuality = 0;
dxParameters.PresentationInterval = parameters.PresentationInterval.ToD3D();
dxParameters.PresentFlag = GetMDXEnumValue("PresentFlag", "None"); // ???
dxParameters.SwapEffect = GetMDXEnumValue("SwapEffect", "Flip"); // ??? see _parameters.RenderTargetUsage
dxParameters.Windowed = !parameters.IsFullScreen;
var resetMethod = mdxDeviceType.GetMethod("Reset");
var mdxPresentParametersArray = Array.CreateInstance(mdxPresentParametersType, 1);
mdxPresentParametersArray.SetValue(((MDXPresentParameters)dxParameters).WrappedValue, 0);
resetMethod.Invoke(dev, new[] { mdxPresentParametersArray });
}
/// <summary>
/// Constructor is private, because this is a singleton class:
/// client controls should use the public AddRef method instead.
/// </summary>
GraphicsDeviceService(IntPtr windowHandle, int width, int height)
{
parameters = new PresentationParameters();
// Basic settings.
parameters.BackBufferWidth = Math.Max(width, 1);
parameters.BackBufferHeight = Math.Max(height, 1);
parameters.BackBufferFormat = SurfaceFormat.Color;
parameters.DepthStencilFormat = DepthFormat.Depth24;
parameters.DeviceWindowHandle = windowHandle;
parameters.PresentationInterval = PresentInterval.Immediate;
parameters.IsFullScreen = false;
// High-quality settings.
parameters.MultiSampleCount = 4;
// Try for high-quality graphics, otherwise drop down to basic settings.
try
{
graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter,
GraphicsProfile.HiDef,
parameters);
}
catch
{
parameters.MultiSampleCount = 0;
graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter,
GraphicsProfile.Reach,
parameters);
}
}
public GraphicsDeviceInformation()
{
deviceType = DeviceType.Hardware;
adapter = GraphicsAdapter.DefaultAdapter;
presentationParameters = new PresentationParameters();
presentationParameters.Clear();
}
/// <summary>
/// Constructor is private, because this is a singleton class:
/// client controls should use the public AddRef method instead.
/// </summary>
GraphicsDeviceService(IntPtr windowHandle, int width, int height)
{
parameters = new PresentationParameters();
parameters.BackBufferWidth = Math.Max(width, 1);
parameters.BackBufferHeight = Math.Max(height, 1);
parameters.BackBufferFormat = SurfaceFormat.Color;
parameters.DepthStencilFormat = DepthFormat.Depth24;
parameters.DeviceWindowHandle = windowHandle;
parameters.RenderTargetUsage = RenderTargetUsage.DiscardContents;
parameters.IsFullScreen = false;
/*PORT XNA 4
parameters.EnableAutoDepthStencil = true;
parameters.AutoDepthStencilFormat = DepthFormat.Depth24;
*/
if(GraphicsAdapter.DefaultAdapter.IsProfileSupported(GraphicsProfile.HiDef))
graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.HiDef, parameters);
else if (GraphicsAdapter.DefaultAdapter.IsProfileSupported(GraphicsProfile.Reach))
graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.Reach, parameters);
else
{
System.Windows.Forms.MessageBox.Show("Default graphics adapter does not support XNA");
throw new System.InvalidOperationException("Default graphics adapter does not support XNA");
}
}
public SelectTeleportationForm(Map map, System.Drawing.Point premier, int layer, Map firstMap, SpriteBatch Mapbatch)
{
InitializeComponent();
utils = new XNAUtils();
this.map = map;
this.premier = premier;
this.layer = layer;
this.firstMap = firstMap;
this.batch = Mapbatch;
this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
this.Size = Screen.PrimaryScreen.Bounds.Size;
this.StartPosition = FormStartPosition.Manual;
this.Location = new System.Drawing.Point(0, 0);
PN_Map.Size = Screen.PrimaryScreen.Bounds.Size;
PresentationParameters pp = new PresentationParameters()
{
BackBufferHeight = PN_Map.Height,
BackBufferWidth = PN_Map.Width,
DeviceWindowHandle = PN_Map.Handle,
IsFullScreen = false
};
XNADevices.graphicsdevice.Reset(pp);
}
public GraphicsDeviceService(IntPtr windowHandle)
{
var screenBounds = System.Windows.Forms.Screen.FromHandle(windowHandle).Bounds;
_parameters = new PresentationParameters
{
BackBufferWidth = screenBounds.Width,
BackBufferHeight = screenBounds.Height,
BackBufferFormat = SurfaceFormat.Color,
DepthStencilFormat = DepthFormat.Depth24,
DeviceWindowHandle = windowHandle,
IsFullScreen = false,
PresentationInterval = PresentInterval.Immediate,
};
var profilingAdapter = GraphicsAdapter.Adapters.FirstOrDefault(a => a.Description.Contains("PerfHUD"));
var useAdapter = profilingAdapter ?? GraphicsAdapter.DefaultAdapter;
if (profilingAdapter != null) GraphicsAdapter.UseReferenceDevice = true;
if (!useAdapter.IsProfileSupported(GraphicsProfile.Reach))
GraphicsAdapter.UseReferenceDevice = !GraphicsAdapter.UseReferenceDevice;
if (!useAdapter.IsProfileSupported(GraphicsProfile.Reach))
throw new NotSupportedException("No suitable graphics adapter found");
try
{
GraphicsDevice = new GraphicsDevice(useAdapter, GraphicsProfile.Reach, _parameters);
}
catch (InvalidOperationException)
{
// With VMware, GraphicsDevice.ctor may throw InvalidOperationException when using reference device.
GraphicsAdapter.UseReferenceDevice = false;
GraphicsDevice = new GraphicsDevice(useAdapter, GraphicsProfile.Reach, _parameters);
}
if (DeviceCreated != null) DeviceCreated(this, EventArgs.Empty);
}
public Renderer( PresentationParameters p_PresentationParameters )
{
m_GraphicsAdapter = GraphicsAdapter.DefaultAdapter;
m_PresentationParameters = p_PresentationParameters;
#if XBOX360
m_PresentationParameters.BackBufferWidth =
m_GraphicsAdapter.CurrentDisplayMode.Width;
m_PresentationParameters.BackBufferHeight =
m_GraphicsAdapter.CurrentDisplayMode.Height;
m_PresentationParameters.IsFullScreen = true;
#endif
m_GraphicsDeviceService = GraphicsDeviceService.AddReference(
m_PresentationParameters );
m_ServiceContainer.AddService< IGraphicsDeviceService >(
m_GraphicsDeviceService );
m_ClearColour = new Color( 1.0f, 1.0f, 1.0f );
m_Width = m_PresentationParameters.BackBufferWidth;
m_Height = m_PresentationParameters.BackBufferHeight;
if( GamerServicesDispatcher.IsInitialized == false )
{
GamerServicesDispatcher.WindowHandle =
m_GraphicsDeviceService.GraphicsDevice.
PresentationParameters.DeviceWindowHandle;
GamerServicesDispatcher.Initialize( m_ServiceContainer );
GamerServicesDispatcher.Update( );
}
}
public void EqualsTest()
{
PresentationParameters b = new PresentationParameters();
Assert.IsFalse(b == a, "#1");
Assert.IsTrue(b != a, "#2");
Assert.IsFalse(b == null, "#3");
Assert.IsTrue(b.Equals(b), "#4");
}
public GraphicsDevice()
{
BitmapCacheEnabled = true;
RenderAtScale = 1;
RenderState = new RenderState();
PresentationParameters = new PresentationParameters();
PresentationParameters.BackBufferFormat = SurfaceFormat.Canvas;
}
GraphicsDeviceService(
PresentationParameters p_PresentationParameters)
{
m_PresentationParameters = p_PresentationParameters;
m_GraphicsDevice = new GraphicsDevice(
GraphicsAdapter.DefaultAdapter, GraphicsProfile.HiDef,
m_PresentationParameters );
}
public void CreateDevice()
{
PresentationParameters pp = new PresentationParameters();
pp.IsFullScreen = false;
pp.BackBufferHeight = this.m_renderControl.Height;
pp.BackBufferWidth = this.m_renderControl.Width;
pp.DeviceWindowHandle = this.m_renderControl.Handle;
this.m_graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.HiDef, pp);
}
private GraphicsDeviceService(IntPtr windowHandle, int width, int height)
{
this.parameters = new PresentationParameters();
this.parameters.BackBufferWidth = Math.Max(width, 1);
this.parameters.BackBufferHeight = Math.Max(height, 1);
this.parameters.BackBufferFormat = SurfaceFormat.Color;
this.parameters.EnableAutoDepthStencil = true;
this.parameters.AutoDepthStencilFormat = DepthFormat.Depth24;
this.graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, DeviceType.Hardware, windowHandle, this.parameters);
}
public static GraphicsDeviceService AddReference(
PresentationParameters p_PresentationParameters)
{
if( Interlocked.Increment( ref m_ReferenceCount ) == 1 )
{
Instance = new GraphicsDeviceService(
p_PresentationParameters );
}
return Instance;
}
private static GraphicsDevice setupGraphicsDevice()
{
PresentationParameters windowParams = new PresentationParameters();
windowParams.DeviceWindowHandle = new IntPtr(1);
GraphicsAdapter.UseNullDevice = true;
GraphicsDevice device = new GraphicsDevice(
GraphicsAdapter.DefaultAdapter,
GraphicsProfile.Reach,
windowParams);
return device;
}
GraphicsDeviceService(IntPtr windowHandle, int width, int height)
{
parameters = new PresentationParameters();
parameters.BackBufferWidth = Math.Max(width, 1);
parameters.BackBufferHeight = Math.Max(height, 1);
parameters.DepthStencilFormat = DepthFormat.Depth24;
parameters.DeviceWindowHandle = windowHandle;
parameters.PresentationInterval = PresentInterval.Immediate;
parameters.IsFullScreen = false;
graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.HiDef, parameters);
}
public override bool InitializeHandler(IntPtr hAttachedWindow)
{
m_XNA_GraphicsDevice = null;
pp = null;
if (!base.InitializeHandler(hAttachedWindow))
return false;
UWB_XNAGraphicsDevice.m_TheAPI.CreateGraphicsContext(hAttachedWindow, ref pp);
m_XNA_GraphicsDevice = UWB_XNAGraphicsDevice.m_TheAPI.GraphicsDevice;
return true;
}
/// <summary>
/// Constructor is private, because this is a singleton class:
/// client controls should use the public AddRef method instead.
/// </summary>
GraphicsDeviceService(IntPtr windowHandle, int width, int height)
{
GraphicsAdapter adapter = GraphicsAdapter.DefaultAdapter;
GraphicsProfile profile = GraphicsProfile.Reach;
PresentationParameters pp = new PresentationParameters()
{
DeviceWindowHandle = windowHandle,
BackBufferWidth = Math.Max(width, 1),
BackBufferHeight = Math.Max(height, 1),
};
graphicsDevice = new GraphicsDevice(adapter, profile, pp);
}
/// <summary>
/// Constructor is private, because this is a singleton class:
/// client controls should use the public AddRef method instead.
/// </summary>
GraphicsDeviceService(GraphicsProfile profile, IntPtr windowHandle, int width, int height)
{
parameters = new PresentationParameters();
parameters.BackBufferWidth = Math.Max(width, 1);
parameters.BackBufferHeight = Math.Max(height, 1);
parameters.BackBufferFormat = SurfaceFormat.Color;
parameters.DepthStencilFormat = DepthFormat.Depth24Stencil8;
parameters.DeviceWindowHandle = windowHandle;
parameters.IsFullScreen = false;
graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, profile, parameters);
}
public static GraphicsDevice CreateDevice()
{
//init PresentationParameters
pp = new PresentationParameters();
pp.AutoDepthStencilFormat = DepthFormat.Depth24Stencil8;
pp.EnableAutoDepthStencil = true;
pp.PresentOptions = PresentOptions.DiscardDepthStencil;
pp.RenderTargetUsage = RenderTargetUsage.DiscardContents;
pp.SwapEffect = SwapEffect.Discard;
pp.BackBufferFormat = SurfaceFormat.Color;
return new GraphicsDevice(GraphicsAdapter.DefaultAdapter, DeviceType.Hardware, Static.RenderTarget.Handle, pp);
}
internal XNASwapChainImplementation(XNA.GraphicsDeviceManager gdManager, IntPtr windowHandle, PresentationParameters presentParams)
{
_gdManager = gdManager;
_graphicsDevice = gdManager.GraphicsDevice;
_windowHandle = windowHandle;
_presentParams = presentParams;
_pp = new XFG.PresentationParameters();
_pp.DeviceWindowHandle = windowHandle;
_pp.IsFullScreen = false;
_pp.DisplayOrientation = XNA.DisplayOrientation.Default;
SetXNAPresentationParameters(presentParams);
_graphicsDevice.Reset(_pp);
}
internal XNARenderer(XFG.GraphicsProfile profile)
{
_dummyForm = new System.Windows.Forms.Form();
XFG.PresentationParameters pp = new XFG.PresentationParameters();
pp.BackBufferFormat = XFG.SurfaceFormat.Color;
pp.BackBufferHeight = 1;
pp.BackBufferWidth = 1;
pp.DepthStencilFormat = XFG.DepthFormat.None;
pp.DeviceWindowHandle = _dummyForm.Handle;
pp.PresentationInterval = XFG.PresentInterval.Immediate;
pp.IsFullScreen = false;
_device = new XFG.GraphicsDevice(XFG.GraphicsAdapter.DefaultAdapter, profile, pp);
}
public RendererImpl(IntPtr hwnd, int multiSampleCount, int minWidth, int minHeight)
{
Adapter = GraphicsAdapter.DefaultAdapter;
PresentParams = new PresentationParameters()
{
DeviceWindowHandle = hwnd,
BackBufferWidth = Math.Max(minWidth, GraphicsAdapter.Adapters.Max(a => a.CurrentDisplayMode.Width)),
BackBufferHeight = Math.Max(minHeight, GraphicsAdapter.Adapters.Max(a => a.CurrentDisplayMode.Height)),
BackBufferFormat = Adapter.CurrentDisplayMode.Format,
DepthStencilFormat = DepthFormat.Depth24Stencil8,
PresentationInterval = PresentInterval.Immediate,
RenderTargetUsage = RenderTargetUsage.PreserveContents,
MultiSampleCount = multiSampleCount,
IsFullScreen = false,
};
Device = new GraphicsDevice(Adapter, GraphicsProfile.HiDef, PresentParams);
DeviceService = new GraphicsDeviceService(Device);
Loader = new ContentManager(DeviceService, Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));
SpriteBatch = new SpriteBatch(Device);
DebugFont = Loader.Load<SpriteFont>("Content/Fonts/Debug");
WhiteTexel = new Texture2D(Device, 1, 1);
WhiteTexel.SetData(new Color[] { Color.White });
if (Global.No)
{
CoordinateSystemTexture2D = Loader.Load<Texture2D>("Content/Textures/UV");
var ptw = 800;
var pth = 600;
var ptd = from y in Enumerable.Range(0, pth)
from x in Enumerable.Range(0, ptw)
let yb = y == 0 || y == (pth - 1)
let xb = x == 0 || x == (ptw - 1)
let bw = ((x / 8) % 2) == 0 ? Color.Black : Color.White
select (xb || yb)
? Color.Black.Alpha(0.1f)
: bw;
HorizontalStripes = new Texture2D(Device, ptw, pth, false, SurfaceFormat.Color);
HorizontalStripes.SetData(ptd.ToArray());
RenderTarget2D = new RenderTarget2D(Device, PresentParams.BackBufferWidth, PresentParams.BackBufferHeight, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PreserveContents);
}
PostOps = new List<Action>();
}
public TestingApp()
{
App.Instance = this;
PresentationParameters pp = new PresentationParameters();
graphics = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, DeviceType.NullReference, System.IntPtr.Zero, pp);
model = new GameModel();
model.Music.TimeSignature = new TimeSignature(4, 4);
model.Music.Tempo = 60;
model.Music.ClicksPerBeat = 4;
controller = new ContactParser();
}
static void InitGraphics()
{
PresentationParameters parameters = new PresentationParameters();
parameters.BackBufferWidth = 1024;
parameters.BackBufferHeight = 1024;
parameters.BackBufferFormat = SurfaceFormat.Color;
parameters.DepthStencilFormat = DepthFormat.None;
parameters.IsFullScreen = false;
parameters.MultiSampleCount = 0;
parameters.PresentationInterval = PresentInterval.Default;
form = new Form();
parameters.DeviceWindowHandle = form.Handle;
GraphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.HiDef, parameters);
}
/// <summary>
/// Constructor is private, because this is a singleton class:
/// client controls should use the public AddRef method instead.
/// </summary>
GraphicsDeviceService(IntPtr windowHandle, int width, int height)
{
PresentationParameters pp = new PresentationParameters();
pp.DeviceWindowHandle = windowHandle;
pp.BackBufferWidth = Math.Max(width, 1);
pp.BackBufferHeight = Math.Max(height, 1);
pp.PresentationInterval = PresentInterval.Two;
graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.HiDef, pp);
//graphicsDevice.PresentationParameters.DeviceWindowHandle = windowHandle;
//graphicsDevice.PresentationParameters.BackBufferWidth = Math.Max(width, 1);
//graphicsDevice.PresentationParameters.BackBufferHeight = Math.Max(height, 1);
//graphicsDevice.PresentationParameters.PresentationInterval = PresentInterval.Two;
}
/// <summary>
/// Constructor is private, because this is a singleton class:
/// client controls should use the public AddRef method instead.
/// </summary>
GraphicsDeviceService(IntPtr windowHandle, int width, int height)
{
parameters = new PresentationParameters();
parameters.BackBufferWidth = Math.Max(width, 1);
parameters.BackBufferHeight = Math.Max(height, 1);
parameters.BackBufferFormat = SurfaceFormat.Color;
//parameters.EnableAutoDepthStencil = true;
//parameters.AutoDepthStencilFormat = DepthFormat.Depth24;
//CURRENTLY HORRIBLY BROKEN! DO NOT USE!!!
//graphicsDevice = new GraphicsDevice();
}
protected void CreateDevice (IntPtr windowHandle, int width, int height)
{
GraphicsAdapter adapter = GraphicsAdapter.DefaultAdapter;
GraphicsProfile profile = GraphicsProfile.Reach;
PresentationParameters pp = new PresentationParameters() {
DeviceWindowHandle = windowHandle,
BackBufferWidth = Math.Max(width, 1),
BackBufferHeight = Math.Max(height, 1),
};
_device = new GraphicsDevice(adapter, profile, pp);
if (DeviceCreated != null)
DeviceCreated(this, EventArgs.Empty);
}
private static void CreateGraphicsDevice(IntPtr windowHandle, int width, int height)
{
parameters = new PresentationParameters
{
BackBufferWidth = Math.Max(width, 1),
BackBufferHeight = Math.Max(height, 1),
BackBufferFormat = SurfaceFormat.Color,
DepthStencilFormat = DepthFormat.Depth24,
DeviceWindowHandle = windowHandle,
PresentationInterval = PresentInterval.Immediate,
IsFullScreen = false
};
graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.Reach, parameters);
}
void ToggleFullScreen()
{
Microsoft.Xna.Framework.Graphics.PresentationParameters presentation = CommonItem.GraphicsDevice.PresentationParameters;
if (presentation.IsFullScreen)
{
CommonItem.GraphicsDeviceManager.PreferredBackBufferWidth = Prefs.WindowSizeW;
CommonItem.GraphicsDeviceManager.PreferredBackBufferHeight = Prefs.WindowSizeH;
CommonItem.Game.Window.AllowUserResizing = false;
}
else
{
GraphicsAdapter adapter = CommonItem.GraphicsDeviceManager.GraphicsDevice.Adapter;
CommonItem.GraphicsDeviceManager.PreferredBackBufferWidth = adapter.CurrentDisplayMode.Width;
CommonItem.GraphicsDeviceManager.PreferredBackBufferHeight = adapter.CurrentDisplayMode.Height;
}
CommonItem.GraphicsDeviceManager.ToggleFullScreen();
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphicsDevice" /> class.
/// </summary>
/// <param name="adapter">The graphics adapter.</param>
/// <param name="graphicsProfile">The graphics profile.</param>
/// <param name="presentationParameters">The presentation options.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="presentationParameters"/> is <see langword="null"/>.
/// </exception>
public GraphicsDevice(GraphicsAdapter adapter, GraphicsProfile graphicsProfile, PresentationParameters presentationParameters)
{
if (adapter == null)
{
throw new ArgumentNullException("adapter");
}
if (!adapter.IsProfileSupported(graphicsProfile))
{
throw new NoSuitableGraphicsDeviceException(String.Format("Adapter '{0}' does not support the {1} profile.", adapter.Description, graphicsProfile));
}
if (presentationParameters == null)
{
throw new ArgumentNullException("presentationParameters");
}
Adapter = adapter;
PresentationParameters = presentationParameters;
_graphicsProfile = graphicsProfile;
Setup();
GraphicsCapabilities = new GraphicsCapabilities();
GraphicsCapabilities.Initialize(this);
Initialize();
}
public override bool Equals(object obj)
{
PresentationParameters parameters = obj as PresentationParameters;
if (parameters == null)
{
return(false);
}
return((parameters.autoDepthStencilFormat == this.autoDepthStencilFormat) &&
(parameters.backBufferCount == this.backBufferCount) &&
(parameters.backBufferFormat == this.backBufferFormat) &&
(parameters.backBufferHeight == this.backBufferHeight) &&
(parameters.backBufferWidth == this.backBufferWidth) &&
(parameters.deviceWindowHandle == this.deviceWindowHandle) &&
(parameters.enableAutoDepthStencil == this.enableAutoDepthStencil) &&
(parameters.fullScreenRefreshRateInHz == this.fullScreenRefreshRateInHz) &&
(parameters.isFullScreen == this.isFullScreen) &&
(parameters.multiSampleQuality == this.multiSampleQuality) &&
(parameters.multiSampleType == this.multiSampleType) &&
(parameters.presentationInterval == this.presentationInterval) &&
(parameters.presentOptions == this.presentOptions) &&
(parameters.swapEffect == this.swapEffect));
}
public ThreadedGLDevice(PresentationParameters presentationParameters)
{
csThread = new Thread(new ThreadStart(csThreadProc));
csThread.Start();
FNALoggerEXT.LogInfo("Running with ThreadedGLDevice!");
ForceToMainThread(() =>
{
if (Environment.GetEnvironmentVariable(
"FNA_THREADEDGLDEVICE_GLDEVICE"
) == "OpenGLDevice")
{
GLDevice = new OpenGLDevice(
presentationParameters
);
}
else
{
GLDevice = new ModernGLDevice(
presentationParameters
);
}
}); // End ForceToMainThread
}
internal void PlatformSetMultiSamplingToMaximum(PresentationParameters presentationParameters, out int quality)
{
presentationParameters.MultiSampleCount = 4;
quality = 0;
}
public void Reset(PresentationParameters presentationParameters, GraphicsAdapter graphicsAdapter)
{
throw new NotImplementedException();
}
public void Reset(
PresentationParameters presentationParameters,
GraphicsAdapter graphicsAdapter
)
{
if (presentationParameters == null)
{
throw new ArgumentNullException("presentationParameters");
}
PresentationParameters = presentationParameters;
Adapter = graphicsAdapter;
// Verify MSAA before we really start...
PresentationParameters.MultiSampleCount = Math.Min(
MathHelper.ClosestMSAAPower(
PresentationParameters.MultiSampleCount
),
GLDevice.MaxMultiSampleCount
);
// We're about to reset, let the application know.
if (DeviceResetting != null)
{
DeviceResetting(this, EventArgs.Empty);
}
/* FIXME: Why are we not doing this...? -flibit
* lock (resourcesLock)
* {
* foreach (WeakReference resource in resources)
* {
* object target = resource.Target;
* if (target != null)
* {
* (target as GraphicsResource).GraphicsDeviceResetting();
* }
* }
*
* // Remove references to resources that have been garbage collected.
* resources.RemoveAll(wr => !wr.IsAlive);
* }
*/
/* Reset the backbuffer first, before doing anything else.
* The GLDevice needs to know what we're up to right away.
* -flibit
*/
GLDevice.ResetBackbuffer(
PresentationParameters,
Adapter
);
// The mouse needs to know this for faux-backbuffer mouse scaling.
Input.Mouse.INTERNAL_BackBufferWidth = PresentationParameters.BackBufferWidth;
Input.Mouse.INTERNAL_BackBufferHeight = PresentationParameters.BackBufferHeight;
// The Touch Panel needs this too, for the same reason.
Input.Touch.TouchPanel.DisplayWidth = PresentationParameters.BackBufferWidth;
Input.Touch.TouchPanel.DisplayHeight = PresentationParameters.BackBufferHeight;
#if WIIU_GAMEPAD
wiiuPixelData = new byte[
PresentationParameters.BackBufferWidth *
PresentationParameters.BackBufferHeight *
4
];
#endif
// Now, update the viewport
Viewport = new Viewport(
0,
0,
PresentationParameters.BackBufferWidth,
PresentationParameters.BackBufferHeight
);
// Update the scissor rectangle to our new default target size
ScissorRectangle = new Rectangle(
0,
0,
PresentationParameters.BackBufferWidth,
PresentationParameters.BackBufferHeight
);
// Finally, update the swap interval
GLDevice.SetPresentationInterval(
PresentationParameters.PresentationInterval
);
// We just reset, let the application know.
if (DeviceReset != null)
{
DeviceReset(this, EventArgs.Empty);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphicsDevice" /> class.
/// </summary>
/// <param name="adapter">The graphics adapter.</param>
/// <param name="graphicsProfile">The graphics profile.</param>
/// <param name="presentationParameters">The presentation options.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="presentationParameters"/> is <see langword="null"/>.
/// </exception>
public GraphicsDevice(
GraphicsAdapter adapter,
GraphicsProfile graphicsProfile,
PresentationParameters presentationParameters
)
{
if (presentationParameters == null)
{
throw new ArgumentNullException("presentationParameters");
}
// Set the properties from the constructor parameters.
Adapter = adapter;
PresentationParameters = presentationParameters;
GraphicsProfile = graphicsProfile;
PresentationParameters.MultiSampleCount = MathHelper.ClosestMSAAPower(
PresentationParameters.MultiSampleCount
);
// Set up the IGLDevice
GLDevice = FNAPlatform.CreateGLDevice(PresentationParameters, adapter);
// The mouse needs to know this for faux-backbuffer mouse scaling.
Input.Mouse.INTERNAL_BackBufferWidth = PresentationParameters.BackBufferWidth;
Input.Mouse.INTERNAL_BackBufferHeight = PresentationParameters.BackBufferHeight;
// The Touch Panel needs this too, for the same reason.
Input.Touch.TouchPanel.DisplayWidth = PresentationParameters.BackBufferWidth;
Input.Touch.TouchPanel.DisplayHeight = PresentationParameters.BackBufferHeight;
// Force set the default render states.
BlendState = BlendState.Opaque;
DepthStencilState = DepthStencilState.Default;
RasterizerState = RasterizerState.CullCounterClockwise;
// Initialize the Texture/Sampler state containers
int maxTextures = Math.Min(GLDevice.MaxTextureSlots, MAX_TEXTURE_SAMPLERS);
int maxVertexTextures = MathHelper.Clamp(
GLDevice.MaxTextureSlots - MAX_TEXTURE_SAMPLERS,
0,
MAX_VERTEXTEXTURE_SAMPLERS
);
vertexSamplerStart = GLDevice.MaxTextureSlots - maxVertexTextures;
Textures = new TextureCollection(
maxTextures,
modifiedSamplers
);
SamplerStates = new SamplerStateCollection(
maxTextures,
modifiedSamplers
);
VertexTextures = new TextureCollection(
maxVertexTextures,
modifiedVertexSamplers
);
VertexSamplerStates = new SamplerStateCollection(
maxVertexTextures,
modifiedVertexSamplers
);
// Set the default viewport and scissor rect.
Viewport = new Viewport(PresentationParameters.Bounds);
ScissorRectangle = Viewport.Bounds;
// Allocate the pipeline cache to be used by Effects
PipelineCache = new PipelineCache(this);
#if WIIU_GAMEPAD
wiiuStream = DRC.drc_new_streamer();
if (wiiuStream == IntPtr.Zero)
{
FNALoggerEXT.LogError("Failed to alloc GamePad stream!");
return;
}
if (DRC.drc_start_streamer(wiiuStream) < 1) // ???
{
FNALoggerEXT.LogError("Failed to start GamePad stream!");
DRC.drc_delete_streamer(wiiuStream);
wiiuStream = IntPtr.Zero;
return;
}
DRC.drc_enable_system_input_feeder(wiiuStream);
wiiuPixelData = new byte[
PresentationParameters.BackBufferWidth *
PresentationParameters.BackBufferHeight *
4
];
#endif
}
public PresentationEventArgs(PresentationParameters presentationParameters)
{
PresentationParameters = presentationParameters;
}
public GraphicsDevice(GraphicsAdapter adapter, DeviceType deviceType, IntPtr renderWindowHandle, PresentationParameters presentationParameters)
{
if (adapter == null || presentationParameters == null)
{
throw new ArgumentNullException("adapter or presentationParameters is null.");
}
graphicsDeviceCapabilities = adapter.GetCapabilities(deviceType);
numActiveRenderTargets = 0;
renderTargets = new RenderTarget[graphicsDeviceCapabilities.MaxSimultaneousRenderTargets];
initGL();
this.adapter = adapter;
this.deviceType = deviceType;
this.renderWindowHandle = renderWindowHandle;
PresentationParameters = presentationParameters; // set through property to ensure OpenGL propagation
this.textures = new TextureCollection();
this.clearColor = Color.Black;
}
public unsafe void Reset(PresentationParameters presentationParameters, GraphicsAdapter graphicsAdapter)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphicsDevice" /> class.
/// </summary>
/// <param name="adapter">The graphics adapter.</param>
/// <param name="graphicsProfile">The graphics profile.</param>
/// <param name="presentationParameters">The presentation options.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="presentationParameters"/> is <see langword="null"/>.
/// </exception>
public GraphicsDevice(GraphicsAdapter adapter, GraphicsProfile graphicsProfile, PresentationParameters presentationParameters)
{
if (presentationParameters == null)
{
throw new ArgumentNullException("presentationParameters");
}
// Set the properties from the constructor parameters.
Adapter = adapter;
PresentationParameters = presentationParameters;
GraphicsProfile = graphicsProfile;
// Force set the default render states.
BlendState = BlendState.Opaque;
DepthStencilState = DepthStencilState.Default;
RasterizerState = RasterizerState.CullCounterClockwise;
// Initialize the Texture/Sampler state containers
Textures = new TextureCollection(OpenGLDevice.Instance.MaxTextureSlots);
SamplerStates = new SamplerStateCollection(OpenGLDevice.Instance.MaxTextureSlots);
Textures.Clear();
SamplerStates.Clear();
// Clear constant buffers
vertexConstantBuffers.Clear();
pixelConstantBuffers.Clear();
// Force set the buffers and shaders on next ApplyState() call
vertexBufferBindings = new VertexBufferBinding[OpenGLDevice.Instance.MaxVertexAttributes];
// First draw will need to set the shaders.
vertexShaderDirty = true;
pixelShaderDirty = true;
// Set the default scissor rect.
ScissorRectangle = Viewport.Bounds;
// Free all the cached shader programs.
programCache.Clear();
shaderProgram = null;
}
public void Reset(
PresentationParameters presentationParameters,
GraphicsAdapter graphicsAdapter
)
{
if (presentationParameters == null)
{
throw new ArgumentNullException("presentationParameters");
}
// We're about to reset, let the application know.
if (DeviceResetting != null)
{
DeviceResetting(this, EventArgs.Empty);
}
/* FIXME: Why are we not doing this...? -flibit
* lock (resourcesLock)
* {
* foreach (WeakReference resource in resources)
* {
* object target = resource.Target;
* if (target != null)
* {
* (target as GraphicsResource).GraphicsDeviceResetting();
* }
* }
*
* // Remove references to resources that have been garbage collected.
* resources.RemoveAll(wr => !wr.IsAlive);
* }
*/
// Set the new PresentationParameters first.
PresentationParameters = presentationParameters;
PresentationParameters.MultiSampleCount = Math.Min(
MathHelper.ClosestMSAAPower(
PresentationParameters.MultiSampleCount
),
GLDevice.MaxMultiSampleCount
);
/* Reset the backbuffer first, before doing anything else.
* The GLDevice needs to know what we're up to right away.
* -flibit
*/
GLDevice.ResetBackbuffer(
PresentationParameters,
RenderTargetCount > 0
);
// Now, update the viewport
Viewport = new Viewport(
0,
0,
PresentationParameters.BackBufferWidth,
PresentationParameters.BackBufferHeight
);
// Update the scissor rectangle to our new default target size
ScissorRectangle = new Rectangle(
0,
0,
PresentationParameters.BackBufferWidth,
PresentationParameters.BackBufferHeight
);
// FIXME: This should probably mean something. -flibit
Adapter = graphicsAdapter;
// We just reset, let the application know.
if (DeviceReset != null)
{
DeviceReset(this, EventArgs.Empty);
}
}
public void Reset(PresentationParameters presentationParameters)
{
raise_DeviceResetting(this, EventArgs.Empty);
PresentationParameters = presentationParameters;
raise_DeviceReset(this, EventArgs.Empty);
}
public void Reset(PresentationParameters presentationParameters)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphicsDevice" /> class.
/// </summary>
/// <param name="adapter">The graphics adapter.</param>
/// <param name="graphicsProfile">The graphics profile.</param>
/// <param name="presentationParameters">The presentation options.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="presentationParameters"/> is <see langword="null"/>.
/// </exception>
public GraphicsDevice(GraphicsAdapter adapter, GraphicsProfile graphicsProfile, PresentationParameters presentationParameters)
{
Adapter = adapter;
if (presentationParameters == null)
{
throw new ArgumentNullException("presentationParameters");
}
PresentationParameters = presentationParameters;
Setup();
GraphicsCapabilities = new GraphicsCapabilities(this);
GraphicsProfile = graphicsProfile;
Initialize();
}
public void Reset(PresentationParameters presentationParameters)
{
Reset(presentationParameters, Adapter);
}
public GraphicsDevice(GraphicsAdapter adapter, GraphicsProfile graphicsProfile, PresentationParameters presentationParameters)
{
}
public void Reset(PresentationParameters presentationParameters)
{
throw new NotImplementedException();
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphicsDevice" /> class.
/// </summary>
/// <param name="adapter">The graphics adapter.</param>
/// <param name="graphicsProfile">The graphics profile.</param>
/// <param name="presentationParameters">The presentation options.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="presentationParameters"/> is <see langword="null"/>.
/// </exception>
public GraphicsDevice(GraphicsAdapter adapter, GraphicsProfile graphicsProfile, PresentationParameters presentationParameters, IntPtr hnw)
{
windowsHandle = hnw;
windowsHandleSet = true;
Adapter = adapter;
if (presentationParameters == null)
{
throw new ArgumentNullException("presentationParameters");
}
PresentationParameters = presentationParameters;
Setup();
GraphicsCapabilities = new GraphicsCapabilities(this);
GraphicsProfile = graphicsProfile;
Initialize();
}
