public unsafe void inverseTangentW()
{
using (MeshPtr mesh = entity.getMesh())
{
SubMesh subMesh = mesh.Value.getSubMesh(0);
VertexData vertexData = subMesh.vertexData;
VertexDeclaration vertexDeclaration = vertexData.vertexDeclaration;
VertexBufferBinding vertexBinding = vertexData.vertexBufferBinding;
VertexElement tangentElement = vertexDeclaration.findElementBySemantic(VertexElementSemantic.VES_TANGENT);
int numVertices = vertexData.vertexCount.ToInt32();
HardwareVertexBufferSharedPtr tangentHardwareBuffer = vertexBinding.getBuffer(tangentElement.getSource());
int tangetVertexSize = tangentHardwareBuffer.Value.getVertexSize().ToInt32();
byte *tangentBuffer = (byte *)tangentHardwareBuffer.Value.lockBuf(HardwareBuffer.LockOptions.HBL_NORMAL);
Vector4 *tangent;
for (int i = 0; i < numVertices; ++i)
{
tangentElement.baseVertexPointerToElement(tangentBuffer, (float **)&tangent);
tangent->w = -tangent->w;
tangentBuffer += tangetVertexSize;
}
tangentHardwareBuffer.Value.unlock();
tangentHardwareBuffer.Dispose();
}
}
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 void DestroyHardwareBuffer()
{
this.renderOp.vertexData.Dispose();
this.renderOp.Dispose();
this.renderOp = null;
this.hardwareBuffer.Dispose();
this.hardwareBuffer = null;
}
/// <summary>
/// Recalculate the binormal vectors as the cross product between the tangents and the normals.
/// </summary>
public unsafe void buildBinormalVectors()
{
using (MeshPtr mesh = entity.getMesh())
{
SubMesh subMesh = mesh.Value.getSubMesh(0);
VertexData vertexData = subMesh.vertexData;
VertexDeclaration vertexDeclaration = vertexData.vertexDeclaration;
VertexBufferBinding vertexBinding = vertexData.vertexBufferBinding;
VertexElement normalElement = vertexDeclaration.findElementBySemantic(VertexElementSemantic.VES_NORMAL);
VertexElement tangentElement = vertexDeclaration.findElementBySemantic(VertexElementSemantic.VES_TANGENT);
VertexElement binormalElement = vertexDeclaration.findElementBySemantic(VertexElementSemantic.VES_BINORMAL);
int numVertices = vertexData.vertexCount.ToInt32();
HardwareVertexBufferSharedPtr normalHardwareBuffer = vertexBinding.getBuffer(normalElement.getSource());
int normalVertexSize = normalHardwareBuffer.Value.getVertexSize().ToInt32();
byte *normalBuffer = (byte *)normalHardwareBuffer.Value.lockBuf(HardwareBuffer.LockOptions.HBL_READ_ONLY);
HardwareVertexBufferSharedPtr tangentHardwareBuffer = vertexBinding.getBuffer(tangentElement.getSource());
int tangetVertexSize = tangentHardwareBuffer.Value.getVertexSize().ToInt32();
byte *tangentBuffer = (byte *)tangentHardwareBuffer.Value.lockBuf(HardwareBuffer.LockOptions.HBL_READ_ONLY);
HardwareVertexBufferSharedPtr binormalHardwareBuffer = vertexBinding.getBuffer(binormalElement.getSource());
int binormalVertexSize = binormalHardwareBuffer.Value.getVertexSize().ToInt32();
byte *binormalBuffer = (byte *)binormalHardwareBuffer.Value.lockBuf(HardwareBuffer.LockOptions.HBL_NORMAL);
Vector3 *normal;
Vector3 *tangent;
Vector3 *binormal;
for (int i = 0; i < numVertices; ++i)
{
normalElement.baseVertexPointerToElement(normalBuffer, (float **)&normal);
tangentElement.baseVertexPointerToElement(tangentBuffer, (float **)&tangent);
binormalElement.baseVertexPointerToElement(binormalBuffer, (float **)&binormal);
*binormal = normal->cross(ref *tangent) * -1.0f;
normalBuffer += normalVertexSize;
tangentBuffer += tangetVertexSize;
binormalBuffer += binormalVertexSize;
}
normalHardwareBuffer.Value.unlock();
tangentHardwareBuffer.Value.unlock();
binormalHardwareBuffer.Value.unlock();
normalHardwareBuffer.Dispose();
tangentHardwareBuffer.Dispose();
binormalHardwareBuffer.Dispose();
}
}
//增加读取纹理坐标
private unsafe uint ReadVertexData(uint vertexOffset, VertexData vertexData)
{
VertexElement posElem = vertexData.vertexDeclaration.FindElementBySemantic(VertexElementSemantic.VES_POSITION);
HardwareVertexBufferSharedPtr vertexBuffer = vertexData.vertexBufferBinding.GetBuffer(posElem.Source);
byte * vertexMemory = (byte *)vertexBuffer.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY);
float *pElem;
bool needrecomputeVertex = false;
if (this._quaoffset != Quaternion.IDENTITY || this._posoffset != Vector3.ZERO)
{
needrecomputeVertex = true;
}
//texture
if (_readTextureCoordinate)
{
ReadTextureCoordData(vertexOffset, vertexMemory, vertexBuffer.VertexSize, vertexData);
}
if (needrecomputeVertex)
{
for (uint i = 0; i < vertexData.vertexCount; i++)
{
posElem.BaseVertexPointerToElement(vertexMemory, &pElem);
Vector3 point = new Vector3(pElem[0], pElem[1], pElem[2]);
// vertices[current_offset + j] = (orientation * (pt * scale)) + position;
_vertices[vertexOffset] = GetVextexTrans(point, this._quaoffset, this._scale, this._posoffset); //point * this.scale;
vertexMemory += vertexBuffer.VertexSize;
vertexOffset++;
}
}
else
{
for (uint i = 0; i < vertexData.vertexCount; i++)
{
posElem.BaseVertexPointerToElement(vertexMemory, &pElem);
Vector3 point = new Vector3(pElem[0], pElem[1], pElem[2]);
_vertices[vertexOffset] = point * this._scale;
vertexMemory += vertexBuffer.VertexSize;
vertexOffset++;
}
}
vertexBuffer.Unlock();
// SGD ：2013/6/8 13:43:51
// 说明：销毁指针引用 防止.NET回收
vertexBuffer.Dispose();
return(vertexOffset);
}
/// <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;
}
private unsafe uint ReadVertexData(uint vertexOffset, VertexData vertexData)
{
VertexElement posElem = vertexData.vertexDeclaration.FindElementBySemantic(VertexElementSemantic.VES_POSITION);
HardwareVertexBufferSharedPtr vertexBuffer = vertexData.vertexBufferBinding.GetBuffer(posElem.Source);
byte * vertexMemory = (byte *)vertexBuffer.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY);
float *pElem;
for (uint i = 0; i < vertexData.vertexCount; i++)
{
posElem.BaseVertexPointerToElement(vertexMemory, &pElem);
Vector3 point = new Vector3(pElem[0], pElem[1], pElem[2]);
vertices[vertexOffset] = point * this.scale;
vertexMemory += vertexBuffer.VertexSize;
vertexOffset++;
}
vertexBuffer.Unlock();
return(vertexOffset);
}
private void CreateHardwareBuffer(uint size)
{
this.renderOp = new RenderOperation
{
vertexData = new VertexData
{
vertexStart = 0
}
};
VertexDeclaration vd = this.renderOp.vertexData.vertexDeclaration;
vd.AddElement(
0,
0,
VertexElementType.VET_FLOAT3,
VertexElementSemantic.VES_POSITION);
vd.AddElement(
0,
VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3),
VertexElementType.VET_FLOAT2,
VertexElementSemantic.VES_TEXTURE_COORDINATES);
vd.AddElement(
0,
VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3) + VertexElement.GetTypeSize(VertexElementType.VET_FLOAT2),
VertexElementType.VET_COLOUR,
VertexElementSemantic.VES_DIFFUSE);
this.hardwareBuffer = HardwareBufferManager.Singleton.CreateVertexBuffer(
vd.GetVertexSize(0),
size,
HardwareBuffer.Usage.HBU_DYNAMIC_WRITE_ONLY,
false);
this.renderOp.vertexData.vertexBufferBinding.SetBinding(0, this.hardwareBuffer);
this.renderOp.operationType = RenderOperation.OperationTypes.OT_TRIANGLE_LIST;
this.renderOp.useIndexes = false;
}
// HARDWARE VERTEX BUFFER - functions
// NOTE: we do not need a _clearVertexBuffer function, since we get new, blank memory when locking with HBL_DISCARD.
private void _createVertexBuffer(int numberOfVertices)
{
mVertexBufferSize = numberOfVertices;
mRenderOperation.vertexData = new VertexData();
mRenderOperation.vertexData.vertexStart = 0;
_declareVertexStructure();
// Create the Vertex Buffer, using the Vertex Structure we previously declared in _declareVertexStructure.
mVertexBuffer = HardwareBufferManager.Singleton.CreateVertexBuffer(
mRenderOperation.vertexData.vertexDeclaration.GetVertexSize(0), // declared Vertex used
(uint)mVertexBufferSize,
HardwareBuffer.Usage.HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE,
false);
// Bind the created buffer to the renderOperation object. Now we can manipulate the buffer, and the RenderOp keeps the changes.
mRenderOperation.vertexData.vertexBufferBinding.SetBinding(0, mVertexBuffer);
mRenderOperation.operationType = RenderOperation.OperationTypes.OT_TRIANGLE_STRIP;
mRenderOperation.useIndexes = false;
}
// SGD ：2013/6/18 15:02:51
// 说明：顶点纹理坐标
private unsafe void ReadTextureCoordData(uint vertexOffset, byte *vertexBuffer_Lock, uint vertexBuffer_VertexSize, VertexData vertexData)
{
VertexElement texElem = vertexData.vertexDeclaration.FindElementBySemantic(VertexElementSemantic.VES_TEXTURE_COORDINATES);
float * tReal;
if (texElem == null)
{
for (uint i = 0; i < vertexData.vertexCount; i++)
{
this._textureCroodnitas[vertexOffset + i] = new Vector2(0f, 0f);
}
}
else
{
//byte* vextex = vertexBuffer_Lock;
//for (uint i = 0; i < vertexData.vertexCount; i++) {
// texElem.BaseVertexPointerToElement(vextex, &tReal);
// this._textureCroodnitas[vertexOffset + i] = new Vector2(tReal[0], tReal[1]);
// vextex += vertexBuffer_VertexSize;
//}
//读取纹理坐标修正 2013/12/18
VertexData vertex_data = vertexData;
HardwareVertexBufferSharedPtr vbufPtr_tex = vertex_data.vertexBufferBinding.GetBuffer(texElem.Source);
byte *vertex_tex = (byte *)vbufPtr_tex.Lock(HardwareBuffer.LockOptions.HBL_READ_ONLY);
for (uint i = 0; i < vertex_data.vertexCount; ++i, /*vertex += vbufPtr.VertexSize,*/ vertex_tex += vbufPtr_tex.VertexSize)
{
//posElem.BaseVertexPointerToElement(vertex, &pReal);
texElem.BaseVertexPointerToElement(vertex_tex, &tReal);
this._textureCroodnitas[vertexOffset + i] = new Vector2(tReal[0], tReal[1]);
vertex_tex += vertexBuffer_VertexSize;
//Vector3 pt = new Vector3(pReal[0], pReal[1], pReal[2]);
//vertices[current_offset + j] = (orientation * (pt * scale)) + position;
//tex_Cors[current_offset + j] = new Vector2(tReal[0], tReal[1]);
}
vbufPtr_tex.Unlock();
vbufPtr_tex.Dispose();
}
}
protected void updateHardwareBuffers()
{
if (mChainElementList.Count < 2)
{
return;
}
// Here. we need to compute the position of the camera in the coordinate system of the billboard chain.
Vector3 eyePos = this.ParentNode._getDerivedOrientation().Inverse() *
(mCamera.GetDerivedPosition() - this.ParentNode._getDerivedPosition());
IntPtr ptrBuff;
uint buffIdx = 0;
int chainSize = mChainElementList.Count;
mVD.vertexCount = (uint)chainSize * 2;
// Setup the vertex coordinates
HardwareVertexBufferSharedPtr pPosBuffer = mVD.vertexBufferBinding.getBuffer(POSITION_BINDING);
ptrBuff = pPosBuffer.Get().Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
// Compute the position of the vertices in the chain
for (int i = 0; i < chainSize; i++)
{
myBillBoardChainElement bbe = (myBillBoardChainElement)mChainElementList[i];
Vector3 chainTangent;
if (i == 0)
{
chainTangent = bbe.position - ((myBillBoardChainElement)mChainElementList[0]).position;
}
else if (i == chainSize - 1)
{
chainTangent = ((myBillBoardChainElement)mChainElementList[chainSize - 1]).position -
((myBillBoardChainElement)mChainElementList[chainSize - 2]).position;
}
else
{
chainTangent = ((myBillBoardChainElement)mChainElementList[i + 1]).position -
((myBillBoardChainElement)mChainElementList[i - 1]).position;
}
Vector3 p1 = bbe.position;
Vector3 vP1ToEye = eyePos - p1;
Vector3 vPerpendicular = chainTangent.Cross(vP1ToEye);
vPerpendicular.Normalize();
vPerpendicular *= bbe.width;
Vector3 pos0 = p1 - vPerpendicular;
Vector3 pos1 = p1 + vPerpendicular;
// Update the buffer with the 2 vertex positions
MeshBuilderHelper.SetVertexFloat(ptrBuff, mVBVertexSize, buffIdx++, mVBPostOff,
pos0.x, pos0.y, pos0.z);
MeshBuilderHelper.SetVertexFloat(ptrBuff, mVBVertexSize, buffIdx++, mVBPostOff,
pos1.x, pos1.y, pos1.z);
}
pPosBuffer.Get().Unlock();
// Setup the diffuse color of the vertex
HardwareVertexBufferSharedPtr pVertexColorBuffer = mVD.vertexBufferBinding.getBuffer(DIFFUSE_COLOR_BINDING);
ptrBuff = pVertexColorBuffer.Get().Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
buffIdx = 0;
for (int i = 0; i < chainSize; i++)
{
Color col = ((myBillBoardChainElement)mChainElementList[i]).colour;
MeshBuilderHelper.SetVertexFloat(ptrBuff, mVCBVertexSize, buffIdx++, mVCBrgbaOff,
((float)col.R / 255.0f), ((float)col.G / 255.0f), ((float)col.B / 255.0f), ((float)col.A / 255.0f));
MeshBuilderHelper.SetVertexFloat(ptrBuff, mVCBVertexSize, buffIdx++, mVCBrgbaOff,
((float)col.R / 255.0f), ((float)col.G / 255.0f), ((float)col.B / 255.0f), ((float)col.A / 255.0f));
}
pVertexColorBuffer.Get().Unlock();
// Setup the texture coordinates
HardwareVertexBufferSharedPtr pTexCoordBuffer = mVD.vertexBufferBinding.getBuffer(TEXCOORD_BINDING);
ptrBuff = pTexCoordBuffer.Get().Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
buffIdx = 0;
for (int i = 0; i < chainSize; i++)
{
myBillBoardChainElement bbe = (myBillBoardChainElement)mChainElementList[i];
MeshBuilderHelper.SetVertexFloat(ptrBuff, mTCVertexSize, buffIdx++, mTCBuvOff,
bbe.uTexCoord, 0.0f);
MeshBuilderHelper.SetVertexFloat(ptrBuff, mTCVertexSize, buffIdx++, mTCBuvOff,
bbe.uTexCoord, 1.0f);
}
pTexCoordBuffer.Get().Unlock();
}
/// <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);
}
// 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;
}
}
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>
/// createGrassMesh
/// This demonstrates how to create a manual mesh
/// only use static members of MeshBuilderHelper to help set vertex and index data.
/// </summary>
void createGrassMesh()
{
OgreDotNet.MeshPtr mp = MeshManager.Instance.CreateManual(GRASS_MESH_NAME, "General");
SubMesh sm = mp.Get().CreateSubMesh();
sm.useSharedVertices = false;
sm.vertexData = new VertexData();
sm.vertexData.vertexStart = 0;
sm.vertexData.vertexCount = 12;
//mIndexType = HardwareIndexBuffer::IT_16BIT;
VertexDeclaration dcl = sm.vertexData.vertexDeclaration;
UInt32 offset = 0;
UInt32 offPos = dcl.addElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_POSITION).getOffset();
offset = VertexElement.getTypeSize(VertexElementType.VET_FLOAT3);
UInt32 offNorm = dcl.addElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_NORMAL).getOffset();
offset += VertexElement.getTypeSize(VertexElementType.VET_FLOAT3);
UInt32 offUV = dcl.addElement(0, offset, VertexElementType.VET_FLOAT2, VertexElementSemantic.VES_TEXTURE_COORDINATES).getOffset();
offset += VertexElement.getTypeSize(VertexElementType.VET_FLOAT2);
UInt32 vertexsize = offset;
mLog.LogMessage(string.Format("createGrassMesh vertexsize={0}", vertexsize));
HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager.getSingleton().createVertexBuffer(
vertexsize, 12, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
IntPtr pV = vbuf.Get().Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
Vector3 vec = new Vector3(GRASS_WIDTH / 2.0f, 0.0f, 0.0f);
Quaternion rot = Quaternion.FromAngleAxis(60, Vector3.UnitY);
uint i;
for (i = 0; i < 3; ++i)
{
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 0, offPos, -vec.x, GRASS_HEIGHT, -vec.z); //position
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 0, offNorm, 0.0f, 1.0f, 0.0f); //normal
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 0, offUV, 0.0f, 0.0f); //uv
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 1, offPos, vec.x, GRASS_HEIGHT, vec.z); //position
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 1, offNorm, 0.0f, 1.0f, 0.0f); //normal
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 1, offUV, 1.0f, 0.0f); //uv
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 2, offPos, -vec.x, 0.0f, -vec.z); //position
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 2, offNorm, 0.0f, 1.0f, 0.0f); //normal
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 2, offUV, 0.0f, 1.0f); //uv
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 3, offPos, vec.x, 0.0f, vec.z); //position
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 3, offNorm, 0.0f, 1.0f, 0.0f); //normal
OgreDotNet.MeshBuilderHelper.SetVertexFloat(pV, vertexsize, (i * 4) + 3, offUV, 1.0f, 1.0f); //uv
vec = rot * vec;
}
vbuf.Get().Unlock();
sm.vertexData.vertexBufferBinding.setBinding(0, vbuf);
sm.indexData.indexCount = 6 * 3;
sm.indexData.indexBuffer = HardwareBufferManager.getSingleton().createIndexBuffer(
HardwareIndexBuffer.IndexType.IT_16BIT, 6 * 3, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
IntPtr pI = sm.indexData.indexBuffer.Get().Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
for (i = 0; i < 3; ++i)
{
UInt16 off = (UInt16)(i * 4);
OgreDotNet.MeshBuilderHelper.SetIndex16bit(pI, (i * 2) + 0, (UInt16)(0 + off), (UInt16)(3 + off), (UInt16)(1 + off));
OgreDotNet.MeshBuilderHelper.SetIndex16bit(pI, (i * 2) + 1, (UInt16)(0 + off), (UInt16)(2 + off), (UInt16)(3 + off));
}
sm.indexData.indexBuffer.Get().Unlock();
sm.SetMaterialName(GRASS_MATERIAL);
mp.Get().Load();
}
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();
}
/**************** 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());
}
public myBillBoardChain(Camera vCamera, int maxNbChainElements) : base()
{
Init_Event_NotifyCurrentCamera();
Init_Event_GetSquaredViewDepth();
Init_Event_GetBoundingRadius();
evtNotifyCurrentCamera += new SRD_Delegate_notifyCurrentCamera(event_notifyCurrentCamera);
evtGetSquaredViewDepth += new SRD_Delegate_getSquaredViewDepth(event_getSquaredViewDepth);
evtGetBoundingRadius += new SRD_Delegate_getBoundingRadius(event_getBoundingRadius);
mCamera = vCamera;
mChainElementList = new ArrayList();
mRadius = 0.0f;
mMaxNbChainElements = maxNbChainElements;
mVD = new VertexData();
this.RO_VertexData = mVD;
this.RO_IndexData = null;
mVD.vertexCount = (uint)0;
mVD.vertexStart = 0;
this.RO_OperationType = OperationType.OT_TRIANGLE_STRIP;
this.RO_UseIndexes = false;
mVBPostOff = 0; mVBVertexSize = 0;
mVCBrgbaOff = 0; mVCBVertexSize = 0;
mTCBuvOff = 0; mTCVertexSize = 0;
//----------
// Add a description for the buffer of the positions of the vertices
mVBPostOff = mVD.vertexDeclaration.addElement(POSITION_BINDING, 0, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_POSITION).getOffset();
mVBVertexSize += VertexElement.getTypeSize(VertexElementType.VET_FLOAT3);
// Create the buffer
HardwareVertexBufferSharedPtr pVertexBuffer = HardwareBufferManager.getSingleton().createVertexBuffer(
mVD.vertexDeclaration.getVertexSize(POSITION_BINDING),
(uint)(mMaxNbChainElements * 2),
HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
// Bind the buffer
mVD.vertexBufferBinding.setBinding(POSITION_BINDING, pVertexBuffer);
//----------
// Add a description for the buffer of the diffuse color of the vertices
mVCBrgbaOff = mVD.vertexDeclaration.addElement(DIFFUSE_COLOR_BINDING, 0, VertexElementType.VET_FLOAT4, VertexElementSemantic.VES_DIFFUSE).getOffset();
mVCBVertexSize += VertexElement.getTypeSize(VertexElementType.VET_FLOAT4);
// Create the buffer
HardwareVertexBufferSharedPtr pVertexColorBuffer = HardwareBufferManager.getSingleton().createVertexBuffer(
mVD.vertexDeclaration.getVertexSize(DIFFUSE_COLOR_BINDING),
(uint)(mMaxNbChainElements * 2),
HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
// Bind the buffer
mVD.vertexBufferBinding.setBinding(DIFFUSE_COLOR_BINDING, pVertexColorBuffer);
//----------
// Add a description for the buffer of the texture coordinates of the vertices
mTCBuvOff = mVD.vertexDeclaration.addElement(TEXCOORD_BINDING, 0, VertexElementType.VET_FLOAT2, VertexElementSemantic.VES_TEXTURE_COORDINATES).getOffset();
mTCVertexSize += VertexElement.getTypeSize(VertexElementType.VET_FLOAT2);
// Create the buffer
HardwareVertexBufferSharedPtr pTexCoordBuffer = HardwareBufferManager.getSingleton().createVertexBuffer(
mVD.vertexDeclaration.getVertexSize(TEXCOORD_BINDING),
(uint)(mMaxNbChainElements * 2),
HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
// Bind the buffer
mVD.vertexBufferBinding.setBinding(TEXCOORD_BINDING, pTexCoordBuffer);
// set basic white material
this.setMaterial("BaseWhiteNoLighting");
}
/// <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();
}
} // 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();
}
public virtual void CreateVertexBuffer(uint numVerts, HardwareBuffer.Usage usage, bool useShadowBuffer)
{
mVertexSize = offset;
mNumVerts = numVerts;
mvbuf = HardwareBufferManager.Singleton.CreateVertexBuffer(
mVertexSize, mNumVerts, usage, useShadowBuffer);
unsafe
{
pVBuffStart = mvbuf.Lock(HardwareBuffer.LockOptions.HBL_DISCARD);
}
}
// 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;
}
}
//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();
}
/// <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];
}
internal unsafe void saveModelJSON(string filename)
{
StringBuilder sb = new StringBuilder();
using (MeshPtr mesh = entity.getMesh())
{
SubMesh subMesh = mesh.Value.getSubMesh(0);
VertexData vertexData = subMesh.vertexData;
VertexDeclaration vertexDeclaration = vertexData.vertexDeclaration;
VertexBufferBinding vertexBinding = vertexData.vertexBufferBinding;
VertexElement normalElement = vertexDeclaration.findElementBySemantic(VertexElementSemantic.VES_NORMAL);
VertexElement tangentElement = vertexDeclaration.findElementBySemantic(VertexElementSemantic.VES_TANGENT);
VertexElement binormalElement = vertexDeclaration.findElementBySemantic(VertexElementSemantic.VES_BINORMAL);
VertexElement uvElement = vertexDeclaration.findElementBySemantic(VertexElementSemantic.VES_TEXTURE_COORDINATES);
VertexElement positionElement = vertexDeclaration.findElementBySemantic(VertexElementSemantic.VES_POSITION);
int numVertices = vertexData.vertexCount.ToInt32();
HardwareVertexBufferSharedPtr normalHardwareBuffer = vertexBinding.getBuffer(normalElement.getSource());
int normalVertexSize = normalHardwareBuffer.Value.getVertexSize().ToInt32();
byte *normalBuffer = (byte *)normalHardwareBuffer.Value.lockBuf(HardwareBuffer.LockOptions.HBL_READ_ONLY);
HardwareVertexBufferSharedPtr tangentHardwareBuffer = vertexBinding.getBuffer(tangentElement.getSource());
int tangetVertexSize = tangentHardwareBuffer.Value.getVertexSize().ToInt32();
byte *tangentBuffer = (byte *)tangentHardwareBuffer.Value.lockBuf(HardwareBuffer.LockOptions.HBL_READ_ONLY);
HardwareVertexBufferSharedPtr binormalHardwareBuffer = vertexBinding.getBuffer(binormalElement.getSource());
int binormalVertexSize = binormalHardwareBuffer.Value.getVertexSize().ToInt32();
byte *binormalBuffer = (byte *)binormalHardwareBuffer.Value.lockBuf(HardwareBuffer.LockOptions.HBL_NORMAL);
HardwareVertexBufferSharedPtr uvHardwareBuffer = vertexBinding.getBuffer(uvElement.getSource());
int uvVertexSize = uvHardwareBuffer.Value.getVertexSize().ToInt32();
byte *uvBuffer = (byte *)uvHardwareBuffer.Value.lockBuf(HardwareBuffer.LockOptions.HBL_NORMAL);
HardwareVertexBufferSharedPtr positionHardwareBuffer = vertexBinding.getBuffer(positionElement.getSource());
int positionVertexSize = positionHardwareBuffer.Value.getVertexSize().ToInt32();
byte *positionBuffer = (byte *)positionHardwareBuffer.Value.lockBuf(HardwareBuffer.LockOptions.HBL_NORMAL);
Vector3 *normal;
Vector3 *tangent;
Vector3 *binormal;
Vector3 *uv;
Vector3 *position;
IndexData indexData = subMesh.indexData;
sb.AppendFormat(@"{{
""metadata"":
{{
""sourceFile"": ""Skull.max"",
""generatedBy"": ""3ds max ThreeJSExporter"",
""formatVersion"": 3,
""vertices"": {0},
""normals"": {1},
""colors"": 0,
""uvs"": {2},
""triangles"": {3},
""materials"": 1
}},
""materials"": [
{{
""DbgIndex"" : 0,
""DbgName"" : ""Material #327"",
""colorDiffuse"" : [0.5880, 0.5880, 0.5880],
""colorAmbient"" : [0.5880, 0.5880, 0.5880],
""colorSpecular"" : [0.9000, 0.9000, 0.9000],
""transparency"" : 1.0,
""specularCoef"" : 10.0,
""vertexColors"" : false
}}
],
", numVertices, numVertices, numVertices, indexData.IndexBuffer.Value.getNumIndexes().ToInt32() / 3);
StringBuilder vertexStringBuilder = new StringBuilder("\n\n\"vertices\": [");
StringBuilder normalStringBuilder = new StringBuilder("\n\n\"normals\": [");
StringBuilder uvStringBuilder = new StringBuilder("\n\n\"uvs\": [[");
String appendString = "{0},{1},{2}";
for (int i = 0; i < numVertices; ++i)
{
normalElement.baseVertexPointerToElement(normalBuffer, (float **)&normal);
tangentElement.baseVertexPointerToElement(tangentBuffer, (float **)&tangent);
binormalElement.baseVertexPointerToElement(binormalBuffer, (float **)&binormal);
uvElement.baseVertexPointerToElement(uvBuffer, (float **)&uv);
positionElement.baseVertexPointerToElement(positionBuffer, (float **)&position);
//*binormal = normal->cross(ref *tangent) * -1.0f;
vertexStringBuilder.AppendFormat(appendString, position->x, position->y, position->z);
normalStringBuilder.AppendFormat(appendString, normal->x, normal->y, normal->z);
uvStringBuilder.AppendFormat(appendString, uv->x, uv->y, uv->z);
normalBuffer += normalVertexSize;
tangentBuffer += tangetVertexSize;
binormalBuffer += binormalVertexSize;
uvBuffer += uvVertexSize;
positionBuffer += positionVertexSize;
appendString = ",{0},{1},{2}";
}
vertexStringBuilder.Append("],");
normalStringBuilder.Append("],");
uvStringBuilder.Append("]],");
normalHardwareBuffer.Value.unlock();
tangentHardwareBuffer.Value.unlock();
binormalHardwareBuffer.Value.unlock();
uvHardwareBuffer.Value.unlock();
positionHardwareBuffer.Value.unlock();
normalHardwareBuffer.Dispose();
tangentHardwareBuffer.Dispose();
binormalHardwareBuffer.Dispose();
uvHardwareBuffer.Dispose();
positionHardwareBuffer.Dispose();
sb.Append(vertexStringBuilder.ToString());
sb.Append(normalStringBuilder.ToString());
sb.Append(uvStringBuilder.ToString());
sb.Append("\n\n\"colors\": [],");
StringBuilder triangleStringBuilder = new StringBuilder("\n\n\"faces\": [");
int numFaces = indexData.IndexBuffer.Value.getNumIndexes().ToInt32();
int indexSize = indexData.IndexBuffer.Value.getIndexSize().ToInt32();
byte *indexBuffer = (byte *)indexData.IndexBuffer.Value.lockBuf(HardwareBuffer.LockOptions.HBL_READ_ONLY);
appendString = "{0}";
switch (indexData.IndexBuffer.Value.getType())
{
case HardwareIndexBuffer.IndexType.IT_16BIT:
for (int i = 0; i < numFaces; ++i)
{
triangleStringBuilder.AppendFormat(appendString, *(short *)indexBuffer);
indexBuffer += indexSize;
appendString = ",{0}";
}
break;
case HardwareIndexBuffer.IndexType.IT_32BIT:
for (int i = 0; i < numFaces; ++i)
{
triangleStringBuilder.AppendFormat(appendString, *(int *)indexBuffer);
indexBuffer += indexSize;
appendString = ",{0}";
}
break;
}
triangleStringBuilder.Append("]");
sb.Append(triangleStringBuilder.ToString());
sb.Append("\n\n}");
}
using (StreamWriter fileStream = new StreamWriter(File.Open(filename, FileMode.Create, FileAccess.Write)))
{
fileStream.Write(sb.ToString());
}
}
private void CreateGrassMesh()
{
// Each grass section is 3 planes at 60 degrees to each other
// Normals point straight up to simulate correct lighting
Mesh msh = MeshManager.Singleton.CreateManual(GRASS_MESH_NAME, ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME, null);
SubMesh sm = msh.CreateSubMesh();
sm.useSharedVertices = false;
sm.vertexData = new VertexData();
sm.vertexData.vertexStart = 0;
sm.vertexData.vertexCount = 12;
VertexDeclaration dcl = sm.vertexData.vertexDeclaration;
uint offset = 0;
dcl.AddElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_POSITION);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
dcl.AddElement(0, offset, VertexElementType.VET_FLOAT3, VertexElementSemantic.VES_NORMAL);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT3);
dcl.AddElement(0, offset, VertexElementType.VET_FLOAT2, VertexElementSemantic.VES_TEXTURE_COORDINATES);
offset += VertexElement.GetTypeSize(VertexElementType.VET_FLOAT2);
HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager.Singleton.CreateVertexBuffer(offset, 12, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
int i;
unsafe {
float *pData = (float *)(vbuf.Lock(HardwareBuffer.LockOptions.HBL_DISCARD));
Vector3 baseVec = new Vector3(GRASS_WIDTH / 2, 0, 0);
Vector3 vec = baseVec;
Quaternion rot = new Quaternion();
rot.FromAngleAxis(Math.DegreesToRadians(60), Vector3.UNIT_Y);
for (i = 0; i < 3; ++i)
{
//position
*pData++ = -vec.x;
*pData++ = GRASS_HEIGHT;
*pData++ = -vec.z;
// normal
*pData++ = 0;
*pData++ = 1;
*pData++ = 0;
// uv
*pData++ = 0;
*pData++ = 0;
// position
*pData++ = vec.x;
*pData++ = GRASS_HEIGHT;
*pData++ = vec.z;
// normal
*pData++ = 0;
*pData++ = 1;
*pData++ = 0;
// uv
*pData++ = 1;
*pData++ = 0;
// position
*pData++ = -vec.x;
*pData++ = 0;
*pData++ = -vec.z;
// normal
*pData++ = 0;
*pData++ = 1;
*pData++ = 0;
// uv
*pData++ = 0;
*pData++ = 1;
// position
*pData++ = vec.x;
*pData++ = 0;
*pData++ = vec.z;
// normal
*pData++ = 0;
*pData++ = 1;
*pData++ = 0;
// uv
*pData++ = 1;
*pData++ = 1;
vec = rot * vec;
} //for
} //unsafe
vbuf.Unlock();
sm.vertexData.vertexBufferBinding.SetBinding(0, vbuf);
sm.indexData.indexCount = 6 * 3;
sm.indexData.indexBuffer = HardwareBufferManager.Singleton.CreateIndexBuffer(HardwareIndexBuffer.IndexType.IT_16BIT, 6 * 3, HardwareBuffer.Usage.HBU_STATIC_WRITE_ONLY);
unsafe {
ushort *pI = (ushort *)(sm.indexData.indexBuffer.Lock(HardwareBuffer.LockOptions.HBL_DISCARD));
for (i = 0; i < 3; ++i)
{
int off = i * 4;
* pI++ = (ushort)(off);
* pI++ = (ushort)(off + 3);
* pI++ = (ushort)(off + 1);
*pI++ = (ushort)(off + 0);
*pI++ = (ushort)(off + 2);
*pI++ = (ushort)(off + 3);
}
}
sm.indexData.indexBuffer.Unlock();
sm.SetMaterialName(GRASS_MATERIAL);
msh.Load();
}
