diff --git a/PortableGL.OpenTK/OpenTKGL20.cs b/PortableGL.OpenTK/OpenTKGL20.cs new file mode 100644 index 0000000..c9b2d7d --- /dev/null +++ b/PortableGL.OpenTK/OpenTKGL20.cs @@ -0,0 +1,719 @@ +using System; +using OpenTK.Graphics.OpenGL; + +namespace PortableGL.OpenTK +{ + public class OpenTKGL20 : GL20 + { + public override void glActiveTexture(int texture) + { + GL.ActiveTexture((TextureUnit)texture); + } + + public override void glAttachShader(int program, int shader) + { + GL.AttachShader(program, shader); + } + + public override void glBindAttribLocation(int program, int index, string name) + { + GL.BindAttribLocation(program, index, name); + } + + public override void glBindBuffer(int target, int buffer) + { + GL.BindBuffer((BufferTarget)target, buffer); + } + + public override void glBindFramebuffer(int target, int framebuffer) + { + GL.BindFramebuffer((FramebufferTarget)target, framebuffer); + } + + public override void glBindRenderbuffer(int target, int renderbuffer) + { + GL.BindRenderbuffer((RenderbufferTarget)target, renderbuffer); + } + + public override void glBindTexture(int target, int texture) + { + GL.BindTexture((TextureTarget)target, texture); + } + + public override void glBlendColor(float red, float green, float blue, float alpha) + { + GL.BlendColor(red, green, blue, alpha); + } + + public override void glBlendEquation(int mode) + { + GL.BlendEquation((BlendEquationMode)mode); + } + + public override void glBlendEquationSeparate(int modeRGB, int modeAlpha) + { + GL.BlendEquationSeparate((BlendEquationMode)modeRGB, (BlendEquationMode)modeAlpha); + } + + public override void glBlendFunc(int sfactor, int dfactor) + { + GL.BlendFunc((BlendingFactorSrc)sfactor, (BlendingFactorDest)dfactor); + } + + public override void glBlendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) + { + GL.BlendFuncSeparate((BlendingFactorSrc)srcRGB, (BlendingFactorDest)dstRGB, (BlendingFactorSrc)srcAlpha, (BlendingFactorDest)dstAlpha); + } + + public override void glBufferData(int target, int size, IntPtr data, int usage) + { + GL.BufferData((BufferTarget)target, (IntPtr)size, data, (BufferUsageHint)usage); + } + + public override void glBufferSubData(int target, int offset, int size, IntPtr data) + { + GL.BufferSubData((BufferTarget)target, (IntPtr)offset, (IntPtr)size, data); + } + + public override int glCheckFramebufferStatus(int target) + { + return (int)GL.CheckFramebufferStatus((FramebufferTarget)target); + } + + public override void glClear(int mask) + { + GL.Clear((ClearBufferMask)mask); + } + + public override void glClearColor(float red, float green, float blue, float alpha) + { + GL.ClearColor(red, green, blue, alpha); + } + + public override void glClearDepthf(float depth) + { + GL.ClearDepth(depth); + } + + public override void glClearStencil(int s) + { + GL.ClearStencil(s); + } + + public override void glColorMask(bool red, bool green, bool blue, bool alpha) + { + GL.ColorMask(red, green, blue, alpha); + } + + public override void glCompileShader(int shader) + { + GL.CompileShader(shader); + } + + public override void glCompressedTexImage2D(int target, int level, int internalformat, int width, int height, int border, int imageSize, IntPtr data) + { + GL.CompressedTexImage2D((TextureTarget)target, level, (PixelInternalFormat)internalformat, width, height, border, imageSize, data); + } + + public override void glCompressedTexSubImage2D(int target, int level, int xoffset, int yoffset, int width, int height, int format, int imageSize, IntPtr data) + { + GL.CompressedTexSubImage2D((TextureTarget)target, level, xoffset, yoffset, width, height, (PixelFormat)format, imageSize, data); + } + + public override void glCopyTexImage2D(int target, int level, int internalformat, int x, int y, int width, int height, int border) + { + GL.CopyTexImage2D((TextureTarget)target, level, (PixelInternalFormat)internalformat, x, y, width, height, border); + } + + public override void glCopyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y, int width, int height) + { + GL.CopyTexSubImage2D((TextureTarget)target, level, xoffset, yoffset, x, y, width, height); + } + + public override int glCreateProgram() + { + return GL.CreateProgram(); + } + + public override int glCreateShader(int shaderType) + { + return GL.CreateShader((ShaderType)shaderType); + } + + public override void glCullFace(int mode) + { + GL.CullFace((CullFaceMode)mode); + } + + public override unsafe void glDeleteBuffers(int n, IntPtr buffers) + { + GL.DeleteBuffers(n, (int*)buffers); + } + + public override unsafe void glDeleteFramebuffers(int n, IntPtr framebuffers) + { + GL.DeleteFramebuffers(n, (int*)framebuffers); + } + + public override void glDeleteProgram(int program) + { + GL.DeleteProgram(program); + } + + public override unsafe void glDeleteRenderbuffers(int n, IntPtr renderbuffers) + { + GL.DeleteRenderbuffers(n, (int*)renderbuffers); + } + + public override void glDeleteShader(int shader) + { + GL.DeleteShader(shader); + } + + public override unsafe void glDeleteTextures(int n, IntPtr textures) + { + GL.DeleteTextures(n, (int*)textures); + } + + public override void glDepthFunc(int func) + { + GL.DepthFunc((DepthFunction)func); + } + + public override void glDepthMask(bool flag) + { + GL.DepthMask(flag); + } + + public override void glDepthRangef(float nearVal, float farVal) + { + GL.DepthRange(nearVal, farVal); + } + + public override void glDetachShader(int program, int shader) + { + GL.DetachShader(program, shader); + } + + public override void glDisable(int cap) + { + GL.Disable((EnableCap)cap); + } + + public override void glDisableVertexAttribArray(int index) + { + GL.DisableVertexAttribArray(index); + } + + public override void glDrawArrays(int mode, int first, int count) + { + GL.DrawArrays((BeginMode)mode, first, count); + } + + public override void glDrawElements(int mode, int count, int type, IntPtr indices) + { + GL.DrawElements((BeginMode)mode, count, (DrawElementsType)type, indices); + } + + public override void glEnable(int cap) + { + GL.Enable((EnableCap)cap); + } + + public override void glEnableVertexAttribArray(int index) + { + GL.EnableVertexAttribArray(index); + } + + public override void glFinish() + { + GL.Finish(); + } + + public override void glFlush() + { + GL.Flush(); + } + + public override void glFramebufferRenderbuffer(int target, int attachment, int renderbuffertarget, int renderbuffer) + { + GL.FramebufferRenderbuffer((FramebufferTarget)target, (FramebufferAttachment)attachment, (RenderbufferTarget)renderbuffertarget, renderbuffer); + } + + public override void glFramebufferTexture2D(int target, int attachment, int textarget, int texture, int level) + { + GL.FramebufferTexture2D((FramebufferTarget)target, (FramebufferAttachment)attachment, (TextureTarget)textarget, texture, level); + } + + public override void glFrontFace(int mode) + { + GL.FrontFace((FrontFaceDirection)mode); + } + + public override unsafe void glGenBuffers(int n, IntPtr buffers) + { + GL.GenBuffers(n, (int*)buffers); + } + + public override unsafe void glGenFramebuffers(int n, IntPtr framebuffers) + { + GL.GenFramebuffers(n, (int*)framebuffers); + } + + public override unsafe void glGenRenderbuffers(int n, IntPtr renderbuffers) + { + GL.GenRenderbuffers(n, (int*)renderbuffers); + } + + public override unsafe void glGenTextures(int n, IntPtr textures) + { + GL.GenTextures(n, (int*)textures); + } + + public override void glGenerateMipmap(int target) + { + GL.GenerateMipmap((GenerateMipmapTarget)target); + } + + public override unsafe void glGetboolv(int pname, IntPtr parameters) + { + GL.GetBoolean((GetPName)pname, (bool*)parameters); + } + + public override unsafe void glGetFloatv(int pname, IntPtr parameters) + { + GL.GetFloat((GetPName)pname, (float*)parameters); + } + + public override unsafe void glGetIntegerv(int pname, IntPtr parameters) + { + GL.GetInteger((GetPName)pname, (int*)parameters); + } + + public override unsafe void glGetActiveAttrib(int program, int index, int bufSize, IntPtr length, IntPtr size, IntPtr type, System.Text.StringBuilder name) + { + GL.GetActiveAttrib(program, index, bufSize, (int*)length, (int*)size, (ActiveAttribType*)type, name); + } + + public override unsafe void glGetActiveUniform(int program, int index, int bufSize, IntPtr length, IntPtr size, IntPtr type, System.Text.StringBuilder name) + { + GL.GetActiveUniform(program, index, bufSize, (int*)length, (int*)size, (ActiveUniformType*)type, name); + } + + public override unsafe void glGetAttachedShaders(int program, int maxCount, IntPtr count, IntPtr shaders) + { + GL.GetAttachedShaders(program, maxCount, (int*)count, (int*)shaders); + } + + public override int glGetAttribLocation(int program, string name) + { + return GL.GetAttribLocation(program, name); + } + + public override unsafe void glGetBufferParameteriv(int target, int value, IntPtr data) + { + GL.GetBufferParameter((BufferTarget)target, (BufferParameterName)value, (int*)data); + } + + public override int glGetError() + { + return (int)GL.GetError(); + } + + public override unsafe void glGetFramebufferAttachmentParameteriv(int target, int attachment, int pname, IntPtr parameters) + { + GL.GetFramebufferAttachmentParameter((FramebufferTarget)target, (FramebufferAttachment)attachment, (FramebufferParameterName)pname, (int*)parameters); + } + + public override unsafe void glGetProgramInfoLog(int program, int maxLength, IntPtr length, System.Text.StringBuilder infoLog) + { + GL.GetProgramInfoLog(program, maxLength, (int*)length, infoLog); + } + + public override unsafe void glGetProgramiv(int program, int pname, IntPtr parameters) + { + GL.GetProgram(program, (ProgramParameter)pname, (int*)parameters); + } + + public override unsafe void glGetRenderbufferParameteriv(int target, int pname, IntPtr parameters) + { + GL.GetRenderbufferParameter((RenderbufferTarget)target, (RenderbufferParameterName)pname, (int*)parameters); + } + + public override unsafe void glGetShaderInfoLog(int shader, int maxLength, IntPtr length, System.Text.StringBuilder infoLog) + { + GL.GetShaderInfoLog(shader, maxLength, (int*)length, infoLog); + } + + public override unsafe void glGetShaderPrecisionFormat(int shaderType, int precisionType, IntPtr range, IntPtr precision) + { + GL.GetShaderPrecisionFormat((ShaderType)shaderType, (ShaderPrecisionType)precisionType, (int*)range, (int*)precision); + } + + public override unsafe void glGetShaderSource(int shader, int maxLength, IntPtr length, System.Text.StringBuilder source) + { + GL.GetShaderSource(shader, maxLength, (int*)length, source); + } + + public override unsafe void glGetShaderiv(int shader, int pname, IntPtr parameters) + { + GL.GetShader(shader, (ShaderParameter)pname, (int*)parameters); + } + + public override string glGetString(int name) + { + return GL.GetString((StringName)name); + } + + public override unsafe void glGetTexParameterfv(int target, int pname, IntPtr parameters) + { + GL.GetTexParameter((TextureTarget)target, (GetTextureParameter)pname, (float*)parameters); + } + + public override unsafe void glGetTexParameteriv(int target, int pname, IntPtr parameters) + { + GL.GetTexParameter((TextureTarget)target, (GetTextureParameter)pname, (int*)parameters); + } + + public override unsafe void glGetUniformfv(int program, int location, IntPtr parameters) + { + GL.GetUniform(program, location, (float*)parameters); + } + + public override unsafe void glGetUniformiv(int program, int location, IntPtr parameters) + { + GL.GetUniform(program, location, (int*)parameters); + } + + public override int glGetUniformLocation(int program, string name) + { + return GL.GetUniformLocation(program, name); + } + + public override unsafe void glGetVertexAttribfv(int index, int pname, IntPtr parameters) + { + GL.GetVertexAttrib(index, (VertexAttribParameter)pname, (float*)parameters); + } + + public override unsafe void glGetVertexAttribiv(int index, int pname, IntPtr parameters) + { + GL.GetVertexAttrib(index, (VertexAttribParameter)pname, (int*)parameters); + } + + public override unsafe void glGetVertexAttribPointerv(int index, int pname, IntPtr pointer) + { + GL.GetVertexAttribPointer(index, (VertexAttribPointerParameter)pname, pointer); + } + + public override void glHint(int target, int mode) + { + GL.Hint((HintTarget)target, (HintMode)mode); + } + + public override bool glIsBuffer(int buffer) + { + return GL.IsBuffer(buffer); + } + + public override bool glIsEnabled(int cap) + { + return GL.IsEnabled((EnableCap)cap); + } + + public override bool glIsFramebuffer(int framebuffer) + { + return GL.IsFramebuffer(framebuffer); + } + + public override bool glIsProgram(int program) + { + return GL.IsProgram(program); + } + + public override bool glIsRenderbuffer(int renderbuffer) + { + return GL.IsRenderbuffer(renderbuffer); + } + + public override bool glIsShader(int shader) + { + return GL.IsShader(shader); + } + + public override bool glIsTexture(int texture) + { + return GL.IsTexture(texture); + } + + public override void glLineWidth(float width) + { + GL.LineWidth(width); + } + + public override void glLinkProgram(int program) + { + GL.LinkProgram(program); + } + + public override void glPixelStorei(int pname, int param) + { + GL.PixelStore((PixelStoreParameter)pname, param); + } + + public override void glPolygonOffset(float factor, float units) + { + GL.PolygonOffset(factor, units); + } + + public override void glReadPixels(int x, int y, int width, int height, int format, int type, IntPtr pixels) + { + GL.ReadPixels(x, y, width, height, (PixelFormat)format, (PixelType)type, pixels); + } + + public override void glReleaseShaderCompiler() + { + GL.ReleaseShaderCompiler(); + } + + public override void glRenderbufferStorage(int target, int internalformat, int width, int height) + { + GL.RenderbufferStorage((RenderbufferTarget)target, (RenderbufferStorage)internalformat, width, height); + } + + public override void glSampleCoverage(float value, bool invert) + { + GL.SampleCoverage(value, invert); + } + + public override void glScissor(int x, int y, int width, int height) + { + GL.Scissor(x, y, width, height); + } + + public override unsafe void glShaderBinary(int n, IntPtr shaders, int binaryformat, IntPtr binary, int length) + { + GL.ShaderBinary(n, (int*)shaders, (BinaryFormat)binaryformat, binary, length); + } + + public override unsafe void glShaderSource(int shader, int count, string[] str, IntPtr length) + { + GL.ShaderSource(shader, count, str, (int*)length); + } + + public override void glStencilFunc(int func, int reference, int mask) + { + GL.StencilFunc((StencilFunction)func, reference, mask); + } + + public override void glStencilFuncSeparate(int face, int func, int reference, int mask) + { + GL.StencilFuncSeparate((Version20)face, (StencilFunction)func, reference, mask); + } + + public override void glStencilMask(int mask) + { + GL.StencilMask(mask); + } + + public override void glStencilMaskSeparate(int face, int mask) + { + GL.StencilMaskSeparate((StencilFace)face, mask); + } + + public override void glStencilOp(int sfail, int dpfail, int dppass) + { + GL.StencilOp((StencilOp)sfail, (StencilOp)dpfail, (StencilOp)dppass); + } + + public override void glStencilOpSeparate(int face, int sfail, int dpfail, int dppass) + { + GL.StencilOpSeparate((StencilFace)face, (StencilOp)sfail, (StencilOp)dpfail, (StencilOp)dppass); + } + + public override void glTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, IntPtr data) + { + GL.TexImage2D((TextureTarget)target, level, (PixelInternalFormat)internalformat, width, height, border, (PixelFormat)format, (PixelType)type, data); + } + + public override void glTexParameterf(int target, int pname, float param) + { + GL.TexParameter((TextureTarget)target, (TextureParameterName)pname, param); + } + + public override unsafe void glTexParameterfv(int target, int pname, IntPtr parameters) + { + GL.TexParameter((TextureTarget)target, (TextureParameterName)pname, (float*)parameters); + } + + public override void glTexParameteri(int target, int pname, int param) + { + GL.TexParameter((TextureTarget)target, (TextureParameterName)pname, param); + } + + public override unsafe void glTexParameteriv(int target, int pname, IntPtr parameters) + { + GL.TexParameter((TextureTarget)target, (TextureParameterName)pname, (int*)parameters); + } + + public override void glTexSubImage2D(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, IntPtr data) + { + GL.TexSubImage2D((TextureTarget)target, level, xoffset, yoffset, width, height, (PixelFormat)format, (PixelType)type, data); + } + + public override void glUniform1f(int location, float v0) + { + GL.Uniform1(location, v0); + } + + public override unsafe void glUniform1fv(int location, int count, IntPtr value) + { + GL.Uniform1(location, count, (float*)value); + } + + public override void glUniform1i(int location, int v0) + { + GL.Uniform1(location, v0); + } + + public override unsafe void glUniform1iv(int location, int count, IntPtr value) + { + GL.Uniform1(location, count, (int*)value); + } + + public override void glUniform2f(int location, float v0, float v1) + { + GL.Uniform2(location, v0, v1); + } + + public override unsafe void glUniform2fv(int location, int count, IntPtr value) + { + GL.Uniform2(location, count, (float*)value); + } + + public override void glUniform2i(int location, int v0, int v1) + { + GL.Uniform2(location, v0, v1); + } + + public override unsafe void glUniform2iv(int location, int count, IntPtr value) + { + GL.Uniform2(location, count, (int*)value); + } + + public override void glUniform3f(int location, float v0, float v1, float v2) + { + GL.Uniform3(location, v0, v1, v2); + } + + public override unsafe void glUniform3fv(int location, int count, IntPtr value) + { + GL.Uniform3(location, count, (float*)value); + } + + public override void glUniform3i(int location, int v0, int v1, int v2) + { + GL.Uniform3(location, v0, v1, v2); + } + + public override unsafe void glUniform3iv(int location, int count, IntPtr value) + { + GL.Uniform3(location, count, (int*)value); + } + + public override void glUniform4f(int location, float v0, float v1, float v2, float v3) + { + GL.Uniform4(location, v0, v1, v2, v3); + } + + public override unsafe void glUniform4fv(int location, int count, IntPtr value) + { + GL.Uniform4(location, count, (float*)value); + } + + public override void glUniform4i(int location, int v0, int v1, int v2, int v3) + { + GL.Uniform4(location, v0, v1, v2, v3); + } + + public override unsafe void glUniform4iv(int location, int count, IntPtr value) + { + GL.Uniform4(location, count, (int*)value); + } + + public override unsafe void glUniformMatrix2fv(int location, int count, bool transpose, IntPtr value) + { + GL.UniformMatrix2(location, count, transpose, (float*)value); + } + + public override unsafe void glUniformMatrix3fv(int location, int count, bool transpose, IntPtr value) + { + GL.UniformMatrix3(location, count, transpose, (float*)value); + } + + public override unsafe void glUniformMatrix4fv(int location, int count, bool transpose, IntPtr value) + { + GL.UniformMatrix4(location, count, transpose, (float*)value); + } + + public override void glUseProgram(int program) + { + GL.UseProgram(program); + } + + public override void glValidateProgram(int program) + { + GL.ValidateProgram(program); + } + + public override void glVertexAttrib1f(int index, float v0) + { + GL.VertexAttrib1(index, v0); + } + + public override unsafe void glVertexAttrib1fv(int index, IntPtr v) + { + GL.VertexAttrib1(index, (float*)v); + } + + public override void glVertexAttrib2f(int index, float v0, float v1) + { + GL.VertexAttrib2(index, v0, v1); + } + + public override unsafe void glVertexAttrib2fv(int index, IntPtr v) + { + GL.VertexAttrib2(index, (float*)v); + } + + public override void glVertexAttrib3f(int index, float v0, float v1, float v2) + { + GL.VertexAttrib3(index, v0, v1, v2); + } + + public override unsafe void glVertexAttrib3fv(int index, IntPtr v) + { + GL.VertexAttrib3(index, (float*)v); + } + + public override void glVertexAttrib4f(int index, float v0, float v1, float v2, float v3) + { + GL.VertexAttrib4(index, v0, v1, v2, v3); + } + + public override unsafe void glVertexAttrib4fv(int index, IntPtr v) + { + GL.VertexAttrib4(index, (float*)v); + } + + public override void glVertexAttribPointer(int index, int size, int type, bool normalized, int stride, IntPtr pointer) + { + GL.VertexAttribPointer(index, size, (VertexAttribPointerType)type, normalized, stride, pointer); + } + + public override void glViewport(int x, int y, int width, int height) + { + GL.Viewport(x, y, width, height); + } + } +} + diff --git a/PortableGL.OpenTK/PortableGL.OpenTK.csproj b/PortableGL.OpenTK/PortableGL.OpenTK.csproj new file mode 100644 index 0000000..a5565a2 --- /dev/null +++ b/PortableGL.OpenTK/PortableGL.OpenTK.csproj @@ -0,0 +1,50 @@ + + + + Debug + AnyCPU + 10.0.0 + 2.0 + {E41C0646-FA26-4154-9EEE-4EA3689B0B7B} + Library + PortableGL.OpenTK + PortableGL.OpenTK + + + true + full + false + bin\Debug + DEBUG; + prompt + 4 + false + true + + + full + true + bin\Release + prompt + 4 + false + true + + + + + ..\libs\OpenTK\OpenTK.dll + + + + + + + + + + {8C271551-9F6D-4657-965E-2D321698048C} + PortableGL + + + \ No newline at end of file diff --git a/PortableGL.OpenTK/Properties/AssemblyInfo.cs b/PortableGL.OpenTK/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..2c51abf --- /dev/null +++ b/PortableGL.OpenTK/Properties/AssemblyInfo.cs @@ -0,0 +1,6 @@ +using System.Reflection; + +[assembly: AssemblyTitle("PortableGL.OpenTK")] +[assembly: AssemblyDescription("PortableGL OpenTK backend.")] +[assembly: AssemblyProduct("PortableGL.OpenTK")] +[assembly: AssemblyVersion("0.1")] \ No newline at end of file diff --git a/PortableGL.sln b/PortableGL.sln index 9b62c9b..b059b17 100644 --- a/PortableGL.sln +++ b/PortableGL.sln @@ -5,6 +5,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PortableGL.SDL", "PortableG EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PortableGL", "PortableGL\PortableGL.csproj", "{8C271551-9F6D-4657-965E-2D321698048C}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PortableGL.OpenTK", "PortableGL.OpenTK\PortableGL.OpenTK.csproj", "{E41C0646-FA26-4154-9EEE-4EA3689B0B7B}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -19,6 +21,10 @@ Global {8C271551-9F6D-4657-965E-2D321698048C}.Debug|Any CPU.Build.0 = Debug|Any CPU {8C271551-9F6D-4657-965E-2D321698048C}.Release|Any CPU.ActiveCfg = Release|Any CPU {8C271551-9F6D-4657-965E-2D321698048C}.Release|Any CPU.Build.0 = Release|Any CPU + {E41C0646-FA26-4154-9EEE-4EA3689B0B7B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E41C0646-FA26-4154-9EEE-4EA3689B0B7B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E41C0646-FA26-4154-9EEE-4EA3689B0B7B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E41C0646-FA26-4154-9EEE-4EA3689B0B7B}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(MonoDevelopProperties) = preSolution StartupItem = PortableGL.SDL\PortableGL.SDL.csproj diff --git a/libs/OpenTK/OpenTK.dll b/libs/OpenTK/OpenTK.dll new file mode 100755 index 0000000..4dd3b3c Binary files /dev/null and b/libs/OpenTK/OpenTK.dll differ diff --git a/libs/OpenTK/OpenTK.dll.config b/libs/OpenTK/OpenTK.dll.config new file mode 100644 index 0000000..c3f78fa --- /dev/null +++ b/libs/OpenTK/OpenTK.dll.config @@ -0,0 +1,13 @@ + + + + + + + + + + + + +