LightSourceManager.cpp

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

#include <PVLE/3D/LightSourceManager.h>
#include <PVLE/Util/Math.h>

#include <boost/integer_traits.hpp>

//const LightSourceManager::Priority MIN_PRIORITY = boost::integer_traits<LightSourceManager::Priority>::const_min;
//const LightSourceManager::Priority MAX_PRIORITY = boost::integer_traits<LightSourceManager::Priority>::const_max;
const LightSourceManager::Priority MIN_PRIORITY = std::numeric_limits<LightSourceManager::Priority>::is_integer ? (std::numeric_limits<LightSourceManager::Priority>::min)() : -(std::numeric_limits<LightSourceManager::Priority>::max)();
const LightSourceManager::Priority MAX_PRIORITY = (std::numeric_limits<LightSourceManager::Priority>::max)();

UINT LightSourceManager::request(osg::Referenced * pNewUser, Priority priority, LightSourceUserCallback * pUserCB, bool enqueue) {
    // Check for available light
    Priority minPriority = MAX_PRIORITY;
    User * pMinPriorityUser = NULL;
    UINT minPriorityLightNumber = UINT_MAX;
    for(UINT i=firstManagedLight; i<lastManagedLight; ++i) {
        User & user = users[i];
        if (user.check()) {
            // Not available
            clampu(minPriority, user.priority);
            pMinPriorityUser = &user;
            minPriorityLightNumber = i;
            continue;
        }

        // Use the available light
        user.pUserObject = pNewUser;
        user.priority = priority;
        user.pUserCB = pUserCB;
        return i;       // Success
    }

    // If no light available but a light of lower priority exists, then exchange
    if (pMinPriorityUser && minPriority < priority) {
        // Delete old user
        unManage(minPriorityLightNumber, true);
        // Assign new one
        pMinPriorityUser->pUserObject = pNewUser;
        pMinPriorityUser->priority = priority;
        pMinPriorityUser->pUserCB = pUserCB;
        return minPriorityLightNumber;      // Success
    }

    // Else enqueue the user
    if (enqueue) doEnqueue(pNewUser, priority, pUserCB);
    return UINT_MAX;
}


void LightSourceManager::doEnqueue(osg::Referenced * pNewUser, Priority priority, LightSourceUserCallback * pUserCB) {
    ASSERT(pUserCB);            // You cannot be enqueued if you don't have a callback for handling the case where a light becomes available.
    if (!pUserCB) return;       // In case the ASSERT() is commented out

    cleanQueue();
    User tmpUser;
    tmpUser.pUserObject = pNewUser;
    tmpUser.priority = priority;
    tmpUser.pUserCB = pUserCB;
    usersQueue.push_back(tmpUser);
}


void LightSourceManager::remove(osg::Referenced * pUserObject) {
    // Normal users
    for(UINT i=firstManagedLight; i<lastManagedLight; ++i) {
        User & user = users[i];
        if (!user.check()) lightAvailable(&user);       // Clean if necessary
        else if (pUserObject == user.pUserObject.get()) {
            unManage(i, false);
            lightAvailable(i);
            return;
        }
    }

    // Enqueued users
    for(std::vector<User>::iterator it=usersQueue.begin(), itEnd=usersQueue.end(); it!=itEnd; ++it) {
        // Clean if necessary
        if (!it->check()) {
            it = usersQueue.erase(it);
            continue;
        }
        // Remove if user objects matches
        if (it->pUserObject == pUserObject) {
            if (it->pUserCB.valid()) it->pUserCB->onUserDropped(this, it->pUserObject.get());
            it = usersQueue.erase(it);
            return;
        }
    }

    THROW_TRACED_EXCEPTION("User object not found");
}


void LightSourceManager::clear() {
    for(UINT i=firstManagedLight; i<lastManagedLight; ++i) {
        if (users[i].check()) unManage(i, false);
    }
    for(std::vector<User>::iterator it=usersQueue.begin(), itEnd=usersQueue.end(); it!=itEnd; ++it) {
        if (!it->check() && it->pUserCB.valid()) it->pUserCB->onUserDropped(this, it->pUserObject.get());
    }
    usersQueue.clear();
}


void LightSourceManager::checkForAvailableLights() {
    if (usersQueue.empty()) return;     // Noone requested a light.
    
    std::vector<User>::iterator itBestCandidate = usersQueue.end();
    for(UINT i=firstManagedLight; i<lastManagedLight; ++i) {
        User & user = users[i];
        // Check for empty users
        if (!user.check()) {
            lightAvailable(i);
            if (usersQueue.empty()) return;     // No more ?
        } else {
            // Check for lower priority users
            if (itBestCandidate == usersQueue.end()) {
                // No best candidate computed, or best candidate has been moved to active users.
                itBestCandidate = getBestEnqueuedCandidate();
            }
            if (itBestCandidate != usersQueue.end() && user.priority < itBestCandidate->priority) {
                unManage(i, true);
                //lightAvailable(i, itBestCandidate);       // DON'T CALL ! unManage() changes the list, and thus the iterator is not useable anymore.
                lightAvailable(i);
                itBestCandidate = usersQueue.end();     // Candidate has been moved.
            }

            if (usersQueue.empty()) return;     // No more ?
        }
    }
}


