/*求对象rend和射线ray的全部交点到射线原点的距离
*/
vector<Ogre::Real> BaseManager::Intersect(const Ogre::Ray& ray,Ogre::Renderable *rend){
Ogre::RenderOperation op;
Ogre::VertexElementType vtype;
size_t offset,pkgsize,source,indexNums,vertexNums;
vector<Ogre::Real> result;
rend->getRenderOperation( op );
if( !op.indexData ||
op.operationType==Ogre::RenderOperation::OT_LINE_LIST ||
op.operationType==Ogre::RenderOperation::OT_LINE_STRIP ||
op.operationType==Ogre::RenderOperation::OT_POINT_LIST )
return result;
Ogre::VertexDeclaration* pvd = op.vertexData->vertexDeclaration;
source = -1;
for( size_t i = 0;i < pvd->getElementCount();++i ){
if( pvd->getElement(i)->getSemantic()==Ogre::VES_POSITION ){
source = pvd->getElement(i)->getSource();
offset = pvd->getElement(i)->getOffset();
vtype = pvd->getElement(i)->getType();
break;
}
}
if( source == - 1 || vtype != Ogre::VET_FLOAT3 ) //别的格式目前没有考虑
return result;
/*source对应与一个缓存区
getVertexSize(source)求缓存区中一个紧密数据包的大小
例如：一个数据包里面包括POSITION,COLOR,NORMAL,TEXCROOD然后在这个缓冲
区中循环。而getVertexSize求出这个包的字节大小
例如POSITION(FLOAT3) TEXCROOD(FLOAT2) 这样前面的是12字节后面的是8字节
getVertexSize返回20
*/
pkgsize = pvd->getVertexSize(source);
Ogre::HardwareVertexBufferSharedPtr hvb = op.vertexData->vertexBufferBinding->getBuffer(source);
Ogre::HardwareIndexBufferSharedPtr ivb = op.indexData->indexBuffer;
Ogre::HardwareIndexBuffer::IndexType indexType = op.indexData->indexBuffer->getType();
/*先将顶点数据复制一份，然后变换到世界坐标系
*/
vertexNums = hvb->getNumVertices();
indexNums = ivb->getNumIndexes();
boost::scoped_array<float> vp( new float[3*vertexNums] );
boost::scoped_array<unsigned int> ip( new unsigned int[indexNums] );
{
Ogre::Vector3 p3;
Ogre::Matrix4 mat;
rend->getWorldTransforms( &mat );
float* preal = (float*)hvb->lock( Ogre::HardwareBuffer::HBL_READ_ONLY );
float* ptarget = vp.get();
//这里考虑到对齐，我假设offset和pkgsize都可以被sizeof(float)整除
preal += offset/sizeof(float);
size_t strip = pkgsize/sizeof(float);
for( size_t i = 0; i < vertexNums;++i ){
p3.x = *preal;
p3.y = *(preal+1);
p3.z = *(preal+2);
p3 = mat * p3;
*ptarget++ = p3.x;
*ptarget++ = p3.y;
*ptarget++ = p3.z;
preal += strip;
}
hvb->unlock();
}
//拷贝出顶点数据
{
unsigned int* pindex32 = ip.get();
if( indexType==Ogre::HardwareIndexBuffer::IT_16BIT ){
unsigned short* pi16 = (unsigned short*)ivb->lock( Ogre::HardwareBuffer::HBL_READ_ONLY );
copy( pi16,pi16+indexNums,pindex32 );
}else
memcpy( pindex32,ivb->lock( Ogre::HardwareBuffer::HBL_READ_ONLY ),ivb->getSizeInBytes() );
ivb->unlock();
}
/*数据都准备好了，vp保存了变换好的顶点，ip保存了顶点索引
下面根据情况求交点
*/
switch( op.operationType ){
case Ogre::RenderOperation::OT_TRIANGLE_LIST:
{ /* 0,1,2 组成一个三角 3,4,5 下一个...
*/
Ogre::Vector3 a[3],n;
int index,k = 0;
float* preal = vp.get();
unsigned int* pindex = ip.get();
for( size_t i = 0;i<indexNums;++i ){
if( pindex[i] < vertexNums ){
index = pindex[i]*3; //对应与格式VET_FLOAT3
a[k].x = preal[index];
a[k].y = preal[index+1];
a[k].z = preal[index+2];
if( k == 2 ){//三个点都填满了
//这里使用的是Math3d的求交函数，而不是Ogre::Math的
//原因就在于Ogre::Math的求交点函数不能得到射线背面那个负的交点
std::pair<bool,Ogre::Real> res = Math3d::intersects(ray,a[0],a[1],a[2],true,true);
if( res.first )
result.push_back( res.second );
k = 0;
}else
k++;
}else{
WARNING_LOG("Game::Intersect"<<" Invalid index rang out" << " pindex["<<i<<"]="<<pindex[i] << "("<<vertexNums<<")");
return result;
}
}
}
break;
case Ogre::RenderOperation::OT_TRIANGLE_FAN:
{/* 0,1,2组成一个三角 0,2,3 组成下一个 0,3,4...
*/
assert( false||"Game::Intersect can't support OT_TRIANGLE_FAN " );
}
break;
case Ogre::RenderOperation::OT_TRIANGLE_STRIP:
{//0,1,2组成第一个三角 1,2,3 组成下一个 2,3,4...
assert( false||"Game::Intersect can't support OT_TRIANGLE_STRIP " );
}
break;
default:;
}
return result;
}
void GetTrianglesFromMesh(Ogre::Mesh* mesh, std::vector<float3>& dest)
{
dest.clear();
try
{
for(uint i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* submesh = mesh->getSubMesh(i);
Ogre::VertexData* vertex_data = submesh->useSharedVertices ? mesh->sharedVertexData : submesh->vertexData;
const Ogre::VertexElement* posElem = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
Ogre::HardwareVertexBufferSharedPtr vbuf = vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
unsigned char* vertices = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
size_t vertexSize = vbuf->getVertexSize();
float* pReal = 0;
Ogre::IndexData* index_data = submesh->indexData;
size_t numTris = index_data->indexCount / 3;
Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
u32* pLong = static_cast<u32*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
u16* pShort = reinterpret_cast<u16*>(pLong);
bool use32bitindexes = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
if (use32bitindexes)
{
for(size_t k = 0; k < numTris * 3; k += 3)
{
uint i1 = pLong[k];
uint i2 = pLong[k+1];
uint i3 = pLong[k+2];
posElem->baseVertexPointerToElement(vertices + i1 * vertexSize, &pReal);
dest.push_back(float3(pReal[0], pReal[1], pReal[2]));
posElem->baseVertexPointerToElement(vertices + i2 * vertexSize, &pReal);
dest.push_back(float3(pReal[0], pReal[1], pReal[2]));
posElem->baseVertexPointerToElement(vertices + i3 * vertexSize, &pReal);
dest.push_back(float3(pReal[0], pReal[1], pReal[2]));
}
}
else
{
for(size_t k = 0; k < numTris * 3; k += 3)
{
uint i1 = pShort[k];
uint i2 = pShort[k+1];
uint i3 = pShort[k+2];
posElem->baseVertexPointerToElement(vertices + i1 * vertexSize, &pReal);
dest.push_back(float3(pReal[0], pReal[1], pReal[2]));
posElem->baseVertexPointerToElement(vertices + i2 * vertexSize, &pReal);
dest.push_back(float3(pReal[0], pReal[1], pReal[2]));
posElem->baseVertexPointerToElement(vertices + i3 * vertexSize, &pReal);
dest.push_back(float3(pReal[0], pReal[1], pReal[2]));
}
}
vbuf->unlock();
ibuf->unlock();
}
} catch(Ogre::Exception &e)
{
///\todo Fix Ogre to not allow meshes like this to be successfully created.
LogError("GetTrianglesFromMesh failed for mesh! Ogre threw an exception: " + QString(e.what()));
dest.clear();
}
}
bool ShaderParticleRenderer::allocateBuffers(size_t iNumParticles)
{
// prepare vertex declaration
if (mVertexData->vertexDeclaration->getElementCount() == 0) {
VertexDeclaration* pDecl = mVertexData->vertexDeclaration;
size_t ofs = 0;
ofs += pDecl->addElement(0, ofs, VET_FLOAT4, VES_POSITION).getSize(); // position
if (mVertexFormatColour)
ofs += pDecl->addElement(0, ofs, VET_FLOAT4, VES_DIFFUSE).getSize(); // diffuse colour
// other data are stored in vertex as texture coordinates
ushort ix = 0;
if (mVertexFormatTexture)
ofs += pDecl->addElement(0, ofs, VET_FLOAT2, VES_TEXTURE_COORDINATES, ix++).getSize(); // general texture coord
if (mVertexFormatSize)
ofs += pDecl->addElement(0, ofs, VET_FLOAT2, VES_TEXTURE_COORDINATES, ix++).getSize(); // particle size
if (mVertexFormatRotation || mVertexFormatRotationSpeed) {
if (mVertexFormatRotation && mVertexFormatRotationSpeed)
ofs += pDecl->addElement(0, ofs, VET_FLOAT2, VES_TEXTURE_COORDINATES, ix++).getSize(); // current rotation and rotation speed
else
ofs += pDecl->addElement(0, ofs, VET_FLOAT1, VES_TEXTURE_COORDINATES, ix++).getSize(); // current rotation or rotation speed
}
if (mVertexFormatDirection)
ofs += pDecl->addElement(0, ofs, VET_FLOAT3, VES_TEXTURE_COORDINATES, ix++).getSize(); // particle direction (as speed)
// add packed times
size_t iNumTimes = 0;
if (mVertexFormatTTL) iNumTimes++;
if (mVertexFormatTotalTTL) iNumTimes++;
if (mVertexFormatTimeFragment) iNumTimes++;
if (mVertexFormatTimeFragmentInv) iNumTimes++;
switch(iNumTimes) {
case 1:
ofs += pDecl->addElement(0, ofs, VET_FLOAT1, VES_TEXTURE_COORDINATES, ix++).getSize();
break;
case 2:
ofs += pDecl->addElement(0, ofs, VET_FLOAT2, VES_TEXTURE_COORDINATES, ix++).getSize();
break;
case 3:
ofs += pDecl->addElement(0, ofs, VET_FLOAT3, VES_TEXTURE_COORDINATES, ix++).getSize();
break;
case 4:
ofs += pDecl->addElement(0, ofs, VET_FLOAT4, VES_TEXTURE_COORDINATES, ix++).getSize();
break;
}
// add custom parameters
ofs += pDecl->addElement(0, ofs, VET_FLOAT4, VES_TEXTURE_COORDINATES, ix++).getSize();
assert(ix <= 8);
// cache vertex size
mVertexSize = pDecl->getVertexSize(0);
}
Ogre::HardwareVertexBufferSharedPtr pVB;
if (mVertexData->vertexBufferBinding->isBufferBound(0))
pVB = mVertexData->vertexBufferBinding->getBuffer(0);
// prepare vertex buffer
if (pVB.isNull() || pVB->getNumVertices() < iNumParticles * 4) {
assert(iNumParticles * 4 < 65536); // we are using 16bit index buffer
pVB = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(mVertexSize, 4 * iNumParticles, Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
if (pVB.isNull())
return false;
mVertexData->vertexBufferBinding->setBinding(0, pVB);
}
// prepare index buffer
Ogre::HardwareIndexBufferSharedPtr pIB = mIndexData->indexBuffer;
if (pIB.isNull() || pIB->getNumIndexes() < iNumParticles * 6) {
pIB = Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(Ogre::HardwareIndexBuffer::IT_16BIT, iNumParticles * 6, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY);
if (pIB.isNull())
return false;
mIndexData->indexBuffer = pIB;
// fill
Ogre::uint16* pDataIB = reinterpret_cast<Ogre::uint16*>(pIB->lock(Ogre::HardwareBuffer::HBL_NORMAL));
for (Ogre::uint16 k=0; k<static_cast<Ogre::uint16>(iNumParticles); ++k) {
pDataIB[0] = k*4 + 0;
pDataIB[1] = k*4 + 1;
pDataIB[2] = k*4 + 2;
pDataIB[3] = k*4 + 0;
pDataIB[4] = k*4 + 2;
pDataIB[5] = k*4 + 3;
pDataIB += 6;
}
pIB->unlock();
}
return true;
}
// Get the mesh information for the given mesh.
// Code found on this forum link: http://www.ogre3d.org/wiki/index.php/RetrieveVertexData
void CollisionTools::GetMeshInformation(const Ogre::MeshPtr mesh,
size_t &vertex_count,
Ogre::Vector3* &vertices,
size_t &index_count,
Ogre::uint32* &indices,
const Ogre::Vector3 &position,
const Ogre::Quaternion &orient,
const Ogre::Vector3 &scale)
{
bool added_shared = false;
size_t current_offset = 0;
size_t shared_offset = 0;
size_t next_offset = 0;
size_t index_offset = 0;
vertex_count = index_count = 0;
// Calculate how many vertices and indices we're going to need
for (unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::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 Ogre::Vector3[vertex_count];
indices = new Ogre::uint32[index_count];
added_shared = false;
// Run through the submeshes again, adding the data into the arrays
for ( unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* submesh = mesh->getSubMesh(i);
Ogre::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;
}
const Ogre::VertexElement* posElem =
vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
Ogre::HardwareVertexBufferSharedPtr vbuf =
vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
unsigned char* vertex =
static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
// There is _no_ baseVertexPointerToElement() which takes an Ogre::Ogre::Real or a double
// as second argument. So make it float, to avoid trouble when Ogre::Ogre::Real will
// be comiled/typedefed as double:
// Ogre::Ogre::Real* pOgre::Real;
float* pReal;
for( size_t j = 0; j < vertex_data->vertexCount; ++j, vertex += vbuf->getVertexSize())
{
posElem->baseVertexPointerToElement(vertex, &pReal);
Ogre::Vector3 pt(pReal[0], pReal[1], pReal[2]);
vertices[current_offset + j] = (orient * (pt * scale)) + position;
}
vbuf->unlock();
next_offset += vertex_data->vertexCount;
}
Ogre::IndexData* index_data = submesh->indexData;
size_t numTris = index_data->indexCount / 3;
Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
bool use32bitindexes = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
Ogre::uint32* pLong = static_cast<Ogre::uint32*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
unsigned short* pShort = reinterpret_cast<unsigned short*>(pLong);
size_t offset = (submesh->useSharedVertices)? shared_offset : current_offset;
if ( use32bitindexes )
{
for ( size_t k = 0; k < numTris*3; ++k)
{
indices[index_offset++] = pLong[k] + static_cast<Ogre::uint32>(offset);
}
}
else
{
for ( size_t k = 0; k < numTris*3; ++k)
{
indices[index_offset++] = static_cast<Ogre::uint32>(pShort[k]) +
static_cast<Ogre::uint32>(offset);
}
}
ibuf->unlock();
current_offset = next_offset;
}
}
/* -----------------------------------------------------------------------
| the function describe retrieve vertexbuffer from Ogre entity :
| (Ref:http://www.ogre3d.org/tikiwiki/tiki-index.php?page=RetrieveVertexData)
|
| @prama in : Ogre entity
| @pamra out : vertex buffer, size of vertexbuffer, vertex indices, sizeof vertex indices
----------------------------------------------------------------------- */
void
getVertexBuffer(Ogre::Entity* ent, void* &vertices, size_t& vertexCount, void* &indices, size_t& indexCount)
{
bool added_shared = false;
size_t current_offset = 0;
size_t shared_offset = 0;
size_t next_offset = 0;
size_t index_offset = 0;
vertexCount = indexCount = 0;
const Ogre::MeshPtr& mesh = ent->getMesh();
// Calculate vertexCount, indexCount
for ( Ogre::ushort i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* subMesh = mesh->getSubMesh(i);
if (subMesh->useSharedVertices)
{
if( !added_shared )
{
vertexCount += mesh->sharedVertexData->vertexCount;
added_shared = true;
}
vertexCount += mesh->sharedVertexData->vertexCount;
}
else
vertexCount += subMesh->vertexData->vertexCount;
indexCount += subMesh->indexData->indexCount;
}
// Alloc vertices, indices
vertices = new Ogre::Vector3[ vertexCount ];
indices = new Ogre::ulong[ indexCount ];
added_shared = false;
// Assign vertices data, indices data
for (Ogre::ushort i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* subMesh = mesh->getSubMesh(i);
Ogre::VertexData* vertexData = subMesh->useSharedVertices ? mesh->sharedVertexData : subMesh->vertexData;
if ((!subMesh->useSharedVertices) || (subMesh->useSharedVertices && !added_shared))
{
if(subMesh->useSharedVertices)
{
added_shared = true;
shared_offset = current_offset;
}
// Retrieve vertices
const Ogre::VertexElement* posElem = vertexData->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
Ogre::HardwareVertexBufferSharedPtr vbuf = vertexData->vertexBufferBinding->getBuffer(posElem->getSource());
Ogre::uchar* vertex = static_cast<Ogre::uchar*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
Ogre::Real* data;
for (size_t j = 0 ; j < vertexData->vertexCount ; ++j, vertex += vbuf->getVertexSize())
{
posElem->baseVertexPointerToElement(vertex, &data);
Ogre::Vector3 origin(data[0], data[1], data[2]);
// ((Ogre::Vector3*)vertices)[ current_offset + j ] = (orient * (origin * scale)) + position;
((Ogre::Vector3*)vertices)[ current_offset + j ] = origin;
} // End for
vbuf->unlock();
next_offset += vertexData->vertexCount;
} // End if
// Retrieve indices
Ogre::IndexData* indexData = subMesh->indexData;
size_t trisCount = indexData->indexCount / 3;
Ogre::HardwareIndexBufferSharedPtr ibuf = indexData->indexBuffer;
bool use32bitindexes = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
void* index = (ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
Ogre::ulong offset = (subMesh->useSharedVertices) ? shared_offset : current_offset;
for (Ogre::ulong k = 0; k < trisCount * 3; ++k)
{
if ( use32bitindexes )
((Ogre::ulong*)indices)[ index_offset++ ] = ((Ogre::ulong*)index)[ k + offset ];
else
((Ogre::ulong*)indices)[ index_offset++ ] = ((Ogre::ushort*)index)[ k + offset ];
}
ibuf->unlock();
current_offset = next_offset;
} // End for
}
void TutorialApplication::createSphere(const std::string& strName, const float r, const int nRings, const int nSegments) {
Ogre::MeshPtr pSphere = Ogre::MeshManager::getSingleton().createManual(Ogre::String(strName), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::SubMesh *pSphereVertex = pSphere->createSubMesh();
pSphere->sharedVertexData = new Ogre::VertexData();
Ogre::VertexData* vertexData = pSphere->sharedVertexData;
// define the vertex format
Ogre::VertexDeclaration* vertexDecl = vertexData->vertexDeclaration;
size_t currOffset = 0;
// positions
vertexDecl->addElement(0, currOffset, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
currOffset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
// normals
vertexDecl->addElement(0, currOffset, Ogre::VET_FLOAT3, Ogre::VES_NORMAL);
currOffset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
// two dimensional texture coordinates
vertexDecl->addElement(0, currOffset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES, 0);
currOffset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT2);
// allocate the vertex buffer
vertexData->vertexCount = (nRings + 1) * (nSegments+1);
Ogre::HardwareVertexBufferSharedPtr vBuf = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(vertexDecl->getVertexSize(0), vertexData->vertexCount, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
Ogre::VertexBufferBinding* binding = vertexData->vertexBufferBinding;
binding->setBinding(0, vBuf);
float* pVertex = static_cast<float*>(vBuf->lock(Ogre::HardwareBuffer::HBL_DISCARD));
// allocate index buffer
pSphereVertex->indexData->indexCount = 6 * nRings * (nSegments + 1);
pSphereVertex->indexData->indexBuffer = Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(Ogre::HardwareIndexBuffer::IT_16BIT, pSphereVertex->indexData->indexCount, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
Ogre::HardwareIndexBufferSharedPtr iBuf = pSphereVertex->indexData->indexBuffer;
unsigned short* pIndices = static_cast<unsigned short*>(iBuf->lock(Ogre::HardwareBuffer::HBL_DISCARD));
float fDeltaRingAngle = (Ogre::Math::PI / nRings);
float fDeltaSegAngle = (2 * Ogre::Math::PI / nSegments);
unsigned short wVerticeIndex = 0 ;
// Generate the group of rings for the sphere
for( int ring = 0; ring <= nRings; ring++ ) {
float r0 = r * sinf (ring * fDeltaRingAngle);
float y0 = r * cosf (ring * fDeltaRingAngle);
// Generate the group of segments for the current ring
for(int seg = 0; seg <= nSegments; seg++) {
float x0 = r0 * sinf(seg * fDeltaSegAngle);
float z0 = r0 * cosf(seg * fDeltaSegAngle);
// Add one vertex to the strip which makes up the sphere
*pVertex++ = x0;
*pVertex++ = y0;
*pVertex++ = z0;
Ogre::Vector3 vNormal = Ogre::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++ = wVerticeIndex + nSegments + 1;
*pIndices++ = wVerticeIndex;
*pIndices++ = wVerticeIndex + nSegments;
*pIndices++ = wVerticeIndex + nSegments + 1;
*pIndices++ = 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( Ogre::AxisAlignedBox( Ogre::Vector3(-r, -r, -r), Ogre::Vector3(r, r, r) ), false );
pSphere->_setBoundingSphereRadius(r);
// this line makes clear the mesh is loaded (avoids memory leaks)
pSphere->load();
}
Mesh loadMesh(const std::string& meshName)
{
Mesh result;
bool addedShared = false;
size_t currentOffset = 0;
size_t sharedOffset = 0;
size_t nextOffset = 0;
size_t indexOffset = 0;
const v3 scale = v3::UNIT_SCALE;
const v3 position = v3::ZERO;
const qv4 orientation = qv4::IDENTITY;
Ogre::MeshManager* mm = Ogre::MeshManager::getSingletonPtr();
assert(mm && "Ogre must be initialized");
//! \todo check for mesh existance.
Ogre::MeshPtr mesh = mm->load(meshName, "General");
// Calculate how many result.mVertices and result.mIndices we're going to need
for (unsigned short i=0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* subMesh = mesh->getSubMesh(i);
// We only need to add the shared result.mVertices once
if (subMesh->useSharedVertices)
{
if (!addedShared)
{
result.mVertexCount += mesh->sharedVertexData->vertexCount;
addedShared = true;
}
}
else
{
result.mVertexCount += subMesh->vertexData->vertexCount;
}
result.mIndexCount += subMesh->indexData->indexCount;
}
result.mVertices.reset(new v3[result.mVertexCount]);
result.mIndices.reset(new u32[result.mIndexCount]);
addedShared = false;
// Run through the sub-meshes again, adding the data into the arrays
for (unsigned short i=0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* subMesh = mesh->getSubMesh(i);
Ogre::VertexData* vertexData = subMesh->useSharedVertices ? mesh->sharedVertexData : subMesh->vertexData;
if((!subMesh->useSharedVertices) || (subMesh->useSharedVertices && !addedShared))
{
if(subMesh->useSharedVertices)
{
addedShared = true;
sharedOffset = currentOffset;
}
const Ogre::VertexElement* posElem =
vertexData->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
Ogre::HardwareVertexBufferSharedPtr vbuf =
vertexData->vertexBufferBinding->getBuffer(posElem->getSource());
unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::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 compiled/typedefed as double:
float* pReal;
for( size_t j = 0; j < vertexData->vertexCount; ++j, vertex += vbuf->getVertexSize())
{
posElem->baseVertexPointerToElement(vertex, &pReal);
v3 pt(pReal[0], pReal[1], pReal[2]);
result.mVertices[currentOffset + j] = (orientation * (pt * scale)) + position;
}
vbuf->unlock();
nextOffset += vertexData->vertexCount;
}
Ogre::IndexData* index_data = subMesh->indexData;
size_t numTris = index_data->indexCount / 3;
Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
bool use32bitindexes = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
unsigned long* pLong = static_cast<unsigned long*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
unsigned short* pShort = reinterpret_cast<unsigned short*>(pLong);
size_t offset = (subMesh->useSharedVertices)? sharedOffset : currentOffset;
if (use32bitindexes)
{
for (size_t k = 0; k < numTris*3; ++k)
{
result.mIndices[indexOffset++] = pLong[k] + static_cast<unsigned long>(offset);
}
}
else
{
for (size_t k = 0; k < numTris*3; ++k)
{
result.mIndices[indexOffset++] = static_cast<unsigned long>(pShort[k]) + static_cast<unsigned long>(offset);
}
}
ibuf->unlock();
currentOffset = nextOffset;
}
return result;
}
//-----------------------------------------------------------------------
void MeshInfo::getMeshInformation( Ogre::MeshPtr mesh,
const Vector3 &position,
const Quaternion &orient,
const Vector3 &scale)
{
size_t vertexCount = 0;
size_t indexCount = 0;
Vector3* vertices = 0;
Vector3* normals;
unsigned long* indices = 0;
bool added_shared = false;
size_t current_offset = 0;
size_t shared_offset = 0;
size_t next_offset = 0;
size_t index_offset = 0;
// Calculate how many vertices and indices we're going to need
for ( unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* submesh = mesh->getSubMesh( i );
// We only need to add the shared vertices once
if(submesh->useSharedVertices)
{
if( !added_shared )
{
vertexCount += mesh->sharedVertexData->vertexCount;
added_shared = true;
}
}
else
{
vertexCount += submesh->vertexData->vertexCount;
}
// Add the indices
indexCount += submesh->indexData->indexCount;
}
// Allocate space for the vertices and indices
vertices = new Vector3[vertexCount];
normals = new Vector3[vertexCount];
indices = new unsigned long[indexCount];
added_shared = false;
// Run through the submeshes again, adding the data into the arrays
for ( unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* submesh = mesh->getSubMesh(i);
Ogre::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;
}
const Ogre::VertexElement* posElem = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
const Ogre::VertexElement* normalElem = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_NORMAL);
Ogre::HardwareVertexBufferSharedPtr vbuf = vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
float* pReal;
for( size_t j = 0; j < vertex_data->vertexCount; ++j, vertex += vbuf->getVertexSize())
{
posElem->baseVertexPointerToElement(vertex, &pReal);
Vector3 pt(pReal[0], pReal[1], pReal[2]);
vertices[current_offset + j] = (orient * (pt * scale)) + position;
normalElem->baseVertexPointerToElement(vertex, &pReal);
Vector3 nt(pReal[0], pReal[1], pReal[2]);
normals[current_offset + j] = nt;
}
vbuf->unlock();
next_offset += vertex_data->vertexCount;
}
Ogre::IndexData* index_data = submesh->indexData;
size_t numTris = index_data->indexCount / 3;
Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
bool use32bitindexes = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
unsigned long* pLong = static_cast<unsigned long*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
unsigned short* pShort = reinterpret_cast<unsigned short*>(pLong);
size_t offset = (submesh->useSharedVertices)? shared_offset : current_offset;
size_t numTrisMultThree = numTris*3;
if ( use32bitindexes )
{
for ( size_t k = 0; k < numTrisMultThree; ++k)
{
indices[index_offset++] = pLong[k] + static_cast<unsigned long>(offset);
}
}
else
{
for ( size_t k = 0; k < numTrisMultThree; ++k)
{
indices[index_offset++] = static_cast<unsigned long>(pShort[k]) + static_cast<unsigned long>(offset);
}
}
ibuf->unlock();
current_offset = next_offset;
}
// Create triangles from the retrieved data
for (size_t k = 0; k < indexCount-1; k+=3)
{
Triangle t;
t.v1 = vertices [indices[k]];
t.vn1 = normals [indices[k]];
t.v2 = vertices [indices[k+1]];
t.vn2 = normals [indices[k+1]];
t.v3 = vertices [indices[k+2]];
t.vn3 = normals [indices[k+2]];
t.calculateSquareSurface();
t.calculateSurfaceNormal();
t.calculateEdgeNormals();
_triangles.push_back(t);
}
// Delete intermediate arrays
delete [] indices;
delete [] normals;
delete [] vertices;
// Sort the triangle on their size, if needed (only if a gaussian random number generator
// function is used to perform a random lookup of a triangle)
if (mDistribution == MSD_HOMOGENEOUS)
sort(_triangles.begin(), _triangles.end(), SortDescending());
else
if (mDistribution == MSD_HETEROGENEOUS_1)
sort(_triangles.begin(), _triangles.end(), SortAscending());
}
void
PolyMousePicker::GetMeshInformation(
Ogre::Entity *entity,
size_t &vertex_count,
Ogre::Vector3* &vertices,
size_t &index_count,
Ogre::uint32* &indices,
const Ogre::Vector3 &position,
const Ogre::Quaternion &orient,
const Ogre::Vector3 &scale)
{
bool added_shared = false;
size_t current_offset = 0;
size_t shared_offset = 0;
size_t next_offset = 0;
size_t index_offset = 0;
vertex_count = index_count = 0;
Ogre::MeshPtr mesh = entity->getMesh();
bool useSoftwareBlendingVertices = entity->hasSkeleton();
if (useSoftwareBlendingVertices)
{
entity->_updateAnimation();
}
// Calculate how many vertices and indices we're going to need
for (unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::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 Ogre::Vector3[vertex_count];
indices = new Ogre::uint32[index_count];
added_shared = false;
// Run through the submeshes again, adding the data into the arrays
for ( unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* submesh = mesh->getSubMesh(i);
//----------------------------------------------------------------
// GET VERTEXDATA
//----------------------------------------------------------------
Ogre::VertexData* vertex_data;
//When there is animation:
if(useSoftwareBlendingVertices)
vertex_data = submesh->useSharedVertices ? entity->_getSkelAnimVertexData() : entity->getSubEntity(i)->_getSkelAnimVertexData();
else
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;
}
const Ogre::VertexElement* posElem =
vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
Ogre::HardwareVertexBufferSharedPtr vbuf =
vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
unsigned char* vertex =
static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::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( size_t j = 0; j < vertex_data->vertexCount; ++j, vertex += vbuf->getVertexSize())
{
posElem->baseVertexPointerToElement(vertex, &pReal);
Ogre::Vector3 pt(pReal[0], pReal[1], pReal[2]);
vertices[current_offset + j] = (orient * (pt * scale)) + position;
}
vbuf->unlock();
next_offset += vertex_data->vertexCount;
}
Ogre::IndexData* index_data = submesh->indexData;
size_t numTris = index_data->indexCount / 3;
Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
bool use32bitindexes = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
void* hwBuf = ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY);
size_t offset = (submesh->useSharedVertices)? shared_offset : current_offset;
size_t index_start = index_data->indexStart;
size_t last_index = numTris*3 + index_start;
if (use32bitindexes) {
Ogre::uint32* hwBuf32 = static_cast<Ogre::uint32*>(hwBuf);
for (size_t k = index_start; k < last_index; ++k)
{
indices[index_offset++] = hwBuf32[k] + static_cast<Ogre::uint32>( offset );
}
} else {
Ogre::uint16* hwBuf16 = static_cast<Ogre::uint16*>(hwBuf);
for (size_t k = index_start; k < last_index; ++k)
{
indices[ index_offset++ ] = static_cast<Ogre::uint32>( hwBuf16[k] ) +
static_cast<Ogre::uint32>( offset );
}
}
ibuf->unlock();
current_offset = next_offset;
}
}
Rocket::Core::CompiledGeometryHandle RocketInterface::CompileGeometry(
Rocket::Core::Vertex* vertices, int numVertices, int* indices, int numIndices,
Rocket::Core::TextureHandle texture)
{
RocketOgreGeometry* geometry = new RocketOgreGeometry();
geometry->texture = texture == 0 ? nullptr : reinterpret_cast<RocketOgreTexture*>(texture);
geometry->renderOp.vertexData = new Ogre::VertexData();
geometry->renderOp.vertexData->vertexStart = 0;
geometry->renderOp.vertexData->vertexCount = numVertices;
geometry->renderOp.indexData = new Ogre::IndexData();
geometry->renderOp.indexData->indexStart = 0;
geometry->renderOp.indexData->indexCount = numIndices;
geometry->renderOp.operationType = Ogre::RenderOperation::OT_TRIANGLE_LIST;
// Set up the vertex declaration
Ogre::VertexDeclaration* vertexDecl = geometry->renderOp.vertexData->vertexDeclaration;
size_t offset = 0;
vertexDecl->addElement(0, offset, Ogre::VET_FLOAT2, Ogre::VES_POSITION);
offset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT2);
vertexDecl->addElement(0, offset, Ogre::VET_COLOUR, Ogre::VES_DIFFUSE);
offset += Ogre::VertexElement::getTypeSize(Ogre::VET_COLOUR);
vertexDecl->addElement(0, offset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES);
// Create the vertex buffer
Ogre::HardwareVertexBufferSharedPtr vb =
Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(
vertexDecl->getVertexSize(0), numVertices, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY);
geometry->renderOp.vertexData->vertexBufferBinding->setBinding(0, vb);
// Fill the vertex buffer
RocketOgreVertex* vertexData = static_cast<RocketOgreVertex*>(
vb->lock(0, vb->getSizeInBytes(), Ogre::HardwareBuffer::HBL_NORMAL));
for (int i = 0; i < numVertices; ++i)
{
vertexData[i].position.x = vertices[i].position.x;
vertexData[i].position.y = vertices[i].position.y;
vertexData[i].uv.x = vertices[i].tex_coord[0];
vertexData[i].uv.y = vertices[i].tex_coord[1];
// Calculate colour value
Ogre::ColourValue diffuse(
vertices[i].colour.red / 255.0f, vertices[i].colour.green / 255.0f,
vertices[i].colour.blue / 255.0f, vertices[i].colour.alpha / 255.0f);
// Scale colour by gamma value (2.2)
diffuse.r = Pow(diffuse.r, 2.2f);
diffuse.g = Pow(diffuse.g, 2.2f);
diffuse.b = Pow(diffuse.b, 2.2f);
diffuse.a = Pow(diffuse.a, 2.2f);
mRenderSystem->convertColourValue(diffuse, &vertexData[i].colour);
}
vb->unlock();
// Create the index buffer
Ogre::HardwareIndexBufferSharedPtr ib =
Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(
Ogre::HardwareIndexBuffer::IT_32BIT, numIndices,
Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY);
geometry->renderOp.indexData->indexBuffer = ib;
geometry->renderOp.useIndexes = true;
// Fill the index buffer
void* indexData = ib->lock(0, ib->getSizeInBytes(), Ogre::HardwareBuffer::HBL_NORMAL);
memcpy(indexData, indices, sizeof(unsigned int) * numIndices);
ib->unlock();
return reinterpret_cast<Rocket::Core::CompiledGeometryHandle>(geometry);
}
bool Terrain::createTerrain()
{
if(mMainViewport == NULL)
mMainViewport = Core::getSingleton().mCamera->getViewport();
Ogre::CompositorManager::getSingleton().addCompositor(mMainViewport, "DemoCompositor");
Ogre::CompositorManager::getSingleton().setCompositorEnabled(mMainViewport, "DemoCompositor", true);
mMapData = MapDataManager::getSingletonPtr();
DataLibrary* datalib = DataLibrary::getSingletonPtr();
int terrainszie = mMapData->getMapSize() + 2 * MAPBOLDER + 1;
Core::getSingleton().mSceneMgr->setSkyBox(true, "SkyBox",200);
Ogre::GpuSharedParametersPtr sharedparams = Ogre::GpuProgramManager::getSingleton().getSharedParameters("TestSharedParamsName");
float border = mMapData->getMapSize() * 12.0f;
sharedparams->setNamedConstant("border", border);
//创建灯光
Core::getSingleton().mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f));
mLight = Core::getSingleton().mSceneMgr->createLight("TerrainLight");
mLight->setType(Ogre::Light::LT_DIRECTIONAL);
mLight->setPosition(-500.0f,500.0f, 500.0f);
mLight->setDirection(1.0f, -1.0f, -1.0f);
mLight->setDiffuseColour(Ogre::ColourValue(0.5f, 0.5f,0.5f));
mLight->setSpecularColour(Ogre::ColourValue(0.8f, 0.8f,0.8f));
//设置深度图投影
Ogre::TexturePtr tex = Ogre::TextureManager::getSingleton().getByName("shadowdepthmap");
if(tex.isNull())
tex = Ogre::TextureManager::getSingleton().createManual("shadowdepthmap",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 2048, 2048, 0, Ogre::PF_FLOAT16_R, Ogre::TU_RENDERTARGET);
mShadowDepthMapTarget = tex->getBuffer()->getRenderTarget();
Ogre::Viewport* vp = mShadowDepthMapTarget->addViewport(CameraContral::getSingleton().getShadowMapCamera());
vp->setSkiesEnabled(false);
vp->setOverlaysEnabled(false);
vp->setVisibilityMask(VISMASK_OPAQUE);
vp->setMaterialScheme("WriteDepthMap");
vp->setBackgroundColour(Ogre::ColourValue(1.0f,1.0f,1.0f));
mShadowDepthMapTarget->addListener(this);
//弱爆了……
Ogre::MaterialPtr mat;
mat = Ogre::MaterialManager::getSingleton().getByName("TerrainTile");
Ogre::AliasTextureNamePairList texAliasList;
std::string texname;
datalib->getData("GameData/BattleData/MapData/Ground/G0Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
datalib->getData("GameData/BattleData/MapData/Ground/G1Tex",texname);
texAliasList.insert(std::make_pair("Diffuse1",texname));
datalib->getData("GameData/BattleData/MapData/Ground/G2Tex",texname);
texAliasList.insert(std::make_pair("Diffuse2",texname));
datalib->getData("GameData/BattleData/MapData/Ground/G3Tex",texname);
texAliasList.insert(std::make_pair("Diffuse3",texname));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("CliffMat1");
datalib->getData("GameData/BattleData/MapData/Ground/G0Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("CliffMat2");
datalib->getData("GameData/BattleData/MapData/Ground/G1Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("CliffMat3");
datalib->getData("GameData/BattleData/MapData/Ground/G2Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("CliffMat4");
datalib->getData("GameData/BattleData/MapData/Ground/G3Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("BankMat1");
datalib->getData("GameData/BattleData/MapData/Ground/G0Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("BankMat2");
datalib->getData("GameData/BattleData/MapData/Ground/G1Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("BankMat3");
datalib->getData("GameData/BattleData/MapData/Ground/G2Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("BankMat4");
datalib->getData("GameData/BattleData/MapData/Ground/G3Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
//创建地面Mesh
mTerrainNode = Core::getSingleton().mSceneMgr->getRootSceneNode()->createChildSceneNode("TerrainNode");
int numVertices = terrainszie * terrainszie * VERTEX_QUAD;
int numIndex = terrainszie * terrainszie * VERTEX_PREQUAD;
Ogre::MeshPtr mTerrainMesh = Ogre::MeshManager::getSingleton().createManual("TerrianMesh",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::SubMesh* subMesh = mTerrainMesh->createSubMesh();
subMesh->useSharedVertices=false;
subMesh->setMaterialName("TerrainTile");
// 创建顶点数据结构
subMesh->vertexData = new Ogre::VertexData();
subMesh->vertexData->vertexStart = 0;
subMesh->vertexData->vertexCount = numVertices;
//顶点声明与缓冲区绑定
Ogre::VertexDeclaration* vdecl = subMesh->vertexData->vertexDeclaration;
Ogre::VertexBufferBinding* vbind = subMesh->vertexData->vertexBufferBinding;
//设置顶点数据结构
size_t offsetUV = 0;
vdecl->addElement(VERTEX_POS_BINDING, 0, Ogre::VET_FLOAT3,Ogre::VES_POSITION);//向顶点添加一个位置元素
vdecl->addElement(VERTEX_NOM_BINDING, 0, Ogre::VET_FLOAT3,Ogre::VES_NORMAL);
for(int i = 0 ; i < TEXTURE_COUNT ; i ++)
{
offsetUV += vdecl->addElement (VERTEX_UV_BINDING, offsetUV, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES , i).getSize();
}
// 创建世界坐标顶点缓冲区
Ogre::HardwareVertexBufferSharedPtr vbufPos =
Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(
vdecl->getVertexSize(VERTEX_POS_BINDING),
numVertices,
Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
vbind->setBinding(VERTEX_POS_BINDING, vbufPos);
Ogre::HardwareVertexBufferSharedPtr vbufNOM =
Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(
vdecl->getVertexSize(VERTEX_NOM_BINDING),
numVertices,
Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
vbind->setBinding(VERTEX_NOM_BINDING, vbufNOM);
// 创建纹理坐标顶点缓冲区
Ogre::HardwareVertexBufferSharedPtr vbufUV =
Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(
vdecl->getVertexSize(VERTEX_UV_BINDING),
numVertices,
Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
vbind->setBinding(VERTEX_UV_BINDING, vbufUV);
// 创建索引缓冲区
Ogre::HardwareIndexBufferSharedPtr indexBuffer =
Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(
Ogre::HardwareIndexBuffer::IT_16BIT ,
numIndex,
Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY);
//创建地形
float* pBufferPos = (float*)vbufPos->lock(Ogre::HardwareBuffer::HBL_DISCARD);
float* pBufferUV = (float*)vbufUV->lock(Ogre::HardwareBuffer::HBL_DISCARD);
float* pBufferNom = (float*)vbufNOM->lock(Ogre::HardwareBuffer::HBL_DISCARD);
float startpos = - terrainszie * TILESIZE / 2;
for(int y = 0 ; y < terrainszie; y ++)
{
for(int x = 0 ; x < terrainszie; x ++)
{
createTile(x, y, startpos + x * TILESIZE, startpos + y * TILESIZE, pBufferPos, pBufferUV, pBufferNom);
pBufferPos += 3 * VERTEX_QUAD ;
pBufferNom += 3 * VERTEX_QUAD ;
pBufferUV += 2 * VERTEX_QUAD * 4;
}
}
vbufNOM->unlock();
vbufUV->unlock();
vbufPos->unlock();
//写入索引信息
// 锁定索引缓冲区
Ogre::ushort* pIdx = (Ogre::ushort*)indexBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
for(int y = 0 ; y < terrainszie ; y ++)
{
for(int x = 0 ; x < terrainszie ; x ++)
{
Ogre::ushort iIndexTopLeft = (x + y * terrainszie) * VERTEX_QUAD;
Ogre::ushort iIndexTopRight = iIndexTopLeft + 1;
Ogre::ushort iIndexBottomLeft = iIndexTopLeft + 2;
Ogre::ushort iIndexBottomRight = iIndexTopLeft + 3;
*pIdx++ = iIndexBottomLeft;
*pIdx++ = iIndexBottomRight;
*pIdx++ = iIndexTopLeft;
*pIdx++ = iIndexBottomRight;
*pIdx++ = iIndexTopRight;
*pIdx++ = iIndexTopLeft;
}
}
indexBuffer->unlock();
//设置模型的的索引数据
subMesh->indexData->indexBuffer = indexBuffer;
subMesh->indexData->indexStart = 0;
subMesh->indexData->indexCount =numIndex;
Ogre::AxisAlignedBox meshBounds(startpos,0,startpos,
-startpos,5,-startpos);
mTerrainMesh->_setBounds(meshBounds);
mTerrainEntity = Core::getSingleton().mSceneMgr->createEntity("TerrianMesh");
mTerrainNode->attachObject(mTerrainEntity);
mTerrainEntity->setQueryFlags(QUERYMASK_TERRAIN);
mTerrainNode->setPosition(0,0,0);
//创建水面
tex = Ogre::TextureManager::getSingleton().getByName("reflection");
if(tex.isNull())
tex = Ogre::TextureManager::getSingleton().createManual("reflection",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 512, 512, 0, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET);
mReflectionTarget = tex->getBuffer()->getRenderTarget();
mReflectionTarget->addViewport(Core::getSingleton().mCamera)->setOverlaysEnabled(false);
mReflectionTarget->addListener(this);
// mat = Ogre::MaterialManager::getSingleton().getByName("ReflectionWater");
// tech = mat->getTechnique(0);
// pass = tech->getPass(0);
// tu = pass->getTextureUnitState(1);
// tu->setTextureName(tex->getName());
mWaterPlane = Ogre::Plane(Ogre::Vector3::UNIT_Y, WATERHEIGHT);
mWaterNode = Core::getSingleton().mSceneMgr->getRootSceneNode()->createChildSceneNode("WaterNode");
mWaterObject = Core::getSingleton().mSceneMgr->createManualObject("WaterObject");
mWaterObject->begin("DemoWater",Ogre::RenderOperation::OT_TRIANGLE_LIST);
startpos += TILESIZE/2;
for(int y = 0; y < terrainszie; y++)
for(int x = 0; x < terrainszie; x++)
{
if(mMapData->getTerrainType(x -MAPBOLDER, y -MAPBOLDER ) == Water)
{
mWaterObject->position(startpos + x * TILESIZE, 0.0f, startpos + y * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(0.0f,0.0f);
mWaterObject->position(startpos + (x+1) * TILESIZE, 0.0f, startpos + (y+1) * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(1.0f,1.0f);
mWaterObject->position(startpos + (x+1) * TILESIZE, 0.0f, startpos + y * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(1.0f,0.0f);
mWaterObject->position(startpos + (x+1) * TILESIZE, 0.0f, startpos + (y+1) * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(1.0f,1.0f);
mWaterObject->position(startpos + x * TILESIZE, 0.0f, startpos + y * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(0.0f,0.0f);
mWaterObject->position(startpos + x * TILESIZE, 0.0f, startpos + (y+1) * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(0.0f,1.0f);
}
}
mWaterObject->end();
mWaterNode->attachObject(mWaterObject);
mWaterNode->setPosition(0,WATERHEIGHT,0);
//设置摄像机移动范围
float minx = 0.0f;// = ( - (float)(terrainszie - 2 * MAPBOLDER) / 2.0f - 1.0f) * TILESIZE ;
getWorldCoords(0,0,minx,minx);
minx -= TILESIZE/2;
CameraContral::getSingleton().setMoveRect(minx, minx);
CameraContral::getSingleton().resetCamera();
//深度投影测试
// Ogre::MeshManager::getSingleton().createPlane("testplane", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
// mWaterPlane, 64, 64, 1, 1, true, 1, 1, 1, Ogre::Vector3::UNIT_Z);
// Ogre::Entity* testent = Core::getSingleton().mSceneMgr->createEntity("testplaneent", "testplane");
// testent->setMaterialName("DepthTest");
// Ogre::SceneNode* testnode = Core::getSingleton().mSceneMgr->getRootSceneNode()->createChildSceneNode();
// testnode->attachObject(testent);
// testnode->setPosition(0.0f,10.0f,0.0f);
return true;
}