ImpostorSprite.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_ImpostorSprite
#define OSG_ImpostorSprite 1

#include <osg/Vec2>
#include <osg/BoundingSphere>
#include <osg/Drawable>
#include <osg/AlphaFunc>
#include <osg/TexEnv>
#include <osg/Texture2D>
#include <osg/Camera>

#include <osgSim/Export>

namespace osgSim {

class Impostor;
class ImpostorSpriteManager;

class OSGSIM_EXPORT ImpostorSprite : public osg::Drawable
{
    public:

        ImpostorSprite();

        virtual osg::Object* cloneType() const { return new ImpostorSprite(); }

        virtual osg::Object* clone(const osg::CopyOp&) const { return new ImpostorSprite(); }
        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const ImpostorSprite*>(obj)!=NULL; }
        virtual const char* libraryName() const { return "osgSim"; }
        virtual const char* className() const { return "ImpostorSprite"; }

        void setParent(Impostor* parent) { _parent = parent; }

        Impostor* getParent() { return _parent; }

        const Impostor* getParent() const { return _parent; }

        inline void setStoredLocalEyePoint(const osg::Vec3& v) { _storedLocalEyePoint=v; }

        inline const osg::Vec3& getStoredLocalEyePoint() const { return _storedLocalEyePoint; }

        inline void setLastFrameUsed(unsigned int frameNumber) { _lastFrameUsed = frameNumber; }

        inline unsigned int getLastFrameUsed() const { return _lastFrameUsed; }


        inline osg::Vec3* getCoords() { return _coords; }

        inline const osg::Vec3* getCoords() const { return _coords; }



        inline osg::Vec2* getTexCoords() { return _texcoords; }

        inline const osg::Vec2* getTexCoords() const { return _texcoords; }

        inline osg::Vec3* getControlCoords() { return _controlcoords; }

        inline const osg::Vec3* getControlCoords() const { return _controlcoords; }


        float calcPixelError(const osg::Matrix& MVPW) const;

        void setTexture(osg::Texture2D* tex,int s,int t);
        osg::Texture2D* getTexture() { return _texture; }
        const osg::Texture2D* getTexture() const { return _texture; }

        int s() const { return _s; }
        int t() const { return _t; }

        virtual void drawImplementation(osg::RenderInfo& renderInfo) const;

        virtual bool supports(const Drawable::AttributeFunctor&) const { return true; }

        virtual void accept(Drawable::AttributeFunctor& af);

        virtual bool supports(const Drawable::ConstAttributeFunctor&) const { return true; }

        virtual void accept(Drawable::ConstAttributeFunctor& af) const;

        virtual bool supports(const osg::PrimitiveFunctor&) const { return true; }

        virtual void accept(osg::PrimitiveFunctor& pf) const;

        // for debugging purposes.
        osg::Vec4 _color;

        virtual osg::BoundingBox computeBoundingBox() const;

        void setCamera(osg::Camera* camera) { _camera = camera; }

        osg::Camera* getCamera() { return _camera.get(); }

        const osg::Camera* getCamera() const { return _camera.get(); }

    protected:

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

        virtual ~ImpostorSprite();

        Impostor* _parent;

        friend class osgSim::ImpostorSpriteManager;

        // camera node for doing the pre rendering.
        osg::ref_ptr<osg::Camera> _camera;

        // support for a double linked list managed by the
        // ImposotorSpriteManager.
        ImpostorSpriteManager*  _ism;
        ImpostorSprite*         _previous;
        ImpostorSprite*         _next;

        unsigned int _lastFrameUsed;

        osg::Vec3 _storedLocalEyePoint;

        osg::Vec3 _coords[4];
        osg::Vec2 _texcoords[4];
        osg::Vec3 _controlcoords[4];

        osg::Texture2D* _texture;
        int _s;
        int _t;


};

class OSGSIM_EXPORT ImpostorSpriteManager : public osg::Referenced
{
    public:

        ImpostorSpriteManager();

        bool empty() const { return _first==0; }

        ImpostorSprite* first() { return _first; }

        ImpostorSprite* last() { return _last; }

        void push_back(ImpostorSprite* is);

        void remove(ImpostorSprite* is);

        ImpostorSprite* createOrReuseImpostorSprite(int s,int t,unsigned int frameNumber);

        osg::StateSet* createOrReuseStateSet();

        void reset();

    protected:


        ~ImpostorSpriteManager();

        osg::ref_ptr<osg::TexEnv>       _texenv;
        osg::ref_ptr<osg::AlphaFunc>    _alphafunc;

        ImpostorSprite*                 _first;
        ImpostorSprite*                 _last;

        typedef std::vector< osg::ref_ptr<osg::StateSet> > StateSetList;
        StateSetList                    _stateSetList;
        unsigned int                    _reuseStateSetIndex;


};

}

#endif