SO3BaseMeshsTools.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Utils/SO3BaseMeshsTools.h"
 
namespace SO3
{
 
SBaseMeshsTools::SBaseMeshsTools()
{
  // Forbiden (private). Use static functions instead.
}
 
Ogre::MeshPtr SBaseMeshsTools::CreateSphere(const Ogre::String& strName, float radius, int nRings, int nSegments, bool bNormals, bool bTexCoords, Ogre::String groupName)
{
  Ogre::MeshPtr pSphere = Ogre::MeshManager::getSingleton().createManual(strName, groupName);
  Ogre::SubMesh* pSphereVertex = pSphere->createSubMesh();
  pSphere->sharedVertexData = new Ogre::VertexData();
        CreateSphere(pSphere->sharedVertexData, pSphereVertex->indexData, radius, nRings, nSegments, bNormals, bTexCoords);
 
        // Generate face list
        pSphereVertex->useSharedVertices = true;
  pSphere->_setBounds(Ogre::AxisAlignedBox(Ogre::Vector3(-radius, -radius, -radius), Ogre::Vector3(radius, radius, radius)), false);
        pSphere->_setBoundingSphereRadius(radius);
 
        // this line makes clear the mesh is loaded (avoids memory leaks)
        pSphere->load();
  return pSphere;
}
 
void SBaseMeshsTools::CreateSphere(Ogre::VertexData*& vertexData, Ogre::IndexData*& indexData, float radius, int nRings, int nSegments, bool bNormals, bool bTexCoords)
{
        assert(vertexData && indexData);
 
        // 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
        if (bNormals)
        {
                vertexDecl->addElement(0, currOffset, Ogre::VET_FLOAT3, Ogre::VES_NORMAL);
                currOffset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
        }
 
        // two dimensional texture coordinates
        if (bTexCoords)
        {
                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, false);
        Ogre::VertexBufferBinding* binding = vertexData->vertexBufferBinding;
        binding->setBinding(0, vBuf);
        float* pVertex = static_cast<float*>(vBuf->lock(Ogre::HardwareBuffer::HBL_WRITE_ONLY));
 
        // allocate index buffer
        indexData->indexCount = 6 * nRings * (nSegments+1);
        indexData->indexBuffer = Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(Ogre::HardwareIndexBuffer::IT_16BIT, indexData->indexCount, Ogre::HardwareBuffer::HBU_STATIC, false);
        Ogre::HardwareIndexBufferSharedPtr iBuf = indexData->indexBuffer;
        unsigned short* pIndices = static_cast<unsigned short*>(iBuf->lock(Ogre::HardwareBuffer::HBL_WRITE_ONLY));
 
        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 = radius * sinf (ring * fDeltaRingAngle);
                float y0 = radius * 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;
 
                        if (bNormals)
                        {
                                Ogre::Vector3 vNormal = Ogre::Vector3(x0, y0, z0).normalisedCopy();
                                *pVertex++ = vNormal.x;
                                *pVertex++ = vNormal.y;
                                *pVertex++ = vNormal.z;
                        }
 
                        if (bTexCoords)
                        {
                                *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 ++;
                        }
                }
        }
 
        // Unlock
        vBuf->unlock();
        iBuf->unlock();
}
 
Ogre::MeshPtr SBaseMeshsTools::CreateCone(const Ogre::String& strName , float radius , float height, int nVerticesInBase, Ogre::String groupName)
{
        Ogre::MeshPtr pCone = Ogre::MeshManager::getSingleton().createManual(strName, groupName);
        Ogre::SubMesh *pConeVertex = pCone->createSubMesh();
        pCone->sharedVertexData = new Ogre::VertexData();
 
        CreateCone(pCone->sharedVertexData, pConeVertex->indexData, radius, height, nVerticesInBase);
 
        // Generate face list
        pConeVertex->useSharedVertices = true;
        pCone->_setBounds(Ogre::AxisAlignedBox(Ogre::Vector3(-radius, 0, -radius), Ogre::Vector3(radius, height, radius)), false);
        pCone->_setBoundingSphereRadius(Ogre::Math::Sqrt(height*height + radius*radius));
 
        // this line makes clear the mesh is loaded (avoids memory leaks)
        pCone->load();
 
  return pCone;
}
 
