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); }
/// <summary> /// Creation of vertex and color buffer from a List<Vertex>. This function reset all values once a new file is loaded /// </summary> private void createInitialBuffers() { // Get the OpenGL object. OpenGL gl = openGLControl.OpenGL; //create if (l_sizes == null) { l_sizes = new List <int>(); //create list to store points of each buffer's list } l_sizes.Add(l_vertex.Count); uint [] ids = new uint[2]; l_vboId.Add(ids); //create buffers gl.GenBuffers(2, l_vboId[0]); //vertex buffer gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, l_vboId[0][0]); IntPtr ptr1 = GCHandle.Alloc(l_vertex.ToArray().ToArray(), GCHandleType.Pinned).AddrOfPinnedObject(); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, sizeof(float) * l_vertex.Count * 3, ptr1, OpenGL.GL_STATIC_DRAW); //color buffer gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, l_vboId[0][1]); IntPtr ptr2 = GCHandle.Alloc(l_color.ToArray().ToArray(), GCHandleType.Pinned).AddrOfPinnedObject(); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, sizeof(float) * l_color.Count * 3, ptr2, OpenGL.GL_DYNAMIC_DRAW); //unbind buffers gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, 0); }
public void SetBufferData(OpenGL gl, IEnumerable <TransformationMatrix> transformations, OGLModelUsage usage = OGLModelUsage.StaticRead) { var transCount = transformations.Count(); // Validation. if (transCount > Math.Pow(2, 24)) { throw new OverflowException( "This shader can't handle more than 2^24 transformations while " + "using 24 bit colors."); } #region get indices var indices = new ushort[transCount]; for (ushort i = 0; i < indices.Length; i++) { indices[i] = i; // Do all transformations once. } #endregion get indices #region get transformations array var stride = 16; // Transformation matrix is a 4x4 = 16. var transformationsArray = new float[transCount * stride]; for (int i = 0; i < transCount; i++) { float[] transAsFloats = transformations.ElementAt(i).ResultMatrix.to_array(); for (int j = 0; j < stride; j++) { transformationsArray[i * stride + j] = transAsFloats[j]; } } #endregion get transformations array #region get color array int colorStride = 3; var colorArray = new float[transCount * colorStride]; for (int i = 0; i < transCount; i++) { ulong id = transformations.ElementAt(i).UniqueId; var color = new ColorF((uint)id); colorArray[i * stride] = color.R; colorArray[i * stride + 1] = color.G; colorArray[i * stride + 2] = color.B; } #endregion get color array gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _indicesBufferId.Value); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, indices, (uint)usage); gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _transformationsBufferId.Value); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, transformationsArray, (uint)usage); gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _colorsBufferId.Value); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, colorArray, (uint)usage); }
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 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)); }
public void BufferData(OpenGL gl, uint[] indices, float[] vertices, float[] normals, float[] ambs, float[] diffs, float[] specs, float[] shinis, float[] htColor) { gl.BindBuffer(_iboTarget, Ibo); gl.BufferData(_iboTarget, indices, _usage); gl.BindBuffer(_vboTarget, Position); gl.BufferData(_vboTarget, vertices, _usage); gl.BindBuffer(_vboTarget, Normal); gl.BufferData(_vboTarget, normals, _usage); gl.BindBuffer(_vboTarget, AmbientMaterial); gl.BufferData(_vboTarget, ambs, _usage); gl.BindBuffer(_vboTarget, DiffuseMaterial); gl.BufferData(_vboTarget, diffs, _usage); gl.BindBuffer(_vboTarget, SpecularMaterial); gl.BufferData(_vboTarget, specs, _usage); gl.BindBuffer(_vboTarget, ShininessValue); gl.BufferData(_vboTarget, shinis, _usage); gl.BindBuffer(_vboTarget, HTColorId); gl.BufferData(_vboTarget, htColor, _usage); }
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 }
public void BufferData(OpenGL gl, uint[] indices, float[] vertices, float[] colors) { if (indices != null) { gl.BindBuffer(_iboTarget, Ibo); gl.BufferData(_iboTarget, indices, _usage); } gl.BindBuffer(_vboTarget, Position); gl.BufferData(_vboTarget, vertices, _usage); gl.BindBuffer(_vboTarget, ColorValue); gl.BufferData(_vboTarget, colors, _usage); }
public void InitializeGrid(float duration) { InitializeBuffers(); var linesCount = ((int)duration + 1) * SubSegmentsInUnit + 1; _verticesCount = (linesCount + 1) * 2; _linesCoordinates = new float[_verticesCount * 2]; for (int i = 0; i < linesCount; i++) { var yValue = 0.15f; if (i % SubSegmentsInUnit == 0) { yValue *= 3; } _linesCoordinates[i * 4] = (float)i / SubSegmentsInUnit; _linesCoordinates[i * 4 + 1] = -yValue; _linesCoordinates[i * 4 + 2] = (float)i / SubSegmentsInUnit; _linesCoordinates[i * 4 + 3] = yValue; } //x axis line _linesCoordinates[linesCount * 4] = 0; _linesCoordinates[linesCount * 4 + 1] = 0; _linesCoordinates[linesCount * 4 + 2] = duration; _linesCoordinates[linesCount * 4 + 3] = 0; _gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vbo); _gl.BufferData(OpenGL.GL_ARRAY_BUFFER, _linesCoordinates, OpenGL.GL_STATIC_DRAW); _gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, OpenGLUtils.NO_BUFFER); }
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; }
public void SetData(OpenGL gl, uint attributeIndex, float[] rawData, bool isNormalised, int stride) { // Set the data, specify its shape and assign it to a vertex attribute (so shaders can bind to it). gl.BufferData(OpenGL.GL_ARRAY_BUFFER, rawData, OpenGL.GL_STATIC_DRAW); gl.VertexAttribPointer(attributeIndex, stride, OpenGL.GL_FLOAT, isNormalised, 0, IntPtr.Zero); gl.EnableVertexAttribArray(attributeIndex); }
private VertexBufferArray CreateVertexBufferArray(OpenGL gl, PrimordialObject primordialObject) { vertexBufferArray = new VertexBufferArray(); vertexBufferArray.Create(gl); vertexBufferArray.Bind(gl); vertexDataBuffer = new VertexBuffer(); vertexDataBuffer.Create(gl); vertexDataBuffer.Bind(gl); // for(int i = 0; i<100; i++) { // var sendDataTime = _stopwatch.ElapsedMilliseconds; gl.BufferData(OpenGL.GL_ARRAY_BUFFER, primordialObject.VertexData, OpenGL.GL_STATIC_DRAW); // File.AppendAllText(fileTitle + "Data.txt", (_stopwatch.ElapsedMilliseconds - sendDataTime).ToString() + "\n"); // } gl.VertexAttribPointer(attributeIndexPosition, 4, OpenGL.GL_FLOAT, false, 3 * 4 * sizeof(float), IntPtr.Zero); gl.EnableVertexAttribArray(0); gl.VertexAttribPointer(attributeIndexColour, 4, OpenGL.GL_FLOAT, false, 3 * 4 * sizeof(float), IntPtr.Add(IntPtr.Zero, 4 * sizeof(float))); gl.EnableVertexAttribArray(1); gl.VertexAttribPointer(attributeIndexNormal, 4, OpenGL.GL_FLOAT, false, 3 * 4 * sizeof(float), IntPtr.Add(IntPtr.Zero, 8 * sizeof(float))); gl.EnableVertexAttribArray(2); vertexDataBuffer.Unbind(gl); vertexBufferArray.Unbind(gl); return(vertexBufferArray); }
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); }
private void UpdateItem(int index) { numVertices = 0; if (index >= 0 && index < Variables.Count) { ObservedVariable variable = Variables[index]; if (DebugHandler.Debugger.CurrentMode == dbgDebugMode.dbgBreakMode) { PointCloud pointCloud = null; if (variable.MemberData == null) { pointCloud = DebugHandler.Load(variable.Name); } else { pointCloud = DebugHandler.Load(variable.Name, variable.MemberData); } if (pointCloud != null) { OpenGL gl = openGLControl.OpenGL; vao.Bind(gl); vbo.Bind(gl); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, pointCloud.vertices, OpenGL.GL_STATIC_DRAW); numVertices = pointCloud.numVertices; } } } }
protected uint CreateVertexBufferObject(uint mode, VertexBuffer bufferData, uint usage) { uint[] ids = new uint[1]; gl.GenBuffers(1, ids); gl.BindBuffer(mode, ids[0]); gl.BufferData(mode, bufferData.SizeInBytes, bufferData.Data, usage); return(ids[0]); }
public void Create(int bufferSize) { uint[] temp = new uint[1]; Device.GenBuffers(1, temp); Device.BindBuffer(OpenGL.GL_SHADER_STORAGE_BUFFER, temp[0]); Device.BufferData(OpenGL.GL_SHADER_STORAGE_BUFFER, bufferSize, IntPtr.Zero, OpenGL.GL_DYNAMIC_DRAW); Device.BindBuffer(OpenGL.GL_SHADER_STORAGE_BUFFER, 0); Buffer = temp[0]; }
private void InitTrianglesBuffer(OpenGL gl, UnmanagedArray <uint> TriangleStrip) { uint[] triangleBuffer = new uint[1]; gl.GenBuffers(triangleBuffer.Length, triangleBuffer); gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, triangleBuffer[0]); gl.BufferData(OpenGL.GL_ELEMENT_ARRAY_BUFFER, TriangleStrip.ByteLength, TriangleStrip.Header, OpenGL.GL_STATIC_DRAW); this.triangleIndexCount = TriangleStrip.Length; this.triangleBufferObject = triangleBuffer[0]; }
/// <summary> /// Calls the glBufferData(...). The data.Length will be used as value for Size property. /// </summary> /// <param name="gl">The gl.</param> /// <param name="target">The buffer data target.</param> /// <param name="data">The data as float.</param> /// <param name="usage">The usage.</param> /// <param name="stride">The amount of floats that form one input variable.</param> public virtual void SetBufferData(OpenGL gl, OGLBufferDataTarget target, float[] data, OGLModelUsage usage, int stride) { Size = data.Length / stride; Stride = stride; BufferDataType = OGLType.Float; gl.BufferData((uint)target, data, (uint)usage); }
/// <summary> /// Function invoked when points and colors must be added to the render. /// The size of lvertex and lcolor MUST BE THE SAME. Otherwise, there will be black points (no visible) /// </summary> /// <param name="lvertex"> List of vertexes to be added</param> /// <param name="lcolor"> List of colors to be added</param> private void addPointsAndColor(List <SharpGL.SceneGraph.Vertex> lvertex, List <SharpGL.SceneGraph.Vertex> lcolor) { OpenGL gl = openGLControl.OpenGL; //append new points to the existing list (if exists) if (l_vertex == null) { l_vertex = new List <SharpGL.SceneGraph.Vertex>(); } l_vertex.AddRange(lvertex); //append new colors to the existing list (if exists) if (l_color == null) { l_color = new List <SharpGL.SceneGraph.Vertex>(); } l_color.AddRange(lcolor); //set new size of the new list (just to render, if it exists) if (l_sizes == null) { l_sizes = new List <int>(); } l_sizes.Add(lvertex.Count); uint[] ids = new uint[2]; int pos = l_vboId.Count; //add ids to the existing list if (l_vboId == null) { l_vboId = new List <uint[]>(); } l_vboId.Add(ids); gl.GenBuffers(2, l_vboId[pos]); gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, l_vboId[pos][0]); IntPtr ptr1 = GCHandle.Alloc(lvertex.ToArray().ToArray(), GCHandleType.Pinned).AddrOfPinnedObject(); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, sizeof(float) * lvertex.Count * 3, ptr1, OpenGL.GL_STATIC_DRAW); gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, l_vboId[pos][1]); IntPtr ptr2 = GCHandle.Alloc(lcolor.ToArray().ToArray(), GCHandleType.Pinned).AddrOfPinnedObject(); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, sizeof(float) * lcolor.Count * 3, ptr2, OpenGL.GL_DYNAMIC_DRAW); gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, 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 override uint CreateVBO(UsageType usage) { OpenGL gl = new OpenGL(); uint[] buffers = new uint[1]; gl.GenBuffers(1, buffers); gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, buffers[0]); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, this.SizeInBytes, this.Data, (uint)usage); return(buffers[0]); }
private void FlushVertexArray(OpenGL gl, int vertexCount, int triangleCount) { if (vertexCount == 0 || triangleCount == 0) { return; } gl.PushMatrix(); gl.Translate(0, -300, 0); var bufferArrayData = vertexArray; gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vertexBuffer); if (_bufferSize < sizeof(float) * vertexCount * 8) { gl.BufferData( OpenGL.GL_ARRAY_BUFFER, sizeof(float) * vertexCount * 8, Marshal.UnsafeAddrOfPinnedArrayElement(bufferArrayData, 0), OpenGL.GL_DYNAMIC_DRAW); } else { gl.BufferSubData( OpenGL.GL_ARRAY_BUFFER, 0, sizeof(float) * vertexCount * 8, Marshal.UnsafeAddrOfPinnedArrayElement(bufferArrayData, 0)); } _bufferSize = Math.Max(sizeof(float) * vertexCount * 8, _bufferSize); gl.EnableClientState(OpenGL.GL_VERTEX_ARRAY); gl.EnableClientState(OpenGL.GL_COLOR_ARRAY); gl.EnableClientState(OpenGL.GL_TEXTURE_COORD_ARRAY); gl.VertexPointer(2, OpenGL.GL_FLOAT, 8 * sizeof(float), (IntPtr)0); gl.ColorPointer(4, OpenGL.GL_FLOAT, 8 * sizeof(float), (IntPtr)(2 * sizeof(float))); gl.TexCoordPointer(2, OpenGL.GL_FLOAT, 8 * sizeof(float), (IntPtr)(6 * sizeof(float))); gl.DrawElements( OpenGL.GL_TRIANGLES, triangleCount, OpenGL.GL_UNSIGNED_SHORT, Marshal.UnsafeAddrOfPinnedArrayElement(triangles, 0)); gl.DisableClientState(OpenGL.GL_VERTEX_ARRAY); gl.DisableClientState(OpenGL.GL_COLOR_ARRAY); gl.DisableClientState(OpenGL.GL_TEXTURE_COORD_ARRAY); gl.PopMatrix(); }
public static void SetArrayData(OpenGL gl, float[] data, int sizeInBytes, uint openGlDrawType) { unsafe { fixed(float *pointerToData = data) { IntPtr pointerToVerticesData = new IntPtr((void *)pointerToData); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, sizeInBytes, pointerToVerticesData, openGlDrawType); } } }
public static void SetElementData(OpenGL gl, uint[] data, int sizeInBytes, uint openGlDrawType) { unsafe { fixed(uint *pointerToData = data) { IntPtr pointerToIndicesData = new IntPtr((void *)pointerToData); gl.BufferData(OpenGL.GL_ELEMENT_ARRAY_BUFFER, sizeInBytes, pointerToIndicesData, openGlDrawType); pointerToIndicesData.ToInt32(); } } }
/// <summary> /// Calls the glBufferData(...). The size will be used as value for Size property. /// </summary> /// <param name="gl">The gl.</param> /// <param name="target">The buffer data target.</param> /// <param name="size">The size of the data buffer.</param> /// <param name="data">The pointer to the data in memory.</param> /// <param name="usage">The usage.</param> public virtual void SetBufferData(OpenGL gl, OGLBufferDataTarget target, int size, IntPtr data, OGLModelUsage usage, int stride, OGLType bufferDataType, bool bind = false, OGLBindBufferTarget bindTarget = OGLBindBufferTarget.ArrayBuffer) { Size = size / stride; Stride = stride; if (bind) { BindBuffer(gl, bindTarget); } gl.BufferData((uint)target, size, data, (uint)usage); }
// load given vertices into VBO private static void loadVertices(float[] vertices) { int size = Marshal.SizeOf(vertices[0]) * vertices.Length; IntPtr handle = Marshal.AllocHGlobal(size); try { Marshal.Copy(vertices, 0, handle, vertices.Length); var unmanagedSize = new IntPtr(size); OpenGL.BufferData(OpenGL.GL_ARRAY_BUFFER, unmanagedSize, handle, OpenGL.GL_STATIC_DRAW); } finally { Marshal.FreeHGlobal(handle); } }
static void Main(string[] args) { try { window = new Window("Text", 800, 600, false); //float[] vert = new float[]{ // -0.5f,-0.5f,0.0f, // -0.5f, 0.5f,0.0f, // 0.5f, 0.5f,0.0f, // 0.5f, 0.5f,0.0f, // 0.5f,-0.5f,0.0f, // -0.5f,-0.5f,0.0f, //}; float[] vert = new float[] { 0, 0, 0, 8, 0, 0, 0, 3, 0, 0, 3, 0, 8, 3, 0, 8, 0, 0, }; UInt32[] vbo = new UInt32[2]; gl.GenBuffers(1, vbo); gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, vbo[0]); gl.BufferData(OpenGL.GL_ARRAY_BUFFER, vert, OpenGL.GL_STATIC_DRAW); gl.VertexAttribPointer(0, 3, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero); gl.EnableVertexAttribArray(0); shader s = new shader("minimal.vert", "minimal.frag"); s.enable(); s.SetUniformMatrix("pr_matrix", Matrix.CreateOrthographic(0.0, 16.0, -1.0, 1.0)); s.SetUniformMatrix("ml_matrix", Matrix.CreateTranslation(new Vector3(2, 2, 0))); s.SetUniform("light_pos", new Vector2(4, 1.5f)); s.SetUniform("colour", new Vector4(0f, 0.0f, 1f, 1.0f)); } catch (Exception e) { Console.WriteLine(e.ToString()); } window.SetUpdate(EventUpdate, update); }
// load given indices into EBO private void loadIndices(uint[] indices) { byte[] data = indices.ToByteArray(); int size = Marshal.SizeOf(data[0]) * data.Length; IntPtr handle = Marshal.AllocHGlobal(size); try { Marshal.Copy(data, 0, handle, data.Length); var unmanagedSize = new IntPtr(size); OpenGL.BufferData(OpenGL.GL_ELEMENT_ARRAY_BUFFER, unmanagedSize, handle, OpenGL.GL_STATIC_DRAW); } finally { Marshal.FreeHGlobal(handle); } }
/// <summary> /// Calls the glBufferData(...). The data.Length will be used as value for Size property. /// </summary> /// <param name="gl">The gl.</param> /// <param name="target">The buffer data target.</param> /// <param name="data">The data as uint.</param> /// <param name="usage">The usage.</param> /// <param name="stride">The amount of uint that form one input variable.</param> public virtual void SetBufferData(OpenGL gl, OGLBufferDataTarget target, uint[] data, OGLModelUsage usage, int stride) { Size = data.Length / stride; Stride = stride; BufferDataType = OGLType.UnsignedInt; var dataSize = data.Length * sizeof(uint); IntPtr newDataPtr = Marshal.AllocHGlobal(dataSize); var intData = new int[data.Length]; Buffer.BlockCopy(data, 0, intData, 0, dataSize); Marshal.Copy(intData, 0, newDataPtr, data.Length); gl.BufferData((uint)target, dataSize, newDataPtr, (uint)usage); }
public void SetData(OpenGL gl, ushort[] rawData) { gl.BufferData(OpenGL.GL_ELEMENT_ARRAY_BUFFER, rawData, OpenGL.GL_STATIC_DRAW); }