VRS - The Virtual Rendering System

version 3.3

canvas.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2008 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: canvas.h 6441 2008-07-17 15:19:45Z Manuel_Wellmann $

#ifndef VRS_SG_CANVAS_H
#define VRS_SG_CANVAS_H

#include <vrs/contextdata.h>
#include <vrs/sharedobj.h>
#include <vrs/viewport.h>
#include <vrs/time.h>
#include <vrs/sg/behaviornode.h>
#include <vrs/sg/inputevent.h>
#include <vrs/sg/manager.h>
#include <vrs/scenenode.h>
#include <vrs/sg/scenething.h>
#include <vrs/sg/cursor.h>

namespace VRS {

class Clock;
class Engine;
class Filter;
class IntersectionInfo;
class MultiSceneRenderer;
class TechniqueProcessor;
class ButtonEvent;
class ConfigureEvent;
class KeyEvent;
class MotionEvent;
class PointerEvent;
class ResizeEvent;
class WheelEvent;
class TimeManager;
template <typename T> class Array;
template <typename T> class Iterator;
template <typename T> class NonPersistentArray;
template <typename T> class Stack;

class VRS_CORE_API Canvas : public Manager {

public:
    Canvas(
        Clock* canvasClock = NULL,
        double pixelRatio = 1.0,
        double resolutionDPI = 96.0
    );
    virtual ~Canvas();
    void append(SceneNode* sceneGraph);
    void prepend(SceneNode* sceneGraph);
    void insert(int atPosition, SceneNode* sceneGraph);
    void remove(SceneNode* sceneGraph);
    bool contains(SceneNode* sceneGraph) const;

    void switchOn(SceneNode* sceneGraph);
    void switchOff(SceneNode* sceneGraph);
    bool isSwitchedOn(SceneNode* sceneGraph) const;

    int sceneGraphs() const;
    SceneNode* sceneGraph(int atPosition) const;


    void append(BehaviorNode* behaviorGraph);
    void prepend(BehaviorNode* behaviorGraph);
    void insert(int atPosition, BehaviorNode* behaviorGraph);
    void remove(BehaviorNode* behaviorGraph);
    bool contains(BehaviorNode* behaviorGraph) const;
    
    void reset(BehaviorNode* behaviorGraph);
    void switchOn(BehaviorNode* behaviorGraph, Clock* clock = NULL);
    void switchOff(BehaviorNode* behaviorGraph);
    bool isSwitchedOn(BehaviorNode* behaviorGraph) const;

    int behaviorGraphs() const;
    BehaviorNode* behaviorGraph(int atPosition) const;


    virtual void enableRedisplay();
    virtual void disableRedisplay();
    virtual bool isRedisplayEnabled() const;

    void redisplay();

    virtual void postForRedisplay(double delay = 0.0);
    virtual bool isRedisplayNeeded() const;
    virtual VRSTime lastRedisplay() const;

    static Iterator<Canvas*>* canvasList();
    static void redisplayAll();
    static void postAllForRedisplay(double delay = 0.0);

    virtual void setSize(unsigned int width, unsigned int height) = 0;

    virtual unsigned int getWidth() const = 0;

    virtual unsigned int getHeight() const = 0;

    double pixelRatio() const;
    void setResolution(double dpi);

    double getResolution() const;

    virtual void setSceneRenderer(MultiSceneRenderer*);
    virtual MultiSceneRenderer* getSceneRenderer() const;

    virtual Engine* engine() const = 0;
    virtual TechniqueProcessor* processor() const = 0;
    
    Clock* clock() const;

    void pushClock(Clock* clock);
    void popClock();

    void install(Engine* externalEngine);
    void deinstall(Engine* externalEngine);
    bool isInstalled(Engine* externalEngine) const;
        /* To deploy an engine for a canvas, the engine must be installed
           for that canvas. Once it is installed, the engine can be passed on 
           as argument to the Canvas::eval method. */

