MercuryObject.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryObject.h"
#include "MercuryDisplay.h"
#include "MercuryLog.h"

MercuryObjectRegister   OBJECTREGISTER;

MercuryObject::MercuryObject()
:MercuryObjectBase()
{
    m_bClone = false;
    m_initalized = false;
}

MercuryObject::MercuryObject( const MString & name )
:MercuryObjectBase()
{
    m_bClone = false;
    m_initalized = false;
    SetName(m_name);
}

void MercuryObject::Init()
{
    MercuryObjectBase::Init();

    m_bMarkedForDestroy = false;
    m_hidden = false;
    m_pMaterial = NULL;

    m_modColor.m_alpha = m_modColor.m_shininess = 1.0f;

    m_halignment = LEFT;
    m_valignment = TOP;
    m_drawable = false;
    m_width = m_height = 0;

    m_state = LOADED;

    m_initalized = true;

    m_culled = false;

    m_glState.Enable(MGLS_ALL);
    m_inheretedGLState.Enable(MGLS_ALL);

    Tweening.AttachToObject( this );
    OBJECTREGISTER.Register( this, m_name );
}

MercuryObject::~MercuryObject()
{
    OBJECTREGISTER.Unregister( m_name );
    /* Objects do not have to be removed when the parent is destroying
        because vector will do it for us */

    if( !m_bClone )
        FOREACH_Object(m_objects, i)
            if ( i->bAutoDelete )
                SAFE_DELETE(i->pObject);

    m_pMaterial = NULL;
}

void MercuryObject::Update( const float dTime )
{
    ASSERT_M(m_initalized,"Object '" + GetName() + "'not initialized.");

    if ((m_state == UNLOADED) || (dTime == 0))
        return;

    if ( m_bMarkedForDestroy )
    {
        ((MercuryObject*)m_parentObject)->RemoveObject( this );
        return;
    }

    WorldStack.Push();

    Tweening.Update( dTime );

    if ( !IsHidden() )
    {
        Prerender();
        ComputeInheritedGLState();
    }

    //We must always look for m_objects.end() because
    //objects can be destroyed during this call.
    //The post increment keeps the iterator from becoming invalid
    MDequeIterator<ParentHoldPair> child = m_objects.begin();
    while (child != m_objects.end())
        (child++)->pObject->Update(dTime);

    WorldStack.Pop();
}

void MercuryObject::Prerender()
{
    //Alignment stuff
    switch(m_halignment)
    {
    case LEFT:
        SetAlignX(0);
        break;
    case CENTER:
        SetAlignX(-m_width / 2.0f);
        break;
    case RIGHT:
        SetAlignX(-(float)m_width);
        break;
    }
    switch(m_valignment)
    {
    case TOP:
        SetAlignY(0);
        break;
    case VCENTER:
        SetAlignY(-m_height / 2.0f);
        break;
    case BOTTOM:
        SetAlignY(-(float)m_height);
        break;
    }

    CalculateMatrices();
}

void MercuryObject::ComputeCull()
{
    //This really needs to be a bottom up verses a top down approach
    //So we can take into account children bouning boxes.
    if (m_parentObject)
    {
        m_culled = ((MercuryObject*)m_parentObject)->IsCulled();
        if (m_culled)
            return;
    }
    m_culled = !DISPLAY->IsVisible( GetPosition(), GetScaledRadius(), m_finalMatrix );
}

void MercuryObject::ComputeInheritedGLState()
{
    m_inheretedGLState = m_glState;
    if (m_parentObject)
        m_inheretedGLState &= ((MercuryObject*)m_parentObject)->GetInheritedGLState();
}

