VRS - The Virtual Rendering System

version 3.3

engine.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: engine.h 6136 2007-11-14 11:56:35Z Konstantin_Baumann $

#ifndef VRS_ENGINE_H
#define VRS_ENGINE_H

#include <vrs/matrix.h>
#include <vrs/sharedobj.h>
#include <vector>

namespace VRS {

class Attribute;
class CameraInfo;
class Canvas;
class Handler;
class MonoAttribute;
class Painter;
class PolyAttribute;
class Technique;
class TechniqueProcessor;
class Shader;
class Shape;
class Simplifier;
class Switch;
class ViewInfo;
class ViewInfoFactory;
template<typename T> class Callback1;
template<typename T> class DataIterator;
template<typename T> class NonPersistentDeque;
template<typename T> class IDHashTable;
template<typename T> class NonPersistentArray;
template<typename T, typename V> class NonPersistentDictionary;
template<typename T> class NonPersistentHashTable;
template<typename T> class Stack;

class VRS_CORE_API Engine : public SharedObj {
public:
    VRS_TYPEINFO(Engine, SharedObj);

    Engine();
    virtual ~Engine();

    virtual void push(MonoAttribute* attr);

    virtual void push(PolyAttribute* attr);

    virtual void push(Switch* sw);

    virtual void push(Handler* hdl);
    virtual void push(Technique* tech);

    virtual void pop(MonoAttribute* attr);

    virtual void pop(PolyAttribute* attr);

    virtual void pop(Switch* sw);

    virtual void pop(Handler* hdl);
    virtual void pop(Technique* tech);

    virtual void eval(const Shape* shape);
    virtual void eval(const MonoAttribute* attr, bool pushHint);
    virtual void eval(const PolyAttribute* attr, unsigned int index, bool pushHint);

    virtual bool isHandledByShader(const MonoAttribute* attr);

    virtual bool demandsShadingPass(const MonoAttribute* attr);
    virtual unsigned int shadingPass() const;

    virtual void push(Attribute* attr);
    virtual void pop(Attribute* attr);
    virtual void pop(const ID& id);

    virtual void setProcessor(TechniqueProcessor*);
    virtual TechniqueProcessor* getProcessor() const;

    enum TFType { modelviewMatrix = 0, projectionMatrix = 1, 
                  textureMatrix   = 2, colorMatrix      = 3 };
    VRS_SERIALIZABLE_CLASS_ENUM(TFType);
    virtual void pushTf(TFType category = Engine::modelviewMatrix);
    virtual void popTf(TFType category = Engine::modelviewMatrix);
    virtual void multTf(const Matrix& matrix, TFType category = Engine::modelviewMatrix);
    virtual void loadTf(const Matrix& matrix, TFType category = Engine::modelviewMatrix);
    virtual Matrix currentTf(TFType category = Engine::modelviewMatrix) const;
    virtual Matrix currentTfInv(TFType category = Engine::modelviewMatrix) const;
    virtual Matrix orientationTf() const;
    virtual Matrix orientationTfInv() const;
    virtual void setOrientationTf(const Matrix& matrix);
    virtual void setOrientationTf();

    virtual Matrix currentNormalizedDeviceCoordsTf() const;
    virtual Matrix currentPureProjectionTf() const;
    virtual Matrix currentPureProjectionTfInv() const;

    virtual void pushViewInfoFactory(SO<ViewInfoFactory> newViewInfoFactory);

    virtual void popViewInfoFactory();
    virtual SO<ViewInfo> viewInfo() const;

    virtual SO<CameraInfo> cameraInfo() const;

    virtual Handler* handler(const ID& service, const ID& target) const;
    virtual Painter* painter(const ID& target) const;
    virtual Simplifier* simplifier(const ID& target) const;
    virtual void pushMonoAttribute(const ID& category, MonoAttribute* attr);

    virtual void popMonoAttribute(const ID& category);
    virtual MonoAttribute* getMonoAttribute(const ID& category) const;

    enum SwitchType { ON = 1, OFF = 2, ALL = 3 };
    VRS_SERIALIZABLE_CLASS_ENUM(SwitchType);

    virtual unsigned int appendPolyAttribute(const ID& category, PolyAttribute* attr, SwitchType switchSetting = Engine::ON);

    virtual void removePolyAttribute(const ID& category, PolyAttribute* attr);

    virtual void applyGlobalPolyAttributes();

    virtual void unapplyGlobalPolyAttributes();

    virtual unsigned int polyAttributes(const ID& category, SwitchType switchQuery = Engine::ALL) const;

    virtual PolyAttribute* getPolyAttribute(const ID& category, unsigned int i, SwitchType switchQuery = Engine::ALL) const;

    virtual int containsPolyAttribute(PolyAttribute* attr, SwitchType switchQuery = Engine::ALL) const;

    virtual unsigned int findPolyAttribute(PolyAttribute* attr, SwitchType switchQuery = Engine::ALL) const;

    virtual Iterator<SO<PolyAttribute> >* newPolyAttributeIterator(const ID& category, SwitchType switchQuery = Engine::ON) const;

    virtual bool getSwitch(const ID& category, unsigned int index) const;
    virtual bool getSwitch(PolyAttribute*) const;

    void disregard(const ID& category);

