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); }