#include <qglviewer.h>
Display of visual hints | |
bool | axisIsDrawn () const |
bool | gridIsDrawn () const |
bool | fpsIsDisplayed () const |
bool | zBufferIsDisplayed () const |
bool | textIsEnabled () const |
bool | cameraPathIsEdited () const |
void | setDrawAxis (bool draw=true) |
void | toggleDrawAxis () |
void | setDrawGrid (bool draw=true) |
void | toggleDrawGrid () |
void | setDisplayFPS (bool display=true) |
void | toggleDisplayFPS () |
void | setDisplayZBuffer (bool display=true) |
void | toggleDisplayZBuffer () |
void | setEnableText (bool enable=true) |
void | toggleEnableText () |
void | editCameraPath (bool edit=true) |
void | toggleCameraPathEditor () |
Viewer colors | |
QColor | backgroundColor () const |
QColor | foregroundColor () const |
void | setBackgroundColor (const QColor &color) |
void | setForegroundColor (const QColor &color) |
Scene related values | |
float | sceneRadius () const |
qglviewer::Vec | sceneCenter () const |
void | getSceneCenter (float &x, float &y, float &z) const |
void | setSceneBoundingBox (const float m[3], const float M[3]) |
float | currentFPS () |
void | setSceneRadius (float r) |
void | setSceneCenter (const qglviewer::Vec &sc) |
void | setSceneCenter (float x, float y, float z) |
void | setSceneBoundingBox (const qglviewer::Vec &m, const qglviewer::Vec &M) |
void | showEntireScene () |
Associated objects | |
qglviewer::Camera * | camera () const |
qglviewer::ManipulatedFrame * | manipulatedFrame () const |
void | setCamera (qglviewer::Camera *const c) |
void | setManipulatedFrame (qglviewer::ManipulatedFrame *fr) |
State of the viewer | |
float | aspectRatio () const |
bool | isFullScreen () const |
bool | displaysInStereo () const |
void | setFullScreen (bool fs=true) |
void | toggleFullScreen () |
void | setStereoDisplay (bool s=true) |
void | toggleStereoDisplay () |
virtual void | toggleCameraMode () |
virtual void | aboutQGLViewer () |
Display functions | |
void | drawAxis (float scale=1.0f) |
void | drawGrid () |
virtual void | startScreenCoordinatesSystem (bool upward=false) const |
virtual void | stopScreenCoordinatesSystem () const |
void | drawText (int x, int y, const QString &text, const QFont &fnt=QFont()) |
void | displayMessage (const QString &message, int time=2000) |
void | draw3DText (const qglviewer::Vec &pos, const qglviewer::Vec &normal, const QString &string, GLfloat height=0.1f) |
virtual void | drawLight (GLenum light, float scale=1.0f) const |
virtual void | displayFPS () |
virtual void | displayZBuffer () const |
Mouse grabber | |
qglviewer::MouseGrabber * | mouseGrabber () const |
void | setMouseGrabber (qglviewer::MouseGrabber *mg) |
Snapshots | |
const QString & | snapshotFilename () const |
const QString & | snapshotFormat () const |
int | snapshotCounter () const |
int | snapshotQuality () |
void | saveSnapshot (bool automatic=false, bool overwrite=false) |
void | saveSnapshot (const QString &filename, bool overwrite=false) |
void | setSnapshotFilename (const QString &n) |
void | setSnapshotFormat (const QString &f) |
void | openSnapshotFormatDialog () |
void | setSnapshotCounter (const int c) |
void | setSnapshotQuality (int snapshotQuality) |
Animation | |
bool | animationIsStarted () const |
int | animationPeriod () const |
void | setAnimationPeriod (int msecs) |
virtual void | startAnimation () |
virtual void | stopAnimation () |
void | toggleAnimationMode () |
virtual void | animate () |
Help window | |
virtual QString | helpString () const |
virtual QString | mouseString () const |
virtual QString | keyboardString () const |
virtual void | help () |
Object selection | |
virtual void | beginSelection (int x, int y) |
virtual void | drawWithNames () |
virtual void | endSelection (int x, int y) |
virtual void | postSelection (int, int) |
int | selectedName () const |
int | selectBufferSize () const |
int | selectRegionWidth () const |
int | selectRegionHeight () const |
GLuint * | selectBuffer () |
virtual void | select (const QMouseEvent *e) |
virtual void | select (int x, int y) |
void | setSelectBufferSize (int size) |
void | setSelectRegionWidth (int width) |
void | setSelectRegionHeight (int height) |
void | setSelectedName (int id) |
Keyboard accelerators customization | |
void | setKeyboardAccelerator (KeyboardAction action, int key) |
int | keyboardAccelerator (KeyboardAction action) const |
void | setKeyDescription (int key, QString description) |
void | setShortcutKey (KeyboardAction action, int key, int state=-1) |
void | setShortcutStateKey (KeyboardAction, int) |
Qt::Key | shortcutKey (KeyboardAction action) const |
Qt::ButtonState | shortcutStateKey (KeyboardAction action) const |
virtual void | setKeyFrameKey (int nb, int key) |
Qt::Key | keyFrameKey (int nb) const |
virtual void | setAddKeyFrameStateKey (int buttonState) |
Qt::ButtonState | addKeyFrameStateKey () const |
virtual void | setPlayKeyFramePathStateKey (int buttonState) |
Qt::ButtonState | playKeyFramePathStateKey () const |
enum | KeyboardAction { DRAW_AXIS, DRAW_GRID, DISPLAY_FPS, DISPLAY_Z_BUFFER, ENABLE_TEXT, EXIT_VIEWER, SAVE_SCREENSHOT, CAMERA_MODE, FULL_SCREEN, STEREO, ANIMATION, HELP, EDIT_CAMERA_PATHS, MOVE_CAMERA_LEFT, MOVE_CAMERA_RIGHT, MOVE_CAMERA_UP, MOVE_CAMERA_DOWN, INCREASE_FLYSPEED, DECREASE_FLYSPEED } |
Mouse behavior customization | |
void | setMouseStateKey (MouseHandler mh, int buttonState) |
void | setMouseBinding (int buttonState, MouseHandler handler, MouseAction action, bool withConstraint=true) |
MouseAction | mouseAction (int buttonState) const |
int | mouseHandler (int buttonState) const |
Qt::ButtonState | mouseButtonState (MouseHandler mh, MouseAction ma, bool withConstraint=true) const |
void | setMouseBinding (int buttonState, ClickAction action, bool doubleClick=false, int buttonBefore=Qt::NoButton) |
ClickAction | clickAction (int buttonState, bool doubleClick, int buttonBefore) const |
void | getClickButtonState (ClickAction ca, Qt::ButtonState &buttonState, bool &doubleClick, Qt::ButtonState &buttonBefore) const |
void | setMouseBindingDescription (int buttonState, bool doubleClick, QString description) |
void | setWheelBinding (int stateKey, MouseHandler handler, MouseAction action, bool withConstraint=true) |
MouseAction | wheelAction (int buttonState) const |
int | wheelHandler (int buttonState) const |
int | wheelButtonState (MouseHandler mh, MouseAction ma, bool withConstraint=true) const |
enum | MouseHandler { CAMERA, FRAME } |
enum | ClickAction { NO_CLICK_ACTION, ZOOM_ON_PIXEL, ZOOM_TO_FIT, SELECT, RAP_FROM_PIXEL, RAP_IS_CENTER, CENTER_FRAME, CENTER_SCENE, SHOW_ENTIRE_SCENE, ALIGN_FRAME, ALIGN_CAMERA } |
enum | MouseAction { NO_MOUSE_ACTION, ROTATE, ZOOM, TRANSLATE, MOVE_FORWARD, LOOK_AROUND, MOVE_BACKWARD, SCREEN_ROTATE, ROLL, SCREEN_TRANSLATE, ZOOM_ON_REGION } |
Save and restore viewer state | |
virtual void | saveToFile (const QString &fileName="") |
virtual void | restoreFromFile (const QString &fileName="") |
virtual QDomElement | domElement (const QString &name, QDomDocument &doc) const |
virtual void | initFromDOMElement (const QDomElement &e) |
Visual hints | |
virtual void | setVisualHintsMask (int mask, int delay=2000) |
virtual void | drawVisualHints () |
virtual void | resetVisualHints () |
QGLViewerPool associated methods | |
const QPtrList< QGLViewer > & | QGLViewerPool () |
int | QGLViewerIndex (const QGLViewer *const v) |
void | connectSignalToAllViewers (const QObject *sender, const char *signal, const char *member=SLOT(updateGL())) |
void | disconnectSignalToAllViewers (const QObject *sender, const char *signal, const char *member=SLOT(updateGL())) |
void | updateGLForAllViewers () |
void | saveToFileForAllViewers () |
Mouse, keyboard and event handlers | |
virtual void | mousePressEvent (QMouseEvent *) |
virtual void | mouseDoubleClickEvent (QMouseEvent *) |
virtual void | mouseReleaseEvent (QMouseEvent *) |
virtual void | mouseMoveEvent (QMouseEvent *) |
virtual void | wheelEvent (QWheelEvent *) |
virtual void | timerEvent (QTimerEvent *) |
virtual void | closeEvent (QCloseEvent *) |
virtual void | keyPressEvent (QKeyEvent *) |
Signals | |
void | viewerInitialized () |
void | drawNeeded () |
void | drawFinished (bool dummy) |
void | animateNeeded () |
void | helpRequired () |
void | axisDrawn (bool on) |
void | gridDrawn (bool on) |
void | fpsDisplayed (bool on) |
void | zBufferDisplayed (bool on) |
void | textEnabled (bool on) |
void | cameraPathEdited (bool on) |
void | stereoChanged (bool on) |
void | pointSelected (const QMouseEvent *e) |
Public Member Functions | |
QGLViewer (QWidget *parent=NULL, const char *name=0, const QGLWidget *shareWidget=0, WFlags flags=0) | |
QGLViewer (const QGLFormat &format, QWidget *parent=0, const char *name=0, const QGLWidget *shareWidget=0, WFlags flags=0) | |
QGLViewer (QGLContext *context, QWidget *parent, const char *name=0, const QGLWidget *shareWidget=0, WFlags flags=0) | |
virtual | ~QGLViewer () |
Protected Types | |
Protected Member Functions | |
virtual void | resizeGL (int w, int h) |
virtual void | initializeGL () |
virtual void | init () |
virtual void | paintGL () |
virtual void | preDraw () |
virtual void | preDrawStereo (bool leftBuffer=true) |
virtual void | draw () |
virtual void | fastDraw () |
virtual void | postDraw () |
virtual QSize | sizeHint () const |
A QGLViewer is a 3D OpenGL viewer based on the Qt's QGLWidget. It includes many classical viewer functionalities, such as a camera trackball, manipulated objects, snapshot saving and much more. Its main goal is to enable the very fast development of new 3D applications.
In order to display a scene, you simply have to derive the draw() function (or use the drawNeeded() signal, see below) and to provide the openGL orders that define your scene. New users should read the introduction page to get familiar with important notions such as sceneRadius() and sceneCenter().
Try the numerous simple examples to discover the possibilities and understand how it works. See also the Qt's QGLWidget documentation for details about inherited methods such as QGLWidget::setAutoBufferSwap() or QGLWidget::swapBuffers().
To use it, you can derive a class from it and overload the draw() virtual method. See the simpleViewer example for an introduction.
A complete commented example is also available.
An other method is to connect your drawing methods to the signals emitted by the QGLViewer (clean callback mechanism). See the callback example for a complete implementation.
// A Scene class holds the scene data and provides a drawScene function. class Scene : public QObject { Q_OBJECT // Needed in order to use the Qt signals/slots mechanism public: Scene(const QGLViewer* const v); public slots: void drawScene(); }; Scene::Scene(const QGLViewer* const viewer) { // Connect the viewer signal to our draw function slot connect(viewer, SIGNAL(drawNeeded()), SLOT(drawScene())); }
|
Defines the possible actions that can be binded to a mouse click. ClickAction are binded using setMouseBinding(). See the mouse page for details. |
|
Defines the different actions that can directly be associated with a keyboard accelerator. Use setKeyboardAccelerator() to modify a keyboard accelerator. See the keyboard page for details. |
|
Defines the possible actions that can be binded to a mouse motion (a click, followed by a mouse displacement). These actions may be applied to the camera() or to the manipulatedFrame() (see MouseHandler). Use setMouseBinding() to bind a mouse button to an action. See the mouse page for details. |
|
Defines the different mouse handlers : Camera or Frame motion. Used by setMouseBinding() to define which handler receives the mouse displacements. See the mouse page for details. |
|
Set default display flags, initializes camera and other parameters. Calls the QGLWidget constructor with the same parameters.
If the The initialization of OpenGL rendering state, etc. should be done in init() rather than in the constructor. See the Qt::QGLWidget associated constructor documentation for details on the parameters. |
|
Same as QGLViewer(), but a Qt::QGLFormat can be provided (used for stereo display in the stereoViewer example. |
|
Same as QGLViewer(), but a Qt::QGLContext can be provided so that viewers share GL contexts, even with
|
|
Virtual destructor. Removes object from QGLViewerPool() and releases allocated memory. |
|
Open a small about dialog, showing libQGLViewer version, copyright notice and web site. |
|
Returns the state key (Qt::AltButton, Qt::ShiftButton, Qt::ControlButton) that must be pressed with the keyFrameKey() to add a KeyFrame to a camera KeyFrame path. Default value is Qt::AltButton. See setAddKeyFrameStateKey() for details. See also keyFrameKey() and playKeyFramePathStateKey(). See the keyboard accelerator page for details. |
|
Scene animation function. Once startAnimation() has been called, an infinite loop calls animate() and draw(). This function should be used for dynamic simulation, games or other applications where the scene geometry evolves over time. Note that KeyFrameInterpolator and SpinningFrame, which regularily update a Frame do not use this method but rather rely on a QTimer signal-slot mechanism. See the animation example for an illustration. |
|
Signal emitted by the default QGLViewer::animate() function. Connect this signal to your scene animation function. Use this signal-slot mechanism ONLY IF you don't inherit your viewer from QGLViewer (in that case, simply overload the animate() function). |
|
Return true when the animation loop is started, i.e. viewer calls animate() and draw(). See startAnimation() and animate(). You should override this method if your scene contains animated elements (KeyFrameInterpolator driven objects excepted). |
|
The animation loop period, in milliseconds. See startAnimation() and animate(). |
|
Returns the aspect ratio of the GL widget. That is the ratio between its width and height (see the Qt QGLWidget documentation). |
|
This signal is emitted whenever axisIsDrawn() changes value. This can be done with setDrawAxis() or toggleDrawAxis(). |
|
Returns |
|
Returns the current background color of the viewer. Use setBackgroundColor() to define the background color.
This function is provided for convenience since the background color is an OpenGL state variable set with
|
|
This method should prepare the selection. It is called by select() before drawWithNames().
The default implementation uses the
You should not need to redefine this function (if you use the |
|
The camera that is used by the viewer. See the qglviewer::Camera documentation for a complete description of the available functions. |
|
This signal is emitted whenever cameraPathIsEdited() changes value. This can be done with editCameraPath() or toggleCameraPathEditor(). |
|
Returns When cameraPathIsEdited(), the camera paths that are defined are displayed using qglviewer::Camera::drawAllPaths(). qglviewer::Camera::zNear() and qglviewer::Camera::zFar() are modified so that the paths are not clipped. zBuffer precision is highly affected. |
|
Same as mouseAction(), but for the click action set using setMouseBinding(). |
|
Save the viewer current state using saveToFile() and then call QGLWidget::closeEvent(). |
|
Connect a signal to a signal or a slot of all the QGLViewers. Typical usage would be:
The default target signal is updateGL(), but any other signal/slot can be used. This function will silently ignore the connections that cannot be established. See also QGLViewerPool(), disconnectSignalToAllViewers() and updateGLForAllViewers(). |
|
Returns the current viewer frame rate, as displayed by displayFPS() (see setDisplayFPS() and toggleDisplayFPS()). This function is useful for true real-time applications that may adapt the computational load according to frame rate evolution in order to maintain a given frequency. Note that for stability reasons this value is averaged over 20 frames, and hence will only change every 20 draw. As Qt redraws the window only when needed, this value is meaningful only when startAnimation() is called, when you use qglviewer::Camera::playKeyFramePath() or when the camera is manipulated with the mouse, so that draw() is called in a loop. |
|
Disconnect a signal to a signal or a slot of all the QGLViewers. Used in conjunction with connectSignalToAllViewers(). The default target signal is updateGL(), but any other signal/slot can be used. This function will silently ignore the connections that cannot be removed. See also updateGLForAllViewers(). |
|
Displays the current averaged frame rate in the upper left corner of the window. updateGL() should be called in a loop in order to have a meaningful value (this is the case when you continuously move the camera using the mouse or when animationIsStarted()). setAnimationPeriod(0) to make this loop as fast as possible in order to reach the maximum available frame rate. The FPS display can be toggled with toggleDisplayFPS() (default keyboard accelerator is 'F') or with setDisplayFPS(). Use QApplication::setFont() to define the FPS font (see drawText()). Current application averaged frame rate is available from currentFPS(). |
|
Briefly displays a message in the lower left corner of the window. Convenient to provide feedback to the user.
This function should not be called in draw(). If you want to display a text at each draw(), use drawText() instead. If this method is called when a message is already displayed, the new message simply replaces the old one. Use enableText() (default shortcut is '?') to enable or disable text (and hence message) display. |
|
Returns |
|
Displays the current z-buffer in grey levels for debugging purposes. Note that it hides the normal display. Frame rate is slowed down because of the z-buffer reading and writing. |
|
Creates an XML QDomElement that represents the QGLViewer. Use initFromDOMElement() to restore the QGLViewer state from the resulting domElement. Merges the qglviewer::ManipulatedFrame::domElement(), qglviewer::Camera::domElement(), ... elements.
|
|
The core function of the viewer, called to draw the scene. If you build a class that inherits from QGLViewer, this is the function you want to overload. See the simpleViewer example for an illustration. If you choose to use a callback mechanism instead, connect the drawNeeded() signal to your own draw function (signal emitted by preDraw()). See the callback example for details.
|
|
Similar to drawText(), but the text is handled as a classical 3D object of the scene. Although useful, this function is deprecated with recent Qt versions. Indeed, Qt renders text as pixmaps that cannot be orientated. However, when GLUT is used instead of Qt (when your Qt version is lower than 3.1, see QT_VERSION_WITHOUT_GLUT in config .h) orientated characters are possible and this function will work.
If you want your text to always face the camera (normal parallel to camera()->viewDirection), use QGLWidget::renderText(x,y,z). See the draw3DText example for an illustration. |
|
Draws an XYZ axis, with a given size (default is 1.0). The axis position and orientation only depends on the current modelview matrix state.
Note that pressing the Use the following code to display the current position and orientation of a qglviewer::Frame :
|
|
Signal emitted at the end of the QGLViewer::paintGL() function, when current frame drawing is finished. Can be used to notify image grabbing processes that the image is ready. A typical example is to connect this signal to the saveSnapshot() method, so that a (numbered) snapshot is generated after each new display:
The See also the drawNeeded() signal. |
|
Displays a XY grid of size 1, centered on (0,0,0). The calling function should set the
|
|
This debugging function draws a representation of
Optionnal parameter Note that this size is already proportional to the scene radius. See the drawLight example for an illustration. |
|
Signal emitted by the default QGLViewer::draw() function. Connect this signal to your main drawing function. preDraw() is called before this signal is emitted and will call qglviewer::Camera::loadProjectionMatrix() and qglviewer::Camera::loadModelViewMatrix() to set the viewing matrices. postDraw() will be called after this signal is answered. pre (resp. post) draw can be tuned by adding code at the beginning (resp. end) of your draw slot. See the callback example for an illustration. You can check whether the camera is manipulated to call a fast draw version : Use this signal-slot mechanism ONLY IF you don't inherit your viewer from QGLViewer (in that case, simply overload the draw() and fastDraw() function). See the fastDraw example for an illustration. |
|
Draws a
This procedure calls QGLWidget::renderText() if your Qt version is at least 3.1, otherwise it uses GLUT. The default QApplication::font() is used to render the text when no
See the screenCoordSystem example for an illustration. QGLWidget::renderText() (Qt >= 3.1) performs a similar action. It exists in a 2D (pixel coordinates) and a 3D (classical coordinates) version. Use this QGLWidget::renderText(x,y,z, str) function to draw a text that faces the camera, located at a specific 3D location (no need to convert to screen coordinates).
The
Text is displayed only when textIsEnabled() is displayMessage() is useful to drawText() only for a short amount of time. See also the draw3DText() and displayFPS() functions.
|
|
Draws viewer related visual hints. Displays the new qglviewer::Camera::revolveAroundPoint() when it is changed. See the mouse page for details. Also draws a line between qglviewer::Camera::revolveAroundPoint() and mouse cursor when the camera is rotated around the camera Z axis. See also setVisualHintsMask() and resetVisualHints(). The hint color is foregroundColor().
|
|
This function is called by select() and is originally empty. You should overload it to draw the different elements of your scene you want to be able to select. The default select() implementation relies on the
The resulting selected name is retrieved by endSelection(), which setSelectedName() (a value of -1 means no selection). Use selectedName() to update your selection, probably in the postSelection() method. |
|
Start (default, |
|
This method is called by select() after scene elements were drawned by drawWithNames(). It should analyse the selection result to determine which object is actually selected.
The default implementation relies on This default implementation, although sufficient for many cases is however limited and you may have to overload this method. This will be the case if drawWithNames() uses several push levels in the name heap. A more precise depth selection, for instance priviledging points over edges and triangles to avoir z precision problems, will also require an overloading. A typical implementation will look like:
See the multiSelect example for a multi-object selection implementation of this function. |
|
Fast draw of the scene. Called instead of draw() when the camera is manipulated. Useful for interactive displacements in a complex scene. Default behavior calls draw(). See the fastDraw example for an illustration. |
|
The current viewer foreground color. This color is used to display the FPS text (see setDisplayFPS()), the camera paths (see qglviewer::Camera::drawAllPaths() and editCameraPath()), the XY grid (see drawGrid() and setDrawGrid()) and the visual hints (see drawVisualHints()).
To set the current OpenGL color to foregroundColor(), simply use:
|
|
This signal is emitted whenever fpsIsDisplayed() changes value. This can be done with setDisplayFPS() or toggleDisplayFPS(). |
|
Returns |
|
Similar to mouseButtonState(), but for the click actions. Note that the results of the query are returned in the |
|
|
|
This signal is emitted whenever gridIsDrawn() changes value. This can be done with setDrawGrid() or toggleDrawGrid(). |
|
Returns |
|
This function is called when the user presses the HELP_KEY (default is 'H'). It opens a modal help window that includes three tabs, which are respectively filled with the results of helpString(), keyboardString() and mouseString(). You should overload helpString() to define you own help text. Rich html-like text can be used (see the QStyleSheet documentation).
Set the The helpRequired() signal is emitted. |
|
Signal emitted by the default QGLViewer::help() function. Connect this signal to your own help function. Use this signal-slot mechanism ONLY IF you don't inherit your viewer from QGLViewer (in that case, simply overload the help() function). |
|
helpString() is displayed in the help window main tab. This window is created by the help() function when the HELP_KEY (default is 'H') is pressed. Overload this function to define your own help string, which should shortly describe your application and explains how it works. Rich-text (HTML) tags can be used. See Qt::QStyleSheet() documentation for available tags.
See also mouseString() and keyboardString(). |
|
Initialization of the viewer. This function will be called before the first drawing and you can overload it to initialize some of the GL flags. The original function is empty and hence does not need to be called. Can be used to set the camera (qglviewer::Camera::setPosition(), qglviewer::Camera::setFieldOfView(), ...) or to make the camera fit the scene (see qglviewer::Camera::showEntireScene()).
OpenGL flags should also be (re)defined here. Some default flags are set in initializeGL(): only the
|
|
Restores the QGLViewer state from a QDomElement created by domElement(). See also qglviewer::Camera::initFromDOMElement(), qglviewer::ManipulatedFrame::initFromDOMElement().
|
|
Initialization of the GL context, creation of some viewer display lists. Calls init() at the end.
If you port an existing application to QGLViewer and your display changes, you probably want to disable these flags (in init()) to get back to a standard openGL state. init() is called at the end, and the openGL flags can be re-defined there. This function should not be overloaded. Use init() for viewer initialization. In case of overloading, you should call QGLViewer::initializeGL() at the beginning of your new initializeGL() function (display list creation). |
|
Returns |
|
Returns the keyboard accelerator currently associated to a given QGLViewer::KeyboardAction.
Result is an
Returns |
|
Returns a QString that describes the application keyboard accelerator bindings, and that will be displayed in the help() window Default value is a table that describes all the current keyboard accelerators. This table is made of the standard QGLViewer::KeyboardAction accelerators (defined using setKeyboardAccelerator()), merged with the custom accelerators defined using setKeyDescription(). See the keyboard accelerator page for details on key customization. |
|
Returns the camera Key Frame path keyboard accelerator for index See also addKeyFrameStateKey() and playKeyFramePathStateKey(). See the keyboard accelerator page for details. |
|
Key pressed callback function. Some default keyboard accelerators are defined and can easily be redefined using setKeyboardAccelerator(). See the keyboard accelerator page for details and default bindings. Overload this function to implement a specific keyboard accelerator binding for one of your application function. You should call the original function in the default case of your switch to preserve the default viewer key bindings :
Consider testing the modifier keys for more complex behaviors:
When you define a new keyboard accelerator, you should give a short description of your accelerator using setKeyDescription(), which is displayed in the help() window Keyboard tab.
Note that if you want to overload a QGLViewer::KeyboardAction accelerator, you need to disable the original accelerator using setKeyboardAccelerator() with a An alternative to this function is to use the QAccel class. See the associated Qt documentation. |
|
Returns the current manipulated frame, which can be moved with the mouse. Default mouse bindings make the ManipulatedFrame move when the
Returns |
|
Returns the MouseAction currently associated with the Qt::ButtonState For instance, to know which motion corresponds to Alt-LeftButton, do:
Use mouseHandler() to know who (CAMERA or FRAME) will perform this motion. |
|
Returns the Qt::ButtonState (if any) that has to be used to activate action To know which keys and mouse buttons have to be pressed to translate the camera, use tests like: Note that current mouse bindings are displayed by one of the help window tabs (use the 'H' key). |
|
The behavior of the mouse double click depends on the current mouse binding. See setMouseBinding() and the QGLViewer mouse page. |
|
Returns the current MouseGrabber, or You may use setMouseGrabber() to define a qglviewer::MouseGrabber, but mouseMoveEvent() already does it, using qglviewer::MouseGrabber::checkIfGrabsMouse() to determine if a MouseGrabber is currently under the mouse cursor. See the mouseGrabber example for an illustration. In order to use mouseGrabber, you need to enable mouse tracking so that mouseMoveEvent() is called even when no mouse button is pressed. Add this in init() or in your viewer constructor: Note that the default behavior is to disable mouse tracking. Use QWidget::hasMouseTracking() to get current value. |
|
Returns the MouseHandler currently associated with the Qt::ButtonState For instance, to know which handler receives the Alt-LeftButton, do: Use mouseAction() to know which action (see the MouseAction enum) will be perform on this handler. |
|
Maintaining a button pressed while moving the mouse updates the camera or the manipulated frame. The different possible actions (see MouseAction) are binded to mouse buttons using setMouseBinding(). If you want to define your own mouse behavior, do something like this :
Many other event handlers can be customized : mouseDoubleClickEvent(), wheelEvent(), mouseReleaseEvent()... See the Qt::QWidget protected members documentation for a complete list. |
|
When the user clicks on the mouse:
Classical mouse binding customization can be achieved using setMouseBinding() and setWheelBinding(). See the mouseMoveEvent() documentation for an example of more complex mouse behavior customization.
|
|
When the user releases the mouse button, the camera (or the manipulatedFrame) action is stopped. See the mouseMoveEvent() documentation for an example of mouse behavior customization. |
|
Returns a QString that describes the application mouse bindings, as it will be displayed in the help() window Returns a table that describes all the current standard mouse bindings (as defined using setMouseBinding() and setWheelBinding()) as well as custom application mouse binding descriptions defined using setMouseBindingDescription(). See the mouse page for details on mouse bindings. |
|
Opens a dialog that displays the different available snapshot formats. Calls setSnapshotFormat() with the selected one (unless the user presses |
|
The paint method. Calls preDraw(), draw() (or fastDraw()) and postDraw() in that order. Should not be overloaded. Overload the internal functions instead.
If you choose to overload, the
If viewer displaysInStereo(), calls preDrawStereo(flag), draw(), postDraw(), first with flag = |
|
Returns the state key (Qt::AltButton, Qt::ShiftButton, Qt::ControlButton) that must be pressed with the keyFrameKey() to play a camera KeyFrame path. Default value is Qt::NoButton. See setPlayKeyFramePathStateKey() for details. See also keyFrameKey() and addKeyFrameStateKey(). See the keyboard accelerator page for details. |
|
Signal emitted when select() is called. Connect this signal to your selection drawing function. Use this signal-slot mechanism ONLY IF you don't inherit your viewer from QGLViewer (in that case, simply overload the select() or the drawWithNames() functions). See select() for more details. |
|
Done after draw(). Default behavior displays axis, grid, FPS... when the respective flags are enabled. The GLContext (color, LIGHTING, BLEND...) should not be changed by this function, so that in draw(), you can rely on the OpenGL context. Respect this convention (by pushing/popping the different attributes) if you overload this function. Assumes the |
|
This method is called at the end of the select() procedure. It should finalise the selection process and update the data structure/interface/computation/display... according to the newly selected entity. The default implementation is empty. Overload this method if needed, and use selectedName() to retrieve the selected entity name (returns -1 if no object was selectable under the mouse cursor). See the select example for an illustration. It may be convenient to set to new qglviewer::Camera::revolveAroundPoint() to the selected point: |
|
Called before draw(). Default behavior clears screen and set the projection and model view matrices :
Emits the drawNeeded() signal once this is done. Mainly useful if you choose not to use derivation to create your own viewer. See the callback example for details. |
|
Called before draw() (instead of preDraw()) when viewer displaysInStereo(). Same as preDraw() except that the glDrawBuffer() is set to |
|
Returns the index of the QGLViewer Returns -1 if the QGLViewer could not be found (which should not be possible). |
|
This QPtrList (see Qt documentation) holds all the created QGLViewer. If you need to apply a method to all the created viewers, use code like this: Classical functions are allready implemented : connectSignalToAllViewers(), disconnectSignalToAllViewers() and updateGLForAllViewers(). See also QGLViewerIndex(). |
|
Reset the mask used by drawVisualHints(). Called by setVisualHintsMask() after 2 seconds to reset the display. |
|
Called when the window size is modified. If you override this function, be very careful to call first the inherited method. |
|
Restores the QGLViewer from a state saved in
If You should define your manipulatedFrame() before you call this function, so that its previous state can be restored. Initialization code put after this function will override saved values.
If you viewer starts with a black screen, remember that the mouse double clicks automatically fits the orientation, zoom and placement of the camera(). If sceneCenter() and sceneRadius() are properly defined, you no longer should have an empty screen. |
|
Same as saveSnapshot(), except that it uses the specified
The file format is determined from snapshotFormat(). A correct file extension will be added if not provided in
Asks for confirmation when file already exists and |
|
Saves a snapshot of the current image displayed by the widget. The image size is equal to the viewer dimension. Saving formats are those available in the Qt library, plus some vectorial formats (EPS, PS, XFIG). Use setSnapshotFormat() to change file format. The image quality (and hence the file size) can be tuned using setSnapshotQuality().
If
When
Then call draw() in a loop (for instance using animate() and/or a camera() KeyFrameInterpolator replay) to create your image sequence. If you want to create a Quicktime VR panoramic sequence, simply use code like this:
When Some artifacts may appear when displaying the PS and EPS result. Simply remove the anti-alias option in ghostview to get the correct display. Printed output will be fine anyway. The libEPSRender library was written by Cyril Soler (Cyril dot Soler at imag dot fr).
|
|
Saves in
If no
If This function is called when a viewer is closed (default key is Escape). |
|
saveToFile() is called on all the created QGLViewers using the QGLViewerPool(). See connectSignalToAllViewers() and disconnectSignalToAllViewers() for more complex connections. |
|
Scene should be included in a sphere centered on this point. Simply calls qglviewer::Camera::sceneCenter(). Set using setSceneCenter(). |
|
Returns the scene radius (used by the camera() to set qglviewer::Camera::zNear() and qglviewer::Camera::zFar()). The entire scene must be included in a sphere of radius sceneRadius(), centered on sceneCenter(). This function is equivalent to camera()->sceneRadius(). |
|
This function performs a selection in the scene from pixel coordinates. It is called when the user clicks on the SELECT ClickAction binded button(s) (default is Shift-LeftButton). This function successively calls four other functions: The default implementation of these functions is as follows (see the functions' documentation for more details) :
glSelectBuffer() man page for details on this GL_SELECT mechanism.This default implementation is quite limited: only the closer object is selected, and only one level of names can be pushed. However, this reveals sufficient in many cases and you usually only have to overload drawWithNames() and maybe postSelection() to implement a simple object selection process. See the select example for an illustration. If you need a more complex selection process (such as a point, edge or triangle selection, which is easier with a 2 or 3 levels selectBuffer() heap, and which requires a finer depth sorting to priviledge point over edge and edges over triangles), overload the endSelection() method. Use setSelectRegionWidth(), setSelectRegionHeight() and setSelectBufferSize() to tune the select buffer configuration. See the multiSelect example for an illustration.
Use setMouseBinding() to customize mouse bindings. See also selectBuffer(), selectBufferSize(), selectRegionWidth() and selectRegionHeight().
|
|
Simple wrapper function : calls
Emits |
|
Returns a pointer to an array of |
|
Returns the current selectBuffer() size. Use setSelectBufferSize() to change this value. Default value is 4000 (i.e. 1000 objects in selection region, since each object pushes 4 values). This size should be over estimated to prevent a buffer overflow when many objects are drawned under the mouse cursor. The default value should however fit most applications. See the select() documentation for details. See also selectRegionWidth() and selectRegionHeight(). |
|
Returns the name (an integer value) of the entity that was last selected by select(). This value is set by endSelection(). See the select() documentation for details. As a convention, this function returns -1 if the selectBuffer() was empty, meaning that no object was selected. Note that this function returns the same value until setSelectedName() is called, which should only be done by endSelection(), and hence only when a selection is performed using select(). Before the first call to select(), the return value is -1. |
|
See the selectRegionWidth() documentation. |
|
This size (in pixels) is used in beginSelection() to define the width of a selection frustum, centered on the mouse cursor, that is used to select objets. See also selectRegionHeight(). The objects that will be drawned in this region by drawWithNames() will be recorded in the selectBuffer(). endSelection() then analyses this buffer and setSelectedName() to the closest object name. See the gluPickMatrix() documentation for details. The default value is 3, which is adapted to standard applications. A smaller value results in a more precise selection but the user has to be careful for small feature selection. See the multiSelect example for an illustration. |
|
Defines the accelerator state key (Qt::AltButton, Qt::ShiftButton, Qt::ControlButton) that must be pressed in conjunction with the keyFrameKey(i) to add a Key Frame to the camera Key Frame path of index
The state key can be set to Use setKeyFrameKey() to define the associated Key Frame key. See also setPlayKeyFramePathStateKey(). See the keyboard accelerator page for details. |
|
Set the period (in milliseconds) between the calls to animate() and draw(). Default is 40 msecs (25 Hz). The frame rate (DISPLAY_FPS default binding is 'F') will be set accordingly, provided that your animate() and draw() functions are fast enough.
If you want to know the maximum possible frame rate of your machine on a given scene, set this value to
|
|
Defines the backgroundColor() of the viewer and calls |
|
Associate a new qglviewer::Camera to the viewer. You should only use this method when you derive a new class from Camera and want to use one of its instances instead of the original class. It you simply want to save and restore Camera positions, use qglviewer::Camera::addKeyFrame() and qglviewer::Camera::playKeyFramePath() instead.
This method will silently ignore NULL
All the
The sceneRadius() and sceneCenter() of the new |
|
Set the state of fpsIsDisplayed(). displayFPS() is called or not. See also toggleDisplayFPS() and currentFPS(). |
|
Set the state of zBufferIsDisplayed(). displayZBuffer() is called or not. See also toggleDisplayZBuffer(). |
|
Set the state of the axisIsDrawn(). World axis is drawn or not. See also toggleDrawAxis(). |
|
Set the state of the gridIsDrawn(). A XY grid is drawn or not. See also toggleDrawGrid(). |
|
Set the state of textIsEnabled() : drawText() and draw3DText() actually draw text or not (default is yes). See also toggleEnableText(). |
|
Defines the foregroundColor(), used to draw viewer visual hints. See foregroundColor() for details. See also setBackgroundColor(). |
|
Viewer is set in full screen mode ( |
|
Defines the keyboard accelerator sequence that triggers a given QGLViewer::KeyboardAction on the viewer. If you want to define keyboard accelerators for custom actions (say, open a scene file), overload keyPressEvent() and then setKeyDescription().
Accelerators are composed of a keyboard key combined with optional modifier keys (CONTROL, ALT, SHIFT and META). The
Set
Use keyboardAccelerator() to retrieve the accelerator that is currently binded to a QGLViewer::KeyboardAction. See also setKeyFrameKey() and setMouseStateKey().
These accelerators are automatically included in the help() window If several KeyboardAction are binded to the same key accelerator, only one of them will be active. If your keyboard accelerator does not work, check it is not allready binded to an other KeyboardAction. See the keyboard accelerator page for details and default values and the keyboardAndMouse example for a practical illustration. |
|
Sets a custom keyboard accelerator description, that will be displayed in the help() window
The
See the keyboardAndMouse example for illustration. See the keyboard page for more details.
The help() window
|
|
Defines the accelerator key associated with the camera Key Frame path of index Use setAddKeyFrameStateKey() and setPlayKeyFramePathStateKey() to define the state key that must be pressed with this key to add (or delete) or play the Key Frame. To delete a Key Frame path, quickly press twice the keyFrameKey() while pressing the addKeyFrameStateKey(). Once a path has been delete, trying to re-play the path (using keyFrameKey() and playKeyFramePathStateKey()) will do nothing until new key frames are added (using keyFrameKey() and addKeyFrameStateKey()). Use setKeyboardAccelerator() to define other keyboard accelerators. See the keyboard accelerator page for details. |
|
The frame You can use a manipulated frame to move an object in the scene. Your code will look like this (see the manipulatedFrame example):
Since a camera() position is defined with a ManipulatedCameraFrame, a Camera frame can be given as a manipulatedFrame(). This is useful for an application with several viewers, where the other viewers' cameras are displayed and can be manipulated (with a direct feedback in the other viewer). Use code like: Defining the own viewer camera()->frame() as the manipulatedFrame() is possible and will result in a classical camera manipulation. See the Luxo example for an illustration. The value of the currently manipulated frame is retrieved with manipulatedFrame(). |
|
This function lets you associate any ClickAction to any Qt::ButtonState mouse button and state key combination. The list of all possible ClickAction, some binding examples and default bindings are provided in the mouse page. See the keyboardAndMouse example for an illustration.
The parameters should read : when the
If
If no mouse button is specified in To discard a specific action mouse binding, use code like:
See also setMouseBinding() and setWheelBinding(). |
|
This function lets you associate any MouseAction to any Qt::ButtonState mouse button and state key combination. The receiver of the mouse events is a MouseHandler (
The parameters should read : when the Alt + Shift + Left button rotates the manipulatedFrame(). setMouseBinding(Qt::AltButton | Qt::ShiftButton | Qt::LeftButton, FRAME, ROTATE); /endcode The list of all possible MouseAction, some binding examples and default bindings are provided in the mouse page. See the keyboardAndMouse example for an illustration.
If no mouse button is specified in To discard a specific mouse binding, use code like:
See also setMouseBinding() and setWheelBinding(). |
|
Sets a custom mouse binding description, that will be displayed in the help() window
See the keyboardAndMouse example for an illustration. See the mouseMoveEvent() documentation for an example of custom mouse binding implementation. See the mouse page for more details. Use setMouseBinding() and setWheelBinding() to change the standard mouse action bindings.
The help() window |
|
Directly defines the QGLViewer's mouseGrabber(). You should not call this function directly as mouseMoveEvent() already does it using qglviewer::MouseGrabber::checkIfGrabsMouse(). |
|
Associate a given state key (Alt, Shift, Control or a combinaison of these) to a specific MouseHandler. All the mouse handler's associated bindings will then need the specified With this code, you will have to press the Alt key while pressing mouse buttons in order to move the camera, while no key will be needed to move the associated manipulatedFrame().
This function is provided for convenience but its implementation is basic. Indeed, every action binded to
The default binding configuration binds
the FRAME bindings would have replaced all the previous CAMERA bindings (as CAMERA uses NoButton by default). A call to : would then have done nothing as no more actions are binded to the CAMERA. See the QGLViewer mouse page for details. |
|
Defines the accelerator state key (Qt::AltButton, Qt::ShiftButton, Qt::ControlButton) that must be pressed in conjunction with the keyFrameKey(i) to start playing the camera Key Frame path of index
The state key can be set to Use setKeyFrameKey() to define the associated Key Frame key. See also setAddKeyFrameStateKey(). See the keyboard accelerator page for details. |
|
Same as setSceneBoundingBox(), with float[3] parameters. |
|
Convenient way to call setSceneCenter() and setSceneRadius() from a Bounding Box of the scene. Equivalent to :
|
|
float version of setSceneCenter(). |
|
Set the center of the scene, defined in world coordinates. The entire scene should be include in a sphere of radius sceneRadius(), centered on sceneCenter(). Default value is (0,0,0), the world coordinate system origin. This method should typically be called in the init() function, when the drawn scene is not centered on the world origin (so that sceneRadius(), qglviewer::Camera::zNear() and qglviewer::Camera::zFar() can be tightly fitted to the scene). It should normally not be modified after. See also setSceneBoundingBox().
The qglviewer::Camera::revolveAroundPoint() has a different meaning, and is probably the value you want to change while the program is running (see qglviewer::Camera::setRevolveAroundPoint()).
|
|
Scene radius is used by the camera to scale axis and grid display, and to optimally set qglviewer::Camera::zNear() and qglviewer::Camera::zFar(). The entire scene must be included in a sphere centered on sceneCenter(), with radius sceneRadius(). Current value can be retrieved from sceneRadius(). You will typically use this function in QGLViewer::init() :
The default sceneRadius() is 1.0. See also setSceneCenter() and setSceneBoundingBox(). The camera() qglviewer::Camera::flySpeed() is set to 1% of this value by this function.
|
|
Changes the selectBufferSize(). The previous selectBuffer() is deleted and a new one is created. Default value is 4000 (enables 1000 objects in the selection region). |
|
Set the selectedName() value. Called by endSelection() during a selection. You should only call this method if you overload the endSelection() function. |
|
Changes the selectRegionHeight(). Default value is 3 pixels. |
|
Changes the selectRegionWidth(). Default value is 3 pixels. |
|
Deprecated function. Use setKeyboardAccelerator() instead. Should still work. |
|
Deprecated function. Use setKeyboardAccelerator() instead. Does nothing. |
|
Defines the new snapshotCounter() value. |
|
Sets the filename to use when saving snapshot with saveSnapshot(). If the filename is relative, the current working directory at the moment of the function call is added. snapshotFilename() returns the current snapshot file name. |
|
Defines the snapshot file format. This format will be used by saveSnapshot() in automatic mode. In non-automatic mode, this will be the default format of the saveAs dialog box.
The available formats are those handled by Qt. Classical values are
If the library was compiled with the EPSRender option, three additional vectorial formats are available: The default snapshotFormat() is the first available one in the above list. See also openSnapshotFormatDialog();
|
|
Defines the snapshotQuality() value. Ranges between 0 (worst) and 100 (best). Default is 95. A -1 value means use default Qt quality. |
|
Activates stereo mode (resp. switch back to mono when The QGLViewer instance must be created with a stereo format to handle stereovision: See the stereoViewer example. The stereo parameters are defined by the camera(). See qglviewer::Camera::setIODist(), qglviewer::Camera::setDistanceToScreen(), qglviewer::Camera::setDistanceToZeroParallaxPlane() and qglviewer::Camera::setPhysicalScreenWidth(). |
|
Defines the mask that will be used to drawVisualHints(). The only available mask is currently 1, corresponding to the display of the qglviewer::Camera::revolveAroundPoint(). resetVisualHints() is automatically called after |
|
Associates a MouseAction to a mouse wheel event. The wheel event is received by
In the current implementation only MouseAction::ZOOM can be associated with See the mouse page for a list of all possible MouseAction, some binding examples and default bindings. See the keyboardAndMouse example for an illustration. The difference between ZOOM and MOVE_FORWARD is that ZOOM speed depends on the distance to the object, while MOVE_FORWARD depends on qglviewer::ManipulatedCameraFrame::flySpeed(). |
|
Deprecated function. Use keyboardAccelerator() instead. Still works with simple QKeySequence. |
|
Deprecated function. Use keyboardAccelerator() instead. Still works with simple QKeySequence. |
|
Set camera so that the entire scene is visible. This method should be called in init(), usually after setSceneRadius(), setSceneCenter() or qglviewer::Camera::setType(). This function simply calls qglviewer::Camera::showEntireScene(). It is called in the QGLViewer constructor, but with default scene parameters (sceneRadius() = 1.0, sceneCenter()=0,0,0 and qglviewer::Camera::type=PERSPECTIVE) that may not correspond to your scene. That is the reason why you should call it in init(), or use restoreFromFile() instead. |
|
Returns the recommended size for the QGLViewer. Default is 600x400 pixels. |
|
The current value of the counter used to name snapshots in saveSnapshot() when |
|
Returns the current snapshot filename. Set by setSnapshotFilename(). Used in saveSnapshot(). |
|
Returns the current snapshot file format. Defined from the File Dialog window or with setSnapshotFormat(). Default value is the first available in "JPEG, PNG, EPS, PS, PPM, BMP". |
|
Defines the image quality of the snapshots produced with saveSnapshot(). Default value is 95. Values must be in the range -1..100. Specify 0 to obtain small compressed files, 100 for large uncompressed files, and -1 for snapshotFormat() default quality. Set using setSnapshotQuality(). See also the snapshotFormat(), snapshotCounter() and QImage::save() documentation. |
|
Start the animation loop. animate() and draw() will be called in a loop. The loop frequency is defined by animationPeriod() (default is 40 msecs=25Hz). See also stopAnimation() and animate(). See the animation example for illustration. You may also be interested in qglviewer::KeyFrameInterpolator::startInterpolation(). |
|
Use this function when you want to start drawing directly with the 2D screen coordinates system in your draw() function. Once this function has been called, the
The coordinates origin (0,0) is in the upper left corner of the window by default. This follows the Qt standards and make it easier to directly use The select() function is an example of sensitivity to the orientation of the coordinates system. It assumes an origin in the upper left corner. You need to call stopScreenCoordinatesSystem() at the end of the drawing block to restore the previous camera matrix. See the screenCoordSystem, multiSelect and backgroundImage examples for an illustration. You may want to change GL state when drawing in 2D, such as for instance:
Use qglviewer::Camera::projectedCoordinatesOf() to compute the 2D projection on screen of a 3D point (see the screenCoordSystem example).
You will usually disable
|
|
This signal is emitted whenever displaysInStereo() changes value. This can be done with setStereoDisplay() or toggleStereoDisplay(). |
|
Stop an animation started with startAnimation() or toggleAnimationMode(). |
|
This function closes the screen coordinates drawing block that was started by startScreenCoordinatesSystem(). The
|
|
This signal is emitted whenever textIsEnabled() changes value. This can be done with setEnableText() or toggleEnableText(). |
|
Returns |
|
Overloading of the timer function. If animationIsStarted(), calls animate() and then draw(), at a frequency set by setAnimationPeriod(). |
|
Calls startAnimation() or stopAnimation(), depending on animationIsStarted(). |
|
Swaps between two predefined camera mouse bindings. This function is provided for backward compatibility since version 1.3.4. It simply defines preset mouse bindings as could be done using setMouseBinding(). The first mode makes the camera observe the scene while revolving around the qglviewer::Camera::revolveAroundPoint(). The second mode is designed for walkthrough applications and simulates a flying camera. Practically, the three mouse buttons are respectly binded to :
The |
|
Start/stop the edition of the camera paths (default EDIT_CAMERA_PATHS keyboard accelerator is 'C'). See cameraPathIsEdited(). See also editCameraPath(). |
|
Toggle the state of fpsIsDisplayed(). displayFPS() is called or not (default DISPLAY_FPS keyboard accelerator is 'F'). See also setDisplayFPS() and currentFPS(). |
|
Toggle the state of zBufferIsDisplayed(). displayZBuffer() is called or not (default DISPLAY_Z_BUFFER keyboard accelerator is 'Z'). See also setDisplayZBuffer(). |
|
Toggle the state of axisIsDrawn(). A world axis is drawn or not (default DRAW_AXIS keyboard accelerator is 'A'). See also setDrawAxis(). |
|
Toggle the state of gridIsDrawn() flag. A XY grid is drawn or not (default DRAW_GRID keyboard accelerator is 'G'). See also setDrawGrid(). |
|
Toggle the state of textIsEnabled() : drawText() and draw3DText() actually draw text or not (default is yes) (default ENABLE_TEXT keyboard accelerator is '?'). See also setEnableText(). |
|
Viewer is toggled between normal and full screen mode (FULL_SCREEN keyboard accelerator, default is Alt-Enter, see the keyboard accelerator page). See setFullScreen() and isFullScreen(). |
|
Toggle the state of displaysInStereo() (default STEREO keyboard accelerator is 'S'). See setStereoDisplay() for details. See the stereoViewer example for an illustration. |
|
updateGL() is called on all the created QGLViewers. All the viewers will have their display updated. See also QGLViewerPool(). Use connectSignalToAllViewers() and disconnectSignalToAllViewers() for more complex connections. |
|
Signal emitted by the default QGLViewer::init() function. Connect this signal to the functions that need to be called before any drawing (if any), to initialize your viewer. Use this signal-slot mechanism ONLY IF you don't inherit your viewer from QGLViewer (in that case, simply overload the init() function). |
|
Same as mouseAction(), but for the wheel action. |
|
Same as mouseButtonState(), but for the wheel.
|
|
The wheel associated event is controled using setWheelBinding(). Default behavior simulates a ZOOM action. See the QGLViewer mouse page and setWheelBinding() for details. Depending on your system configuration, you may have to actually press the wheel while wheeling. |
|
Same as mouseHandler but for the wheel action. |
|
This signal is emitted whenever zBufferIsDisplayed() changes value. This can be done with setDisplayZBuffer() or toggleDisplayZBuffer(). |
|
Returns |