LightSourceManager.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// 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 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// 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.
//
//-----------------------------------------------------------------------------------

#ifndef _3D_LIGHT_SOURCE_MANAGER_H
#define _3D_LIGHT_SOURCE_MANAGER_H


#include <PVLE/Export.h>
#include <PVLE/Util/Util.h>
#include <PVLE/Util/Callback.h>
#include <PVLE/Util/Singleton.h>
#include <osg/LightSource>
#include <osg/observer_ptr>
#include <boost/operators.hpp>
#include <vector>


class LightSourceManager;

class LightSourceUserCallback : public Util::Callback<LightSourceUserCallback> {
public:
    virtual bool onSourceTaken(LightSourceManager * pLightSourceManager, osg::Referenced * pUserObject, UINT lightNumber) {
        if (_nestedCallback.valid()) return _nestedCallback->onSourceTaken(pLightSourceManager, pUserObject, lightNumber);
        else return false;
    }

    virtual bool onSourceAvailable(LightSourceManager * pLightSourceManager, osg::Referenced * pUserObject, UINT lightNumber) =0;

    virtual void onUserDropped(LightSourceManager * pLightSourceManager, osg::Referenced * pUserObject) =0;
};



class PVLE_EXPORT LightSourceManager {
public:
    typedef float Priority;
    static const UINT MAX_LIGHT = 8;

    LightSourceManager(UINT _firstManagedLight = 0, UINT _lastManagedLight = MAX_LIGHT) : firstManagedLight(_firstManagedLight), lastManagedLight(_lastManagedLight) {
        //setManagedLights(_firstManagedLight, _lastManagedLight);
    }

    UINT request(osg::Referenced * pNewUser, Priority priority, LightSourceUserCallback * pUserCB = NULL, bool enqueue = false);

    //UINT requestTest(Priority priority) const;

    void remove(osg::Referenced * pUserObject);

    void clear();

    const LightSourceUserCallback * getUserCallback(const osg::Referenced * pUserObject) const { return getUser(pUserObject)->pUserCB.get(); }
    LightSourceUserCallback * getUserCallback(osg::Referenced * pUserObject) { return getUser(pUserObject)->pUserCB.get(); }
    void setUserCallback(osg::Referenced * pUserObject, LightSourceUserCallback * pUserCB) { getUser(pUserObject)->pUserCB = pUserCB; }

    void updatePriority(osg::Referenced * pUserObject, Priority newPriority) { getUser(pUserObject)->priority = newPriority; }

    void checkForAvailableLights();

    void setManagedLights(UINT _firstManagedLight, UINT _lastManagedLight);

protected:
    UINT firstManagedLight;
    UINT lastManagedLight;

    class User : public boost::totally_ordered<User> {
    public:
        User() : priority(0) {}
        //~User() { reset(); }

        osg::observer_ptr<osg::Referenced> pUserObject;     
        Priority priority;
        osg::ref_ptr<LightSourceUserCallback> pUserCB;      

        bool check() { if (pUserObject.valid()) return true; pUserCB = NULL; return false; }
        void reset() { pUserObject = NULL; pUserCB = NULL; }

        inline bool operator<(const User & u) const { return priority < u.priority; }
        inline bool operator==(const User & u) const { return priority == u.priority; }
        User & operator=(const User & u) {
            pUserObject = u.pUserObject;
            priority = u.priority;
            pUserCB = u.pUserCB;
            return *this;
        }
    };

    User users[MAX_LIGHT];

    User * getUser(const osg::Referenced * pUserObject);
    const User * getUser(const osg::Referenced * pUserObject) const;

    void lightAvailable(UINT lightNumber);
    void lightAvailable(UINT lightNumber, std::vector<User>::iterator & itBestCandidate);

    inline void lightAvailable(User * pEmptyUser) {
        int pos = pEmptyUser - users;
        ASSERT(pos>=0 && pos<MAX_LIGHT);
        lightAvailable(static_cast<UINT>(MAX_LIGHT));
    }
    //inline void lightAvailable(User * pEmptyUser , std::vector<User>::iterator itBestCandidate) { ... }

    //void cleanUsers();
    void cleanQueue();

    void doEnqueue(osg::Referenced * pNewUser, Priority priority, LightSourceUserCallback * pUserCB);
    inline void doEnqueue(User * pUserObject) { doEnqueue(pUserObject->pUserObject.get(), pUserObject->priority, pUserObject->pUserCB.get()); }

    void unManage(UINT i, bool canEnqueue);     
    std::vector<User>::iterator getBestEnqueuedCandidate();     

    std::vector<User> usersQueue;           
};



#endif  // _3D_LIGHT_SOURCE_MANAGER_H

---