VRS - The Virtual Rendering System

version 3.3

statehandler.h

Go to the documentation of this file.

/******************************************************************************
* VRS - The Virtual Rendering System
* Copyright (C) 2003 Computer Graphics Systems Group at the 
* Hasso-Plattner-Institute (HPI), Potsdam, Germany.
*
* This  library  is  free  software; you can redistribute it and/or  modify it
* under the terms of the GNU Lesser General Public  License  as  published  by
* the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
* your option) any later version. 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
* GNU Lesser General Public License for more details. You should have received
* a copy of the GNU Lesser+ General Public License along with this library; if
* not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA, 02111-1307, USA.
******************************************************************************/

#ifndef VRS_SG_STATEHANDLER_H
#define VRS_SG_STATEHANDLER_H

#include <map>
#include <functional>

#include <vrs/texture.h>
#include <vrs/container/dictionary.h>
#include <vrs/opengl/textureunitselectorgl.h>
#include <vrs/opengl/textureunitsettinggl.h>
#include <vrs/opengl/shapematerialgl.h>

namespace std {
        using VRS::SO;
        using VRS::ShapeMaterialGL;

        template<> struct less<SO<ShapeMaterialGL> > : public binary_function<SO<ShapeMaterialGL>, SO<ShapeMaterialGL>, bool> {
                bool operator()(const SO<ShapeMaterialGL> left, const SO<ShapeMaterialGL> right) const {
                        if(     (left->getPerVertexColor() < right->getPerVertexColor()) ||
                                (left->getSpecular() < right->getSpecular()) ||
                                (left->getShininess() < right->getShininess()) || 
                                (left->getVertexColorMapping() < right->getVertexColorMapping()) ||
                                (left->getAmbient() < right->getAmbient()) ||
                                (left->getDiffuse() < right->getDiffuse()) ||
                                (left->getEmission() < right->getEmission()))
                                return true;
                        else
                                return false;
                }
        };
}

namespace VRS {

class AbstractStateHandler : public SharedObj{
public:
        virtual AbstractStateHandler* create(void) = 0;
        virtual void reset(void) = 0;
        virtual void setSuccessor(AbstractStateHandler* successor) {
                successor_ = successor;
        }

        virtual void setState(RenderObj* state) = 0;

        virtual void pushState(void) = 0;

        virtual void popState(void) = 0;

        virtual void collectShape(unsigned int index) = 0;

        virtual void createSortedScene(SO<SceneThing> root, SO<Array<unsigned int> > shapeIndices, SO<Array<SO<SharedObj> > > shapes) = 0;

protected:
        SO<AbstractStateHandler> successor_;
};

template<class T>
class StateHandler : public AbstractStateHandler {
public:
        StateHandler(void) : stateStack_(new Stack<SO<T> >) {
                stateStack_->push(new T);
        }

        virtual AbstractStateHandler* create(void) {
                return new StateHandler<T>;
        }

        virtual void reset(void) {
                stateStack_->clear();
                stateShapes_.clear();
        }

        virtual void setState(RenderObj* state) {
                if(state->isA(T::ClassNameVRS())) {
                        stateStack_->pop();
                        SO<T> type = VRS_GuardedCast(T, state);
                        stateStack_->push(type);
                }
        }

        virtual void pushState(void) {
                stateStack_->push(stateStack_->top());
        }

        virtual void popState(void) {
                stateStack_->pop();
        }

        virtual void collectShape(unsigned int index) {
                typename std::map<SO<T>, SO<Array<unsigned int> > >::iterator iter = stateShapes_.find(stateStack_->top());

                if(iter == stateShapes_.end()) {
                        stateShapes_[stateStack_->top()] = new Array<unsigned int>;
                        stateShapes_[stateStack_->top()]->append(index);
                }
                else
                        iter->second->append(index);
        }

        virtual void createSortedScene(SO<SceneThing> root, SO<Array<unsigned int> > shapeIndices, SO<Array<SO<SharedObj> > > shapes) {
                typename std::map<SO<T>, SO<Array<unsigned int> > >::iterator state = stateShapes_.begin();

                // for each specific state of this handler
                while(state != stateShapes_.end()) {
                        SO<Array<unsigned int> > intersection(new IndicesArray);
                        SO<Iterator<unsigned int> > iter = state->second->newIterator();

                        // create shape intersection (find the shapes affected by a particular state)
                        for(unsigned int i = 0; i < iter->size(); ++i) {
                                if(shapeIndices->contains(iter->get(i)))
                                        intersection->append(iter->get(i));
                        }

                        // add state and shapes to sorted scene
                        if(!successor_) {
                                if(0 < intersection->size()) {
                                        root->append(state->first);

                                        SO<Iterator<unsigned int> > indices = intersection->newIterator();

                                        for(unsigned int i = 0; i < indices->size(); ++i) {
                                                root->append(shapes->getElement(indices->get(i)));
                                        }
                                }
                        }
                        // forward to next handler in chain
                        else {
                                root->append(state->first);

                                successor_->createSortedScene(root, intersection, shapes);
                        }

                        ++state;
                }
        }

private:
        typedef Array<unsigned int> IndicesArray;
        typedef std::map<SO<T>, SO<IndicesArray> > StateShapesMap;

        SO<Stack<SO<T> > > stateStack_;
        StateShapesMap stateShapes_;
};

} // namespace VRS

#endif // VRS_SG_STATEHANDLER_H

---

Generated on Thu May 24 06:00:15 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact