Object.h

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library 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
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSG_OBJECT
#define OSG_OBJECT 1

#include <osg/Referenced>
#include <osg/CopyOp>
#include <osg/ref_ptr>
#include <osg/Notify>

#include <string>
#include <vector>

namespace osg {

// forward declare
class State;
class UserDataContainer;
class Node;
class NodeVisitor;
class StateAttribute;
class Uniform;

#define _ADDQUOTES(def) #def
#define ADDQUOTES(def) _ADDQUOTES(def)

#define META_Object(library,name) \
        virtual osg::Object* cloneType() const { return new name (); } \
        virtual osg::Object* clone(const osg::CopyOp& copyop) const { return new name (*this,copyop); } \
        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const name *>(obj)!=NULL; } \
        virtual const char* libraryName() const { return #library; }\
        virtual const char* className() const { return #name; }

#define OSG_INIT_SINGLETON_PROXY(ProxyName, Func) static struct ProxyName{ ProxyName() { Func; } } s_##ProxyName;

class OSG_EXPORT Object : public Referenced
{
    public:


        inline Object():Referenced(),_dataVariance(UNSPECIFIED), _userDataContainer(0) {}

        inline explicit Object(bool threadSafeRefUnref):Referenced(threadSafeRefUnref),_dataVariance(UNSPECIFIED),_userDataContainer(0) {}

        Object(const Object&,const CopyOp& copyop=CopyOp::SHALLOW_COPY);

        virtual Object* cloneType() const = 0;

        virtual Object* clone(const CopyOp&) const = 0;

        virtual bool isSameKindAs(const Object*) const { return true; }


        virtual const char* libraryName() const = 0;

        virtual const char* className() const = 0;

        std::string getCompoundClassName() const { return std::string(libraryName()) + std::string("::") + std::string(className()); }
        
        
        virtual Node* asNode() { return 0; }

        virtual const Node* asNode() const { return 0; }

        virtual NodeVisitor* asNodeVisitor() { return 0; }

        virtual const NodeVisitor* asNodeVisitor() const { return 0; }

        virtual StateAttribute* asStateAttribute() { return 0; }

        virtual const StateAttribute* asStateAttribute() const { return 0; }

        virtual Uniform* asUniform() { return 0; }

        virtual const Uniform* asUniform() const { return 0; }


        virtual void setThreadSafeRefUnref(bool threadSafe);

        virtual void setName( const std::string& name ) { _name = name; }

        inline void setName( const char* name )
        {
            if (name) setName(std::string(name));
            else setName(std::string());
        }

        inline const std::string& getName() const { return _name; }


        enum DataVariance
        {
            DYNAMIC,
            STATIC,
            UNSPECIFIED
        };

        inline void setDataVariance(DataVariance dv) { _dataVariance = dv; }

        inline DataVariance getDataVariance() const { return _dataVariance; }

        virtual void computeDataVariance() {}


        void setUserDataContainer(osg::UserDataContainer* udc);

        osg::UserDataContainer* getUserDataContainer() { return _userDataContainer; }

        const osg::UserDataContainer* getUserDataContainer() const { return _userDataContainer; }

        osg::UserDataContainer* getOrCreateUserDataContainer();


        virtual void setUserData(Referenced* obj);

        virtual Referenced* getUserData();

        virtual const Referenced* getUserData() const;



        template<typename T>
        bool getUserValue(const std::string& name, T& value) const;

        template<typename T>
        void setUserValue(const std::string& name, const T& value);


        virtual void resizeGLObjectBuffers(unsigned int /*maxSize*/) {}

        virtual void releaseGLObjects(osg::State* = 0) const {}


    protected:

        virtual ~Object();

        std::string _name;
        DataVariance _dataVariance;

        osg::UserDataContainer* _userDataContainer;

    private:

        Object& operator = (const Object&) { return *this; }
};

template<typename T>
T* clone(const T* t, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY)
{
    if (t)
    {
        osg::ref_ptr<osg::Object> obj = t->clone(copyop);

        T* ptr = dynamic_cast<T*>(obj.get());
        if (ptr)
        {
            obj.release();
            return ptr;
        }
        else
        {
            OSG_WARN<<"Warning: osg::clone(const T*, osg::CopyOp&) cloned object not of type T, returning NULL."<<std::endl;
            return 0;
        }
    }
    else
    {
        OSG_WARN<<"Warning: osg::clone(const T*, osg::CopyOp&) passed null object to clone, returning NULL."<<std::endl;
        return 0;
    }
}

template<typename T>
T* clone(const T* t, const std::string& name, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY)
{
    T* newObject = osg::clone(t, copyop);
    if (newObject)
    {
        newObject->setName(name);
        return newObject;
    }
    else
    {
        OSG_WARN<<"Warning: osg::clone(const T*, const std::string&, const osg::CopyOp) passed null object to clone, returning NULL."<<std::endl;
        return 0;
    }
}

template<typename T>
T* cloneType(const T* t)
{
    if (t)
    {
        osg::ref_ptr<osg::Object> obj = t->cloneType();

        T* ptr = dynamic_cast<T*>(obj.get());
        if (ptr)
        {
            obj.release();
            return ptr;
        }
        else
        {
            OSG_WARN<<"Warning: osg::cloneType(const T*) cloned object not of type T, returning NULL."<<std::endl;
            return 0;
        }
    }
    else
    {
        OSG_WARN<<"Warning: osg::cloneType(const T*) passed null object to clone, returning NULL."<<std::endl;
        return 0;
    }
}

class DummyObject : public osg::Object
{
public:
    DummyObject() {}
    DummyObject(const DummyObject&, const osg::CopyOp&) {}
    META_Object(osg, DummyObject)
protected:
    virtual ~DummyObject() {}
};



}

#endif