MercuryShapes.cpp

Go to the documentation of this file.

#include "MercuryShapes.h"
#include "MercuryINI.h"
#include "MercuryMath.h"
#include "MercuryLog.h"
#include "MercuryUtil.h"
#include "MercuryPoly.h"
#include "MercuryTexture.h"
#include "MercuryObjectFactory.h"

MercuryShape::MercuryShape() : MercuryModel()
{
    AddMaterial( new MercuryMaterial );
}

MercuryShape::~MercuryShape()
{
}

bool MercuryShape::LoadImage( const MString & Filename )
{
    //Assume 1st material for shapes
    MercuryMaterial* m = m_materials[0];

    m->LoadMaterial( Filename );

    m->m_diffuse.SetA( 1 );
    m->m_diffuse.SetB( 1 );
    m->m_diffuse.SetG( 1 );
    m->m_diffuse.SetR( 1 );

    m->m_specular.SetA( .4f );
    m->m_specular.SetB( .4f );
    m->m_specular.SetG( .4f );
    m->m_specular.SetR( .4f );
        
    m->m_ambient.SetA( .1f );
    m->m_ambient.SetB( .1f );
    m->m_ambient.SetG( .1f );
    m->m_ambient.SetR( .1f );

    if (m->NumTextures() > 0)
    {
        SetScaleX((m->GetTexture(0)->GetWidth() / m->GetTexture(0)->GetDpiX()) * 12);
        SetScaleY((m->GetTexture(0)->GetHeight() / m->GetTexture(0)->GetDpiY()) * 12);
    }

    return true;
}

void MercuryShape::MakeSphere( int Stacks, int Slices )
{
    int x,y;
    CleanupMeshes();

    MercuryMesh* m = new MercuryMesh;
    if( !MESHMAN.RegMesh( m, ssprintf( "BASE:Sphere%d,%d", Stacks, Slices ), true ) )
    {
        m->SetDrawType(MGL_TRIANGLE);

        //stacks*slices*2 = number of polys
        //3 verts per poly
        m->SetNumVertices( (Stacks+1)*(Slices+1) );

        float dY = 6.2831853072f / float(Stacks)/2;
        float dX = 6.2831853072f / float(Slices);

        for ( y = 0; y < Stacks+1; y++ )
            for ( x = 0; x < Slices+1; x++ )
            {
                int p = (x)+(y*Slices);
                MercuryVertex& v = (*m)[p];
                v.x = COS( dX * x ) * SIN( dY * y );
                v.y = SIN( dX * x ) * SIN( dY * y );
                v.z = COS( dY * y );
                v.SetV( float( y ) / Stacks );
                v.SetU( float( x ) / Slices );
            }

        m->SetNumIndices(Stacks*Slices*3*2);
        unsigned int kjg = 0;
        for ( y = 0; y < Stacks; y++ )
            for ( x = 0; x < Slices; x++ )
            {
                int p = (x)+(y*Slices);
                m->SetIndice(kjg++, p+1);
                m->SetIndice(kjg++, p);
                m->SetIndice(kjg++, p+Slices);

                m->SetIndice(kjg++, p+Slices);
                m->SetIndice(kjg++, p+Slices+1);
                m->SetIndice(kjg++, p+1);

            }
        m->CalculateVertexNormals();
        m->ToggleUseVBOs(true);
        m->BuildVBO();

    }
    m->SetMaterial( m_materials[0] );
    AddMesh(m);
    m_hidden = false;
    m_fVisRadius = 1;
}