void MercuryObject::Render()
{
    if ( IsHidden() || (m_state == UNLOADED))
        return;

    //XXX This needs to be moved to the stack unwind of update
    //once everything has a bounding volume.
    ComputeCull();

    if ( IsCulled() )
        return;

    if ( GetInheritedGLState().GetState(MGLS_OPAQUE) )
        CustomRender();
    else
        DISPLAY->AddTranslucentObject(this);

    MDequeIterator<ParentHoldPair> child = m_objects.begin();
    while (child != m_objects.end())
        (child++)->pObject->Render();
}

void MercuryObject::CustomRender()
{
    if (m_fVisRadius > 0)
        DISPLAY->FindLights(m_finalMatrix, m_fVisRadius);

    //Skip expensive steps in things that don't have anything to draw
    //(pretty much any non mesh)
    if (m_drawable)
    {
        DISPLAY->SetStates( GetInheritedGLState() );
        DISPLAY->EnableShaders(m_pMaterial);
        DISPLAY->EnableTextures(m_pMaterial);

        DISPLAY->SetMaterial(&m_finalMaterial);

        Draw();
    }
}

void MercuryObject::AddObject(MercuryObject* object, bool bParentDelete)
{
    ASSERT(object->m_initalized);

    ParentHoldPair c;
    c.bAutoDelete = bParentDelete;
    c.pObject = object;

    m_objects.push_back(c);
    object->SetParentObject(this);

    //I think we can do the sorting on insert in log(n)
    SortDrawOrder();

    //child needs to inheret colors from parent
    object->CalculateRealColor();
}

void MercuryObject::SetDrawOrder(int order)
{
    MercuryObjectBase::SetDrawOrder(order);

    //I think we can also do this in log(n) vs linear
    if (m_parentObject)
        ((MercuryObject*)m_parentObject)->SortDrawOrder();
}

void MercuryObject::SortDrawOrder()
{
    TSortDrawOrder(m_objects);
}

#include "MercuryObjectFactory.h"

CLASS_FUNCTION_VOID_NOARGS( MercuryObject, Destroy );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetName, TYPECASTMSTRING , const char * );
CLASS_FUNCTION_VOID_TWOARGS( MercuryObject, AddObject, (MercuryObject*)(void*), void *, (bool), bool );
CLASS_FUNCTION_TWOARGS( MercuryObject, RemoveObject, bool, (MercuryObject*)(void*), void *, (bool), bool );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetMaterial, (MercuryMaterial*)(void*), MercuryMaterial* );
CLASS_FUNCTION_VOID_FOURARGS( MercuryObject, SetDiffusef, (float), float, (float), float, (float), float, (float), float );
CLASS_FUNCTION_VOID_FOURARGS( MercuryObject, SetSpecularf, (float), float, (float), float, (float), float, (float), float );
CLASS_FUNCTION_VOID_FOURARGS( MercuryObject, SetEmissivef, (float), float, (float), float, (float), float, (float), float );
CLASS_FUNCTION_VOID_FOURARGS( MercuryObject, SetAmbientf, (float), float, (float), float, (float), float, (float), float );
CLASS_FUNCTION_NOARGS( MercuryObject, GetName, const char * );
CLASS_FUNCTION_NOARGS( MercuryObject, GetMaterial, const MercuryMaterial * );
//CLASS_FUNCTION_VOID_FOURARGS( MercuryObject, GetDiffusef, (float), float &, (float), float &, (float), float &, (float), float& );
CLASS_FUNCTION_THREEARGS( MercuryObject, Spawn, MercuryObject*,TYPECASTMSTRING , const char *, TYPECASTMSTRING, const char *, (PROJECTIONTYPE)(int), int );
CLASS_FUNCTION_NOARGS( MercuryObject, GetNumChildren, int );
CLASS_FUNCTION_NOARGS( MercuryObject, GetHAlignment, int );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetHAlignment, (MercuryObject::HALIGN)(int), int );
CLASS_FUNCTION_NOARGS( MercuryObject, GetVAlignment, int );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetVAlignment, (MercuryObject::VALIGN)(int), int );

