void IRenderable.Render(OpenGL gl, RenderMode renderMode)
{
if (positionBuffer != null && colorBuffer != null && radiusBuffer != null)
{
if (this.shaderProgram == null)
{
this.shaderProgram = InitShader(gl, renderMode);
}
if (this.vertexArrayObject == null)
{
CreateVertexArrayObject(gl, renderMode);
}
BeforeRendering(gl, renderMode);
if (this.RenderGrid && this.vertexArrayObject != null)
{
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(SharpGL.Enumerations.BlendingSourceFactor.SourceAlpha, SharpGL.Enumerations.BlendingDestinationFactor.OneMinusSourceAlpha);
gl.BindVertexArray(this.vertexArrayObject[0]);
gl.DrawArrays(OpenGL.GL_POINTS, 0, count);
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_BLEND);
}
AfterRendering(gl, renderMode);
}
}
public override void Draw(SharpGL.OpenGL gl)
{
gl.PushMatrix();
gl.PushAttrib(AttributeMask.All);
gl.PushClientAttrib(OpenGL.GL_CLIENT_ALL_ATTRIB_BITS);
gl.VertexPointer(3, 0, vertexs);
gl.NormalPointer(OpenGL.GL_FLOAT, 0, normals);
gl.TexCoordPointer(2, OpenGL.GL_FLOAT, 0, texCoord);
gl.EnableClientState(OpenGL.GL_VERTEX_ARRAY);
//gl.EnableClientState(OpenGL.GL_COLOR_ARRAY);
gl.EnableClientState(OpenGL.GL_NORMAL_ARRAY);
gl.EnableClientState(OpenGL.GL_TEXTURE_COORD_ARRAY);
gl.Translate(position.x, position.y + sizeY / 2, position.z);
gl.Color(color.GetInArrWithAlpha());
if (texture != null)
{
gl.Enable(OpenGL.GL_TEXTURE_2D);
texture.Bind(gl);
}
else
{
gl.Disable(OpenGL.GL_TEXTURE_2D);
}
gl.DrawArrays(OpenGL.GL_QUADS, 0, 24);
gl.PopClientAttrib();
gl.PopAttrib();
gl.PopMatrix();
}
private void RenderVertices_VertexArray(OpenGL gl)
{
gl.EnableClientState(OpenGL.GL_VERTEX_ARRAY);
gl.VertexPointer(3, 0, vertexArrayValues);
gl.DrawArrays(OpenGL.GL_POINTS, 0, 2);//vertices.Length);
gl.DisableClientState(OpenGL.GL_VERTEX_ARRAY);
}
public void Render(SharpGL.OpenGL gl, SharpGL.SceneGraph.Core.RenderMode renderMode)
{
gl.BindVertexArray(vao[0]);
gl.DrawArrays((uint)primitiveMode, 0, vertexCount);
gl.BindVertexArray(0);
}
private void DrawSound()
{
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
float[] spectrum = new float[256];
float[] wavedata = new float[512];
Player.getWaveData(ref wavedata, 256, 0);
Player.getSpectrum(ref spectrum, 256, 0);
DateTime currentDate = DateTime.Now;
float time = (float)currentDate.Ticks / (float)TimeSpan.TicksPerSecond;
gl.Uniform1(timeLoc, time);
gl.Uniform1(sampleLoc, 256, spectrum);
gl.Uniform1(waveLoc, 256, wavedata);
gl.ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 6);
}
/// <summary>
/// Draws the scene.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
public void Draw(OpenGL gl)
{
// Clear the scene.
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT | OpenGL.GL_STENCIL_BUFFER_BIT);
// Bind the shader, set the matrices.
shaderProgram.Bind(gl);
shaderProgram.SetUniformMatrix4(gl, "projectionMatrix", projectionMatrix.to_array());
shaderProgram.SetUniformMatrix4(gl, "viewMatrix", viewMatrix.to_array());
shaderProgram.SetUniformMatrix4(gl, "modelMatrix", modelMatrix.to_array());
// Bind the out vertex array.
vertexBufferArray.Bind(gl);
// Draw the square.
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 6);
// Unbind our vertex array and shader.
vertexBufferArray.Unbind(gl);
shaderProgram.Unbind(gl);
}
/// <summary>
/// 渲染此元素。
/// </summary>
/// <param name="gl"></param>
/// <param name="renderMode"></param>
public virtual void Render(SharpGL.OpenGL gl, SharpGL.SceneGraph.Core.RenderMode renderMode)
{
BeforeRendering(gl, renderMode);
ShaderProgram shader = this.shaderProgram;// GetShader(gl, renderMode);
shader.Bind(gl);
// 用VAO+EBO进行渲染。
// Bind the out vertex array.
gl.BindVertexArray(vao[0]);
gl.DrawArrays(this.primitiveMode, 0, this.primitiveCount);
// Unbind our vertex array and shader.
gl.BindVertexArray(0);
shader.Unbind(gl);
AfterRendering(gl, renderMode);
}
public void Render(SharpGL.OpenGL gl, RenderMode renderMode)
{
if (this._colorVertexes.Size <= 0)
{
return;
}
unsafe
{
gl.Enable(OpenGL.GL_DEPTH_TEST);
gl.Enable(0X8861);
gl.EnableClientState(OpenGL.GL_VERTEX_ARRAY);
gl.EnableClientState(OpenGL.GL_COLOR_ARRAY);
gl.VertexPointer(3, OpenGL.GL_FLOAT, 0, (IntPtr)this._colorVertexes.Centers);
gl.ColorPointer(3, OpenGL.GL_BYTE, 0, (IntPtr)this._colorVertexes.Colors);
gl.DrawArrays(OpenGL.GL_POINTS, 0, this._colorVertexes.Size);
gl.DisableClientState(OpenGL.GL_VERTEX_ARRAY);
gl.DisableClientState(OpenGL.GL_COLOR_ARRAY);
}
}
private void runGlThread(object args)
{
var inputs = (Tuple<CancellationToken>) args;
var cancelToken = inputs.Item1;
var gl = new OpenGL();
int localRenderWidth = 1;
int localRenderHeight = 1;
if (!createRenderContext(gl, localRenderWidth, localRenderHeight))
{
//TODO better error handling here
Console.WriteLine("*** Unable to create OpenGL Render Context");
return;
}
uint activeVaoHandle;
uint activeGlProgramHandle;
initGLObjects(gl, out activeVaoHandle, out activeGlProgramHandle);
ActiveProgramValues localActiveProgramValues = null;
while (!cancelToken.IsCancellationRequested)
{
bool resizeRenderContext;
lock (this)
{
if (!ReferenceEquals(localActiveProgramValues, activeProgramValues))
{
localActiveProgramValues = activeProgramValues;
if (localActiveProgramValues.Valid)
{
linkProgram(gl, localActiveProgramValues, activeGlProgramHandle);
} else
{
// Leave the old program running. This prevents the user from seeing
// a black screen while they are in the process of modifying a shader.
}
}
resizeRenderContext = localRenderWidth != renderWidth || localRenderHeight != renderHeight;
localRenderWidth = renderWidth;
localRenderHeight = renderHeight;
}
if (resizeRenderContext)
{
localActiveProgramValues = null;
deleteGlObjects(gl, activeVaoHandle, activeGlProgramHandle);
if (!createRenderContext(gl, localRenderWidth, localRenderHeight))
{
//TODO better error handling here
Console.WriteLine("*** Unable to resize OpenGL Render Context");
return;
}
initGLObjects(gl, out activeVaoHandle, out activeGlProgramHandle);
}
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT);
gl.BindVertexArray(activeVaoHandle);
gl.UseProgram(activeGlProgramHandle);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3);
// do some other stuff while the image is rendering, to give it a chance to finish
ShaderCompiler.ValidateShaders(gl);
var provider = gl.RenderContextProvider as FBORenderContextProvider;
Debug.Assert(provider != null, "Render context provider is not an FBO renderer");
//TODO this call to blit will probably block. Find a better way to copy the image to CPU memory.
gl.Blit(IntPtr.Zero);
var hBitmap = provider.InternalDIBSection.HBitmap;
if (hBitmap != IntPtr.Zero)
{
var bitmap = GetFormattedBitmapSource(hBitmap);
// the bitmap needs to be frozen in order to share it between threads
bitmap.Freeze();
ImageRendered(bitmap);
}
}
deleteGlObjects(gl, activeVaoHandle, activeGlProgramHandle);
}
void CreateAndPlotData(OpenGL GL, float[] raw_data, int figureID)
{
if (_dataTail[figureID] + raw_data.Length >= C_SAMPLES_PER_FRAME)
{
_dataTail[figureID] = 0; // Clear the buffer
}
AddVerticesToFigure(figureID, raw_data, _dataTail[figureID]);
// Create the vertex array object.
vertexBufferArray = new VertexBufferArray();
vertexBufferArray.Create(GL);
vertexBufferArray.Bind(GL);
// Create a vertex buffer for the vertex data.
var vertexDataBuffer = new VertexBuffer();
vertexDataBuffer.Create(GL);
vertexDataBuffer.Bind(GL);
vertexDataBuffer.SetData(GL, attribute_vpos, _data[figureID], false, 3);
// Now do the same for the colour data.
var colourDataBuffer = new VertexBuffer();
colourDataBuffer.Create(GL);
colourDataBuffer.Bind(GL);
colourDataBuffer.SetData(GL, attribute_vcol, _dataColor[figureID], false, 3);
// Unbind the vertex array, we've finished specifying data for it.
vertexBufferArray.Unbind(GL);
// Bind the shader, set the matrices.
shaderProgram.Bind(GL);
//shaderProgram.SetUniformMatrix4(gl, "projectionMatrix", projectionMatrix.to_array());
//shaderProgram.SetUniformMatrix4(gl, "viewMatrix", viewMatrix.to_array());
shaderProgram.SetUniformMatrix4(GL, "modelMatrix", mviewdata.to_array());
// Bind the out vertex array.
vertexBufferArray.Bind(GL);
// Draw the square.
GL.DrawArrays(OpenGL.GL_LINE_STRIP, 0, _dataTail[figureID]);
// Unbind our vertex array and shader.
vertexBufferArray.Unbind(GL);
shaderProgram.Unbind(GL);
}
void CreateAndDrawGrid(OpenGL GL)
{
// Debug.WriteLine("Painting Begins..");
// Create vertices for 4 lines that will split the figure into 3 equal sections
xgrid = new vec3[(C_NUM_Y_DIV + 1) * 2];
for (int i = 0; i < (C_NUM_Y_DIV + 1) * 2; i = i + 2)
{
xgrid[i].x = -1f; xgrid[i + 1].x = 1f;
xgrid[i].y = C_X_MARGIN_MIN + C_Y_STEP * i / 2; xgrid[i + 1].y = C_X_MARGIN_MIN + C_Y_STEP * i / 2;
xgrid[i].z = 0f; xgrid[i + 1].z = 0f;
}
coldata = new vec3[] {
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White)
};
mviewdata = new mat4(1.0f);
// --------------- Implementation WITH VERTEX ARRAY OBJECTS --------------------
//// Create the vertex array object.
vertexBufferArray = new VertexBufferArray();
vertexBufferArray.Create(GL);
vertexBufferArray.Bind(GL);
// Create a vertex buffer for the vertex data.
var vertexDataBuffer = new VertexBuffer();
vertexDataBuffer.Create(GL);
vertexDataBuffer.Bind(GL);
vertexDataBuffer.SetData(GL, attribute_vpos, xgrid, false, 3);
// Now do the same for the colour data.
var colourDataBuffer = new VertexBuffer();
colourDataBuffer.Create(GL);
colourDataBuffer.Bind(GL);
colourDataBuffer.SetData(GL, attribute_vcol, coldata, false, 3);
// Unbind the vertex array, we've finished specifying data for it.
vertexBufferArray.Unbind(GL);
// Bind the shader, set the matrices.
shaderProgram.Bind(GL);
//shaderProgram.SetUniformMatrix4(gl, "projectionMatrix", projectionMatrix.to_array());
//shaderProgram.SetUniformMatrix4(gl, "viewMatrix", viewMatrix.to_array());
shaderProgram.SetUniformMatrix4(GL, "modelview", mviewdata.to_array());
// Bind the out vertex array.
vertexBufferArray.Bind(GL);
GL.DrawArrays(OpenGL.GL_LINES, 0, 8);
// Unbind our vertex array and shader.
vertexBufferArray.Unbind(GL);
shaderProgram.Unbind(GL);
// --------------- Implementation WITH VERTEX ARRAY OBJECTS END --------------------
}
/// <summary>
/// 渲染基质
/// </summary>
/// <param name="gl"></param>
/// <param name="renderMode"></param>
private void DoRenderMatrix(OpenGL gl, RenderMode renderMode)
{
if (this.positionBuffer == null || this.colorBuffer == null) { return; }
if (this.RenderGrid && this.matrixVertexArrayObject != null)
{
shaderProgram.SetUniform1(gl, "renderingWireframe", 0.0f);
shaderProgram.SetUniform1(gl, "opacity", this.Opacity);
gl.Enable(OpenGL.GL_POLYGON_OFFSET_FILL);
gl.PolygonOffset(1.0f, 1.0f);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(SharpGL.Enumerations.BlendingSourceFactor.SourceAlpha, SharpGL.Enumerations.BlendingDestinationFactor.OneMinusSourceAlpha);
gl.BindVertexArray(matrixVertexArrayObject[0]);
switch (this.MatrixType)
{
case MatrixFormat.Triangle:
gl.DrawArrays(this.matrixRenderMode, 0, this.MatrixVertexOrIndexCount);
break;
case MatrixFormat.Tetrahedron:
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, this.matrixIndexBuffer[0]);
gl.DrawElements(this.matrixRenderMode, this.MatrixVertexOrIndexCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
break;
case MatrixFormat.TriangularPrism:
// 先渲染三棱柱的上下三角形
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, this.MatrixVertexOrIndexCount);
// 再渲染三棱柱的三个侧面
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, this.matrixIndexBuffer[0]);
gl.DrawElements(this.matrixRenderMode, this.MatrixVertexOrIndexCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
break;
default:
break;
}
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_BLEND);
gl.Disable(OpenGL.GL_POLYGON_OFFSET_FILL);
}
if (this.RenderGridWireframe && this.matrixVertexArrayObject != null)
{
shaderProgram.SetUniform1(gl, "renderingWireframe", 1.0f);
shaderProgram.SetUniform1(gl, "opacity", this.Opacity);
gl.PolygonMode(SharpGL.Enumerations.FaceMode.FrontAndBack, SharpGL.Enumerations.PolygonMode.Lines);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(SharpGL.Enumerations.BlendingSourceFactor.SourceAlpha, SharpGL.Enumerations.BlendingDestinationFactor.OneMinusSourceAlpha);
gl.BindVertexArray(matrixVertexArrayObject[0]);
switch (this.MatrixType)
{
case MatrixFormat.Triangle:
gl.DrawArrays(this.matrixRenderMode, 0, this.MatrixVertexOrIndexCount);
break;
case MatrixFormat.Tetrahedron:
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, this.matrixIndexBuffer[0]);
gl.DrawElements(this.matrixRenderMode, this.MatrixVertexOrIndexCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
break;
case MatrixFormat.TriangularPrism:
// 先渲染三棱柱的上下三角形
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, this.MatrixVertexOrIndexCount / 9 * 6);
// 再渲染三棱柱的三个侧面
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, this.matrixIndexBuffer[0]);
gl.DrawElements(this.matrixRenderMode, this.MatrixVertexOrIndexCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
break;
default:
break;
}
gl.PolygonMode(SharpGL.Enumerations.FaceMode.FrontAndBack, SharpGL.Enumerations.PolygonMode.Filled);
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_BLEND);
}
}
private void DoRenderFraction(OpenGL gl, RenderMode renderMode)
{
if (this.fractionPositionBuffer == null || this.fractionUVBuffer == null) { return; }
if (this.RenderFraction && this.fractionVertexArrayObject != null)
{
shaderProgram.SetUniform1(gl, "renderingWireframe", 0.0f);
gl.Enable(OpenGL.GL_POLYGON_OFFSET_FILL);
gl.PolygonOffset(1.0f, 1.0f);
gl.BindVertexArray(fractionVertexArrayObject[0]);
switch (this.FractionType)
{
case FractureFormat.Line:
float[] originalWidth = new float[1];
gl.GetFloat(SharpGL.Enumerations.GetTarget.LineWidth, originalWidth);
gl.LineWidth(this.FractionLineWidth);
gl.DrawArrays(OpenGL.GL_LINES, 0, this.FractionVertexCount);
gl.LineWidth(originalWidth[0]);
break;
case FractureFormat.Triange:
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, this.FractionVertexCount);
break;
case FractureFormat.Quad:
gl.DrawArrays(OpenGL.GL_QUADS, 0, this.FractionVertexCount);
break;
default:
throw new NotImplementedException();
//break;
}
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_POLYGON_OFFSET_FILL);
}
if (this.renderFractionWireframe && this.fractionVertexArrayObject != null)
{
shaderProgram.SetUniform1(gl, "renderingWireframe", 1.0f);
gl.BindVertexArray(fractionVertexArrayObject[0]);
{
gl.PolygonMode(SharpGL.Enumerations.FaceMode.FrontAndBack, SharpGL.Enumerations.PolygonMode.Lines);
switch (this.FractionType)
{
case FractureFormat.Line:
gl.DrawArrays(OpenGL.GL_LINES, 0, this.FractionVertexCount);
break;
case FractureFormat.Triange:
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, this.FractionVertexCount);
break;
case FractureFormat.Quad:
gl.DrawArrays(OpenGL.GL_QUADS, 0, this.FractionVertexCount);
break;
default:
break;
}
gl.PolygonMode(SharpGL.Enumerations.FaceMode.FrontAndBack, SharpGL.Enumerations.PolygonMode.Filled);
}
gl.BindVertexArray(0);
}
}
public void BindAll(OpenGL gl)
{
//return;
UseProgram(gl, () =>
{
// Update uniforms.
foreach (var action in ChangedUniforms)
{
action.Invoke(gl);
}
ChangedUniforms.Clear();
foreach (var group in BufferGroups)
{
group.BindVAO(gl);
gl.LineWidth(group.LineWidth);
// Use draw elements if an index buffer is defined. Else use draw arrays.
if (group.IndicesCount > 0)
gl.DrawElements(OpenGL.GL_LINES, group.IndicesCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
else
gl.DrawArrays(OpenGL.GL_LINES, 0, group.VerticesCount);
}
});
}
/// <summary>
/// Renders the scene in retained mode.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
public void RenderRetainedMode(OpenGL gl)
{
// Use the shader program.
shaderPerPixel.Bind(gl);
// Set the light position.
shaderPerPixel.SetUniform3(gl, "LightPosition", 0.25f, 0.25f, 10f);
// Set the matrices.
shaderPerPixel.SetUniformMatrix4(gl, "Projection", projectionMatrix.to_array());
shaderPerPixel.SetUniformMatrix4(gl, "Modelview", modelviewMatrix.to_array());
shaderPerPixel.SetUniformMatrix3(gl, "NormalMatrix", normalMatrix.to_array());
// Go through each mesh and render the vertex buffer array.
foreach(var mesh in meshes)
{
// Set the variables for the shader program.
shaderPerPixel.SetUniform3(gl, "DiffuseMaterial", mesh.material.Diffuse.r, mesh.material.Diffuse.g, mesh.material.Diffuse.b);
shaderPerPixel.SetUniform3(gl, "AmbientMaterial", mesh.material.Ambient.r, mesh.material.Ambient.g, mesh.material.Ambient.b);
shaderPerPixel.SetUniform3(gl, "SpecularMaterial", mesh.material.Specular.r, mesh.material.Specular.g, mesh.material.Specular.b);
shaderPerPixel.SetUniform1(gl, "Shininess", mesh.material.Shininess);
var vertexBufferArray = meshVertexBufferArrays[mesh];
vertexBufferArray.Bind(gl);
// IMPORTANT: This is interesting. If you use OpenGL 2.1, you can use quads. If you move to 3.0 or onwards,
// you can only draw the triangle types - cause 3.0 onwards deprecates other types.
// see: http://stackoverflow.com/questions/8041361/simple-opengl-clarification
// this shows that the OpenGL mode selection works - if I choose 2.1 I can draw quads, otherwise I can't.
// There's a good article on tesselating quads to triangles here:
// http://prideout.net/blog/?p=49
// This should be a sample!
uint mode = OpenGL.GL_TRIANGLES;
if (mesh.indicesPerFace == 4)
mode = OpenGL.GL_QUADS;
else if (mesh.indicesPerFace > 4)
mode = OpenGL.GL_POLYGON;
gl.DrawArrays(mode, 0, mesh.vertices.Length);
}
// Unbind the shader.
shaderPerPixel.Unbind(gl);
}
public override void Draw(OpenGL gl)
{
this.vertexBufferArray.Bind(gl);
gl.DrawArrays(OpenGL.GL_LINES, 0, this.lineCount*2);
this.vertexBufferArray.Unbind(gl);
}
public override void Draw(OpenGL gl)
{
this.vertexBufferArray.Bind(gl);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, this.cells.Count * 6); //cells.Count * 4);
this.vertexBufferArray.Unbind(gl);
}
/// <summary>
/// Function to draw the model
/// </summary>
private void drawModel(OpenGL gl)
{
if(l_vboId != null)
{
gl.EnableClientState(OpenGL.GL_VERTEX_ARRAY);
gl.EnableClientState(OpenGL.GL_COLOR_ARRAY);
// itering over each list of points
for(int k = 0; k < l_vboId.Count; k++)
{
gl.PushMatrix();
//transformations
gl.Scale(1.0f / f_scale, 1.0f / f_scale, 1.0f / f_scale);
gl.Translate(-v_center.X, -v_center.Y, -v_center.Z);
//vertexes
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, l_vboId[k][0]);
gl.VertexPointer(3, OpenGL.GL_FLOAT, 0, BUFFER_OFFSET_ZERO);
//color
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, l_vboId[k][1]);
gl.ColorPointer(3, OpenGL.GL_FLOAT, 0, BUFFER_OFFSET_ZERO);
//draw l_sizes[k] points
gl.DrawArrays(OpenGL.GL_POINTS, 0, l_sizes[k]);
gl.PopMatrix();
}
gl.DisableClientState(OpenGL.GL_VERTEX_ARRAY);
gl.DisableClientState(OpenGL.GL_COLOR_ARRAY);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, 0);
}
}