void MercuryShape::MakeSprite( int Rows, int Cols )
{
    CleanupMeshes();
    MercuryMesh* m = new MercuryMesh;
    if( !MESHMAN.RegMesh( m, ssprintf("BASE:Sprite%dx%d", Rows, Cols ), true ) )
    {
        m->SetDrawType(MGL_TRIANGLE);
        m->SetNumIndices( Rows * Cols * 6 );
        unsigned int * i = m->GetIndicesPtr();
        unsigned l;

        for( l = 0; l < Rows*Cols; l++ )
        {
            int c1 = l + l/Cols;
            int c2 = l + l/Cols+1;
            int c3 = c1 + Cols+1;
            int c4 = c2 + Cols+1;
            i[l*6+0] = c2;
            i[l*6+1] = c1;
            i[l*6+2] = c3;
            i[l*6+3] = c2;
            i[l*6+4] = c3;
            i[l*6+5] = c4;
                            
            /*i[l*6+0] = 1+l*6;
            i[l*6+1] = 0+l*6;
            i[l*6+2] = 2+l*6;
            i[l*6+3] = 1+l*6;
            i[l*6+4] = 2+l*6;
            i[l*6+5] = 3+l*6;*/

        }

        m->SetNumVertices(4 * Rows * Cols);

        l=0;
        for( unsigned r = 0; r<=Rows; r++ )
        {
            for( unsigned c = 0; c<=Cols; c++ )
            {
                float rc = (float)r, rt = (float)Rows;
                float cc = (float)c, ct = (float)Cols;

                (*m)[l].x = rc/rt-0.5f;
                (*m)[l].y = cc/ct-0.5f;
                (*m)[l].z = 0;
                (*m)[l].SetU( rc/rt );
                (*m)[l].SetV( cc/ct );
                ++l;
            }
        }
    }
    
    m->ToggleUseVBOs(true);

    AddMesh(m);
    m_hidden = false;
    m->SetMaterial( m_materials[0] );

    m->CalculateVertexNormals();
    m->BuildVBO();

    m_fVisRadius = 1;
}

void MercuryShape::MakeCylinder( int Stacks, int Slices )
{
    int y,x;
    CleanupMeshes();
    MercuryMesh* m = new MercuryMesh;
    if( !MESHMAN.RegMesh( m, ssprintf( "BASE:Cylinder%d,%d", Stacks, Slices ), true ) )
    {
        int p;
        float dX = 6.2831853072f / float(Slices);

        m->SetDrawType(MGL_TRIANGLE);
        m->SetNumVertices( (Stacks+3)*(Slices+1) );


        for ( y = 0; y < Stacks+3; y++ )
            for ( x = 0; x < Slices+1; x++ )
            {
                p = (x)+(y*Slices);

                MercuryVertex& v = (*m)[p];

                if ( y == Stacks + 1 || y == Stacks + 2 )       //We're at a pole
                {
                    v.x = 0;
                    v.y = 0; 
                } else {
                    v.x = COS( dX * x );
                    v.y = SIN( dX * x );
                }
                if ( y == Stacks + 2 )  //North Pole
                {
                    v.SetV( 0 );
                    v.z = - 0.5f;
                } else if ( y == Stacks + 1 ) //South Pole
                {
                    v.SetV( 1 );
                    v.z = 0.5f;
                } else 
                {
                    v.SetV( float( y ) / Stacks/3+0.333333f );
                    v.z = ( float( y ) / Stacks ) - 0.5f;
                }
                v.SetU( float( x ) / Slices );
            }
        m->CalculateVertexNormals();
        m->ToggleUseVBOs(true);
        m->BuildVBO();

    }
    
    m->SetMaterial( m_materials[0] );
    AddMesh(m);
    m_hidden = false;
    m_fVisRadius = 1;
}

void MercuryShape::MakeBox( bool bWholeMap )
{
    int i;
    CleanupMeshes();

    MercuryMesh* m = new MercuryMesh;
    if( !MESHMAN.RegMesh( m, "BASE:Box", true ) )
    {
        m->SetDrawType(MGL_TRIANGLE);
        m->SetNumIndices( 36 );
        m->SetNumVertices( 24 );

        for( i = 0; i < 6; i++ )
        {
            //order: 0 1 2    2 1 3 
            
            m->SetIndice( i*6 + 0, 0 + 4*i );
            m->SetIndice( i*6 + 1, 1 + 4*i );
            m->SetIndice( i*6 + 2, 2 + 4*i );
            m->SetIndice( i*6 + 3, 2 + 4*i );
            m->SetIndice( i*6 + 4, 1 + 4*i );
            m->SetIndice( i*6 + 5, 3 + 4*i );
        }
        MercuryPoint CoreF[8];
        static int CoreI[36] = {    1,0,3,2,
                                    0,1,4,5,
                                    3,2,7,6,
                                    2,0,6,4,
                                    4,5,6,7,
                                    1,3,5,7 };

        for( i = 0; i < 8; i++ )
            CoreF[i] = MercuryPoint( (i%2)-.5f,((i/2)%2)-.5f,((i/4)%2)-.5f );

        //Now that we have the cores set up, we can generate general verticies
        for( i = 0; i < 24; i++ )
        {
            m->GetVerticePtr()[i].GetPointHandle() = CoreF[CoreI[i]];
            m->GetVerticePtr()[i].SetU( float((i)%2) );
            m->GetVerticePtr()[i].SetV( float((i/2)%2) );
        }
        m->ToggleUseVBOs(true);
    }
    m->SetMaterial( m_materials[0] );
    AddMesh(m);
    m->CalculateVertexNormals();
            m->BuildVBO();

    m_hidden = false;
    m_fVisRadius = 1.1f;
}