PSElement PS_MercuryObject_FinishTweening( MercuryCommandHandler * pThs, const PStack & pParameters )
{
    ((MercuryObject*)pThs)->Tweening.FinishTweening();
    return PSElement();
}
RUN_STATEMENT_AT_BOOT( REGISTER_MercuryObject_FinishTweening, MercuryObjectFactory::GetInstance().RegisterFunction( &PS_MercuryObject_FinishTweening, "MercuryObject", "FinishTweening" ); )
EXPORTPREFIX void HGEXPORT MercuryObject_FinishTweening( void * pThs )
{
    ((MercuryObject*)pThs)->Tweening.FinishTweening(); 
} EXPORTSUFFIX


PSElement PS_MercuryObject_StopTweening( MercuryCommandHandler * pThs, const PStack & pParameters )
{
    ((MercuryObject*)pThs)->Tweening.StopTweening();
    return PSElement();
}
RUN_STATEMENT_AT_BOOT( REGISTER_MercuryObject_StopTweening, MercuryObjectFactory::GetInstance().RegisterFunction( &PS_MercuryObject_StopTweening, "MercuryObject", "StopTweening" ); )
EXPORTPREFIX void HGEXPORT MercuryObject_StopTweening( void * pThs )
{
    ((MercuryObject*)pThs)->Tweening.StopTweening(); 
} EXPORTSUFFIX


PSElement PS_MercuryObject_AddCommand( MercuryCommandHandler * pThs, const PStack & pParameters )
{
    ((MercuryObject*)pThs)->Tweening.AddCommand( pParameters.PeekItem(0), (MercuryTweenState::SPACE)(int)pParameters.PeekItem(1), pParameters.PeekItem(2) );
    return PSElement();
}
RUN_STATEMENT_AT_BOOT( REGISTER_MercuryObject_AddCommand, MercuryObjectFactory::GetInstance().RegisterFunction( &PS_MercuryObject_AddCommand, "MercuryObject", "AddCommand" ); )
EXPORTPREFIX void HGEXPORT MercuryObject_AddCommand( void * pThs, const char * p1, int p2, const char * p3 )
{ 
    ((MercuryObject*)pThs)->Tweening.AddCommand( p1, (MercuryTweenState::SPACE) p2, p3 );
} EXPORTSUFFIX


void MercuryObject::SetName( const MString& name )
{
    OBJECTREGISTER.Unregister( m_name );
    m_name=name;
    OBJECTREGISTER.Register( this, m_name );
}

bool MercuryObject::ReplaceObject(MercuryObject* object, MercuryObject* newobject)
{
    ASSERT(object->m_initalized);

    FOREACH_Object(m_objects, i)
        if (i->pObject == object)
        {
            i->pObject->SetParentObject(NULL);
            i->pObject = newobject;

            i->pObject->SetParentObject(this);
            //I think we can do the sorting on insert in log(n)
            SortDrawOrder();
            //child needs to inheret colors from parent
            i->pObject->CalculateRealColor();
            return true;
        }

    return false;
}

bool MercuryObject::RemoveObject(MercuryObject* object, bool bAllowDelete )
{
    FOREACH_Object(m_objects, i)
        if (i->pObject == object)
        {
            i->pObject->SetParentObject(NULL);

            if (i->bAutoDelete && bAllowDelete && !m_bClone )
                SAFE_DELETE( i->pObject );

            i->pObject = NULL;
            m_objects.erase(i);
            return true;
        }

    return false;
}

void MercuryObject::CalculateRealColor()
{
    m_realColor = m_modColor;

    if (m_parentObject != NULL)
        m_realColor *= ((MercuryObject*)m_parentObject)->m_realColor;

    m_finalMaterial = m_realColor;

    if (m_pMaterial != NULL)
        m_finalMaterial *= *m_pMaterial;

    //Calculate color recursively
    FOREACH_Object(m_objects, child)
        child->pObject->CalculateRealColor();
}