void SBaseMeshsTools::CreateCone(Ogre::VertexData*& vertexData, Ogre::IndexData*& indexData, float radius , float height, int nVerticesInBase)
{
        assert(vertexData && indexData);
 
        // 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 = nVerticesInBase + 1;
        Ogre::HardwareVertexBufferSharedPtr vBuf = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(vertexDecl->getVertexSize(0), vertexData->vertexCount, Ogre::HardwareBuffer::HBU_STATIC, false);
        Ogre::VertexBufferBinding* binding = vertexData->vertexBufferBinding;
        binding->setBinding(0, vBuf);
        float* pVertex = static_cast<float*>(vBuf->lock(Ogre::HardwareBuffer::HBL_WRITE_ONLY));
 
        // allocate index buffer - cone and base
        indexData->indexCount = (3 * nVerticesInBase) + (3 * (nVerticesInBase - 2));
        indexData->indexBuffer = Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(Ogre::HardwareIndexBuffer::IT_16BIT, indexData->indexCount, Ogre::HardwareBuffer::HBU_STATIC, false);
        Ogre::HardwareIndexBufferSharedPtr iBuf = indexData->indexBuffer;
        unsigned short* pIndices = static_cast<unsigned short*>(iBuf->lock(Ogre::HardwareBuffer::HBL_WRITE_ONLY));
 
        //Positions : cone head and base
  *pVertex++ = 0.0f;
  *pVertex++ = 0.0f;
  *pVertex++ = 0.0f;
 
  *pVertex++ = 0.0f;
  *pVertex++ = 1.0f;
  *pVertex++ = 0.0f;
 
  *pVertex++ = 0.0f;
  *pVertex++ = 0.0f;
 
        //Base :
        float fDeltaBaseAngle = (2 * Ogre::Math::PI) / nVerticesInBase;
        for (int i=0; i<nVerticesInBase; i++)
        {
                float angle = i * fDeltaBaseAngle;
    float x0 = radius * cosf(angle);
    float y0 = height;
    float z0 = radius * sinf(angle);
                *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)i / (float)nVerticesInBase;
    *pVertex++ = 1.0f;
        }
 
        //Indices :
        //Cone head to vertices
        for (int i=0; i<nVerticesInBase; i++)
        {
                *pIndices++ = 0;
                *pIndices++ = (i%nVerticesInBase) + 1;
                *pIndices++ = ((i+1)%nVerticesInBase) + 1;
        }
        
  //Cone base
        for (int i=0; i<nVerticesInBase-2; i++)
        {
                *pIndices++ = 1;
                *pIndices++ = i + 3;
                *pIndices++ = i + 2;
        }
 
        // Unlock
        vBuf->unlock();
        iBuf->unlock();
}
 
Ogre::MeshPtr SBaseMeshsTools::CreateOctahedron(const Ogre::String& strName, float baseLength, float bottomDistance, float upDistance, Ogre::String groupName)
{
  assert(baseLength > 0);
  assert(bottomDistance > 0);
  assert(upDistance > 0);
 
  Ogre::MeshPtr pOctahedron = Ogre::MeshManager::getSingleton().createManual(strName, groupName);
        Ogre::SubMesh *pOctahedronVertex = pOctahedron->createSubMesh();
        pOctahedron->sharedVertexData = new Ogre::VertexData();
 
        CreateOctahedron(pOctahedron->sharedVertexData, pOctahedronVertex->indexData, baseLength, bottomDistance, upDistance);
 
        // Generate face list
        pOctahedronVertex->useSharedVertices = true;
  float totalLength = bottomDistance + upDistance;
        pOctahedron->_setBounds(Ogre::AxisAlignedBox(Ogre::Vector3(-baseLength/2, 0, -baseLength/2), Ogre::Vector3(baseLength/2, upDistance, baseLength/2)), false);
        // TODO: verify this:
  pOctahedron->_setBoundingSphereRadius(Ogre::Math::Sqrt(totalLength*totalLength + (baseLength/2)*(baseLength/2)));
 
        // this line makes clear the mesh is loaded (avoids memory leaks)
        pOctahedron->load();
  return pOctahedron;
}
 
