/// <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));
}
/// <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 Vertex 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 Vertex buffer.</param>
/// <param name="usage">The usage of this resource.</param>
/// <returns>A Vertex buffer</returns>
public static Buffer New(GraphicsDevice device, DataPointer value, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable)
{
return(Buffer.New(device, value, 0, BufferFlags.VertexBuffer, usage));
}
/// <summary>
/// Creates a new Vertex buffer with <see cref="GraphicsResourceUsage.Immutable"/> uasge 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="value">The value to initialize the Vertex buffer.</param>
/// <param name="usage">The usage of this resource.</param>
/// <returns>A Vertex 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.VertexBuffer, 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, Color.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 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 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 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 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>
/// <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>
/// <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 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 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));
}
private static Buffer <Matrix> CreateMatrixBuffer(GraphicsDevice graphicsDevice, int elementCount)
{
return(Buffer.New <Matrix>(graphicsDevice, elementCount, BufferFlags.ShaderResource | BufferFlags.StructuredBuffer, GraphicsResourceUsage.Dynamic));
}
/// <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));
}
/// <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));
}
/// <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="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 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));
}
public static Mesh ToStrideMesh(GraphicsDevice graphicsDevice, SimpleMesh g3Mesh, Vector3 offset, float scaling = 1f)
{
if (g3Mesh is null || g3Mesh.VertexCount == 0)
{
return(null);
}
var vertexDeclaration = GetVertexDeclaration(g3Mesh);
var vertices = new byte[g3Mesh.VertexCount * vertexDeclaration.VertexStride];
var boundingBox = BoundingBox.Empty;
BoundingSphere boundingSphere;
unsafe
{
fixed(byte *ptr = vertices)
{
byte *current = ptr;
for (int i = 0; i < g3Mesh.VertexCount; i++)
{
var vi = g3Mesh.GetVertexAll(i);
var p = (new Vector3((float)vi.v.x, (float)vi.v.y, (float)vi.v.z) + offset) * scaling;
BoundingBox.Merge(ref boundingBox, ref p, out boundingBox);
Unsafe.Write(current, p);
current += sizeof(Vector3);
if (vi.bHaveN)
{
Unsafe.Write(current, vi.n);
current += sizeof(Vector3);
}
if (vi.bHaveUV)
{
Unsafe.Write(current, vi.uv);
current += sizeof(Vector2);
}
if (vi.bHaveC)
{
Unsafe.Write(current, new Color(vi.c.x, vi.c.y, vi.c.z));
current += sizeof(Color);
}
}
BoundingSphere.FromPoints((IntPtr)ptr, 0, g3Mesh.VertexCount, vertexDeclaration.VertexStride, out boundingSphere);
}
}
var vertexBuffer = Buffer.New(graphicsDevice, vertices, vertexDeclaration.VertexStride, BufferFlags.VertexBuffer);
var indexBuffer = Buffer.Index.New(graphicsDevice, g3Mesh.Triangles.Reverse().ToArray());
return(new Mesh()
{
Draw = new MeshDraw()
{
VertexBuffers = new VertexBufferBinding[]
{
new VertexBufferBinding(vertexBuffer, vertexDeclaration, g3Mesh.VertexCount)
},
IndexBuffer = new IndexBufferBinding(indexBuffer, is32Bit: true, g3Mesh.Triangles.Length),
DrawCount = g3Mesh.Triangles.Length,
PrimitiveType = PrimitiveType.TriangleList
},
BoundingBox = boundingBox,
BoundingSphere = boundingSphere
});
}
/// <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));
}
/// <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 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 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));
}
/// <inheritdoc/>
public void Generate(IServiceRegistry services, Model model)
{
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var needsTempDevice = false;
var graphicsDevice = services?.GetSafeServiceAs <IGraphicsDeviceService>().GraphicsDevice;
if (graphicsDevice is 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.");
}
// Translate if necessary
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;
// TODO: Shouldn't be TransformNormal?
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 Multi texturing coords
var maxTexCoords = MathUtil.Clamp(NumberOfTextureCoordinates, 1, 10) - 1;
var result = VertexHelper.GenerateMultiTextureCoordinates(resultWithTangentBiNormal, vertexStride: 0, maxTexCoords);
var meshDraw = new MeshDraw();
var layout = result.Layout;
var vertexBuffer = result.VertexBuffer;
var indices = data.Indices;
if (indices.Length < 0xFFFF)
{
// 16-bit indices
var indicesShort = new ushort[indices.Length];
for (int i = 0; i < indicesShort.Length; i++)
{
indicesShort[i] = (ushort)indices[i];
}
var indexBuffer = Buffer.Index.New(graphicsDevice, indicesShort)
.RecreateWith(indicesShort);
meshDraw.IndexBuffer = new IndexBufferBinding(indexBuffer, is32Bit: false, indices.Length);
if (needsTempDevice)
{
var indexData = BufferData.New(BufferFlags.IndexBuffer, indicesShort);
meshDraw.IndexBuffer = new IndexBufferBinding(indexData.ToSerializableVersion(), is32Bit: false, indices.Length);
}
}
else
{
// 32-bit indices
var indexBuffer = Buffer.Index.New(graphicsDevice, indices)
.RecreateWith(indices);
meshDraw.IndexBuffer = new IndexBufferBinding(indexBuffer, is32Bit: true, indices.Length);
if (needsTempDevice)
{
var indexData = BufferData.New(BufferFlags.IndexBuffer, indices);
meshDraw.IndexBuffer = new IndexBufferBinding(indexData.ToSerializableVersion(), is32Bit: true, indices.Length);
}
}
var geometryBuffer = Buffer.New(graphicsDevice, vertexBuffer, BufferFlags.VertexBuffer)
.RecreateWith(vertexBuffer);
meshDraw.VertexBuffers = new[] { new VertexBufferBinding(geometryBuffer, 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 is not null)
{
model.Materials.Add(MaterialInstance);
}
if (needsTempDevice)
{
graphicsDevice.Dispose();
}
}
/// <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));
}
