MercuryObject.h

Go to the documentation of this file.

#ifndef MERCURYOBJECT_H
#define MERCURYOBJECT_H

#include "MercuryObjectCommands.h"
#include "MercuryMessages.h"
#include "MercuryDisplayTypes.h"
#include "MercuryMaterial.h"
#include "MercuryObjectBase.h"
#include "MercuryUtil.h"
#include "MercuryGLState.h"

class MercuryPoly;

enum State
{
    UNLOADED = 0, //If we are not loaded, we are probably expecting a callback
    LOADED
};

enum LightState
{
    LS_IGNORE = 0,
    LS_ENABLE,
    LS_DISABLE
};

class MercuryObject : public MercuryObjectBase, public MercuryMessageHandler
{
public:
    struct ParentHoldPair
    {
        ParentHoldPair(MercuryObject* o = NULL) : pObject(o) {};
        inline bool operator<(const ParentHoldPair& r) const { return *pObject < *(r.pObject); }
        inline bool operator>=(const ParentHoldPair& r) const { return *pObject >= *(r.pObject); }

        MercuryObject * pObject;
        bool            bAutoDelete;
    };

    enum HALIGN
    {
        LEFT = 0,
        CENTER,
        RIGHT
    };
    enum VALIGN
    {
        TOP = 0,
        VCENTER,  //VCENTER to avoid confliction with HALIGN CENTER
        BOTTOM
    };
    MercuryObject();
    MercuryObject( const MString & name );
    virtual ~MercuryObject();
    virtual void Init();

    void CalculateRealColor();
    void SetName(const MString& name);

    //overloaded for MercuryScreen
    virtual void SortDrawOrder();
    virtual void AddObject(MercuryObject* object, bool bParentDelete = false);
    virtual bool RemoveObject(MercuryObject* object, bool bAllowDelete = true );
    virtual bool ReplaceObject(MercuryObject* object, MercuryObject* newobject);

    inline void Destroy() { m_bMarkedForDestroy = true; }
    inline void SetMaterial(MercuryMaterial* material) { ASSERT(material); m_pMaterial = material; CalculateRealColor();}
    inline void SetDiffuse( const MercuryColor & c ) { m_modColor.m_diffuse = c; CalculateRealColor(); }
    inline void SetDiffusef( float r, float g, float b, float a ) { m_modColor.m_diffuse = MercuryColor(r,g,b,a); }
    inline void SetEmissive( const MercuryColor & c ) { m_modColor.m_emissive = c; CalculateRealColor(); }
    inline void SetEmissivef( float r, float g, float b, float a ) { m_modColor.m_emissive = MercuryColor(r,g,b,a); }
    inline void SetSpecular( const MercuryColor & c ) { m_modColor.m_specular = c; CalculateRealColor(); }
    inline void SetSpecularf( float r, float g, float b, float a ) { m_modColor.m_specular = MercuryColor(r,g,b,a); }
    inline void SetAmbient( const MercuryColor & c ) { m_modColor.m_ambient = c; CalculateRealColor(); }
    inline void SetAmbientf( float r, float g, float b, float a ) { m_modColor.m_ambient = MercuryColor(r,g,b,a); }
    inline const MString& GetName() const { return m_name; }
    inline const MercuryMaterial* GetMaterial() const { return m_pMaterial; }
    inline const MercuryMaterial& GetFinalMaterial() const { return m_finalMaterial; }
    inline const MercuryColor& GetDiffuse( ) { return m_modColor.m_diffuse; }
    inline const MercuryColor& GetEmissive( ) { return m_modColor.m_emissive; }
    inline const MercuryColor& GetSpecular( ) { return m_modColor.m_specular; }
    inline const MercuryColor& GetAmbient( ) { return m_modColor.m_ambient; }
    void GetDiffusef( float & r, float & g, float & b, float & a );
    virtual MercuryObject* Spawn( const MString & sClass, const MString & sName, PROJECTIONTYPE projection = PERSPECTIVE );
    unsigned int GetNumChildren() const { return m_objects.size(); }

