void FinalizeInner()
{
GL.Ext.DeleteFramebuffers(1, ref framebuffer);
ErrorHandler.CheckGlError();
GL.Ext.DeleteRenderbuffers(1, ref depth);
ErrorHandler.CheckGlError();
}
public void Clear()
{
GL.ClearColor(0, 0, 0, 0);
ErrorHandler.CheckGlError();
GL.Clear(ClearBufferMask.ColorBufferBit);
ErrorHandler.CheckGlError();
}
public void Clear()
{
Gl.glClearColor(0, 0, 0, 0);
ErrorHandler.CheckGlError();
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
ErrorHandler.CheckGlError();
}
public void EnableDepthBuffer()
{
Gl.glClear(Gl.GL_DEPTH_BUFFER_BIT);
ErrorHandler.CheckGlError();
Gl.glEnable(Gl.GL_DEPTH_TEST);
ErrorHandler.CheckGlError();
}
public void SetData(Bitmap bitmap)
{
var allocatedBitmap = false;
if (!Exts.IsPowerOf2(bitmap.Width) || !Exts.IsPowerOf2(bitmap.Height))
{
bitmap = new Bitmap(bitmap, bitmap.Size.NextPowerOf2());
allocatedBitmap = true;
}
try
{
size = new Size(bitmap.Width, bitmap.Height);
var bits = bitmap.LockBits(bitmap.Bounds(),
ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
PrepareTexture();
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba8, bits.Width, bits.Height,
0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, bits.Scan0); // TODO: weird strides
ErrorHandler.CheckGlError();
bitmap.UnlockBits(bits);
}
finally
{
if (allocatedBitmap)
{
bitmap.Dispose();
}
}
}
public void EnableDepthBuffer()
{
GL.Clear(ClearBufferMask.DepthBufferBit);
ErrorHandler.CheckGlError();
GL.Enable(EnableCap.DepthTest);
ErrorHandler.CheckGlError();
}
public void SetData(T[] data, int length)
{
Bind();
GL.BufferSubData(BufferTarget.ArrayBuffer,
IntPtr.Zero,
new IntPtr(VertexSize * length),
data);
ErrorHandler.CheckGlError();
}
public void Bind()
{
GL.BindBuffer(BufferTarget.ArrayBuffer, buffer);
ErrorHandler.CheckGlError();
GL.VertexPointer(3, VertexPointerType.Float, VertexSize, IntPtr.Zero);
ErrorHandler.CheckGlError();
GL.TexCoordPointer(4, TexCoordPointerType.Float, VertexSize, new IntPtr(12));
ErrorHandler.CheckGlError();
}
public void Unbind()
{
GL.Flush();
ErrorHandler.CheckGlError();
GL.Ext.BindFramebuffer(FramebufferTarget.FramebufferExt, 0);
ErrorHandler.CheckGlError();
GL.Viewport(cv[0], cv[1], cv[2], cv[3]);
ErrorHandler.CheckGlError();
}
public void SetData(IntPtr data, int start, int length)
{
Bind();
GL.BufferSubData(BufferTarget.ArrayBuffer,
new IntPtr(VertexSize * start),
new IntPtr(VertexSize * length),
data);
ErrorHandler.CheckGlError();
}
public void SetVec(string name, float x, float y)
{
GL.UseProgram(program);
ErrorHandler.CheckGlError();
var param = GL.GetUniformLocation(program, name);
ErrorHandler.CheckGlError();
GL.Uniform2(param, x, y);
ErrorHandler.CheckGlError();
}
public VertexBuffer(int size)
{
GL.GenBuffers(1, out buffer);
ErrorHandler.CheckGlError();
Bind();
GL.BufferData(BufferTarget.ArrayBuffer,
new IntPtr(VertexSize * size),
new T[size],
BufferUsageHint.DynamicDraw);
ErrorHandler.CheckGlError();
}
public void SetBlendMode(BlendMode mode)
{
GL.BlendEquation(BlendEquationMode.FuncAdd);
ErrorHandler.CheckGlError();
switch (mode)
{
case BlendMode.None:
GL.Disable(EnableCap.Blend);
break;
case BlendMode.Alpha:
GL.Enable(EnableCap.Blend);
ErrorHandler.CheckGlError();
GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.OneMinusSrcAlpha);
break;
case BlendMode.Additive:
case BlendMode.Subtractive:
GL.Enable(EnableCap.Blend);
ErrorHandler.CheckGlError();
GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One);
if (mode == BlendMode.Subtractive)
{
ErrorHandler.CheckGlError();
GL.BlendEquation(BlendEquationMode.FuncReverseSubtract);
}
break;
case BlendMode.Multiply:
GL.Enable(EnableCap.Blend);
ErrorHandler.CheckGlError();
GL.BlendFunc(BlendingFactorSrc.DstColor, BlendingFactorDest.OneMinusSrcAlpha);
ErrorHandler.CheckGlError();
break;
case BlendMode.Multiplicative:
GL.Enable(EnableCap.Blend);
ErrorHandler.CheckGlError();
GL.BlendFunc(BlendingFactorSrc.Zero, BlendingFactorDest.SrcColor);
break;
case BlendMode.DoubleMultiplicative:
GL.Enable(EnableCap.Blend);
ErrorHandler.CheckGlError();
GL.BlendFunc(BlendingFactorSrc.DstColor, BlendingFactorDest.SrcColor);
break;
}
ErrorHandler.CheckGlError();
}
public void SetEmpty(int width, int height)
{
if (!Exts.IsPowerOf2(width) || !Exts.IsPowerOf2(height))
{
throw new InvalidDataException("Non-power-of-two array {0}x{1}".F(width, height));
}
size = new Size(width, height);
PrepareTexture();
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba8, width, height,
0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, IntPtr.Zero);
ErrorHandler.CheckGlError();
}
static int[] ViewportRectangle()
{
var v = new int[4];
unsafe
{
fixed(int *ptr = &v[0])
GL.GetInteger(GetPName.Viewport, ptr);
}
ErrorHandler.CheckGlError();
return(v);
}
public void SetMatrix(string name, float[] mtx)
{
if (mtx.Length != 16)
{
throw new InvalidDataException("Invalid 4x4 matrix");
}
GL.UseProgram(program);
ErrorHandler.CheckGlError();
var param = GL.GetUniformLocation(program, name);
ErrorHandler.CheckGlError();
GL.UniformMatrix4(param, 1, false, mtx);
ErrorHandler.CheckGlError();
}
public void Render(Action a)
{
GL.UseProgram(program);
// bind the textures
foreach (var kv in textures)
{
GL.ActiveTexture(TextureUnit.Texture0 + kv.Key);
GL.BindTexture(TextureTarget.Texture2D, ((Texture)kv.Value).ID);
}
ErrorHandler.CheckGlError();
a();
ErrorHandler.CheckGlError();
}
public void Bind()
{
// Cache viewport rect to restore when unbinding
cv = ViewportRectangle();
GL.Flush();
ErrorHandler.CheckGlError();
GL.Ext.BindFramebuffer(FramebufferTarget.FramebufferExt, framebuffer);
ErrorHandler.CheckGlError();
GL.Viewport(0, 0, size.Width, size.Height);
ErrorHandler.CheckGlError();
GL.ClearColor(0, 0, 0, 0);
ErrorHandler.CheckGlError();
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
ErrorHandler.CheckGlError();
}
void Dispose(bool disposing)
{
if (disposed)
{
return;
}
disposed = true;
if (disposing)
{
texture.Dispose();
}
GL.Ext.DeleteFramebuffers(1, ref framebuffer);
ErrorHandler.CheckGlError();
GL.Ext.DeleteRenderbuffers(1, ref depth);
ErrorHandler.CheckGlError();
}
public FrameBuffer(Size size)
{
this.size = size;
if (!Exts.IsPowerOf2(size.Width) || !Exts.IsPowerOf2(size.Height))
{
throw new InvalidDataException("Frame buffer size ({0}x{1}) must be a power of two".F(size.Width, size.Height));
}
GL.Ext.GenFramebuffers(1, out framebuffer);
ErrorHandler.CheckGlError();
GL.Ext.BindFramebuffer(FramebufferTarget.FramebufferExt, framebuffer);
ErrorHandler.CheckGlError();
// Color
texture = new Texture();
texture.SetEmpty(size.Width, size.Height);
GL.Ext.FramebufferTexture2D(FramebufferTarget.FramebufferExt, FramebufferAttachment.ColorAttachment0Ext, TextureTarget.Texture2D, texture.ID, 0);
ErrorHandler.CheckGlError();
// Depth
GL.Ext.GenRenderbuffers(1, out depth);
ErrorHandler.CheckGlError();
GL.Ext.BindRenderbuffer(RenderbufferTarget.RenderbufferExt, depth);
ErrorHandler.CheckGlError();
GL.Ext.RenderbufferStorage(RenderbufferTarget.RenderbufferExt, RenderbufferStorage.DepthComponent, size.Width, size.Height);
ErrorHandler.CheckGlError();
GL.Ext.FramebufferRenderbuffer(FramebufferTarget.FramebufferExt, FramebufferAttachment.DepthAttachmentExt, RenderbufferTarget.RenderbufferExt, depth);
ErrorHandler.CheckGlError();
// Test for completeness
var status = GL.Ext.CheckFramebufferStatus(FramebufferTarget.FramebufferExt);
if (status != FramebufferErrorCode.FramebufferCompleteExt)
{
var error = "Error creating framebuffer: {0}\n{1}".F(status, new StackTrace());
ErrorHandler.WriteGraphicsLog(error);
throw new InvalidOperationException("OpenGL Error: See graphics.log for details.");
}
// Restore default buffer
GL.Ext.BindFramebuffer(FramebufferTarget.FramebufferExt, 0);
ErrorHandler.CheckGlError();
}
public void EnableScissor(int left, int top, int width, int height)
{
if (width < 0)
{
width = 0;
}
if (height < 0)
{
height = 0;
}
Gl.glScissor(left, size.Height - (top + height), width, height);
ErrorHandler.CheckGlError();
Gl.glEnable(Gl.GL_SCISSOR_TEST);
ErrorHandler.CheckGlError();
}
public void EnableScissor(int left, int top, int width, int height)
{
if (width < 0)
{
width = 0;
}
if (height < 0)
{
height = 0;
}
GL.Scissor(left, size.Height - (top + height), width, height);
ErrorHandler.CheckGlError();
GL.Enable(EnableCap.ScissorTest);
ErrorHandler.CheckGlError();
}
public byte[] GetData()
{
var data = new byte[4 * size.Width * size.Height];
ErrorHandler.CheckGlError();
GL.BindTexture(TextureTarget.Texture2D, texture);
unsafe
{
fixed(byte *ptr = &data[0])
{
var intPtr = new IntPtr((void *)ptr);
GL.GetTexImage(TextureTarget.Texture2D, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, intPtr);
}
}
ErrorHandler.CheckGlError();
return(data);
}
public void SetVec(string name, float[] vec, int length)
{
var param = GL.GetUniformLocation(program, name);
ErrorHandler.CheckGlError();
switch (length)
{
case 1: GL.Uniform1(param, 1, vec); break;
case 2: GL.Uniform2(param, 1, vec); break;
case 3: GL.Uniform3(param, 1, vec); break;
case 4: GL.Uniform4(param, 1, vec); break;
default: throw new InvalidDataException("Invalid vector length");
}
ErrorHandler.CheckGlError();
}
void PrepareTexture()
{
ErrorHandler.CheckGlError();
GL.BindTexture(TextureTarget.Texture2D, texture);
ErrorHandler.CheckGlError();
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMinFilter.Nearest);
ErrorHandler.CheckGlError();
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest);
ErrorHandler.CheckGlError();
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (float)TextureWrapMode.ClampToEdge);
ErrorHandler.CheckGlError();
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (float)TextureWrapMode.ClampToEdge);
ErrorHandler.CheckGlError();
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureBaseLevel, 0);
ErrorHandler.CheckGlError();
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMaxLevel, 0);
ErrorHandler.CheckGlError();
}
public void SetBlendMode(BlendMode mode)
{
Gl.glBlendEquation(Gl.GL_FUNC_ADD);
ErrorHandler.CheckGlError();
switch (mode)
{
case BlendMode.None:
Gl.glDisable(Gl.GL_BLEND);
break;
case BlendMode.Alpha:
Gl.glEnable(Gl.GL_BLEND);
ErrorHandler.CheckGlError();
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
break;
case BlendMode.Additive:
Gl.glEnable(Gl.GL_BLEND);
ErrorHandler.CheckGlError();
Gl.glBlendFunc(Gl.GL_ONE, Gl.GL_ONE);
break;
case BlendMode.Subtractive:
Gl.glEnable(Gl.GL_BLEND);
ErrorHandler.CheckGlError();
Gl.glBlendFunc(Gl.GL_ONE, Gl.GL_ONE);
ErrorHandler.CheckGlError();
Gl.glBlendEquation(Gl.GL_FUNC_REVERSE_SUBTRACT);
break;
case BlendMode.Multiply:
Gl.glEnable(Gl.GL_BLEND);
ErrorHandler.CheckGlError();
Gl.glBlendFuncSeparate(Gl.GL_DST_COLOR, Gl.GL_ZERO, Gl.GL_ONE, Gl.GL_ONE_MINUS_SRC_ALPHA);
ErrorHandler.CheckGlError();
break;
}
ErrorHandler.CheckGlError();
}
public void SetData(byte[] colors, int width, int height)
{
if (!Exts.IsPowerOf2(width) || !Exts.IsPowerOf2(height))
{
throw new InvalidDataException("Non-power-of-two array {0}x{1}".F(width, height));
}
size = new Size(width, height);
unsafe
{
fixed(byte *ptr = &colors[0])
{
var intPtr = new IntPtr((void *)ptr);
PrepareTexture();
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba8, width, height,
0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, intPtr);
ErrorHandler.CheckGlError();
}
}
}
protected int CompileShaderObject(ShaderType type, string name)
{
string ext = type == ShaderType.VertexShader ? "vert" : "frag";
string filename = "glsl{0}{1}.{2}".F(Path.DirectorySeparatorChar, name, ext);
string code;
using (var file = new StreamReader(GlobalFileSystem.Open(filename)))
code = file.ReadToEnd();
var shader = GL.CreateShader(type);
ErrorHandler.CheckGlError();
GL.ShaderSource(shader, code);
ErrorHandler.CheckGlError();
GL.CompileShader(shader);
ErrorHandler.CheckGlError();
int success;
GL.GetShader(shader, ShaderParameter.CompileStatus, out success);
ErrorHandler.CheckGlError();
if (success == (int)All.False)
{
int len;
GL.GetShader(shader, ShaderParameter.InfoLogLength, out len);
var log = new StringBuilder(len);
unsafe
{
GL.GetShaderInfoLog(shader, len, null, log);
}
Log.Write("graphics", "GL Info Log:\n{0}", log.ToString());
throw new InvalidProgramException("Compile error in shader object '{0}'".F(filename));
}
return(shader);
}
public Texture()
{
GL.GenTextures(1, out texture);
ErrorHandler.CheckGlError();
}
public Texture(Bitmap bitmap)
{
GL.GenTextures(1, out texture);
ErrorHandler.CheckGlError();
SetData(bitmap);
}