public void CopyFromSystemMemory <T>( T[] bufferInSystemMemory, int destinationOffsetInBytes, int lengthInBytes) where T : struct { if (destinationOffsetInBytes < 0) { throw new ArgumentOutOfRangeException("destinationOffsetInBytes", "destinationOffsetInBytes must be greater than or equal to zero."); } if (destinationOffsetInBytes + lengthInBytes > _sizeInBytes) { throw new ArgumentOutOfRangeException( "destinationOffsetInBytes + lengthInBytes must be less than or equal to SizeInBytes."); } if (lengthInBytes < 0) { throw new ArgumentOutOfRangeException("lengthInBytes", "lengthInBytes must be greater than or equal to zero."); } if (lengthInBytes > ArraySizeInBytes.Size(bufferInSystemMemory)) { throw new ArgumentOutOfRangeException("lengthInBytes", "lengthInBytes must be less than or equal to the size of bufferInSystemMemory in bytes."); } Bind(); GL.BufferSubData <T>(_type, new IntPtr(destinationOffsetInBytes), new IntPtr(lengthInBytes), bufferInSystemMemory); }
public void Texture2D() { BlittableRGBA[] pixels = new BlittableRGBA[] { new BlittableRGBA(Color.Red), new BlittableRGBA(Color.Green) }; int sizeInBytes = ArraySizeInBytes.Size(pixels); Texture2DDescription description = new Texture2DDescription(2, 1, TextureFormat.RedGreenBlueAlpha8, false); using (GraphicsWindow window = Device.CreateWindow(1, 1)) using (WritePixelBuffer writePixelBuffer = Device.CreateWritePixelBuffer(PixelBufferHint.Stream, sizeInBytes)) using (Texture2D texture = Device.CreateTexture2D(description)) { writePixelBuffer.CopyFromSystemMemory(pixels); // // Create texture with pixel buffer // texture.CopyFromBuffer(writePixelBuffer, BlittableRGBA.Format, BlittableRGBA.Datatype); // // Read back pixels // using (ReadPixelBuffer readPixelBuffer = texture.CopyToBuffer(BlittableRGBA.Format, BlittableRGBA.Datatype)) { BlittableRGBA[] readPixels = readPixelBuffer.CopyToSystemMemory <BlittableRGBA>(); Assert.AreEqual(sizeInBytes, readPixelBuffer.SizeInBytes); Assert.AreEqual(pixels[0], readPixels[0]); Assert.AreEqual(pixels[1], readPixels[1]); Assert.AreEqual(description, texture.Description); } } }
private static VertexBuffer CreateVertexBuffer <T>(IList <T> values, BufferHint usageHint) where T : struct { T[] valuesArray = new T[values.Count]; values.CopyTo(valuesArray, 0); VertexBuffer vertexBuffer = Device.CreateVertexBuffer(usageHint, ArraySizeInBytes.Size(valuesArray)); vertexBuffer.CopyFromSystemMemory(valuesArray); return(vertexBuffer); }
public void VertexArray() { Vector3F[] positions = new Vector3F[] { new Vector3F(0, 0, 0), new Vector3F(1, 0, 0), new Vector3F(0, 1, 0) }; int vbSizeInBytes = ArraySizeInBytes.Size(positions); uint[] indices = new uint[] { 0, 1, 2 }; int ibSizeInBytes = indices.Length * sizeof(uint); using (GraphicsWindow window = Device.CreateWindow(1, 1)) using (VertexBuffer vertexBuffer = Device.CreateVertexBuffer(BufferHint.StaticDraw, vbSizeInBytes)) using (IndexBuffer indexBuffer = Device.CreateIndexBuffer(BufferHint.StreamDraw, ibSizeInBytes)) using (VertexArray va = window.Context.CreateVertexArray()) { vertexBuffer.CopyFromSystemMemory(positions); indexBuffer.CopyFromSystemMemory(indices); // // Create and verify vertex buffer attribute // VertexBufferAttribute vertexBufferAttribute = new VertexBufferAttribute( vertexBuffer, ComponentDatatype.Float, 3, false, 0, 0); Assert.AreEqual(vertexBuffer, vertexBufferAttribute.VertexBuffer); Assert.AreEqual(ComponentDatatype.Float, vertexBufferAttribute.ComponentDatatype); Assert.AreEqual(3, vertexBufferAttribute.NumberOfComponents); Assert.IsFalse(vertexBufferAttribute.Normalize); Assert.AreEqual(0, vertexBufferAttribute.OffsetInBytes); Assert.AreEqual(SizeInBytes <Vector3F> .Value, vertexBufferAttribute.StrideInBytes); // // Verify vertex array // va.Attributes[0] = vertexBufferAttribute; va.IndexBuffer = indexBuffer; Assert.AreEqual(vertexBufferAttribute, va.Attributes[0]); Assert.AreEqual(indexBuffer, va.IndexBuffer); va.Attributes[0] = null; va.IndexBuffer = null; Assert.IsNull(va.Attributes[0]); Assert.IsNull(va.IndexBuffer); } }
public void RenderNonInterleavedVertexBuffer() { Vector4F[] positions = new[] { new Vector4F(0, 0, 0, 1) }; BlittableRGBA[] colors = new[] { new BlittableRGBA(Color.Red) }; string vs = @"#version 330 layout(location = og_positionVertexLocation) in vec4 position; layout(location = og_colorVertexLocation) in vec4 color; out vec4 fsColor; void main() { gl_Position = position; fsColor = color; }"; string fs = @"#version 330 in vec4 fsColor; out vec4 FragColor; void main() { FragColor = fsColor; }"; using (GraphicsWindow window = Device.CreateWindow(1, 1)) using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context)) using (ShaderProgram sp = Device.CreateShaderProgram(vs, fs)) using (VertexBuffer vertexBuffer = Device.CreateVertexBuffer(BufferHint.StaticDraw, ArraySizeInBytes.Size(positions) + ArraySizeInBytes.Size(colors))) using (VertexArray va = window.Context.CreateVertexArray()) { int colorsOffset = ArraySizeInBytes.Size(positions); vertexBuffer.CopyFromSystemMemory(positions); vertexBuffer.CopyFromSystemMemory(colors, colorsOffset); va.Attributes[sp.VertexAttributes["position"].Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.Float, 4); va.Attributes[sp.VertexAttributes["color"].Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.UnsignedByte, 4, true, colorsOffset, 0); window.Context.Framebuffer = framebuffer; window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState()); TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 0, 0); } }
public void VertexBuffer() { Vector3F[] positions = new Vector3F[] { Vector3F.Zero, new Vector3F(1, 0, 0), new Vector3F(0, 1, 0) }; int sizeInBytes = ArraySizeInBytes.Size(positions); using (GraphicsWindow window = Device.CreateWindow(1, 1)) using (VertexBuffer vertexBuffer = Device.CreateVertexBuffer(BufferHint.StaticDraw, sizeInBytes)) { // // Verify creating vertex buffer // Assert.IsNotNull(vertexBuffer); Assert.AreEqual(BufferHint.StaticDraw, vertexBuffer.UsageHint); Assert.AreEqual(sizeInBytes, vertexBuffer.SizeInBytes); // // Verify copying entire buffer between system memory and vertex buffer // vertexBuffer.CopyFromSystemMemory(positions); Vector3F[] positions2 = vertexBuffer.CopyToSystemMemory <Vector3F>(0, vertexBuffer.SizeInBytes); Assert.AreEqual(positions[0], positions2[0]); Assert.AreEqual(positions[1], positions2[1]); Assert.AreEqual(positions[2], positions2[2]); // // Verify modiying a subset of the vertex buffer // Vector3F[] modifiedPositions = new Vector3F[] { new Vector3F(0, 1, 0), Vector3F.Zero }; vertexBuffer.CopyFromSystemMemory(modifiedPositions, SizeInBytes <Vector3F> .Value, SizeInBytes <Vector3F> .Value); Vector3F[] positions3 = vertexBuffer.CopyToSystemMemory <Vector3F>(0, vertexBuffer.SizeInBytes); Assert.AreEqual(positions[0], positions3[0]); Assert.AreEqual(modifiedPositions[0], positions3[1]); Assert.AreEqual(positions[2], positions3[2]); } }
public void Create() { _context.MakeCurrent(); int vbSizeInBytes = ArraySizeInBytes.Size(_positions); _vertexBuffer = Device.CreateVertexBuffer(BufferHint.StaticDraw, vbSizeInBytes); _vertexBuffer.CopyFromSystemMemory(_positions); _positions = null; Fence fence = Device.CreateFence(); while (fence.ClientWait(0) == ClientWaitResult.TimeoutExpired) { Thread.Sleep(10); } }
public void WritePixelBuffer() { BlittableRGBA[] pixels = new BlittableRGBA[] { new BlittableRGBA(Color.Red), new BlittableRGBA(Color.Green), new BlittableRGBA(Color.Blue), new BlittableRGBA(Color.White) }; int sizeInBytes = ArraySizeInBytes.Size(pixels); using (GraphicsWindow window = Device.CreateWindow(1, 1)) using (WritePixelBuffer pixelBuffer = Device.CreateWritePixelBuffer(PixelBufferHint.Stream, sizeInBytes)) { // // Verify creating pixel buffer // Assert.IsNotNull(pixelBuffer); Assert.AreEqual(PixelBufferHint.Stream, pixelBuffer.UsageHint); Assert.AreEqual(sizeInBytes, pixelBuffer.SizeInBytes); // // Verify copying entire buffer between system memory and pixel buffer // pixelBuffer.CopyFromSystemMemory(pixels); BlittableRGBA[] pixels2 = pixelBuffer.CopyToSystemMemory <BlittableRGBA>(0, pixelBuffer.SizeInBytes); Assert.AreEqual(pixels[0], pixels2[0]); Assert.AreEqual(pixels[1], pixels2[1]); Assert.AreEqual(pixels[2], pixels2[2]); // // Verify modiying a subset of the vertex buffer // BlittableRGBA modifiedPixel = new BlittableRGBA(Color.Black); pixelBuffer.CopyFromSystemMemory(new[] { modifiedPixel }, SizeInBytes <BlittableRGBA> .Value); BlittableRGBA[] pixels3 = pixelBuffer.CopyToSystemMemory <BlittableRGBA>(0, pixelBuffer.SizeInBytes); Assert.AreEqual(pixels[0], pixels3[0]); Assert.AreEqual(modifiedPixel, pixels3[1]); Assert.AreEqual(pixels[2], pixels3[2]); } }
public CPURelativeToEye(Context context, Vector3D[] positions, byte[] colors) { _sp = Device.CreateShaderProgram( EmbeddedResources.GetText("OpenGlobe.Examples.CPURelativeToEye.Shaders.VS.glsl"), EmbeddedResources.GetText("OpenGlobe.Examples.Shaders.FS.glsl")); _modelViewPerspectiveMatrixRelativeToEye = (Uniform <Matrix4F>)(_sp.Uniforms["u_modelViewPerspectiveMatrixRelativeToEye"]); _pointSize = (Uniform <float>)_sp.Uniforms["u_pointSize"]; /////////////////////////////////////////////////////////////////// _positions = new Vector3D[positions.Length]; positions.CopyTo(_positions, 0); _positionsRelativeToEye = new Vector3F[_positions.Length]; _eye = Vector3D.Zero; // // _positionBuffer is dynamic, and is written to when the camera moves. // _positionBuffer = Device.CreateVertexBuffer(BufferHint.DynamicDraw, ArraySizeInBytes.Size(_positionsRelativeToEye)); _colorBuffer = Device.CreateVertexBuffer(BufferHint.StaticDraw, colors.Length); _colorBuffer.CopyFromSystemMemory(colors); _va = context.CreateVertexArray(); _va.Attributes[_sp.VertexAttributes["position"].Location] = new VertexBufferAttribute(_positionBuffer, ComponentDatatype.Float, 3); _va.Attributes[_sp.VertexAttributes["color"].Location] = new VertexBufferAttribute(_colorBuffer, ComponentDatatype.UnsignedByte, 3, true, 0, 0); /////////////////////////////////////////////////////////////////// RenderState renderState = new RenderState(); renderState.FacetCulling.Enabled = false; renderState.DepthTest.Enabled = false; renderState.ProgramPointSize = ProgramPointSize.Enabled; _drawState = new DrawState(renderState, _sp, _va); }
public virtual void CopyFromSystemMemory <T>(T[] bufferInSystemMemory, int destinationOffsetInBytes) where T : struct { CopyFromSystemMemory <T>(bufferInSystemMemory, destinationOffsetInBytes, ArraySizeInBytes.Size(bufferInSystemMemory)); }
public static VertexArray CreateVertexArray(Context context, int positionLocation) { Vector4F[] positions = new[] { new Vector4F(0, 0, 0, 1) }; VertexBuffer positionsBuffer = Device.CreateVertexBuffer(BufferHint.StaticDraw, ArraySizeInBytes.Size(positions)); positionsBuffer.CopyFromSystemMemory(positions); VertexArray va = context.CreateVertexArray(); va.Attributes[positionLocation] = new VertexBufferAttribute(positionsBuffer, ComponentDatatype.Float, 4); va.DisposeBuffers = true; return(va); }
/// <summary> /// Creates a 1x1 RGBA8 texture /// </summary> public static Texture2D CreateTexture(BlittableRGBA rgba) { Texture2DDescription description = new Texture2DDescription(1, 1, TextureFormat.RedGreenBlueAlpha8, false); Texture2D texture = Device.CreateTexture2D(description); BlittableRGBA[] pixels = new BlittableRGBA[] { rgba }; using (WritePixelBuffer writePixelBuffer = Device.CreateWritePixelBuffer(PixelBufferHint.Stream, ArraySizeInBytes.Size(pixels))) { writePixelBuffer.CopyFromSystemMemory(pixels); texture.CopyFromBuffer(writePixelBuffer, ImageFormat.RedGreenBlueAlpha, ImageDatatype.UnsignedByte); } return(texture); }
public static MeshBuffers CreateMeshBuffers(Mesh mesh, ShaderVertexAttributeCollection shaderAttributes, BufferHint usageHint) { if (mesh == null) { throw new ArgumentNullException("mesh"); } if (shaderAttributes == null) { throw new ArgumentNullException("shaderAttributes"); } MeshBuffers meshBuffers = new MeshBuffers(); if (mesh.Indices != null) { if (mesh.Indices.Datatype == IndicesType.UnsignedShort) { IList <ushort> meshIndices = ((IndicesUnsignedShort)mesh.Indices).Values; ushort[] indices = new ushort[meshIndices.Count]; for (int j = 0; j < meshIndices.Count; ++j) { indices[j] = meshIndices[j]; } IndexBuffer indexBuffer = Device.CreateIndexBuffer(usageHint, indices.Length * sizeof(ushort)); indexBuffer.CopyFromSystemMemory(indices); meshBuffers.IndexBuffer = indexBuffer; } else if (mesh.Indices.Datatype == IndicesType.UnsignedInt) { IList <uint> meshIndices = ((IndicesUnsignedInt)mesh.Indices).Values; uint[] indices = new uint[meshIndices.Count]; for (int j = 0; j < meshIndices.Count; ++j) { indices[j] = meshIndices[j]; } IndexBuffer indexBuffer = Device.CreateIndexBuffer(usageHint, indices.Length * sizeof(uint)); indexBuffer.CopyFromSystemMemory(indices); meshBuffers.IndexBuffer = indexBuffer; } else { throw new NotSupportedException("mesh.Indices.Datatype " + mesh.Indices.Datatype.ToString() + " is not supported."); } } // // Emulated double precision vectors are a special case: one mesh vertex attribute // yields two shader vertex attributes. As such, these are handled separately before // normal attributes. // HashSet <string> ignoreAttributes = new HashSet <string>(); foreach (VertexAttribute attribute in mesh.Attributes) { if (attribute is VertexAttributeDoubleVector3) { VertexAttributeDoubleVector3 emulated = (VertexAttributeDoubleVector3)attribute; int highLocation = -1; int lowLocation = -1; foreach (ShaderVertexAttribute shaderAttribute in shaderAttributes) { if (shaderAttribute.Name == emulated.Name + "High") { highLocation = shaderAttribute.Location; } else if (shaderAttribute.Name == emulated.Name + "Low") { lowLocation = shaderAttribute.Location; } if ((highLocation != -1) && (lowLocation != -1)) { break; } } if ((highLocation == -1) && (lowLocation == -1)) { // // The shader did not have either attribute. No problem. // continue; } else if ((highLocation == -1) || (lowLocation == -1)) { throw new ArgumentException("An emulated double vec3 mesh attribute requires both " + emulated.Name + "High and " + emulated.Name + "Low vertex attributes, but the shader only contains one matching attribute."); } // // Copy both high and low parts into a single vertex buffer. // IList <Vector3D> values = ((VertexAttribute <Vector3D>)attribute).Values; Vector3F[] vertices = new Vector3F[2 * values.Count]; int j = 0; for (int i = 0; i < values.Count; ++i) { EmulatedVector3D v = new EmulatedVector3D(values[i]); vertices[j++] = v.High; vertices[j++] = v.Low; } VertexBuffer vertexBuffer = Device.CreateVertexBuffer(usageHint, ArraySizeInBytes.Size(vertices)); vertexBuffer.CopyFromSystemMemory(vertices); int stride = 2 * SizeInBytes <Vector3F> .Value; meshBuffers.Attributes[highLocation] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.Float, 3, false, 0, stride); meshBuffers.Attributes[lowLocation] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.Float, 3, false, SizeInBytes <Vector3F> .Value, stride); ignoreAttributes.Add(emulated.Name + "High"); ignoreAttributes.Add(emulated.Name + "Low"); } } // TODO: Not tested exhaustively foreach (ShaderVertexAttribute shaderAttribute in shaderAttributes) { if (ignoreAttributes.Contains(shaderAttribute.Name)) { continue; } if (!mesh.Attributes.Contains(shaderAttribute.Name)) { throw new ArgumentException("Shader requires vertex attribute \"" + shaderAttribute.Name + "\", which is not present in mesh."); } VertexAttribute attribute = mesh.Attributes[shaderAttribute.Name]; if (attribute.Datatype == VertexAttributeType.EmulatedDoubleVector3) { IList <Vector3D> values = ((VertexAttribute <Vector3D>)attribute).Values; Vector3F[] valuesArray = new Vector3F[values.Count]; for (int i = 0; i < values.Count; ++i) { valuesArray[i] = values[i].ToVector3F(); } VertexBuffer vertexBuffer = Device.CreateVertexBuffer(usageHint, ArraySizeInBytes.Size(valuesArray)); vertexBuffer.CopyFromSystemMemory(valuesArray); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.Float, 3); } else if (attribute.Datatype == VertexAttributeType.HalfFloat) { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <Half>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.HalfFloat, 1); } else if (attribute.Datatype == VertexAttributeType.HalfFloatVector2) { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <Vector2H>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.HalfFloat, 2); } else if (attribute.Datatype == VertexAttributeType.HalfFloatVector3) { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <Vector3H>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.HalfFloat, 3); } else if (attribute.Datatype == VertexAttributeType.HalfFloatVector4) { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <Vector4H>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.HalfFloat, 4); } else if (attribute.Datatype == VertexAttributeType.Float) { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <float>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.Float, 1); } else if (attribute.Datatype == VertexAttributeType.FloatVector2) { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <Vector2F>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.Float, 2); } else if (attribute.Datatype == VertexAttributeType.FloatVector3) { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <Vector3F>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.Float, 3); } else if (attribute.Datatype == VertexAttributeType.FloatVector4) { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <Vector4F>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.Float, 4); } else if (attribute.Datatype == VertexAttributeType.UnsignedByte) { if (attribute is VertexAttributeRGBA) { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <byte>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.UnsignedByte, 4, true, 0, 0); } else if (attribute is VertexAttributeRGB) { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <byte>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.UnsignedByte, 3, true, 0, 0); } else { VertexBuffer vertexBuffer = CreateVertexBuffer(((VertexAttribute <byte>)attribute).Values, usageHint); meshBuffers.Attributes[shaderAttribute.Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.UnsignedByte, 1); } } else { Debug.Fail("attribute.Datatype"); } } return(meshBuffers); }
public SceneGPURelativeToEyeLOD(Context context, Vector3D[] positions, byte[] colors) { _spHigh = Device.CreateShaderProgram( EmbeddedResources.GetText("OpenGlobe.Examples.GPURelativeToEyeLOD.Shaders.HighPrecisionVS.glsl"), EmbeddedResources.GetText("OpenGlobe.Examples.Shaders.FS.glsl")); _cameraEyeHigh = (Uniform <Vector3F>)_spHigh.Uniforms["u_cameraEyeHigh"]; _cameraEyeLow = (Uniform <Vector3F>)_spHigh.Uniforms["u_cameraEyeLow"]; _modelViewPerspectiveMatrixRelativeToEye = (Uniform <Matrix4F>)(_spHigh.Uniforms["u_modelViewPerspectiveMatrixRelativeToEye"]); _pointSizeHigh = (Uniform <float>)_spHigh.Uniforms["u_pointSize"]; /////////////////////////////////////////////////////////////////// Vector3F[] positionsHigh = new Vector3F[positions.Length]; Vector3F[] positionsLow = new Vector3F[positions.Length]; for (int i = 0; i < positions.Length; ++i) { Vector3DToTwoVector3F(positions[i], out positionsHigh[i], out positionsLow[i]); } _center = positions[6]; _positionBufferHigh = Device.CreateVertexBuffer(BufferHint.StaticDraw, ArraySizeInBytes.Size(positions)); _positionBufferLow = Device.CreateVertexBuffer(BufferHint.StaticDraw, ArraySizeInBytes.Size(positions)); _colorBuffer = Device.CreateVertexBuffer(BufferHint.StaticDraw, colors.Length); _positionBufferHigh.CopyFromSystemMemory(positionsHigh); _positionBufferLow.CopyFromSystemMemory(positionsLow); _colorBuffer.CopyFromSystemMemory(colors); _vaHigh = context.CreateVertexArray(); _vaHigh.Attributes[_spHigh.VertexAttributes["positionHigh"].Location] = new VertexBufferAttribute(_positionBufferHigh, ComponentDatatype.Float, 3); _vaHigh.Attributes[_spHigh.VertexAttributes["positionLow"].Location] = new VertexBufferAttribute(_positionBufferLow, ComponentDatatype.Float, 3); _vaHigh.Attributes[_spHigh.VertexAttributes["color"].Location] = new VertexBufferAttribute(_colorBuffer, ComponentDatatype.UnsignedByte, 3, true, 0, 0); /////////////////////////////////////////////////////////////////// RenderState renderState = new RenderState(); renderState.FacetCulling.Enabled = false; renderState.DepthTest.Enabled = false; renderState.ProgramPointSize = ProgramPointSize.Enabled; _drawStateHigh = new DrawState(renderState, _spHigh, _vaHigh); /////////////////////////////////////////////////////////////////// // Low Precision _spLow = Device.CreateShaderProgram( EmbeddedResources.GetText("OpenGlobe.Examples.GPURelativeToEyeLOD.Shaders.LowPrecisionVS.glsl"), EmbeddedResources.GetText("OpenGlobe.Examples.Shaders.FS.glsl")); _pointSizeLow = (Uniform <float>)_spLow.Uniforms["u_pointSize"]; _vaLow = context.CreateVertexArray(); _vaLow.Attributes[_spLow.VertexAttributes["position"].Location] = new VertexBufferAttribute(_positionBufferHigh, ComponentDatatype.Float, 3); _vaLow.Attributes[_spLow.VertexAttributes["color"].Location] = new VertexBufferAttribute(_colorBuffer, ComponentDatatype.UnsignedByte, 3, true, 0, 0); _drawStateLow = new DrawState(renderState, _spLow, _vaLow); }
public void RenderTriangle() { Vector4F[] positions = new[] { new Vector4F(-0.5f, -0.5f, 0, 1), new Vector4F(0.5f, -0.5f, 0, 1), new Vector4F(0.5f, 0.5f, 0, 1) }; ushort[] indices = new ushort[] { 0, 1, 2 }; using (GraphicsWindow window = Device.CreateWindow(1, 1)) using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context)) using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), ShaderSources.PassThroughFragmentShader())) using (VertexBuffer positionsBuffer = Device.CreateVertexBuffer(BufferHint.StaticDraw, ArraySizeInBytes.Size(positions))) using (IndexBuffer indexBuffer = Device.CreateIndexBuffer(BufferHint.StaticDraw, indices.Length * sizeof(ushort))) using (VertexArray va = window.Context.CreateVertexArray()) { positionsBuffer.CopyFromSystemMemory(positions); indexBuffer.CopyFromSystemMemory(indices); va.Attributes[sp.VertexAttributes["position"].Location] = new VertexBufferAttribute(positionsBuffer, ComponentDatatype.Float, 4); va.IndexBuffer = indexBuffer; window.Context.Framebuffer = framebuffer; window.Context.Draw(PrimitiveType.Triangles, 0, 3, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState()); TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 0, 0); // // Verify detach // window.Context.Clear(new ClearState() { Buffers = ClearBuffers.ColorBuffer, Color = Color.FromArgb(0, 255, 0) }); va.Attributes[sp.VertexAttributes["position"].Location] = null; va.IndexBuffer = null; window.Context.Draw(PrimitiveType.Triangles, 0, 0, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState()); TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 0, 255, 0); // // Verify rendering without indices // va.Attributes[sp.VertexAttributes["position"].Location] = new VertexBufferAttribute(positionsBuffer, ComponentDatatype.Float, 4); window.Context.Draw(PrimitiveType.Triangles, 0, 3, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState()); TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 0, 0); } }
public void RenderInterleavedVertexBuffer() { string vs = @"#version 330 layout(location = og_positionVertexLocation) in vec4 position; layout(location = og_colorVertexLocation) in vec4 color; out vec4 fsColor; void main() { gl_Position = position; fsColor = color; }"; string fs = @"#version 330 in vec4 fsColor; out vec4 FragColor; void main() { FragColor = fsColor; }"; InterleavedVertex[] vertices = new InterleavedVertex[] { new InterleavedVertex() { Position = new Vector4F(0, 0, 0, 1), Color = new BlittableRGBA(Color.Red) }, new InterleavedVertex() { Position = new Vector4F(0, 0, 0, 1), Color = new BlittableRGBA(Color.FromArgb(255, 0, 255, 0)) } }; GraphicsWindow window = Device.CreateWindow(1, 1); Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context); ShaderProgram sp = Device.CreateShaderProgram(vs, fs); VertexBuffer vertexBuffer = Device.CreateVertexBuffer(BufferHint.StaticDraw, ArraySizeInBytes.Size(vertices)); VertexArray va = window.Context.CreateVertexArray(); { int colorOffset = SizeInBytes <Vector4F> .Value; vertexBuffer.CopyFromSystemMemory(vertices); va.Attributes[sp.VertexAttributes["position"].Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.Float, 4, false, 0, SizeInBytes <InterleavedVertex> .Value); va.Attributes[sp.VertexAttributes["color"].Location] = new VertexBufferAttribute(vertexBuffer, ComponentDatatype.UnsignedByte, 4, true, colorOffset, SizeInBytes <InterleavedVertex> .Value); window.Context.Framebuffer = framebuffer; window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState()); TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 0, 0); window.Context.Draw(PrimitiveType.Points, 1, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState()); TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 0, 255, 0); } }