public VBO(OpenGL gl, BeginMode beginMode)
{
Mode = beginMode;
_gl = gl;
var buffers = new uint[1];
gl.GenBuffers(1, buffers);
Handle = buffers[0];
Count = 0;
}
public static OGLBufferId[] CreateBufferIds(OpenGL gl, int amount)
{
uint[] ids = new uint[amount];
OGLBufferId[] bIds = new OGLBufferId[amount];
gl.GenBuffers(amount, ids);
for (int i = 0; i < amount; i++)
{
bIds[i] = new OGLBufferId(ids[i]);
}
return bIds;
}
public uint CreateVertexNormalBuffer(OpenGL gl)
{
Vertex[] verts = new Vertex[VertexCount * 2];
int count = 0;
float ds = 1.0f / Slices;
float dt = 1.0f / Stacks;
// The upper bounds in these loops are tweaked to reduce the
// chance of precision error causing an incorrect # of iterations.
for (float s = 0; s < 1 - ds / 2; s += ds)
{
for (float t = 0; t < 1 - dt / 2; t += dt)
{
const float E = 0.01f;
Vertex p = EvaluateTrefoil(s, t);
Vertex u = EvaluateTrefoil(s + E, t) - p;
Vertex v = EvaluateTrefoil(s, t + E) - p;
Vertex n = u.VectorProduct(v);
n.Normalize();
verts[count++] = p;
verts[count++] = n;
}
}
// Pin the data.
GCHandle vertsHandle = GCHandle.Alloc(verts, GCHandleType.Pinned);
IntPtr vertsPtr = vertsHandle.AddrOfPinnedObject();
var size = Marshal.SizeOf(typeof(Vertex)) * VertexCount;
uint[] buffers = new uint[1];
gl.GenBuffers(1, buffers);
uint handle = buffers[0];
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, handle);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, size, vertsPtr, OpenGL.GL_STATIC_DRAW);
// Free the data.
vertsHandle.Free();
return handle;
}
private void CreateBufferIds(OpenGL gl)
{
var amount = 8;
uint[] ids = new uint[amount];
gl.GenBuffers(amount, ids);
Position = ids[0];
Normal = ids[1];
AmbientMaterial = ids[2];
DiffuseMaterial = ids[3];
SpecularMaterial = ids[4];
ShininessValue = ids[5];
HTColorId = ids[6];
Ibo = ids[7];
}
private uint CreateIndexBuffer(OpenGL gl)
{
ushort[] inds = new ushort[IndexCount];
int count = 0;
ushort n = 0;
for (ushort i = 0; i < Slices; i++)
{
for (ushort j = 0; j < Stacks; j++)
{
inds[count++] = (ushort)(n + j);
inds[count++] = (ushort)(n + (j + 1) % Stacks);
inds[count++] = (ushort)((n + j + Stacks) % VertexCount);
inds[count++] = (ushort)((n + j + Stacks) % VertexCount);
inds[count++] = (ushort)((n + (j + 1) % Stacks) % VertexCount);
inds[count++] = (ushort)((n + (j + 1) % Stacks + Stacks) % VertexCount);
}
n += (ushort)Stacks;
}
// Pin the data.
GCHandle indsHandle = GCHandle.Alloc(inds, GCHandleType.Pinned);
IntPtr indsPtr = indsHandle.AddrOfPinnedObject();
var size = Marshal.SizeOf(typeof(ushort)) * VertexCount;
uint[] buffers = new uint[1];
gl.GenBuffers(1, buffers);
uint handle = buffers[0];
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, handle);
gl.BufferData(OpenGL.GL_ELEMENT_ARRAY_BUFFER, (int)size, indsPtr, OpenGL.GL_STATIC_DRAW);
// Free the data.
indsHandle.Free();
return handle;
}
private void CreateBufferIds(OpenGL gl)
{
var amount = 3;
uint[] ids = new uint[amount];
gl.GenBuffers(amount, ids);
Position = ids[0];
ColorValue = ids[1];
Ibo = ids[2];
}
public VBO(OpenGL gl)
{
_gl = gl;
_gl.GenBuffers(1, _handle);
}
private void PlaySound()
{
try
{
gl.GenVertexArrays(1, vao);
gl.BindVertexArray(vao[0]);
gl.GenBuffers(1, vbo);
float[] vertices = new float[] {
-1.0f, 1.0f,
1.0f, 1.0f,
1.0f, -1.0f,
-1.0f, 1.0f,
-1.0f, -1.0f,
1.0f, -1.0f
};
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, vbo[0]);
unsafe
{
fixed(float *verts = vertices)
{
var ptr = new IntPtr(verts);
// fill the buffer to the currently binded buffer
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, vertices.Length * sizeof(float), ptr, OpenGL.GL_STATIC_DRAW);
}
}
// Create the shader program.
var vertexShaderSource = ManifestResourceLoader.LoadTextFile("SoundShader.vert");
var fragmentShaderSource = ManifestResourceLoader.LoadTextFile("SoundShader.frag");
vertexShader = gl.CreateShader(OpenGL.GL_VERTEX_SHADER);
gl.ShaderSource(vertexShader, vertexShaderSource);
gl.CompileShader(vertexShader);
// Create and compile the fragment shader
fragmentShader = gl.CreateShader(OpenGL.GL_FRAGMENT_SHADER);
gl.ShaderSource(fragmentShader, fragmentShaderSource);
gl.CompileShader(fragmentShader);
// Link the vertex and fragment shader into a shader program
shaderProgram = gl.CreateProgram();
gl.AttachShader(shaderProgram, vertexShader);
gl.AttachShader(shaderProgram, fragmentShader);
gl.BindFragDataLocation(shaderProgram, (uint)0, "gl_FragColor");
gl.LinkProgram(shaderProgram);
int[] infoLength = new int[] { 0 };
int bufSize = infoLength[0];
// Get the compile info.
StringBuilder il = new StringBuilder(bufSize);
gl.GetProgramInfoLog(shaderProgram, bufSize, IntPtr.Zero, il);
gl.UseProgram(shaderProgram);
posAttrib = gl.GetAttribLocation(shaderProgram, "position");
gl.EnableVertexAttribArray((uint)posAttrib);
gl.VertexAttribPointer((uint)posAttrib, 2, OpenGL.GL_FLOAT, false, 0, new IntPtr(0));
timeLoc = gl.GetUniformLocation(shaderProgram, "iGlobalTime");
sampleLoc = gl.GetUniformLocation(shaderProgram, "Spectrum");
waveLoc = gl.GetUniformLocation(shaderProgram, "Wavedata");
int resLoc = gl.GetUniformLocation(shaderProgram, "iResolution");
gl.Uniform3(resLoc, (float)this.openGLControl1.Width, (float)this.openGLControl1.Height, (float)(this.openGLControl1.Width * this.openGLControl1.Height));
Thread thread = new Thread(() => PlaySoundT(((USound)selectedObject).SoundBuffer));
thread.Start();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace.ToString());
}
}
