alysbrooks-public » games » isometric-park-fna

Location: alysbrooks-public/games/isometric-park-fna/FNA/src/FNAPlatform/ThreadedGLDevice.cs

Show More
Commit Description:
Various UI improvements.
Commit Description:
Various UI improvements.
References:
r291:6a7d5e8510b1 default
File last commit:
r0:e33f209de7e5 default
Show/Diff file:
Action:
FNA/src/FNAPlatform/ThreadedGLDevice.cs
1203 lines | 21.5 KiB | text/x-csharp | CSharpLexer
History | Annotation | Raw | Download
#region License
/* FNA - XNA4 Reimplementation for Desktop Platforms
* Copyright 2009-2020 Ethan Lee and the MonoGame Team
*
* Released under the Microsoft Public License.
* See LICENSE for details.
*/
#endregion
#region Using Statements
using System;
using System.Threading;
using System.Collections.Generic;
using System.Collections.Concurrent;
#endregion
namespace Microsoft.Xna.Framework.Graphics
{
internal class ThreadedGLDevice : IGLDevice
{
#region Public Properties
public Color BlendFactor
{
get
{
Color result = Color.Black;
ForceToMainThread(() =>
{
result = GLDevice.BlendFactor;
}); // End ForceToMainThread
return result;
}
set
{
ForceToMainThread(() =>
{
GLDevice.BlendFactor = value;
}); // End ForceToMainThread
}
}
public int MultiSampleMask
{
get
{
int result = 0;
ForceToMainThread(() =>
{
result = GLDevice.MultiSampleMask;
}); // End ForceToMainThread
return result;
}
set
{
ForceToMainThread(() =>
{
GLDevice.MultiSampleMask = value;
}); // End ForceToMainThread
}
}
public int ReferenceStencil
{
get
{
int result = 0;
ForceToMainThread(() =>
{
result = GLDevice.ReferenceStencil;
}); // End ForceToMainThread
return result;
}
set
{
ForceToMainThread(() =>
{
GLDevice.ReferenceStencil = value;
}); // End ForceToMainThread
}
}
public bool SupportsDxt1
{
get
{
bool result = false;
ForceToMainThread(() =>
{
result = GLDevice.SupportsDxt1;
}); // End ForceToMainThread
return result;
}
}
public bool SupportsS3tc
{
get
{
bool result = false;
ForceToMainThread(() =>
{
result = GLDevice.SupportsS3tc;
}); // End ForceToMainThread
return result;
}
}
public bool SupportsHardwareInstancing
{
get
{
bool result = false;
ForceToMainThread(() =>
{
result = GLDevice.SupportsHardwareInstancing;
}); // End ForceToMainThread
return result;
}
}
public bool SupportsNoOverwrite
{
get
{
bool result = false;
ForceToMainThread(() =>
{
result = GLDevice.SupportsNoOverwrite;
}); // End ForceToMainThread
return result;
}
}
public int MaxTextureSlots
{
get
{
int result = 0;
ForceToMainThread(() =>
{
result = GLDevice.MaxTextureSlots;
}); // End ForceToMainThread
return result;
}
}
public int MaxMultiSampleCount
{
get
{
int result = 0;
ForceToMainThread(() =>
{
result = GLDevice.MaxMultiSampleCount;
}); // End ForceToMainThread
return result;
}
}
public IGLBackbuffer Backbuffer
{
get
{
IGLBackbuffer result = null;
ForceToMainThread(() =>
{
result = GLDevice.Backbuffer;
}); // End ForceToMainThread
return result;
}
}
#endregion
#region Private Variables
private IGLDevice GLDevice;
private Thread csThread;
private bool csDone = false;
private AutoResetEvent csEvent = new AutoResetEvent(false);
private List<Action> actions = new List<Action>();
#endregion
#region Private Graphics Object Disposal Queues
private ConcurrentQueue<IGLTexture> GCTextures = new ConcurrentQueue<IGLTexture>();
private ConcurrentQueue<IGLRenderbuffer> GCRenderbuffers = new ConcurrentQueue<IGLRenderbuffer>();
private ConcurrentQueue<IGLBuffer> GCVertexBuffers = new ConcurrentQueue<IGLBuffer>();
private ConcurrentQueue<IGLBuffer> GCIndexBuffers = new ConcurrentQueue<IGLBuffer>();
private ConcurrentQueue<IGLEffect> GCEffects = new ConcurrentQueue<IGLEffect>();
private ConcurrentQueue<IGLQuery> GCQueries = new ConcurrentQueue<IGLQuery>();
#endregion
#region Thread Functions
private void csThreadProc()
{
while (!csDone)
{
csEvent.WaitOne();
lock (actions)
{
foreach (Action action in actions)
{
action();
}
actions.Clear();
}
}
GLDevice.Dispose();
}
private void ForceToMainThread(Action action)
{
ManualResetEventSlim resetEvent = new ManualResetEventSlim(false);
lock (actions)
{
actions.Add(() =>
{
action();
resetEvent.Set();
});
}
csEvent.Set();
resetEvent.Wait();
}
#endregion
#region Constructor/Disposal
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
}
public void Dispose()
{
ForceToMainThread(() =>
{
csDone = true;
}); // End ForceToMainThread
csThread.Join();
}
#endregion
#region BeginFrame Operations
public void BeginFrame()
{
ForceToMainThread(() =>
{
GLDevice.BeginFrame();
}); // End ForceToMainThread
}
#endregion
#region Backbuffer Operations
public void ResetBackbuffer(PresentationParameters presentationParameters)
{
ForceToMainThread(() =>
{
GLDevice.ResetBackbuffer(
presentationParameters
);
}); // End ForceToMainThread
}
public void SwapBuffers(
Rectangle? sourceRectangle,
Rectangle? destinationRectangle,
IntPtr overrideWindowHandle
) {
ForceToMainThread(() =>
{
GLDevice.SwapBuffers(
sourceRectangle,
destinationRectangle,
overrideWindowHandle
);
IGLTexture gcTexture;
while (GCTextures.TryDequeue(out gcTexture))
{
GLDevice.AddDisposeTexture(gcTexture);
}
IGLRenderbuffer gcRenderbuffer;
while (GCRenderbuffers.TryDequeue(out gcRenderbuffer))
{
GLDevice.AddDisposeRenderbuffer(gcRenderbuffer);
}
IGLBuffer gcBuffer;
while (GCVertexBuffers.TryDequeue(out gcBuffer))
{
GLDevice.AddDisposeVertexBuffer(gcBuffer);
}
while (GCIndexBuffers.TryDequeue(out gcBuffer))
{
GLDevice.AddDisposeIndexBuffer(gcBuffer);
}
IGLEffect gcEffect;
while (GCEffects.TryDequeue(out gcEffect))
{
GLDevice.AddDisposeEffect(gcEffect);
}
IGLQuery gcQuery;
while (GCQueries.TryDequeue(out gcQuery))
{
GLDevice.AddDisposeQuery(gcQuery);
}
}); // End ForceToMainThread
}
#endregion
#region SetStringMarkerEXT
public void SetStringMarker(string text)
{
ForceToMainThread(() =>
{
GLDevice.SetStringMarker(text);
}); // End ForceToMainThread
}
#endregion
#region Draw Calls
public void DrawIndexedPrimitives(
PrimitiveType primitiveType,
int baseVertex,
int minVertexIndex,
int numVertices,
int startIndex,
int primitiveCount,
IGLBuffer indices,
IndexElementSize indexElementSize
) {
ForceToMainThread(() =>
{
GLDevice.DrawIndexedPrimitives(
primitiveType,
baseVertex,
minVertexIndex,
numVertices,
startIndex,
primitiveCount,
indices,
indexElementSize
);
}); // End ForceToMainThread
}
public void DrawInstancedPrimitives(
PrimitiveType primitiveType,
int baseVertex,
int minVertexIndex,
int numVertices,
int startIndex,
int primitiveCount,
int instanceCount,
IGLBuffer indices,
IndexElementSize indexElementSize
) {
ForceToMainThread(() =>
{
GLDevice.DrawInstancedPrimitives(
primitiveType,
baseVertex,
minVertexIndex,
numVertices,
startIndex,
primitiveCount,
instanceCount,
indices,
indexElementSize
);
}); // End ForceToMainThread
}
public void DrawPrimitives(
PrimitiveType primitiveType,
int vertexStart,
int primitiveCount
) {
ForceToMainThread(() =>
{
GLDevice.DrawPrimitives(
primitiveType,
vertexStart,
primitiveCount
);
}); // End ForceToMainThread
}
public void DrawUserIndexedPrimitives(
PrimitiveType primitiveType,
IntPtr vertexData,
int vertexOffset,
int numVertices,
IntPtr indexData,
int indexOffset,
IndexElementSize indexElementSize,
int primitiveCount
) {
ForceToMainThread(() =>
{
GLDevice.DrawUserIndexedPrimitives(
primitiveType,
vertexData,
vertexOffset,
numVertices,
indexData,
indexOffset,
indexElementSize,
primitiveCount
);
}); // End ForceToMainThread
}
public void DrawUserPrimitives(
PrimitiveType primitiveType,
IntPtr vertexData,
int vertexOffset,
int primitiveCount
) {
ForceToMainThread(() =>
{
GLDevice.DrawUserPrimitives(
primitiveType,
vertexData,
vertexOffset,
primitiveCount
);
}); // End ForceToMainThread
}
#endregion
#region Render States
public void SetPresentationInterval(PresentInterval presentInterval)
{
ForceToMainThread(() =>
{
GLDevice.SetPresentationInterval(presentInterval);
}); // End ForceToMainThread
}
public void SetViewport(Viewport vp)
{
ForceToMainThread(() =>
{
GLDevice.SetViewport(vp);
}); // End ForceToMainThread
}
public void SetScissorRect(Rectangle scissorRect)
{
ForceToMainThread(() =>
{
GLDevice.SetScissorRect(scissorRect);
}); // End ForceToMainThread
}
public void SetBlendState(BlendState blendState)
{
ForceToMainThread(() =>
{
GLDevice.SetBlendState(blendState);
}); // End ForceToMainThread
}
public void SetDepthStencilState(DepthStencilState depthStencilState)
{
ForceToMainThread(() =>
{
GLDevice.SetDepthStencilState(
depthStencilState
);
}); // End ForceToMainThread
}
public void ApplyRasterizerState(RasterizerState rasterizerState)
{
ForceToMainThread(() =>
{
GLDevice.ApplyRasterizerState(rasterizerState);
}); // End ForceToMainThread
}
public void VerifySampler(
int index,
Texture texture,
SamplerState sampler
) {
ForceToMainThread(() =>
{
GLDevice.VerifySampler(index, texture, sampler);
}); // End ForceToMainThread
}
#endregion
#region Target Reads/Writes
public void Clear(
ClearOptions options,
Vector4 color,
float depth,
int stencil
) {
ForceToMainThread(() =>
{
GLDevice.Clear(options, color, depth, stencil);
}); // End ForceToMainThread
}
public void SetRenderTargets(
RenderTargetBinding[] renderTargets,
IGLRenderbuffer renderbuffer,
DepthFormat depthFormat
) {
ForceToMainThread(() =>
{
GLDevice.SetRenderTargets(
renderTargets,
renderbuffer,
depthFormat
);
}); // End ForceToMainThread
}
public void ResolveTarget(RenderTargetBinding target)
{
ForceToMainThread(() =>
{
GLDevice.ResolveTarget(target);
}); // End ForceToMainThread
}
public void ReadBackbuffer(
IntPtr data,
int dataLen,
int startIndex,
int elementCount,
int elementSizeInBytes,
int subX,
int subY,
int subW,
int subH
) {
ForceToMainThread(() =>
{
GLDevice.ReadBackbuffer(
data,
dataLen,
startIndex,
elementCount,
elementSizeInBytes,
subX,
subY,
subW,
subH
);
}); // End ForceToMainThread
}
#endregion
#region Textures
public IGLTexture CreateTexture2D(
SurfaceFormat format,
int width,
int height,
int levelCount,
bool isRenderTarget
) {
IGLTexture result = null;
ForceToMainThread(() =>
{
result = GLDevice.CreateTexture2D(
format,
width,
height,
levelCount,
isRenderTarget
);
}); // End ForceToMainThread
return result;
}
public IGLTexture CreateTexture3D(
SurfaceFormat format,
int width,
int height,
int depth,
int levelCount
) {
IGLTexture result = null;
ForceToMainThread(() =>
{
result = GLDevice.CreateTexture3D(
format,
width,
height,
depth,
levelCount
);
}); // End ForceToMainThread
return result;
}
public IGLTexture CreateTextureCube(
SurfaceFormat format,
int size,
int levelCount,
bool isRenderTarget
) {
IGLTexture result = null;
ForceToMainThread(() =>
{
result = GLDevice.CreateTextureCube(
format,
size,
levelCount,
isRenderTarget
);
}); // End ForceToMainThread
return result;
}
public void AddDisposeTexture(IGLTexture texture)
{
GCTextures.Enqueue(texture);
}
public void SetTextureData2D(
IGLTexture texture,
SurfaceFormat format,
int x,
int y,
int w,
int h,
int level,
IntPtr data,
int dataLength
) {
ForceToMainThread(() =>
{
GLDevice.SetTextureData2D(
texture,
format,
x,
y,
w,
h,
level,
data,
dataLength
);
}); // End ForceToMainThread
}
public void SetTextureData3D(
IGLTexture texture,
SurfaceFormat format,
int level,
int left,
int top,
int right,
int bottom,
int front,
int back,
IntPtr data,
int dataLength
) {
ForceToMainThread(() =>
{
GLDevice.SetTextureData3D(
texture,
format,
level,
left,
top,
right,
bottom,
front,
back,
data,
dataLength
);
}); // End ForceToMainThread
}
public void SetTextureDataCube(
IGLTexture texture,
SurfaceFormat format,
int xOffset,
int yOffset,
int width,
int height,
CubeMapFace cubeMapFace,
int level,
IntPtr data,
int dataLength
) {
ForceToMainThread(() =>
{
GLDevice.SetTextureDataCube(
texture,
format,
xOffset,
yOffset,
width,
height,
cubeMapFace,
level,
data,
dataLength
);
}); // End ForceToMainThread
}
public void SetTextureDataYUV(Texture2D[] textures, IntPtr ptr)
{
ForceToMainThread(() =>
{
GLDevice.SetTextureDataYUV(textures, ptr);
}); // End ForceToMainThread
}
public void GetTextureData2D(
IGLTexture texture,
SurfaceFormat format,
int width,
int height,
int level,
int subX,
int subY,
int subW,
int subH,
IntPtr data,
int startIndex,
int elementCount,
int elementSizeInBytes
) {
ForceToMainThread(() =>
{
GLDevice.GetTextureData2D(
texture,
format,
width,
height,
level,
subX,
subY,
subW,
subH,
data,
startIndex,
elementCount,
elementSizeInBytes
);
}); // End ForceToMainThread
}
public void GetTextureData3D(
IGLTexture texture,
SurfaceFormat format,
int left,
int top,
int front,
int right,
int bottom,
int back,
int level,
IntPtr data,
int startIndex,
int elementCount,
int elementSizeInBytes
) {
ForceToMainThread(() =>
{
GLDevice.GetTextureData3D(
texture,
format,
left,
top,
front,
right,
bottom,
back,
level,
data,
startIndex,
elementCount,
elementSizeInBytes
);
}); // End ForceToMainThread
}
public void GetTextureDataCube(
IGLTexture texture,
SurfaceFormat format,
int size,
CubeMapFace cubeMapFace,
int level,
int subX,
int subY,
int subW,
int subH,
IntPtr data,
int startIndex,
int elementCount,
int elementSizeInBytes
) {
ForceToMainThread(() =>
{
GLDevice.GetTextureDataCube(
texture,
format,
size,
cubeMapFace,
level,
subX,
subY,
subW,
subH,
data,
startIndex,
elementCount,
elementSizeInBytes
);
}); // End ForceToMainThread
}
#endregion
#region Renderbuffers
public IGLRenderbuffer GenRenderbuffer(
int width,
int height,
SurfaceFormat format,
int multiSampleCount,
IGLTexture texture
) {
IGLRenderbuffer result = null;
ForceToMainThread(() =>
{
result = GLDevice.GenRenderbuffer(
width,
height,
format,
multiSampleCount,
texture
);
}); // End ForceToMainThread
return result;
}
public IGLRenderbuffer GenRenderbuffer(
int width,
int height,
DepthFormat format,
int multiSampleCount
) {
IGLRenderbuffer result = null;
ForceToMainThread(() =>
{
result = GLDevice.GenRenderbuffer(
width,
height,
format,
multiSampleCount
);
}); // End ForceToMainThread
return result;
}
public void AddDisposeRenderbuffer(IGLRenderbuffer renderbuffer)
{
GCRenderbuffers.Enqueue(renderbuffer);
}
#endregion
#region Vertex/Index Buffers
public IGLBuffer GenVertexBuffer(
bool dynamic,
BufferUsage usage,
int vertexCount,
int vertexStride
) {
IGLBuffer result = null;
ForceToMainThread(() =>
{
result = GLDevice.GenVertexBuffer(
dynamic,
usage,
vertexCount,
vertexStride
);
}); // End ForceToMainThread
return result;
}
public void AddDisposeVertexBuffer(IGLBuffer buffer)
{
GCVertexBuffers.Enqueue(buffer);
}
public void SetVertexBufferData(
IGLBuffer buffer,
int offsetInBytes,
IntPtr data,
int dataLength,
SetDataOptions options
) {
ForceToMainThread(() =>
{
GLDevice.SetVertexBufferData(
buffer,
offsetInBytes,
data,
dataLength,
options
);
}); // End ForceToMainThread
}
public void GetVertexBufferData(
IGLBuffer buffer,
int offsetInBytes,
IntPtr data,
int startIndex,
int elementCount,
int elementSizeInBytes,
int vertexStride
) {
ForceToMainThread(() =>
{
GLDevice.GetVertexBufferData(
buffer,
offsetInBytes,
data,
startIndex,
elementCount,
elementSizeInBytes,
vertexStride
);
}); // End ForceToMainThread
}
public IGLBuffer GenIndexBuffer(
bool dynamic,
BufferUsage usage,
int indexCount,
IndexElementSize indexElementSize
) {
IGLBuffer result = null;
ForceToMainThread(() =>
{
result = GLDevice.GenIndexBuffer(
dynamic,
usage,
indexCount,
indexElementSize
);
}); // End ForceToMainThread
return result;
}
public void AddDisposeIndexBuffer(IGLBuffer buffer)
{
GCIndexBuffers.Enqueue(buffer);
}
public void SetIndexBufferData(
IGLBuffer buffer,
int offsetInBytes,
IntPtr data,
int dataLength,
SetDataOptions options
) {
ForceToMainThread(() =>
{
GLDevice.SetIndexBufferData(
buffer,
offsetInBytes,
data,
dataLength,
options
);
}); // End ForceToMainThread
}
public void GetIndexBufferData(
IGLBuffer buffer,
int offsetInBytes,
IntPtr data,
int startIndex,
int elementCount,
int elementSizeInBytes
) {
ForceToMainThread(() =>
{
GLDevice.GetIndexBufferData(
buffer,
offsetInBytes,
data,
startIndex,
elementCount,
elementSizeInBytes
);
}); // End ForceToMainThread
}
#endregion
#region Effects
public IGLEffect CreateEffect(byte[] effectCode)
{
IGLEffect result = null;
ForceToMainThread(() =>
{
result = GLDevice.CreateEffect(effectCode);
}); // End ForceToMainThread
return result;
}
public IGLEffect CloneEffect(IGLEffect effect)
{
IGLEffect result = null;
ForceToMainThread(() =>
{
result = GLDevice.CloneEffect(effect);
}); // End ForceToMainThread
return result;
}
public void AddDisposeEffect(IGLEffect effect)
{
GCEffects.Enqueue(effect);
}
public void ApplyEffect(
IGLEffect effect,
IntPtr technique,
uint pass,
IntPtr stateChanges
) {
ForceToMainThread(() =>
{
GLDevice.ApplyEffect(
effect,
technique,
pass,
stateChanges
);
}); // End ForceToMainThread
}
public void BeginPassRestore(IGLEffect effect, IntPtr stateChanges)
{
ForceToMainThread(() =>
{
GLDevice.BeginPassRestore(effect, stateChanges);
}); // End ForceToMainThread
}
public void EndPassRestore(IGLEffect effect)
{
ForceToMainThread(() =>
{
GLDevice.EndPassRestore(effect);
}); // End ForceToMainThread
}
#endregion
#region Vertex Attributes
public void ApplyVertexAttributes(
VertexBufferBinding[] bindings,
int numBindings,
bool bindingsUpdated,
int baseVertex
) {
ForceToMainThread(() =>
{
GLDevice.ApplyVertexAttributes(
bindings,
numBindings,
bindingsUpdated,
baseVertex
);
}); // End ForceToMainThread
}
public void ApplyVertexAttributes(
VertexDeclaration vertexDeclaration,
IntPtr ptr,
int vertexOffset
) {
ForceToMainThread(() =>
{
GLDevice.ApplyVertexAttributes(
vertexDeclaration,
ptr,
vertexOffset
);
}); // End ForceToMainThread
}
#endregion
#region Queries
public IGLQuery CreateQuery()
{
IGLQuery result = null;
ForceToMainThread(() =>
{
result = GLDevice.CreateQuery();
}); // End ForceToMainThread
return result;
}
public void AddDisposeQuery(IGLQuery query)
{
GCQueries.Enqueue(query);
}
public void QueryBegin(IGLQuery query)
{
ForceToMainThread(() =>
{
GLDevice.QueryBegin(query);
}); // End ForceToMainThread
}
public void QueryEnd(IGLQuery query)
{
ForceToMainThread(() =>
{
GLDevice.QueryEnd(query);
}); // End ForceToMainThread
}
public bool QueryComplete(IGLQuery query)
{
bool result = false;
ForceToMainThread(() =>
{
result = GLDevice.QueryComplete(query);
}); // End ForceToMainThread
return result;
}
public int QueryPixelCount(IGLQuery query)
{
int result = 0;
ForceToMainThread(() =>
{
result = GLDevice.QueryPixelCount(query);
}); // End ForceToMainThread
return result;
}
#endregion
}
}