void SBaseMeshsTools::CreateOctahedron(Ogre::VertexData*& vertexData, Ogre::IndexData*& indexData, float baseLength, float bottomDistance, float upDistance)
{
  assert(vertexData && indexData);
 
        // 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 = 6;
        Ogre::HardwareVertexBufferSharedPtr vBuf = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(vertexDecl->getVertexSize(0), vertexData->vertexCount, Ogre::HardwareBuffer::HBU_STATIC, false);
        Ogre::VertexBufferBinding* binding = vertexData->vertexBufferBinding;
        binding->setBinding(0, vBuf);
        float* pVertex = static_cast<float*>(vBuf->lock(Ogre::HardwareBuffer::HBL_WRITE_ONLY));
 
        // allocate index buffer - cone and base
        indexData->indexCount = 3 * 8;
        indexData->indexBuffer = Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(Ogre::HardwareIndexBuffer::IT_16BIT, indexData->indexCount, Ogre::HardwareBuffer::HBU_STATIC, false);
        Ogre::HardwareIndexBufferSharedPtr iBuf = indexData->indexBuffer;
        unsigned short* pIndices = static_cast<unsigned short*>(iBuf->lock(Ogre::HardwareBuffer::HBL_WRITE_ONLY));
 
        //Positions : bottom vertex
 
  *pVertex++ = 0.0f;
  *pVertex++ = bottomDistance;
  *pVertex++ = 0.0f;
 
  //Normal
  *pVertex++ = 0.0f;
  *pVertex++ = 1.0f;
  *pVertex++ = 0.0f;
 
  //UV
  *pVertex++ = 0.0f;
  *pVertex++ = 0.0f;
 
  // base
  float baseOffset = baseLength / 2.0f;
  *pVertex++ = baseOffset; *pVertex++ = 0; *pVertex++ = baseOffset;  // corner 1
  //Normal
  Ogre::Vector3 vNormal = Ogre::Vector3(baseOffset, 0.0f, baseOffset).normalisedCopy();
  *pVertex++ = vNormal.x; *pVertex++ = vNormal.y; *pVertex++ = vNormal.z;
  //UV
  *pVertex++ = 0.0f; *pVertex++ = 0.0f;
 
  *pVertex++ = baseOffset; *pVertex++ = 0; *pVertex++ = -baseOffset; // corner 2
  //Normal
  vNormal = Ogre::Vector3(baseOffset, 0.0f, -baseOffset).normalisedCopy();
  *pVertex++ = vNormal.x; *pVertex++ = vNormal.y; *pVertex++ = vNormal.z;
  //UV
  *pVertex++ = 0.0f; *pVertex++ = 1.0f;
 
  *pVertex++ = -baseOffset; *pVertex++ = 0; *pVertex++ = -baseOffset; // corner 3
  //Normal
  vNormal = Ogre::Vector3(-baseOffset, 0.0f, -baseOffset).normalisedCopy();
  *pVertex++ = vNormal.x; *pVertex++ = vNormal.y; *pVertex++ = vNormal.z;
  //UV
  *pVertex++ = 1.0f; *pVertex++ = 1.0f;
 
  *pVertex++ = -baseOffset; *pVertex++ = 0; *pVertex++ = baseOffset;  // corner 4
  //Normal
  vNormal = Ogre::Vector3(-baseOffset, 0.0f, baseOffset).normalisedCopy();
  *pVertex++ = vNormal.x; *pVertex++ = vNormal.y; *pVertex++ = vNormal.z;
  //UV
  *pVertex++ = 1.0f; *pVertex++ = 0.0f;
 
  // upVertex
  *pVertex++ = 0;
  *pVertex++ = -upDistance;
  *pVertex++ = 0;
 
  //Normal
  *pVertex++ = 0.0f;
  *pVertex++ = -1.0f;
  *pVertex++ = 0.0f;
 
  //UV
  *pVertex++ = 0.0f;
  *pVertex++ = 1.0f;
 
  //Indices :
        // bottom pyramid
        for (int i=0; i<4; i++)
        {
                *pIndices++ = 0;
                *pIndices++ = (i%4) + 1;
                *pIndices++ = ((i+1)%4) + 1;
        }
 
  // up pyramid
        for (int i=0; i<4; i++)
        {
                *pIndices++ = ((i+1)%4) + 1;
    *pIndices++ = (i % 4) + 1;
    *pIndices++ = 5;
        }
 
  // unlock buffers
        vBuf->unlock();
        iBuf->unlock();
}
 
void SBaseMeshsTools::CreateQuad(Ogre::VertexData*& vertexData)
{
        assert(vertexData);
 
        vertexData->vertexCount = 4;
        vertexData->vertexStart = 0;
 
        Ogre::VertexDeclaration* vertexDecl = vertexData->vertexDeclaration;
        Ogre::VertexBufferBinding* bind = vertexData->vertexBufferBinding;
 
        vertexDecl->addElement(0, 0, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
        Ogre::HardwareVertexBufferSharedPtr vbuf = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(vertexDecl->getVertexSize(0), vertexData->vertexCount, Ogre::HardwareBuffer::HBU_STATIC);
 
        // Bind buffer
        bind->setBinding(0, vbuf);
 
  // Upload data
        float data[]=
  {
                -1,1,0,  // corner 1
                -1,-1,0, // corner 2
                1,1,0,   // corner 3
                1,-1,0   // corner 4
  };
        vbuf->writeData(0, sizeof(data), data, true);
}
 
}