MercuryObject * MercuryObject::Spawn( const MString & sClass, const MString & sName, PROJECTIONTYPE projection )
{
    MercuryObject * pObject = MercuryObjectFactory::GetInstance().GenerateObject( sClass, sName );
    if ( pObject == NULL )
        return false;

    pObject->Init();
    
    AddObject( pObject, true );
    return pObject;
}

MercuryObjectRegister::MercuryObjectRegister()
:NOTFOUND(-5280) //Charles's magic number >:-(
{
    if ( !MESSAGEMAN )
        MESSAGEMAN = new MercuryMessageManager;
    MESSAGEMAN->Subscribe( "ObjectStopTweening", MercuryCallback( SendCompiledMessage, (void*)1 ) );
    MESSAGEMAN->Subscribe( "ObjectFinishTweening", MercuryCallback( SendCompiledMessage, (void*)2 ) );
    MESSAGEMAN->Subscribe( "ObjectAddCommand", MercuryCallback( SendCompiledMessage, (void*)3 ) );
    MESSAGEMAN->Subscribe( "LogAllObjects", MercuryCallback( SendCompiledMessage, (void*)4 ) );
}

void MercuryObjectRegister::Register( MercuryObject * obj, const MString & name )
{
    m_mObjects[name] = obj;
    if ( GetCountOfObject( name ) == NOTFOUND )
        m_mObjectCounts[name]=1;
    else
        ++m_mObjectCounts[name];
}

void MercuryObjectRegister::Unregister( const MString & name )
{
    if ( --m_mObjectCounts[name] == 0 )
        m_mObjectCounts.remove( name );
    m_mObjects.remove( name );
}

MercuryObject * MercuryObjectRegister::GetObjectFromName( const MString & name )
{
    MercuryObject ** ret = m_mObjects.get( name );
    if( ret )
        return *ret;
    else
        return NULL;
}

void MercuryObjectRegister::SendCompiledMessage( const MString &message, void * data, PStack & info )
{
    switch ( (MVPtr)data )
    {
    case 4:
        {
            LOG.Info( "Logging all currently created objects." );
            LOG.Info( ssprintf( "Current noname allocations: %d", GetCountOfObject( "" ) ) );
            LOG.Info( "Memory Address:ObjectName Count" );
            MVector< MString > vNames;
            OBJECTREGISTER.m_mObjects.VectorIndicies( vNames );
            for( unsigned int i = 0; i < vNames.size(); i++ )
                LOG.Info( ssprintf( "%X:%s  %d", OBJECTREGISTER.m_mObjects[vNames[i]], vNames[i].c_str(), GetCountOfObject( vNames[i] ) ) );
        }
        return;
    }

    MString sObjectName = info.PopItem().GetValueS();
    MercuryObject * res;

    res = OBJECTREGISTER.GetObjectFromName( sObjectName );

    if ( !res )
        return;

    switch ( (MVPtr)data )
    {
    case 1:
        res->Tweening.StopTweening();
        break;
    case 2:
        res->Tweening.FinishTweening();
        break;
    case 3:
        res->Tweening.AddCommand( info.PopItem().GetValueS() );
        break;
    }
}

int MercuryObjectRegister::GetCountOfObject( const MString & name )
{
    if( m_mObjectCounts.get( name ) )
        return *(m_mObjectCounts.get( name ));
    else
        return 0;
}

void MercuryObjectRegister::ShutDown()
{
    m_mObjects.clear();
    m_mObjectCounts.clear();
}
long HGEXPORT GetObjectByName( const char * sName )
{
    return (long)OBJECTREGISTER.GetObjectFromName( sName );
}

REGISTER_OBJECT_TYPE( MercuryObject );

MHash< MercuryObject * >    MercuryObjectRegister::m_mObjects;
MHash< int >                MercuryObjectRegister::m_mObjectCounts;

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