private void InitVAO()
{
this.axisPrimitiveMode = DrawMode.QuadStrip;
GLColor[] colors = this.ColorPalette.Colors;
float[] coords = this.ColorPalette.Coords;
this.vertexCount = coords.Length * 2;
this.vao = new uint[1];
float coordLength = coords[coords.Length - 1] - coords[0];
{
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray <vec3> positionArray = new UnmanagedArray <vec3>(this.vertexCount);
positionArray[0] = new vec3(-0.5f, -0.5f, 0);
positionArray[1] = new vec3(-0.5f, 0.5f, 0);
for (int i = 1; i < coords.Length; i++)
{
float x = (coords[i] - coords[0]) / coordLength - 0.5f;
positionArray[i * 2 + 0] = new vec3(x, -0.5f, 0);
positionArray[i * 2 + 1] = new vec3(x, 0.5f, 0);
}
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_PositionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_PositionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
var colorArray = new UnmanagedArray <vec4>(this.vertexCount);
for (int i = 0; i < colors.Length; i++)
{
GLColor color = colors[i];
colorArray[i * 2 + 0] = new vec4(color.R, color.G, color.B, color.A);
colorArray[i * 2 + 1] = new vec4(color.R, color.G, color.B, color.A);
}
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_ColorLocation, 4, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_ColorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
}
protected override void DoInitialize()
{
base.DoInitialize();
{
// velocity
var velocity_buffer = new uint[1];
OpenGL.GetDelegateFor <OpenGL.glGenBuffers>()(1, velocity_buffer);
OpenGL.BindBuffer(BufferTarget.ArrayBuffer, velocity_buffer[0]);
var velocities = new UnmanagedArray <vec4>(SunshineParticleModel.particleCount);
unsafe
{
var random = new Random();
var array = (vec4 *)velocities.Header.ToPointer();
for (int i = 0; i < SunshineParticleModel.particleCount; i++)
{
array[i] = new vec4(
(float)(random.NextDouble() - 0.5) * 0.2f,
(float)(random.NextDouble() - 0.5) * 0.2f,
(float)(random.NextDouble() - 0.5) * 0.2f,
0);
}
}
OpenGL.BufferData(BufferTarget.ArrayBuffer, velocities, BufferUsage.DynamicCopy);
velocities.Dispose();
//GL.GetDelegateFor<GL.glVertexAttribPointer>()(0, 4, GL.GL_FLOAT, false, 0, IntPtr.Zero);
//GL.GetDelegateFor<GL.glEnableVertexAttribArray>()(0);
//
OpenGL.BindBuffer(BufferTarget.ArrayBuffer, 0);
this.VelocityBufferPtrId = velocity_buffer[0];
}
this.PositionBufferPtr = this.bufferable.GetProperty(SunshineParticleModel.strPosition, null);
this.VertexArrayObject = this.vertexArrayObject;
}
internal void LoadSoundInMemory()
{
if (PreloadedBuffer.Ptr != IntPtr.Zero)
{
return;
}
using (var soundStream = ContentManager.FileProvider.OpenStream(CompressedDataUrl, VirtualFileMode.Open, VirtualFileAccess.Read, VirtualFileShare.Read, StreamFlags.Seekable))
using (var decoder = new Celt(SampleRate, CompressedSoundSource.SamplesPerFrame, Channels, true))
{
var reader = new BinarySerializationReader(soundStream);
var samplesPerPacket = CompressedSoundSource.SamplesPerFrame * Channels;
PreloadedBuffer = AudioLayer.BufferCreate(samplesPerPacket * NumberOfPackets * sizeof(short));
var memory = new UnmanagedArray <short>(samplesPerPacket * NumberOfPackets);
var offset = 0;
var outputBuffer = new short[samplesPerPacket];
for (var i = 0; i < NumberOfPackets; i++)
{
var len = reader.ReadInt16();
var compressedBuffer = reader.ReadBytes(len);
var samplesDecoded = decoder.Decode(compressedBuffer, len, outputBuffer);
memory.Write(outputBuffer, offset, 0, samplesDecoded * Channels);
offset += samplesDecoded * Channels * sizeof(short);
}
AudioLayer.BufferFill(PreloadedBuffer, memory.Pointer, memory.Length * sizeof(short), SampleRate, Channels == 1);
memory.Dispose();
}
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
private void Dispose(Boolean disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
//TODO: Managed cleanup code here, while managed refs still valid
}
//TODO: Unmanaged cleanup code here
if (PositionArray != null)
{
PositionArray.Dispose();
}
if (ColorArray != null)
{
ColorArray.Dispose();
}
if (RadiusArray != null)
{
RadiusArray.Dispose();
}
if (VisibleArray != null)
{
VisibleArray.Dispose();
}
disposed = true;
}
private void InitVAO()
{
this.mode = DrawMode.Quads;
this.vertexCount = 4;
// Create a vertex buffer for the vertex data.
UnmanagedArray <vec3> in_Position = new UnmanagedArray <vec3>(this.vertexCount);
UnmanagedArray <vec2> in_TexCoord = new UnmanagedArray <vec2>(this.vertexCount);
Bitmap bigBitmap = this.ttfTexture.BigBitmap;
float factor = (float)this.ttfTexture.BigBitmap.Width / (float)this.ttfTexture.BigBitmap.Height;
float x1 = -factor;
float x2 = factor;
float y1 = -1;
float y2 = 1;
in_Position[0] = new vec3(x1, y1, 0);
in_Position[1] = new vec3(x2, y1, 0);
in_Position[2] = new vec3(x2, y2, 0);
in_Position[3] = new vec3(x1, y2, 0);
in_TexCoord[0] = new vec2(0, 0);
in_TexCoord[1] = new vec2(1, 0);
in_TexCoord[2] = new vec2(1, 1);
in_TexCoord[3] = new vec2(0, 1);
if (vao[0] != 0)
{
GL.DeleteBuffers(1, vao);
}
if (vbo[0] != 0)
{
GL.DeleteBuffers(vbo.Length, vbo);
}
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
GL.GenBuffers(2, vbo);
uint in_PositionLocation = shaderProgram.GetAttributeLocation(strin_Position);
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo[0]);
GL.BufferData(BufferTarget.ArrayBuffer, in_Position, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_PositionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_PositionLocation);
uint in_TexCoordLocation = shaderProgram.GetAttributeLocation(strin_TexCoord);
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo[1]);
GL.BufferData(BufferTarget.ArrayBuffer, in_TexCoord, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_TexCoordLocation, 2, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_TexCoordLocation);
GL.BindVertexArray(0);
in_Position.Dispose();
in_TexCoord.Dispose();
}
public override void Serialize(ref Sound obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey);
var audioEngine = services.GetServiceAs <IAudioEngineProvider>()?.AudioEngine;
obj.CompressedDataUrl = stream.ReadString();
obj.SampleRate = stream.ReadInt32();
obj.Channels = stream.ReadByte();
obj.StreamFromDisk = stream.ReadBoolean();
obj.Spatialized = stream.ReadBoolean();
obj.NumberOfPackets = stream.ReadInt16();
obj.MaxPacketLength = stream.ReadInt16();
if (!obj.StreamFromDisk && audioEngine != null && audioEngine.State != AudioEngineState.Invalidated && audioEngine.State != AudioEngineState.Disposed) //immediatelly preload all the data and decode
{
using (var soundStream = ContentManager.FileProvider.OpenStream(obj.CompressedDataUrl, VirtualFileMode.Open, VirtualFileAccess.Read, VirtualFileShare.Read, StreamFlags.Seekable))
using (var decoder = new Celt(obj.SampleRate, CompressedSoundSource.SamplesPerFrame, obj.Channels, true))
{
var reader = new BinarySerializationReader(soundStream);
var samplesPerPacket = CompressedSoundSource.SamplesPerFrame * obj.Channels;
obj.PreloadedBuffer = AudioLayer.BufferCreate(samplesPerPacket * obj.NumberOfPackets * sizeof(short));
var memory = new UnmanagedArray <short>(samplesPerPacket * obj.NumberOfPackets);
var offset = 0;
var outputBuffer = new short[samplesPerPacket];
for (var i = 0; i < obj.NumberOfPackets; i++)
{
var len = reader.ReadInt16();
var compressedBuffer = reader.ReadBytes(len);
var samplesDecoded = decoder.Decode(compressedBuffer, len, outputBuffer);
memory.Write(outputBuffer, offset, 0, samplesDecoded * obj.Channels);
offset += samplesDecoded * obj.Channels * sizeof(short);
}
AudioLayer.BufferFill(obj.PreloadedBuffer, memory.Pointer, memory.Length * sizeof(short), obj.SampleRate, obj.Channels == 1);
memory.Dispose();
}
}
if (audioEngine != null)
{
obj.Attach(audioEngine);
}
}
else
{
stream.Write(obj.CompressedDataUrl);
stream.Write(obj.SampleRate);
stream.Write((byte)obj.Channels);
stream.Write(obj.StreamFromDisk);
stream.Write(obj.Spatialized);
stream.Write((short)obj.NumberOfPackets);
stream.Write((short)obj.MaxPacketLength);
}
}
private void InitVAO()
{
this.axisPrimitiveMode = DrawMode.LineLoop;
this.axisVertexCount = 4;
this.vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray <vec3> positionArray = new UnmanagedArray <vec3>(4);
positionArray[0] = new vec3(-0.5f, -0.5f, 0);
positionArray[1] = new vec3(0.5f, -0.5f, 0);
positionArray[2] = new vec3(0.5f, 0.5f, 0);
positionArray[3] = new vec3(-0.5f, 0.5f, 0);
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
UnmanagedArray <vec3> colorArray = new UnmanagedArray <vec3>(4);
vec3 color = this.rectColor;
for (int i = 0; i < colorArray.Length; i++)
{
colorArray[i] = color;
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
//protected void InitializeVAO(out uint[] vao, out DrawMode primitiveMode, out int vertexCount)
protected void InitializeVAO()
{
this.primitiveMode = DrawMode.Triangles;
this.vertexCount = positions.Length;
this.vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
//uint[] ids = new uint[1];
this.positionBufferObject = new uint[1];
GL.GenBuffers(1, this.positionBufferObject);
GL.BindBuffer(BufferTarget.ArrayBuffer, this.positionBufferObject[0]);
UnmanagedArray <vec3> positionArray = new UnmanagedArray <vec3>(positions.Length);
for (int i = 0; i < positions.Length; i++)
{
positionArray[i] = positions[i];
}
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
//uint[] ids = new uint[1];
this.colorBufferObject = new uint[1];
GL.GenBuffers(1, this.colorBufferObject);
GL.BindBuffer(BufferTarget.ArrayBuffer, this.colorBufferObject[0]);
UnmanagedArray <vec3> colorArray = new UnmanagedArray <vec3>(positions.Length);
for (int i = 0; i < colors.Length; i++)
{
colorArray[i] = colors[i];
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
private void InitVAO()
{
this.mode = DrawMode.Quads;
this.vertexCount = 4;
// Create a vertex buffer for the vertex data.
UnmanagedArray<vec3> in_Position = new UnmanagedArray<vec3>(this.vertexCount);
UnmanagedArray<vec2> in_TexCoord = new UnmanagedArray<vec2>(this.vertexCount);
Bitmap bigBitmap = this.ttfTexture.BigBitmap;
float factor = (float)this.ttfTexture.BigBitmap.Width / (float)this.ttfTexture.BigBitmap.Height;
float x1 = -factor;
float x2 = factor;
float y1 = -1;
float y2 = 1;
in_Position[0] = new vec3(x1, y1, 0);
in_Position[1] = new vec3(x2, y1, 0);
in_Position[2] = new vec3(x2, y2, 0);
in_Position[3] = new vec3(x1, y2, 0);
in_TexCoord[0] = new vec2(0, 0);
in_TexCoord[1] = new vec2(1, 0);
in_TexCoord[2] = new vec2(1, 1);
in_TexCoord[3] = new vec2(0, 1);
if (vao[0] != 0)
{ GL.DeleteBuffers(1, vao); }
if (vbo[0] != 0)
{ GL.DeleteBuffers(vbo.Length, vbo); }
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
GL.GenBuffers(2, vbo);
uint in_PositionLocation = shaderProgram.GetAttributeLocation(strin_Position);
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo[0]);
GL.BufferData(BufferTarget.ArrayBuffer, in_Position, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_PositionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_PositionLocation);
uint in_TexCoordLocation = shaderProgram.GetAttributeLocation(strin_TexCoord);
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo[1]);
GL.BufferData(BufferTarget.ArrayBuffer, in_TexCoord, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_TexCoordLocation, 2, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_TexCoordLocation);
GL.BindVertexArray(0);
in_Position.Dispose();
in_TexCoord.Dispose();
}
public override void Cleanup()
{
_trianglePrimitive?.Dispose();
_trianglePrimitiveTransforms.Dispose();
_trianglePrimitivePerSecondDelta.Dispose();
_constantBuffer?.Dispose();
_uploadBuffer?.Dispose();
_vertexBuffer?.Dispose();
base.Cleanup();
}
private void DoRender(object sender, PaintEventArgs e)
{
// Compute the MVP (Model View Projection matrix)
{
GL.BindBuffer(BufferTarget.UniformBuffer, BufferName[1]);//BufferName[TRANSFORM]
var mvpPointer = GL.MapBufferRange(GL.GL_UNIFORM_BUFFER, 0, 64, (uint)(GL.GL_MAP_WRITE_BIT | GL.GL_MAP_INVALIDATE_BUFFER_BIT));
var tmp = new UnmanagedArray <mat4>(1);
mat4 projection = this.camera.GetProjectionMat4();
mat4 view = this.camera.GetViewMat4();
//tmp[0] = projection * view;
//tmp.CopyTo(Pointer);
unsafe
{
mat4 *array = (mat4 *)mvpPointer.ToPointer();
array[0] = projection * view;
}
GL.UnmapBuffer(GL.GL_UNIFORM_BUFFER);
tmp.Dispose();
}
// Clear color buffer
//GL.ClearBufferfv(GL_COLOR, 0, &GL.m.vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
GL.ClearBuffer(GL.GL_COLOR, 0, new float[] { 0.0f, 0.0f, 0.0f, 1.0f });
// First draw, capture the attributes
// Disable rasterisation, vertices processing only!
GL.Enable(GL.GL_RASTERIZER_DISCARD);
transformProgram.Bind();
GL.BindVertexArray(transformArray[0]);
//GL.BindBufferBase(GL.GL_UNIFORM_BUFFER, semantic.uniform.TRANSFORM0, BufferName[buffer.TRANSFORM]);
GL.BindBufferBase(GL.GL_UNIFORM_BUFFER, 1, BufferName[1]);
GL.BindTransformFeedback(GL.GL_TRANSFORM_FEEDBACK, feedbackObj[0]);
GL.BeginTransformFeedback(GL.GL_TRIANGLES);
GL.DrawArraysInstanced(GL.GL_TRIANGLES, 0, 6, 1);//VertexCount: 6
GL.EndTransformFeedback();
GL.BindTransformFeedback(GL.GL_TRANSFORM_FEEDBACK, 0);
GL.Disable(GL.GL_RASTERIZER_DISCARD);
// Second draw, reuse the captured attributes
feedbackProgram.Bind();
GL.BindVertexArray(feedbackArray[0]);
GL.DrawTransformFeedback(GL.GL_TRIANGLES, feedbackObj[0]);
}
protected void InitializeVAO(out uint[] vao, out DrawMode primitiveMode, out int vertexCount)
{
primitiveMode = DrawMode.Quads;
vertexCount = positions.Length;
vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
var positionArray = new UnmanagedArray <vec3>(positions.Length);
for (int i = 0; i < positions.Length; i++)
{
positionArray[i] = positions[i];
}
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Create a vertex buffer for the uv data.
{
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
var uvArray = new UnmanagedArray <vec2>(uvs.Length);
for (int i = 0; i < uvs.Length; i++)
{
uvArray[i] = uvs[i];
}
uint uvLocation = shaderProgram.GetAttributeLocation(strin_uv);
GL.BufferData(BufferTarget.ArrayBuffer, uvArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(uvLocation, 2, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(uvLocation);
uvArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
protected void InitializeVAO(OpenGL gl, out uint[] vao, out BeginMode primitiveMode, out int vertexCount)
{
primitiveMode = BeginMode.Quads;
vertexCount = positions.Length;
vao = new uint[1];
gl.GenVertexArrays(1, vao);
gl.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
uint[] ids = new uint[1];
gl.GenBuffers(1, ids);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, ids[0]);
var positionArray = new UnmanagedArray <vec3>(positions.Length);
for (int i = 0; i < positions.Length; i++)
{
positionArray[i] = positions[i];
}
uint positionLocation = (uint)shaderProgram.GetAttributeLocation(gl, strin_Position);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, positionArray.ByteLength, positionArray.Header, OpenGL.GL_STATIC_DRAW);
gl.VertexAttribPointer(positionLocation, 3, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Create a vertex buffer for the uv data.
{
uint[] ids = new uint[1];
gl.GenBuffers(1, ids);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, ids[0]);
var uvArray = new UnmanagedArray <vec2>(uvs.Length);
for (int i = 0; i < uvs.Length; i++)
{
uvArray[i] = uvs[i];
}
uint uvLocation = (uint)shaderProgram.GetAttributeLocation(gl, strin_uv);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, uvArray.ByteLength, uvArray.Header, OpenGL.GL_STATIC_DRAW);
gl.VertexAttribPointer(uvLocation, 2, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(uvLocation);
uvArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
gl.BindVertexArray(0);
}
private void initVol3DTex(string filename, int width, int height, int depth)
{
var data = new UnmanagedArray <byte>(width * height * depth);
unsafe
{
int index = 0;
int readCount = 0;
byte *array = (byte *)data.Header.ToPointer();
using (var fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
using (var br = new BinaryReader(fs))
{
int unReadCount = (int)fs.Length;
const int cacheSize = 1024 * 1024;
do
{
int min = Math.Min(cacheSize, unReadCount);
var cache = new byte[min];
readCount = br.Read(cache, 0, min);
if (readCount != min)
{
throw new Exception();
}
for (int i = 0; i < readCount; i++)
{
array[index++] = cache[i];
}
unReadCount -= readCount;
} while (readCount > 0);
}
}
OpenGL.GenTextures(1, vol3DTexObj);
// bind 3D texture target
OpenGL.BindTexture(OpenGL.GL_TEXTURE_3D, vol3DTexObj[0]);
OpenGL.TexParameteri(OpenGL.GL_TEXTURE_3D, OpenGL.GL_TEXTURE_MAG_FILTER, (int)OpenGL.GL_LINEAR);
OpenGL.TexParameteri(OpenGL.GL_TEXTURE_3D, OpenGL.GL_TEXTURE_MIN_FILTER, (int)OpenGL.GL_LINEAR);
OpenGL.TexParameteri(OpenGL.GL_TEXTURE_3D, OpenGL.GL_TEXTURE_WRAP_S, (int)OpenGL.GL_REPEAT);
OpenGL.TexParameteri(OpenGL.GL_TEXTURE_3D, OpenGL.GL_TEXTURE_WRAP_T, (int)OpenGL.GL_REPEAT);
OpenGL.TexParameteri(OpenGL.GL_TEXTURE_3D, OpenGL.GL_TEXTURE_WRAP_R, (int)OpenGL.GL_REPEAT);
// pixel transfer happens here from client to OpenGL server
OpenGL.PixelStorei(OpenGL.GL_UNPACK_ALIGNMENT, 1);
OpenGL.TexImage3D(OpenGL.GL_TEXTURE_3D, 0, (int)OpenGL.GL_INTENSITY,
width, height, depth, 0,
OpenGL.GL_LUMINANCE, OpenGL.GL_UNSIGNED_BYTE, data.Header);
data.Dispose();
OpenGL.BindTexture(OpenGL.GL_TEXTURE_3D, 0);
}
protected override void DoInitialize()
{
// Now create a simple program to visualize the result
basicShaderProgram = new ShaderProgram();
basicShaderProgram.Create(basicVertexShader, basicFragmentShader, null);
base_model_matrix_pos = GL.GetUniformLocation(basicShaderProgram.ShaderProgramObject, "model_matrix");
base_projection_matrix_pos = GL.GetUniformLocation(basicShaderProgram.ShaderProgramObject, "projection_matrix");
fur_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(fur_prog, ShaderType.VertexShader, furVertexShader);
ShaderHelper.vglAttachShaderSource(fur_prog, ShaderType.GeometryShader, furGeometryShader);
ShaderHelper.vglAttachShaderSource(fur_prog, ShaderType.FragmentShader, furFragmentShader);
GL.LinkProgram(fur_prog);
GL.UseProgram(fur_prog);
fur_model_matrix_pos = GL.GetUniformLocation(fur_prog, "model_matrix");
fur_projection_matrix_pos = GL.GetUniformLocation(fur_prog, "projection_matrix");
GL.GenTextures(1, fur_texture);
UnmanagedArray <byte> tex = new UnmanagedArray <byte>(1024 * 1024 * 4);
Random random = new Random();
for (int n = 0; n < 256; n++)
{
for (int m = 0; m < 1270; m++)
{
int x = random.Next() & 0x3FF;
int y = random.Next() & 0x3FF;
tex[(y * 1024 + x) * 4 + 0] = (byte)((random.Next() & 0x3F) + 0xC0);
tex[(y * 1024 + x) * 4 + 1] = (byte)((random.Next() & 0x3F) + 0xC0);
tex[(y * 1024 + x) * 4 + 2] = (byte)((random.Next() & 0x3F) + 0xC0);
tex[(y * 1024 + x) * 4 + 3] = (byte)(n);
//tex[(y * 1024 + x) * 4 + 0] = (byte)(random.Next());
//tex[(y * 1024 + x) * 4 + 1] = (byte)(random.Next());
//tex[(y * 1024 + x) * 4 + 2] = (byte)(random.Next());
//tex[(y * 1024 + x) * 4 + 3] = (byte)(random.Next());
}
}
GL.BindTexture(GL.GL_TEXTURE_2D, fur_texture[0]);
GL.TexImage2D(TexImage2DTargets.Texture2D, 0, TexImage2DFormats.RGBA, 1024, 1024, 0, TexImage2DFormats.RGBA, TexImage2DTypes.UnsignedByte, tex.Header);
GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, (int)GL.GL_LINEAR);
GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, (int)GL.GL_LINEAR);
tex.Dispose();
vboObject.LoadFromVBM(@"media\ninja.vbm", 0, 1, 2);
base.BeforeRendering += LightingExample_BeforeRendering;
base.AfterRendering += LightingExample_AfterRendering;
}
protected void InitializeVAO()
{
this.primitiveMode = DrawMode.Points;
const int axisCount = 3;
const int count = axisCount * axisCount * axisCount;
this.vertexCount = count;
this.vao = new uint[1];
GL.GenVertexArrays(4, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray <vec3> positionArray = new UnmanagedArray <vec3>(count);
for (int i = 0, index = 0; i < axisCount; i++)
{
for (int j = 0; j < axisCount; j++)
{
for (int k = 0; k < axisCount; k++)
{
//positionArray[index++] = 10 * new vec3(i - axisCount / 2, j - axisCount / 2, k - axisCount / 2);
positionArray[index++] = 10 * new vec3((float)random.NextDouble() - 0.5f, (float)random.NextDouble() - 0.5f, (float)random.NextDouble() - 0.5f);
}
}
}
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
private void Dispose(bool disposing)
{
if (this.disposedValue == false)
{
if (disposing)
{
// Dispose managed resources.
}
// Dispose unmanaged resources.
UnmanagedArray <T> array = this.array;
this.array = null;
if (array != null)
{
array.Dispose();
}
}
this.disposedValue = true;
}
/// <summary>
///
/// </summary>
public override void Fill()
{
var data = new UnmanagedArray <byte>(width * height * depth);
unsafe
{
int index = 0;
int readCount = 0;
byte *array = (byte *)data.Header.ToPointer();
using (var fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
using (var br = new BinaryReader(fs))
{
int unReadCount = (int)fs.Length;
const int cacheSize = 1024 * 1024;
do
{
int min = Math.Min(cacheSize, unReadCount);
var cache = new byte[min];
readCount = br.Read(cache, 0, min);
if (readCount != min)
{
throw new Exception();
}
for (int i = 0; i < readCount; i++)
{
array[index++] = cache[i];
}
unReadCount -= readCount;
} while (readCount > 0);
}
}
OpenGL.PixelStorei(OpenGL.GL_UNPACK_ALIGNMENT, 1);
OpenGL.TexImage3D(OpenGL.GL_TEXTURE_3D, 0, (int)OpenGL.GL_INTENSITY,
width, height, depth, 0,
OpenGL.GL_LUMINANCE, OpenGL.GL_UNSIGNED_BYTE, data.Header);
data.Dispose();
}
public bool LoadFromVBM(string filename, int vertexIndex, int normalIndex, int texCoord0Index)
{
FileStream f = new FileStream(filename, FileMode.Open, FileAccess.Read);
BinaryReader br = new BinaryReader(f);
long filesize = f.Length;
byte[] data = new byte[filesize];
UnmanagedArray<byte> raw_data;
f.Read(data, 0, (int)filesize);
f.Seek(0, SeekOrigin.Begin);
VBM_HEADER header = br.ReadStruct<VBM_HEADER>();
VBM_ATTRIB_HEADER attrib_header = br.ReadStruct<VBM_ATTRIB_HEADER>();
{
long offset = header.size + header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER));
f.Seek(offset, SeekOrigin.Begin);
}
VBM_FRAME_HEADER frame_header = br.ReadStruct<VBM_FRAME_HEADER>();
uint total_data_size = 0;
this.m_header = header;
{
long offset = header.size;// +header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER));
f.Seek(offset, SeekOrigin.Begin);
}
this.m_attrib = new VBM_ATTRIB_HEADER[header.num_attribs];
for (int i = 0; i < header.num_attribs; i++)
{
this.m_attrib[i] = br.ReadStruct<VBM_ATTRIB_HEADER>();
}
{
long offset = header.size + header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER));// +header.num_frames * Marshal.SizeOf(typeof(VBM_FRAME_HEADER));
f.Seek(offset, SeekOrigin.Begin);
}
this.m_frame = new VBM_FRAME_HEADER[header.num_frames];
for (int i = 0; i < header.num_frames; i++)
{
this.m_frame[i] = br.ReadStruct<VBM_FRAME_HEADER>();
}
GL.GenVertexArrays(1, m_vao);
GL.BindVertexArray(m_vao[0]);
GL.GenBuffers(1, m_attribute_buffer);
GL.BindBuffer(BufferTarget.ArrayBuffer, m_attribute_buffer[0]);
//uint i;
for (uint i = 0; i < header.num_attribs; i++)
{
total_data_size += m_attrib[i].components * sizeof(float) * header.num_vertices;
}
{
long offset = header.size + header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER)) + header.num_frames * Marshal.SizeOf(typeof(VBM_FRAME_HEADER));
raw_data = new UnmanagedArray<byte>((int)total_data_size);
for (int i = 0; i < raw_data.Length; i++)
{
raw_data[i] = data[offset + i];
}
}
//GL.BufferData(GL_ARRAY_BUFFER, total_data_size, raw_data, GL_STATIC_DRAW);
GL.BufferData(BufferTarget.ArrayBuffer, raw_data, BufferUsage.StaticDraw);
total_data_size = 0;
for (uint i = 0; i < header.num_attribs; i++)
{
uint attribIndex = i;
if (attribIndex == 0)
attribIndex = (uint)vertexIndex;
else if (attribIndex == 1)
attribIndex = (uint)normalIndex;
else if (attribIndex == 2)
attribIndex = (uint)texCoord0Index;
GL.VertexAttribPointer(attribIndex, (int)m_attrib[i].components, m_attrib[i].type, false, 0, new IntPtr(total_data_size));
GL.EnableVertexAttribArray(attribIndex);
total_data_size += m_attrib[i].components * sizeof(float) * header.num_vertices;
}
if (header.num_indices > 0)
{
GL.GenBuffers(1, m_index_buffer);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, m_index_buffer[0]);
uint element_size;
if (header.indexype == 0x1403)
{
element_size = sizeof(ushort);
}
else
{
element_size = sizeof(uint);
}
//GL.BufferData(GL_ELEMENT_ARRAY_BUFFER, header.num_indices * element_size, raw_data + total_data_size, GL_STATIC_DRAW);
UnmanagedArray<byte> tmp = new UnmanagedArray<byte>((int)(header.num_indices * element_size));
for (int t = 0; t < tmp.Length; t++)
{
tmp[t] = raw_data[(int)(t + total_data_size)];
}
GL.BufferData(BufferTarget.ElementArrayBuffer, tmp, BufferUsage.StaticDraw);
tmp.Dispose();
}
GL.BindVertexArray(0);
raw_data.Dispose();
return true;
}
private void DoRender(object sender, PaintEventArgs e)
{
// Compute the MVP (Model View Projection matrix)
{
GL.BindBuffer(BufferTarget.UniformBuffer, BufferName[1]);//BufferName[TRANSFORM]
var mvpPointer = GL.MapBufferRange(GL.GL_UNIFORM_BUFFER, 0, 64, (uint)(GL.GL_MAP_WRITE_BIT | GL.GL_MAP_INVALIDATE_BUFFER_BIT));
var tmp = new UnmanagedArray<mat4>(1);
mat4 projection = this.camera.GetProjectionMat4();
mat4 view = this.camera.GetViewMat4();
//tmp[0] = projection * view;
//tmp.CopyTo(Pointer);
unsafe
{
mat4* array = (mat4*)mvpPointer.ToPointer();
array[0] = projection * view;
}
GL.UnmapBuffer(GL.GL_UNIFORM_BUFFER);
tmp.Dispose();
}
// Clear color buffer
//GL.ClearBufferfv(GL_COLOR, 0, &GL.m.vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
GL.ClearBuffer(GL.GL_COLOR, 0, new float[] { 0.0f, 0.0f, 0.0f, 1.0f });
// First draw, capture the attributes
// Disable rasterisation, vertices processing only!
GL.Enable(GL.GL_RASTERIZER_DISCARD);
transformProgram.Bind();
GL.BindVertexArray(transformArray[0]);
//GL.BindBufferBase(GL.GL_UNIFORM_BUFFER, semantic.uniform.TRANSFORM0, BufferName[buffer.TRANSFORM]);
GL.BindBufferBase(GL.GL_UNIFORM_BUFFER, 1, BufferName[1]);
GL.BindTransformFeedback(GL.GL_TRANSFORM_FEEDBACK, feedbackObj[0]);
GL.BeginTransformFeedback(GL.GL_TRIANGLES);
GL.DrawArraysInstanced(GL.GL_TRIANGLES, 0, 6, 1);//VertexCount: 6
GL.EndTransformFeedback();
GL.BindTransformFeedback(GL.GL_TRANSFORM_FEEDBACK, 0);
GL.Disable(GL.GL_RASTERIZER_DISCARD);
// Second draw, reuse the captured attributes
feedbackProgram.Bind();
GL.BindVertexArray(feedbackArray[0]);
GL.DrawTransformFeedback(GL.GL_TRIANGLES, feedbackObj[0]);
}
protected void InitializeVAO()
{
this.axisPrimitiveMode = DrawMode.QuadStrip; //PrimitiveModes.QuadStrip;
this.axisVertexCount = faceCount * 2;
this.vao = new uint[4];
GL.GenVertexArrays(4, vao);
vec3[] colors = new vec3[] { new vec3(1, 0, 0), new vec3(0, 1, 0), new vec3(0, 0, 1) };
// 计算三个坐标轴
for (int axisIndex = 0; axisIndex < 3; axisIndex++)
{
GL.BindVertexArray(vao[axisIndex]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray<vec3> positionArray = new UnmanagedArray<vec3>(faceCount * 2);
for (int i = 0; i < faceCount * 2; i++)
{
int face = i / 2;
float[] components = new float[]{
i % 2 == 1 ? 0 : this.axisLength,
(float)(this.radius * Math.Cos(face * (Math.PI * 2) / faceCount)),
(float)(this.radius * Math.Sin(face * (Math.PI * 2) / faceCount))};
positionArray[i] = new vec3(
components[(0 + axisIndex) % 3], components[(2 + axisIndex) % 3], components[(4 + axisIndex) % 3]);
}
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
UnmanagedArray<vec3> colorArray = new UnmanagedArray<vec3>(faceCount * 2);
for (int i = 0; i < colorArray.Length; i++)
{
colorArray[i] = colors[axisIndex];
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
{
UnmanagedArray<uint> cylinderIndex = new UnmanagedArray<uint>(faceCount * 2 + 2);
for (int i = 0; i < cylinderIndex.Length - 2; i++)
{
cylinderIndex[i] = (uint)i;
}
cylinderIndex[cylinderIndex.Length - 2] = 0;
cylinderIndex[cylinderIndex.Length - 1] = 1;
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ElementArrayBuffer, cylinderIndex, BufferUsage.StaticDraw);
cylinderIndex.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
// 计算XZ平面
{
this.planPrimitveMode = DrawMode.LineLoop;
var lanVertexCount = 4;
GL.BindVertexArray(vao[3]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray<vec3> plan = new UnmanagedArray<vec3>(lanVertexCount);
float length = this.axisLength;
plan[0] = new vec3(-length, 0, -length);
plan[1] = new vec3(-length, 0, length);
plan[2] = new vec3(length, 0, length);
plan[3] = new vec3(length, 0, -length);
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, plan, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
plan.Dispose();
}
// Now do the same for the colour data.
{
UnmanagedArray<vec3> colorArray = new UnmanagedArray<vec3>(4);
for (int i = 0; i < colorArray.Length; i++)
{
colorArray[i] = this.planColor;
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
}
protected void InitializeVAO(out uint[] vao, out DrawMode primitiveMode, out int vertexCount)
{
primitiveMode = DrawMode.Quads;
vertexCount = positions.Length;
vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
var positionArray = new UnmanagedArray<vec3>(positions.Length);
for (int i = 0; i < positions.Length; i++)
{
positionArray[i] = positions[i];
}
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Create a vertex buffer for the uv data.
{
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
var uvArray = new UnmanagedArray<vec2>(uvs.Length);
for (int i = 0; i < uvs.Length; i++)
{
uvArray[i] = uvs[i];
}
uint uvLocation = shaderProgram.GetAttributeLocation(strin_uv);
GL.BufferData(BufferTarget.ArrayBuffer, uvArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(uvLocation, 2, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(uvLocation);
uvArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
public bool LoadFromVBM(string filename, int vertexIndex, int normalIndex, int texCoord0Index)
{
//FILE * f = NULL;
FileStream f = new FileStream(filename, FileMode.Open, FileAccess.Read);
BinaryReader br = new BinaryReader(f);
//f = fopen(filename, "rb");
//if(f == NULL)
//return false;
//fseek(f, 0, SEEK_END);
//size_t filesize = ftell(f);
//fseek(f, 0, SEEK_SET);
long filesize = f.Length;
//f.Seek(0, SeekOrigin.End);
//f.Seek(0, SeekOrigin.Begin);
byte[] data = new byte[filesize];
UnmanagedArray<byte> raw_data;
f.Read(data, 0, (int)filesize);
//f.Close();
f.Seek(0, SeekOrigin.Begin);
//VBM_HEADER * header = (VBM_HEADER *)data;
VBM_HEADER header = br.ReadStruct<VBM_HEADER>();
//raw_data = data + header.size + header->num_attribs * sizeof(VBM_ATTRIB_HEADER) + header->num_frames * sizeof(VBM_FRAME_HEADER);
//{
// long offset = header.size + header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER)) + header.num_frames * Marshal.SizeOf(typeof(VBM_FRAME_HEADER));
// raw_data = new UnmanagedArray<byte>((int)(data.Length - offset));
// for (int i = 0; i < raw_data.Length; i++)
// {
// raw_data[i] = data[offset+i];
// }
//}
//VBM_ATTRIB_HEADER * attrib_header = (VBM_ATTRIB_HEADER *)(data + header.size);
VBM_ATTRIB_HEADER attrib_header = br.ReadStruct<VBM_ATTRIB_HEADER>();
//VBM_FRAME_HEADER * frame_header = (VBM_FRAME_HEADER *)(data + header.size + header.num_attribs * sizeof(VBM_ATTRIB_HEADER));
{
long offset = header.size + header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER));
f.Seek(offset, SeekOrigin.Begin);
}
VBM_FRAME_HEADER frame_header = br.ReadStruct<VBM_FRAME_HEADER>();
uint total_data_size = 0;
//memcpy(&m_header, header, header.size < Marshal.SizeOf(typeof(VBM_HEADER)) ? header.size : Marshal.SizeOf(typeof(VBM_HEADER)));
this.m_header = header;
//memcpy(m_attrib, attrib_header, header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER)));
{
long offset = header.size;// +header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER));
f.Seek(offset, SeekOrigin.Begin);
}
this.m_attrib = new VBM_ATTRIB_HEADER[header.num_attribs];
for (int i = 0; i < header.num_attribs; i++)
{
this.m_attrib[i] = br.ReadStruct<VBM_ATTRIB_HEADER>();
}
//memcpy(m_frame, frame_header, header.num_frames * Marshal.SizeOf(typeof(VBM_FRAME_HEADER)));
{
long offset = header.size + header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER));// +header.num_frames * Marshal.SizeOf(typeof(VBM_FRAME_HEADER));
f.Seek(offset, SeekOrigin.Begin);
}
this.m_frame = new VBM_FRAME_HEADER[header.num_frames];
for (int i = 0; i < header.num_frames; i++)
{
this.m_frame[i] = br.ReadStruct<VBM_FRAME_HEADER>();
}
GL.GenVertexArrays(1, m_vao);
GL.BindVertexArray(m_vao[0]);
GL.GenBuffers(1, m_attribute_buffer);
GL.BindBuffer(BufferTarget.ArrayBuffer, m_attribute_buffer[0]);
//uint i;
for (uint i = 0; i < header.num_attribs; i++)
{
total_data_size += m_attrib[i].components * sizeof(float) * header.num_vertices;
}
{
long offset = header.size + header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER)) + header.num_frames * Marshal.SizeOf(typeof(VBM_FRAME_HEADER));
raw_data = new UnmanagedArray<byte>((int)total_data_size);
for (int i = 0; i < raw_data.Length; i++)
{
raw_data[i] = data[offset + i];
}
}
//GL.BufferData(GL_ARRAY_BUFFER, total_data_size, raw_data, GL_STATIC_DRAW);
GL.BufferData(BufferTarget.ArrayBuffer, raw_data, BufferUsage.StaticDraw);
total_data_size = 0;
for (uint i = 0; i < header.num_attribs; i++)
{
uint attribIndex = i;
if (attribIndex == 0)
attribIndex = (uint)vertexIndex;
else if (attribIndex == 1)
attribIndex = (uint)normalIndex;
else if (attribIndex == 2)
attribIndex = (uint)texCoord0Index;
GL.VertexAttribPointer(attribIndex, (int)m_attrib[i].components, m_attrib[i].type, false, 0, new IntPtr(total_data_size));
GL.EnableVertexAttribArray(attribIndex);
total_data_size += m_attrib[i].components * sizeof(float) * header.num_vertices;
}
if (header.num_indices > 0)
{
GL.GenBuffers(1, m_index_buffer);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, m_index_buffer[0]);
uint element_size;
if (header.indexype == 0x1403)
{
element_size = sizeof(ushort);
}
else
{
element_size = sizeof(uint);
}
//GL.BufferData(GL_ELEMENT_ARRAY_BUFFER, header.num_indices * element_size, raw_data + total_data_size, GL_STATIC_DRAW);
UnmanagedArray<byte> tmp = new UnmanagedArray<byte>((int)(header.num_indices * element_size));
for (int t = 0; t < tmp.Length; t++)
{
tmp[t] = raw_data[(int)(t + total_data_size)];
}
GL.BufferData(BufferTarget.ElementArrayBuffer, tmp, BufferUsage.StaticDraw);
tmp.Dispose();
}
GL.BindVertexArray(0);
if (m_header.num_materials != 0)
{
m_material = new VBM_MATERIAL[m_header.num_materials];
//memcpy(m_material, raw_data + total_data_size, m_header.num_materials * sizeof(VBM_MATERIAL));
{
var offset = header.size + total_data_size;
f.Seek(offset, SeekOrigin.Begin);
}
for (int t = 0; t < m_header.num_materials; t++)
{
m_material[t] = br.ReadStruct<VBM_MATERIAL>();
}
total_data_size += (uint)(m_header.num_materials * Marshal.SizeOf(typeof(VBM_MATERIAL)));
m_material_textures = new material_texture[m_header.num_materials];
//memset(m_material_textures, 0, m_header.num_materials * sizeof(*m_material_textures));
{
var offset = 0;
f.Seek(0, SeekOrigin.Begin);
}
for (int t = 0; t < m_header.num_materials; t++)
{
m_material_textures[t] = br.ReadStruct<material_texture>();
}
}
if (m_header.num_chunks != 0)
{
m_chunks = new VBM_RENDER_CHUNK[m_header.num_chunks];
//memcpy(m_chunks, raw_data + total_data_size, m_header.num_chunks * sizeof(VBM_RENDER_CHUNK));
{
var offset = m_header.size + total_data_size;
f.Seek(offset, SeekOrigin.Begin);
}
for (int t = 0; t < m_header.num_chunks; t++)
{
m_chunks[t] = br.ReadStruct<VBM_RENDER_CHUNK>();
}
//total_data_size += m_header.num_chunks * sizeof(VBM_RENDER_CHUNK);
}
raw_data.Dispose();
return true;
}
private void InitVAO()
{
this.axisPrimitiveMode = DrawMode.LineLoop;
this.axisVertexCount = 4;
this.vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray<vec3> positionArray = new UnmanagedArray<vec3>(4);
positionArray[0] = new vec3(-0.5f, -0.5f, 0);
positionArray[1] = new vec3(0.5f, -0.5f, 0);
positionArray[2] = new vec3(0.5f, 0.5f, 0);
positionArray[3] = new vec3(-0.5f, 0.5f, 0);
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
UnmanagedArray<vec3> colorArray = new UnmanagedArray<vec3>(4);
vec3 color = this.rectColor;
for (int i = 0; i < colorArray.Length; i++)
{
colorArray[i] = color;
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
private void InitVAO()
{
this.axisPrimitiveMode = DrawMode.Lines;
this.axisVertexCount = 8 * 3;
this.vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray <vec3> positionArray = new UnmanagedArray <vec3>(8 * 3);
const float halfLength = 0.5f;
// x axis
positionArray[0] = new vec3(-halfLength, -halfLength, -halfLength);
positionArray[1] = new vec3(halfLength, -halfLength, -halfLength);
positionArray[2] = new vec3(-halfLength, -halfLength, halfLength);
positionArray[3] = new vec3(halfLength, -halfLength, halfLength);
positionArray[4] = new vec3(-halfLength, halfLength, halfLength);
positionArray[5] = new vec3(halfLength, halfLength, halfLength);
positionArray[6] = new vec3(-halfLength, halfLength, -halfLength);
positionArray[7] = new vec3(halfLength, halfLength, -halfLength);
// y axis
positionArray[8 + 0] = new vec3(-halfLength, -halfLength, -halfLength);
positionArray[8 + 1] = new vec3(-halfLength, halfLength, -halfLength);
positionArray[8 + 2] = new vec3(-halfLength, -halfLength, halfLength);
positionArray[8 + 3] = new vec3(-halfLength, halfLength, halfLength);
positionArray[8 + 4] = new vec3(halfLength, -halfLength, halfLength);
positionArray[8 + 5] = new vec3(halfLength, halfLength, halfLength);
positionArray[8 + 6] = new vec3(halfLength, -halfLength, -halfLength);
positionArray[8 + 7] = new vec3(halfLength, halfLength, -halfLength);
// z axis
positionArray[16 + 0] = new vec3(-halfLength, -halfLength, -halfLength);
positionArray[16 + 1] = new vec3(-halfLength, -halfLength, halfLength);
positionArray[16 + 2] = new vec3(-halfLength, halfLength, -halfLength);
positionArray[16 + 3] = new vec3(-halfLength, halfLength, halfLength);
positionArray[16 + 4] = new vec3(halfLength, halfLength, -halfLength);
positionArray[16 + 5] = new vec3(halfLength, halfLength, halfLength);
positionArray[16 + 6] = new vec3(halfLength, -halfLength, -halfLength);
positionArray[16 + 7] = new vec3(halfLength, -halfLength, halfLength);
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
UnmanagedArray <vec3> colorArray = new UnmanagedArray <vec3>(8 * 3);
vec3[] colors = new vec3[] { new vec3(1, 0, 0), new vec3(0, 1, 0), new vec3(0, 0, 1), };
for (int i = 0; i < colorArray.Length; i++)
{
colorArray[i] = colors[i / 8];
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
protected void InitializeVAO()
{
this.axisPrimitiveMode = DrawMode.QuadStrip; //PrimitiveModes.QuadStrip;
this.axisVertexCount = faceCount * 2;
this.vao = new uint[4];
GL.GenVertexArrays(4, vao);
vec3[] colors = new vec3[] { new vec3(1, 0, 0), new vec3(0, 1, 0), new vec3(0, 0, 1) };
// 计算三个坐标轴
for (int axisIndex = 0; axisIndex < 3; axisIndex++)
{
GL.BindVertexArray(vao[axisIndex]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray <vec3> positionArray = new UnmanagedArray <vec3>(faceCount * 2);
for (int i = 0; i < faceCount * 2; i++)
{
int face = i / 2;
float[] components = new float[] {
i % 2 == 1 ? 0 : this.axisLength,
(float)(this.radius * Math.Cos(face * (Math.PI * 2) / faceCount)),
(float)(this.radius * Math.Sin(face * (Math.PI * 2) / faceCount))
};
positionArray[i] = new vec3(
components[(0 + axisIndex) % 3], components[(2 + axisIndex) % 3], components[(4 + axisIndex) % 3]);
}
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
UnmanagedArray <vec3> colorArray = new UnmanagedArray <vec3>(faceCount * 2);
for (int i = 0; i < colorArray.Length; i++)
{
colorArray[i] = colors[axisIndex];
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
{
UnmanagedArray <uint> cylinderIndex = new UnmanagedArray <uint>(faceCount * 2 + 2);
for (int i = 0; i < cylinderIndex.Length - 2; i++)
{
cylinderIndex[i] = (uint)i;
}
cylinderIndex[cylinderIndex.Length - 2] = 0;
cylinderIndex[cylinderIndex.Length - 1] = 1;
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ElementArrayBuffer, cylinderIndex, BufferUsage.StaticDraw);
cylinderIndex.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
// 计算XZ平面
{
this.planPrimitveMode = DrawMode.LineLoop;
var lanVertexCount = 4;
GL.BindVertexArray(vao[3]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray <vec3> plan = new UnmanagedArray <vec3>(lanVertexCount);
float length = this.axisLength;
plan[0] = new vec3(-length, 0, -length);
plan[1] = new vec3(-length, 0, length);
plan[2] = new vec3(length, 0, length);
plan[3] = new vec3(length, 0, -length);
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, plan, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
plan.Dispose();
}
// Now do the same for the colour data.
{
UnmanagedArray <vec3> colorArray = new UnmanagedArray <vec3>(4);
for (int i = 0; i < colorArray.Length; i++)
{
colorArray[i] = this.planColor;
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
}
} // end sub
#endregion
protected override void DoInitialize()
{
render_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(render_prog, ShaderType.VertexShader, render_vs);
ShaderHelper.vglAttachShaderSource(render_prog, ShaderType.FragmentShader, render_fs);
GL.LinkProgram(render_prog);
GL.UseProgram(render_prog);
view_matrix_loc = GL.GetUniformLocation(render_prog, "view_matrix");
projection_matrix_loc = GL.GetUniformLocation(render_prog, "projection_matrix");
vboObject.LoadFromVBM(@"media\armadillo_low.vbm", 0, 1, 2);
// Bind its vertex array object so that we can append the instanced attributes
vboObject.BindVertexArray();
// Get the locations of the vertex attributes in 'prog', which is the
// (linked) program object that we're going to be rendering with. Note
// that this isn't really necessary because we specified locations for
// all the attributes in our vertex shader. This code could be made
// more concise by assuming the vertex attributes are where we asked
// the compiler to put them.
int position_loc = GL.GetAttribLocation(render_prog, "position");
int normal_loc = GL.GetAttribLocation(render_prog, "normal");
int color_loc = GL.GetAttribLocation(render_prog, "color");
int matrix_loc = GL.GetAttribLocation(render_prog, "model_matrix");
// Generate the colors of the objects
var colors = new UnmanagedArray <vec4>(INSTANCE_COUNT);
for (int n = 0; n < INSTANCE_COUNT; n++)
{
float a = (float)(n) / 4.0f;
float b = (float)(n) / 5.0f;
float c = (float)(n) / 6.0f;
colors[n] = new vec4(
(float)(0.5f + 0.25f * (Math.Sin(a + 1.0f) + 1.0f)),
(float)(0.5f + 0.25f * (Math.Sin(b + 2.0f) + 1.0f)),
(float)(0.5f + 0.25f * (Math.Sin(c + 3.0f) + 1.0f)),
(float)(1.0f)
);
}
GL.GenBuffers(1, color_buffer);
GL.BindBuffer(BufferTarget.ArrayBuffer, color_buffer[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colors, BufferUsage.DynamicDraw);
colors.Dispose();
// Now we set up the color array. We want each instance of our geometry
// to assume a different color, so we'll just pack colors into a buffer
// object and make an instanced vertex attribute out of it.
GL.BindBuffer(BufferTarget.ArrayBuffer, color_buffer[0]);
GL.VertexAttribPointer((uint)color_loc, 4, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray((uint)color_loc);
// This is the important bit... set the divisor for the color array to
// 1 to get OpenGL to give us a new value of 'color' per-instance
// rather than per-vertex.
GL.VertexAttribDivisor((uint)color_loc, 1);
// Likewise, we can do the same with the model matrix. Note that a
// matrix input to the vertex shader consumes N consecutive input
// locations, where N is the number of columns in the matrix. So...
// we have four vertex attributes to set up.
UnmanagedArray <mat4> tmp = new UnmanagedArray <mat4>(INSTANCE_COUNT);
GL.GenBuffers(1, model_matrix_buffer);
GL.BindBuffer(BufferTarget.ArrayBuffer, model_matrix_buffer[0]);
GL.BufferData(BufferTarget.ArrayBuffer, tmp, BufferUsage.DynamicDraw);
tmp.Dispose();
// Loop over each column of the matrix...
for (int i = 0; i < 4; i++)
{
// Set up the vertex attribute
GL.VertexAttribPointer((uint)(matrix_loc + i), // Location
4, GL.GL_FLOAT, false, // vec4
Marshal.SizeOf(typeof(mat4)), // Stride
new IntPtr(Marshal.SizeOf(typeof(vec4)) * i)); // Start offset
// Enable it
GL.EnableVertexAttribArray((uint)(matrix_loc + i));
// Make it instanced
GL.VertexAttribDivisor((uint)(matrix_loc + i), 1);
}
// Done (unbind the object's VAO)
GL.BindVertexArray(0);
}
private void InitVAO()
{
this.axisPrimitiveMode = DrawMode.QuadStrip;
GLColor[] colors = this.ColorPalette.Colors;
float[] coords = this.ColorPalette.Coords;
this.numbers = new PointSpriteStringElement[coords.Length];
this.vertexCount = coords.Length * 2;
this.vao = new uint[1];
float coordLength = coords[coords.Length - 1] - coords[0];
{
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray<vec3> positionArray = new UnmanagedArray<vec3>(this.vertexCount);
positionArray[0] = new vec3(-0.5f, -0.5f, 0);
positionArray[1] = new vec3(-0.5f, 0.5f, 0);
for (int i = 1; i < coords.Length; i++)
{
float x = (coords[i] - coords[0]) / coordLength - 0.5f;
positionArray[i * 2 + 0] = new vec3(x, -0.5f, 0);
positionArray[i * 2 + 1] = new vec3(x, 0.5f, 0);
}
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_PositionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_PositionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
var colorArray = new UnmanagedArray<vec4>(this.vertexCount);
for (int i = 0; i < colors.Length; i++)
{
GLColor color = colors[i];
colorArray[i * 2 + 0] = new vec4(color.R, color.G, color.B, color.A);
colorArray[i * 2 + 1] = new vec4(color.R, color.G, color.B, color.A);
}
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_ColorLocation, 4, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_ColorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
// prepare numbers
{
const float numberPosY = -0.6f;
this.numbers[0] = new PointSpriteStringElement(
this.Min.ToShortString(), new vec3(-0.5f, numberPosY, 0));
this.numbers[0].Initialize();
for (int i = 1; i < coords.Length; i++)
{
float x = (coords[i] - coords[0]) / coordLength - 0.5f;
if (i + 1 == coords.Length)
{
this.numbers[i] = new PointSpriteStringElement(
(this.Min + i * this.Step).ToShortString(), new vec3(x, numberPosY, 0));
}
else
{
this.numbers[i] = new PointSpriteStringElement(
this.Max.ToShortString(), new vec3(x, numberPosY, 0));
}
this.numbers[i].Initialize();
}
}
}
private void InitVAO()
{
this.axisPrimitiveMode = DrawMode.Lines;
this.axisVertexCount = 8 * 3;
this.vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray<vec3> positionArray = new UnmanagedArray<vec3>(8 * 3);
const float halfLength = 0.5f;
// x axis
positionArray[0] = new vec3(-halfLength, -halfLength, -halfLength);
positionArray[1] = new vec3(halfLength, -halfLength, -halfLength);
positionArray[2] = new vec3(-halfLength, -halfLength, halfLength);
positionArray[3] = new vec3(halfLength, -halfLength, halfLength);
positionArray[4] = new vec3(-halfLength, halfLength, halfLength);
positionArray[5] = new vec3(halfLength, halfLength, halfLength);
positionArray[6] = new vec3(-halfLength, halfLength, -halfLength);
positionArray[7] = new vec3(halfLength, halfLength, -halfLength);
// y axis
positionArray[8 + 0] = new vec3(-halfLength, -halfLength, -halfLength);
positionArray[8 + 1] = new vec3(-halfLength, halfLength, -halfLength);
positionArray[8 + 2] = new vec3(-halfLength, -halfLength, halfLength);
positionArray[8 + 3] = new vec3(-halfLength, halfLength, halfLength);
positionArray[8 + 4] = new vec3(halfLength, -halfLength, halfLength);
positionArray[8 + 5] = new vec3(halfLength, halfLength, halfLength);
positionArray[8 + 6] = new vec3(halfLength, -halfLength, -halfLength);
positionArray[8 + 7] = new vec3(halfLength, halfLength, -halfLength);
// z axis
positionArray[16 + 0] = new vec3(-halfLength, -halfLength, -halfLength);
positionArray[16 + 1] = new vec3(-halfLength, -halfLength, halfLength);
positionArray[16 + 2] = new vec3(-halfLength, halfLength, -halfLength);
positionArray[16 + 3] = new vec3(-halfLength, halfLength, halfLength);
positionArray[16 + 4] = new vec3(halfLength, halfLength, -halfLength);
positionArray[16 + 5] = new vec3(halfLength, halfLength, halfLength);
positionArray[16 + 6] = new vec3(halfLength, -halfLength, -halfLength);
positionArray[16 + 7] = new vec3(halfLength, -halfLength, halfLength);
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
UnmanagedArray<vec3> colorArray = new UnmanagedArray<vec3>(8 * 3);
vec3[] colors = new vec3[] { new vec3(1, 0, 0), new vec3(0, 1, 0), new vec3(0, 0, 1), };
for (int i = 0; i < colorArray.Length; i++)
{
colorArray[i] = colors[i / 8];
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
protected override void DoInitialize()
{
// Initialize our compute program
compute_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(compute_prog, ShaderType.ComputerShader, compute_shader_source);
GL.LinkProgram(compute_prog);
dt_location = GL.GetUniformLocation(compute_prog, "dt");
GL.GenVertexArrays(1, render_vao);
GL.BindVertexArray(render_vao[0]);
GL.GenBuffers(2, buffers);
{
GL.BindBuffer(BufferTarget.ArrayBuffer, buffers[0]);//position buffer
UnmanagedArray<vec4> tmp = new UnmanagedArray<vec4>(PARTICLE_COUNT);
GL.BufferData(BufferTarget.ArrayBuffer, tmp, BufferUsage.DynamicCopy);
tmp.Dispose();
IntPtr positions = GL.MapBufferRange(GL.GL_ARRAY_BUFFER,
0, PARTICLE_COUNT * Marshal.SizeOf(typeof(vec4)), GL.GL_MAP_WRITE_BIT | GL.GL_MAP_INVALIDATE_BUFFER_BIT);
unsafe
{
vec4* array = (vec4*)positions.ToPointer();
for (int i = 0; i < PARTICLE_COUNT; i++)
{
array[i] = new vec4(Vec3Helper.GetRandomVec3(), (float)random.NextDouble());
}
}
GL.UnmapBuffer(BufferTarget.ArrayBuffer);
GL.VertexAttribPointer(0, 4, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(0);
}
{
GL.BindBuffer(BufferTarget.ArrayBuffer, buffers[1]);// velocity buffer
UnmanagedArray<vec4> tmp = new UnmanagedArray<vec4>(PARTICLE_COUNT);
GL.BufferData(BufferTarget.ArrayBuffer, tmp, BufferUsage.DynamicCopy);
tmp.Dispose();
IntPtr velocities = GL.MapBufferRange(GL.GL_ARRAY_BUFFER,
0, PARTICLE_COUNT * Marshal.SizeOf(typeof(vec4)), GL.GL_MAP_WRITE_BIT | GL.GL_MAP_INVALIDATE_BUFFER_BIT);
unsafe
{
vec4* array = (vec4*)velocities.ToPointer();
for (int i = 0; i < PARTICLE_COUNT; i++)
{
array[i] = new vec4(Vec3Helper.GetRandomVec3(), (float)random.NextDouble());
}
}
GL.UnmapBuffer(BufferTarget.ArrayBuffer);
}
{
GL.GenTextures(2, tbos);
for (int i = 0; i < 2; i++)
{
GL.BindTexture(GL.GL_TEXTURE_BUFFER, tbos[i]);
GL.TexBuffer(GL.GL_TEXTURE_BUFFER, GL.GL_RGBA32F, buffers[i]);
}
}
{
GL.GenBuffers(1, attractor_buffer);
GL.BindBuffer(BufferTarget.UniformBuffer, attractor_buffer[0]);
UnmanagedArray<vec4> tmp = new UnmanagedArray<vec4>(32);
GL.BufferData(BufferTarget.UniformBuffer, tmp, BufferUsage.StaticDraw);
tmp.Dispose();
for (int i = 0; i < MAX_ATTRACTORS; i++)
{
attractor_masses[i] = 0.5f + (float)random.NextDouble() * 0.5f;
}
GL.BindBufferBase(TransformFeedbackBufferTarget.UniformBuffer, 0, attractor_buffer[0]);
}
{
render_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(render_prog, ShaderType.VertexShader, render_vs);
ShaderHelper.vglAttachShaderSource(render_prog, ShaderType.FragmentShader, render_fs);
GL.LinkProgram(render_prog);
}
}
internal void LoadSoundInMemory()
{
if (PreloadedBuffer.Ptr != IntPtr.Zero) return;
using (var soundStream = ContentManager.FileProvider.OpenStream(CompressedDataUrl, VirtualFileMode.Open, VirtualFileAccess.Read, VirtualFileShare.Read, StreamFlags.Seekable))
using (var decoder = new Celt(SampleRate, CompressedSoundSource.SamplesPerFrame, Channels, true))
{
var reader = new BinarySerializationReader(soundStream);
var samplesPerPacket = CompressedSoundSource.SamplesPerFrame * Channels;
PreloadedBuffer = AudioLayer.BufferCreate(samplesPerPacket * NumberOfPackets * sizeof(short));
var memory = new UnmanagedArray<short>(samplesPerPacket * NumberOfPackets);
var offset = 0;
var outputBuffer = new short[samplesPerPacket];
for (var i = 0; i < NumberOfPackets; i++)
{
var len = reader.ReadInt16();
var compressedBuffer = reader.ReadBytes(len);
var samplesDecoded = decoder.Decode(compressedBuffer, len, outputBuffer);
memory.Write(outputBuffer, offset, 0, samplesDecoded * Channels);
offset += samplesDecoded * Channels * sizeof(short);
}
AudioLayer.BufferFill(PreloadedBuffer, memory.Pointer, memory.Length * sizeof(short), SampleRate, Channels == 1);
memory.Dispose();
}
}
protected override void DoInitialize()
{
render_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(render_prog, ShaderType.VertexShader, render_vs);
ShaderHelper.vglAttachShaderSource(render_prog, ShaderType.FragmentShader, render_fs);
GL.LinkProgram(render_prog);
GL.UseProgram(render_prog);
view_matrix_loc = GL.GetUniformLocation(render_prog, "view_matrix");
projection_matrix_loc = GL.GetUniformLocation(render_prog, "projection_matrix");
vboObject.LoadFromVBM(@"media\armadillo_low.vbm", 0, 1, 2);
// Bind its vertex array object so that we can append the instanced attributes
vboObject.BindVertexArray();
// Get the locations of the vertex attributes in 'prog', which is the
// (linked) program object that we're going to be rendering with. Note
// that this isn't really necessary because we specified locations for
// all the attributes in our vertex shader. This code could be made
// more concise by assuming the vertex attributes are where we asked
// the compiler to put them.
int position_loc = GL.GetAttribLocation(render_prog, "position");
int normal_loc = GL.GetAttribLocation(render_prog, "normal");
int color_loc = GL.GetAttribLocation(render_prog, "color");
int matrix_loc = GL.GetAttribLocation(render_prog, "model_matrix");
// Generate the colors of the objects
var colors = new UnmanagedArray<vec4>(INSTANCE_COUNT);
for (int n = 0; n < INSTANCE_COUNT; n++)
{
float a = (float)(n) / 4.0f;
float b = (float)(n) / 5.0f;
float c = (float)(n) / 6.0f;
colors[n] = new vec4(
(float)(0.5f + 0.25f * (Math.Sin(a + 1.0f) + 1.0f)),
(float)(0.5f + 0.25f * (Math.Sin(b + 2.0f) + 1.0f)),
(float)(0.5f + 0.25f * (Math.Sin(c + 3.0f) + 1.0f)),
(float)(1.0f)
);
}
GL.GenBuffers(1, color_buffer);
GL.BindBuffer(BufferTarget.ArrayBuffer, color_buffer[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colors, BufferUsage.DynamicDraw);
colors.Dispose();
// Now we set up the color array. We want each instance of our geometry
// to assume a different color, so we'll just pack colors into a buffer
// object and make an instanced vertex attribute out of it.
GL.BindBuffer(BufferTarget.ArrayBuffer, color_buffer[0]);
GL.VertexAttribPointer((uint)color_loc, 4, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray((uint)color_loc);
// This is the important bit... set the divisor for the color array to
// 1 to get OpenGL to give us a new value of 'color' per-instance
// rather than per-vertex.
GL.VertexAttribDivisor((uint)color_loc, 1);
// Likewise, we can do the same with the model matrix. Note that a
// matrix input to the vertex shader consumes N consecutive input
// locations, where N is the number of columns in the matrix. So...
// we have four vertex attributes to set up.
UnmanagedArray<mat4> tmp = new UnmanagedArray<mat4>(INSTANCE_COUNT);
GL.GenBuffers(1, model_matrix_buffer);
GL.BindBuffer(BufferTarget.ArrayBuffer, model_matrix_buffer[0]);
GL.BufferData(BufferTarget.ArrayBuffer, tmp, BufferUsage.DynamicDraw);
tmp.Dispose();
// Loop over each column of the matrix...
for (int i = 0; i < 4; i++)
{
// Set up the vertex attribute
GL.VertexAttribPointer((uint)(matrix_loc + i), // Location
4, GL.GL_FLOAT, false, // vec4
Marshal.SizeOf(typeof(mat4)), // Stride
new IntPtr(Marshal.SizeOf(typeof(vec4)) * i)); // Start offset
// Enable it
GL.EnableVertexAttribArray((uint)(matrix_loc + i));
// Make it instanced
GL.VertexAttribDivisor((uint)(matrix_loc + i), 1);
}
// Done (unbind the object's VAO)
GL.BindVertexArray(0);
}
private void InitVAO(string value)
{
if (value == null) { value = string.Empty; }
this.mode = DrawMode.Quads;
this.vertexCount = 4 * value.Length;
// Create a vertex buffer for the vertex data.
UnmanagedArray<vec3> in_Position = new UnmanagedArray<vec3>(this.vertexCount);
UnmanagedArray<vec2> in_TexCoord = new UnmanagedArray<vec2>(this.vertexCount);
Bitmap bigBitmap = this.ttfTexture.BigBitmap;
// step 1: set width for each glyph
vec3[] tmpPositions = new vec3[this.vertexCount];
float totalLength = 0;
for (int i = 0; i < value.Length; i++)
{
char c = value[i];
CharacterInfo cInfo;
if (this.ttfTexture.CharInfoDict.TryGetValue(c, out cInfo))
{
float glyphWidth = (float)cInfo.width / (float)this.ttfTexture.FontHeight;
if (i == 0)
{
tmpPositions[i * 4 + 0] = new vec3(0, 0, 0);
tmpPositions[i * 4 + 1] = new vec3(glyphWidth, 0, 0);
tmpPositions[i * 4 + 2] = new vec3(glyphWidth, 1, 0);
tmpPositions[i * 4 + 3] = new vec3(0, 1, 0);
}
else
{
tmpPositions[i * 4 + 0] = tmpPositions[i * 4 + 0 - 4 + 1];
tmpPositions[i * 4 + 1] = tmpPositions[i * 4 + 0] + new vec3(glyphWidth, 0, 0);
tmpPositions[i * 4 + 3] = tmpPositions[i * 4 + 3 - 4 - 1];
tmpPositions[i * 4 + 2] = tmpPositions[i * 4 + 3] + new vec3(glyphWidth, 0, 0);
}
totalLength += glyphWidth;
}
//else
//{ throw new Exception(string.Format("Not support for display the char [{0}]", c)); }
}
for (int i = 0; i < value.Length; i++)
{
char c = value[i];
CharacterInfo cInfo;
float x1 = 0;
float x2 = 1;
float y1 = 0;
float y2 = 1;
if (this.ttfTexture.CharInfoDict.TryGetValue(c, out cInfo))
{
x1 = (float)cInfo.xoffset / (float)bigBitmap.Width;
x2 = (float)(cInfo.xoffset + cInfo.width) / (float)bigBitmap.Width;
y1 = (float)cInfo.yoffset / (float)bigBitmap.Height;
y2 = (float)(cInfo.yoffset + this.ttfTexture.FontHeight) / (float)bigBitmap.Height;
}
//else
//{ throw new Exception(string.Format("Not support for display the char [{0}]", c)); }
in_Position[i * 4 + 0] = tmpPositions[i * 4 + 0] - new vec3(totalLength / 2, 0, 0);
in_Position[i * 4 + 1] = tmpPositions[i * 4 + 1] - new vec3(totalLength / 2, 0, 0);
in_Position[i * 4 + 2] = tmpPositions[i * 4 + 2] - new vec3(totalLength / 2, 0, 0);
in_Position[i * 4 + 3] = tmpPositions[i * 4 + 3] - new vec3(totalLength / 2, 0, 0);
//in_TexCoord[i * 4 + 0] = new vec2(x1, y1);
//in_TexCoord[i * 4 + 1] = new vec2(x2, y1);
//in_TexCoord[i * 4 + 2] = new vec2(x2, y2);
//in_TexCoord[i * 4 + 3] = new vec2(x1, y2);
in_TexCoord[i * 4 + 0] = new vec2(x1, y2);
in_TexCoord[i * 4 + 1] = new vec2(x2, y2);
in_TexCoord[i * 4 + 2] = new vec2(x2, y1);
in_TexCoord[i * 4 + 3] = new vec2(x1, y1);
}
if (vao[0] != 0)
{ GL.DeleteBuffers(1, vao); }
if (vbo[0] != 0)
{ GL.DeleteBuffers(vbo.Length, vbo); }
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
GL.GenBuffers(2, vbo);
uint in_PositionLocation = shaderProgram.GetAttributeLocation(strin_Position);
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo[0]);
GL.BufferData(BufferTarget.ArrayBuffer, in_Position, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_PositionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_PositionLocation);
uint in_TexCoordLocation = shaderProgram.GetAttributeLocation(strin_TexCoord);
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo[1]);
GL.BufferData(BufferTarget.ArrayBuffer, in_TexCoord, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_TexCoordLocation, 2, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_TexCoordLocation);
GL.BindVertexArray(0);
in_Position.Dispose();
in_TexCoord.Dispose();
}
private void InitVAO()
{
// reserve a vertex array object(VAO) 预约一个VAO
this.vertexArrayObject = new uint[1];
GL.GenVertexArrays(1, this.vertexArrayObject);
// prepare vertex buffer object(VBO) for vertexes' positions 为顶点位置准备VBO
uint[] positionBufferObject = new uint[1];
{
// specify position array
var positionArray = new UnmanagedArray <vec3>(vertexCount);
positionArray[0] = new vec3(0.0f, 1.0f, 0.0f);
positionArray[1] = new vec3(-1.0f, -1.0f, 1.0f);
positionArray[2] = new vec3(1.0f, -1.0f, 1.0f);
positionArray[3] = new vec3(0.0f, 1.0f, 0.0f);
positionArray[4] = new vec3(1.0f, -1.0f, 1.0f);
positionArray[5] = new vec3(1.0f, -1.0f, -1.0f);
positionArray[6] = new vec3(0.0f, 1.0f, 0.0f);
positionArray[7] = new vec3(1.0f, -1.0f, -1.0f);
positionArray[8] = new vec3(-1.0f, -1.0f, -1.0f);
positionArray[9] = new vec3(0.0f, 1.0f, 0.0f);
positionArray[10] = new vec3(-1.0f, -1.0f, -1.0f);
positionArray[11] = new vec3(-1.0f, -1.0f, 1.0f);
// put positions into VBO
GL.GenBuffers(1, positionBufferObject);
GL.BindBuffer(BufferTarget.ArrayBuffer, positionBufferObject[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
positionArray.Dispose();
}
// prepare vertex buffer object(VBO) for vertexes' colors
uint[] colorBufferObject = new uint[1];
{
// specify color array
UnmanagedArray <vec3> colorArray = new UnmanagedArray <vec3>(vertexCount);
colorArray[0] = new vec3(1.0f, 0.0f, 0.0f);
colorArray[1] = new vec3(0.0f, 1.0f, 0.0f);
colorArray[2] = new vec3(0.0f, 0.0f, 1.0f);
colorArray[3] = new vec3(1.0f, 0.0f, 0.0f);
colorArray[4] = new vec3(0.0f, 0.0f, 1.0f);
colorArray[5] = new vec3(0.0f, 1.0f, 0.0f);
colorArray[6] = new vec3(1.0f, 0.0f, 0.0f);
colorArray[7] = new vec3(0.0f, 1.0f, 0.0f);
colorArray[8] = new vec3(0.0f, 0.0f, 1.0f);
colorArray[9] = new vec3(1.0f, 0.0f, 0.0f);
colorArray[10] = new vec3(0.0f, 0.0f, 1.0f);
colorArray[11] = new vec3(0.0f, 1.0f, 0.0f);
// put colors into VBO
GL.GenBuffers(1, colorBufferObject);
GL.BindBuffer(BufferTarget.ArrayBuffer, colorBufferObject[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
colorArray.Dispose();
}
uint positionLocation = shaderProgram.GetAttributeLocation("in_Position");
uint colorLocation = shaderProgram.GetAttributeLocation("in_Color");
{
// bind the vertex array object(VAO), we are going to specify data for it.
GL.BindVertexArray(vertexArrayObject[0]);
// specify vertexes' positions
GL.BindBuffer(BufferTarget.ArrayBuffer, positionBufferObject[0]);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
// specify vertexes' colors
GL.BindBuffer(BufferTarget.ArrayBuffer, colorBufferObject[0]);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
// Unbind the vertex array object(VAO), we've finished specifying data for it.
GL.BindVertexArray(0);
}
}
private void InitVAO(string value)
{
if (value == null)
{
value = string.Empty;
}
this.mode = DrawMode.Quads;
this.vertexCount = 4 * value.Length;
// Create a vertex buffer for the vertex data.
UnmanagedArray <vec3> in_Position = new UnmanagedArray <vec3>(this.vertexCount);
UnmanagedArray <vec2> in_TexCoord = new UnmanagedArray <vec2>(this.vertexCount);
Bitmap bigBitmap = this.ttfTexture.BigBitmap;
// step 1: set width for each glyph
vec3[] tmpPositions = new vec3[this.vertexCount];
float totalLength = 0;
for (int i = 0; i < value.Length; i++)
{
char c = value[i];
CharacterInfo cInfo;
if (this.ttfTexture.CharInfoDict.TryGetValue(c, out cInfo))
{
float glyphWidth = (float)cInfo.width / (float)this.ttfTexture.FontHeight;
if (i == 0)
{
tmpPositions[i * 4 + 0] = new vec3(0, 0, 0);
tmpPositions[i * 4 + 1] = new vec3(glyphWidth, 0, 0);
tmpPositions[i * 4 + 2] = new vec3(glyphWidth, 1, 0);
tmpPositions[i * 4 + 3] = new vec3(0, 1, 0);
}
else
{
tmpPositions[i * 4 + 0] = tmpPositions[i * 4 + 0 - 4 + 1];
tmpPositions[i * 4 + 1] = tmpPositions[i * 4 + 0] + new vec3(glyphWidth, 0, 0);
tmpPositions[i * 4 + 3] = tmpPositions[i * 4 + 3 - 4 - 1];
tmpPositions[i * 4 + 2] = tmpPositions[i * 4 + 3] + new vec3(glyphWidth, 0, 0);
}
totalLength += glyphWidth;
}
//else
//{ throw new Exception(string.Format("Not support for display the char [{0}]", c)); }
}
for (int i = 0; i < value.Length; i++)
{
char c = value[i];
CharacterInfo cInfo;
float x1 = 0;
float x2 = 1;
float y1 = 0;
float y2 = 1;
if (this.ttfTexture.CharInfoDict.TryGetValue(c, out cInfo))
{
x1 = (float)cInfo.xoffset / (float)bigBitmap.Width;
x2 = (float)(cInfo.xoffset + cInfo.width) / (float)bigBitmap.Width;
y1 = (float)cInfo.yoffset / (float)bigBitmap.Height;
y2 = (float)(cInfo.yoffset + this.ttfTexture.FontHeight) / (float)bigBitmap.Height;
}
//else
//{ throw new Exception(string.Format("Not support for display the char [{0}]", c)); }
in_Position[i * 4 + 0] = tmpPositions[i * 4 + 0] - new vec3(totalLength / 2, 0, 0);
in_Position[i * 4 + 1] = tmpPositions[i * 4 + 1] - new vec3(totalLength / 2, 0, 0);
in_Position[i * 4 + 2] = tmpPositions[i * 4 + 2] - new vec3(totalLength / 2, 0, 0);
in_Position[i * 4 + 3] = tmpPositions[i * 4 + 3] - new vec3(totalLength / 2, 0, 0);
//in_TexCoord[i * 4 + 0] = new vec2(x1, y1);
//in_TexCoord[i * 4 + 1] = new vec2(x2, y1);
//in_TexCoord[i * 4 + 2] = new vec2(x2, y2);
//in_TexCoord[i * 4 + 3] = new vec2(x1, y2);
in_TexCoord[i * 4 + 0] = new vec2(x1, y2);
in_TexCoord[i * 4 + 1] = new vec2(x2, y2);
in_TexCoord[i * 4 + 2] = new vec2(x2, y1);
in_TexCoord[i * 4 + 3] = new vec2(x1, y1);
}
if (vao[0] != 0)
{
GL.DeleteBuffers(1, vao);
}
if (vbo[0] != 0)
{
GL.DeleteBuffers(vbo.Length, vbo);
}
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
GL.GenBuffers(2, vbo);
uint in_PositionLocation = shaderProgram.GetAttributeLocation(strin_Position);
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo[0]);
GL.BufferData(BufferTarget.ArrayBuffer, in_Position, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_PositionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_PositionLocation);
uint in_TexCoordLocation = shaderProgram.GetAttributeLocation(strin_TexCoord);
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo[1]);
GL.BufferData(BufferTarget.ArrayBuffer, in_TexCoord, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_TexCoordLocation, 2, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_TexCoordLocation);
GL.BindVertexArray(0);
in_Position.Dispose();
in_TexCoord.Dispose();
}
private void scientificVisual3DControl_KeyPress(object sender, KeyPressEventArgs e)
{
if (e.KeyChar == 'r')
{
// 随机显示某些hexahedron
foreach (var item in this.scientificVisual3DControl.ModelContainer.Children)
{
{
HexahedronGridderElement element = item as HexahedronGridderElement;
if (element != null)
{
YieldingGeometryModel.Builder.HexahedronGridderElementHelper.RandomVisibility(element, this.scientificVisual3DControl.OpenGL, 0.2);
}
}
{
PointSpriteGridderElement element = item as PointSpriteGridderElement;
if (element != null)
{
YieldingGeometryModel.Builder.PointSpriteGridderElementHelper.RandomVisibility(element, this.scientificVisual3DControl.OpenGL, 0.2);
}
}
}
this.scientificVisual3DControl.Invalidate();
}
if (e.KeyChar == 'c')
{
OpenGL gl = this.scientificVisual3DControl.OpenGL;
List <HexahedronGridderElement> elements = this.scientificVisual3DControl.ModelContainer.Traverse <HexahedronGridderElement>().ToList <HexahedronGridderElement>();
if (elements.Count > 0)
{
HexahedronGridderElement gridder = elements[0];
HexahedronGridderSource source = gridder.Source;
UnmanagedArray <float> visibles = HexahedronGridderHelper.GridVisibleFromActive(source);
//随机生成不完整网格的属性。
int propCount = source.DimenSize / 2;
if (propCount <= 0)
{
return;
}
int minValue = 5000;
int maxValue = 10000;
int[] gridIndexes;
float[] gridValues;
HexahedronGridderHelper.RandomValue(propCount, minValue, maxValue, out gridIndexes, out gridValues);
float step = (maxValue - minValue) / 10.0f;
this.scientificVisual3DControl.SetColorIndicator(minValue, maxValue, step);
ColorF[] colors = new ColorF[propCount];
for (int i = 0; i < colors.Length; i++)
{
colors[i] = (ColorF)this.scientificVisual3DControl.MapToColor(gridValues[i]);
}
UnmanagedArray <ColorF> colorArray = HexahedronGridderHelper.FromColors(source, gridIndexes, colors, visibles);
gridder.UpdateColorBuffer(gl, colorArray, visibles);
colorArray.Dispose();
visibles.Dispose();
this.scientificVisual3DControl.Invalidate();
}
}
}
internal static void TypicalScene()
{
// 数组较小时可按此方法使用UnmanagedArray，数组较大时请参考UnmanagedArrayHelper。
const int count = 100;
// 测试float类型
{
var floatArray = new UnmanagedArray<float>(count);
for (int i = 0; i < count; i++)
{
floatArray[i] = i;
}
for (int i = 0; i < count; i++)
{
var item = floatArray[i];
if (item != i)
{ throw new Exception(); }
}
}
// 测试decimal类型
{
var decimalArray = new UnmanagedArray<decimal>(count);
for (int i = 0; i < count; i++)
{
decimalArray[i] = i;
}
for (int i = 0; i < count; i++)
{
var item = decimalArray[i];
if (item != i)
{ throw new Exception(); }
}
}
// 测试int类型
{
var intArray = new UnmanagedArray<int>(count);
for (int i = 0; i < count; i++)
{
intArray[i] = i;
}
for (int i = 0; i < count; i++)
{
var item = intArray[i];
if (item != i)
{ throw new Exception(); }
}
}
// 测试bool类型
{
var boolArray = new UnmanagedArray<bool>(count);
for (int i = 0; i < count; i++)
{
boolArray[i] = i % 2 == 0;
}
for (int i = 0; i < count; i++)
{
var item = boolArray[i];
if (item != (i % 2 == 0))
{ throw new Exception(); }
}
}
// 测试vec3类型
{
var vec3Array = new UnmanagedArray<vec3>(count);
for (int i = 0; i < count; i++)
{
vec3Array[i] = new vec3(i * 3 + 0, i * 3 + 1, i * 3 + 2);
}
for (int i = 0; i < count; i++)
{
var item = vec3Array[i];
var old = new vec3(i * 3 + 0, i * 3 + 1, i * 3 + 2);
if (item.x != old.x || item.y != old.y || item.z != old.z)
{ throw new Exception(); }
}
// 释放此数组占用的内存，这之后就不能再使用vec3Array了。
vec3Array.Dispose();
}
// 速度较慢，不再使用。
//// 测试foreach
//foreach (var item in vec3Array.Elements())
//{
// Console.WriteLine(item);
//}
// 立即释放所有非托管数组占用的内存，任何之前创建的UnmanagedBase数组都不再可用了。
UnmanagedArray<int>.FreeAll();
}
private void InitVAO()
{
int size = this.size;
this.vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// prepare positions
{
var positionArray = new UnmanagedArray <vec3>(size * size * size * 14);
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
for (int cubeIndex = 0; cubeIndex < 14; cubeIndex++)
{
positionArray[index++] = unitCubePos[cubeIndex]
+ new vec3((i - size / 2) * unitSpace, (j - size / 2) * unitSpace, (k - size / 2) * unitSpace);
}
}
}
}
uint in_PositionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_PositionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_PositionLocation);
positionArray.Dispose();
}
// prepare colors
{
var colorArray = new UnmanagedArray <vec3>(size * size * size * 14);
Random random = new Random();
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
//vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
for (int cubeIndex = 0; cubeIndex < 14; cubeIndex++)
{
vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
colorArray[index++] = color;
}
}
}
}
uint in_ColorLocation = shaderProgram.GetAttributeLocation(strin_Color);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_ColorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_ColorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
// prepare firsts and counts
{
// todo: rename 'size'
this.firsts = new int[size * size * size];
for (int i = 0; i < this.firsts.Length; i++)
{
this.firsts[i] = i * 14;
}
this.counts = new int[size * size * size];
for (int i = 0; i < this.counts.Length; i++)
{
this.counts[i] = 14;
}
}
}
protected override void DoInitialize()
{
// Initialize our compute program
compute_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(compute_prog, ShaderType.ComputerShader, compute_shader_source);
GL.LinkProgram(compute_prog);
dt_location = GL.GetUniformLocation(compute_prog, "dt");
GL.GenVertexArrays(1, render_vao);
GL.BindVertexArray(render_vao[0]);
GL.GenBuffers(2, buffers);
{
GL.BindBuffer(BufferTarget.ArrayBuffer, buffers[0]);//position buffer
UnmanagedArray <vec4> tmp = new UnmanagedArray <vec4>(PARTICLE_COUNT);
GL.BufferData(BufferTarget.ArrayBuffer, tmp, BufferUsage.DynamicCopy);
tmp.Dispose();
IntPtr positions = GL.MapBufferRange(GL.GL_ARRAY_BUFFER,
0, PARTICLE_COUNT * Marshal.SizeOf(typeof(vec4)), GL.GL_MAP_WRITE_BIT | GL.GL_MAP_INVALIDATE_BUFFER_BIT);
unsafe
{
vec4 *array = (vec4 *)positions.ToPointer();
for (int i = 0; i < PARTICLE_COUNT; i++)
{
array[i] = new vec4(Vec3Helper.GetRandomVec3(), (float)random.NextDouble());
}
}
GL.UnmapBuffer(BufferTarget.ArrayBuffer);
GL.VertexAttribPointer(0, 4, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(0);
}
{
GL.BindBuffer(BufferTarget.ArrayBuffer, buffers[1]);// velocity buffer
UnmanagedArray <vec4> tmp = new UnmanagedArray <vec4>(PARTICLE_COUNT);
GL.BufferData(BufferTarget.ArrayBuffer, tmp, BufferUsage.DynamicCopy);
tmp.Dispose();
IntPtr velocities = GL.MapBufferRange(GL.GL_ARRAY_BUFFER,
0, PARTICLE_COUNT * Marshal.SizeOf(typeof(vec4)), GL.GL_MAP_WRITE_BIT | GL.GL_MAP_INVALIDATE_BUFFER_BIT);
unsafe
{
vec4 *array = (vec4 *)velocities.ToPointer();
for (int i = 0; i < PARTICLE_COUNT; i++)
{
array[i] = new vec4(Vec3Helper.GetRandomVec3(), (float)random.NextDouble());
}
}
GL.UnmapBuffer(BufferTarget.ArrayBuffer);
}
{
GL.GenTextures(2, tbos);
for (int i = 0; i < 2; i++)
{
GL.BindTexture(GL.GL_TEXTURE_BUFFER, tbos[i]);
GL.TexBuffer(GL.GL_TEXTURE_BUFFER, GL.GL_RGBA32F, buffers[i]);
}
}
{
GL.GenBuffers(1, attractor_buffer);
GL.BindBuffer(BufferTarget.UniformBuffer, attractor_buffer[0]);
UnmanagedArray <vec4> tmp = new UnmanagedArray <vec4>(32);
GL.BufferData(BufferTarget.UniformBuffer, tmp, BufferUsage.StaticDraw);
tmp.Dispose();
for (int i = 0; i < MAX_ATTRACTORS; i++)
{
attractor_masses[i] = 0.5f + (float)random.NextDouble() * 0.5f;
}
GL.BindBufferBase(TransformFeedbackBufferTarget.UniformBuffer, 0, attractor_buffer[0]);
}
{
render_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(render_prog, ShaderType.VertexShader, render_vs);
ShaderHelper.vglAttachShaderSource(render_prog, ShaderType.FragmentShader, render_fs);
GL.LinkProgram(render_prog);
}
}
/// <summary>
/// 用随机颜色更新当前的颜色。
/// </summary>
public void UpdateColorBuffer()
{
var colorArray = new UnmanagedArray<vec3>(size * size * size * 8);
Random random = new Random();
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
//vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
for (int cubeIndex = 0; cubeIndex < 8; cubeIndex++)
{
vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
colorArray[index++] = color;
}
}
}
}
// update buffer object.
GL.BindBuffer(BufferTarget.ArrayBuffer, this.colorBuffer[0]);
IntPtr destColors = GL.MapBuffer(BufferTarget.ArrayBuffer, MapBufferAccess.ReadWrite);
colorArray.CopyTo(destColors);
GL.UnmapBuffer(BufferTarget.ArrayBuffer);
// This do the same thing: update buffer object
using (var mappingBuffer = new MappingBuffer(BufferTarget.ArrayBuffer, this.colorBuffer[0], MapBufferAccess.ReadWrite))
{
colorArray.CopyTo(mappingBuffer.BufferPointer);
}
colorArray.Dispose();
}
internal static void TypicalScene()
{
// 数组较小时可按此方法使用UnmanagedArray，数组较大时请参考UnmanagedArrayHelper。
const int count = 100;
// 测试float类型
{
var floatArray = new UnmanagedArray <float>(count);
for (int i = 0; i < count; i++)
{
floatArray[i] = i;
}
for (int i = 0; i < count; i++)
{
var item = floatArray[i];
if (item != i)
{
throw new Exception();
}
}
}
// 测试decimal类型
{
var decimalArray = new UnmanagedArray <decimal>(count);
for (int i = 0; i < count; i++)
{
decimalArray[i] = i;
}
for (int i = 0; i < count; i++)
{
var item = decimalArray[i];
if (item != i)
{
throw new Exception();
}
}
}
// 测试int类型
{
var intArray = new UnmanagedArray <int>(count);
for (int i = 0; i < count; i++)
{
intArray[i] = i;
}
for (int i = 0; i < count; i++)
{
var item = intArray[i];
if (item != i)
{
throw new Exception();
}
}
}
// 测试bool类型
{
var boolArray = new UnmanagedArray <bool>(count);
for (int i = 0; i < count; i++)
{
boolArray[i] = i % 2 == 0;
}
for (int i = 0; i < count; i++)
{
var item = boolArray[i];
if (item != (i % 2 == 0))
{
throw new Exception();
}
}
}
// 测试vec3类型
{
var vec3Array = new UnmanagedArray <vec3>(count);
for (int i = 0; i < count; i++)
{
vec3Array[i] = new vec3(i * 3 + 0, i * 3 + 1, i * 3 + 2);
}
for (int i = 0; i < count; i++)
{
var item = vec3Array[i];
var old = new vec3(i * 3 + 0, i * 3 + 1, i * 3 + 2);
if (item.x != old.x || item.y != old.y || item.z != old.z)
{
throw new Exception();
}
}
// 释放此数组占用的内存，这之后就不能再使用vec3Array了。
vec3Array.Dispose();
}
// 速度较慢，不再使用。
//// 测试foreach
//foreach (var item in vec3Array.Elements())
//{
// Console.WriteLine(item);
//}
// 立即释放所有非托管数组占用的内存，任何之前创建的UnmanagedBase数组都不再可用了。
UnmanagedArray <int> .FreeAll();
}
protected override void DoInitialize()
{
skybox_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(skybox_prog, ShaderType.VertexShader, skybox_shader_vs);
ShaderHelper.vglAttachShaderSource(skybox_prog, ShaderType.FragmentShader, skybox_shader_fs);
GL.LinkProgram(skybox_prog);
object_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(object_prog, ShaderType.VertexShader, object_shader_vs);
ShaderHelper.vglAttachShaderSource(object_prog, ShaderType.FragmentShader, object_shader_fs);
GL.LinkProgram(object_prog);
GL.GenBuffers(1, cube_vbo);
GL.BindBuffer(BufferTarget.ArrayBuffer, cube_vbo[0]);
var cube_vertices = new UnmanagedArray<vec3>(8);
cube_vertices[0] = new vec3(-1.0f, -1.0f, -1.0f);
cube_vertices[1] = new vec3(-1.0f, -1.0f, 1.0f);
cube_vertices[2] = new vec3(-1.0f, 1.0f, -1.0f);
cube_vertices[3] = new vec3(-1.0f, 1.0f, 1.0f);
cube_vertices[4] = new vec3(1.0f, -1.0f, -1.0f);
cube_vertices[5] = new vec3(1.0f, -1.0f, 1.0f);
cube_vertices[6] = new vec3(1.0f, 1.0f, -1.0f);
cube_vertices[7] = new vec3(1.0f, 1.0f, 1.0f);
var cube_indices = new UnmanagedArray<ushort>(16);
// First strip
cube_indices[0] = 0;
cube_indices[1] = 1;
cube_indices[2] = 2;
cube_indices[3] = 3;
cube_indices[4] = 6;
cube_indices[5] = 7;
cube_indices[6] = 4;
cube_indices[7] = 5;
// Second strip
cube_indices[8] = 2;
cube_indices[9] = 6;
cube_indices[10] = 0;
cube_indices[11] = 4;
cube_indices[12] = 1;
cube_indices[13] = 5;
cube_indices[14] = 3;
cube_indices[15] = 7;
GL.BufferData(BufferTarget.ArrayBuffer, cube_vertices, BufferUsage.StaticDraw);
cube_vertices.Dispose();
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
GL.VertexAttribPointer(0, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(0);
GL.GenBuffers(1, cube_element_buffer);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, cube_element_buffer[0]);
GL.BufferData(BufferTarget.ElementArrayBuffer, cube_indices, BufferUsage.StaticDraw);
cube_indices.Dispose();
skybox_rotate_loc = GL.GetUniformLocation(skybox_prog, "tc_rotate");
object_mat_mvp_loc = GL.GetUniformLocation(object_prog, "mat_mvp");
object_mat_mv_loc = GL.GetUniformLocation(object_prog, "mat_mv");
skyboxTexLocation = GL.GetUniformLocation(skybox_prog, "tex");
objectTexLocation = GL.GetUniformLocation(object_prog, "tex");
//tex = new Texture2D();
//System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(@"media\TantolundenCube.png");
//tex.Initialize(bmp);
vglImageData data = new vglImageData();
tex = vgl.vglLoadTexture(@"media\TantolundenCube.dds", 0, ref data);
uint e = GL.GetError();
vgl.vglUnloadImage(ref data);
vboObject.LoadFromVBM(@"media\unit_torus.vbm", 0, 1, 2);
}
protected override void DoInitialize()
{
// Now create a simple program to visualize the result
basicShaderProgram = new ShaderProgram();
basicShaderProgram.Create(basicVertexShader, basicFragmentShader, null);
basicShaderProgram.AssertValid();
base_model_matrix_pos = GL.GetUniformLocation(basicShaderProgram.ShaderProgramObject, "model_matrix");
base_projection_matrix_pos = GL.GetUniformLocation(basicShaderProgram.ShaderProgramObject, "projection_matrix");
fur_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(fur_prog, ShaderType.VertexShader, furVertexShader);
ShaderHelper.vglAttachShaderSource(fur_prog, ShaderType.GeometryShader, furGeometryShader);
ShaderHelper.vglAttachShaderSource(fur_prog, ShaderType.FragmentShader, furFragmentShader);
GL.LinkProgram(fur_prog);
GL.UseProgram(fur_prog);
fur_model_matrix_pos = GL.GetUniformLocation(fur_prog, "model_matrix");
fur_projection_matrix_pos = GL.GetUniformLocation(fur_prog, "projection_matrix");
GL.GenTextures(1, fur_texture);
UnmanagedArray<byte> tex = new UnmanagedArray<byte>(1024 * 1024 * 4);
Random random = new Random();
for (int n = 0; n < 256; n++)
{
for (int m = 0; m < 1270; m++)
{
int x = random.Next() & 0x3FF;
int y = random.Next() & 0x3FF;
tex[(y * 1024 + x) * 4 + 0] = (byte)((random.Next() & 0x3F) + 0xC0);
tex[(y * 1024 + x) * 4 + 1] = (byte)((random.Next() & 0x3F) + 0xC0);
tex[(y * 1024 + x) * 4 + 2] = (byte)((random.Next() & 0x3F) + 0xC0);
tex[(y * 1024 + x) * 4 + 3] = (byte)(n);
//tex[(y * 1024 + x) * 4 + 0] = (byte)(random.Next());
//tex[(y * 1024 + x) * 4 + 1] = (byte)(random.Next());
//tex[(y * 1024 + x) * 4 + 2] = (byte)(random.Next());
//tex[(y * 1024 + x) * 4 + 3] = (byte)(random.Next());
}
}
GL.BindTexture(GL.GL_TEXTURE_2D, fur_texture[0]);
GL.TexImage2D(TexImage2DTargets.Texture2D, 0, TexImage2DFormats.RGBA, 1024, 1024, 0, TexImage2DFormats.RGBA, TexImage2DTypes.UnsignedByte, tex.Header);
GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, (int)GL.GL_LINEAR);
GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, (int)GL.GL_LINEAR);
tex.Dispose();
vboObject.LoadFromVBM(@"media\ninja.vbm", 0, 1, 2);
base.BeforeRendering += LightingExample_BeforeRendering;
base.AfterRendering += LightingExample_AfterRendering;
}
public bool LoadFromVBM(string filename, int vertexIndex, int normalIndex, int texCoord0Index)
{
FileStream f = new FileStream(filename, FileMode.Open, FileAccess.Read);
BinaryReader br = new BinaryReader(f);
long filesize = f.Length;
byte[] data = new byte[filesize];
UnmanagedArray <byte> raw_data;
f.Read(data, 0, (int)filesize);
f.Seek(0, SeekOrigin.Begin);
VBM_HEADER header = br.ReadStruct <VBM_HEADER>();
VBM_ATTRIB_HEADER attrib_header = br.ReadStruct <VBM_ATTRIB_HEADER>();
{
long offset = header.size + header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER));
f.Seek(offset, SeekOrigin.Begin);
}
VBM_FRAME_HEADER frame_header = br.ReadStruct <VBM_FRAME_HEADER>();
uint total_data_size = 0;
this.m_header = header;
{
long offset = header.size;// +header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER));
f.Seek(offset, SeekOrigin.Begin);
}
this.m_attrib = new VBM_ATTRIB_HEADER[header.num_attribs];
for (int i = 0; i < header.num_attribs; i++)
{
this.m_attrib[i] = br.ReadStruct <VBM_ATTRIB_HEADER>();
}
{
long offset = header.size + header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER));// +header.num_frames * Marshal.SizeOf(typeof(VBM_FRAME_HEADER));
f.Seek(offset, SeekOrigin.Begin);
}
this.m_frame = new VBM_FRAME_HEADER[header.num_frames];
for (int i = 0; i < header.num_frames; i++)
{
this.m_frame[i] = br.ReadStruct <VBM_FRAME_HEADER>();
}
GL.GenVertexArrays(1, m_vao);
GL.BindVertexArray(m_vao[0]);
GL.GenBuffers(1, m_attribute_buffer);
GL.BindBuffer(BufferTarget.ArrayBuffer, m_attribute_buffer[0]);
//uint i;
for (uint i = 0; i < header.num_attribs; i++)
{
total_data_size += m_attrib[i].components * sizeof(float) * header.num_vertices;
}
{
long offset = header.size + header.num_attribs * Marshal.SizeOf(typeof(VBM_ATTRIB_HEADER)) + header.num_frames * Marshal.SizeOf(typeof(VBM_FRAME_HEADER));
raw_data = new UnmanagedArray <byte>((int)total_data_size);
for (int i = 0; i < raw_data.Length; i++)
{
raw_data[i] = data[offset + i];
}
}
//GL.BufferData(GL_ARRAY_BUFFER, total_data_size, raw_data, GL_STATIC_DRAW);
GL.BufferData(BufferTarget.ArrayBuffer, raw_data, BufferUsage.StaticDraw);
total_data_size = 0;
for (uint i = 0; i < header.num_attribs; i++)
{
uint attribIndex = i;
if (attribIndex == 0)
{
attribIndex = (uint)vertexIndex;
}
else if (attribIndex == 1)
{
attribIndex = (uint)normalIndex;
}
else if (attribIndex == 2)
{
attribIndex = (uint)texCoord0Index;
}
GL.VertexAttribPointer(attribIndex, (int)m_attrib[i].components, m_attrib[i].type, false, 0, new IntPtr(total_data_size));
GL.EnableVertexAttribArray(attribIndex);
total_data_size += m_attrib[i].components * sizeof(float) * header.num_vertices;
}
if (header.num_indices > 0)
{
GL.GenBuffers(1, m_index_buffer);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, m_index_buffer[0]);
uint element_size;
if (header.indexype == 0x1403)
{
element_size = sizeof(ushort);
}
else
{
element_size = sizeof(uint);
}
//GL.BufferData(GL_ELEMENT_ARRAY_BUFFER, header.num_indices * element_size, raw_data + total_data_size, GL_STATIC_DRAW);
UnmanagedArray <byte> tmp = new UnmanagedArray <byte>((int)(header.num_indices * element_size));
for (int t = 0; t < tmp.Length; t++)
{
tmp[t] = raw_data[(int)(t + total_data_size)];
}
GL.BufferData(BufferTarget.ElementArrayBuffer, tmp, BufferUsage.StaticDraw);
tmp.Dispose();
}
GL.BindVertexArray(0);
raw_data.Dispose();
return(true);
}
private void InitVAO()
{
// reserve a vertex array object(VAO) 预约一个VAO
this.vertexArrayObject = new uint[1];
GL.GenVertexArrays(1, this.vertexArrayObject);
// prepare vertex buffer object(VBO) for vertexes' positions 为顶点位置准备VBO
uint[] positionBufferObject = new uint[1];
{
// specify position array
var positionArray = new UnmanagedArray<vec3>(vertexCount);
positionArray[0] = new vec3(0.0f, 1.0f, 0.0f);
positionArray[1] = new vec3(-1.0f, -1.0f, 1.0f);
positionArray[2] = new vec3(1.0f, -1.0f, 1.0f);
positionArray[3] = new vec3(0.0f, 1.0f, 0.0f);
positionArray[4] = new vec3(1.0f, -1.0f, 1.0f);
positionArray[5] = new vec3(1.0f, -1.0f, -1.0f);
positionArray[6] = new vec3(0.0f, 1.0f, 0.0f);
positionArray[7] = new vec3(1.0f, -1.0f, -1.0f);
positionArray[8] = new vec3(-1.0f, -1.0f, -1.0f);
positionArray[9] = new vec3(0.0f, 1.0f, 0.0f);
positionArray[10] = new vec3(-1.0f, -1.0f, -1.0f);
positionArray[11] = new vec3(-1.0f, -1.0f, 1.0f);
// put positions into VBO
GL.GenBuffers(1, positionBufferObject);
GL.BindBuffer(BufferTarget.ArrayBuffer, positionBufferObject[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
positionArray.Dispose();
}
// prepare vertex buffer object(VBO) for vertexes' colors
uint[] colorBufferObject = new uint[1];
{
// specify color array
UnmanagedArray<vec3> colorArray = new UnmanagedArray<vec3>(vertexCount);
colorArray[0] = new vec3(1.0f, 0.0f, 0.0f);
colorArray[1] = new vec3(0.0f, 1.0f, 0.0f);
colorArray[2] = new vec3(0.0f, 0.0f, 1.0f);
colorArray[3] = new vec3(1.0f, 0.0f, 0.0f);
colorArray[4] = new vec3(0.0f, 0.0f, 1.0f);
colorArray[5] = new vec3(0.0f, 1.0f, 0.0f);
colorArray[6] = new vec3(1.0f, 0.0f, 0.0f);
colorArray[7] = new vec3(0.0f, 1.0f, 0.0f);
colorArray[8] = new vec3(0.0f, 0.0f, 1.0f);
colorArray[9] = new vec3(1.0f, 0.0f, 0.0f);
colorArray[10] = new vec3(0.0f, 0.0f, 1.0f);
colorArray[11] = new vec3(0.0f, 1.0f, 0.0f);
// put colors into VBO
GL.GenBuffers(1, colorBufferObject);
GL.BindBuffer(BufferTarget.ArrayBuffer, colorBufferObject[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
colorArray.Dispose();
}
uint positionLocation = shaderProgram.GetAttributeLocation("in_Position");
uint colorLocation = shaderProgram.GetAttributeLocation("in_Color");
{
// bind the vertex array object(VAO), we are going to specify data for it.
GL.BindVertexArray(vertexArrayObject[0]);
// specify vertexes' positions
GL.BindBuffer(BufferTarget.ArrayBuffer, positionBufferObject[0]);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
// specify vertexes' colors
GL.BindBuffer(BufferTarget.ArrayBuffer, colorBufferObject[0]);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
// Unbind the vertex array object(VAO), we've finished specifying data for it.
GL.BindVertexArray(0);
}
}
protected void InitializeVAO(OpenGL gl, out uint[] vao, out BeginMode primitiveMode, out int vertexCount)
{
primitiveMode = BeginMode.QuadStrip;
vertexCount = (faceCount * 2 + 2) * (this.pipe.Count - 1);
UnmanagedArray <Vertex> positionArray = new UnmanagedArray <Vertex>(vertexCount);
{
int index = 0;
for (int i = 1; i < this.pipe.Count; i++)
{
Vertex p1 = this.pipe[i - 1];
Vertex p2 = this.pipe[i];
Vertex vector = p2 - p1;// 从p1到p2的向量
// 找到互相垂直的三个向量：vector, orthogontalVector1和orthogontalVector2
Vertex orthogontalVector1 = new Vertex(vector.Y - vector.Z, vector.Z - vector.X, vector.X - vector.Y);
Vertex orthogontalVector2 = vector.VectorProduct(orthogontalVector1);
orthogontalVector1.Normalize();
orthogontalVector2.Normalize();
orthogontalVector1 *= (float)Math.Sqrt(this.radius);
orthogontalVector2 *= (float)Math.Sqrt(this.radius);
for (int faceIndex = 0; faceIndex < faceCount + 1; faceIndex++)
{
double angle = (Math.PI * 2 * faceIndex) / faceCount;
Vertex point = orthogontalVector1 * (float)Math.Cos(angle) + orthogontalVector2 * (float)Math.Sin(angle);
positionArray[index++] = p2 + point;
positionArray[index++] = p1 + point;
}
//positionArray[index++] = new vec3();//用于分割圆柱体
}
}
UnmanagedArray <Vertex> colorArray = new UnmanagedArray <Vertex>(vertexCount);
{
Vertex vColor = new Vertex(this.color.R, this.color.G, this.color.B);
for (int i = 0; i < colorArray.Length; i++)
{
colorArray[i] = vColor;
// 测试时用此代码区分各个圆柱
//if ((i / (faceCount * 2 + 2)) % 3 == 0)
//{
// colorArray[i] = new vec3(1, 0, 0);
//}
//else if ((i / (faceCount * 2 + 2)) % 3 == 1)
//{
// colorArray[i] = new vec3(0, 1, 0);
//}
//else
//{
// colorArray[i] = new vec3(0, 0, 1);
//}
}
}
UnmanagedArray <uint> indexArray = new UnmanagedArray <uint>(vertexCount + (this.pipe.Count - 1));
{
uint positionIndex = 0;
for (int i = 0; i < indexArray.Length; i++)
{
if (i % (faceCount * 2 + 2 + 1) == (faceCount * 2 + 2))
{
indexArray[i] = uint.MaxValue;//分割各个圆柱体
}
else
{
indexArray[i] = positionIndex++;
}
}
}
vao = new uint[1];
gl.GenVertexArrays(1, vao);
gl.BindVertexArray(vao[0]);
{
uint[] ids = new uint[1];
gl.GenBuffers(1, ids);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, ids[0]);
int location = gl.GetAttribLocation(shaderProgram.ShaderProgramObject, strin_Position);
if (location < 0)
{
throw new Exception();
}
uint positionLocation = (uint)location;
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, positionArray.ByteLength, positionArray.Header, OpenGL.GL_STATIC_DRAW);
gl.VertexAttribPointer(positionLocation, 3, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
this.positionBufferObject = ids[0];
}
{
uint[] ids = new uint[1];
gl.GenBuffers(1, ids);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, ids[0]);
int location = gl.GetAttribLocation(shaderProgram.ShaderProgramObject, strin_Color);
if (location < 0)
{
throw new Exception();
}
uint colorLocation = (uint)location;
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, colorArray.ByteLength, colorArray.Header, OpenGL.GL_STATIC_DRAW);
gl.VertexAttribPointer(colorLocation, 3, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
this.colorBufferObject = ids[0];
}
{
uint[] ids = new uint[1];
gl.GenBuffers(1, ids);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, ids[0]);
gl.BufferData(OpenGL.GL_ELEMENT_ARRAY_BUFFER, indexArray.ByteLength, indexArray.Header, OpenGL.GL_STATIC_DRAW);
indexArray.Dispose();
this.indexBufferObject = ids[0];
}
// Unbind the vertex array, we've finished specifying data for it.
gl.BindVertexArray(0);
}
private void InitVAO()
{
int size = this.size;
this.vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// prepare positions
{
var positionArray = new UnmanagedArray<vec3>(size * size * size * 14);
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
for (int cubeIndex = 0; cubeIndex < 14; cubeIndex++)
{
positionArray[index++] = unitCubePos[cubeIndex]
+ new vec3((i - size / 2) * unitSpace, (j - size / 2) * unitSpace, (k - size / 2) * unitSpace);
}
}
}
}
uint in_PositionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_PositionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_PositionLocation);
positionArray.Dispose();
}
// prepare colors
{
var colorArray = new UnmanagedArray<vec3>(size * size * size * 14);
Random random = new Random();
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
//vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
for (int cubeIndex = 0; cubeIndex < 14; cubeIndex++)
{
vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
colorArray[index++] = color;
}
}
}
}
uint in_ColorLocation = shaderProgram.GetAttributeLocation(strin_Color);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_ColorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_ColorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
// prepare firsts and counts
{
// todo: rename 'size'
this.firsts = new int[size * size * size];
for (int i = 0; i < this.firsts.Length; i++)
{
this.firsts[i] = i * 14;
}
this.counts = new int[size * size * size];
for (int i = 0; i < this.counts.Length; i++)
{
this.counts[i] = 14;
}
}
}
} // end sub
#endregion
protected override void DoInitialize()
{
skybox_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(skybox_prog, ShaderType.VertexShader, skybox_shader_vs);
ShaderHelper.vglAttachShaderSource(skybox_prog, ShaderType.FragmentShader, skybox_shader_fs);
GL.LinkProgram(skybox_prog);
object_prog = GL.CreateProgram();
ShaderHelper.vglAttachShaderSource(object_prog, ShaderType.VertexShader, object_shader_vs);
ShaderHelper.vglAttachShaderSource(object_prog, ShaderType.FragmentShader, object_shader_fs);
GL.LinkProgram(object_prog);
GL.GenBuffers(1, cube_vbo);
GL.BindBuffer(BufferTarget.ArrayBuffer, cube_vbo[0]);
var cube_vertices = new UnmanagedArray <vec3>(8);
cube_vertices[0] = new vec3(-1.0f, -1.0f, -1.0f);
cube_vertices[1] = new vec3(-1.0f, -1.0f, 1.0f);
cube_vertices[2] = new vec3(-1.0f, 1.0f, -1.0f);
cube_vertices[3] = new vec3(-1.0f, 1.0f, 1.0f);
cube_vertices[4] = new vec3(1.0f, -1.0f, -1.0f);
cube_vertices[5] = new vec3(1.0f, -1.0f, 1.0f);
cube_vertices[6] = new vec3(1.0f, 1.0f, -1.0f);
cube_vertices[7] = new vec3(1.0f, 1.0f, 1.0f);
var cube_indices = new UnmanagedArray <ushort>(16);
// First strip
cube_indices[0] = 0;
cube_indices[1] = 1;
cube_indices[2] = 2;
cube_indices[3] = 3;
cube_indices[4] = 6;
cube_indices[5] = 7;
cube_indices[6] = 4;
cube_indices[7] = 5;
// Second strip
cube_indices[8] = 2;
cube_indices[9] = 6;
cube_indices[10] = 0;
cube_indices[11] = 4;
cube_indices[12] = 1;
cube_indices[13] = 5;
cube_indices[14] = 3;
cube_indices[15] = 7;
GL.BufferData(BufferTarget.ArrayBuffer, cube_vertices, BufferUsage.StaticDraw);
cube_vertices.Dispose();
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
GL.VertexAttribPointer(0, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(0);
GL.GenBuffers(1, cube_element_buffer);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, cube_element_buffer[0]);
GL.BufferData(BufferTarget.ElementArrayBuffer, cube_indices, BufferUsage.StaticDraw);
cube_indices.Dispose();
skybox_rotate_loc = GL.GetUniformLocation(skybox_prog, "tc_rotate");
object_mat_mvp_loc = GL.GetUniformLocation(object_prog, "mat_mvp");
object_mat_mv_loc = GL.GetUniformLocation(object_prog, "mat_mv");
skyboxTexLocation = GL.GetUniformLocation(skybox_prog, "tex");
objectTexLocation = GL.GetUniformLocation(object_prog, "tex");
//tex = new Texture2D();
//System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(@"media\TantolundenCube.png");
//tex.Initialize(bmp);
vglImageData data = new vglImageData();
tex = vgl.vglLoadTexture(@"media\TantolundenCube.dds", 0, ref data);
uint e = GL.GetError();
vgl.vglUnloadImage(ref data);
vboObject.LoadFromVBM(@"media\unit_torus.vbm", 0, 1, 2);
}
//protected void InitializeVAO(out uint[] vao, out DrawMode primitiveMode, out int vertexCount)
protected void InitializeVAO()
{
this.primitiveMode = DrawMode.Triangles;
this.vertexCount = positions.Length;
this.vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
//uint[] ids = new uint[1];
this.positionBufferObject = new uint[1];
GL.GenBuffers(1, this.positionBufferObject);
GL.BindBuffer(BufferTarget.ArrayBuffer, this.positionBufferObject[0]);
UnmanagedArray<vec3> positionArray = new UnmanagedArray<vec3>(positions.Length);
for (int i = 0; i < positions.Length; i++)
{
positionArray[i] = positions[i];
}
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
//uint[] ids = new uint[1];
this.colorBufferObject = new uint[1];
GL.GenBuffers(1, this.colorBufferObject);
GL.BindBuffer(BufferTarget.ArrayBuffer, this.colorBufferObject[0]);
UnmanagedArray<vec3> colorArray = new UnmanagedArray<vec3>(positions.Length);
for (int i = 0; i < colors.Length; i++)
{
colorArray[i] = colors[i];
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
protected void InitializeVAO()
{
this.primitiveMode = DrawMode.Points;
const int axisCount = 3;
const int count = axisCount * axisCount * axisCount;
this.vertexCount = count;
this.vao = new uint[1];
GL.GenVertexArrays(4, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
UnmanagedArray<vec3> positionArray = new UnmanagedArray<vec3>(count);
for (int i = 0, index = 0; i < axisCount; i++)
{
for (int j = 0; j < axisCount; j++)
{
for (int k = 0; k < axisCount; k++)
{
//positionArray[index++] = 10 * new vec3(i - axisCount / 2, j - axisCount / 2, k - axisCount / 2);
positionArray[index++] = 10 * new vec3((float)random.NextDouble() - 0.5f, (float)random.NextDouble() - 0.5f, (float)random.NextDouble() - 0.5f);
}
}
}
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
private void InitVAO()
{
int size = this.size;
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// prepare positions
{
var positionArray = new UnmanagedArray<vec3>(size * size * size * 8);
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
for (int cubeIndex = 0; cubeIndex < 8; cubeIndex++)
{
positionArray[index++] = unitCubePos[cubeIndex]
+ new vec3((i - size / 2) * unitSpace, (j - size / 2) * unitSpace, (k - size / 2) * unitSpace);
}
}
}
}
uint in_PositionLocation = shaderProgram.GetAttributeLocation(strin_Position);
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_PositionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_PositionLocation);
positionArray.Dispose();
}
// prepare colors
{
var colorArray = new UnmanagedArray<vec3>(size * size * size * 8);
Random random = new Random();
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
//vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
for (int cubeIndex = 0; cubeIndex < 8; cubeIndex++)
{
vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
colorArray[index++] = color;
}
}
}
}
uint in_ColorLocation = shaderProgram.GetAttributeLocation(strin_Color);
GL.GenBuffers(1, this.colorBuffer);
GL.BindBuffer(BufferTarget.ArrayBuffer, this.colorBuffer[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(in_ColorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_ColorLocation);
colorArray.Dispose();
}
// prepare index
{
var indexArray = new UnmanagedArray<uint>(size * size * size * (14 + 1));
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
for (int cubeIndex = 0; cubeIndex < 14; cubeIndex++)
{
long posIndex = unitCubeIndex[cubeIndex] + (i * size * size + j * size + k) * 8;
indexArray[index++] = (uint)posIndex;
}
indexArray[index++] = uint.MaxValue;
}
}
}
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ElementArrayBuffer, indexArray, BufferUsage.StaticDraw);
indexArray.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
protected void InitializeVAO(out uint[] vao, out DrawMode primitiveMode, out int vertexCount)
{
primitiveMode = DrawMode.QuadStrip;// PrimitiveModes.QuadStrip;
vertexCount = faceCount * 2;
vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// Create a vertex buffer for the vertex data.
{
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
UnmanagedArray<vec3> positionArray = new UnmanagedArray<vec3>(faceCount * 2);
for (int i = 0; i < faceCount * 2; i++)
{
int face = i / 2;
positionArray[i] = new vec3(
(float)(this.radius * Math.Cos(face * (Math.PI * 2) / faceCount)),
(i % 2 == 1 ? -1 : 1) * this.height / 2,
(float)(this.radius * Math.Sin(face * (Math.PI * 2) / faceCount))
);
}
uint positionLocation = shaderProgram.GetAttributeLocation(strin_Position);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(positionLocation);
positionArray.Dispose();
}
// Now do the same for the colour data.
{
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
UnmanagedArray<vec3> colorArray = new UnmanagedArray<vec3>(faceCount * 2);
for (int i = 0; i < colorArray.Length; i++)
{
if (i % 2 == 0)
{
colorArray[i] = new vec3(1, 0, 0); //new vec3((i % 3) / 3.0f, (i + 1) % 3 / 3.0f, (i + 2) % 3 / 3.0f);
}
else
{
colorArray[i] = new vec3(0, 1, 0); //new vec3((i % 3) / 3.0f, (i + 1) % 3 / 3.0f, (i + 2) % 3 / 3.0f);
}
}
uint colorLocation = shaderProgram.GetAttributeLocation(strin_Color);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(colorLocation);
colorArray.Dispose();
}
{
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, ids[0]);
UnmanagedArray<uint> cylinderIndex = new UnmanagedArray<uint>(faceCount * 2 + 2);
for (int i = 0; i < cylinderIndex.Length - 2; i++)
{
cylinderIndex[i] = (uint)i;
}
cylinderIndex[cylinderIndex.Length - 2] = 0;
cylinderIndex[cylinderIndex.Length - 1] = 1;
GL.BufferData(BufferTarget.ElementArrayBuffer, cylinderIndex, BufferUsage.StaticDraw);
cylinderIndex.Dispose();
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
private void InitVAO()
{
int size = this.size;
// prepare positions
{
var positionArray = new UnmanagedArray <vec3>(size * size * size * 8);
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
for (int cubeIndex = 0; cubeIndex < 8; cubeIndex++)
{
positionArray[index++] = unitCubePos[cubeIndex]
+ new vec3((i - size / 2) * unitSpace, (j - size / 2) * unitSpace, (k - size / 2) * unitSpace);
}
}
}
}
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
positionArray.Dispose();
positionBuffer = ids[0];
}
// prepare colors
{
var colorArray = new UnmanagedArray <vec3>(size * size * size * 8);
Random random = new Random();
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
//vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
for (int cubeIndex = 0; cubeIndex < 8; cubeIndex++)
{
vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
colorArray[index++] = color;
}
}
}
}
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
colorArray.Dispose();
colorBuffer = ids[0];
}
// prepare index
{
var indexArray = new UnmanagedArray <uint>(size * size * size * (14 + 1));
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
for (int cubeIndex = 0; cubeIndex < 14; cubeIndex++)
{
long posIndex = unitCubeIndex[cubeIndex] + (i * size * size + j * size + k) * 8;
indexArray[index++] = (uint)posIndex;
}
indexArray[index++] = uint.MaxValue;
}
}
}
uint[] ids = new uint[1];
GL.GenBuffers(1, ids);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, ids[0]);
GL.BufferData(BufferTarget.ElementArrayBuffer, indexArray, BufferUsage.StaticDraw);
indexArray.Dispose();
indexBuffer = ids[0];
}
// create vao
{
this.vao = new uint[1];
GL.GenVertexArrays(1, vao);
GL.BindVertexArray(vao[0]);
// prepare positions
{
GL.BindBuffer(BufferTarget.ArrayBuffer, positionBuffer);
GL.VertexAttribPointer(in_PositionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_PositionLocation);
}
// prepare colors
{
GL.BindBuffer(BufferTarget.ArrayBuffer, colorBuffer);
GL.VertexAttribPointer(in_ColorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
GL.EnableVertexAttribArray(in_ColorLocation);
}
// prepare index
{
GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexBuffer);
}
// Unbind the vertex array, we've finished specifying data for it.
GL.BindVertexArray(0);
}
}
private void initVol3DTex(string filename, int width, int height, int depth)
{
var data = new UnmanagedArray<byte>(width * height * depth);
unsafe
{
int index = 0;
int readCount = 0;
byte* array = (byte*)data.Header.ToPointer();
using (var fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
using (var br = new BinaryReader(fs))
{
int unReadCount = (int)fs.Length;
const int cacheSize = 1024 * 1024;
do
{
int min = Math.Min(cacheSize, unReadCount);
var cache = new byte[min];
readCount = br.Read(cache, 0, min);
if (readCount != min)
{ throw new Exception(); }
for (int i = 0; i < readCount; i++)
{
array[index++] = cache[i];
}
unReadCount -= readCount;
} while (readCount > 0);
}
}
OpenGL.GenTextures(1, vol3DTexObj);
// bind 3D texture target
OpenGL.BindTexture(OpenGL.GL_TEXTURE_3D, vol3DTexObj[0]);
OpenGL.TexParameteri(OpenGL.GL_TEXTURE_3D, OpenGL.GL_TEXTURE_MAG_FILTER, (int)OpenGL.GL_LINEAR);
OpenGL.TexParameteri(OpenGL.GL_TEXTURE_3D, OpenGL.GL_TEXTURE_MIN_FILTER, (int)OpenGL.GL_LINEAR);
OpenGL.TexParameteri(OpenGL.GL_TEXTURE_3D, OpenGL.GL_TEXTURE_WRAP_S, (int)OpenGL.GL_REPEAT);
OpenGL.TexParameteri(OpenGL.GL_TEXTURE_3D, OpenGL.GL_TEXTURE_WRAP_T, (int)OpenGL.GL_REPEAT);
OpenGL.TexParameteri(OpenGL.GL_TEXTURE_3D, OpenGL.GL_TEXTURE_WRAP_R, (int)OpenGL.GL_REPEAT);
// pixel transfer happens here from client to OpenGL server
OpenGL.PixelStorei(OpenGL.GL_UNPACK_ALIGNMENT, 1);
OpenGL.TexImage3D(OpenGL.GL_TEXTURE_3D, 0, (int)OpenGL.GL_INTENSITY,
width, height, depth, 0,
OpenGL.GL_LUMINANCE, OpenGL.GL_UNSIGNED_BYTE, data.Header);
data.Dispose();
OpenGL.BindTexture(OpenGL.GL_TEXTURE_3D, 0);
}