    void regard(const ID& category);
    bool isRegarded(const ID& category) const;

    virtual void pushShader(Shader*);

    virtual void popShader();

    virtual Shader* getShader() const;

    virtual MonoAttribute* getShaderAttribute() const;

    void storeTransform(const Attribute*);
    void deleteTransform(const Attribute*);

    void setTransform(const SharedObj*, const Matrix&);
    void eraseTransform(const SharedObj*);
    Matrix getTransform(const SharedObj*) const;
    bool containsTransform(const SharedObj*) const;

    virtual void pushHandler(const ID& service, const ID& target, Handler* hdl);

    virtual void popHandler(const ID& service, const ID& target);

    virtual Iterator<SO<Technique> >* getTechniques() const;

    const Stack< SO<MonoAttribute> >* monoTable(const ID& category) const;

    struct PolyAttributeEntry {
        PolyAttributeEntry(PolyAttribute* p, SwitchType s) : attribute(p), setting(s) { }
        SO<PolyAttribute> attribute;
        SwitchType        setting;
    };
    const NonPersistentArray<PolyAttributeEntry>* polyTable(const ID& category) const;

    const IDHashTable< Stack< SO<Handler> > >* serviceTable(const ID& service) const;

    virtual void initialize();

    static bool addInitializer(Callback1<Engine*>* init);
    void callInitializers();

    Canvas* getCanvas() const;
    void pushCanvas(Canvas* canvas);
    void popCanvas();

    static bool registerHandler(Handler* handler);


    typedef Callback1<SO<Engine> > RenderCallback;

    static void addPreRenderCallback(SO<RenderCallback> cb);
    static bool removePreRenderCallback(SO<RenderCallback> cb);
    static SO<Iterator<SO<RenderCallback> > > preRenderCallbacks();

    static void addPostRenderCallback(SO<RenderCallback> cb);
    static bool removePostRenderCallback(SO<RenderCallback> cb);
    static SO<Iterator<SO<RenderCallback> > > postRenderCallbacks();

protected:
    virtual void finalEval(const Shape* shape);
    virtual bool isFinalEvalDone() const;

private:
    // mono attribute table
    SO<IDHashTable< Stack< SO<MonoAttribute> > > > monoAttrTable_;

    // poly attribute table
    SO<IDHashTable< NonPersistentArray<PolyAttributeEntry> > > polyAttrTable_;

    // deque of global polyattributes
    SO<NonPersistentDeque<SO<PolyAttribute> > > globalPolyAttrStack_;
    // keeps track whether global poly attributes were already applied in a rendering pass or not
    unsigned int globalPolyAttrCounter_;

    // Disregard Attribute Table
    SO<NonPersistentHashTable<ID> > disregardTable_;

    // handler table
    SO<IDHashTable< IDHashTable< Stack< SO< Handler> > > > > handlerTable_;

    // Transformations for attributes
    SO<NonPersistentDictionary<SO<const SharedObj>, Matrix> > attrTransform_;

    std::vector<Matrix> matrixStacks_[4];
    mutable std::vector<Matrix> invMatrixStacks_[4];
    Matrix orientationTf_;
    mutable Matrix invOrientationTf_;

    SO<NonPersistentArray<SO<Technique> > > techniques_;

    struct ShaderStackEntry {
        SO<MonoAttribute> attribute;
        SO<Shader>        shader;
        unsigned int      pass;
        bool              prepared;
    };
    SO<Stack<ShaderStackEntry> > shaderStack_;
    unsigned int shadingPass_;
    bool passPrepared_;

    bool finalEvalDone_;

    SO<Stack<SO<Canvas> > > renderingCanvases_;
    SO<TechniqueProcessor> processor_;

    mutable SO<CameraInfo> m_cameraInfo;
    mutable SO<Stack<SO<ViewInfoFactory> > > viewInfoFactoryStack_;
    mutable SO<ViewInfo> viewInfo_;

#ifndef NDEBUG
    SO<Stack<SO<MonoAttribute> > > unorderedAttributeStack_;
#endif // NDEBUG
};

inline unsigned int Engine::shadingPass() const {
    return shadingPass_;
}

#define VRS_GetMonoAttribute(TARGET_TYPE, ENGINE) \
    VRS_Cast(TARGET_TYPE, (ENGINE)->getMonoAttribute(TARGET_TYPE::ClassNameVRS()))

#define VRS_GuardedGetMonoAttribute(TARGET_TYPE, ENGINE) \
    VRS_GuardedCast(TARGET_TYPE, (ENGINE)->getMonoAttribute(TARGET_TYPE::ClassNameVRS()))

//
// macro for handler registration (the handler class must define a default c'tor!)
//
// e.g.: VRS_REGISTER_HANDLER(SphereSimplifier, Engine);
// or:   VRS_REGISTER_HANDLER(TexturePainterGL, EngineGL);
//

#define VRS_REGISTER_HANDLER(HANDLER, ENGINE)                                               \
    namespace {                                                                             \
        bool VRS_ANONYMOUS_IDENTIFIER(registration) = ENGINE::registerHandler(new HANDLER); \
    }

} // namespace VRS

#endif // VRS_ENGINE_H

---

Generated on Sat May 18 06:00:18 2013 by Doxygen 1.5.6

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