MercuryModel.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryModel.h"
#include "MercuryDisplay.h"
#include "MercuryLog.h"
#include "MercuryUtil.h"

MercuryModel::MercuryModel()
{
    m_polys = 0;
    m_file = NULL;
//  m_curFrame = 0;
}

MercuryModel::~MercuryModel()
{
    //If we're a clone, don't do anything.
    if( m_bClone )
        return;
    unsigned int i;
    unsigned int num = m_meshes.size();
    for (i = 0; i < num; i++)
        MESHMAN.UnregMesh( m_meshes[i] );
}

void MercuryModel::AddMesh(MercuryMesh* mesh)
{
    m_meshes.push_back(mesh);
    AddObject(mesh);
}

void MercuryModel::AddMaterial(MercuryMaterial* material)
{
    ASSERT(material);
    m_materials.push_back(material);
}

void MercuryModel::OpenFile(const MString& path)
{
    SAFE_DELETE(m_file);
    m_file = FILEMAN.Open(path);

    if (m_file==NULL)
    {   
        LOG.Warn("File not oppened:" + path);
        throw;
    }
}

void MercuryModel::Load(MString path)
{
    m_path =    path.substr(0, path.find_last_of("/")+1);
    m_filename = path.substr(path.find_last_of("/")+1);
    OpenFile(path);
    LoadModel();
    CloseFile();
}

bool MercuryModel::ReadLine()
{
    //This will strip out comments for us.
    do
    {
        if (!m_file->Eof())
            m_file->ReadLine(m_line);
        else
            return false;

        if (!m_line.empty())
        {
            //Remove leading whitespace
            while ((m_line.find(" ") == 0)||(m_line.find("\t") == 0))
                m_line = m_line.substr(1, m_line.length());

            //Remove comments
            int comment = m_line.find("//");
            if (comment >= 0)
                m_line = m_line.substr(0,comment);

            //Remove trailing whitespace
            while ((m_line.rfind(" ") == 0)||(m_line.rfind("\t") == 0))
                m_line = m_line.substr(0, m_line.length()-1);
        }
    }
    while (m_line.length() <= 0);

    return true;
}

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

void MercuryModel::EnumerateCommands( MVector< MString > & toAdd )
{
    toAdd.push_back( "LoadModel" );
    MercuryObject::EnumerateCommands( toAdd );
}

/* 
 * Copyright (c) 2005-2006 Joshua Allen
 * 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