282 lines
11 KiB
C#
282 lines
11 KiB
C#
using StgSharp.Logic;
|
|
using StgSharp.Math;
|
|
|
|
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace StgSharp.Graphics
|
|
{
|
|
internal unsafe partial class GLonUpdate : IglFunc
|
|
{
|
|
private IntPtr ActiveTexturePtr = (IntPtr)(delegate*<void>)&InternalActiveTexture;
|
|
private IntPtr AttachShaderPtr = (IntPtr)(delegate*<void>)&InternalAttachShader;
|
|
private IntPtr BindBufferPtr = (IntPtr)(delegate*<void>)&InternalBindBuffer;
|
|
private IntPtr ClearColorPtr = (IntPtr)(delegate*<void>)&InternalClearColor;
|
|
private IntPtr ClearGraphicErrorPtr = (IntPtr)(delegate*<void>)&InternalClearGraphicError;
|
|
private IntPtr CompileShaderPtr = (IntPtr)(delegate*<void>)&InternalCompileShader;
|
|
private IntPtr DeleBufferPtr = (IntPtr)(delegate*<void>)&InternalDeleteBuffer;
|
|
private IntPtr BindTexturePtr = (IntPtr)(delegate*<void>)&InternalBindTexture;
|
|
private IntPtr BindVertexArrayPtr = (IntPtr)(delegate*<void>)&InternalBindVertexArray;
|
|
private IntPtr BufferDataPtr = (IntPtr)(delegate*<void>)&InternalSetBufferData;
|
|
private IntPtr ClearPtr = (IntPtr)(delegate*<void>)&InternalClear;
|
|
private IntPtr CreateProgramPtr = (IntPtr)(delegate*<void>)&InternalCreateProgram;
|
|
private IntPtr CreateProgramSetPtr = (IntPtr)(delegate*<void>)&InternalCreateProgramSet;
|
|
private IntPtr DeleteVertexArrayPtr = (IntPtr)(delegate*<void>)&InternalDeleteVertexArrays;
|
|
private IntPtr DrawElementsPtr = (IntPtr)(delegate*<void>)&InternalDrawElements;
|
|
private IntPtr GenBufferPtr = (IntPtr)(delegate*<void>)&InternalGenBuffers;
|
|
private IntPtr GenTexturesPtr = (IntPtr)(delegate*<void>)&InternalGenTextures;
|
|
private IntPtr GenVertexArraysPtr = (IntPtr)(delegate*<void>)&InternalGenVertexArrays;
|
|
private IntPtr GetUniformLocationPtr = (IntPtr)(delegate*<void>)&InternalGetUniformLocation;
|
|
private IntPtr SetVertexArrayPtr = (IntPtr)(delegate*<void>)&InternalSetVertexAttribute;
|
|
private IntPtr textureImage2dPtr = (IntPtr)(delegate*<void>)&InternalTextureImage2d;
|
|
private IntPtr TextureParameterPtr = (IntPtr)(delegate*<void>)&InternalTextureParameter;
|
|
private IntPtr UseProgramPtr = (IntPtr)(delegate*<void>)&InternalUseProgram;
|
|
private IntPtr ViewPortPtr = (IntPtr)(delegate*<void>)&InternalViewport;
|
|
|
|
private static void InternalActiveTexture()
|
|
{
|
|
uint t;
|
|
paramQueue.TryDequeue(out t);
|
|
paramQueue.context->glActiveTexture(t);
|
|
}
|
|
|
|
private static void InternalAttachShader()
|
|
{
|
|
uint p, s;
|
|
paramQueue.TryDequeue(out p, out s);
|
|
paramQueue.context->glAttachShader(p, s);
|
|
}
|
|
|
|
private static void InternalBindBuffer()
|
|
{
|
|
M128 m = default;
|
|
paramQueue.TryDequeue(out m);
|
|
paramQueue.context->glBindBuffer(m.UInt32[0], *(uint*)m.UInt64[1]);
|
|
}
|
|
|
|
private static void InternalBindTexture()
|
|
{
|
|
M128 m = default;
|
|
paramQueue.TryDequeue(out m);
|
|
paramQueue.context->glBindTexture(m.UInt32[0], *(uint*)m.UInt64[1]);
|
|
}
|
|
|
|
private static void InternalBindVertexArray()
|
|
{
|
|
IntPtr i;
|
|
paramQueue.TryDequeue(out i);
|
|
paramQueue.context->glBindVertexArray(*(uint*)i);
|
|
}
|
|
|
|
private static void InternalClear()
|
|
{
|
|
uint mt;
|
|
paramQueue.TryDequeue(out mt);
|
|
paramQueue.context->glClear(mt);
|
|
}
|
|
|
|
private static void InternalClearColor()
|
|
{
|
|
float r, g, b, a;
|
|
paramQueue.TryDequeue(out r, out g, out b, out a);
|
|
paramQueue.context->glClearColor(r, g, b, a);
|
|
}
|
|
|
|
private static void InternalClearGraphicError()
|
|
{
|
|
while (paramQueue.context->glGetError() != 0) { }
|
|
}
|
|
|
|
private static void InternalCompileShader()
|
|
{
|
|
IntPtr shaderHandle, codeHandle;
|
|
int count, type;
|
|
paramQueue.TryDequeue(out type, out count);
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
paramQueue.TryDequeue(out shaderHandle, out codeHandle);
|
|
GCHandle code = GCHandle.FromIntPtr(codeHandle);
|
|
byte[] c = (byte[])code.Target;
|
|
Console.WriteLine(Encoding.UTF8.GetString(c));
|
|
*(uint*)shaderHandle = InternalIO.InternalLoadShaderCode(paramQueue.context, (byte*)codeHandle, type);
|
|
if (*(uint*)shaderHandle == 0)
|
|
{
|
|
IntPtr logPtr = InternalIO.InternalReadSSCLog();
|
|
string log;
|
|
try
|
|
{
|
|
byte[] logByte = new byte[512];
|
|
Marshal.Copy(logPtr, logByte, 0, 512);
|
|
log = Encoding.UTF8.GetString(logByte);
|
|
log = log.Replace("\0", "");
|
|
|
|
bool isUseful = false;
|
|
foreach (char item in log)
|
|
{
|
|
if (!char.IsControl(item))
|
|
{
|
|
isUseful = true; break;
|
|
}
|
|
}
|
|
if (!isUseful)
|
|
{
|
|
throw new Exception();
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
log = "Failed to compile shader.\nFailed to get GLSL compiler log";
|
|
}
|
|
|
|
InternalIO.InternalWriteLog(log, LogType.Error);
|
|
}
|
|
GCHandle.FromIntPtr(codeHandle).Free();
|
|
}
|
|
}
|
|
|
|
private static void InternalCreateProgram()
|
|
{
|
|
IntPtr programHandle = default;
|
|
paramQueue.TryDequeue(out programHandle);
|
|
*(uint*)programHandle = paramQueue.context->glCreateProgram();
|
|
}
|
|
|
|
private static void InternalCreateProgramSet()
|
|
{
|
|
uint* programHandle;
|
|
M128 m = default;
|
|
paramQueue.TryDequeue(out m);
|
|
programHandle = (uint*)m.UInt64[0];
|
|
for (int i = 0; i < m.Int32[2]; i++)
|
|
{
|
|
*(programHandle + i) = paramQueue.context->glCreateProgram();
|
|
}
|
|
}
|
|
|
|
private static void InternalDeleteBuffer()
|
|
{
|
|
M128 m = default;
|
|
paramQueue.TryDequeue(out m);
|
|
paramQueue.context->glDeleteBuffers(m.UInt32[2], (uint*)m.UInt64[0]);
|
|
}
|
|
|
|
private static void InternalDeleteVertexArrays()
|
|
{
|
|
M128 m = default;
|
|
paramQueue.TryDequeue(out m);
|
|
paramQueue.context->glDeleteVertexArrays((uint)m.Int32[0], (uint*)m.UInt64[0]);
|
|
}
|
|
|
|
private static void InternalDrawElements()
|
|
{
|
|
uint mode, count, type;
|
|
IntPtr ptr;
|
|
paramQueue.TryDequeue(out mode, out count, out type);
|
|
paramQueue.TryDequeue(out ptr);
|
|
paramQueue.context->glDrawElements(mode, count, type, (void*)ptr);
|
|
}
|
|
|
|
private static void InternalGenBuffers()
|
|
{
|
|
M128 m = default;
|
|
paramQueue.TryDequeue(out m);
|
|
paramQueue.context->glGenBuffers(m.UInt32[2], (uint*)m.UInt64[0]);
|
|
}
|
|
|
|
private static void InternalGenTextures()
|
|
{
|
|
M128 m = default;
|
|
paramQueue.TryDequeue(out m);
|
|
paramQueue.context->glGenTextures(m.UInt32[2], (uint*)m.UInt64[0]);
|
|
}
|
|
|
|
private static void InternalGenVertexArrays()
|
|
{
|
|
M128 m = default;
|
|
paramQueue.TryDequeue(out m);
|
|
paramQueue.context->glGenVertexArrays(m.UInt32[2], (uint*)m.UInt64[0]);
|
|
}
|
|
|
|
private static void InternalGetUniformLocation()
|
|
{
|
|
IntPtr programHandle = default, nameHandle = default, targetHandle = default;
|
|
paramQueue.TryDequeue(out programHandle, out nameHandle);
|
|
paramQueue.TryDequeue(out targetHandle);
|
|
*(int*)targetHandle = paramQueue.context->glGetUniformLocation(*(uint*)programHandle, (byte*)nameHandle);
|
|
}
|
|
|
|
private static void InternalSetBufferData()
|
|
{
|
|
uint type = 0, use = 0;
|
|
IntPtr size = default, handle = default;
|
|
paramQueue.TryDequeue(out type, out use);
|
|
paramQueue.TryDequeue(out size, out handle);
|
|
paramQueue.context->glBufferData(type, size, (void*)handle, use);
|
|
GCHandle.FromIntPtr(handle).Free();
|
|
}
|
|
|
|
private static void InternalSetVertexAttribute()
|
|
{
|
|
uint index, type, stride;
|
|
int size, normalized, pointer;
|
|
paramQueue.TryDequeue(out index, out type, out stride);
|
|
paramQueue.TryDequeue(out size, out normalized, out pointer);
|
|
paramQueue.context->glVertexAttribPointer(index, size, type, normalized, stride, (void*)pointer);
|
|
paramQueue.context->glEnableVertexAttribArray(index);
|
|
}
|
|
|
|
private static void InternalTextureImage2d()
|
|
{
|
|
IntPtr pix = IntPtr.Zero;
|
|
uint target, level, internalFormat, width, height, format, type;
|
|
paramQueue.TryDequeue(out pix);
|
|
paramQueue.TryDequeue(out level, out internalFormat, out width, out height);
|
|
paramQueue.TryDequeue(out target, out format, out type);
|
|
paramQueue.context->glTexImage2D(target, (int)level, internalFormat, width, height, 0, format, type, (void*)pix);
|
|
GCHandle.FromIntPtr(pix).Free();
|
|
}
|
|
|
|
private static void InternalTextureParameter()
|
|
{
|
|
M128 m = default;
|
|
paramQueue.TryDequeue(out m);
|
|
paramQueue.context->glTextureParameteri(m.UInt32[0], m.UInt32[2], m.Int32[3]);
|
|
}
|
|
|
|
private static void InternalUseProgram()
|
|
{
|
|
IntPtr handle = IntPtr.Zero;
|
|
paramQueue.TryDequeue(out handle);
|
|
paramQueue.context->glUseProgram(*(uint*)handle);
|
|
}
|
|
|
|
private static void InternalViewport()
|
|
{
|
|
M128 m = default;
|
|
paramQueue.TryDequeue(out m);
|
|
paramQueue.context->glViewport(m.Int32[0], m.Int32[1], m.UInt32[2], m.UInt32[3]);
|
|
}
|
|
|
|
private void InternalMakeContexCurrent(Form form)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
private void InternalSetValue(Uniform<float, float, float, float> uniform, float v0, float v1, float v2, float v3)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
private void InternalSwitchContext()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
} |