SO3Engine/SO3Utils/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include "SO3BaseMeshsTools.h"

namespace SO3
{

SBaseMeshsTools::SBaseMeshsTools()
{
  // Forbiden (private). Use static functions instead.
}

void 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();
}

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_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
        indexData->indexCount = 6 * nRings * (nSegments+1);
        indexData->indexBuffer = Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(Ogre::HardwareIndexBuffer::IT_16BIT, indexData->indexCount, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
        Ogre::HardwareIndexBufferSharedPtr iBuf = 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 = 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();
}

void 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();
}

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;

  // positions
        vertexDecl->addElement(0, 0, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
        
        // allocate the vertex buffer
        vertexData->vertexCount = nVerticesInBase + 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 - 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_WRITE_ONLY, false);
        Ogre::HardwareIndexBufferSharedPtr iBuf = indexData->indexBuffer;
        unsigned short* pIndices = static_cast<unsigned short*>(iBuf->lock(Ogre::HardwareBuffer::HBL_DISCARD));

        //Positions : cone head and base
        for (int i=0; i<3; i++)
                *pVertex++ = 0.0f;

        //Base :
        float fDeltaBaseAngle = (2 * Ogre::Math::PI) / nVerticesInBase;
        for (int i=0; i<nVerticesInBase; i++)
        {
                float angle = i * fDeltaBaseAngle;
                *pVertex++ = radius * cosf(angle);
                *pVertex++ = height;
                *pVertex++ = radius * sinf(angle);
        }

        //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();
}

void 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();
}

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;
        vertexDecl->addElement(0, 0, Ogre::VET_FLOAT3, Ogre::VES_POSITION); // positions

        // allocate the vertex buffer
        vertexData->vertexCount = 6;
        Ogre::HardwareVertexBufferSharedPtr vBuf = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(vertexDecl->getVertexSize(0), 6, 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 - cone and base
        indexData->indexCount = 3 * 6;
        indexData->indexBuffer = Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(Ogre::HardwareIndexBuffer::IT_16BIT, 24, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
        Ogre::HardwareIndexBufferSharedPtr iBuf = indexData->indexBuffer;
        unsigned short* pIndices = static_cast<unsigned short*>(iBuf->lock(Ogre::HardwareBuffer::HBL_DISCARD));

        //Positions : bottom vertex
        for (int i=0; i<3; i++)
                *pVertex++ = 0.0f;

  // base
  float baseOffset = baseLength / 2.0f;
  *pVertex++ = baseOffset;  *pVertex++ = bottomDistance; *pVertex++ = baseOffset;  // corner 1
  *pVertex++ = baseOffset;  *pVertex++ = bottomDistance; *pVertex++ = -baseOffset; // corner 2
  *pVertex++ = -baseOffset; *pVertex++ = bottomDistance; *pVertex++ = -baseOffset; // corner 3
  *pVertex++ = -baseOffset; *pVertex++ = bottomDistance; *pVertex++ = baseOffset;  // corner 4

  // upVertex
  *pVertex++ = 0;
  *pVertex++ = upDistance;
  *pVertex++ = 0;

  //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++ = 5;
                *pIndices++ = (i%4) + 1;
                *pIndices++ = ((i+1)%4) + 1;
        }

  // 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_WRITE_ONLY);

        // Bind buffer
        bind->setBinding(0, vbuf);

  // Upload data
        float data[]=
  {
                -1,1,-1,  // corner 1
                -1,-1,-1, // corner 2
                1,1,-1,   // corner 3
                1,-1,-1   // corner 4
  };
        vbuf->writeData(0, sizeof(data), data, true);
}

}

---