930b2526f7
Also made the recording inputsystem not selectable for that sample as that needs some code modification in the sample to make it work. It was not possible to run it with openGL because the creation of the windowInfo object was faulty, it might have worked on linux, but it didn't work on windows. Also updated a few deprecated calls for OpenGL. Closing an OpenGL application did wrongly throw an exception when an effect gets disposed, this is fixed now and the memory usage was slightly reduced. For DirectX 11, which didn't work for the samples out of the box, it was changed that the sharpdx effect dll's are now part of the directx 11 rendersystem so that they don't have to be copied over manually anymore. Did some very small change to the RecordingGamePad class which makes it work if no data is recorded or played back.
477 lines
14 KiB
C#
477 lines
14 KiB
C#
using System;
|
|
using ANX.Framework;
|
|
using ANX.Framework.Graphics;
|
|
using ANX.Framework.NonXNA;
|
|
using ANX.RenderSystem.GL3.Helpers;
|
|
using OpenTK.Graphics;
|
|
using OpenTK.Graphics.OpenGL;
|
|
using OpenTK.Platform;
|
|
using OpenTK.Platform.X11;
|
|
|
|
// This file is part of the ANX.Framework created by the
|
|
// "ANX.Framework developer group" and released under the Ms-PL license.
|
|
// For details see: http://anxframework.codeplex.com/license
|
|
|
|
namespace ANX.RenderSystem.GL3
|
|
{
|
|
public class GraphicsDeviceWindowsGL3 : INativeGraphicsDevice
|
|
{
|
|
#region Constants
|
|
private const float ColorMultiplier = 1f / 255f;
|
|
#endregion
|
|
|
|
#region Private
|
|
private GraphicsContext nativeContext;
|
|
private IWindowInfo nativeWindowInfo;
|
|
private GraphicsMode graphicsMode;
|
|
|
|
private int cachedVersionMinor = -1;
|
|
private int cachedVersionMajor = -1;
|
|
|
|
internal static VertexBufferGL3[] boundVertexBuffers;
|
|
private static RenderTarget2DGL3[] boundRenderTargets;
|
|
internal static IndexBufferGL3 boundIndexBuffer;
|
|
internal static EffectGL3 activeEffect;
|
|
|
|
internal static GraphicsDeviceWindowsGL3 Current
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
internal static bool IsContextCurrent
|
|
{
|
|
get
|
|
{
|
|
return (Current != null && Current.nativeContext != null) && Current.nativeContext.IsCurrent;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Public
|
|
public bool VSync
|
|
{
|
|
get { return nativeContext.VSync; }
|
|
set { nativeContext.VSync = value; }
|
|
}
|
|
|
|
public Rectangle ScissorRectangle
|
|
{
|
|
get
|
|
{
|
|
// TODO: test
|
|
var boxParams = new int[4];
|
|
GL.GetInteger(GetPName.ScissorBox, boxParams);
|
|
return new Rectangle(boxParams[0], boxParams[1], boxParams[2], boxParams[3]);
|
|
}
|
|
set { GL.Scissor(value.X, value.Y, value.Width, value.Height); }
|
|
}
|
|
#endregion
|
|
|
|
#region Constructor
|
|
internal GraphicsDeviceWindowsGL3(PresentationParameters presentationParameters)
|
|
{
|
|
Current = this;
|
|
ResetDevice(presentationParameters);
|
|
}
|
|
#endregion
|
|
|
|
#region ResetDevice
|
|
private void ResetDevice(PresentationParameters presentationParameters)
|
|
{
|
|
if (nativeContext != null)
|
|
Dispose();
|
|
|
|
boundVertexBuffers = new VertexBufferGL3[0];
|
|
boundRenderTargets = new RenderTarget2DGL3[0];
|
|
boundIndexBuffer = null;
|
|
activeEffect = null;
|
|
|
|
int depth = 0;
|
|
int stencil = 0;
|
|
switch (presentationParameters.DepthStencilFormat)
|
|
{
|
|
case DepthFormat.None:
|
|
break;
|
|
|
|
case DepthFormat.Depth16:
|
|
depth = 16;
|
|
break;
|
|
|
|
case DepthFormat.Depth24:
|
|
depth = 24;
|
|
break;
|
|
|
|
case DepthFormat.Depth24Stencil8:
|
|
depth = 24;
|
|
stencil = 8;
|
|
break;
|
|
}
|
|
|
|
ResizeRenderWindow(presentationParameters);
|
|
|
|
var colorFormat = DatatypesMapping.SurfaceToColorFormat(presentationParameters.BackBufferFormat);
|
|
graphicsMode = new GraphicsMode(colorFormat, depth, stencil, presentationParameters.MultiSampleCount);
|
|
|
|
CreateWindowInfo(presentationParameters.DeviceWindowHandle, graphicsMode.Index);
|
|
|
|
nativeContext = new GraphicsContext(graphicsMode, nativeWindowInfo);
|
|
nativeContext.MakeCurrent(nativeWindowInfo);
|
|
nativeContext.LoadAll();
|
|
|
|
LogOpenGLInformation();
|
|
|
|
GL.Viewport(0, 0, presentationParameters.BackBufferWidth, presentationParameters.BackBufferHeight);
|
|
|
|
GraphicsResourceManager.RecreateAllResources();
|
|
}
|
|
#endregion
|
|
|
|
#region LogOpenGLInformation
|
|
private void LogOpenGLInformation()
|
|
{
|
|
string version = GL.GetString(StringName.Version);
|
|
string vendor = GL.GetString(StringName.Vendor);
|
|
string renderer = GL.GetString(StringName.Renderer);
|
|
string shadingLanguageVersion = GL.GetString(StringName.ShadingLanguageVersion);
|
|
Logger.Info("OpenGL version: " + version + " (" + vendor + " - " + renderer + ")");
|
|
Logger.Info("GLSL version: " + shadingLanguageVersion);
|
|
string[] parts = version.Split(new char[] { '.', ' ' });
|
|
cachedVersionMajor = int.Parse(parts[0]);
|
|
cachedVersionMinor = int.Parse(parts[1]);
|
|
}
|
|
#endregion
|
|
|
|
#region CreateWindowInfo
|
|
private void CreateWindowInfo(IntPtr windowHandle, IntPtr? graphicsModeHandle)
|
|
{
|
|
if (OpenTK.Configuration.RunningOnWindows)
|
|
nativeWindowInfo = Utilities.CreateWindowsWindowInfo(windowHandle);
|
|
else if (OpenTK.Configuration.RunningOnX11)
|
|
nativeWindowInfo = LinuxInterop.CreateX11WindowInfo(windowHandle, graphicsModeHandle.Value);
|
|
else if (OpenTK.Configuration.RunningOnMacOS)
|
|
nativeWindowInfo = Utilities.CreateMacOSCarbonWindowInfo(windowHandle, false, true);
|
|
else
|
|
throw new NotImplementedException();
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region SetViewport
|
|
public void SetViewport(Viewport viewport)
|
|
{
|
|
GL.Viewport(viewport.X, viewport.Y, viewport.Width, viewport.Height);
|
|
ErrorHelper.Check("SetViewport");
|
|
}
|
|
#endregion
|
|
|
|
#region Clear
|
|
private uint? lastClearColor;
|
|
/// <summary>
|
|
/// Clear the current screen by the specified clear color.
|
|
/// </summary>
|
|
/// <param name="color">Clear color.</param>
|
|
public void Clear(ref Color color)
|
|
{
|
|
uint newClearColor = color.PackedValue;
|
|
if (lastClearColor.HasValue == false ||
|
|
lastClearColor != newClearColor)
|
|
{
|
|
lastClearColor = newClearColor;
|
|
GL.ClearColor(color.R * ColorMultiplier, color.G * ColorMultiplier,
|
|
color.B * ColorMultiplier, color.A * ColorMultiplier);
|
|
ErrorHelper.Check("ClearColor");
|
|
}
|
|
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
|
|
ErrorHelper.Check("Clear");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear the current screen by the specified clear color and options.
|
|
/// </summary>
|
|
/// <param name="options">Clear options defining which components
|
|
/// should be cleared.</param>
|
|
/// <param name="color">Clear color.</param>
|
|
/// <param name="depth">Depth value.</param>
|
|
/// <param name="stencil">Stencil value.</param>
|
|
public void Clear(ClearOptions options, Vector4 color, float depth,
|
|
int stencil)
|
|
{
|
|
Color anxColor;
|
|
DatatypesMapping.Convert(ref color, out anxColor);
|
|
uint newClearColor = anxColor.PackedValue;
|
|
if (lastClearColor != newClearColor)
|
|
{
|
|
lastClearColor = newClearColor;
|
|
GL.ClearColor(anxColor.R * ColorMultiplier, anxColor.G * ColorMultiplier,
|
|
anxColor.B * ColorMultiplier, anxColor.A * ColorMultiplier);
|
|
ErrorHelper.Check("ClearColor");
|
|
}
|
|
|
|
ClearBufferMask mask = (ClearBufferMask)0;
|
|
if ((options | ClearOptions.Target) == options)
|
|
{
|
|
mask |= ClearBufferMask.ColorBufferBit;
|
|
}
|
|
if ((options | ClearOptions.Stencil) == options)
|
|
{
|
|
mask |= ClearBufferMask.StencilBufferBit;
|
|
}
|
|
if ((options | ClearOptions.DepthBuffer) == options)
|
|
{
|
|
mask |= ClearBufferMask.DepthBufferBit;
|
|
}
|
|
|
|
GL.ClearDepth(depth);
|
|
ErrorHelper.Check("ClearDepth");
|
|
GL.ClearStencil(stencil);
|
|
ErrorHelper.Check("ClearStencil");
|
|
GL.Clear(mask);
|
|
ErrorHelper.Check("Clear");
|
|
}
|
|
#endregion
|
|
|
|
#region Present
|
|
/// <summary>
|
|
/// Swap the graphics buffers.
|
|
/// </summary>
|
|
public void Present()
|
|
{
|
|
if (nativeContext != null)
|
|
{
|
|
nativeContext.SwapBuffers();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region DrawIndexedPrimitives
|
|
public void DrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex, int numVertices,
|
|
int startIndex, int primitiveCount, IndexBuffer indexBuffer)
|
|
{
|
|
if (indexBuffer != null)
|
|
{
|
|
SetIndexBuffer(indexBuffer);
|
|
}
|
|
|
|
// TODO: baseVertex, minVertexIndex, numVertices, startIndex
|
|
DrawElementsType elementsType = boundIndexBuffer.elementSize == IndexElementSize.SixteenBits ?
|
|
DrawElementsType.UnsignedShort :
|
|
DrawElementsType.UnsignedInt;
|
|
|
|
int count;
|
|
BeginMode mode = DatatypesMapping.PrimitiveTypeToBeginMode(primitiveType, primitiveCount, out count);
|
|
|
|
GL.DrawElements(mode, count, elementsType, 0);
|
|
ErrorHelper.Check("DrawElements");
|
|
}
|
|
#endregion
|
|
|
|
#region DrawInstancedPrimitives (TODO)
|
|
public void DrawInstancedPrimitives(PrimitiveType primitiveType,
|
|
int baseVertex, int minVertexIndex, int numVertices, int startIndex,
|
|
int primitiveCount, int instanceCount, IndexBuffer indexBuffer)
|
|
{
|
|
if (indexBuffer != null)
|
|
{
|
|
SetIndexBuffer(indexBuffer);
|
|
}
|
|
|
|
//GL.DrawArraysInstanced(
|
|
// DatatypesMapping.PrimitiveTypeToBeginMode(primitiveType),
|
|
// baseVertex, numVertices, instanceCount);
|
|
throw new NotImplementedException();
|
|
}
|
|
#endregion
|
|
|
|
#region DrawUserIndexedPrimitives (TODO)
|
|
public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType,
|
|
T[] vertexData, int vertexOffset, int numVertices, Array indexData,
|
|
int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration,
|
|
IndexElementSize indexFormat) where T : struct, IVertexType
|
|
{
|
|
//BeginMode mode = DatatypesMapping.PrimitiveTypeToBeginMode(primitiveType);
|
|
|
|
//if (indexFormat == IndexElementSize.SixteenBits)
|
|
//{
|
|
// ushort[] indices = new ushort[indexData.Length];
|
|
// indexData.CopyTo(indices, 0);
|
|
// GL.DrawElements(mode, numVertices, DrawElementsType.UnsignedShort,
|
|
// indices);
|
|
//}
|
|
//else
|
|
//{
|
|
// uint[] indices = new uint[indexData.Length];
|
|
// indexData.CopyTo(indices, 0);
|
|
// GL.DrawElements(mode, numVertices, DrawElementsType.UnsignedInt,
|
|
// indices);
|
|
//}
|
|
|
|
throw new NotImplementedException();
|
|
}
|
|
#endregion
|
|
|
|
#region DrawUserPrimitives (TODO)
|
|
public void DrawUserPrimitives<T>(PrimitiveType primitiveType,
|
|
T[] vertexData, int vertexOffset, int primitiveCount,
|
|
VertexDeclaration vertexDeclaration) where T : struct, IVertexType
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
#endregion
|
|
|
|
#region DrawPrimitives (TODO: check)
|
|
public void DrawPrimitives(PrimitiveType primitiveType, int vertexOffset,
|
|
int primitiveCount)
|
|
{
|
|
int count;
|
|
BeginMode mode = DatatypesMapping.PrimitiveTypeToBeginMode(primitiveType,
|
|
primitiveCount, out count);
|
|
GL.DrawArrays(mode, vertexOffset, count);
|
|
ErrorHelper.Check("DrawArrays");
|
|
}
|
|
#endregion
|
|
|
|
#region SetConstantBuffer (TODO)
|
|
#if XNAEXT
|
|
public void SetConstantBuffer(int slot, ConstantBuffer constantBuffer)
|
|
{
|
|
if (constantBuffer == null)
|
|
throw new ArgumentNullException("constantBuffer");
|
|
|
|
throw new NotImplementedException();
|
|
}
|
|
#endif
|
|
#endregion
|
|
|
|
#region SetVertexBuffers
|
|
public void SetVertexBuffers(VertexBufferBinding[] vertexBuffers)
|
|
{
|
|
boundVertexBuffers = new VertexBufferGL3[vertexBuffers.Length];
|
|
for (int index = 0; index < vertexBuffers.Length; index++)
|
|
{
|
|
var nativeBuffer = (VertexBufferGL3)vertexBuffers[index].VertexBuffer.NativeVertexBuffer;
|
|
boundVertexBuffers[index] = nativeBuffer;
|
|
nativeBuffer.Bind(activeEffect);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region SetIndexBuffer
|
|
public void SetIndexBuffer(IndexBuffer indexBuffer)
|
|
{
|
|
boundIndexBuffer = (IndexBufferGL3)indexBuffer.NativeIndexBuffer;
|
|
GL.BindBuffer(BufferTarget.ElementArrayBuffer, boundIndexBuffer.BufferHandle);
|
|
ErrorHelper.Check("BindBuffer");
|
|
}
|
|
#endregion
|
|
|
|
#region ResizeRenderWindow
|
|
private void ResizeRenderWindow(PresentationParameters presentationParameters)
|
|
{
|
|
if (OpenTK.Configuration.RunningOnWindows)
|
|
{
|
|
WindowsInterop.ResizeWindow(presentationParameters.DeviceWindowHandle,
|
|
presentationParameters.BackBufferWidth,
|
|
presentationParameters.BackBufferHeight);
|
|
}
|
|
else
|
|
{
|
|
if (nativeWindowInfo != null)
|
|
{
|
|
LinuxInterop.ResizeWindow(IntPtr.Zero, presentationParameters.DeviceWindowHandle,
|
|
presentationParameters.BackBufferWidth,
|
|
presentationParameters.BackBufferHeight);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region SetRenderTargets
|
|
public void SetRenderTargets(params RenderTargetBinding[] renderTargets)
|
|
{
|
|
if (renderTargets == null)
|
|
{
|
|
if (boundRenderTargets.Length > 0)
|
|
{
|
|
for (int index = 0; index < boundRenderTargets.Length; index++)
|
|
{
|
|
boundRenderTargets[index].Unbind();
|
|
}
|
|
boundRenderTargets = new RenderTarget2DGL3[0];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
boundRenderTargets = new RenderTarget2DGL3[renderTargets.Length];
|
|
for (int index = 0; index < renderTargets.Length; index++)
|
|
{
|
|
RenderTarget2D renderTarget =
|
|
renderTargets[index].RenderTarget as RenderTarget2D;
|
|
RenderTarget2DGL3 nativeRenderTarget =
|
|
renderTarget.NativeRenderTarget as RenderTarget2DGL3;
|
|
boundRenderTargets[index] = nativeRenderTarget;
|
|
|
|
nativeRenderTarget.Bind();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region GetBackBufferData (TODO)
|
|
public void GetBackBufferData<T>(Rectangle? rect, T[] data,
|
|
int startIndex, int elementCount) where T : struct
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public void GetBackBufferData<T>(T[] data) where T : struct
|
|
{
|
|
//glReadPixels(0, 0, nWidth, nHeight, GL_RGB, GL_UNSIGNED_BYTE, m_pPixelData)
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public void GetBackBufferData<T>(T[] data, int startIndex,
|
|
int elementCount) where T : struct
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
#endregion
|
|
|
|
#region ResizeBuffers
|
|
public void ResizeBuffers(PresentationParameters presentationParameters)
|
|
{
|
|
ResizeRenderWindow(presentationParameters);
|
|
|
|
GL.Viewport(0, 0, presentationParameters.BackBufferWidth,
|
|
presentationParameters.BackBufferHeight);
|
|
|
|
ResetDevice(presentationParameters);
|
|
}
|
|
#endregion
|
|
|
|
#region Dispose
|
|
public void Dispose()
|
|
{
|
|
GraphicsResourceManager.DisposeAllResources();
|
|
|
|
lastClearColor = new uint?();
|
|
boundVertexBuffers = null;
|
|
boundIndexBuffer = null;
|
|
activeEffect = null;
|
|
boundRenderTargets = null;
|
|
|
|
if (nativeWindowInfo != null)
|
|
{
|
|
nativeWindowInfo.Dispose();
|
|
nativeWindowInfo = null;
|
|
}
|
|
if (nativeContext != null)
|
|
{
|
|
nativeContext.Dispose();
|
|
nativeContext = null;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|