    virtual void eval(Engine* engine, TechniqueProcessor* techniqueprocessor);
    /* 'eval' evaluates the scene graphs of a canvas by the given engine 
        (instead of the internal engine which is used when the canvas is
        redisplayed) using the given technique processor. The engine must 
        be installed for the canvas. 'eval' always uses a StandardRenderer
        that evaluates the scene graph only once.
    */

    virtual bool prepareRedisplay();

    virtual void finishRedisplay();

    virtual void makeContextCurrent();

    virtual void releaseContext();

        IntersectionInfo* pickingResult(
                ButtonEvent* buttonEvent,
                SO<Filter> filter=NULL
        ) const;
    
        SO<Iterator<SO<IntersectionInfo> > > allPickingResults(
                ButtonEvent* buttonEvent,
                SO<Filter> filter=NULL
        ) const;

        int handle(Event* e);




    void setWatching(int onOff);
    int getWatching() const;
    
    Matrix modelviewMatrix() const;
    Matrix projectionMatrix() const;


        virtual void setCursor(Cursor::Shape cursor);


        virtual Cursor::Shape getCursor() const;
    
    VRS_TYPEINFO(Canvas, Manager);

    void installEngine(Engine* engine);
    void deinstallEngine(Engine* engine);
    
    void renderContents();

    SceneThing* sceneRootNode() const;

    Viewport* viewport() const;
    ContextData<Canvas*>* canvasHint() const;
    enum RenderingMode { Interactive = 1, HighQuality = 2 };
    virtual RenderingMode  getRenderingMode() const;
    virtual void setRenderingMode(RenderingMode mode);

    KeyEvent* keyEvent (
        InputEvent::Modifier modifiers,
        VRSTime time,
        unsigned long keyCode,
        int pressed,
        bool isAutoRepeat = false
    );
    MotionEvent* motionEvent (
        InputEvent::Modifier modifiers,
        VRSTime time,
        int x, int y, bool sameWindow
    );
    ButtonEvent* buttonEvent (
        InputEvent::Modifier modifiers,
        VRSTime time,
        InputEvent::Button button, 
        InputEvent::Change pressed, 
        int x, int y
    );
    ResizeEvent* resizeEvent (
        unsigned int width, unsigned int height, double aspectRatio=1.0
    );
    ConfigureEvent* configureEvent (
        int reason
    );
    PointerEvent* pointerEvent (
        InputEvent::Modifier modifiers,
        VRSTime time,
        bool entered
    );

    WheelEvent* wheelEvent (
        InputEvent::Modifier modifiers,
        VRSTime time,
        int delta,
        int x,
        int y
    );

protected:
    virtual void acceptChildren(std::vector<Visitable*>& appendChildrenHere) const;

private:
    // containers for scene graphs and behavior graphs
    SO<SceneThing> georoot_;
    SO<SceneThing> scenes_;
    SO<Array<SO<BehaviorNode> > > interaction_;
    SO<TimeManager> animation_;

    SO<KeyEvent> keyEvent_;
    SO<MotionEvent> motionEvent_;
    SO<ButtonEvent> buttonEvent_;
    SO<ResizeEvent> resizeEvent_;
    SO<ConfigureEvent> configureEvent_;
    SO<PointerEvent> pointerEvent_;
    SO<WheelEvent> wheelEvent_;

    double pixelRatio_;
    double resolutionDPI_;
    SO<Viewport> viewport_;
    SO<ContextData<Canvas*> > canvasHint_;
    SO<NonPersistentArray<Engine*> > installedEngines_;
    SO<MultiSceneRenderer> multiSceneRenderer_;

    bool rendering_;
    bool redisplayDisabled_;
    VRSTime lastUpdate_;
    VRSTime nextUpdate_;
    SO<Stack<SO<Clock> > > clocks_;
        Cursor::Shape cursor_;

    RenderingMode m_renderingMode;

    mutable SO<ButtonEvent>      lastPickingEvent_;
    mutable SO<IntersectionInfo> lastPickingResult_;

    mutable InputEvent::Button currentPressedButtons_;
};

} // namespace VRS

#endif // VRS_SG_CANVAS_H

---

Generated on Fri May 18 06:00:13 2012 by Doxygen 1.5.6

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