VRS - The Virtual Rendering System

version 3.3

scenething.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2007 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.
 ******************************************************************************/

// $Id: scenething.h 6378 2008-06-02 13:30:09Z Konstantin_Baumann $

#ifndef VRS_SCENETHING_H
#define VRS_SCENETHING_H

#include <vrs/scenenode.h>
#include <vrs/bounds.h>
#include <vrs/matrix.h>

#include <map>
#include <vector>

namespace VRS {

class Engine;
template<typename T> class DataIterator;

class VRS_CORE_API SceneThing : public SceneNode {
    
public:
    SceneThing(SceneThing* parent = NULL);
    virtual void append(SharedObj* obj);
    virtual void append(Iterator<SO<SharedObj> >* iter);
    virtual void prepend(SharedObj* obj);
    virtual void prepend(Iterator<SO<SharedObj> >* iter);
    virtual void insert(int position, SharedObj* obj);
    virtual void insert(int position, Iterator<SO<SharedObj> >* iter);
    virtual int replace(SharedObj* oldObj, SharedObj* newObj);
    virtual void remove(int position);
    virtual void remove(SharedObj* obj);
    virtual void clear();
    virtual void appendContent(SceneThing* obj);
    virtual void prependContent(SceneThing* obj);
    virtual void insertContent(int position,SceneThing* obj);
    virtual int objects() const;
    virtual SharedObj* object(int i) const;
    virtual bool contains(SharedObj* obj) const;
    virtual Iterator<SO<SharedObj> >* find(const ID& objClassName) const;
    virtual int find(SharedObj* obj, int startIndex = 0) const;
    void setFilter(unsigned int value);
    unsigned int getFilter() const;
    void setMask(SharedObj* obj, unsigned int value);
    void setMask(int position, unsigned int value);
    unsigned int getMask(SharedObj* obj) const;
    unsigned int getMask(int position) const;
    enum { ModelView=1, Projection=2, Orientation = 4, All=7 };
    void setWatching(int onOff);
    int getWatching() const;
    Matrix modelviewMatrix(Engine* engine) const;
    Matrix projectionMatrix(Engine* engine) const;
    Matrix orientationMatrix(Engine* engine) const;
    void setLocalMatrix(const Matrix& matrix);
    Matrix getLocalMatrix() const;
    virtual int childNodes() const;
    virtual SceneNode* childNode(int i) const;
    virtual void install(Engine* engine);
    virtual void deinstall(Engine* engine);
    virtual void evaluate(Engine* engine);

    virtual SceneNodeVisitor::TraversalFlag traverse(SceneNodeVisitor* visitor);
    virtual Bounds boundingBox(Engine* engine) const;

    VRS_TYPEINFO(SceneThing, SceneNode);

    VRS_SERIALIZABLE(SceneThing);
        
protected:
    virtual bool accepts (const SharedObj*) const;
    int evaluateForward (Engine*, int from, int to);
    void evaluateBackward (Engine*, int from, int to);
    virtual void preEvaluate(Engine*);
    virtual void postEvaluate(Engine*);
    virtual SceneNodeVisitor::TraversalFlag preTraverse(SceneNodeVisitor*);
    virtual SceneNodeVisitor::TraversalFlag postTraverse(SceneNodeVisitor*);
protected:
    virtual void acceptChildren(std::vector<Visitable*>& appendChildrenHere) const;
    
private:
    enum ObjectType { 
        SCENENODE, MONOATTRIBUTE, POLYATTRIBUTE, SWITCH,
        TECHNIQUE, HANDLER, SHAPE, TRANSFORM, UNKNOWN
    };

    enum ShaderEvalState {
        SHADER_EVAL, SHADER_BLOCK
    }; // to ensure that shader attributes are not evaluated recursively
       // within other shader attributes
    
    SO<DataIterator<SO<SharedObj> > >  objects_;
    SO<DataIterator<ObjectType> >      objTypes_;
    SO<DataIterator<unsigned int> >    objMasks_;
    std::vector<ShaderEvalState> objShaderState_;
    unsigned int filter_;
    
    ObjectType getType(SharedObj*);
        VRS_SERIALIZABLE_CLASS_ENUM(ObjectType);
    
    int watching_;
    mutable std::map<Engine*, Matrix> modelviewMatrix_;
    mutable std::map<Engine*, Matrix> projectionMatrix_;
    mutable std::map<Engine*, Matrix> orientationMatrix_;
    
    Matrix localTf_;
    bool localTfFlag_;
};

} // namespace VRS

#endif // VRS_SCENETHING_H

---

Generated on Thu May 23 06:00:20 2013 by Doxygen 1.5.6

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