    /*  It does not currently make sense to align most objects because we do not know
        the width and the height of most objects. However, in the future we may have the
        ability to know the with and the height of objects, thus making it possible to
        align any object. */
    virtual void SetHAlignment(HALIGN alignment) { m_halignment = alignment; }
    inline HALIGN GetHAlignment() const { return m_halignment; }
    virtual void SetVAlignment(VALIGN alignment) { m_valignment = alignment; }
    inline VALIGN GetVAlignment() const { return m_valignment; }

    /* Objects do not have to be removed when the parent is destroying
        because vector will do it for us */


    virtual void Prerender();
    virtual void Render();
    virtual void CustomRender();
    void ComputeCull();

    inline bool IsCulled() const { return m_culled; }

    virtual void Update( const float dTime );
    virtual void SetDrawOrder(int order);

    MercuryTweenState   Tweening;
    MDeque<ParentHoldPair> m_objects;

    virtual void Draw() {};
    CLASS_RTTI( MercuryObject, MercuryMessageHandler );

    virtual void Clonize() { m_bClone = true; Tweening.AttachToObject( this ); }

    inline bool IsInitalized() const { return m_initalized; }

    inline float GetScaledRadius() const { return m_fVisRadius*GetScale().GetBiggestElement(); }
    inline State GetState() const { return m_state; }
    inline MercuryGLState& GetGLState() { return m_glState; }

    void ComputeInheritedGLState();
    inline MercuryGLState GetInheritedGLState() { return m_inheretedGLState; }

protected:
    bool m_bClone;
    bool m_bMarkedForDestroy;
    unsigned int m_polys;
    MString m_name;

    int m_width, m_height;

    bool m_drawable;
    bool m_culled;

    MercuryMaterial m_finalMaterial;
    MercuryMaterial* m_pMaterial;   //renamed to keep the compiler from becomming confused

    /*  State is used to prevent rendering of objects who have not been loaded
        We don't want to use hide for this, because hide can be modified outside
        of this class. */
    State m_state;
    MercuryGLState m_glState;
    bool m_initalized;
private:

    MercuryMaterial m_modColor; //Modifier color (from tweens and stuff)
    MercuryMaterial m_realColor; //Inherited and base combined.

    //stuff for alignment
    HALIGN m_halignment;
    VALIGN m_valignment;

    MercuryGLState m_inheretedGLState;
};

template<typename T>
void TSortDrawOrder(MDeque<T>& Xdeque)
{
    MDequeIterator< T > child = Xdeque.begin();
    MDequeIterator< T > tmp;

    if ( Xdeque.empty() )
        return;

    while ( true )
    {
        //If we see a swapped pair, start swapping
        child = Xdeque.begin();
        for (++child; child != Xdeque.end(); ++child) //starts one after begin
        {
            tmp = child;
            --tmp; //One before child
            if ( (*child) < (*tmp) )
                break;
        }

        if ( child == Xdeque.end() )
            return;

        for ( ; child != Xdeque.begin(); --child )
        {
            tmp = child;
            --tmp;//one before child

            //Check to see if we're in order
            if ( (*child) >= (*tmp) )
                break;

            Xdeque.swap( child, tmp );
            child = tmp;
        }
    }
}


#define FOREACH_Object( x, obj ) for( MDequeIterator<MercuryObject::ParentHoldPair> obj = x.begin();    obj != x.end(); ++obj)
#define FOREACH_CONST_Object( x, obj ) for( MDequeIterator<MercuryObject::ParentHoldPair> obj = x.begin();  obj != x.end(); ++obj)


class MercuryObjectRegister
{
public:
    MercuryObjectRegister();
    void Register( MercuryObject * obj, const MString & name );
    void Unregister( const MString & name );
    MercuryObject * GetObjectFromName( const MString & name );
    static void SendCompiledMessage( const MString &message, void * data, PStack & info );
    static int GetCountOfObject( const MString & name );
    void ShutDown();
private:
    const int NOTFOUND;
    static MHash< MercuryObject * > m_mObjects;
    static MHash< int >             m_mObjectCounts;
};

extern MercuryObjectRegister    OBJECTREGISTER;

long HGEXPORT GetObjectByName( const char * sName ); 

#endif

/* 
 * 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