void IGraphicsBackend.GetOutputPixelData(IntPtr buffer, ColorDataLayout dataLayout, ColorDataElementType dataElementType, int x, int y, int width, int height)
{
//DefaultOpenTKBackendPlugin.GuardSingleThreadState();
NativeRenderTarget lastRt = NativeRenderTarget.BoundRT;
NativeRenderTarget.Bind(null);
{
// Use a temporary local buffer, since the image will be upside-down because
// of OpenGL's coordinate system and we'll need to flip it before returning.
byte[] byteData = new byte[width * height * 4];
// Retrieve pixel data
GL.ReadPixels(x, y, width, height, dataLayout.ToOpenTK(), dataElementType.ToOpenTK(), byteData);
// Flip the retrieved image vertically
int bytesPerLine = width * 4;
byte[] switchLine = new byte[width * 4];
for (int flipY = 0; flipY < height / 2; flipY++)
{
int lineIndex = flipY * width * 4;
int lineIndex2 = (height - 1 - flipY) * width * 4;
// Copy the current line to the switch buffer
for (int lineX = 0; lineX < bytesPerLine; lineX++)
{
switchLine[lineX] = byteData[lineIndex + lineX];
}
// Copy the opposite line to the current line
for (int lineX = 0; lineX < bytesPerLine; lineX++)
{
byteData[lineIndex + lineX] = byteData[lineIndex2 + lineX];
}
// Copy the switch buffer to the opposite line
for (int lineX = 0; lineX < bytesPerLine; lineX++)
{
byteData[lineIndex2 + lineX] = switchLine[lineX];
}
}
// Copy the flipped data to the output buffer
Marshal.Copy(byteData, 0, buffer, width * height * 4);
}
NativeRenderTarget.Bind(lastRt);
}
private static void ApplyGLBind(NativeRenderTarget target)
{
if (target == null)
{
GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
GL.ReadBuffer(ReadBufferMode.Back);
DrawBufferMode mode = DrawBufferMode.Back;
GL.DrawBuffers(1, ref mode);
}
else
{
GL.BindFramebuffer(FramebufferTarget.Framebuffer, target.samples > 0 ? target.handleMsaaFBO : target.handleMainFBO);
DrawBufferMode[] buffers = new DrawBufferMode[target.targetInfos.Count];
for (int i = 0; i < buffers.Length; i++)
{
buffers[i] = (DrawBufferMode)((int)DrawBufferMode.ColorAttachment0 + i);
}
GL.DrawBuffers(buffers.Length, buffers);
}
}
void IGraphicsBackend.GetOutputPixelData <T>(T[] buffer, ColorDataLayout dataLayout, ColorDataElementType dataElementType, int x, int y, int width, int height)
{
// Removed thread guards because of performance
//DefaultOpenTKBackendPlugin.GuardSingleThreadState();
NativeRenderTarget lastRt = NativeRenderTarget.BoundRT;
NativeRenderTarget.Bind(null);
{
GL.ReadPixels(x, y, width, height, dataLayout.ToOpenTK(), dataElementType.ToOpenTK(), buffer);
// The image will be upside-down because of OpenGL's coordinate system. Flip it.
int structSize = Marshal.SizeOf(typeof(T));
T[] switchLine = new T[width * 4 / structSize];
for (int flipY = 0; flipY < height / 2; flipY++)
{
int lineIndex = flipY * width * 4 / structSize;
int lineIndex2 = (height - 1 - flipY) * width * 4 / structSize;
// Copy the current line to the switch buffer
for (int lineX = 0; lineX < width; lineX++)
{
switchLine[lineX] = buffer[lineIndex + lineX];
}
// Copy the opposite line to the current line
for (int lineX = 0; lineX < width; lineX++)
{
buffer[lineIndex + lineX] = buffer[lineIndex2 + lineX];
}
// Copy the switch buffer to the opposite line
for (int lineX = 0; lineX < width; lineX++)
{
buffer[lineIndex2 + lineX] = switchLine[lineX];
}
}
}
NativeRenderTarget.Bind(lastRt);
}
public static void Bind(NativeRenderTarget nextBound)
{
if (curBound == nextBound)
{
return;
}
// When binding a different target, execute pending post-render steps for the previous one
if (curBound != null && curBound != nextBound)
{
curBound.ApplyPostRender();
}
// Bind new RenderTarget
ApplyGLBind(nextBound);
// Update binding info
curBound = nextBound;
if (curBound != null)
{
curBound.pendingPostRender = true;
}
}
void IGraphicsBackend.BeginRendering(IDrawDevice device, VertexBatchStore vertexData, RenderOptions options, RenderStats stats)
{
DebugCheckOpenGLErrors();
// ToDo: AA is disabled for now
//this.CheckContextCaps();
this.currentDevice = device;
this.renderOptions = options;
this.renderStats = stats;
// Upload all vertex data that we'll need during rendering
if (vertexData != null)
{
this.perVertexTypeVBO.Count = Math.Max(this.perVertexTypeVBO.Count, vertexData.Batches.Count);
for (int typeIndex = 0; typeIndex < vertexData.Batches.Count; typeIndex++)
{
// Filter out unused vertex types
IVertexBatch vertexBatch = vertexData.Batches[typeIndex];
if (vertexBatch == null)
{
continue;
}
if (vertexBatch.Count == 0)
{
continue;
}
// Generate a VBO for this vertex type if it didn't exist yet
if (this.perVertexTypeVBO[typeIndex] == 0)
{
GL.GenBuffers(1, out this.perVertexTypeVBO.Data[typeIndex]);
}
GL.BindBuffer(BufferTarget.ArrayBuffer, this.perVertexTypeVBO[typeIndex]);
// Upload all data of this vertex type as a single block
int vertexDataLength = vertexBatch.Declaration.Size * vertexBatch.Count;
using (PinnedArrayHandle pinned = vertexBatch.Lock()) {
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)vertexDataLength, IntPtr.Zero, BufferUsage.StreamDraw);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)vertexDataLength, pinned.Address, BufferUsage.StreamDraw);
}
}
}
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
// Prepare the target surface for rendering
NativeRenderTarget.Bind(options.Target as NativeRenderTarget);
// Determine the available size on the active rendering surface
//Point2 availableSize;
//if (NativeRenderTarget.BoundRT != null) {
// availableSize = new Point2(NativeRenderTarget.BoundRT.Width, NativeRenderTarget.BoundRT.Height);
//} else {
// availableSize = this.externalBackbufferSize;
//}
Rect openGLViewport = options.Viewport;
// Setup viewport and scissor rects
GL.Viewport((int)openGLViewport.X, (int)openGLViewport.Y, (int)MathF.Ceiling(openGLViewport.W), (int)MathF.Ceiling(openGLViewport.H));
GL.Scissor((int)openGLViewport.X, (int)openGLViewport.Y, (int)MathF.Ceiling(openGLViewport.W), (int)MathF.Ceiling(openGLViewport.H));
// Clear buffers
ClearBufferMask glClearMask = 0;
ColorRgba clearColor = options.ClearColor;
if ((options.ClearFlags & ClearFlag.Color) != ClearFlag.None)
{
glClearMask |= ClearBufferMask.ColorBufferBit;
}
if ((options.ClearFlags & ClearFlag.Depth) != ClearFlag.None)
{
glClearMask |= ClearBufferMask.DepthBufferBit;
}
GL.ClearColor(clearColor.R / 255.0f, clearColor.G / 255.0f, clearColor.B / 255.0f, clearColor.A / 255.0f);
GL.ClearDepth(options.ClearDepth);
GL.Clear(glClearMask);
// Configure Rendering params
if (options.RenderMode == RenderMatrix.ScreenSpace)
{
GL.Enable(EnableCap.ScissorTest);
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(DepthFunction.Always);
}
else
{
GL.Enable(EnableCap.ScissorTest);
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(DepthFunction.Lequal);
}
Matrix4 modelView = options.ModelViewMatrix;
Matrix4 projection = options.ProjectionMatrix;
if (NativeRenderTarget.BoundRT != null)
{
modelView = Matrix4.CreateScale(new Vector3(1f, -1f, 1f)) * modelView;
if (options.RenderMode == RenderMatrix.ScreenSpace)
{
modelView = Matrix4.CreateTranslation(new Vector3(0f, -device.TargetSize.Y, 0f)) * modelView;
}
}
// Convert matrices to float arrays
GetArrayMatrix(ref modelView, ref modelViewData);
GetArrayMatrix(ref projection, ref projectionData);
// All EBOs can be used again
lastUsedEBO = 0;
}
void IGraphicsBackend.BeginRendering(IDrawDevice device, RenderOptions options, RenderStats stats)
{
DebugCheckOpenGLErrors();
// ToDo: AA is disabled for now
//this.CheckContextCaps();
this.currentDevice = device;
this.renderOptions = options;
this.renderStats = stats;
// Prepare the target surface for rendering
NativeRenderTarget.Bind(options.Target as NativeRenderTarget);
// Determine the available size on the active rendering surface
//Point2 availableSize;
//if (NativeRenderTarget.BoundRT != null) {
// availableSize = new Point2(NativeRenderTarget.BoundRT.Width, NativeRenderTarget.BoundRT.Height);
//} else {
// availableSize = this.externalBackbufferSize;
//}
Rect openGLViewport = options.Viewport;
// Setup viewport and scissor rects
GL.Viewport((int)openGLViewport.X, (int)openGLViewport.Y, (int)MathF.Ceiling(openGLViewport.W), (int)MathF.Ceiling(openGLViewport.H));
GL.Scissor((int)openGLViewport.X, (int)openGLViewport.Y, (int)MathF.Ceiling(openGLViewport.W), (int)MathF.Ceiling(openGLViewport.H));
// Clear buffers
ClearBufferMask glClearMask = 0;
ColorRgba clearColor = options.ClearColor;
if ((options.ClearFlags & ClearFlag.Color) != ClearFlag.None)
{
glClearMask |= ClearBufferMask.ColorBufferBit;
}
if ((options.ClearFlags & ClearFlag.Depth) != ClearFlag.None)
{
glClearMask |= ClearBufferMask.DepthBufferBit;
}
GL.ClearColor(clearColor.R / 255.0f, clearColor.G / 255.0f, clearColor.B / 255.0f, clearColor.A / 255.0f);
GL.ClearDepth(options.ClearDepth);
GL.Clear(glClearMask);
// Configure Rendering params
GL.Enable(EnableCap.ScissorTest);
GL.Enable(EnableCap.DepthTest);
if (options.DepthTest)
{
GL.DepthFunc(DepthFunction.Lequal);
}
else
{
GL.DepthFunc(DepthFunction.Always);
}
Matrix4 view = options.ViewMatrix;
Matrix4 projection = options.ProjectionMatrix;
if (NativeRenderTarget.BoundRT != null)
{
Matrix4 flipOutput = Matrix4.CreateScale(1.0f, -1.0f, 1.0f);
projection = projection * flipOutput;
}
// Convert matrices to float arrays
GetArrayMatrix(ref view, viewData);
GetArrayMatrix(ref projection, projectionData);
// All EBOs can be used again
lastUsedEBO = 0;
}