bool MercuryShape::SetFromINI( MercuryINI & InINI, const MString & section )
{
    MString Texture = InINI.GetValueS( section, "Texture", "" );
    LoadImage( Texture );

    int ShapeType = InINI.GetValueI( section, "Type", 0 );
    switch ( ShapeType )
    {
    case 0:
        MakeBox( true );
        break;
    case 1:
        MakeCylinder(   InINI.GetValueI( section, "Stacks", 6 ),
                        InINI.GetValueI( section, "Slices", 12 ) );
        break;
    case 2:
        MakeSphere(     InINI.GetValueI( section, "Stacks", 6 ),
                        InINI.GetValueI( section, "Slices", 12 ) );
        break;
    case 3:
        MakeSprite( );
        break;
    default:
        LOG.Warn( ssprintf("Could not find shape type '%s'.", section.c_str() ) );
    }

    SetScaleX( InINI.GetValueF( section, "ScaleX", 1 ) );
    SetScaleY( InINI.GetValueF( section, "ScaleY", 1 ) );
    SetScaleZ( InINI.GetValueF( section, "ScaleZ", 1 ) );

    SetRotX( InINI.GetValueF( section, "RotationX", 0 ) );
    SetRotY( InINI.GetValueF( section, "RotationY", 0 ) );
    SetRotZ( InINI.GetValueF( section, "RotationZ", 0 ) );

    SetPosition( MercuryPoint( 
        InINI.GetValueF( section, "PositionX", 0 ),
        InINI.GetValueF( section, "PositionY", 0 ),
        InINI.GetValueF( section, "PositionZ", 0 ) ) );

    return true;
}

bool MercuryShape::Command( PStack & ret, const char * command, PStack & args )
{
    if ( strcmp( command, "LoadImage" ) == 0 )
    {
        MString Parameter = args.PopItem().GetValueS();
        while( args.GetSize() )
            Parameter = args.PopItem().GetValueS() + "," + Parameter;
        LoadImage( Parameter );
        return true;
    }

    if ( strcmp( command, "SetShape" ) == 0 )
    {
        PSElement type = args.PopItem();
        if ( type.GetValueS() == "Sphere" )
        {
            long Stacks, Slices;
            if ( !args.PopItem().GetValueI( Stacks ) )
                Stacks = 6;
            if ( !args.PopItem().GetValueI( Slices ) )
                Slices = 12;
            MakeSphere( Stacks, Slices );
            return true;
        }
        else if ( type.GetValueS() == "Cylinder" )
        {
            long Stacks, Slices;
            if ( !args.PopItem().GetValueI( Stacks ) )
                Stacks = 6;
            if ( !args.PopItem().GetValueI( Slices ) )
                Slices = 12;
            MakeCylinder( Stacks, Slices );
            return true;
        } else if ( type.GetValueS() == "Box" )
        {
            MakeBox();
            return true;
        } else if ( type.GetValueS() == "Sprite" )
        {
            MakeSprite();
            return true;
        }
        return false;
    }
    return MercuryObject::Command( ret, command, args );
}

void MercuryShape::EnumerateCommands( MVector< MString > & toAdd )
{
    toAdd.push_back( "SetShape" );
    toAdd.push_back( "LoadImage" );
    MercuryObject::EnumerateCommands( toAdd );
}

void MercuryShape::CleanupMeshes()
{
    for ( int i = 0; (unsigned)i < m_meshes.size(); i++ )
    {
        RemoveObject(m_meshes[i]);
        SAFE_DELETE(m_meshes[i]);
    }
}

REGISTER_OBJECT_TYPE( MercuryShape );

/* 
 * Copyright (c) 2005-2006, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by