private void CreateBuffers(ushort[] indices, short[] vertices)
{
var numIndices = (uint)indices.Length;
var numVertices = (uint)vertices.Length;
_vertexDeclaration = HardwareBufferManager.Singleton.CreateVertexDeclaration();
_vertexDeclaration.AddElement(0, 0, VertexElementType.VET_SHORT2, VertexElementSemantic.VES_POSITION);
_ib = HardwareBufferManager.Singleton.CreateIndexBuffer(HardwareIndexBuffer.IndexType.IT_16BIT, numIndices, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
_vb = HardwareBufferManager.Singleton.CreateVertexBuffer(_vertexDeclaration.GetVertexSize(0), numVertices, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY, false);
unsafe
{
fixed(ushort *x = indices)
_ib.WriteData(0, numIndices * sizeof(ushort), x, true);
fixed(short *x = vertices)
_vb.WriteData(0, numVertices * sizeof(ushort), x, true);
}
var binding = new VertexBufferBinding();
binding.SetBinding(0, _vb);
VertexData = new VertexData(_vertexDeclaration, binding);
VertexData.vertexCount = numVertices;
VertexData.vertexStart = 0;
IndexData = new IndexData();
IndexData.indexBuffer = _ib;
IndexData.indexCount = numIndices;
IndexData.indexStart = 0;
}
private unsafe int ReadIndexData(int indexOffset, uint vertexOffset, IndexData indexData)
{
// get index data
HardwareIndexBufferSharedPtr indexBuf = indexData.indexBuffer;
HardwareIndexBuffer.IndexType indexType = indexBuf.Type;
uint * pLong = (uint *)(indexBuf.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY));
ushort *pShort = (ushort *)pLong;
for (uint i = 0; i < indexData.indexCount; i++)
{
if (indexType == HardwareIndexBuffer.IndexType.IT_32BIT)
{
_indices[indexOffset] = pLong[i] + vertexOffset;
}
else
{
_indices[indexOffset] = pShort[i] + vertexOffset;
}
indexOffset++;
}
indexBuf.Unlock();
// SGD ：2013/6/8 13:42:42
// 说明：销毁指针引用 防止.NET回收
indexBuf.Dispose();
return(indexOffset);
}
/// <summary>
///
/// </summary>
public void Remove()
{
if (!this.IsCreated)
{
return;
}
Mogre.MeshManager.Singleton.Remove(_mesh.Name);
//_VClouds.SceneManager.RemoveEntity(_entity);
_VClouds.SceneManager.DestroyEntity(_entity);
_mesh = null;
_subMesh = null;
_vertexBuffer = null;
_indexBuffer = null;
_vertices = null;
this.IsCreated = false;
}
public virtual void CreateIndexBuffer(uint triaglecount,
HardwareIndexBuffer.IndexType itype,
HardwareBuffer.Usage usage,
bool useShadowBuffer)
{
mvbuf.Unlock();
mTriagleCount = triaglecount;
mIndexType = itype;
mSubMesh.vertexData.vertexBufferBinding.SetBinding(0, mvbuf);
mSubMesh.indexData.indexCount = mTriagleCount * 3;
HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager.Singleton
.CreateIndexBuffer(mIndexType, mTriagleCount * 3, usage, useShadowBuffer);
mSubMesh.indexData.indexBuffer = ibuf;
unsafe
{
pIBuffStart = ibuf.Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
}
}
public virtual void CreateIndexBufferForTriStrip(uint indexcount,
HardwareIndexBuffer.IndexType itype,
HardwareBuffer.Usage usage)
{
mvbuf.Unlock();
mTriagleCount = 0;
mIndexType = itype;
mSubMesh.vertexData.vertexBufferBinding.SetBinding(0, mvbuf);
mSubMesh.indexData.indexCount = indexcount;
HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager.Singleton
.CreateIndexBuffer(mIndexType, indexcount, usage, false);
mSubMesh.indexData.indexBuffer = ibuf;
mSubMesh.operationType = RenderOperation.OperationTypes.OT_TRIANGLE_STRIP;
unsafe
{
pIBuffStart = ibuf.Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
pIBuffLastPos = pIBuffStart;
}
}
/**************** New Functions Begin ***************/
/// <summary>
/// Generate navmesh by entity
/// </summary>
/// <param name="ent">Ogre Entity</param>
/// <returns>Navmesh</returns>
public static Navmesh LoadNavmesh(Entity ent)
{
bool addedSharedVertex = false;
vertices.Clear();
faces.Clear();
MeshPtr mesh = ent.GetMesh();
Mesh.SubMeshIterator subIterator = mesh.GetSubMeshIterator();
uint vertexNum = 0;
uint vertexOffset = mesh.sharedVertexData.vertexStart;
MyVector3 <float>[] verticeArray = new MyVector3 <float> [vertexNum];
VertexElement posElem = mesh.sharedVertexData.vertexDeclaration.FindElementBySemantic(VertexElementSemantic.VES_POSITION);
HardwareVertexBufferSharedPtr vertexBuffer = mesh.sharedVertexData.vertexBufferBinding.GetBuffer(posElem.Source);
while (subIterator.MoveNext())
{
SubMesh subMesh = subIterator.Current;
VertexData vertexData = subMesh.useSharedVertices ? mesh.sharedVertexData : subMesh.vertexData;
HardwareIndexBufferSharedPtr indexBuffer = subMesh.indexData.indexBuffer;
HardwareIndexBuffer.IndexType indexType = indexBuffer.Type;
uint indexCount = subMesh.indexData.indexCount;
uint trisNum = indexCount / 3;
uint[] indcies = new uint[indexCount];
uint indexOffset = subMesh.indexData.indexStart;
if (subMesh.useSharedVertices)
{
if (!addedSharedVertex)
{
vertexNum += mesh.sharedVertexData.vertexCount;
addedSharedVertex = true;
}
}
else
{
vertexNum += subMesh.vertexData.vertexCount;
}
unsafe
{
uint * pLong = (uint *)(indexBuffer.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY));
ushort *pShort = (ushort *)pLong;
for (int i = 0; i < indexCount; i++)
{
if (indexType == HardwareIndexBuffer.IndexType.IT_32BIT)
{
indcies[indexOffset] = pLong[i] + vertexNum;
}
else
{
indcies[indexOffset] = pShort[i] + vertexNum;
}
indexOffset++;
}
}
int indexLength = indcies.Length / 3;
for (int i = 0; i < indexLength; i++)
{
faces.Add(new MyVector3 <ushort>(
(ushort)indcies[i * 3 + 0],
(ushort)indcies[i * 3 + 1],
(ushort)indcies[i * 3 + 2]
));
}
indexBuffer.Unlock();
if (subMesh.vertexData != null)
{
vertexNum = subMesh.vertexData.vertexCount;
vertexOffset = subMesh.vertexData.vertexStart;
verticeArray = new MyVector3 <float> [vertexNum];
posElem = subMesh.vertexData.vertexDeclaration.FindElementBySemantic(VertexElementSemantic.VES_POSITION);
vertexBuffer = subMesh.vertexData.vertexBufferBinding.GetBuffer(posElem.Source);
unsafe
{
byte * vertexMemory = (byte *)vertexBuffer.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY);
float *pVertexBuffer;
for (int i = 0; i < vertexNum; i++)
{
posElem.BaseVertexPointerToElement(vertexMemory, &pVertexBuffer);
verticeArray[vertexOffset] = (new MyVector3 <float>(
pVertexBuffer[0],
pVertexBuffer[1],
pVertexBuffer[2]
));
vertexMemory += vertexBuffer.VertexSize;
vertexOffset++;
}
}
for (int i = 0; i < verticeArray.Length; i++)
{
vertices.Add(verticeArray[i]);
}
vertexBuffer.Unlock();
}
}
vertexNum = mesh.sharedVertexData.vertexCount;
vertexOffset = mesh.sharedVertexData.vertexStart;
verticeArray = new MyVector3 <float> [vertexNum];
posElem = mesh.sharedVertexData.vertexDeclaration.FindElementBySemantic(VertexElementSemantic.VES_POSITION);
vertexBuffer = mesh.sharedVertexData.vertexBufferBinding.GetBuffer(posElem.Source);
unsafe
{
byte * vertexMemory = (byte *)vertexBuffer.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY);
float *pVertexBuffer;
for (int i = 0; i < vertexNum; i++)
{
posElem.BaseVertexPointerToElement(vertexMemory, &pVertexBuffer);
verticeArray[vertexOffset] = (new MyVector3 <float>(
pVertexBuffer[0],
pVertexBuffer[1],
pVertexBuffer[2]
));
vertexMemory += vertexBuffer.VertexSize;
vertexOffset++;
}
}
for (int i = 0; i < verticeArray.Length; i++)
{
vertices.Add(verticeArray[i]);
}
vertexBuffer.Unlock();
return(GenerateNavmesh());
}
/// <summary>
/// Convert Obj Model File to Ogre Mesh format
/// </summary>
/// <param name="fileStream">Obj File Stream</param>
/// <returns>Ogre Mesh</returns>
public MeshPtr ConvertObjToMesh(Stream fileStream)
{
List <Vector3> vertexObj = new List <Vector3>();
List <Vector3> faceObj = new List <Vector3>();
float[] vertices;
float[] faces;
StreamReader reader = new StreamReader(fileStream);
string line;
Regex floatNumber = new Regex(@"[\d\-][\d\.]*");
Regex ushortNumber = new Regex(@"\d+");
MatchCollection matchList;
while ((line = reader.ReadLine()) != null)
{
//Read vertices
if (line.Substring(0, 2) == "v ")
{
matchList = floatNumber.Matches(line);
float x = Convert.ToSingle(matchList[0].ToString());
float y = Convert.ToSingle(matchList[1].ToString());
float z = Convert.ToSingle(matchList[2].ToString());
vertexObj.Add(new Vector3(x, y, z));
}
//Read faces
else if (line.Substring(0, 2) == "f ")
{
//Error here where invalid indices were given. This is because the OBJ file started indexing the verts from 1 instead of 0.
matchList = ushortNumber.Matches(line);
int v1 = -1 + Convert.ToUInt16(matchList[0].ToString());
int v2 = -1 + Convert.ToUInt16(matchList[1].ToString());
int v3 = -1 + Convert.ToUInt16(matchList[2].ToString());
faceObj.Add(new Vector3((ushort)v1, (ushort)v2, (ushort)v3));
}
}
int vertexNum = vertexObj.Count;
vertices = new float[vertexNum * 3];
for (int i = 0; i < vertexNum; i++)
{
vertices[i * 3 + 0] = vertexObj[i].x;
vertices[i * 3 + 1] = vertexObj[i].y;
vertices[i * 3 + 2] = vertexObj[i].z;
}
int faceNum = faceObj.Count;
faces = new float[faceNum * 3];
for (int i = 0; i < faceNum; i++)
{
faces[i * 3 + 0] = faceObj[i].x;
faces[i * 3 + 1] = faceObj[i].y;
faces[i * 3 + 2] = faceObj[i].z;
}
MeshPtr mesh = MeshManager.Singleton.CreateManual("mesh1", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME);
SubMesh subMesh = mesh.CreateSubMesh();
mesh.sharedVertexData = new VertexData();
mesh.sharedVertexData.vertexCount = (uint)vertexObj.Count;
VertexDeclaration vdecl = mesh.sharedVertexData.vertexDeclaration;
VertexBufferBinding vbind = mesh.sharedVertexData.vertexBufferBinding;
vdecl.AddElement(0, 0, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_POSITION);
HardwareVertexBufferSharedPtr vertexBuff =
HardwareBufferManager.Singleton.CreateVertexBuffer((uint)(3 * System.Runtime.InteropServices.Marshal.SizeOf(typeof(float))), (uint)vertexObj.Count, HardwareBuffer.Usage.HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
unsafe
{
GCHandle handle = GCHandle.Alloc(vertices, GCHandleType.Pinned);
void * pVertex = (void *)handle.AddrOfPinnedObject();
vertexBuff.WriteData(0, vertexBuff.SizeInBytes, pVertex, true);
handle.Free();
vbind.SetBinding(0, vertexBuff);
}
HardwareIndexBufferSharedPtr indexBuff =
HardwareBufferManager.Singleton.CreateIndexBuffer(HardwareIndexBuffer.IndexType.IT_32BIT, (uint)(3 * faceObj.Count), HardwareBuffer.Usage.HBU_STATIC, true);
unsafe {
GCHandle handle = GCHandle.Alloc(faces, GCHandleType.Pinned);
void * pFaces = (void *)handle.AddrOfPinnedObject();
indexBuff.WriteData(0, indexBuff.SizeInBytes, pFaces, true);
handle.Free();
}
subMesh.useSharedVertices = true;
subMesh.indexData.indexBuffer = indexBuff;
subMesh.indexData.indexStart = 0;
subMesh.indexData.indexCount = (uint)(3 * faceObj.Count);
mesh._setBounds(new AxisAlignedBox(-100, -100, -100, 100, 100, 100));
mesh.Touch();
reader.Close();
return(mesh);
}
private void CreateBuffers(ushort[] indices, short[] vertices)
{
var numIndices = (uint)indices.Length;
var numVertices = (uint)vertices.Length;
_vertexDeclaration = HardwareBufferManager.Singleton.CreateVertexDeclaration();
_vertexDeclaration.AddElement(0, 0, VertexElementType.VET_SHORT2, VertexElementSemantic.VES_POSITION);
_ib = HardwareBufferManager.Singleton.CreateIndexBuffer(HardwareIndexBuffer.IndexType.IT_16BIT, numIndices, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
_vb = HardwareBufferManager.Singleton.CreateVertexBuffer(_vertexDeclaration.GetVertexSize(0), numVertices, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY, false);
unsafe
{
fixed (ushort* x = indices)
_ib.WriteData(0, numIndices * sizeof(ushort), x, true);
fixed (short* x = vertices)
_vb.WriteData(0, numVertices * sizeof(ushort), x, true);
}
var binding = new VertexBufferBinding();
binding.SetBinding(0, _vb);
VertexData = new VertexData(_vertexDeclaration, binding);
VertexData.vertexCount = numVertices;
VertexData.vertexStart = 0;
IndexData = new IndexData();
IndexData.indexBuffer = _ib;
IndexData.indexCount = numIndices;
IndexData.indexStart = 0;
}
/// <summary>
///
/// </summary>
private unsafe void CreateGeometry()
{
int numVertices = this.Steps * this.Circles + 1;
int numEule = 6 * this.Steps * (this.Circles - 1) + 3 * this.Steps;
// Vertex buffers
this.SubMesh.vertexData = new VertexData();
this.SubMesh.vertexData.vertexStart = 0;
this.SubMesh.vertexData.vertexCount = (uint)numVertices;
VertexDeclaration vdecl = this.SubMesh.vertexData.vertexDeclaration;
VertexBufferBinding vbind = this.SubMesh.vertexData.vertexBufferBinding;
uint offset = 0;
vdecl.AddElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_POSITION);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
vdecl.AddElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_TEXTURE_COORDINATES, 0);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
vdecl.AddElement(0, offset, VertexElementType.VET_FLOAT2, VertexElementSemantic.VES_TEXTURE_COORDINATES, 1);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT2);
vdecl.AddElement(0, offset, VertexElementType.VET_FLOAT1, VertexElementSemantic.VES_TEXTURE_COORDINATES, 2);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT1);
_vertexBuffer = HardwareBufferManager.Singleton.CreateVertexBuffer(offset, (uint)numVertices, HardwareBuffer.Usage.HBU_DYNAMIC_WRITE_ONLY);
vbind.SetBinding(0, _vertexBuffer);
int[] indexBuffer = new int[numEule];
for (int k = 0; k < this.Steps; k++)
{
indexBuffer[k * 3] = 0;
indexBuffer[k * 3 + 1] = k + 1;
if (k != this.Steps - 1)
{
indexBuffer[k * 3 + 2] = k + 2;
}
else
{
indexBuffer[k * 3 + 2] = 1;
}
}
for (int y = 0; y < this.Circles - 1; y++)
{
for (int x = 0; x < this.Steps; x++)
{
int twoface = (y * this.Steps + x) * 6 + 3 * this.Steps;
int p0 = 1 + y * this.Steps + x;
int p1 = 1 + y * this.Steps + x + 1;
int p2 = 1 + (y + 1) * this.Steps + x;
int p3 = 1 + (y + 1) * this.Steps + x + 1;
if (x == this.Steps - 1)
{
p1 -= x + 1;
p3 -= x + 1;
}
// First triangle
indexBuffer[twoface + 2] = p0;
indexBuffer[twoface + 1] = p1;
indexBuffer[twoface + 0] = p2;
// Second triangle
indexBuffer[twoface + 5] = p1;
indexBuffer[twoface + 4] = p3;
indexBuffer[twoface + 3] = p2;
}
}
// Prepare buffer for indices
_indexBuffer = HardwareBufferManager.Singleton.CreateIndexBuffer(Mogre.HardwareIndexBuffer.IndexType.IT_32BIT, (uint)numEule, HardwareBuffer.Usage.HBU_STATIC, true);
//for(int z = 0; z < indexBuffer.Length;z++)
// LogManager.Singleton.Write("Index " + indexBuffer[z]);
fixed(int *addr = &indexBuffer[0])
{
_indexBuffer.WriteData(0, _indexBuffer.SizeInBytes, addr, true);
}
// Set index buffer for this submesh
this.SubMesh.indexData.indexBuffer = _indexBuffer;
this.SubMesh.indexData.indexStart = 0;
this.SubMesh.indexData.indexCount = (uint)numEule;
// Create our internal buffer for manipulations
_vertices = new PosUVVertex[1 + this.Steps * this.Circles];
}
//MeshPtr CreateMesh(string Name, string Group, IndexData IndexDataArg, VertexData VertexDataArg, AxisAlignedBox BoundingBox) {
// Mogre.Mesh Mesh = Mogre.MeshManager.Singleton.CreateManual(Name, Group,null);
// SubMesh SubMesh = Mesh.CreateSubMesh();
// //Shallow copy the IndexBuffer argument into the SubMesh's indexData property
// SubMesh.indexData.indexBuffer = IndexDataArg.indexBuffer;
// SubMesh.indexData.indexCount = IndexDataArg.indexCount;
// //Deep copy the VertexData argument into the Mesh's sharedVertexData
// SubMesh.useSharedVertices = true;
// Mesh.sharedVertexData = new VertexData();
// Mesh.sharedVertexData.vertexBufferBinding.SetBinding(0, VertexDataArg.vertexBufferBinding.GetBuffer(0));
// Mesh.sharedVertexData.vertexDeclaration = VertexDataArg.vertexDeclaration.Clone();
// Mesh.sharedVertexData.vertexCount = VertexDataArg.vertexCount;
// Mesh._setBounds(BoundingBox);
// Mesh.Load();
// return Mesh;
//}
unsafe static public void CreateSphere(string strName, float r, int nRings, int nSegments)
{
MeshPtr pSphere = Mogre.MeshManager.Singleton.CreateManual(strName, ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME);
SubMesh pSphereVertex = pSphere.CreateSubMesh();
pSphere.sharedVertexData = new VertexData();
VertexData vertexData = pSphere.sharedVertexData;
// define the vertex format
VertexDeclaration vertexDecl = vertexData.vertexDeclaration;
uint currOffset = 0;
// positions
vertexDecl.AddElement(0, currOffset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_POSITION);
currOffset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
// normals
vertexDecl.AddElement(0, currOffset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_NORMAL);
currOffset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
// two dimensional texture coordinates
vertexDecl.AddElement(0, currOffset, VertexElementType.VET_FLOAT2, VertexElementSemantic.VES_TEXTURE_COORDINATES, 0);
currOffset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT2);
// allocate the vertex buffer
vertexData.vertexCount = (uint)((nRings + 1) * (nSegments + 1));
HardwareVertexBufferSharedPtr vBuf = HardwareBufferManager.Singleton.CreateVertexBuffer(vertexDecl.GetVertexSize(0), vertexData.vertexCount, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY, false);
VertexBufferBinding binding = vertexData.vertexBufferBinding;
binding.SetBinding(0, vBuf);
float *pVertex = (float *)vBuf.Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
// allocate index buffer
pSphereVertex.indexData.indexCount = (uint)(6 * nRings * (nSegments + 1));
pSphereVertex.indexData.indexBuffer = HardwareBufferManager.Singleton.CreateIndexBuffer(Mogre.HardwareIndexBuffer.IndexType.IT_16BIT, pSphereVertex.indexData.indexCount, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY, false);
HardwareIndexBufferSharedPtr iBuf = pSphereVertex.indexData.indexBuffer;
ushort *pIndices = (ushort *)iBuf.Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
float fDeltaRingAngle = (float)(Mogre.Math.PI / nRings);
float fDeltaSegAngle = (float)(2 * Mogre.Math.PI / nSegments);
ushort wVerticeIndex = 0;
// Generate the group of rings for the sphere
for (int ring = 0; ring <= nRings; ring++)
{
float r0 = r * Mogre.Math.Sin(ring * fDeltaRingAngle);
float y0 = r * Mogre.Math.Cos(ring * fDeltaRingAngle);
// Generate the group of segments for the current ring
for (int seg = 0; seg <= nSegments; seg++)
{
float x0 = r0 * Mogre.Math.Sin(seg * fDeltaSegAngle);
float z0 = r0 * Mogre.Math.Cos(seg * fDeltaSegAngle);
// Add one vertex to the strip which makes up the sphere
*pVertex++ = x0;
*pVertex++ = y0;
*pVertex++ = z0;
Mogre.Vector3 vNormal = (new Mogre.Vector3(x0, y0, z0)).NormalisedCopy;
*pVertex++ = vNormal.x;
*pVertex++ = vNormal.y;
*pVertex++ = vNormal.z;
*pVertex++ = (float)seg / (float)nSegments;
*pVertex++ = (float)ring / (float)nRings;
if (ring != nRings)
{
// each vertex (except the last) has six indices pointing to it
*pIndices++ = (ushort)(wVerticeIndex + nSegments + 1);
*pIndices++ = wVerticeIndex;
*pIndices++ = (ushort)(wVerticeIndex + nSegments);
*pIndices++ = (ushort)(wVerticeIndex + nSegments + 1);
*pIndices++ = (ushort)(wVerticeIndex + 1);
*pIndices++ = wVerticeIndex;
wVerticeIndex++;
}
}
; // end for seg
} // end for ring
// Unlock
vBuf.Unlock();
iBuf.Unlock();
// Generate face list
pSphereVertex.useSharedVertices = true;
// the original code was missing this line:
pSphere._setBounds(new AxisAlignedBox(new Mogre.Vector3(-r, -r, -r), new Mogre.Vector3(r, r, r)), false);
pSphere._setBoundingSphereRadius(r);
// this line makes clear the mesh is loaded (avoids memory leaks)
pSphere.Load();
}
// Get the mesh information for the given mesh.
// Code found on this forum link: http://www.ogre3d.org/wiki/index.php/RetrieveVertexData
private static unsafe void GetMeshInformation(MeshPtr mesh, out uint vertex_count, out Vector3[] vertices, out uint index_count, out ulong[] indices, Vector3 position, Quaternion orient, Vector3 scale)
{
bool added_shared = false;
uint current_offset = 0;
uint shared_offset = 0;
uint next_offset = 0;
uint index_offset = 0;
vertex_count = index_count = 0;
// Calculate how many vertices and indices we're going to need
for (ushort i = 0; i < mesh.NumSubMeshes; ++i)
{
SubMesh submesh = mesh.GetSubMesh(i);
// We only need to add the shared vertices once
if (submesh.useSharedVertices)
{
if (!added_shared)
{
vertex_count += mesh.sharedVertexData.vertexCount;
added_shared = true;
}
}
else
{
vertex_count += submesh.vertexData.vertexCount;
}
// Add the indices
index_count += submesh.indexData.indexCount;
}
// Allocate space for the vertices and indices
vertices = new Vector3[vertex_count];
indices = new ulong[index_count];
added_shared = false;
// Run through the submeshes again, adding the data into the arrays
for (ushort i = 0; i < mesh.NumSubMeshes; ++i)
{
SubMesh submesh = mesh.GetSubMesh(i);
VertexData vertex_data = submesh.useSharedVertices ? mesh.sharedVertexData : submesh.vertexData;
if ((!submesh.useSharedVertices) || (submesh.useSharedVertices && !added_shared))
{
if (submesh.useSharedVertices)
{
added_shared = true;
shared_offset = current_offset;
}
VertexElement posElem = vertex_data.vertexDeclaration.FindElementBySemantic(VertexElementSemantic.VES_POSITION);
HardwareVertexBufferSharedPtr vbuf = vertex_data.vertexBufferBinding.GetBuffer(posElem.Source);
byte *vertex = (byte *)vbuf.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY);
// There is _no_ baseVertexPointerToElement() which takes an Ogre::Real or a double
// as second argument. So make it float, to avoid trouble when Ogre::Real will
// be comiled/typedefed as double:
// Ogre::Real* pReal;
float *preal;
for (uint j = 0; j < vertex_data.vertexCount; ++j, vertex += vbuf.VertexSize)
{
posElem.BaseVertexPointerToElement(vertex, &preal);
Vector3 pt = new Vector3(preal[0], preal[1], preal[2]);
vertices[current_offset + j] = (orient * (pt * scale)) + position;
}
vbuf.Unlock();
next_offset += vertex_data.vertexCount;
}
IndexData index_data = submesh.indexData;
uint numTris = index_data.indexCount / 3;
HardwareIndexBufferSharedPtr ibuf = index_data.indexBuffer;
bool use32bitindexes = (ibuf.Type == HardwareIndexBuffer.IndexType.IT_32BIT);
ulong * plong = (ulong *)ibuf.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY);
ushort *pshort = (ushort *)plong;
uint offset = submesh.useSharedVertices ? shared_offset : current_offset;
if (use32bitindexes)
{
for (uint k = 0; k < numTris * 3; ++k)
{
indices[index_offset++] = (ulong)plong[k] + (ulong)offset;
}
}
else
{
for (uint k = 0; k < numTris * 3; ++k)
{
indices[index_offset++] = pshort[k] + (ulong)offset;
}
}
ibuf.Unlock();
current_offset = next_offset;
}
}
} // CreateTetrahedron
unsafe static public void CreateTetrahedron2(string strName)
{
float r = 1f;
int nRings = 8;
int nSegments = 8;
Single scale = 1;
Mogre.Vector3 position = new Mogre.Vector3();
MeshPtr pTetra = MeshManager.Singleton.CreateManual(strName, ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME);
SubMesh pTetraVertex = pTetra.CreateSubMesh();
pTetra.sharedVertexData = new VertexData();
VertexData vertexData = pTetra.sharedVertexData;
// define the vertex format
VertexDeclaration vertexDecl = vertexData.vertexDeclaration;
uint currOffset = 0;
// positions
vertexDecl.AddElement(0, currOffset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_POSITION);
currOffset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
// normals
vertexDecl.AddElement(0, currOffset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_NORMAL);
currOffset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
// two dimensional texture coordinates
vertexDecl.AddElement(0, currOffset, VertexElementType.VET_FLOAT2, VertexElementSemantic.VES_TEXTURE_COORDINATES, 0);
currOffset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT2);
// allocate the vertex buffer
vertexData.vertexCount = 4; //(uint)((nRings + 1) * (nSegments + 1));
HardwareVertexBufferSharedPtr vBuf = HardwareBufferManager.Singleton.CreateVertexBuffer(vertexDecl.GetVertexSize(0), vertexData.vertexCount, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY, false);
VertexBufferBinding binding = vertexData.vertexBufferBinding;
binding.SetBinding(0, vBuf);
float *pVertex = (float *)vBuf.Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
uint numIndexes = (uint)(6 * 4);
// allocate index buffer
pTetraVertex.indexData.indexCount = numIndexes;
pTetraVertex.indexData.indexBuffer = HardwareBufferManager.Singleton.CreateIndexBuffer(HardwareIndexBuffer.IndexType.IT_16BIT, pTetraVertex.indexData.indexCount, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY, false);
HardwareIndexBufferSharedPtr iBuf = pTetraVertex.indexData.indexBuffer;
ushort *pIndices = (ushort *)iBuf.Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
//float fDeltaRingAngle = (float)(Mogre.Math.PI / nRings);
//float fDeltaSegAngle = (float)(2 * Mogre.Math.PI / nSegments);
ushort wVerticeIndex = 0;
// calculate corners of tetrahedron (with point of origin in middle of volume)
Single mbot = scale * 0.2f; // distance middle to bottom
Single mtop = scale * 0.62f; // distance middle to top
Single mf = scale * 0.289f; // distance middle to front
Single mb = scale * 0.577f; // distance middle to back
Single mlr = scale * 0.5f; // distance middle to left right
// width / height / depth
Mogre.Vector3[] c = new Mogre.Vector3[4]; // corners
c[0] = new Mogre.Vector3(-mlr, -mbot, mf); // left bottom front
c[1] = new Mogre.Vector3(mlr, -mbot, mf); // right bottom front
c[2] = new Mogre.Vector3(0, -mbot, -mb); // (middle) bottom back
c[3] = new Mogre.Vector3(0, mtop, 0); // (middle) top (middle)
// add position offset for all corners (move tetrahedron)
for (Int16 i = 0; i <= 3; i++)
{
c[i] += position;
}
Mogre.Vector3 vNormal = new Mogre.Vector3();
*pVertex++ = c[0].x;
*pVertex++ = c[0].y;
*pVertex++ = c[0].z;
vNormal = (new Mogre.Vector3(c[0].x, c[0].y, c[0].z)).NormalisedCopy;
*pVertex++ = vNormal.x;
*pVertex++ = vNormal.y;
*pVertex++ = vNormal.z;
*pVertex++ = (float).25;
*pVertex++ = (float).25;
*pIndices++ = (ushort)(wVerticeIndex + numIndexes + 1);
*pIndices++ = wVerticeIndex;
*pIndices++ = (ushort)(wVerticeIndex + numIndexes);
*pIndices++ = (ushort)(wVerticeIndex + numIndexes + 1);
*pIndices++ = (ushort)(wVerticeIndex + 1);
*pIndices++ = wVerticeIndex;
wVerticeIndex++;
*pVertex++ = c[1].x;
*pVertex++ = c[1].y;
*pVertex++ = c[1].z;
vNormal = (new Mogre.Vector3(c[1].x, c[1].y, c[1].z)).NormalisedCopy;
*pVertex++ = vNormal.x;
*pVertex++ = vNormal.y;
*pVertex++ = vNormal.z;
*pVertex++ = (float).50;
*pVertex++ = (float).50;
*pIndices++ = (ushort)(wVerticeIndex + numIndexes + 1);
*pIndices++ = wVerticeIndex;
*pIndices++ = (ushort)(wVerticeIndex + numIndexes);
*pIndices++ = (ushort)(wVerticeIndex + numIndexes + 1);
*pIndices++ = (ushort)(wVerticeIndex + 1);
*pIndices++ = wVerticeIndex;
wVerticeIndex++;
*pVertex++ = c[2].x;
*pVertex++ = c[2].y;
*pVertex++ = c[2].z;
vNormal = (new Mogre.Vector3(c[2].x, c[2].y, c[2].z)).NormalisedCopy;
*pVertex++ = vNormal.x;
*pVertex++ = vNormal.y;
*pVertex++ = vNormal.z;
*pVertex++ = (float).75;
*pVertex++ = (float).75;
*pIndices++ = (ushort)(wVerticeIndex + numIndexes + 1);
*pIndices++ = wVerticeIndex;
*pIndices++ = (ushort)(wVerticeIndex + numIndexes);
*pIndices++ = (ushort)(wVerticeIndex + numIndexes + 1);
*pIndices++ = (ushort)(wVerticeIndex + 1);
*pIndices++ = wVerticeIndex;
wVerticeIndex++;
*pVertex++ = c[3].x;
*pVertex++ = c[3].y;
*pVertex++ = c[3].z;
vNormal = (new Mogre.Vector3(c[3].x, c[3].y, c[3].z)).NormalisedCopy;
*pVertex++ = vNormal.x;
*pVertex++ = vNormal.y;
*pVertex++ = vNormal.z;
*pVertex++ = (float)1;
*pVertex++ = (float)1;
*pIndices++ = (ushort)(wVerticeIndex + numIndexes + 1);
*pIndices++ = wVerticeIndex;
*pIndices++ = (ushort)(wVerticeIndex + numIndexes);
*pIndices++ = (ushort)(wVerticeIndex + numIndexes + 1);
*pIndices++ = (ushort)(wVerticeIndex + 1);
*pIndices++ = wVerticeIndex;
wVerticeIndex++;
//manObTetra.Begin(materialName, RenderOperation.OperationTypes.OT_TRIANGLE_LIST);
//manObTetra.Position(c[2]);
//manObTetra.Position(c[1]);
//manObTetra.Position(c[0]);
//manObTetra.Triangle(0, 1, 2);
//manObTetra.End();
//// create right back side
//manObTetra.Begin(materialName, RenderOperation.OperationTypes.OT_TRIANGLE_LIST);
//manObTetra.Position(c[1]);
//manObTetra.Position(c[2]);
//manObTetra.Position(c[3]);
//manObTetra.Triangle(0, 1, 2);
//manObTetra.End();
//// create left back side
//manObTetra.Begin(materialName, RenderOperation.OperationTypes.OT_TRIANGLE_LIST);
//manObTetra.Position(c[3]);
//manObTetra.Position(c[2]);
//manObTetra.Position(c[0]);
//manObTetra.Triangle(0, 1, 2);
//manObTetra.End();
//// create front side
//manObTetra.Begin(materialName, RenderOperation.OperationTypes.OT_TRIANGLE_LIST);
//manObTetra.Position(c[0]);
//manObTetra.Position(c[1]);
//manObTetra.Position(c[3]);
//manObTetra.Triangle(0, 1, 2);
//manObTetra.End();
//return manObTetra;
//// Generate the group of rings for the sphere
//for (int ring = 0; ring <= nRings; ring++)
//{
// float r0 = r * Mogre.Math.Sin(ring * fDeltaRingAngle);
// float y0 = r * Mogre.Math.Cos(ring * fDeltaRingAngle);
// // Generate the group of segments for the current ring
// for (int seg = 0; seg <= nSegments; seg++)
// {
// float x0 = r0 * Mogre.Math.Sin(seg * fDeltaSegAngle);
// float z0 = r0 * Mogre.Math.Cos(seg * fDeltaSegAngle);
// // Add one vertex to the strip which makes up the sphere
// *pVertex++ = x0;
// *pVertex++ = y0;
// *pVertex++ = z0;
// Mogre.Vector3 vNormal = (new Mogre.Vector3(x0, y0, z0)).NormalisedCopy;
// *pVertex++ = vNormal.x;
// *pVertex++ = vNormal.y;
// *pVertex++ = vNormal.z;
// *pVertex++ = (float)seg / (float)nSegments;
// *pVertex++ = (float)ring / (float)nRings;
// if (ring != nRings)
// {
// // each vertex (except the last) has six indices pointing to it
// *pIndices++ = (ushort)(wVerticeIndex + nSegments + 1);
// *pIndices++ = wVerticeIndex;
// *pIndices++ = (ushort)(wVerticeIndex + nSegments);
// *pIndices++ = (ushort)(wVerticeIndex + nSegments + 1);
// *pIndices++ = (ushort)(wVerticeIndex + 1);
// *pIndices++ = wVerticeIndex;
// wVerticeIndex++;
// }
// }; // end for seg
//} // end for ring
// Unlock
vBuf.Unlock();
iBuf.Unlock();
// Generate face list
pTetraVertex.useSharedVertices = true;
// the original code was missing this line:
pTetra._setBounds(new AxisAlignedBox(new Mogre.Vector3(-r, -r, -r), new Mogre.Vector3(r, r, r)), false);
pTetra._setBoundingSphereRadius(r);
// this line makes clear the mesh is loaded (avoids memory leaks)
pTetra.Load();
}
public unsafe void createMesh()
{
/// Create the mesh via the MeshManager
MeshPtr msh = MeshManager.Singleton.CreateManual("ColourCube", "General");
/// Create one submesh
SubMesh sub = msh.CreateSubMesh();
/// Define the vertices (8 vertices, each consisting of 2 groups of 3 floats
//const int nVertices = 8;
//int row = recordno;
// int col = demcol;
int row = recordno;
int col = 1100;
int step = 10;
int vbufCount;
uint nVertices = (uint)(col * row);
float[] vertices = CreateVertices(row, col, step, out vbufCount);
/// Define 12 triangles (two triangles per cube face)
/// The values in this table refer to vertices in the above table
uint ibufCount;
ushort[] faces = CreateFaces(row, col, out ibufCount);
/// Create vertex data structure for 8 vertices shared between submeshes
msh.sharedVertexData = new VertexData();
msh.sharedVertexData.vertexCount = nVertices;
/// Create declaration (memory format) of vertex data
VertexDeclaration decl = msh.sharedVertexData.vertexDeclaration;
uint offset = 0;
// 1st buffer
decl.AddElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_POSITION);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
decl.AddElement(0, offset, VertexElementType.VET_FLOAT2, VertexElementSemantic.VES_TEXTURE_COORDINATES);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT2);
/// Allocate vertex buffer of the requested number of vertices (vertexCount)
/// and bytes per vertex (offset)
HardwareVertexBufferSharedPtr vbuf =
HardwareBufferManager.Singleton.CreateVertexBuffer(offset, msh.sharedVertexData.vertexCount,
HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
/// Upload the vertex data to the card
fixed(void *p = vertices)
{
vbuf.WriteData(0, vbuf.SizeInBytes, p, true);// writeData(0, vbuf->getSizeInBytes(), vertices, true);
}
/// Set vertex buffer binding so buffer 0 is bound to our vertex buffer
VertexBufferBinding bind = msh.sharedVertexData.vertexBufferBinding;// msh->sharedVertexData->vertexBufferBinding;
bind.SetBinding(0, vbuf);
/// Allocate index buffer of the requested number of vertices (ibufCount)
HardwareIndexBufferSharedPtr ibuf =
HardwareBufferManager.Singleton.CreateIndexBuffer(HardwareIndexBuffer.IndexType.IT_16BIT,
ibufCount, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
/// Upload the index data to the card
fixed(void *p = faces)
{
ibuf.WriteData(0, ibuf.SizeInBytes, p, true);
}
/// Set parameters of the submesh
sub.useSharedVertices = true;
sub.indexData.indexBuffer = ibuf;
sub.indexData.indexCount = ibufCount;
sub.indexData.indexStart = 0;
/// Set bounding information (for culling)
msh._setBounds(new AxisAlignedBox(min, max));
// msh._setBoundingSphereRadius(Mogre.Math.Sqrt(3 * 100 * 100));
/// Notify Mesh object that it has been loaded
msh.Load();
}
/// <summary>
///
/// </summary>
private unsafe void CreateGeometry()
{
// Vertex buffers
_subMesh.vertexData = new VertexData();
_subMesh.vertexData.vertexStart = 0;
_subMesh.vertexData.vertexCount = (uint)_vertexCount;
VertexDeclaration vdecl = _subMesh.vertexData.vertexDeclaration;
VertexBufferBinding vbind = _subMesh.vertexData.vertexBufferBinding;
uint offset = 0;
// Position
vdecl.AddElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_POSITION);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
// 3D coords
vdecl.AddElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_TEXTURE_COORDINATES, 0);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
// Noise coords
vdecl.AddElement(0, offset, VertexElementType.VET_FLOAT2, VertexElementSemantic.VES_TEXTURE_COORDINATES, 1);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT2);
// Opacity
vdecl.AddElement(0, offset, VertexElementType.VET_FLOAT1, VertexElementSemantic.VES_TEXTURE_COORDINATES, 2);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT1);
_vertexBuffer = HardwareBufferManager.Singleton.CreateVertexBuffer(
offset, (uint)_vertexCount,
HardwareBuffer.Usage.HBU_DYNAMIC_WRITE_ONLY);
vbind.SetBinding(0, _vertexBuffer);
int[] indexbuffer = new int[_numberOfTriangles * 3];
int IndexOffset = 0;
int VertexOffset = 0;
// C
for (int k = 0; k < _nc; k++)
{
// First triangle
indexbuffer[IndexOffset] = VertexOffset;
indexbuffer[IndexOffset + 1] = VertexOffset + 1;
indexbuffer[IndexOffset + 2] = VertexOffset + 3;
// Second triangle
indexbuffer[IndexOffset + 3] = VertexOffset;
indexbuffer[IndexOffset + 4] = VertexOffset + 3;
indexbuffer[IndexOffset + 5] = VertexOffset + 2;
IndexOffset += 6;
VertexOffset += 4;
}
// B
for (int k = 0; k < _nb; k++)
{
// First triangle
indexbuffer[IndexOffset] = VertexOffset;
indexbuffer[IndexOffset + 1] = VertexOffset + 1;
indexbuffer[IndexOffset + 2] = VertexOffset + 3;
// Second triangle
indexbuffer[IndexOffset + 3] = VertexOffset;
indexbuffer[IndexOffset + 4] = VertexOffset + 3;
indexbuffer[IndexOffset + 5] = VertexOffset + 2;
// Third triangle
indexbuffer[IndexOffset + 6] = VertexOffset + 2;
indexbuffer[IndexOffset + 7] = VertexOffset + 3;
indexbuffer[IndexOffset + 8] = VertexOffset + 5;
// Fourth triangle
indexbuffer[IndexOffset + 9] = VertexOffset + 2;
indexbuffer[IndexOffset + 10] = VertexOffset + 5;
indexbuffer[IndexOffset + 11] = VertexOffset + 4;
IndexOffset += 12;
VertexOffset += 6;
}
// A
for (int k = 0; k < _na; k++)
{
// First triangle
indexbuffer[IndexOffset] = VertexOffset;
indexbuffer[IndexOffset + 1] = VertexOffset + 1;
indexbuffer[IndexOffset + 2] = VertexOffset + 3;
// Second triangle
indexbuffer[IndexOffset + 3] = VertexOffset;
indexbuffer[IndexOffset + 4] = VertexOffset + 3;
indexbuffer[IndexOffset + 5] = VertexOffset + 2;
// Third triangle
indexbuffer[IndexOffset + 6] = VertexOffset + 2;
indexbuffer[IndexOffset + 7] = VertexOffset + 3;
indexbuffer[IndexOffset + 8] = VertexOffset + 5;
// Fourth triangle
indexbuffer[IndexOffset + 9] = VertexOffset + 2;
indexbuffer[IndexOffset + 10] = VertexOffset + 5;
indexbuffer[IndexOffset + 11] = VertexOffset + 4;
// Fifth triangle
indexbuffer[IndexOffset + 12] = VertexOffset + 4;
indexbuffer[IndexOffset + 13] = VertexOffset + 5;
indexbuffer[IndexOffset + 14] = VertexOffset + 6;
IndexOffset += 15;
VertexOffset += 7;
}
// Prepare buffer for indices
_indexBuffer =
HardwareBufferManager.Singleton.CreateIndexBuffer(Mogre.HardwareIndexBuffer.IndexType.IT_32BIT,
(uint)_numberOfTriangles * 3, HardwareBuffer.Usage.HBU_STATIC, true);
fixed(int *addr = &indexbuffer[0])
{
_indexBuffer.WriteData(
0, _indexBuffer.SizeInBytes, addr, true);
}
//indexbufferArr = null;
// Set index buffer for this submesh
_subMesh.indexData.indexBuffer = _indexBuffer;
_subMesh.indexData.indexStart = 0;
_subMesh.indexData.indexCount = (uint)_numberOfTriangles * 3;
// Create our internal buffer for manipulations
_vertices = new Vertex[_vertexCount];
// Update geometry
UpdateGeometry();
}
private unsafe void createCube(string name, Mogre.Vector3 gpose, double d)
{
MeshPtr msh = MeshManager.Singleton.CreateManual(name, "General");
SubMesh sub1 = msh.CreateSubMesh("1");
const float sqrt13 = 0.577350269f; /* sqrt(1/3) */
const int nVertices = 8;
const int vbufCount = 3 * 2 * nVertices;
float[] vertices = new float[vbufCount] {
(float)(gpose.x - d / 2), (float)(gpose.y + d / 2), (float)(gpose.z - d / 2), //0 position
-sqrt13, sqrt13, -sqrt13, //0 normal A
(float)(gpose.x + d / 2), (float)(gpose.y + d / 2), (float)(gpose.z - d / 2), //1 position
sqrt13, sqrt13, -sqrt13, //1 normal B
(float)(gpose.x + d / 2), (float)(gpose.y - d / 2), (float)(gpose.z - d / 2), //2 position
sqrt13, -sqrt13, -sqrt13, //2 normal F
(float)(gpose.x - d / 2), (float)(gpose.y - d / 2), (float)(gpose.z - d / 2), //3 position
-sqrt13, -sqrt13, -sqrt13, //3 normal H
(float)(gpose.x - d / 2), (float)(gpose.y + d / 2), (float)(gpose.z + d / 2),
-sqrt13, sqrt13, sqrt13, //4 normal C
(float)(gpose.x + d / 2), (float)(gpose.y + d / 2), (float)(gpose.z + d / 2),
sqrt13, sqrt13, sqrt13, //5 normal D
(float)(gpose.x + d / 2), (float)(gpose.y - d / 2), (float)(gpose.z + d / 2),
sqrt13, -sqrt13, sqrt13, //6 normal E
(float)(gpose.x - d / 2), (float)(gpose.y - d / 2), (float)(gpose.z + d / 2),
-sqrt13, -sqrt13, sqrt13, //7 normal G
};
const int ibufCount = 36;
ushort[] faces = new ushort[ibufCount] {
//back
0, 2, 3,
0, 1, 2,
//right
1, 6, 2,
1, 5, 6,
//front
4, 6, 5,
4, 7, 6,
//left
0, 7, 4,
0, 3, 7,
//top
0, 5, 1,
0, 4, 5,
//bottom
2, 7, 3,
2, 6, 7
};
sub1.vertexData = new VertexData();
sub1.vertexData.vertexCount = nVertices;
VertexDeclaration decl = sub1.vertexData.vertexDeclaration;
uint offset = 0;
//position
decl.AddElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_POSITION);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
//normal
decl.AddElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_NORMAL);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager.Singleton.CreateVertexBuffer(offset, sub1.vertexData.vertexCount, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
VertexBufferBinding bind = sub1.vertexData.vertexBufferBinding;
void *pVertices;
fixed(float *pFVertice = vertices)
{
pVertices = (void *)pFVertice;
}
vbuf.WriteData(0, vbuf.SizeInBytes, pVertices, true);
bind.SetBinding(0, vbuf);
void *pFaces;
fixed(ushort *pUFaces = faces)
{
pFaces = (void *)pUFaces;
}
HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager.Singleton.CreateIndexBuffer(HardwareIndexBuffer.IndexType.IT_16BIT, ibufCount, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
ibuf.WriteData(0, ibuf.SizeInBytes, pFaces, true);
sub1.useSharedVertices = false;
sub1.indexData.indexBuffer = ibuf;
sub1.indexData.indexCount = ibufCount;
sub1.indexData.indexStart = 0;
sub1.SetMaterialName("Examples/10PointBlock");
msh._setBounds(new AxisAlignedBox(-100, -100, -100, 100, 100, 100));
msh._setBoundingSphereRadius(Mogre.Math.Sqrt(3 * 100 * 100));
msh.Load();
}
// Get the mesh information for the given mesh.
// Code found on this forum link: http://www.ogre3d.org/wiki/index.php/RetrieveVertexData
private static unsafe void GetMeshInformation(MeshPtr mesh, out Vector3[] vertices, out int[] indices, Vector3 position, Quaternion orient, Vector3 scale)
{
bool addedShared = false;
int currentOffset = 0, sharedOffset = 0, nextOffset = 0, indexOffset = 0;
int vertexCount = 0, indexCount = 0;
// Calculate how many vertices and indices we're going to need
for (ushort i = 0; i < mesh.NumSubMeshes; ++i)
{
SubMesh submesh = mesh.GetSubMesh(i);
// We only need to add the shared vertices once
if (submesh.useSharedVertices)
{
if (!addedShared)
{
vertexCount += (int)mesh.sharedVertexData.vertexCount;
addedShared = true;
}
}
else
{
vertexCount += (int)submesh.vertexData.vertexCount;
}
// Add the indices
indexCount += (int)submesh.indexData.indexCount;
}
// Allocate space for the vertices and indices
vertices = new Vector3[vertexCount];
indices = new int[indexCount];
addedShared = false;
// Run through the submeshes again, adding the data into the arrays
for (ushort i = 0; i < mesh.NumSubMeshes; ++i)
{
SubMesh submesh = mesh.GetSubMesh(i);
VertexData vertexData = submesh.useSharedVertices ? mesh.sharedVertexData : submesh.vertexData;
if ((!submesh.useSharedVertices) || (submesh.useSharedVertices && !addedShared))
{
if (submesh.useSharedVertices)
{
addedShared = true;
sharedOffset = currentOffset;
}
VertexElement posElem = vertexData.vertexDeclaration.FindElementBySemantic(VertexElementSemantic.VES_POSITION);
System.Diagnostics.Debug.Assert(posElem.Type == VertexElementType.VET_FLOAT3);
using (HardwareVertexBufferSharedPtr vbuf = vertexData.vertexBufferBinding.GetBuffer(posElem.Source))
{
byte * vertex = (byte *)vbuf.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY);
float *preal;
for (uint j = 0; j < vertexData.vertexCount; ++j, vertex += vbuf.VertexSize)
{
posElem.BaseVertexPointerToElement(vertex, &preal);
Vector3 pt = new Vector3(preal[0], preal[1], preal[2]);
vertices[currentOffset + j] = (orient * (pt * scale)) + position;
}
vbuf.Unlock();
}
nextOffset += (int)vertexData.vertexCount;
}
IndexData indexData = submesh.indexData;
using (HardwareIndexBufferSharedPtr ibuf = indexData.indexBuffer)
{
bool use32bitindexes = ibuf.Type == HardwareIndexBuffer.IndexType.IT_32BIT;
int * plong = (int *)ibuf.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY);
ushort *pshort = (ushort *)plong;
int offset = submesh.useSharedVertices ? sharedOffset : currentOffset;
if (use32bitindexes)
{
for (uint k = 0; k < indexData.indexCount; ++k)
{
indices[indexOffset++] = plong[k] + offset;
}
}
else
{
for (uint k = 0; k < indexData.indexCount; ++k)
{
indices[indexOffset++] = pshort[k] + offset;
}
}
ibuf.Unlock();
}
currentOffset = nextOffset;
}
}
