internal void ReleaseBuffers()
{
if(IB != IndexBufferId.NULL)
{
MyHwBuffers.Destroy(IB);
IB = IndexBufferId.NULL;
}
if(VB != null)
{
foreach(var vb in VB)
{
//vb.Dispose();
MyHwBuffers.Destroy(vb);
}
VB = null;
}
}
internal unsafe static void InitBillboardsIndexBuffer(int billboardsLimit)
{
if(m_IB != IndexBufferId.NULL)
{
MyHwBuffers.Destroy(m_IB);
}
uint[] indices = new uint[billboardsLimit * 6];
for (int i = 0; i < billboardsLimit; i++)
{
indices[i * 6 + 0] = (uint)(i * 4 + 0);
indices[i * 6 + 1] = (uint)(i * 4 + 1);
indices[i * 6 + 2] = (uint)(i * 4 + 2);
indices[i * 6 + 3] = (uint)(i * 4 + 0);
indices[i * 6 + 4] = (uint)(i * 4 + 2);
indices[i * 6 + 5] = (uint)(i * 4 + 3);
}
fixed (uint* ptr = indices)
{
m_IB = MyHwBuffers.CreateIndexBuffer(MaxBillboards * 6, SharpDX.DXGI.Format.R32_UInt, BindFlags.IndexBuffer, ResourceUsage.Immutable, new IntPtr(ptr));
}
}
private void DestroyIndexBuffer()
{
if (m_cubeIB != IndexBufferId.NULL)
{
MyHwBuffers.Destroy(m_cubeIB);
m_cubeIB = IndexBufferId.NULL;
}
}
private unsafe void InitIndexBuffer()
{
DestroyIndexBuffer();
const int indexCount = 36;
ushort* indices = stackalloc ushort[indexCount];
indices[0] = 0; indices[1] = 1; indices[2] = 2;
indices[3] = 0; indices[4] = 2; indices[5] = 3;
indices[6] = 1; indices[7] = 5; indices[8] = 6;
indices[9] = 1; indices[10] = 6; indices[11] = 2;
indices[12] = 5; indices[13] = 4; indices[14] = 7;
indices[15] = 5; indices[16] = 7; indices[17] = 6;
indices[18] = 4; indices[19] = 0; indices[20] = 3;
indices[21] = 4; indices[22] = 3; indices[23] = 7;
indices[24] = 3; indices[25] = 2; indices[26] = 6;
indices[27] = 3; indices[28] = 6; indices[29] = 7;
indices[30] = 1; indices[31] = 0; indices[32] = 4;
indices[33] = 1; indices[34] = 4; indices[35] = 5;
m_cubeIB = MyHwBuffers.CreateIndexBuffer(indexCount, Format.R16_UInt, BindFlags.IndexBuffer, ResourceUsage.Immutable, new IntPtr(indices));
}
internal static void Destroy(ref IndexBufferId id)
{
if (id != IndexBufferId.NULL)
{
Destroy(id); id = IndexBufferId.NULL;
}
}
internal static void OnDeviceEnd()
{
if (m_IB != IndexBufferId.NULL)
{
MyHwBuffers.Destroy(m_IB);
m_IB = IndexBufferId.NULL;
}
}
internal static Format GetIndexBufferFormat(IndexBufferId id)
{
return IBuffersData[id.Index].Format;
}
internal static void Destroy(IndexBufferId id)
{
IbIndices.Remove(id);
if (IBuffersData[id.Index].Buffer != null)
{
IBuffersData[id.Index].Buffer.Dispose();
IBuffersData[id.Index].Buffer = null;
}
IBuffers.Free(id.Index);
}
//internal static void CreateInputLayout(byte[] bytecode)
//{
// m_inputLayout = MyVertexInputLayout.CreateLayout(MyVertexInputLayout.Empty().Append(MyVertexInputComponentType.POSITION3), bytecode);
//}
static unsafe void InitIB()
{
ushort[] indices = new ushort[]
{
// 0 1 2 3
0, 1, 2, 0, 2, 3,
// 1 5 6 2
1, 5, 6, 1, 6, 2,
// 5 4 7 6
5, 4, 7, 5, 7, 6,
// 4 0 3 7
4, 0, 3, 4, 3, 7,
// 3 2 6 7
3, 2, 6, 3, 6, 7,
// 1 0 4 5
1, 0, 4, 1, 4, 5
};
if(m_cubeIB == IndexBufferId.NULL)
{
fixed (ushort* I = indices)
{
m_cubeIB = MyHwBuffers.CreateIndexBuffer(indices.Length, Format.R16_UInt, BindFlags.IndexBuffer, ResourceUsage.Immutable, new IntPtr(I));
}
}
}
internal static void OnDeviceReset()
{
if (m_cubeIB != IndexBufferId.NULL)
{
MyHwBuffers.Destroy(m_cubeIB);
m_cubeIB = IndexBufferId.NULL;
}
InitIB();
}
MyRenderMeshInfo LoadMesh(string assetName, out MyLODDescriptor[] LodDescriptors)
{
//Debug.Assert(assetName.EndsWith(".mwm"));
#region Temporary for mwm endings
if (!assetName.EndsWith(".mwm"))
{
assetName += ".mwm";
}
#endregion
var meshVertexInput = MyVertexInputLayout.Empty;
LodDescriptors = null;
MyRenderMeshInfo result = new MyRenderMeshInfo();
var importer = new MyModelImporter();
var fsPath = Path.IsPathRooted(assetName) ? assetName : Path.Combine(MyFileSystem.ContentPath, assetName);
if (!MyFileSystem.FileExists(fsPath))
{
System.Diagnostics.Debug.Fail("Model " + assetName + " does not exists!");
return(MyAssetsLoader.GetDebugMesh().LODs[0].m_meshInfo);
}
string contentPath = null;
if (Path.IsPathRooted(assetName) && assetName.ToLower().Contains("models"))
{
contentPath = assetName.Substring(0, assetName.ToLower().IndexOf("models"));
}
try
{
importer.ImportData(fsPath, new string[]
{
MyImporterConstants.TAG_VERTICES,
MyImporterConstants.TAG_BLENDINDICES,
MyImporterConstants.TAG_BLENDWEIGHTS,
MyImporterConstants.TAG_NORMALS,
MyImporterConstants.TAG_TEXCOORDS0,
MyImporterConstants.TAG_TANGENTS,
MyImporterConstants.TAG_BINORMALS,
MyImporterConstants.TAG_BONES,
MyImporterConstants.TAG_MESH_PARTS,
MyImporterConstants.TAG_BOUNDING_BOX,
MyImporterConstants.TAG_BOUNDING_SPHERE,
MyImporterConstants.TAG_LODS,
});
Dictionary <string, object> tagData = importer.GetTagData();
// extract data
var positions = (HalfVector4[])tagData[MyImporterConstants.TAG_VERTICES];
System.Diagnostics.Debug.Assert(positions.Length > 0);
var verticesNum = positions.Length;
var boneIndices = (Vector4I[])tagData[MyImporterConstants.TAG_BLENDINDICES];
var boneWeights = (Vector4[])tagData[MyImporterConstants.TAG_BLENDWEIGHTS];
var normals = (Byte4[])tagData[MyImporterConstants.TAG_NORMALS];
var texcoords = (HalfVector2[])tagData[MyImporterConstants.TAG_TEXCOORDS0];
var tangents = (Byte4[])tagData[MyImporterConstants.TAG_TANGENTS];
var bintangents = (Byte4[])tagData[MyImporterConstants.TAG_BINORMALS];
var tangentBitanSgn = new Byte4[verticesNum];
for (int i = 0; i < verticesNum; i++)
{
var N = VF_Packer.UnpackNormal(normals[i].PackedValue);
var T = VF_Packer.UnpackNormal(tangents[i].PackedValue);
var B = VF_Packer.UnpackNormal(bintangents[i].PackedValue);
var tanW = new Vector4(T.X, T.Y, T.Z, 0);
tanW.W = T.Cross(N).Dot(B) < 0 ? -1 : 1;
tangentBitanSgn[i] = VF_Packer.PackTangentSignB4(ref tanW);
}
bool hasBonesInfo = false;
if (boneIndices.Length > 0 && boneWeights.Length > 0)
{
hasBonesInfo = true;
}
var bones = (MyModelBone[])tagData[MyImporterConstants.TAG_BONES];
//
var vertexBuffers = new List <VertexBufferId>();
IndexBufferId indexBuffer = IndexBufferId.NULL;
var submeshes = new Dictionary <MyMeshDrawTechnique, List <MyDrawSubmesh> >();
var submeshes2 = new Dictionary <MyMeshDrawTechnique, List <MySubmeshInfo> >();
var submeshesMeta = new List <MySubmeshInfo>();
int indicesNum = 0;
bool missingMaterial = false;
if (tagData.ContainsKey(MyImporterConstants.TAG_MESH_PARTS))
{
var indices = new List <uint>(positions.Length);
uint maxIndex = 0;
var meshParts = tagData[MyImporterConstants.TAG_MESH_PARTS] as List <MyMeshPartInfo>;
foreach (MyMeshPartInfo meshPart in meshParts)
{
# region Bones indirection
int[] bonesRemapping = null;
if (boneIndices.Length > 0 && bones.Length > MyRender11Constants.SHADER_MAX_BONES)
{
Dictionary <int, int> vertexChanged = new Dictionary <int, int>();
Dictionary <int, int> bonesUsed = new Dictionary <int, int>();
int trianglesNum = meshPart.m_indices.Count / 3;
for (int i = 0; i < trianglesNum; i++)
{
for (int j = 0; j < 3; j++)
{
int index = meshPart.m_indices[i * 3 + j];
if (boneWeights[index].X > 0)
{
bonesUsed[boneIndices[index].X] = 1;
}
if (boneWeights[index].Y > 0)
{
bonesUsed[boneIndices[index].Y] = 1;
}
if (boneWeights[index].Z > 0)
{
bonesUsed[boneIndices[index].Z] = 1;
}
if (boneWeights[index].W > 0)
{
bonesUsed[boneIndices[index].W] = 1;
}
}
}
if (bonesUsed.Count > MyRender11Constants.SHADER_MAX_BONES)
{
Debug.Assert(bonesUsed.Count <= MyRender11Constants.SHADER_MAX_BONES, "Model \"" + assetName + "\"'s part uses more than 60 bones, please split model on more parts");
}
var partBones = new List <int>(bonesUsed.Keys);
partBones.Sort();
if (partBones.Count > 0 && partBones[partBones.Count - 1] >= MyRender11Constants.SHADER_MAX_BONES)
{
for (int i = 0; i < partBones.Count; i++)
{
bonesUsed[partBones[i]] = i;
}
Dictionary <int, int> vertexTouched = new Dictionary <int, int>();
for (int i = 0; i < trianglesNum; i++)
{
for (int j = 0; j < 3; j++)
{
int index = meshPart.m_indices[i * 3 + j];
if (!vertexTouched.ContainsKey(index))
{
if (boneWeights[index].X > 0)
{
boneIndices[index].X = bonesUsed[boneIndices[index].X];
}
if (boneWeights[index].Y > 0)
{
boneIndices[index].Y = bonesUsed[boneIndices[index].Y];
}
if (boneWeights[index].Z > 0)
{
boneIndices[index].Z = bonesUsed[boneIndices[index].Z];
}
if (boneWeights[index].W > 0)
{
boneIndices[index].W = bonesUsed[boneIndices[index].W];
}
vertexTouched[index] = 1;
int changes = 0;
vertexChanged.TryGetValue(index, out changes);
vertexChanged[index] = changes + 1;
}
}
}
bonesRemapping = partBones.ToArray();
}
if (vertexChanged.Values.Count > 0)
{
Debug.Assert(vertexChanged.Values.Max() < 2, "Vertex shared between model parts, will likely result in wrong skinning");
}
}
#endregion
int startIndex = indices.Count;
int indexCount = meshPart.m_indices.Count;
uint minIndex = (uint)meshPart.m_indices[0];
foreach (var i in meshPart.m_indices)
{
indices.Add((uint)i);
minIndex = Math.Min(minIndex, (uint)i);
}
uint baseVertex = minIndex;
for (int i = startIndex; i < startIndex + indexCount; i++)
{
indices[i] -= minIndex;
maxIndex = Math.Max(maxIndex, indices[i]);
}
#region Material
var materialDesc = meshPart.m_MaterialDesc;
var matId = MyMeshMaterials1.GetMaterialId(materialDesc, contentPath);
var partKey = MyMeshMaterials1.Table[matId.Index].Technique;
var materialName = MyMeshMaterials1.Table[matId.Index].Name;
var list = submeshes.SetDefault(partKey, new List <MyDrawSubmesh>());
list.Add(new MyDrawSubmesh(indexCount, startIndex, (int)baseVertex, MyMeshMaterials1.GetProxyId(matId), bonesRemapping));
submeshesMeta.Add(new MySubmeshInfo
{
IndexCount = indexCount,
StartIndex = startIndex,
BaseVertex = (int)baseVertex,
BonesMapping = bonesRemapping,
Material = materialName.ToString(),
Technique = partKey
});
var list2 = submeshes2.SetDefault(partKey, new List <MySubmeshInfo>());
list2.Add(submeshesMeta[submeshesMeta.Count - 1]);
#endregion
}
indicesNum = indices.Count;
#region Fill gpu buffes
unsafe
{
if (maxIndex <= ushort.MaxValue)
{
// create 16 bit indices
var indices16 = new ushort[indices.Count];
for (int i = 0; i < indices.Count; i++)
{
indices16[i] = (ushort)indices[i];
}
result.Indices = indices16;
fixed(ushort *I = indices16)
{
indexBuffer = MyHwBuffers.CreateIndexBuffer(indices16.Length, Format.R16_UInt, BindFlags.IndexBuffer, ResourceUsage.Immutable, new IntPtr(I), assetName + " index buffer");
}
}
else
{
var indicesArray = indices.ToArray();
fixed(uint *I = indicesArray)
{
indexBuffer = MyHwBuffers.CreateIndexBuffer(indices.Count, Format.R32_UInt, BindFlags.IndexBuffer, ResourceUsage.Immutable, new IntPtr(I), assetName + " index buffer");
}
}
}
unsafe
{
if (!hasBonesInfo)
{
var vertices = new MyVertexFormatPositionH4[verticesNum];
for (int i = 0; i < verticesNum; i++)
{
vertices[i] = new MyVertexFormatPositionH4(positions[i]);
}
meshVertexInput = meshVertexInput.Append(MyVertexInputComponentType.POSITION_PACKED);
result.VertexPositions = vertices;
fixed(MyVertexFormatPositionH4 *V = vertices)
{
vertexBuffers.Add(MyHwBuffers.CreateVertexBuffer(verticesNum, sizeof(MyVertexFormatPositionH4), BindFlags.VertexBuffer, ResourceUsage.Immutable, new IntPtr(V), assetName + " vertex buffer " + vertexBuffers.Count));
}
}
else
{
var vertices = new MyVertexFormatPositionSkinning[verticesNum];
for (int i = 0; i < verticesNum; i++)
{
vertices[i] = new MyVertexFormatPositionSkinning(
positions[i],
new Byte4(boneIndices[i].X, boneIndices[i].Y, boneIndices[i].Z, boneIndices[i].W),
boneWeights[i]);
}
meshVertexInput = meshVertexInput.Append(MyVertexInputComponentType.POSITION_PACKED)
.Append(MyVertexInputComponentType.BLEND_WEIGHTS).Append(MyVertexInputComponentType.BLEND_INDICES);
fixed(MyVertexFormatPositionSkinning *V = vertices)
{
vertexBuffers.Add(MyHwBuffers.CreateVertexBuffer(verticesNum, sizeof(MyVertexFormatPositionSkinning), BindFlags.VertexBuffer, ResourceUsage.Immutable, new IntPtr(V), assetName + " vertex buffer " + vertexBuffers.Count));
}
}
// add second stream
{
var vertices = new MyVertexFormatTexcoordNormalTangent[verticesNum];
for (int i = 0; i < verticesNum; i++)
{
vertices[i] = new MyVertexFormatTexcoordNormalTangent(texcoords[i], normals[i], tangentBitanSgn[i]);
}
fixed(MyVertexFormatTexcoordNormalTangent *V = vertices)
{
vertexBuffers.Add(MyHwBuffers.CreateVertexBuffer(verticesNum, sizeof(MyVertexFormatTexcoordNormalTangent), BindFlags.VertexBuffer, ResourceUsage.Immutable, new IntPtr(V), assetName + " vertex buffer " + vertexBuffers.Count));
}
result.VertexExtendedData = vertices;
meshVertexInput = meshVertexInput
.Append(MyVertexInputComponentType.NORMAL, 1)
.Append(MyVertexInputComponentType.TANGENT_SIGN_OF_BITANGENT, 1)
.Append(MyVertexInputComponentType.TEXCOORD0_H, 1);
}
}
#endregion
}
#region Extract lods
if (tagData.ContainsKey(MyImporterConstants.TAG_LODS))
{
var tagLODs = tagData[MyImporterConstants.TAG_LODS];
if (((MyLODDescriptor[])tagLODs).Length > 0)
{
}
LodDescriptors = (MyLODDescriptor[])((MyLODDescriptor[])tagLODs).Clone();
}
#endregion
if (missingMaterial)
{
Debug.WriteLine(String.Format("Mesh {0} has missing material", assetName));
}
//indexBuffer.SetDebugName(assetName + " index buffer");
int c = 0;
//vertexBuffers.ForEach(x => x.SetDebugName(assetName + " vertex buffer " + c++));
//
result.BoundingBox = (BoundingBox)tagData[MyImporterConstants.TAG_BOUNDING_BOX];
result.BoundingSphere = (BoundingSphere)tagData[MyImporterConstants.TAG_BOUNDING_SPHERE];
result.VerticesNum = verticesNum;
result.IndicesNum = indicesNum;
result.VertexLayout = meshVertexInput;
result.IB = indexBuffer;
result.VB = vertexBuffers.ToArray();
result.IsAnimated = hasBonesInfo;
result.Parts = submeshes.ToDictionary(x => x.Key, x => x.Value.ToArray());
result.PartsMetadata = submeshes2.ToDictionary(x => x.Key, x => x.Value.ToArray());
result.m_submeshes = submeshesMeta;
IsAnimated |= result.IsAnimated;
importer.Clear();
return(result);
}
unsafe static void InitBillboardsIndexBuffer()
{
if(m_IB != IndexBufferId.NULL)
{
MyHwBuffers.Destroy(m_IB);
}
uint[] indices = new uint[MAX_BILLBOARDS_SIZE * 6];
for (int i = 0; i < MAX_BILLBOARDS_SIZE; i++)
{
indices[i * 6 + 0] = (uint)(i * 4 + 0);
indices[i * 6 + 1] = (uint)(i * 4 + 1);
indices[i * 6 + 2] = (uint)(i * 4 + 2);
indices[i * 6 + 3] = (uint)(i * 4 + 0);
indices[i * 6 + 4] = (uint)(i * 4 + 2);
indices[i * 6 + 5] = (uint)(i * 4 + 3);
}
fixed (uint* ptr = indices)
{
m_IB = MyHwBuffers.CreateIndexBuffer(MAX_BILLBOARDS_SIZE * 6, SharpDX.DXGI.Format.R32_UInt, BindFlags.IndexBuffer, ResourceUsage.Immutable, new IntPtr(ptr), "MyBillboardRenderer");
}
}
static unsafe void InitIB()
{
ushort[] indices = new ushort[]
{
// 0 1 2 3
0, 1, 2, 0, 2, 3,
// 1 5 6 2
1, 5, 6, 1, 6, 2,
// 5 4 7 6
5, 4, 7, 5, 7, 6,
// 4 0 3 7
4, 0, 3, 4, 3, 7,
// 3 2 6 7
3, 2, 6, 3, 6, 7,
// 1 0 4 5
1, 0, 4, 1, 4, 5
};
ushort[] indicesData = new ushort[DECAL_BATCH_SIZE * indices.Length];
var instanceLen = indices.Length;
for (int i = 0; i < DECAL_BATCH_SIZE; i++)
{
for (int j = 0; j < instanceLen; j++)
{
indicesData[i * instanceLen + j] = (ushort)(indices[j] + 8 * i);
}
}
if (m_IB == IndexBufferId.NULL)
{
fixed (ushort* I = indicesData)
{
m_IB = MyHwBuffers.CreateIndexBuffer(indicesData.Length, Format.R16_UInt, BindFlags.IndexBuffer, ResourceUsage.Immutable, new IntPtr(I), "MyScreenDecals");
}
}
}
internal static IndexBufferId CreateIndexBuffer(BufferDescription description, Format format, IntPtr ? data = null, string debugName = null)
{
var id = new IndexBufferId { Index = IBuffers.Allocate() };
MyArrayHelpers.Reserve(ref IBuffersData, id.Index + 1);
IBuffers.Data[id.Index] = new MyHwBufferDesc { Description = description, DebugName = debugName };
IBuffersData[id.Index] = new MyIndexBufferData { Format = format };
IbIndices.Add(id);
if (!data.HasValue)
{
InitIndexBuffer(id);
}
else
{
InitIndexBuffer(id, data.Value);
}
return id;
}
internal static Buffer GetIndexBuffer(IndexBufferId id)
{
return(IBuffersData[id.Index].Buffer);
}
internal static void InitIndexBuffer(IndexBufferId id, IntPtr data)
{
IBuffersData[id.Index].Buffer = new Buffer(MyRender11.Device, data, IBuffers.Data[id.Index].Description);
if (IBuffers.Data[id.Index].DebugName != null)
{
IBuffersData[id.Index].Buffer.DebugName = IBuffers.Data[id.Index].DebugName;
}
}
internal static Format GetIndexBufferFormat(IndexBufferId id)
{
return(IBuffersData[id.Index].Format);
}
internal static Buffer GetIndexBuffer(IndexBufferId id)
{
return IBuffersData[id.Index].Buffer;
}
internal static BufferDescription GetBufferDesc(IndexBufferId id)
{
return(IBuffers.Data[id.Index].Description);
}
internal static BufferDescription GetBufferDesc(IndexBufferId id)
{
return IBuffers.Data[id.Index].Description;
}
private static void InitDevice()
{
m_particleBuffer = new MyRWStructuredBuffer(MyGPUEmitters.MAX_PARTICLES, PARTICLE_STRIDE, MyRWStructuredBuffer.UAVType.Default, true, "MyGPUParticleRenderer::particleBuffer");
m_deadListBuffer = new MyRWStructuredBuffer(MyGPUEmitters.MAX_PARTICLES, sizeof(uint), MyRWStructuredBuffer.UAVType.Append, false, "MyGPUParticleRenderer::deadListBuffer");
m_skippedParticleCountBuffer = new MyRWStructuredBuffer(1, sizeof(uint), MyRWStructuredBuffer.UAVType.Counter, true, "MyGPUParticleRenderer::skippedParticleCountBuffer");
#if DEBUG
// Create a staging buffer that is used to read GPU atomic counter into that can then be mapped for reading
// back to the CPU for debugging purposes
m_debugCounterBuffer = new MyReadStructuredBuffer(1, sizeof(uint), "MyGPUParticleRenderer::debugCounterBuffer");
#endif
var description = new SharpDX.Direct3D11.BufferDescription(4 * sizeof(uint),
SharpDX.Direct3D11.ResourceUsage.Default, SharpDX.Direct3D11.BindFlags.ConstantBuffer, SharpDX.Direct3D11.CpuAccessFlags.None,
SharpDX.Direct3D11.ResourceOptionFlags.None, sizeof(uint));
m_activeListConstantBuffer = MyHwBuffers.CreateConstantsBuffer(description, "MyGPUParticleRenderer::activeListConstantBuffer");
m_emitterConstantBuffer = MyHwBuffers.CreateConstantsBuffer(EMITTERCONSTANTBUFFER_SIZE, "MyGPUParticleRenderer::emitterConstantBuffer");
m_emitterStructuredBuffer = MyHwBuffers.CreateStructuredBuffer(MyGPUEmitters.MAX_LIVE_EMITTERS, EMITTERDATA_SIZE, true, null,
"MyGPUParticleRenderer::emitterStructuredBuffer");
m_aliveIndexBuffer = new MyRWStructuredBuffer(MyGPUEmitters.MAX_PARTICLES, sizeof(float), MyRWStructuredBuffer.UAVType.Counter, true,
"MyGPUParticleRenderer::aliveIndexBuffer");
m_indirectDrawArgsBuffer = new MyIndirectArgsBuffer(5, sizeof(uint), "MyGPUParticleRenderer::indirectDrawArgsBuffer");
unsafe
{
uint[] indices = new uint[MyGPUEmitters.MAX_PARTICLES * 6];
for (uint i = 0, index = 0, vertex = 0; i < MyGPUEmitters.MAX_PARTICLES; i++)
{
indices[index + 0] = vertex + 0;
indices[index + 1] = vertex + 1;
indices[index + 2] = vertex + 2;
indices[index + 3] = vertex + 2;
indices[index + 4] = vertex + 1;
indices[index + 5] = vertex + 3;
vertex += 4;
index += 6;
}
fixed (uint* ptr = indices)
{
m_ib = MyHwBuffers.CreateIndexBuffer(MyGPUEmitters.MAX_PARTICLES * 6, SharpDX.DXGI.Format.R32_UInt,
SharpDX.Direct3D11.BindFlags.IndexBuffer, SharpDX.Direct3D11.ResourceUsage.Immutable, new IntPtr(ptr), "MyGPUParticleRenderer::indexBuffer");
}
}
//MyRender11.BlendAlphaPremult
}
