public void Init(OpenGL gl, uint blendMode, int particleCount, bool isContinous, bool autoRotateColors, Random random = null)
{
// Init particles
List <Particle> particles = new List <Particle>();
for (int x = 0; x < particleCount; x++)
{
Particle particle = new Particle(x);
particle.Init(_random);
if (AfterParticleInit != null)
{
AfterParticleInit(particle, 1.0f);
}
particles.Add(particle);
}
// Set member variables
if (random != null)
{
_random = random;
}
_blendMode = blendMode;
_isContinuous = isContinous;
_isActive = true;
_autoRotateColors = autoRotateColors;
_particles = particles;
_pointData = new float[_particles.Count * _point.DataStride];
if (_autoRotateColors)
{
_colorRotateStopwatch.Start();
}
pickColor();
// Load tex
_texture = gl.LoadTexture("Images/GlowParticle.png");
// OpenGL init
gl.GenVertexArrays(1, _vertexArrayObject);
gl.GenBuffers(1, _vertexBufferObject);
// Bind
gl.BindVertexArray(_vertexArrayObject[0]);
{
// Vertex buffer
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vertexBufferObject[0]);
GlBuffer.SetArrayData(gl, _pointData, _pointData.Length * PrimitiveSizes.FloatBytes, OpenGL.GL_STREAM_DRAW);
// Vertex attribute
gl.VertexAttribPointer(0, _point.VertexDataStride, OpenGL.GL_FLOAT, false, _point.DataStride * PrimitiveSizes.FloatBytes, IntPtr.Zero);
gl.EnableVertexAttribArray(0);
// Color attribute
gl.VertexAttribPointer(1, _point.ColorDataStride, OpenGL.GL_FLOAT, false, _point.DataStride * PrimitiveSizes.FloatBytes, new IntPtr(_point.VertexDataStride * PrimitiveSizes.FloatBytes));
gl.EnableVertexAttribArray(1);
}
gl.BindVertexArray(0); // Unbind
}
public void Create(OpenGL gl, Viewport viewport)
{
_viewport = viewport;
GC = new GraphicsContext();
GC.GL = gl;
shader = new Shader(GC, "vertex.vert", "frag.frag");
float[] vertices =
{
-1f, -1f, 0f,
-1f, 1f, 0f,
1f, -1f, 0f,
1f, 1f, 0.0f,
};
gl.GenBuffers(1, VBO);
gl.GenVertexArrays(1, VAO);
gl.BindVertexArray(VAO[0]);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, VBO[0]);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, vertices, OpenGL.GL_STATIC_DRAW);
gl.VertexAttribPointer(0, 3, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(0);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, 0);
gl.BindVertexArray(0);
}
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.BindVertexArray(this.vertexArrayObject[0]);
gl.DrawArrays(OpenGL.GL_POINTS, 0, count);
gl.BindVertexArray(0);
}
AfterRendering(gl, renderMode);
}
}
public void Begin()
{
if (IsDisposed)
{
throw new ObjectDisposedException(nameof(SpriteBatch));
}
gl.Disable(GL_CULL_FACE);
gl.Enable(GL_DEPTH_TEST);
gl.Enable(GL_BLEND);
gl.BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
gl.BlendEquation(GL_FUNC_ADD_EXT);
_shaderProgram.Bind(gl);
gl.BindBuffer(GL_ARRAY_BUFFER, vertexBufferIds[0]);
gl.BindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferIds[0]);
gl.BindVertexArray(vaos[0]);
currTexture = white1x1Tex;
}
public void Init(OpenGL gl)
{
// Data init
_pointData = new float[_pointSphere.VertexCount * _point.DataStride];
_colorIndex = _random.Next(Constants.Colors.Length / 3);
// Load tex
_texture = gl.LoadTexture("Images/GlowParticle.png");
// OpenGL init
gl.GenVertexArrays(1, _vertexArrayObject);
gl.GenBuffers(1, _vertexBufferObject);
// Bind
gl.BindVertexArray(_vertexArrayObject[0]);
{
// Vertex buffer
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vertexBufferObject[0]);
GlBuffer.SetArrayData(gl, _pointData, _pointData.Length * PrimitiveSizes.FloatBytes, OpenGL.GL_STREAM_DRAW);
// Vertex attribute
gl.VertexAttribPointer(0, _point.VertexDataStride, OpenGL.GL_FLOAT, false, _point.DataStride * PrimitiveSizes.FloatBytes, IntPtr.Zero);
gl.EnableVertexAttribArray(0);
// Color attribute
gl.VertexAttribPointer(1, _point.ColorDataStride, OpenGL.GL_FLOAT, false, _point.DataStride * PrimitiveSizes.FloatBytes, new IntPtr(_point.VertexDataStride * PrimitiveSizes.FloatBytes));
gl.EnableVertexAttribArray(1);
}
gl.BindVertexArray(0); // Unbind
}
public void Draw(OpenGL gl, mat4 projectionMatrix, mat4 viewMatrix)
{
theta += 0.07f;
mat4 rotation = glm.rotate(mat4.identity(), theta, new vec3(1, 1, 0));
mat4 translation = glm.translate(mat4.identity(), new vec3(0, 0, 0));
mat4 scale = glm.scale(mat4.identity(), new vec3(10.25f, 10.25f, 10.25f));
modelMatrix = rotation * scale * translation;
gl.UseProgram(shaderProgram);
// Bind the vertex Buffer Array
gl.BindVertexArray(VBA[0]);
// Bind the matrix to the Vertex shader matrix
var p = gl.GetUniformLocation(shaderProgram, "projectionMatrix");
gl.UniformMatrix4(p, 1, false, projectionMatrix.to_array());
var v = gl.GetUniformLocation(shaderProgram, "viewMatrix");
gl.UniformMatrix4(v, 1, false, viewMatrix.to_array());
var unif = gl.GetUniformLocation(shaderProgram, "ModelWorld4x4");
gl.UniformMatrix4(unif, 1, false, modelMatrix.to_array());
gl.BindTexture(OpenGL.GL_TEXTURE_2D, textureValue);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, vertices.Length);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0);
gl.BindVertexArray(0);
gl.UseProgram(0);
}
private void InitVertexes(OpenGL gl, UnmanagedArray <Vertex> vertexes, UnmanagedArray <ColorF> colorArray, UnmanagedArray <float> visibles)
{
uint[] vao = new uint[1];
gl.GenVertexArrays(vao.Length, vao);
gl.BindVertexArray(vao[0]);
this.vertexArrayObject = vao[0];
uint[] vboVertex = new uint[1];
gl.GenBuffers(vboVertex.Length, vboVertex);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, vboVertex[0]);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, vertexes.ByteLength, vertexes.Header, OpenGL.GL_STATIC_DRAW);
gl.VertexAttribPointer(ATTRIB_INDEX_POSITION, 3, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(ATTRIB_INDEX_POSITION);
this.vertexsBufferObject = vboVertex[0];
uint[] vboColor = new uint[1];
gl.GenBuffers(vboColor.Length, vboColor);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, vboColor[0]);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, colorArray.ByteLength, colorArray.Header, OpenGL.GL_DYNAMIC_DRAW);
gl.VertexAttribPointer(ATTRIB_INDEX_COLOUR, 4, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(ATTRIB_INDEX_COLOUR);
this.colorsBufferObject = vboColor[0];
uint[] vboVisual = new uint[1];
gl.GenBuffers(vboVisual.Length, vboVisual);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, vboVisual[0]);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, visibles.ByteLength, visibles.Header, OpenGL.GL_DYNAMIC_READ);
gl.VertexAttribPointer(ATTRIB_INDEX_VISIBLE, 1, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(ATTRIB_INDEX_VISIBLE);
this.visiblesBufferObject = vboVisual[0];
gl.BindVertexArray(0);
}
//private void InitVertexes(OpenGL gl, float [] vertexes, float[] colorArray)
//{
// uint ATTRIB_INDEX_POSITION = 0;
// uint ATTRIB_INDEX_COLOUR = 1;
// uint[] vao = new uint[1];
// gl.GenVertexArrays(vao.Length, vao);
// gl.BindVertexArray(vao[0]);
// uint[] vboVertex = new uint[1];
// gl.GenBuffers(vboVertex.Length, vboVertex);
// gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, vboVertex[0]);
// gl.BufferData(OpenGL.GL_ARRAY_BUFFER, vertexes, OpenGL.GL_STATIC_DRAW);
// gl.VertexAttribPointer(ATTRIB_INDEX_POSITION, 3, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
// gl.EnableVertexAttribArray(ATTRIB_INDEX_POSITION);
// uint[] vboColor = new uint[1];
// gl.GenBuffers(vboColor.Length, vboColor);
// gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, vboColor[0]);
// gl.BufferData(OpenGL.GL_ARRAY_BUFFER, colorArray, OpenGL.GL_DYNAMIC_DRAW);
// gl.VertexAttribPointer(ATTRIB_INDEX_COLOUR, 4, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
// gl.EnableVertexAttribArray(ATTRIB_INDEX_COLOUR);
// gl.BindVertexArray(0);
// gl.InvalidateBufferData(vboVertex[0]);
// gl.InvalidateBufferData(vboColor[0]);
// gl.DeleteBuffers(1, vboVertex);
// gl.DeleteBuffers(1, vboColor);
// gl.DeleteVertexArrays(1, vao);
//}
private void InitVertexes(OpenGL gl, UnmanagedArray <Vertex> vertexes, UnmanagedArray <ColorF> colorArray)
{
uint ATTRIB_INDEX_POSITION = 0;
uint ATTRIB_INDEX_COLOUR = 1;
uint[] vao = new uint[1];
gl.GenVertexArrays(vao.Length, vao);
gl.BindVertexArray(vao[0]);
uint[] vboVertex = new uint[1];
gl.GenBuffers(vboVertex.Length, vboVertex);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, vboVertex[0]);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, vertexes.ByteLength, vertexes.Header, OpenGL.GL_STATIC_DRAW);
gl.VertexAttribPointer(ATTRIB_INDEX_POSITION, 3, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(ATTRIB_INDEX_POSITION);
uint[] vboColor = new uint[1];
gl.GenBuffers(vboColor.Length, vboColor);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, vboColor[0]);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, colorArray.ByteLength, colorArray.Header, OpenGL.GL_DYNAMIC_DRAW);
gl.VertexAttribPointer(ATTRIB_INDEX_COLOUR, 4, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(ATTRIB_INDEX_COLOUR);
gl.BindVertexArray(0);
//gl.InvalidateBufferData(vboVertex[0]);
//gl.InvalidateBufferData(vboColor[0]);
gl.DeleteBuffers(1, vboVertex);
gl.DeleteBuffers(1, vboColor);
gl.DeleteVertexArrays(1, vao);
}
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);
}
}
private void CreateVertexArrayObject(OpenGL gl, RenderMode renderMode)
{
if (this.positionBuffer == null || this.colorBuffer == null)
{
return;
}
this.vertexArrayObject = new uint[1];
gl.GenVertexArrays(1, this.vertexArrayObject);
gl.BindVertexArray(this.vertexArrayObject[0]);
// prepare positions
{
int location = shaderProgram.GetAttributeLocation(gl, in_Position);
ATTRIB_INDEX_POSITION = (uint)location;
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, positionBuffer[0]);
gl.VertexAttribPointer(ATTRIB_INDEX_POSITION, 3, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(ATTRIB_INDEX_POSITION);
}
// prepare colors
{
int location = shaderProgram.GetAttributeLocation(gl, in_uv);
ATTRIB_INDEX_UV = (uint)location;
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, colorBuffer[0]);
gl.VertexAttribPointer(ATTRIB_INDEX_UV, 1, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(ATTRIB_INDEX_UV);
}
gl.BindVertexArray(0);
}
public void Init(OpenGL gl)
{
// Load tex
_texture = gl.LoadTexture("Images/LaserFlare.png");
// OpenGL init
gl.GenVertexArrays(1, _vertexArrayObject);
gl.GenBuffers(1, _vertexBufferObject);
// Bind
gl.BindVertexArray(_vertexArrayObject[0]);
{
// Vertex buffer
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vertexBufferObject[0]);
GlBuffer.SetArrayData(gl, _quad.VertexData, _quad.SizeOfVertexDataBytes, OpenGL.GL_STATIC_DRAW);
// Vertex attribute
gl.VertexAttribPointer(0, _quad.VertexDataStride, OpenGL.GL_FLOAT, false, _quad.DataStride * PrimitiveSizes.FloatBytes, IntPtr.Zero);
gl.EnableVertexAttribArray(0);
// Color attribute
gl.VertexAttribPointer(1, _quad.ColorDataStride, OpenGL.GL_FLOAT, false, _quad.DataStride * PrimitiveSizes.FloatBytes, new IntPtr(_quad.VertexDataStride * PrimitiveSizes.FloatBytes));
gl.EnableVertexAttribArray(1);
// Texture attribute
gl.VertexAttribPointer(2, _quad.TexCoordDataStride, OpenGL.GL_FLOAT, false, _quad.DataStride * PrimitiveSizes.FloatBytes, new IntPtr((_quad.VertexDataStride + _quad.ColorDataStride) * PrimitiveSizes.FloatBytes));
gl.EnableVertexAttribArray(2);
}
gl.BindVertexArray(0); // Unbind
}
public void PrepareVAO(OpenGL gl, LinesProgram program)
{
var vertArrIds = new uint[1];
gl.GenVertexArrays(1, vertArrIds);
Vao = vertArrIds[0];
gl.BindVertexArray(Vao);
BindVBOs(gl, program);
gl.EnableVertexAttribArray(0);
gl.BindVertexArray(0);
}
public void PrepareHTVAO(OpenGL gl, HitTestProgram program)
{
var vertArrIds = new uint[1];
gl.GenVertexArrays(1, vertArrIds);
VaoHT = vertArrIds[0];
gl.BindVertexArray(VaoHT);
BindHTVBOs(gl, program);
gl.EnableVertexAttribArray(0);
gl.BindVertexArray(0);
}
public void PrepareNMVAO(OpenGL gl, NormalMaterialProgram program)
{
var vertArrIds = new uint[1];
gl.GenVertexArrays(1, vertArrIds);
VaoNM = vertArrIds[0];
gl.BindVertexArray(VaoNM);
BindNMVBOs(gl, program);
gl.EnableVertexAttribArray(0);
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);
}
protected void Initialise(OpenGL gl, string textureName)
{
sp = new ShaderProg(gl);
// Load the shader's & link them to the program
shaderProgram = sp.Loader("Shader.vert", "Shader.frag");
VBA = new uint[1];
gl.GenVertexArrays(1, VBA);
gl.BindVertexArray(VBA[0]);
// Allocate 2 buffers (verts & UV's)
VBO = new uint[2];
// Generate the 2 buffers
gl.GenBuffers(2, VBO);
// Bind the first buffer
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, VBO[0]);
// Copy the data from the Vertex array into the array buffer
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, vertices, OpenGL.GL_STATIC_DRAW);
// Align the Buffer to the Vertex shader layout location value (0)
gl.VertexAttribPointer(0, 3, OpenGL.GL_FLOAT, false, 3 * sizeof(float), IntPtr.Zero);
// Unbind the buffer
gl.EnableVertexAttribArray(0);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, 0);
// Bind the UV's buffer
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, VBO[1]);
// Copy the data from the Colour array into the array buffer
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, texCoords, OpenGL.GL_STATIC_DRAW);
// Align the Buffer to the Vertex shader layout location value (1)
gl.VertexAttribPointer(1, 2, OpenGL.GL_FLOAT, false, 2 * sizeof(float), IntPtr.Zero);
// Unbind the buffer
gl.EnableVertexAttribArray(1);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, 0);
// Unbind VBA
gl.BindVertexArray(0);
texture.Create(gl, textureName);
textureValue = texture.TextureName;
// Specify linear filtering.
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MIN_FILTER, OpenGL.GL_LINEAR);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MAG_FILTER, OpenGL.GL_LINEAR);
// Create a model matrix to make the model a little bigger.
modelMatrix = glm.scale(new mat4(1.0f), new vec3(1.5f));//2.5
}
private void LoadSceneData(OpenGL gl)
{
var modelLoader = Model.Load("male_head");
modelLoader.Wait();
Shape = modelLoader.Result;
UI = new Legend();
gl.Enable(OpenGL.GL_DEPTH_TEST);
gl.Enable(OpenGL.GL_CULL_FACE);
gl.ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.GenVertexArrays(ArrayIds.Length, ArrayIds);
// Model data
gl.BindVertexArray(ArrayIds[0]);
gl.GenBuffers(ModelBufferIds.Length, ModelBufferIds);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, ModelBufferIds[0]);
gl.BufferData(OpenGL.GL_ELEMENT_ARRAY_BUFFER, Shape.Indices, OpenGL.GL_STATIC_DRAW);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, ModelBufferIds[1]);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, Shape.Data, OpenGL.GL_STATIC_DRAW);
gl.EnableVertexAttribArray(0);
gl.EnableVertexAttribArray(1);
gl.EnableVertexAttribArray(2);
gl.VertexAttribPointer(0, Shape.GetAttribSize(0), Shape.GetAttribType(0), Shape.ShouldAttribNormalize(0), Shape.GetAttribStride(0), Shape.GetAttribOffset(0));
gl.VertexAttribPointer(1, Shape.GetAttribSize(1), Shape.GetAttribType(1), Shape.ShouldAttribNormalize(1), Shape.GetAttribStride(1), Shape.GetAttribOffset(1));
gl.VertexAttribPointer(2, Shape.GetAttribSize(2), Shape.GetAttribType(2), Shape.ShouldAttribNormalize(2), Shape.GetAttribStride(2), Shape.GetAttribOffset(2));
// UI data
gl.BindVertexArray(ArrayIds[1]);
gl.GenBuffers(UIBufferIds.Length, UIBufferIds);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, UIBufferIds[0]);
gl.BufferData(OpenGL.GL_ELEMENT_ARRAY_BUFFER, UI.Indices, OpenGL.GL_STATIC_DRAW);
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, UIBufferIds[1]);
gl.BufferData(OpenGL.GL_ARRAY_BUFFER, UI.Data, OpenGL.GL_STATIC_DRAW);
gl.EnableVertexAttribArray(0);
gl.EnableVertexAttribArray(1);
gl.EnableVertexAttribArray(2);
gl.VertexAttribPointer(0, UI.GetAttribSize(0), UI.GetAttribType(0), UI.ShouldAttribNormalize(0), UI.GetAttribStride(0), UI.GetAttribOffset(0));
gl.VertexAttribPointer(1, UI.GetAttribSize(1), UI.GetAttribType(1), UI.ShouldAttribNormalize(1), UI.GetAttribStride(1), UI.GetAttribOffset(1));
gl.VertexAttribPointer(2, UI.GetAttribSize(2), UI.GetAttribType(2), UI.ShouldAttribNormalize(2), UI.GetAttribStride(2), UI.GetAttribOffset(2));
}
private void OpenGLControl_OpenGLDraw(object sender, OpenGLEventArgs args)
{
modelRotation += 0.01f;
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
// Reset the modelview matrix.
gl.LoadIdentity();
gl.UseProgram(theProgram);
int projLoc = gl.GetUniformLocation(theProgram, "projection");
int viewLoc = gl.GetUniformLocation(theProgram, "view");
int modelLoc = gl.GetUniformLocation(theProgram, "model");
int lightPosLoc = gl.GetUniformLocation(theProgram, "lightPos");
Matrix4x4 projectionMat = Matrix4x4.CreatePerspectiveFieldOfView(fov * (float)(Math.PI) / 180f, (float)gl.RenderContextProvider.Width / gl.RenderContextProvider.Height, 0.1f, 100);
//projectionMat = Matrix4x4.Identity;
float[] projectionFloats = projectionMat.ToFloatArray();
Vector3 pos = Vector3.Transform(cameraPosition, projectionMat);
gl.Uniform3(lightPosLoc, pos.X, pos.Y, pos.Z);
Matrix4x4 viewMat = Matrix4x4.CreateTranslation(cameraPosition);
//viewMat = Matrix4x4.Identity;
float[] viewFloats = viewMat.ToFloatArray();
Matrix4x4 modelMat = Matrix4x4.CreateRotationY(cameraRotation);
//modelMat = Matrix4x4.Identity;
float[] modelFloats = modelMat.ToFloatArray();
Matrix4x4 test = Matrix4x4.Multiply(modelMat, projectionMat);
gl.UniformMatrix4(projLoc, 1, false, projectionFloats);
gl.UniformMatrix4(viewLoc, 1, false, viewFloats);
gl.UniformMatrix4(modelLoc, 1, false, modelFloats);
gl.BindVertexArray(vertexAttributeObject);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, numberOfTriangles * 3);
gl.BindVertexArray(0);
gl.UseProgram(0);
gl.Flush();
}
public void Draw(OpenGL gl, float originX, float originY, float originZ, vec3 leftColor, vec3 rightColor, float audioModifier)
{
float scaleModifier = audioModifier * 1.6f;
if (scaleModifier < MinSize)
{
scaleModifier = MinSize;
}
for (int index = 0; index < _quad.VertexData.Length / _quad.DataStride; index++)
{
_quad.VertexData[index * _quad.DataStride + 3] = Constants.Colors[6, 0]; // r
_quad.VertexData[index * _quad.DataStride + 4] = Constants.Colors[6, 1]; // g
_quad.VertexData[index * _quad.DataStride + 5] = Constants.Colors[6, 2]; // b
_quad.VertexData[index * _quad.DataStride + 6] = 1.0f; // a
}
// Begin Draw
GlState.Instance.ModelMatrix = glm.translate(GlState.Instance.ModelMatrix, new vec3(originX, originY, originZ));
GlState.Instance.ModelMatrix = glm.scale(GlState.Instance.ModelMatrix, new vec3(scaleModifier, scaleModifier, scaleModifier));
// Update buffers
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vertexBufferObject[0]);
GlBuffer.SetArrayData(gl, _quad.VertexData, _quad.SizeOfVertexDataBytes, OpenGL.GL_STATIC_DRAW);
// Make model matrix available for drawing
gl.UniformMatrix4(GlState.Instance.DefaultTexturedModelMatrixLocation, 1, false, GlState.Instance.ModelMatrix.to_array());
// Set blending for particle system
gl.BlendFunc(OpenGL.GL_ONE, OpenGL.GL_ONE);
gl.DepthFunc(OpenGL.GL_ALWAYS);
// Draw
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, _texture);
gl.BindVertexArray(_vertexArrayObject[0]);
gl.DrawElements(OpenGL.GL_TRIANGLES, _quad.IndexData.Length, _quad.IndexData);
gl.BindVertexArray(0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0);
// Reset depth and blend func
gl.DepthFunc(OpenGL.GL_LESS);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
GlState.Instance.ModelMatrix = mat4.identity();
// End Draw
}
// create the OpenGL Vertex Array Object (VAO)
private static uint loadVertexArrayObject()
{
uint vertexArray = 0;
OpenGL.GenVertexArrays(1, ref vertexArray);
// bind VAO first, then bind and set vertex buffer(s) and attribute pointer(s).
OpenGL.BindVertexArray(vertexArray);
return(vertexArray);
}
public void Init(OpenGL gl)
{
_rowDrawStopwatch.Start();
// OpenGL Init
gl.GenVertexArrays(1, _vertexArrayObject);
gl.GenBuffers(1, _vertexBufferObject);
gl.GenBuffers(1, _positionBufferObject);
gl.GenBuffers(1, _colorBufferObject);
// Bind
gl.BindVertexArray(_vertexArrayObject[0]);
{
// Vertex attribute
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vertexBufferObject[0]);
GlBuffer.SetArrayData(gl, _cube.VertexData, _cube.SizeOfVertexDataBytes, OpenGL.GL_STATIC_DRAW);
gl.VertexAttribPointer(0, _cube.VertexDataStride, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(0);
// PositionAndSize attribute
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _positionBufferObject[0]);
GlBuffer.SetArrayData(gl, _allPositionData, _allPositionData.Length * PrimitiveSizes.FloatBytes, OpenGL.GL_STREAM_DRAW);
gl.VertexAttribPointer(1, PositionDataLength, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(1);
// Color attribute
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _colorBufferObject[0]);
GlBuffer.SetArrayData(gl, _colorData, _colorData.Length * PrimitiveSizes.FloatBytes, OpenGL.GL_STREAM_DRAW);
gl.VertexAttribPointer(2, ColorDataLength, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(2);
gl.VertexAttribDivisor(0, 0); // cube vertices : always reuse the same vertices -> 0
gl.VertexAttribDivisor(1, 1); // positions : one per cube (its center) -> 1
gl.VertexAttribDivisor(2, SpectrumsToDraw); // color : one per SpectrumsToDraw cubes -> 1
}
gl.BindVertexArray(0); // Unbind
}
public void Draw()
{
OpenGL.UseProgram(_shader.Program);
OpenGL.BindVertexArray(_vertexArray);
if (_elementBuffer != 0)
{
OpenGL.DrawElements(OpenGL.GL_TRIANGLES, 6, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
}
else
{
OpenGL.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3);
}
OpenGL.BindVertexArray(0);
}
public void InitializeBuffers()
{
if (IsInitialized())
{
return;
}
_gl.GenBuffers(1, _temp);
_vbo = _temp[0];
_gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vbo);
_gl.GenVertexArrays(1, _temp);
_vao = _temp[0];
_gl.BindVertexArray(_vao);
_gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vbo);
int positionAttribute = _gl.GetAttribLocation(_program, "vertexPosition");
_gl.VertexAttribPointer((uint)positionAttribute, 2, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
_gl.EnableVertexAttribArray((uint)positionAttribute);
_gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, OpenGLUtils.NO_BUFFER);
_gl.BindVertexArray(OpenGLUtils.NO_BUFFER);
}
public void BindVAO(OpenGL gl)
{
var isBuffer = new bool[]
{
gl.IsBuffer(Vao),
gl.IsBuffer(Ibo),
gl.IsBuffer(Position),
gl.IsBuffer(Normal),
gl.IsBuffer(Vao),
gl.IsBuffer(Vao),
gl.IsBuffer(Vao),
gl.IsBuffer(Vao),
};
gl.BindVertexArray(Vao);
}
public OctreeRenderer(OctreeModel model, OpenGL gl)
{
_gl = gl;
_octreeProgram = new OctreeShader(gl);
_cubes = new VAO(gl);
_cubeBuffer = new VBO(gl);
var filled = model.Node.Flatten().Where(o => o.State == NodeState.Filled).ToArray();
_count = filled.Length;
var list = new List <float>();
foreach (var octreeNode in filled)
{
list.AddRange(octreeNode.Center.ToArray().Select(d => (float)d));
list.AddRange(new[]
{
(float)MathsHelper.Map(octreeNode.Color.R, 0, 255, 0, 1),
(float)MathsHelper.Map(octreeNode.Color.G, 0, 255, 0, 1),
(float)MathsHelper.Map(octreeNode.Color.B, 0, 255, 0, 1),
(float)MathsHelper.Map(octreeNode.Color.A, 0, 255, 0, 1),
(float)octreeNode.Size
});
}
var vertices = list.ToArray();
using (new Bind(_cubes))
using (new Bind(_cubeBuffer))
{
_cubeBuffer.Update(vertices, vertices.Length * sizeof(float));
const int stride = sizeof(float) * 8;
gl.EnableVertexAttribArray(0);
gl.VertexAttribPointer(0, 3, OpenGL.GL_FLOAT, false, stride, new IntPtr(0));
gl.EnableVertexAttribArray(1);
gl.VertexAttribPointer(1, 4, OpenGL.GL_FLOAT, false, stride, new IntPtr(sizeof(float) * 3));
gl.EnableVertexAttribArray(2);
gl.VertexAttribPointer(2, 1, OpenGL.GL_FLOAT, false, stride, new IntPtr(sizeof(float) * 7));
gl.BindVertexArray(0);
}
}
public BackgroundRenderer(OpenGL gl)
{
_gl = gl;
_program = new BackgroundShader(gl);
_flat = new VAO(gl);
_flatBuffer = new VBO(gl);
using (new Bind(_flat))
using (new Bind(_flatBuffer))
{
var flatData = new float[] { -1, -1, 1, -1, -1, 1, 1, 1, };
_flatBuffer.Update(flatData, flatData.Length * sizeof(float));
gl.EnableVertexAttribArray(0);
gl.VertexAttribPointer(0, 2, OpenGL.GL_FLOAT, false, 0, new IntPtr(0));
gl.BindVertexArray(0);
}
}
public void BindAll(OpenGL gl)
{
UseProgram(gl, () =>
{
// Update uniforms.
foreach (var action in ChangedUniforms)
{
action.Invoke(gl);
}
ChangedUniforms.Clear();
foreach (var group in BufferGroups)
{
group.BindVAO(gl);
gl.DrawElements(OpenGL.GL_TRIANGLES, group.IndicesCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.BindVertexArray(0);
}
});
}
public SpriteBatch(OpenGL gl, int triCount = 4000)
{
this.gl = gl;
var textureLoaded = this.white1x1Tex.Create(gl, Properties.Resources.white1x1);
if (textureLoaded == false)
{
throw new Exception("white1x1Tex loading failed");
}
_shaderProgram.Create(gl, Properties.Resources.SimpleVS, Properties.Resources.SimplePS, null);
_shaderProgram.BindAttributeLocation(gl, VertexAttributes.Pos, nameof(VertexAttributes.Pos));
_shaderProgram.BindAttributeLocation(gl, VertexAttributes.Color, nameof(VertexAttributes.Color));
_shaderProgram.BindAttributeLocation(gl, VertexAttributes.TexCoord, nameof(VertexAttributes.TexCoord));
_shaderProgram.Bind(gl);
vertices = new VertexPosTexColor[triCount * 3];
indices = new int[triCount * 3];
gl.GenBuffers(1, vertexBufferIds);
gl.BindBuffer(GL_ARRAY_BUFFER, vertexBufferIds[0]);
gl.BufferData(GL_ARRAY_BUFFER, vertices.Length * VertexPosTexColor.SizeOf, IntPtr.Zero, GL_DYNAMIC_DRAW);
gl.GenBuffers(1, indexBufferIds);
gl.BindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferIds[0]);
gl.BufferData(GL_ELEMENT_ARRAY_BUFFER, indices.Length * sizeof(int), IntPtr.Zero, GL_DYNAMIC_DRAW);
gl.GenVertexArrays(1, vaos);
gl.BindVertexArray(vaos[0]);
gl.EnableVertexAttribArray(VertexAttributes.Pos);
gl.VertexAttribPointer(VertexAttributes.Pos, 3, GL_FLOAT, false, VertexPosTexColor.SizeOf, new IntPtr(0));
gl.EnableVertexAttribArray(VertexAttributes.Color);
gl.VertexAttribPointer(VertexAttributes.Color, 4, GL_UNSIGNED_BYTE, true, VertexPosTexColor.SizeOf, new IntPtr(3 * sizeof(float)));
gl.EnableVertexAttribArray(VertexAttributes.TexCoord);
gl.VertexAttribPointer(VertexAttributes.TexCoord, 2, GL_FLOAT, false, VertexPosTexColor.SizeOf, new IntPtr(3 * sizeof(float) + 4 * sizeof(byte)));
}
public PostProcesser(OpenGL gl, int width, int height)
{
_gl = gl;
_fbo = new FBO(gl, width, height);
_flatProgram = new FlatShader(gl);
_flat = new VAO(gl);
_flatBuffer = new VBO(gl);
using (new Bind(_flat))
using (new Bind(_flatBuffer))
{
var flatData = new float[] { -1, -1, 1, -1, -1, 1, 1, 1, };
_flatBuffer.Update(flatData, flatData.Length * sizeof(float));
gl.EnableVertexAttribArray(0);
gl.VertexAttribPointer(0, 2, OpenGL.GL_FLOAT, false, 0, new IntPtr(0));
gl.BindVertexArray(0);
}
}
public void Begin()
{
gl.Disable(GL_CULL_FACE);
gl.Enable(GL_DEPTH_TEST);
gl.Enable(GL_BLEND);
gl.BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
gl.BlendEquation(GL_FUNC_ADD_EXT);
_shaderProgram.Bind(gl);
gl.BindBuffer(GL_ARRAY_BUFFER, vertexBufferIds[0]);
gl.BindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferIds[0]);
gl.BindVertexArray(vaos[0]);
currTexture = white1x1Tex;
}
public void Unbind(OpenGL gl)
{
gl.BindVertexArray(0);
}
public void Bind(OpenGL gl)
{
gl.BindVertexArray(vertexArrayObject);
}
