public static unsafe Buffer New <TData>(GraphicsDevice device, Spread <TData> fromData, BufferFlags bufferFlags, GraphicsResourceUsage usage) where TData : struct { var immutableArray = fromData._array; var array = Unsafe.As <ImmutableArray <TData>, TData[]>(ref immutableArray); return(Buffer.New(device, array, bufferFlags, usage)); }
/// <summary> /// Creates a new Structured buffer <see cref="GraphicsResourceUsage.Default" /> uasge. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <typeparam name="T">Type of the Structured buffer to get the sizeof from</typeparam> /// <param name="value">The value to initialize the Structured buffer.</param> /// <param name="isUnorderedAccess">if set to <c>true</c> this buffer supports unordered access (RW in HLSL).</param> /// <returns>A Structured buffer</returns> public static Buffer <T> New <T>(GraphicsDevice device, T[] value, bool isUnorderedAccess = false) where T : struct { var bufferFlags = BufferFlags.StructuredBuffer | BufferFlags.ShaderResource; if (isUnorderedAccess) { bufferFlags |= BufferFlags.UnorderedAccess; } return(Buffer.New(device, value, bufferFlags)); }
/// <summary> /// Creates a new Structured buffer accessible as a <see cref="ShaderResourceView" /> and optionaly as a <see cref="UnorderedAccessView" />. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="count">The number of element in this buffer.</param> /// <param name="elementSize">Size of the struct.</param> /// <param name="isUnorderedAccess">if set to <c>true</c> this buffer supports unordered access (RW in HLSL).</param> /// <returns>A Structured buffer</returns> public static Buffer New(GraphicsDevice device, int count, int elementSize, bool isUnorderedAccess = false) { var bufferFlags = BufferFlags.StructuredBuffer | BufferFlags.ShaderResource; if (isUnorderedAccess) { bufferFlags |= BufferFlags.UnorderedAccess; } return(Buffer.New(device, count * elementSize, elementSize, bufferFlags)); }
private void Init() { _tribuf = Buffer.New(GraphicsDevice, new[] { new Vector4(-0.5f, 0.5f, 0, 1), new Vector4(0.5f, 0.5f, 0, 1), new Vector4(0, -0.5f, 0, 1) }, BufferFlags.VertexBuffer, GraphicsResourceUsage.Immutable); simpleEffect = new EffectInstance(new Effect(GraphicsDevice, SpriteEffect.Bytecode)); simpleEffect.Parameters.Set(SpriteBaseKeys.MatrixTransform, Matrix.Identity); simpleEffect.UpdateEffect(GraphicsDevice); pipelineState = new MutablePipelineState(GraphicsDevice); pipelineState.State.SetDefaults(); pipelineState.State.InputElements = VertexDeclaration.CreateInputElements(); pipelineState.State.PrimitiveType = PrimitiveType; }
/// <summary> /// Creates a new Typed buffer <see cref="GraphicsResourceUsage.Default" /> uasge. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the Typed buffer.</param> /// <param name="viewFormat">The view format of the buffer.</param> /// <param name="isUnorderedAccess">if set to <c>true</c> this buffer supports unordered access (RW in HLSL).</param> /// <param name="usage">The usage of this resource.</param> /// <returns>A Typed buffer</returns> public static Buffer New(GraphicsDevice device, DataPointer value, PixelFormat viewFormat, bool isUnorderedAccess = false, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) { return(Buffer.New(device, value, 0, BufferFlags.ShaderResource | (isUnorderedAccess?BufferFlags.UnorderedAccess : BufferFlags.None), viewFormat, usage)); }
/// <summary> /// Creates a new Raw buffer with <see cref="GraphicsResourceUsage.Default"/> uasge by default. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the Raw buffer.</param> /// <param name="additionalBindings">The additional bindings (for example, to create a combined raw/index buffer, pass <see cref="BufferFlags.IndexBuffer" />)</param> /// <param name="usage">The usage of this resource.</param> /// <returns>A Raw buffer</returns> public static Buffer New(GraphicsDevice device, DataPointer value, BufferFlags additionalBindings = BufferFlags.None, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) { return(Buffer.New(device, value, 0, BufferFlags.RawBuffer | additionalBindings, usage)); }
/// <summary> /// Creates a new index buffer with <see cref="GraphicsResourceUsage.Immutable"/> uasge by default. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the index buffer.</param> /// <param name="is32BitIndex">Set to true if the buffer is using a 32 bit index or false for 16 bit index.</param> /// <param name="usage">The usage of this resource.</param> /// <returns>A index buffer</returns> public static Buffer New(GraphicsDevice device, byte[] value, bool is32BitIndex, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable) { return(Buffer.New(device, value, is32BitIndex ? 4 : 2, BufferFlags.IndexBuffer, PixelFormat.None, usage)); }
/// <summary> /// Creates a new index buffer with <see cref="GraphicsResourceUsage.Default"/> uasge by default. /// </summary> /// <typeparam name="T">Type of the index buffer to get the sizeof from</typeparam> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="usage">The usage.</param> /// <returns>A index buffer</returns> public static Buffer <T> New <T>(GraphicsDevice device, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct { return(Buffer.New <T>(device, 1, BufferFlags.IndexBuffer, usage)); }
/// <summary> /// Creates a new index buffer with <see cref="GraphicsResourceUsage.Immutable"/> uasge by default. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the index buffer.</param> /// <param name="usage">The usage of this resource.</param> /// <returns>A index buffer</returns> public static Buffer New(GraphicsDevice device, DataPointer value, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable) { return(Buffer.New(device, value, 0, BufferFlags.IndexBuffer, usage)); }
/// <summary> /// Creates a new constant buffer with <see cref="GraphicsResourceUsage.Dynamic"/> usage. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the constant buffer.</param> /// <param name="usage">The usage of this resource.</param> /// <returns>A constant buffer</returns> public static Buffer New(GraphicsDevice device, DataPointer value, GraphicsResourceUsage usage = GraphicsResourceUsage.Dynamic) { return(Buffer.New(device, value, 0, BufferFlags.ConstantBuffer, usage)); }
/// <summary> /// Creates a new constant buffer with <see cref="GraphicsResourceUsage.Dynamic"/> usage. /// </summary> /// <typeparam name="T">Type of the constant buffer to get the sizeof from</typeparam> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <returns>A constant buffer</returns> public static Buffer <T> New <T>(GraphicsDevice device) where T : struct { return(Buffer.New <T>(device, 1, BufferFlags.ConstantBuffer, GraphicsResourceUsage.Dynamic)); }
/// <summary> /// Creates a new StructuredCounter buffer <see cref="GraphicsResourceUsage.Default" /> uasge. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the StructuredCounter buffer.</param> /// <param name="elementSize">Size of the element.</param> /// <returns>A StructuredCounter buffer</returns> public static Buffer New(GraphicsDevice device, DataPointer value, int elementSize) { const BufferFlags BufferFlags = BufferFlags.StructuredCounterBuffer | BufferFlags.ShaderResource | BufferFlags.UnorderedAccess; return(Buffer.New(device, value, elementSize, BufferFlags)); }
/// <summary> /// Creates a new StructuredCounter buffer <see cref="GraphicsResourceUsage.Default" /> uasge. /// </summary> /// <typeparam name="T">Type of the StructuredCounter buffer to get the sizeof from</typeparam> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the StructuredCounter buffer.</param> /// <returns>A StructuredCounter buffer</returns> public static Buffer New <T>(GraphicsDevice device, T[] value) where T : struct { const BufferFlags BufferFlags = BufferFlags.StructuredCounterBuffer | BufferFlags.ShaderResource | BufferFlags.UnorderedAccess; return(Buffer.New(device, value, BufferFlags)); }
/// <summary> /// Creates a new StructuredCounter buffer accessible as a <see cref="ShaderResourceView" /> and optionaly as a <see cref="UnorderedAccessView" />. /// </summary> /// <typeparam name="T">Type of the element in the structured buffer</typeparam> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="count">The number of element in this buffer.</param> /// <returns>A Structured buffer</returns> public static Buffer <T> New <T>(GraphicsDevice device, int count) where T : struct { const BufferFlags BufferFlags = BufferFlags.StructuredCounterBuffer | BufferFlags.ShaderResource | BufferFlags.UnorderedAccess; return(Buffer.New <T>(device, count, BufferFlags)); }
/// <summary> /// Creates a new StructuredAppend buffer accessible as a <see cref="ShaderResourceView" /> and as a <see cref="UnorderedAccessView" />. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="count">The number of element in this buffer.</param> /// <param name="elementSize">Size of the struct.</param> /// <returns>A StructuredAppend buffer</returns> public static Buffer New(GraphicsDevice device, int count, int elementSize) { const BufferFlags BufferFlags = BufferFlags.StructuredAppendBuffer | BufferFlags.ShaderResource | BufferFlags.UnorderedAccess; return(Buffer.New(device, count * elementSize, elementSize, BufferFlags)); }
/// <summary> /// Creates a new constant buffer with a default <see cref="GraphicsResourceUsage.Dynamic"/> usage. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="size">The size in bytes.</param> /// <param name="usage">The usage.</param> /// <returns>A constant buffer</returns> public static Buffer New(GraphicsDevice device, int size, GraphicsResourceUsage usage = GraphicsResourceUsage.Dynamic) { return(Buffer.New(device, size, BufferFlags.ConstantBuffer, usage)); }
/// <summary> /// Creates a temporary buffer. /// </summary> /// <param name="description">The description.</param> /// <param name="viewFormat">The shader view format on the buffer</param> /// <returns>Buffer.</returns> protected virtual Buffer CreateBuffer(BufferDescription description, PixelFormat viewFormat) { return(Buffer.New(GraphicsDevice, description, viewFormat)); }
/// <summary> /// Creates a new constant buffer with <see cref="GraphicsResourceUsage.Dynamic"/> usage. /// </summary> /// <typeparam name="T">Type of the constant buffer to get the sizeof from</typeparam> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the constant buffer.</param> /// <param name="usage">The usage of this resource.</param> /// <returns>A constant buffer</returns> public static Buffer <T> New <T>(GraphicsDevice device, T[] value, GraphicsResourceUsage usage = GraphicsResourceUsage.Dynamic) where T : struct { return(Buffer.New(device, value, BufferFlags.ConstantBuffer, usage)); }
/// <summary> /// Creates a new Vertex buffer with <see cref="GraphicsResourceUsage.Default"/> uasge by default. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="size">The size in bytes.</param> /// <param name="usage">The usage.</param> /// <param name="bindFlags">The bind flags, can be combined with <see cref="BufferFlags.StreamOutput"/> to use the buffer as a stream output target.</param> /// <returns> /// A Vertex buffer /// </returns> public static Buffer New(GraphicsDevice device, int size, GraphicsResourceUsage usage = GraphicsResourceUsage.Default, BufferFlags bindFlags = BufferFlags.VertexBuffer) { return(Buffer.New(device, size, bindFlags, usage)); }
public void Generate(IServiceRegistry services, Model model) { if (model == null) { throw new ArgumentNullException(nameof(model)); } var needsTempDevice = false; var graphicsDevice = services?.GetSafeServiceAs <IGraphicsDeviceService>().GraphicsDevice; if (graphicsDevice == null) { graphicsDevice = GraphicsDevice.New(); needsTempDevice = true; } var data = CreatePrimitiveMeshData(); if (data.Vertices.Length == 0) { throw new InvalidOperationException("Invalid GeometricPrimitive [{0}]. Expecting non-zero Vertices array"); } if (LocalOffset != Vector3.Zero) { for (var index = 0; index < data.Vertices.Length; index++) { data.Vertices[index].Position += LocalOffset; } } //Scale if necessary if (Scale != Vector3.One) { var inverseMatrix = Matrix.Scaling(Scale); inverseMatrix.Invert(); for (var index = 0; index < data.Vertices.Length; index++) { data.Vertices[index].Position *= Scale; Vector3.TransformCoordinate(ref data.Vertices[index].Normal, ref inverseMatrix, out data.Vertices[index].Normal); } } var boundingBox = BoundingBox.Empty; for (int i = 0; i < data.Vertices.Length; i++) { BoundingBox.Merge(ref boundingBox, ref data.Vertices[i].Position, out boundingBox); } BoundingSphere boundingSphere; unsafe { fixed(void *verticesPtr = data.Vertices) BoundingSphere.FromPoints((IntPtr)verticesPtr, 0, data.Vertices.Length, VertexPositionNormalTexture.Size, out boundingSphere); } var originalLayout = data.Vertices[0].GetLayout(); // Generate Tangent/BiNormal vectors var resultWithTangentBiNormal = VertexHelper.GenerateTangentBinormal(originalLayout, data.Vertices, data.Indices); // Generate Multitexcoords var result = VertexHelper.GenerateMultiTextureCoordinates(resultWithTangentBiNormal); var meshDraw = new MeshDraw(); var layout = result.Layout; var vertexBuffer = result.VertexBuffer; var indices = data.Indices; if (indices.Length < 0xFFFF) { var indicesShort = new ushort[indices.Length]; for (int i = 0; i < indicesShort.Length; i++) { indicesShort[i] = (ushort)indices[i]; } meshDraw.IndexBuffer = new IndexBufferBinding(Buffer.Index.New(graphicsDevice, indicesShort).RecreateWith(indicesShort), false, indices.Length); if (needsTempDevice) { var indexData = BufferData.New(BufferFlags.IndexBuffer, indicesShort); meshDraw.IndexBuffer = new IndexBufferBinding(indexData.ToSerializableVersion(), false, indices.Length); } } else { if (graphicsDevice.Features.CurrentProfile <= GraphicsProfile.Level_9_3) { throw new InvalidOperationException("Cannot generate more than 65535 indices on feature level HW <= 9.3"); } meshDraw.IndexBuffer = new IndexBufferBinding(Buffer.Index.New(graphicsDevice, indices).RecreateWith(indices), true, indices.Length); if (needsTempDevice) { var indexData = BufferData.New(BufferFlags.IndexBuffer, indices); meshDraw.IndexBuffer = new IndexBufferBinding(indexData.ToSerializableVersion(), true, indices.Length); } } meshDraw.VertexBuffers = new[] { new VertexBufferBinding(Buffer.New(graphicsDevice, vertexBuffer, BufferFlags.VertexBuffer).RecreateWith(vertexBuffer), layout, data.Vertices.Length) }; if (needsTempDevice) { var vertexData = BufferData.New(BufferFlags.VertexBuffer, vertexBuffer); meshDraw.VertexBuffers = new[] { new VertexBufferBinding(vertexData.ToSerializableVersion(), layout, data.Vertices.Length) }; } meshDraw.DrawCount = indices.Length; meshDraw.PrimitiveType = PrimitiveType.TriangleList; var mesh = new Mesh { Draw = meshDraw, BoundingBox = boundingBox, BoundingSphere = boundingSphere }; model.BoundingBox = boundingBox; model.BoundingSphere = boundingSphere; model.Add(mesh); if (MaterialInstance?.Material != null) { model.Materials.Add(MaterialInstance); } if (needsTempDevice) { graphicsDevice.Dispose(); } }
/// <summary> /// Creates a new Vertex buffer with <see cref="GraphicsResourceUsage.Default"/> usage by default. /// </summary> /// <typeparam name="T">Type of the Vertex buffer to get the sizeof from</typeparam> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="vertexBufferCount">Number of vertex in this buffer with the sizeof(T).</param> /// <param name="usage">The usage.</param> /// <returns>A Vertex buffer</returns> public static Buffer <T> New <T>(GraphicsDevice device, int vertexBufferCount, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct { return(Buffer.New <T>(device, vertexBufferCount, BufferFlags.VertexBuffer, usage)); }
/// <summary> /// Creates a new index buffer with <see cref="GraphicsResourceUsage.Default"/> uasge by default. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="size">The size in bytes.</param> /// <param name="usage">The usage.</param> /// <returns>A index buffer</returns> public static Buffer New(GraphicsDevice device, int size, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) { return(Buffer.New(device, size, BufferFlags.IndexBuffer, usage)); }
/// <summary> /// Creates a new Typed buffer <see cref="GraphicsResourceUsage.Default" /> uasge. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="count">The number of data with the following viewFormat.</param> /// <param name="viewFormat">The view format of the buffer.</param> /// <param name="isUnorderedAccess">if set to <c>true</c> this buffer supports unordered access (RW in HLSL).</param> /// <param name="usage">The usage.</param> /// <returns>A Typed buffer</returns> public static Buffer New(GraphicsDevice device, int count, PixelFormat viewFormat, bool isUnorderedAccess = false, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) { return(Buffer.New(device, count * viewFormat.SizeInBytes(), BufferFlags.ShaderResource | (isUnorderedAccess ? BufferFlags.UnorderedAccess : BufferFlags.None), viewFormat, usage)); }
/// <summary> /// Creates a new index buffer with <see cref="GraphicsResourceUsage.Immutable"/> uasge by default. /// </summary> /// <typeparam name="T">Type of the index buffer to get the sizeof from</typeparam> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the index buffer.</param> /// <param name="usage">The usage of this resource.</param> /// <returns>A index buffer</returns> public static Buffer <T> New <T>(GraphicsDevice device, T[] value, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable) where T : struct { return(Buffer.New(device, value, BufferFlags.IndexBuffer, usage)); }
/// <summary> /// Creates a new Typed buffer <see cref="GraphicsResourceUsage.Default" /> uasge. /// </summary> /// <typeparam name="T">Type of the Typed buffer to get the sizeof from</typeparam> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the Typed buffer.</param> /// <param name="viewFormat">The view format of the buffer.</param> /// <param name="isUnorderedAccess">if set to <c>true</c> this buffer supports unordered access (RW in HLSL).</param> /// <param name="usage">The usage of this resource.</param> /// <returns>A Typed buffer</returns> public static Buffer <T> New <T>(GraphicsDevice device, T[] value, PixelFormat viewFormat, bool isUnorderedAccess = false, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct { return(Buffer.New(device, value, BufferFlags.ShaderResource | (isUnorderedAccess ? BufferFlags.UnorderedAccess : BufferFlags.None), viewFormat, usage)); }
private unsafe Mesh ConvertToMesh(GraphicsDevice graphicsDevice, PrimitiveType primitiveType, LightProbeRuntimeData lightProbeRuntimeData) { // Generate data for vertex buffer var vertices = new VertexPositionNormalColor[lightProbeRuntimeData.LightProbes.Length]; for (var i = 0; i < lightProbeRuntimeData.LightProbes.Length; i++) { vertices[i] = new VertexPositionNormalColor(lightProbeRuntimeData.Vertices[i], Vector3.Zero, Color4.White); } // Generate data for index buffer var indices = new int[lightProbeRuntimeData.Faces.Count * 6]; for (var i = 0; i < lightProbeRuntimeData.Faces.Count; ++i) { var currentFace = lightProbeRuntimeData.Faces[i]; // Skip infinite edges to not clutter display // Maybe we could reenable it when we have better infinite nodes if (currentFace.Vertices[0] >= lightProbeRuntimeData.UserVertexCount || currentFace.Vertices[1] >= lightProbeRuntimeData.UserVertexCount || currentFace.Vertices[2] >= lightProbeRuntimeData.UserVertexCount) { continue; } indices[i * 6 + 0] = currentFace.Vertices[0]; indices[i * 6 + 1] = currentFace.Vertices[1]; indices[i * 6 + 2] = currentFace.Vertices[1]; indices[i * 6 + 3] = currentFace.Vertices[2]; indices[i * 6 + 4] = currentFace.Vertices[2]; indices[i * 6 + 5] = currentFace.Vertices[0]; } var boundingBox = BoundingBox.Empty; for (int i = 0; i < vertices.Length; i++) { BoundingBox.Merge(ref boundingBox, ref vertices[i].Position, out boundingBox); } // Compute bounding sphere BoundingSphere boundingSphere; fixed(void *verticesPtr = vertices) BoundingSphere.FromPoints((IntPtr)verticesPtr, 0, vertices.Length, VertexPositionNormalTexture.Size, out boundingSphere); var layout = vertices[0].GetLayout(); var meshDraw = new MeshDraw { IndexBuffer = new IndexBufferBinding(Buffer.Index.New(graphicsDevice, indices).RecreateWith(indices), true, indices.Length), VertexBuffers = new[] { new VertexBufferBinding(Buffer.New(graphicsDevice, vertices, BufferFlags.VertexBuffer).RecreateWith(vertices), layout, vertices.Length) }, DrawCount = indices.Length, PrimitiveType = primitiveType, }; wireframeResources.Add(meshDraw.VertexBuffers[0].Buffer); wireframeResources.Add(meshDraw.IndexBuffer.Buffer); return(new Mesh { Draw = meshDraw, BoundingBox = boundingBox, BoundingSphere = boundingSphere }); }
/// <summary> /// Creates a new Raw buffer with <see cref="GraphicsResourceUsage.Default"/> uasge by default. /// </summary> /// <typeparam name="T">Type of the Raw buffer to get the sizeof from</typeparam> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="value">The value to initialize the Raw buffer.</param> /// <param name="additionalBindings">The additional bindings (for example, to create a combined raw/index buffer, pass <see cref="BufferFlags.IndexBuffer" />)</param> /// <param name="usage">The usage of this resource.</param> /// <returns>A Raw buffer</returns> public static Buffer <T> New <T>(GraphicsDevice device, T[] value, BufferFlags additionalBindings = BufferFlags.None, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct { return(Buffer.New(device, value, BufferFlags.RawBuffer | additionalBindings, usage)); }