void LightSourceManager::cleanQueue() {
    for(std::vector<User>::iterator it=usersQueue.begin(), itEnd=usersQueue.end(); it!=itEnd; ++it) {
        if (!it->check()) it = usersQueue.erase(it);
    }
}


LightSourceManager::User * LightSourceManager::getUser(const osg::Referenced * pUserObject) {
    // Normal users
    for(UINT i=firstManagedLight; i<lastManagedLight; ++i) {
        User & user = users[i];
        if (!user.check()) lightAvailable(&user);       // Clean if necessary
        else if (pUserObject == user.pUserObject.get()) return &user;
    }

    // Enqueued users
    cleanQueue();       // No need to clean queue if found in normal user (so this call is not on top of the mehtod).
    BOOST_FOREACH(User & user, usersQueue) {
        ASSERT(user.check());
        if (pUserObject == user.pUserObject.get()) return &user;
    }

    THROW_TRACED_EXCEPTION("User object not found");
}


const LightSourceManager::User * LightSourceManager::getUser(const osg::Referenced * pUserObject) const {
    // Normal users
    for(UINT i=firstManagedLight; i<lastManagedLight; ++i) {
        const User & user = users[i];
        if (!user.pUserObject.valid()) continue;        // No clean up possible in a const method
        else if (pUserObject == user.pUserObject.get()) return &user;
    }

    // Enqueued users
    BOOST_FOREACH(const User & user, usersQueue) {
        ASSERT(user.pUserObject.valid());
        if (pUserObject == user.pUserObject.get()) return &user;
    }

    THROW_TRACED_EXCEPTION("User object not found");
}


void LightSourceManager::lightAvailable(UINT lightNumber) {
    if (usersQueue.empty()) return;     // Noone requested a light.
    std::vector<User>::iterator it = getBestEnqueuedCandidate();
    lightAvailable(lightNumber, it);
}

void LightSourceManager::lightAvailable(UINT lightNumber, std::vector<User>::iterator & itBestCandidate) {
    if (usersQueue.empty()) return;     // Noone requested a light.

    ASSERT(itBestCandidate != usersQueue.end());
    // Assign new user
    User & newUser = users[lightNumber];
    newUser = *itBestCandidate;
    // Remove it from the queue
    usersQueue.erase(itBestCandidate);
    // Tell it that it has a new light
    ASSERT(newUser.pUserCB.valid());
    if (!newUser.pUserCB->onSourceAvailable(this, newUser.pUserObject.get(), lightNumber)) {
        // The candidate rejected the offer. Drop it and ask another one.
        newUser.reset();
        lightAvailable(lightNumber);
    }
}


std::vector<LightSourceManager::User>::iterator LightSourceManager::getBestEnqueuedCandidate() {
    std::vector<User>::iterator itBestCandidate = usersQueue.end();
    Priority maxPriority = MIN_PRIORITY;
    for(std::vector<User>::iterator it=usersQueue.begin(), itEnd=usersQueue.end(); it!=itEnd; ++it) {
        // Clean if necessary
        if (!it->check()) {
            it = usersQueue.erase(it);
            continue;
        }
        ASSERT(it->pUserCB.valid());        // Enqueued users must have a callback
        //if (!it->pUserCB.valid()) {
        //  if (it->pUserCB.valid()) it->pUserCB->onUserDropped(this, it->pUserObject.get());
        //  it = usersQueue.erase(it);
        //  continue;
        //}

        // Check for highest priority
        if (itBestCandidate == usersQueue.end() || it->priority > maxPriority) {
            maxPriority = it->priority;
            itBestCandidate = it;
        }
    }
    return itBestCandidate;
}


void LightSourceManager::setManagedLights(UINT _firstManagedLight, UINT _lastManagedLight) {
    ASSERT(_firstManagedLight >= 0);
    ASSERT(_lastManagedLight  <= MAX_LIGHT);
    ASSERT(_firstManagedLight <_lastManagedLight);

    // Remove (or enqueue) users of non-managed light sources
    for(UINT i=firstManagedLight; i<_firstManagedLight; ++i) unManage(i, true);     // [oldFirst; newFirst[
    for(UINT i=_lastManagedLight; i<lastManagedLight;   ++i) unManage(i, true);     // [newLast ; oldLast [

    // Tell potential users of newly available sources
    if (!usersQueue.empty()) {
        for(UINT i=_firstManagedLight; i<firstManagedLight; ++i) {      // [newFirst; oldFirst[
            users[i].reset();       // Should not be useful, but that's safe. Don't call unManage() here since it's kind of "unallocated".
            lightAvailable(i);
        }
        for(UINT i=lastManagedLight;   i<_lastManagedLight; ++i) {      // [oldLast ; newLast [
            users[i].reset();       // Should not be useful, but that's safe. Don't call unManage() here since it's kind of "unallocated".
            lightAvailable(i);
        }
    }

    firstManagedLight = _firstManagedLight;
    lastManagedLight  = _lastManagedLight;
}


void LightSourceManager::unManage(UINT i, bool canEnqueue) {
    User & user = users[i];
    if (!user.check()) return;
    if (user.pUserCB.valid()) {
        if (user.pUserCB->onSourceTaken(this, user.pUserObject.get(), i)) {
            // User asked to be enqueued
            if (canEnqueue) doEnqueue(&user);
        }
        if (!canEnqueue) user.pUserCB->onUserDropped(this, user.pUserObject.get());
    }
    user.reset();
}

---