//-----------------------------------------------------------------------------
MeshPtr ManualObject::convertToMesh(const String& meshName, const String& groupName)
{
if (mCurrentSection)
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"You cannot call convertToMesh() whilst you are in the middle of "
"defining the object; call end() first.",
"ManualObject::convertToMesh");
}
if (mSectionList.empty())
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"No data defined to convert to a mesh.",
"ManualObject::convertToMesh");
}
MeshPtr m = MeshManager::getSingleton().createManual(meshName, groupName);
for (SectionList::iterator i = mSectionList.begin(); i != mSectionList.end(); ++i)
{
ManualObjectSection* sec = *i;
RenderOperation* rop = sec->getRenderOperation();
SubMesh* sm = m->createSubMesh();
sm->useSharedVertices = false;
sm->operationType = rop->operationType;
sm->setMaterialName(sec->getMaterialName(), groupName);
// Copy vertex data; replicate buffers too
sm->vertexData = rop->vertexData->clone(true);
// Copy index data; replicate buffers too; delete the default, old one to avoid memory leaks
// check if index data is present
if (rop->indexData)
{
// Copy index data; replicate buffers too; delete the default, old one to avoid memory leaks
OGRE_DELETE sm->indexData;
sm->indexData = rop->indexData->clone(true);
}
}
// update bounds
m->_setBounds(mAABB);
m->_setBoundingSphereRadius(mRadius);
m->load();
return m;
}
/* *******************************************************************************
| implement of CGrassSticks
******************************************************************************* */
void
CGrassSticks::createGrassMesh()
{
MeshPtr mesh = MeshManager::getSingleton().createManual(GRASS_MESH_NAME, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
// create a submesh with the grass material
SubMesh* sm = mesh->createSubMesh();
sm->setMaterialName("Examples/GrassBlades");
sm->useSharedVertices = false;
sm->vertexData = OGRE_NEW VertexData();
sm->vertexData->vertexStart = 0;
sm->vertexData->vertexCount = 12;
sm->indexData->indexCount = 18;
// specify a vertex format declaration for our mesh: 3 floats for position, 3 floats for normal, 2 floats for UV
VertexDeclaration* decl = sm->vertexData->vertexDeclaration;
decl->addElement(0, 0, VET_FLOAT3, VES_POSITION);
decl->addElement(0, sizeof(float) * 3, VET_FLOAT3, VES_NORMAL);
decl->addElement(0, sizeof(float) * 6, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0);
// create a vertex buffer
HardwareVertexBufferSharedPtr vb = HardwareBufferManager::getSingleton().createVertexBuffer
(decl->getVertexSize(0), sm->vertexData->vertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
GrassVertex* verts = (GrassVertex*)vb->lock(HardwareBuffer::HBL_DISCARD); // start filling in vertex data
for (unsigned int i = 0; i < 3; i++) // each grass mesh consists of 3 planes
{
// planes intersect along the Y axis with 60 degrees between them
Real x = Math::Cos(Degree(i * 60)) * GRASS_WIDTH / 2;
Real z = Math::Sin(Degree(i * 60)) * GRASS_WIDTH / 2;
for (unsigned int j = 0; j < 4; j++) // each plane has 4 vertices
{
GrassVertex& vert = verts[i * 4 + j];
vert.x = j < 2 ? -x : x;
vert.y = j % 2 ? 0 : GRASS_HEIGHT;
vert.z = j < 2 ? -z : z;
// all normals point straight up
vert.nx = 0;
vert.ny = 1;
vert.nz = 0;
vert.u = j < 2 ? 0 : 1;
vert.v = j % 2;
}
}
vb->unlock(); // commit vertex changes
sm->vertexData->vertexBufferBinding->setBinding(0, vb); // bind vertex buffer to our submesh
// create an index buffer
sm->indexData->indexBuffer = HardwareBufferManager::getSingleton().createIndexBuffer
(HardwareIndexBuffer::IT_16BIT, sm->indexData->indexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
// start filling in index data
Ogre::uint16* indices = (Ogre::uint16*)sm->indexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD);
for (unsigned int i = 0; i < 3; i++) // each grass mesh consists of 3 planes
{
unsigned int off = i * 4; // each plane consists of 2 triangles
*indices++ = 0 + off;
*indices++ = 3 + off;
*indices++ = 1 + off;
*indices++ = 0 + off;
*indices++ = 2 + off;
*indices++ = 3 + off;
}
sm->indexData->indexBuffer->unlock(); // commit index changes
// update mesh AABB
Ogre::AxisAlignedBox aabb;
aabb.setExtents(-1,-1,-1,1,1,1);
mesh->_setBounds(aabb);
// Ogre::MeshSerializer serial;
// serial.exportMesh(mesh.getPointer(), "grass.mesh");
}
Mesh *GrassLoader::generateGrass_SPRITE(PageInfo &page, GrassLayer *layer, float *grassPositions, unsigned int grassCount)
{
//Calculate the number of quads to be added
unsigned int quadCount;
quadCount = grassCount;
// check for overflows of the uint16's
unsigned int maxUInt16 = std::numeric_limits<uint16>::max();
if(grassCount > maxUInt16)
{
LogManager::getSingleton().logMessage("grass count overflow: you tried to use more than " + StringConverter::toString(maxUInt16) + " (thats the maximum) grass meshes for one page");
return 0;
}
if(quadCount > maxUInt16)
{
LogManager::getSingleton().logMessage("quad count overflow: you tried to use more than " + StringConverter::toString(maxUInt16) + " (thats the maximum) grass meshes for one page");
return 0;
}
//Create manual mesh to store grass quads
MeshPtr mesh = MeshManager::getSingleton().createManual(getUniqueID(), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
SubMesh *subMesh = mesh->createSubMesh();
subMesh->useSharedVertices = false;
//Setup vertex format information
subMesh->vertexData = new VertexData;
subMesh->vertexData->vertexStart = 0;
subMesh->vertexData->vertexCount = 4 * quadCount;
VertexDeclaration* dcl = subMesh->vertexData->vertexDeclaration;
size_t offset = 0;
dcl->addElement(0, offset, VET_FLOAT3, VES_POSITION);
offset += VertexElement::getTypeSize(VET_FLOAT3);
dcl->addElement(0, offset, VET_FLOAT4, VES_NORMAL);
offset += VertexElement::getTypeSize(VET_FLOAT4);
dcl->addElement(0, offset, VET_COLOUR, VES_DIFFUSE);
offset += VertexElement::getTypeSize(VET_COLOUR);
dcl->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES);
offset += VertexElement::getTypeSize(VET_FLOAT2);
//Populate a new vertex buffer with grass
HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton()
.createVertexBuffer(offset, subMesh->vertexData->vertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
float* pReal = static_cast<float*>(vbuf->lock(HardwareBuffer::HBL_DISCARD));
//Calculate size variance
float rndWidth = layer->maxWidth - layer->minWidth;
float rndHeight = layer->maxHeight - layer->minHeight;
float minY = Math::POS_INFINITY, maxY = Math::NEG_INFINITY;
float *posPtr = grassPositions; //Position array "iterator"
for (uint16 i = 0; i < grassCount; ++i)
{
//Get the x and z positions from the position array
float x = *posPtr++;
float z = *posPtr++;
//Calculate height
float y;
if (heightFunction){
y = heightFunction(x, z, heightFunctionUserData);
} else {
y = 0;
}
float x1 = (x - page.centerPoint.x);
float z1 = (z - page.centerPoint.z);
//Get the color at the grass position
uint32 color;
if (layer->colorMap)
color = layer->colorMap->getColorAt(x, z, layer->mapBounds);
else
color = 0xFFFFFFFF;
//Calculate size
float rnd = *posPtr++; //The same rnd value is used for width and height to maintain aspect ratio
float halfXScale = (layer->minWidth + rndWidth * rnd) * 0.5f;
float scaleY = (layer->minHeight + rndHeight * rnd);
//Randomly mirror grass textures
float uvLeft, uvRight;
if (*posPtr++ > 0.5f){
uvLeft = 0;
uvRight = 1;
} else {
uvLeft = 1;
uvRight = 0;
}
//Add vertices
*pReal++ = x1; *pReal++ = y; *pReal++ = z1; //center position
*pReal++ = -halfXScale; *pReal++ = scaleY; *pReal++ = 0; *pReal++ = 0; //normal (used to store relative corner positions)
*((uint32*)pReal++) = color; //color
*pReal++ = uvLeft; *pReal++ = 0; //uv
*pReal++ = x1; *pReal++ = y; *pReal++ = z1; //center position
*pReal++ = +halfXScale; *pReal++ = scaleY; *pReal++ = 0; *pReal++ = 0; //normal (used to store relative corner positions)
*((uint32*)pReal++) = color; //color
*pReal++ = uvRight; *pReal++ = 0; //uv
*pReal++ = x1; *pReal++ = y; *pReal++ = z1; //center position
*pReal++ = -halfXScale; *pReal++ = 0.0f; *pReal++ = 0; *pReal++ = 0; //normal (used to store relative corner positions)
*((uint32*)pReal++) = color; //color
*pReal++ = uvLeft; *pReal++ = 1; //uv
*pReal++ = x1; *pReal++ = y; *pReal++ = z1; //center position
*pReal++ = +halfXScale; *pReal++ = 0.0f; *pReal++ = 0; *pReal++ = 0; //normal (used to store relative corner positions)
*((uint32*)pReal++) = color; //color
*pReal++ = uvRight; *pReal++ = 1; //uv
//Update bounds
if (y < minY) minY = y;
if (y + scaleY > maxY) maxY = y + scaleY;
}
vbuf->unlock();
subMesh->vertexData->vertexBufferBinding->setBinding(0, vbuf);
//Populate index buffer
subMesh->indexData->indexStart = 0;
subMesh->indexData->indexCount = 6 * quadCount;
subMesh->indexData->indexBuffer = HardwareBufferManager::getSingleton()
.createIndexBuffer(HardwareIndexBuffer::IT_16BIT, subMesh->indexData->indexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
uint16* pI = static_cast<uint16*>(subMesh->indexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD));
for (uint16 i = 0; i < quadCount; ++i)
{
uint16 offset = i * 4;
*pI++ = 0 + offset;
*pI++ = 2 + offset;
*pI++ = 1 + offset;
*pI++ = 1 + offset;
*pI++ = 2 + offset;
*pI++ = 3 + offset;
}
subMesh->indexData->indexBuffer->unlock();
//subMesh->setBuildEdgesEnabled(autoEdgeBuildEnabled);
//Finish up mesh
AxisAlignedBox bounds(page.bounds.left - page.centerPoint.x, minY, page.bounds.top - page.centerPoint.z,
page.bounds.right - page.centerPoint.x, maxY, page.bounds.bottom - page.centerPoint.z);
mesh->_setBounds(bounds);
Vector3 temp = bounds.getMaximum() - bounds.getMinimum();
mesh->_setBoundingSphereRadius(temp.length() * 0.5f);
LogManager::getSingleton().setLogDetail(static_cast<LoggingLevel>(0));
mesh->setAutoBuildEdgeLists(autoEdgeBuildEnabled);
mesh->load();
LogManager::getSingleton().setLogDetail(LL_NORMAL);
//Apply grass material to mesh
subMesh->setMaterialName(layer->material->getName());
//Return the mesh
return mesh.getPointer();
}
void MeshBuilder::end()
{
assert(!m_bIsSharedVertices && !m_currentSubMesh.strName.empty() && "You must call begin() before you call end()");
assert(!m_currentSubMesh.bUseSharedVertices || m_mesh->sharedVertexData);
// Declarations
std::map<unsigned short, std::vector<tElement> >::iterator iterSource, iterSourceEnd;
std::vector<tVertex>::iterator iterVertex, iterVertexEnd;
HardwareVertexBufferSharedPtr vbuffer;
VertexData* pVertexData;
// If a temporary vertex is pending, add it to the list
if (m_bTempVertexPending)
copyTempVertexToBuffer();
m_bFirstVertex = false;
m_bAutomaticDeclaration = false;
m_bIsSharedVertices = false;
// Create the submesh
SubMesh* pSubMesh = m_mesh->createSubMesh(m_currentSubMesh.strName);
pSubMesh->setMaterialName(m_currentSubMesh.strMaterial);
pSubMesh->useSharedVertices = m_currentSubMesh.bUseSharedVertices;
pSubMesh->operationType = m_currentSubMesh.opType;
// Initializes the vertex declaration if necessary
if (!m_currentSubMesh.bUseSharedVertices)
{
pSubMesh->vertexData = createVertexData();
pVertexData = pSubMesh->vertexData;
}
else
{
pVertexData = m_mesh->sharedVertexData;
}
// Add the vertices into their buffers
VertexBufferBinding::VertexBufferBindingMap bindings = pVertexData->vertexBufferBinding->getBindings();
for (iterSource = m_currentSubMesh.verticesElements.begin(), iterSourceEnd = m_currentSubMesh.verticesElements.end();
iterSource != iterSourceEnd; ++iterSource)
{
unsigned int vertexIndex = 0;
for (iterVertex = m_currentSubMesh.vertices.begin(), iterVertexEnd = m_currentSubMesh.vertices.end();
iterVertex != iterVertexEnd; ++iterVertex)
{
if ((iterVertex->blendingDim > 0) && !m_mesh->getSkeletonName().empty())
{
VertexBoneAssignment ass;
ass.vertexIndex = vertexIndex;
for (unsigned int i = 0; i < iterVertex->blendingDim; ++i)
{
ass.boneIndex = iterVertex->blendingIndices[i];
ass.weight = iterVertex->blendingWeights[i];
pSubMesh->addBoneAssignment(ass);
}
}
++vertexIndex;
}
}
// Add the indices into their buffer
pSubMesh->indexData->indexCount = m_currentSubMesh.indices.size();
pSubMesh->indexData->indexBuffer = HardwareBufferManager::getSingleton().createIndexBuffer(
HardwareIndexBuffer::IT_16BIT, m_currentSubMesh.indices.size(),
m_currentSubMesh.indexBufferInfo.usage,
m_currentSubMesh.indexBufferInfo.bUseShadowBuffer);
pSubMesh->indexData->indexBuffer->writeData(0, m_currentSubMesh.indices.size() * sizeof(unsigned short),
&m_currentSubMesh.indices[0]);
// Update the AABB and the radius of the mesh
m_mesh->_setBounds(toOgre(m_AABB));
m_mesh->_setBoundingSphereRadius(m_radius);
// Reset the internal state
m_currentSubMesh.strName = "";
m_currentSubMesh.strMaterial = "";
m_currentSubMesh.bUseSharedVertices = false;
m_currentSubMesh.indexBufferInfo.usage = HardwareBuffer::HBU_STATIC_WRITE_ONLY;
m_currentSubMesh.indexBufferInfo.bUseShadowBuffer = false;
m_currentSubMesh.verticesElements.clear();
m_currentSubMesh.vertexBufferInfos.clear();
m_currentSubMesh.vertices.clear();
m_currentSubMesh.indices.clear();
}
MeshPtr MeshMergeTool::merge(const Ogre::String& name, const Ogre::String& resourceGroupName)
{
print("Baking: New Mesh started", V_HIGH);
MeshPtr mp = MeshManager::getSingleton().createManual(name, resourceGroupName);
if (!mBaseSkeleton.isNull())
{
mp->setSkeletonName(mBaseSkeleton->getName());
}
AxisAlignedBox totalBounds = AxisAlignedBox();
for (std::vector<Ogre::MeshPtr>::iterator it = mMeshes.begin(); it != mMeshes.end(); ++it)
{
print("Baking: adding submeshes for " + (*it)->getName(), V_HIGH);
// insert all submeshes
for (Ogre::ushort sid = 0; sid < (*it)->getNumSubMeshes(); ++sid)
{
SubMesh* sub = (*it)->getSubMesh(sid);
const String name = findSubmeshName((*it), sid);
// create submesh with correct name
SubMesh* newsub;
if (name.length() == 0)
{
newsub = mp->createSubMesh();
}
else
{
/// @todo check if a submesh with this name has been created before
newsub = mp->createSubMesh(name);
}
newsub->useSharedVertices = sub->useSharedVertices;
// add index
newsub->indexData = sub->indexData->clone();
// add geometry
if (!newsub->useSharedVertices)
{
newsub->vertexData = sub->vertexData->clone();
if (!mBaseSkeleton.isNull())
{
// build bone assignments
SubMesh::BoneAssignmentIterator bit = sub->getBoneAssignmentIterator();
while (bit.hasMoreElements())
{
VertexBoneAssignment vba = bit.getNext();
newsub->addBoneAssignment(vba);
}
}
}
newsub->setMaterialName(sub->getMaterialName());
// Add vertex animations for this submesh
Animation *anim = 0;
for (unsigned short i = 0; i < (*it)->getNumAnimations(); ++i)
{
anim = (*it)->getAnimation(i);
// get or create the animation for the new mesh
Animation *newanim;
if (mp->hasAnimation(anim->getName()))
{
newanim = mp->getAnimation(anim->getName());
}
else
{
newanim = mp->createAnimation(anim->getName(), anim->getLength());
}
print("Baking: adding vertex animation "
+ anim->getName() + " for " + (*it)->getName(), V_HIGH);
Animation::VertexTrackIterator vti=anim->getVertexTrackIterator();
while (vti.hasMoreElements())
{
VertexAnimationTrack *vt = vti.getNext();
// handle=0 targets the main mesh, handle i (where i>0) targets submesh i-1.
// In this case there are only submeshes so index 0 will not be used.
unsigned short handle = mp->getNumSubMeshes();
VertexAnimationTrack* newvt = newanim->createVertexTrack(
handle,
vt->getAssociatedVertexData()->clone(),
vt->getAnimationType());
for (int keyFrameIndex = 0; keyFrameIndex < vt->getNumKeyFrames();
++keyFrameIndex)
{
switch (vt->getAnimationType())
{
case VAT_MORPH:
{
// copy the keyframe vertex buffer
VertexMorphKeyFrame *kf =
vt->getVertexMorphKeyFrame(keyFrameIndex);
VertexMorphKeyFrame *newkf =
newvt->createVertexMorphKeyFrame(kf->getTime());
// This creates a ref to the buffer in the original model
// so don't delete it until the export is completed.
newkf->setVertexBuffer(kf->getVertexBuffer());
break;
}
case VAT_POSE:
{
/// @todo implement pose amination merge
break;
}
case VAT_NONE:
default:
{
break;
}
}
}
}
}
print("Baking: adding submesh '" +
name + "' with material " + sub->getMaterialName(), V_HIGH);
}
// sharedvertices
if ((*it)->sharedVertexData)
{
/// @todo merge with existing sharedVertexData
if (!mp->sharedVertexData)
{
mp->sharedVertexData = (*it)->sharedVertexData->clone();
}
if (!mBaseSkeleton.isNull())
{
Mesh::BoneAssignmentIterator bit = (*it)->getBoneAssignmentIterator();
while (bit.hasMoreElements())
{
VertexBoneAssignment vba = bit.getNext();
mp->addBoneAssignment(vba);
}
}
}
print("Baking: adding bounds for " + (*it)->getName(), V_HIGH);
// add bounds
totalBounds.merge((*it)->getBounds());
}
mp->_setBounds(totalBounds);
/// @todo merge submeshes with same material
/// @todo add parameters
mp->buildEdgeList();
print("Baking: Finished", V_HIGH);
reset();
return mp;
}
Airbrake::Airbrake(char* basename, int num, node_t *ndref, node_t *ndx, node_t *ndy, node_t *nda, Vector3 pos, float width, float length, float maxang, char* texname, float tx1, float ty1, float tx2, float ty2, float lift_coef)
{
snode=0;
noderef=ndref;
nodex=ndx;
nodey=ndy;
nodea=nda;
offset=pos;
maxangle=maxang;
area=width*length*lift_coef;
char meshname[256];
sprintf(meshname, "airbrakemesh-%s-%i", basename, num);
/// Create the mesh via the MeshManager
msh = MeshManager::getSingleton().createManual(meshname, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
union
{
float *vertices;
CoVertice_t *covertices;
};
/// Create submesh
SubMesh* sub = msh->createSubMesh();
//materials
sub->setMaterialName(texname);
/// Define the vertices
size_t nVertices = 4;
size_t vbufCount = (2*3+2)*nVertices;
vertices=(float*)malloc(vbufCount*sizeof(float));
//textures coordinates
covertices[0].texcoord=Vector2(tx1, ty1);
covertices[1].texcoord=Vector2(tx2, ty1);
covertices[2].texcoord=Vector2(tx2, ty2);
covertices[3].texcoord=Vector2(tx1, ty2);
/// Define triangles
/// The values in this table refer to vertices in the above table
size_t ibufCount = 3*4;
unsigned short *faces=(unsigned short*)malloc(ibufCount*sizeof(unsigned short));
faces[0]=0; faces[1]=1; faces[2]=2;
faces[3]=0; faces[4]=2; faces[5]=3;
faces[6]=0; faces[7]=2; faces[8]=1;
faces[9]=0; faces[10]=3; faces[11]=2;
//set coords
covertices[0].vertex=Vector3(0,0,0);
covertices[1].vertex=Vector3(width,0,0);
covertices[2].vertex=Vector3(width,0,length);
covertices[3].vertex=Vector3(0,0,length);
covertices[0].normal=Vector3(0,1,0);
covertices[1].normal=Vector3(0,1,0);
covertices[2].normal=Vector3(0,1,0);
covertices[3].normal=Vector3(0,1,0);
/// Create vertex data structure for vertices shared between submeshes
msh->sharedVertexData = new VertexData();
msh->sharedVertexData->vertexCount = nVertices;
/// Create declaration (memory format) of vertex data
VertexDeclaration* decl = msh->sharedVertexData->vertexDeclaration;
size_t offset = 0;
decl->addElement(0, offset, VET_FLOAT3, VES_POSITION);
offset += VertexElement::getTypeSize(VET_FLOAT3);
decl->addElement(0, offset, VET_FLOAT3, VES_NORMAL);
offset += VertexElement::getTypeSize(VET_FLOAT3);
// decl->addElement(0, offset, VET_FLOAT3, VES_DIFFUSE);
// offset += VertexElement::getTypeSize(VET_FLOAT3);
decl->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0);
offset += VertexElement::getTypeSize(VET_FLOAT2);
/// Allocate vertex buffer of the requested number of vertices (vertexCount)
/// and bytes per vertex (offset)
HardwareVertexBufferSharedPtr vbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
offset, msh->sharedVertexData->vertexCount, HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
/// Upload the vertex data to the card
vbuf->writeData(0, vbuf->getSizeInBytes(), vertices, true);
/// Set vertex buffer binding so buffer 0 is bound to our vertex buffer
VertexBufferBinding* bind = msh->sharedVertexData->vertexBufferBinding;
bind->setBinding(0, vbuf);
/// Allocate index buffer of the requested number of vertices (ibufCount)
HardwareIndexBufferSharedPtr faceibuf = HardwareBufferManager::getSingleton().
createIndexBuffer(
HardwareIndexBuffer::IT_16BIT,
ibufCount,
HardwareBuffer::HBU_STATIC_WRITE_ONLY);
/// Upload the index data to the card
faceibuf->writeData(0, faceibuf->getSizeInBytes(), faces, true);
/// Set parameters of the submesh
sub->useSharedVertices = true;
sub->indexData->indexBuffer = faceibuf;
sub->indexData->indexCount = ibufCount;
sub->indexData->indexStart = 0;
/// Set bounding information (for culling)
msh->_setBounds(AxisAlignedBox(-1,-1,0,1,1,0), true);
//msh->_setBoundingSphereRadius(Math::Sqrt(1*1+1*1));
/// Notify Mesh object that it has been loaded
msh->load();
// create the entity and scene node
char entname[256];
sprintf(entname, "airbrakenode-%s-%i", basename, num);
ec = gEnv->sceneManager->createEntity(entname, meshname);
snode = gEnv->sceneManager->getRootSceneNode()->createChildSceneNode();
snode->attachObject(ec);
updatePosition(0.0);
free (vertices);
free (faces);
}
MeshPtr MergeMesh::bake()
{
log(
"Baking: New Mesh started" );
MeshPtr mp = MeshManager::getSingleton().
createManual( "mergedMesh", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
mp->setSkeletonName( m_BaseSkeleton->getName() );
AxisAlignedBox totalBounds = AxisAlignedBox();
for( std::vector< Ogre::MeshPtr >::iterator it = m_Meshes.begin();
it != m_Meshes.end(); ++it )
{
log(
"Baking: adding submeshes for " + (*it)->getName() );
// insert all submeshes
for( Ogre::ushort sid = 0; sid < (*it)->getNumSubMeshes(); ++sid )
{
SubMesh* sub = (*it)->getSubMesh( sid );
const String name = findSubmeshName( (*it), sid );
// create submesh with correct name
SubMesh* newsub;
if( name.length() == 0 )
newsub = mp->createSubMesh( );
else
/// @todo check if a submesh with this name has been created before
newsub = mp->createSubMesh( name );
newsub->useSharedVertices = sub->useSharedVertices;
// add index
newsub->indexData = sub->indexData->clone();
// add geometry
if( !newsub->useSharedVertices )
{
newsub->vertexData = sub->vertexData->clone();
// build bone assignments
SubMesh::BoneAssignmentIterator bit = sub->getBoneAssignmentIterator();
while (bit.hasMoreElements())
{
VertexBoneAssignment vba = bit.getNext();
newsub->addBoneAssignment(vba);
}
}
newsub->setMaterialName( sub->getMaterialName() );
log("Baking: adding submesh '" + name + "' with material " + sub->getMaterialName());
}
// sharedvertices
if ((*it)->sharedVertexData)
{
/// @todo merge with existing sharedVertexData
if (!mp->sharedVertexData)
{
mp->sharedVertexData = (*it)->sharedVertexData->clone();
}
Mesh::BoneAssignmentIterator bit = (*it)->getBoneAssignmentIterator();
while (bit.hasMoreElements())
{
VertexBoneAssignment vba = bit.getNext();
mp->addBoneAssignment(vba);
}
}
log("Baking: adding bounds for " + (*it)->getName());
// add bounds
totalBounds.merge((*it)->getBounds());
}
mp->_setBounds( totalBounds );
/// @todo merge submeshes with same material
/// @todo add parameters
mp->buildEdgeList();
log(
"Baking: Finished" );
return mp;
}
Ogre::MeshPtr LodOutsideMarker::createConvexHullMesh(const String& meshName, const String& resourceGroupName)
{
// Based on the wiki sample: http://www.ogre3d.org/tikiwiki/tiki-index.php?page=Generating+A+Mesh
// Resource with given name should not exist!
assert(MeshManager::getSingleton().getByName(meshName).isNull());
generateHull(); // calculate mHull triangles.
// Convex hull can't be empty!
assert(!mHull.empty());
MeshPtr mesh = MeshManager::getSingleton().createManual(meshName, resourceGroupName, NULL);
SubMesh* subMesh = mesh->createSubMesh();
vector<Real>::type vertexBuffer;
vector<unsigned short>::type indexBuffer;
// 3 position/triangle * 3 Real/position
vertexBuffer.reserve(mHull.size() * 9);
// 3 index / triangle
indexBuffer.reserve(mHull.size() * 3);
int id=0;
// min & max position
Vector3 minBounds(std::numeric_limits<Real>::max(), std::numeric_limits<Real>::max(), std::numeric_limits<Real>::max());
Vector3 maxBounds(std::numeric_limits<Real>::min(), std::numeric_limits<Real>::min(), std::numeric_limits<Real>::min());
for (size_t i = 0; i < mHull.size(); i++) {
assert(!mHull[i].removed);
for(size_t n = 0; n < 3; n++){
indexBuffer.push_back(id++);
vertexBuffer.push_back(mHull[i].vertex[n]->position.x);
vertexBuffer.push_back(mHull[i].vertex[n]->position.y);
vertexBuffer.push_back(mHull[i].vertex[n]->position.z);
minBounds.x = std::min<Real>(minBounds.x, mHull[i].vertex[n]->position.x);
minBounds.y = std::min<Real>(minBounds.y, mHull[i].vertex[n]->position.y);
minBounds.z = std::min<Real>(minBounds.z, mHull[i].vertex[n]->position.z);
maxBounds.x = std::max<Real>(maxBounds.x, mHull[i].vertex[n]->position.x);
maxBounds.y = std::max<Real>(maxBounds.y, mHull[i].vertex[n]->position.y);
maxBounds.z = std::max<Real>(maxBounds.z, mHull[i].vertex[n]->position.z);
}
}
/// Create vertex data structure for 8 vertices shared between submeshes
mesh->sharedVertexData = new VertexData();
mesh->sharedVertexData->vertexCount = mHull.size() * 3;
/// Create declaration (memory format) of vertex data
VertexDeclaration* decl = mesh->sharedVertexData->vertexDeclaration;
size_t offset = 0;
// 1st buffer
decl->addElement(0, offset, VET_FLOAT3, VES_POSITION);
offset += VertexElement::getTypeSize(VET_FLOAT3);
/// Allocate vertex buffer of the requested number of vertices (vertexCount)
/// and bytes per vertex (offset)
HardwareVertexBufferSharedPtr vbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
offset, mesh->sharedVertexData->vertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
/// Upload the vertex data to the card
vbuf->writeData(0, vbuf->getSizeInBytes(), &vertexBuffer[0], true);
/// Set vertex buffer binding so buffer 0 is bound to our vertex buffer
VertexBufferBinding* bind = mesh->sharedVertexData->vertexBufferBinding;
bind->setBinding(0, vbuf);
/// Allocate index buffer of the requested number of vertices (ibufCount)
HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager::getSingleton().
createIndexBuffer(
HardwareIndexBuffer::IT_16BIT,
indexBuffer.size(),
HardwareBuffer::HBU_STATIC_WRITE_ONLY);
/// Upload the index data to the card
ibuf->writeData(0, ibuf->getSizeInBytes(), &indexBuffer[0], true);
/// Set parameters of the submesh
subMesh->useSharedVertices = true;
subMesh->indexData->indexBuffer = ibuf;
subMesh->indexData->indexCount = indexBuffer.size();
subMesh->indexData->indexStart = 0;
/// Set bounding information (for culling)
mesh->_setBounds(AxisAlignedBox(minBounds, maxBounds));
mesh->_setBoundingSphereRadius(maxBounds.distance(minBounds) / 2.0f);
/// Set material to transparent blue
subMesh->setMaterialName("Examples/TransparentBlue50");
/// Notify -Mesh object that it has been loaded
mesh->load();
return mesh;
}
static MeshPtr importObject(QDataStream &stream)
{
using namespace Ogre;
QVector4D bbMin, bbMax;
stream >> bbMin >> bbMax;
float distance, distanceSquared; // Here's a bug for you: writes "double"'s instead of floats
stream >> distanceSquared >> distance;
MeshPtr ogreMesh = MeshManager::getSingleton().createManual("conversion",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
int vertexCount, indexCount;
stream >> vertexCount >> indexCount;
VertexData *vertexData = new VertexData();
ogreMesh->sharedVertexData = vertexData;
LogManager::getSingleton().logMessage("Reading geometry...");
VertexDeclaration* decl = vertexData->vertexDeclaration;
VertexBufferBinding* bind = vertexData->vertexBufferBinding;
unsigned short bufferId = 0;
// Information for calculating bounds
Vector3 min = Vector3::ZERO, max = Vector3::UNIT_SCALE, pos = Vector3::ZERO;
Real maxSquaredRadius = -1;
bool firstVertex = true;
/*
Create a vertex definition for our buffer
*/
size_t offset = 0;
const VertexElement &positionElement = decl->addElement(bufferId, offset, VET_FLOAT3, VES_POSITION);
offset += VertexElement::getTypeSize(VET_FLOAT3);
const VertexElement &normalElement = decl->addElement(bufferId, offset, VET_FLOAT3, VES_NORMAL);
offset += VertexElement::getTypeSize(VET_FLOAT3);
// calculate how many vertexes there actually are
vertexData->vertexCount = vertexCount;
// Now create the vertex buffer
HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton().
createVertexBuffer(offset, vertexData->vertexCount,
HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
// Bind it
bind->setBinding(bufferId, vbuf);
// Lock it
unsigned char *pVert = static_cast<unsigned char*>(vbuf->lock(HardwareBuffer::HBL_DISCARD));
unsigned char *pVertStart = pVert;
QVector<float> positions;
positions.reserve(vertexCount * 3);
// Iterate over all children (vertexbuffer entries)
for (int i = 0; i < vertexCount; ++i) {
float *pFloat;
QVector4D vertex;
stream >> vertex;
vertex.setZ(vertex.z() * -1);
/* Copy over the position */
positionElement.baseVertexPointerToElement(pVert, &pFloat);
*(pFloat++) = (float)vertex.x();
*(pFloat++) = (float)vertex.y();
*(pFloat++) = (float)vertex.z();
positions.append(vertex.x());
positions.append(vertex.y());
positions.append(vertex.z());
/* While we're at it, calculate the bounding sphere */
pos.x = vertex.x();
pos.y = vertex.y();
pos.z = vertex.z();
if (firstVertex) {
min = max = pos;
maxSquaredRadius = pos.squaredLength();
firstVertex = false;
} else {
min.makeFloor(pos);
max.makeCeil(pos);
maxSquaredRadius = qMax(pos.squaredLength(), maxSquaredRadius);
}
pVert += vbuf->getVertexSize();
}
// Set bounds
const AxisAlignedBox& currBox = ogreMesh->getBounds();
Real currRadius = ogreMesh->getBoundingSphereRadius();
if (currBox.isNull())
{
//do not pad the bounding box
ogreMesh->_setBounds(AxisAlignedBox(min, max), false);
ogreMesh->_setBoundingSphereRadius(Math::Sqrt(maxSquaredRadius));
}
else
{
AxisAlignedBox newBox(min, max);
newBox.merge(currBox);
//do not pad the bounding box
ogreMesh->_setBounds(newBox, false);
ogreMesh->_setBoundingSphereRadius(qMax(Math::Sqrt(maxSquaredRadius), currRadius));
}
/*
Create faces
*/
// All children should be submeshes
SubMesh* sm = ogreMesh->createSubMesh();
sm->setMaterialName("clippingMaterial");
sm->operationType = RenderOperation::OT_TRIANGLE_LIST;
sm->useSharedVertices = true;
// tri list
sm->indexData->indexCount = indexCount;
// Allocate space
HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager::getSingleton().
createIndexBuffer(
HardwareIndexBuffer::IT_16BIT,
sm->indexData->indexCount,
HardwareBuffer::HBU_DYNAMIC,
false);
sm->indexData->indexBuffer = ibuf;
unsigned short *pShort = static_cast<unsigned short*>(ibuf->lock(HardwareBuffer::HBL_DISCARD));
QVector<EdgeData::Triangle> triangles(indexCount / 3);
for (int i = 0; i < indexCount / 3; ++i) {
quint16 i1, i2, i3;
stream >> i1 >> i2 >> i3;
*pShort++ = i1;
*pShort++ = i2;
*pShort++ = i3;
triangles[i].vertIndex[0] = i1;
triangles[i].vertIndex[1] = i2;
triangles[i].vertIndex[2] = i3;
}
/* Recalculate the vertex normals */
Vector4 *faceNormals = (Vector4*)_aligned_malloc(sizeof(Vector4) * triangles.size(), 16);
OptimisedUtil *util = OptimisedUtil::getImplementation();
util->calculateFaceNormals(positions.constData(),
triangles.data(),
faceNormals,
indexCount / 3);
// Iterate over all children (vertexbuffer entries)
pVert = pVertStart;
for (int i = 0; i < vertexCount; ++i) {
float *pFloat;
Vector3 normal = Vector3::ZERO;
int count = 0;
/* Search for all faces that use this vertex */
for (int j = 0; j < triangles.size(); ++j) {
if (triangles[j].vertIndex[0] == i
|| triangles[j].vertIndex[1] == i
|| triangles[j].vertIndex[2] == i) {
normal.x += faceNormals[j].x / faceNormals[j].w;
normal.y += faceNormals[j].y / faceNormals[j].w;
normal.z += faceNormals[j].z / faceNormals[j].w;
count++;
}
}
normal.normalise();
/* Copy over the position */
normalElement.baseVertexPointerToElement(pVert, &pFloat);
*(pFloat++) = normal.x;
*(pFloat++) = normal.y;
*(pFloat++) = normal.z;
pVert += vbuf->getVertexSize();
}
_aligned_free(faceNormals);
vbuf->unlock();
ibuf->unlock();
return ogreMesh;
}
// Convert Nif::NiTriShape to Ogre::SubMesh, attached to the given
// mesh.
static void createOgreMesh(Mesh *mesh, NiTriShape *shape, const String &material)
{
NiTriShapeData *data = shape->data.getPtr();
SubMesh *sub = mesh->createSubMesh(shape->name.toString());
int nextBuf = 0;
// This function is just one long stream of Ogre-barf, but it works
// great.
// Add vertices
int numVerts = data->vertices.length / 3;
sub->vertexData = new VertexData();
sub->vertexData->vertexCount = numVerts;
sub->useSharedVertices = false;
VertexDeclaration *decl = sub->vertexData->vertexDeclaration;
decl->addElement(nextBuf, 0, VET_FLOAT3, VES_POSITION);
HardwareVertexBufferSharedPtr vbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
VertexElement::getTypeSize(VET_FLOAT3),
numVerts, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
vbuf->writeData(0, vbuf->getSizeInBytes(), data->vertices.ptr, true);
VertexBufferBinding* bind = sub->vertexData->vertexBufferBinding;
bind->setBinding(nextBuf++, vbuf);
// Vertex normals
if(data->normals.length)
{
decl->addElement(nextBuf, 0, VET_FLOAT3, VES_NORMAL);
vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
VertexElement::getTypeSize(VET_FLOAT3),
numVerts, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
vbuf->writeData(0, vbuf->getSizeInBytes(), data->normals.ptr, true);
bind->setBinding(nextBuf++, vbuf);
}
// Vertex colors
if(data->colors.length)
{
const float *colors = data->colors.ptr;
RenderSystem* rs = Root::getSingleton().getRenderSystem();
std::vector<RGBA> colorsRGB(numVerts);
RGBA *pColour = &colorsRGB.front();
for(int i=0; i<numVerts; i++)
{
rs->convertColourValue(ColourValue(colors[0],colors[1],colors[2],
colors[3]),pColour++);
colors += 4;
}
decl->addElement(nextBuf, 0, VET_COLOUR, VES_DIFFUSE);
vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
VertexElement::getTypeSize(VET_COLOUR),
numVerts, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
vbuf->writeData(0, vbuf->getSizeInBytes(), &colorsRGB.front(), true);
bind->setBinding(nextBuf++, vbuf);
}
// Texture UV coordinates
if(data->uvlist.length)
{
decl->addElement(nextBuf, 0, VET_FLOAT2, VES_TEXTURE_COORDINATES);
vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
VertexElement::getTypeSize(VET_FLOAT2),
numVerts, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
vbuf->writeData(0, vbuf->getSizeInBytes(), data->uvlist.ptr, true);
bind->setBinding(nextBuf++, vbuf);
}
// Triangle faces
int numFaces = data->triangles.length;
if(numFaces)
{
HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager::getSingleton().
createIndexBuffer(HardwareIndexBuffer::IT_16BIT,
numFaces,
HardwareBuffer::HBU_STATIC_WRITE_ONLY);
ibuf->writeData(0, ibuf->getSizeInBytes(), data->triangles.ptr, true);
sub->indexData->indexBuffer = ibuf;
sub->indexData->indexCount = numFaces;
sub->indexData->indexStart = 0;
}
// Set material if one was given
if(!material.empty()) sub->setMaterialName(material);
/* Old commented D code. Might be useful when reimplementing
animation.
// Assign this submesh to the given bone
VertexBoneAssignment v;
v.boneIndex = ((Bone*)bone)->getHandle();
v.weight = 1.0;
std::cerr << "+ Assigning bone index " << v.boneIndex << "\n";
for(int i=0; i < numVerts; i++)
{
v.vertexIndex = i;
sub->addBoneAssignment(v);
}
*/
}
// Convert Nif::NiTriShape to Ogre::SubMesh, attached to the given
// mesh.
void NIFLoader::createOgreSubMesh(NiTriShape *shape, const String &material, std::list<VertexBoneAssignment> &vertexBoneAssignments)
{
// cout << "s:" << shape << "\n";
NiTriShapeData *data = shape->data.getPtr();
SubMesh *sub = mesh->createSubMesh(shape->name.toString());
int nextBuf = 0;
// This function is just one long stream of Ogre-barf, but it works
// great.
// Add vertices
int numVerts = data->vertices.length / 3;
sub->vertexData = new VertexData();
sub->vertexData->vertexCount = numVerts;
sub->useSharedVertices = false;
VertexDeclaration *decl = sub->vertexData->vertexDeclaration;
decl->addElement(nextBuf, 0, VET_FLOAT3, VES_POSITION);
HardwareVertexBufferSharedPtr vbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
VertexElement::getTypeSize(VET_FLOAT3),
numVerts, HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY, false);
if(flip)
{
float *datamod = new float[data->vertices.length];
//std::cout << "Shape" << shape->name.toString() << "\n";
for(int i = 0; i < numVerts; i++)
{
int index = i * 3;
const float *pos = data->vertices.ptr + index;
Ogre::Vector3 original = Ogre::Vector3(*pos ,*(pos+1), *(pos+2));
original = mTransform * original;
mBoundingBox.merge(original);
datamod[index] = original.x;
datamod[index+1] = original.y;
datamod[index+2] = original.z;
}
vbuf->writeData(0, vbuf->getSizeInBytes(), datamod, false);
delete [] datamod;
}
else
{
vbuf->writeData(0, vbuf->getSizeInBytes(), data->vertices.ptr, false);
}
VertexBufferBinding* bind = sub->vertexData->vertexBufferBinding;
bind->setBinding(nextBuf++, vbuf);
if (data->normals.length)
{
decl->addElement(nextBuf, 0, VET_FLOAT3, VES_NORMAL);
vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
VertexElement::getTypeSize(VET_FLOAT3),
numVerts, HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
if(flip)
{
Quaternion rotation = mTransform.extractQuaternion();
rotation.normalise();
float *datamod = new float[data->normals.length];
for(int i = 0; i < numVerts; i++)
{
int index = i * 3;
const float *pos = data->normals.ptr + index;
Ogre::Vector3 original = Ogre::Vector3(*pos ,*(pos+1), *(pos+2));
original = rotation * original;
if (mNormaliseNormals)
{
original.normalise();
}
datamod[index] = original.x;
datamod[index+1] = original.y;
datamod[index+2] = original.z;
}
vbuf->writeData(0, vbuf->getSizeInBytes(), datamod, false);
delete [] datamod;
}
else
{
vbuf->writeData(0, vbuf->getSizeInBytes(), data->normals.ptr, false);
}
bind->setBinding(nextBuf++, vbuf);
}
// Vertex colors
if (data->colors.length)
{
const float *colors = data->colors.ptr;
RenderSystem* rs = Root::getSingleton().getRenderSystem();
std::vector<RGBA> colorsRGB(numVerts);
RGBA *pColour = &colorsRGB.front();
for (int i=0; i<numVerts; i++)
{
rs->convertColourValue(ColourValue(colors[0],colors[1],colors[2],
colors[3]),pColour++);
colors += 4;
}
decl->addElement(nextBuf, 0, VET_COLOUR, VES_DIFFUSE);
vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
VertexElement::getTypeSize(VET_COLOUR),
numVerts, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
vbuf->writeData(0, vbuf->getSizeInBytes(), &colorsRGB.front(), true);
bind->setBinding(nextBuf++, vbuf);
}
if (data->uvlist.length)
{
decl->addElement(nextBuf, 0, VET_FLOAT2, VES_TEXTURE_COORDINATES);
vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
VertexElement::getTypeSize(VET_FLOAT2),
numVerts, HardwareBuffer::HBU_STATIC_WRITE_ONLY,false);
if(flip)
{
float *datamod = new float[data->uvlist.length];
for(unsigned int i = 0; i < data->uvlist.length; i+=2){
float x = *(data->uvlist.ptr + i);
float y = *(data->uvlist.ptr + i + 1);
datamod[i] =x;
datamod[i + 1] =y;
}
vbuf->writeData(0, vbuf->getSizeInBytes(), datamod, false);
delete [] datamod;
}
else
vbuf->writeData(0, vbuf->getSizeInBytes(), data->uvlist.ptr, false);
bind->setBinding(nextBuf++, vbuf);
}
// Triangle faces - The total number of triangle points
int numFaces = data->triangles.length;
if (numFaces)
{
sub->indexData->indexCount = numFaces;
sub->indexData->indexStart = 0;
HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager::getSingleton().
createIndexBuffer(HardwareIndexBuffer::IT_16BIT,
numFaces,
HardwareBuffer::HBU_STATIC_WRITE_ONLY, true);
if(flip && mFlipVertexWinding && sub->indexData->indexCount % 3 == 0){
sub->indexData->indexBuffer = ibuf;
uint16 *datamod = new uint16[numFaces];
int index = 0;
for (size_t i = 0; i < sub->indexData->indexCount; i+=3)
{
const short *pos = data->triangles.ptr + index;
uint16 i0 = (uint16) *(pos+0);
uint16 i1 = (uint16) *(pos+1);
uint16 i2 = (uint16) *(pos+2);
//std::cout << "i0: " << i0 << "i1: " << i1 << "i2: " << i2 << "\n";
datamod[index] = i2;
datamod[index+1] = i1;
datamod[index+2] = i0;
index += 3;
}
ibuf->writeData(0, ibuf->getSizeInBytes(), datamod, false);
delete [] datamod;
}
else
ibuf->writeData(0, ibuf->getSizeInBytes(), data->triangles.ptr, false);
sub->indexData->indexBuffer = ibuf;
}
// Set material if one was given
if (!material.empty()) sub->setMaterialName(material);
//add vertex bone assignments
for (std::list<VertexBoneAssignment>::iterator it = vertexBoneAssignments.begin();
it != vertexBoneAssignments.end(); it++)
{
sub->addBoneAssignment(*it);
}
if(mSkel.isNull())
needBoneAssignments.push_back(sub);
}