SG_IObject.h

Go to the documentation of this file.

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef __SG_IOBJECT
#define __SG_IOBJECT

#include "SG_QList.h"
#include <vector>

// used for debugging: stage of the game engine main loop at which a Scenegraph modification is done
enum SG_Stage
{
    SG_STAGE_UNKNOWN = 0,
    SG_STAGE_NETWORK,
    SG_STAGE_NETWORK_UPDATE,
    SG_STAGE_PHYSICS1,
    SG_STAGE_PHYSICS1_UPDATE,
    SG_STAGE_CONTROLLER,
    SG_STAGE_CONTROLLER_UPDATE,
    SG_STAGE_ACTUATOR,
    SG_STAGE_ACTUATOR_UPDATE,
    SG_STAGE_ANIMATION_UPDATE,
    SG_STAGE_PHYSICS2,
    SG_STAGE_PHYSICS2_UPDATE,
    SG_STAGE_SCENE,
    SG_STAGE_RENDER,
    SG_STAGE_CONVERTER,
    SG_STAGE_CULLING,
    SG_STAGE_MAX
};

extern SG_Stage gSG_Stage;

inline void SG_SetActiveStage(SG_Stage stage)
{
    gSG_Stage = stage;
}
    


class SG_Controller;
class SG_IObject;

typedef std::vector<SG_Controller*> SGControllerList;

typedef void* (*SG_ReplicationNewCallback)(
    SG_IObject* sgobject,
    void*   clientobj,
    void*   clientinfo
);

typedef void* (*SG_DestructionNewCallback)(
    SG_IObject* sgobject,
    void*   clientobj,
    void*   clientinfo
);

typedef void  (*SG_UpdateTransformCallback)(
    SG_IObject* sgobject,
    void*   clientobj,
    void*   clientinfo
);

typedef bool  (*SG_ScheduleUpdateCallback)(
    SG_IObject* sgobject,
    void*   clientobj,
    void*   clientinfo
);

typedef bool  (*SG_RescheduleUpdateCallback)(
    SG_IObject* sgobject,
    void*   clientobj,
    void*   clientinfo
);


struct  SG_Callbacks
{
    SG_Callbacks(
    ):
        m_replicafunc(NULL),
        m_destructionfunc(NULL),
        m_updatefunc(NULL),
        m_schedulefunc(NULL),
        m_reschedulefunc(NULL)
    {
    };
        
    SG_Callbacks(
        SG_ReplicationNewCallback repfunc,
        SG_DestructionNewCallback destructfunc,
        SG_UpdateTransformCallback updatefunc,
        SG_ScheduleUpdateCallback schedulefunc,
        SG_RescheduleUpdateCallback reschedulefunc
    ): 
        m_replicafunc(repfunc),
        m_destructionfunc(destructfunc),
        m_updatefunc(updatefunc),
        m_schedulefunc(schedulefunc),
        m_reschedulefunc(reschedulefunc)
    {
    };

    SG_ReplicationNewCallback   m_replicafunc;
    SG_DestructionNewCallback   m_destructionfunc;
    SG_UpdateTransformCallback  m_updatefunc;
    SG_ScheduleUpdateCallback   m_schedulefunc;
    SG_RescheduleUpdateCallback m_reschedulefunc;
};

class SG_IObject : public SG_QList
{
private :

    void*   m_SGclientObject;
    void*   m_SGclientInfo;
    SG_Callbacks m_callbacks;
    SGControllerList    m_SGcontrollers;

public:
    virtual ~SG_IObject();


        void                
    AddSGController(
        SG_Controller* cont
    );

        void
    RemoveSGController(
        SG_Controller* cont
    );

        void                
    RemoveAllControllers(
    ); 


    SGControllerList& GetSGControllerList()
    { 
        return m_SGcontrollers; 
    }

    SG_Callbacks& GetCallBackFunctions()
    {
        return m_callbacks;
    }
    
    inline const void* GetSGClientObject() const    
    {
        return m_SGclientObject;
    }

    inline void* GetSGClientObject()
    { 
        return m_SGclientObject;
    }

    void SetSGClientObject(void* clientObject)
    {
        m_SGclientObject = clientObject;
    }


    /* needed for scene switching */
    inline const void* GetSGClientInfo() const
    {
        return m_SGclientInfo;
    }
    inline void* GetSGClientInfo()
    {
        return m_SGclientInfo;
    }
    void SetSGClientInfo(void* clientInfo)
    {
        m_SGclientInfo = clientInfo;
    }


    void SetControllerTime(double time);
    
    virtual 
        void        
    Destruct(
    ) = 0;

protected :

        bool
    ActivateReplicationCallback(
        SG_IObject *replica
    )
    {
        if (m_callbacks.m_replicafunc)
        {
            // Call client provided replication func
            if (m_callbacks.m_replicafunc(replica,m_SGclientObject,m_SGclientInfo) == NULL)
                return false;
        }
        return true;
    }


        void
    ActivateDestructionCallback(
    )
    {
        if (m_callbacks.m_destructionfunc)
        {
            // Call client provided destruction function on this!
            m_callbacks.m_destructionfunc(this,m_SGclientObject,m_SGclientInfo);
        }
        else
        {
            // no callback but must still destroy the node to avoid memory leak
            delete this;
        }
    }
    
        void
    ActivateUpdateTransformCallback(
    )
    {
        if (m_callbacks.m_updatefunc)
        {
            // Call client provided update func.
            m_callbacks.m_updatefunc(this, m_SGclientObject, m_SGclientInfo);
        }
    }

        bool
    ActivateScheduleUpdateCallback(
    )
    {
        // HACK, this check assumes that the scheduled nodes are put on a DList (see SG_Node.h)
        // The early check on Empty() allows up to avoid calling the callback function
        // when the node is already scheduled for update.
        if (Empty() && m_callbacks.m_schedulefunc)
        {
            // Call client provided update func.
            return m_callbacks.m_schedulefunc(this, m_SGclientObject, m_SGclientInfo);
        }
        return false;
    }

        void
    ActivateRecheduleUpdateCallback(
    )
    {
        if (m_callbacks.m_reschedulefunc)
        {
            // Call client provided update func.
            m_callbacks.m_reschedulefunc(this, m_SGclientObject, m_SGclientInfo);
        }
    }


    SG_IObject(
        void* clientobj,
        void* clientinfo,
        SG_Callbacks& callbacks
    );

    SG_IObject(
        const SG_IObject &other
    );


#ifdef WITH_CXX_GUARDEDALLOC
public:
    void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:SG_IObject"); }
    void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};

#endif //__SG_IOBJECT