QGLViewer Class Reference

A versatile 3D OpenGL viewer based on QGLWidget. More...

List of all members.

Display of visual hints

bool axisIsDrawn () const
bool gridIsDrawn () const
bool FPSIsDisplayed () const
bool textIsEnabled () const
bool zBufferIsDisplayed () const
bool cameraIsEdited () const
void setAxisIsDrawn (bool draw=true)
void setGridIsDrawn (bool draw=true)
void setFPSIsDisplayed (bool display=true)
void setTextIsEnabled (bool enable=true)
void setZBufferIsDisplayed (bool display=true)
void setCameraIsEdited (bool edit=true)
void toggleAxisIsDrawn ()
void toggleGridIsDrawn ()
void toggleFPSIsDisplayed ()
void toggleTextIsEnabled ()
void toggleZBufferIsDisplayed ()
void toggleCameraIsEdited ()

Viewer's colors

QColor backgroundColor () const
QColor foregroundColor () const
void setBackgroundColor (const QColor &color)
void setForegroundColor (const QColor &color)

Scene dimensions

float sceneRadius () const
qglviewer::Vec sceneCenter () const
void setSceneRadius (float radius)
void setSceneCenter (const qglviewer::Vec &center)
void setSceneBoundingBox (const qglviewer::Vec &min, const qglviewer::Vec &max)
void showEntireScene ()

Associated objects

qglviewer::Cameracamera () const
qglviewer::ManipulatedFramemanipulatedFrame () const
void setCamera (qglviewer::Camera *const camera)
void setManipulatedFrame (qglviewer::ManipulatedFrame *frame)

Mouse grabbers

qglviewer::MouseGrabbermouseGrabber () const
void setMouseGrabberIsEnabled (const qglviewer::MouseGrabber *const mouseGrabber, bool enabled=true)
bool mouseGrabberIsEnabled (const qglviewer::MouseGrabber *const mouseGrabber)
void setMouseGrabber (qglviewer::MouseGrabber *mouseGrabber)

State of the viewer

float aspectRatio () const
float currentFPS ()
bool isFullScreen () const
bool displaysInStereo () const
virtual QSize sizeHint () const
void setFullScreen (bool fullScreen=true)
void setStereoDisplay (bool stereo=true)
void toggleFullScreen ()
void toggleStereoDisplay ()
void toggleCameraMode ()

Display methods

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 delay=2000)
static void drawArrow (float length=1.0f, float radius=-1.0f, int nbSubdivisions=12)
static void drawAxis (float length=1.0f)
static void drawGrid (float size=1.0f, int nbSubdivisions=10)
virtual void drawLight (GLenum light, float scale=1.0f) const

Useful inherited methods

int width () const
int height () const
virtual void updateGL ()
void qglColor (const QColor &color) const
void qglClearColor (const QColor &color) const
bool isValid () const
bool isSharing () const
virtual void makeCurrent ()
bool hasMouseTracking () const
virtual void resize (int width, int height)
virtual void setMouseTracking (bool enable)
static QImage convertToGLFormat (const QImage &image)
bool autoBufferSwap () const
void setAutoBufferSwap (bool on)

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 &name)
void setSnapshotFormat (const QString &format)
void setSnapshotCounter (int counter)
void setSnapshotQuality (int quality)
void openSnapshotFormatDialog ()

Buffer to texture

GLuint bufferTextureId () const
float bufferTextureMaxU () const
float bufferTextureMaxV () const
void copyBufferToTexture (GLint internalFormat, GLenum format=GL_NONE)

Animation

bool animationIsStarted () const
int animationPeriod () const
void setAnimationPeriod (int period)
virtual void startAnimation ()
virtual void stopAnimation ()
virtual void animate ()
void toggleAnimation ()

Help window

virtual QString helpString () const
virtual QString mouseString () const
virtual QString keyboardString () const
virtual void help ()
virtual void aboutQGLViewer ()
QTabWidget * helpWidget ()

Object selection

int selectedName () const
int selectBufferSize () const
int selectRegionWidth () const
int selectRegionHeight () const
GLuint * selectBuffer ()
virtual void select (const QMouseEvent *event)
virtual void select (const QPoint &point)
void setSelectBufferSize (int size)
void setSelectRegionWidth (int width)
void setSelectRegionHeight (int height)
void setSelectedName (int id)
virtual void beginSelection (const QPoint &point)
virtual void drawWithNames ()
virtual void endSelection (const QPoint &point)
virtual void postSelection (const QPoint &point)

Keyboard customization

int shortcut (KeyboardAction action) const
Qt::Key pathKey (int index) const
Qt::ButtonState addKeyFrameStateKey () const
Qt::ButtonState playPathStateKey () const
void setShortcut (KeyboardAction action, int key)
void setKeyDescription (int key, QString description)
virtual void setPathKey (int key, int index=0)
virtual void setPlayPathStateKey (int buttonState)
virtual void setAddKeyFrameStateKey (int buttonState)
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, MOVE_CAMERA_LEFT, MOVE_CAMERA_RIGHT, MOVE_CAMERA_UP, MOVE_CAMERA_DOWN, INCREASE_FLYSPEED,
  DECREASE_FLYSPEED
}

Mouse customization

MouseAction mouseAction (int buttonState) const
int mouseHandler (int buttonState) const
Qt::ButtonState mouseButtonState (MouseHandler handler, MouseAction action, bool withConstraint=true) const
ClickAction clickAction (int buttonState, bool doubleClick, int buttonBefore) const
void getClickButtonState (ClickAction action, Qt::ButtonState &buttonState, bool &doubleClick, Qt::ButtonState &buttonBefore) const
MouseAction wheelAction (int buttonState) const
int wheelHandler (int buttonState) const
int wheelButtonState (MouseHandler handler, MouseAction action, bool withConstraint=true) const
void setMouseBinding (int buttonState, MouseHandler handler, MouseAction action, bool withConstraint=true)
void setMouseBinding (int buttonState, ClickAction action, bool doubleClick=false, int buttonBefore=Qt::NoButton)
void setWheelBinding (int buttonState, MouseHandler handler, MouseAction action, bool withConstraint=true)
void setMouseBindingDescription (int buttonState, QString description, bool doubleClick=false)
void setHandlerStateKey (MouseHandler handler, int buttonState)
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
}

State persistence

QString stateFileName () const
virtual QDomElement domElement (const QString &name, QDomDocument &document) const
virtual void initFromDOMElement (const QDomElement &element)
virtual void saveStateToFile ()
virtual bool restoreStateFromFile ()
void setStateFileName (const QString &name)

QGLViewer pool

static const QPtrList< QGLViewer > & QGLViewerPool ()
static int QGLViewerIndex (const QGLViewer *const viewer)

Drawing methods

virtual void resizeGL (int width, int height)
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 ()

Mouse, keyboard and event handlers

virtual void mousePressEvent (QMouseEvent *)
virtual void mouseMoveEvent (QMouseEvent *)
virtual void mouseReleaseEvent (QMouseEvent *)
virtual void mouseDoubleClickEvent (QMouseEvent *)
virtual void wheelEvent (QWheelEvent *)
virtual void keyPressEvent (QKeyEvent *)
virtual void timerEvent (QTimerEvent *)
virtual void closeEvent (QCloseEvent *)

Signals

void viewerInitialized ()
void drawNeeded ()
void drawFinished (bool dummy)
void animateNeeded ()
void helpRequired ()
void axisIsDrawnChanged (bool drawn)
void gridIsDrawnChanged (bool drawn)
void FPSIsDisplayedChanged (bool displayed)
void textIsEnabledChanged (bool enabled)
void cameraIsEditedChanged (bool edited)
void zBufferIsDisplayedChanged (bool displayed)
void stereoChanged (bool on)
void pointSelected (const QMouseEvent *e)
void mouseGrabberChanged (qglviewer::MouseGrabber *mouseGrabber)

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 ()


Detailed Description

A versatile 3D OpenGL viewer based on QGLWidget.

It features 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.

New users should read the introduction page to get familiar with important notions such as sceneRadius(), sceneCenter() and the world coordinate system. Try the numerous simple examples to discover the possibilities and understand how it works.

Usage

To use a QGLViewer, derive you viewer class from the QGLViewer and overload its draw() virtual method. See the commented code of the simpleViewer example for details.

An other option is to connect your drawing methods to the signals emitted by the QGLViewer (clean callback mechanism). See the callback example for a complete implementation.


Member Enumeration Documentation

enum ClickAction [protected]
 

Defines the possible actions that can be binded to a mouse click using setMouseBinding(int,ClickAction,bool,int).

See the mouse page for details.

Enumerator:
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 KeyboardAction [protected]
 

Defines the different actions that can be associated with a keyboard shortcut using setShortcut().

See the keyboard page for details.

Enumerator:
DRAW_AXIS 
DRAW_GRID 
DISPLAY_FPS 
DISPLAY_Z_BUFFER 
ENABLE_TEXT 
EXIT_VIEWER 
SAVE_SCREENSHOT 
CAMERA_MODE 
FULL_SCREEN 
STEREO 
ANIMATION 
HELP 
EDIT_CAMERA 
MOVE_CAMERA_LEFT 
MOVE_CAMERA_RIGHT 
MOVE_CAMERA_UP 
MOVE_CAMERA_DOWN 
INCREASE_FLYSPEED 
DECREASE_FLYSPEED 

enum MouseAction [protected]
 

Defines the possible actions that can be binded to a mouse motion (a click, followed by a mouse displacement).

These actions may be binded to the camera() or to the manipulatedFrame() (see QGLViewer::MouseHandler) using setMouseBinding().

Enumerator:
NO_MOUSE_ACTION 
ROTATE 
ZOOM 
TRANSLATE 
MOVE_FORWARD 
LOOK_AROUND 
MOVE_BACKWARD 
SCREEN_ROTATE 
ROLL 
SCREEN_TRANSLATE 
ZOOM_ON_REGION 

enum MouseHandler [protected]
 

Defines the different mouse handlers: camera() or manipulatedFrame().

Used by setMouseBinding(), setMouseBinding(int, ClickAction, bool, int) and setWheelBinding() to define which handler receives the mouse events.

Enumerator:
CAMERA 
FRAME 


Constructor & Destructor Documentation

QGLViewer QWidget *  parent = NULL,
const char *  name = 0,
const QGLWidget *  shareWidget = 0,
WFlags  flags = 0
[explicit]
 

Implementation of the QGLWidget associated constructor.

The display flags, scene parameters, associated objects... are all set to their default values. See documentation.

If the shareWidget parameter points to a valid QGLWidget, the QGLViewer will share the OpenGL context with shareWidget (see isSharing()).

QGLViewer const QGLFormat &  format,
QWidget *  parent = 0,
const char *  name = 0,
const QGLWidget *  shareWidget = 0,
WFlags  flags = 0
[explicit]
 

Implementation of the QGLWidget associated constructor.

Same as QGLViewer(), but a Qt::QGLFormat can be provided. This is for instance needed for stereo display as is illustrated in the stereoViewer example.

QGLViewer QGLContext *  context,
QWidget *  parent,
const char *  name = 0,
const QGLWidget *  shareWidget = 0,
WFlags  flags = 0
 

Implementation of the QGLWidget associated constructor.

Same as QGLViewer(), but a Qt::QGLContext can be provided so that viewers share GL contexts, even with QGLContext sub-classes.

Note:
This constructor is only available with Qt versions greater or equal than 3.2. The provided context is simply ignored otherwise.

~QGLViewer  )  [virtual]
 

Virtual destructor.

Removes viewer from QGLViewerPool() and releases allocated memory. The camera() is deleted and should be copied before if it is shared.


Member Function Documentation

void aboutQGLViewer  )  [virtual, slot]
 

Opens an about dialog.

Default implementation displays libQGLViewer version, copyright notice and web site.

Qt::ButtonState addKeyFrameStateKey  )  const
 

Returns the state key that must be pressed with a pathKey() to add the current camera position to a KeyFrame path.

It can be Qt::NoButton, Qt::ControlButton, Qt::ShiftButton, Qt::AltButton, or a combination of these (using the bit '|' operator, see setHandlerStateKey()). Default value is Qt::AltButton, defined using setAddKeyFrameStateKey().

See also playPathStateKey().

virtual void animate  )  [virtual, slot]
 

Scene animation method.

When animationIsStarted(), this method is in charge of the scene update before each draw(). Overload it to define how your scene evolves over time. The time should either be regularly incremented in this method (frame-rate independent animation) or computed from actual time (for instance using QTime::elapsed()) for real-time animations.

Note that KeyFrameInterpolator (which regularly updates a Frame) do not use this method but rather rely on a QTimer signal-slot mechanism.

See the animation example for an illustration.

void animateNeeded  )  [signal]
 

Signal emitted by the default animate() method.

Connect this signal to your scene animation method or overload animate().

bool animationIsStarted  )  const
 

Return true when the animation loop is started.

During animation, an infinite loop calls animate() and draw() and then waits for animationPeriod() milliseconds before calling animate() and draw() again. And again.

Use startAnimation(), stopAnimation() or toggleAnimation() to change this value.

See the animation example for illustration.

int animationPeriod  )  const
 

The animation loop period, in milliseconds.

When animationIsStarted(), this is delay waited after draw() to call animate() and draw() again. Default value is 40 milliseconds (25 Hz).

This value will define the currentFPS() when animationIsStarted() (provided that your animate() and draw() methods are fast enough).

If you want to know the maximum possible frame rate of your machine on a given scene, setAnimationPeriod() to 0, and startAnimation() (keyboard shortcut is Enter). The display will then be updated as often as possible, and the frame rate will be meaningful.

Note:
This value is taken into account only the next time you call startAnimation(). If animationIsStarted(), you should stopAnimation() first.

float aspectRatio  )  const
 

Returns the aspect ratio of the viewer's widget (width() / height()).

bool autoBufferSwap  )  const [protected]
 

Returns true when buffers are automatically swapped (default). See details in the QGLWidget documentation.

bool axisIsDrawn  )  const
 

Returns true if the world axis is drawn by the viewer.

Set by setAxisIsDrawn() or toggleAxisIsDrawn(). Default value is false.

void axisIsDrawnChanged bool  drawn  )  [signal]
 

This signal is emitted whenever axisIsDrawn() changes value.

QColor backgroundColor  )  const
 

Returns the background color of the viewer.

This method is provided for convenience since the background color is an OpenGL state variable set with glClearColor(). However, this internal representation has the advantage that it is saved (resp. restored) with saveStateToFile() (resp. restoreStateFromFile()).

Use setBackgroundColor() to define and activate a background color.

Attention:
Each QColor component is an integer ranging from 0 to 255. This differs from the float values used by glClearColor() which are in the 0.0-1.0 range. Default value is (51, 51, 51) (dark gray). You may have to change foregroundColor() accordingly.

This method does not return the current OpenGL clear color as glGet() does. Instead, it returns the QGLViewer internal variable. If you directly use glClearColor() or qglClearColor() instead of setBackgroundColor(), the two results will differ.

void beginSelection const QPoint &  point  )  [protected, virtual]
 

This method should prepare the selection. It is called by select() before drawWithNames().

The default implementation uses the GL_SELECT mode to perform a selection. It uses selectBuffer() and selectBufferSize() to define a glSelectBuffer(). The GL_PROJECTION is then set using gluPickMatrix(), with a window selection size defined by selectRegionWidth() and selectRegionHeight(). Finally, the GL_MODELVIEW matrix is set to the world coordinate system using qglviewer::Camera::loadModelViewMatrix(). See the gluPickMatrix() documentation for details.

You should not need to redefine this method (if you use the GL_SELECT mode to perform your selection), since this code is fairly classical and can be tuned. You are more likely to overload endSelection() if you want to use a more complex select buffer structure.

GLuint bufferTextureId  )  const
 

Returns the texture id of the texture created by copyBufferToTexture().

Use glBindTexture() to use this texture. Note that this is already done by copyBufferToTexture().

Returns 0 is copyBufferToTexture() was never called or if the texure was deleted using glDeleteTextures() since then.

float bufferTextureMaxU  )  const
 

Returns the texture coordinate corresponding to the u extremum of the bufferTexture.

The bufferTexture is created by copyBufferToTexture(). The texture size has powers of two dimensions and the buffer image hence only fills a part of it. This value corresponds to the u coordinate of the extremum right side of the buffer image.

Use (0,0) to (bufferTextureMaxU(), bufferTextureMaxV()) texture coordinates to map the entire texture on a quad.

float bufferTextureMaxV  )  const
 

Same as bufferTextureMaxU(), but for the v texture coordinate.

qglviewer::Camera* camera  )  const
 

Returns the associated qglviewer::Camera, never NULL.

bool cameraIsEdited  )  const
 

Returns true if the camera() is being edited in the viewer.

Set by setCameraIsEdited() or toggleCameraIsEdited(). Default value is false.

The current implementation is limited: the defined camera() paths (see qglviewer::Camera::keyFrameInterpolator()) are simply displayed using qglviewer::Camera::drawAllPaths(). Actual camera and path edition will be implemented in the future.

void cameraIsEditedChanged bool  edited  )  [signal]
 

This signal is emitted whenever cameraIsEdited() changes value..

QGLViewer::ClickAction clickAction int  buttonState,
bool  doubleClick,
int  buttonBefore
const
 

Same as mouseAction(), but for the ClickAction set using setMouseBinding().

void closeEvent QCloseEvent *  e  )  [protected, virtual]
 

Overloading of the QWidget method.

Saves the viewer state using saveStateToFile() and then calls QGLWidget::closeEvent().

static QImage convertToGLFormat const QImage &  image  )  [static]
 

Converts image into the unnamed format expected by OpenGL methods such as glTexImage2D(). See QGLWidget documentation.

void copyBufferToTexture GLint  internalFormat,
GLenum  format = GL_NONE
[slot]
 

float currentFPS  ) 
 

Returns the current averaged viewer frame rate.

This value is computed and averaged over 20 successive frames. It only changes every 20 draw() (previously computed value is otherwise returned).

This method is useful for true real-time applications that may adapt their computational load accordingly in order to maintain a given frequency.

This value is meaningful only when draw() is regularly called, either using a QTimer, when animationIsStarted() or when the camera is manipulated with the mouse.

void displayMessage const QString &  message,
int  delay = 2000
 

Briefly displays a message in the lower left corner of the widget. Convenient to provide feedback to the user.

message is displayed during delay milliseconds (default is 2 seconds) using drawText().

This method should not be called in draw(). If you want to display a text in each draw(), use drawText() instead.

If this method is called when a message is already displayed, the new message replaces the old one. Use setTextIsEnabled() (default shortcut is '?') to enable or disable text (and hence messages) display.

bool displaysInStereo  )  const
 

Returns true if the viewer displays in stereo.

The QGLViewer object must be created with a stereo format to handle stereovision:

  QGLFormat format;
  format.setStereoDisplay( TRUE );
  QGLViewer viewer(format);
The hardware needs to support stereo display. Try the stereoViewer example to check.

Set by setStereoDisplay() or toggleStereoDisplay(). Default value is false.

The stereo parameters are defined by the camera(). See qglviewer::Camera::setIODistance(), qglviewer::Camera::setPhysicalDistanceToScreen(), qglviewer::Camera::setPhysicalScreenWidth() and qglviewer::Camera::setFocusDistance().

QDomElement domElement const QString &  name,
QDomDocument &  document
const [virtual]
 

Returns an XML QDomElement that represents the QGLViewer.

Used by saveStateToFile(). restoreStateFromFile() uses initFromDOMElement() to restore the QGLViewer state from the resulting QDomElement.

name is the name of the QDomElement tag. doc is the QDomDocument factory used to create QDomElement.

The created QDomElement contains state values (axisIsDrawn(), FPSIsDisplayed(), isFullScreen()...), viewer geometry, as well as camera() (see qglviewer::Camera::domElement()) and manipulatedFrame() (if defined, see qglviewer::ManipulatedFrame::domElement()) states.

Overload this method to add your own attributes to the state file:

 QDomElement Viewer::domElement(const QString& name, QDomDocument& document) const
 {
   QDomElement de = document.createElement("Light");
   de.setAttribute("state", (lightIsOn()?"on":"off"));
   de.appendChild(lightManipulatedFrame()->domElement("LightFrame", document));

   // Get default state domElement and append custom node
   QDomElement res = QGLViewer::domElement(name, document);
   res.appendChild(de);
   return res;
 }
See initFromDOMElement() for the associated restoration code.

Attention:
For the manipulatedFrame(), qglviewer::Frame::constraint() and qglviewer::Frame::referenceFrame() are not saved. See qglviewer::Frame::domElement().

virtual void draw  )  [protected, virtual]
 

The core method of the viewer, that draws the scene.

If you build a class that inherits from QGLViewer, this is the method you want to overload. See the simpleViewer example for an illustration.

The camera modelView matrix set in preDraw() converts from the world to the camera coordinate systems. Vertices given in draw() can then be considered as being given in the world coordinate system. The camera is moved in this world using the mouse. This representation is much more intuitive than the default camera-centric OpenGL standard.

Attention:
The GL_PROJECTION matrix should not be modified by this method, to correctly display visual hints (axis, grid, FPS...) in postDraw(). Use push/pop or call camera()->loadProjectionMatrix() at the end of draw() if you need to change the projection matrix (unlikely). On the other hand, the GL_MODELVIEW matrix can be modified and left in a arbitrary state.

void drawArrow float  length = 1.0f,
float  radius = -1.0f,
int  nbSubdivisions = 12
[static]
 

Draws a 3D arrow along the positive Z axis.

length, radius and nbSub subdivisions define its geometry. If radius is negative (default), it is set to 0.06 * length.

Uses current color and does not modify the OpenGL state. Change the modelView to place the arrow in 3D (see qglviewer::Frame::matrix()).

void drawAxis float  length = 1.0f  )  [static]
 

Draws an XYZ axis, with a given size (default is 1.0).

The axis position and orientation depends on the current modelView matrix state. Use the following code to display the current position and orientation of a qglviewer::Frame:

  glPushMatrix();
  glMultMatrixd(frame.matrix());
  QGLViewer::drawAxis(sceneRadius() / 5.0); // Or any scale
  glPopMatrix();

The current color is used to draw the X, Y and Z characters at the extremities of the three arrows. The OpenGL state is modified: GL_LIGHTING and GL_COLOR_MATERIAL are enabled and line width is set to 2.0.

axisIsDrawn() uses this method to draw a representation of the world coordinate system. See also QGLViewer::drawArrow().

void drawFinished bool  dummy  )  [signal]
 

Signal emitted at the end of the QGLViewer::paintGL() method, when frame is drawn.

Can be used to notify an image grabbing process 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, in order to create a movie:

  connect(viewer, SIGNAL(drawFinished(bool)), SLOT(saveSnapshot(bool)));

The dummy bool variable is always true and has been added so that the signal can be connected to saveSnapshot() with an automatic value set to true.

void drawGrid float  size = 1.0f,
int  nbSubdivisions = 10
[static]
 

Draws a grid in the XY plane, centered on (0,0,0).

size (OpenGL units) and nbSubdivisions define its geometry. Set the GL_MODELVIEW matrix to place and orientate the grid in 3D space. See the drawAxis() documentation.

Attention:
The OpenGL state is modified by this method: GL_LIGHTING is disabled and line width is set to 1.

void drawLight GLenum  light,
float  scale = 1.0f
const [protected, virtual]
 

Draws a representation of light.

Called in draw(), this method is useful to debug or display your light setup. Light drawing depends on the type of light (point, spot, directional).

The method retrieves the light setup using glGetLightfv. Position and define your lights before calling this method.

Light is drawn using its diffuse color. Disabled lights are not displayed.

Drawing size is proportional to sceneRadius(). Use scale to rescale it.

See the drawLight example for an illustration.

Attention:
You need to enable GL_COLOR_MATERIAL before calling this method. glColor is set to the light diffuse color.

void drawNeeded  )  [signal]
 

Signal emitted by the default draw() method.

Connect this signal to your main drawing method or overload draw(). See the callback example for an illustration.

void drawText int  x,
int  y,
const QString &  text,
const QFont &  fnt = QFont()
 

Draws text at position x, y (expressed in screen coordinates pixels, origin in the upper left corner of the widget).

The default QApplication::font() is used to render the text when no fnt is specified. Use QApplication::setFont() to define this default font.

You should disable GL_LIGHTING before this method so that colors are properly rendered.

This method can be used in conjunction with the qglviewer::Camera::projectedCoordinatesOf() method to display a text attached to an object. In your draw() method use:

  qglviewer::Vec screenPos = camera()->projectedCoordinatesOf(myFrame.position());
  drawText((int)screenPos[0], (int)screenPos[1], "My Object");
See the screenCoordSystem example for an illustration.

Text is displayed only when textIsEnabled() (default). This mechanism allows the user to conveniently remove all the displayed text with a single keyboard shortcut.

Use displayMessage() to drawText() for only a short amount of time.

Use the QGLWidget::renderText(x,y,z, text) method (Qt version >= 3.1) to draw a text (fixed size, facing the camera) located at a specific 3D position instead of 2D screen coordinates.

The GL_MODELVIEW and GL_PROJECTION matrices are not modified by this method.

Attention:
This method uses display lists to render the characters, with an index that starts at 2000 by default (see the QGLWidget::renderText() documentation). If you use more than 2000 Display Lists, they may overlap. Directly use QGLWidget::renderText() in that case, with a higher listBase parameter.

There is a problem with anti-aliased font with nVidia cards and Qt versions lower than 3.3. Until this version, the fnt parameter is not taken into account to prevent a crash. It is replaced by a fixed font that should be compatible with the qtconfig anti-aliased font configuration (disable this option otherwise).

Note:
This method calls QGLWidget::renderText() if your Qt version is at least 3.1, otherwise it uses GLUT. The Qt minimum version that disables GLUT is set by QT_VERSION_WITHOUT_GLUT in config .h. Default value is 3.1. Only the fnt size (set with QFont::setPixelSize() or QFont::setPointSize()) is taken into account with the GLUT version.

With Qt versions < QT_VERSION_WITHOUT_GLUT, each call to drawText() changes the camera projection matrix and restores it back (using startScreenCoordinatesSystem() and stopScreenCoordinatesSystem()). If you call this method several times and it slows down your frame rate, consider factorizing the context changes.

virtual void drawWithNames  )  [protected, virtual]
 

This method is called by select() and should draw selectable entities.

Default implementation is empty. Overload and draw the different elements of your scene you want to be able to select. The default select() implementation relies on the GL_SELECT, and requires that each selectable element is drawn within a glPushName() - glPopName() block. A typical usage would be (see the select example):

  void Viewer::drawWithNames()
  {
    for (int i=0; i<nbObjects; ++i)
    {
      glPushName(i);
      object(i)->draw();
      glPopName();
    }
  }

The resulting selected name is computed by endSelection(), which setSelectedName() to the integer id pushed by this method (a value of -1 means no selection). Use selectedName() to update your selection, probably in the postSelection() method.

void endSelection const QPoint &  point  )  [protected, virtual]
 

This method is called by select() after scene elements were drawn by drawWithNames(). It should analyze the selection result to determine which object is actually selected.

The default implementation relies on GL_SELECT mode (see beginSelection()). It assumes that names were pushed and popped in drawWithNames(), and analyzes the selectBuffer() to find the name that corresponds to the closer (z min) object. It then setSelectedName() to this value, or to -1 if the selectBuffer() is empty (no object drawn in selection region). Use selectedName() (probably in the postSelection() method) to retrieve this value and update your data structure accordingly.

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 privileging points over edges and triangles to avoid z precision problems, will also require an overloading. A typical implementation will look like:

 glFlush();

 // Get the number of objects that were seen through the pick matrix frustum.
 // Resets GL_RENDER mode.
 GLint nbHits = glRenderMode(GL_RENDER);

 if (nbHits <= 0)
   setSelectedName(-1);
 else
 {
   // Interpret results: each object created values in the selectBuffer().
   // See the glSelectBuffer() man page for details on the buffer structure.
   // The following code depends on your selectBuffer() structure.
   for (int i=0; i<nbHits; ++i)
    if ((selectBuffer())[i*4+1] < zMin)
      setSelectedName((selectBuffer())[i*4+3])
 }

See the multiSelect example for a multi-object selection implementation of this method.

void fastDraw  )  [protected, virtual]
 

Draws a simplified version of the scene to guarantee interactive camera displacements.

This method is called instead of draw() when the qglviewer::Camera::frame() is qglviewer::ManipulatedCameraFrame::isManipulated(). Default implementation simply calls draw().

Overload this method if your scene is too complex to allow for interactive camera manipulation. See the fastDraw example for an illustration.

QColor foregroundColor  )  const
 

Returns the foreground color used by the viewer.

This color is used when FPSIsDisplayed(), gridIsDrawn(), to display the camera paths when the cameraIsEdited().

Attention:
Each QColor component is an integer in the range 0-255. This differs from the float values used by glColor3f() which are in the range 0-1. Default value is (180, 180, 180) (light gray).
Use qglColor(foregroundColor()) to set the current OpenGL color to the foregroundColor().

See also backgroundColor().

bool FPSIsDisplayed  )  const
 

Returns true if the viewer displays the current frame rate (Frames Per Second).

Use QApplication::setFont() to define the display font (see drawText()).

Set by setFPSIsDisplayed() or toggleFPSIsDisplayed(). Use currentFPS() to get the current FPS. Default value is false.

void FPSIsDisplayedChanged bool  displayed  )  [signal]
 

This signal is emitted whenever FPSIsDisplayed() changes value.

void getClickButtonState ClickAction  ca,
Qt::ButtonState &  buttonState,
bool &  doubleClick,
Qt::ButtonState &  buttonBefore
const
 

Similar to mouseButtonState(), but for ClickAction.

The results of the query are returned in the buttonState, doubleClick and buttonBefore parameters. If the ClickAction is not associated to any mouse button, Qt::NoButton is returned in buttonState. If several mouse buttons trigger in the ClickAction, one of them is returned.

bool gridIsDrawn  )  const
 

Returns true if a XY grid is drawn by the viewer.

Set by setGridIsDrawn() or toggleGridIsDrawn(). Default value is false.

void gridIsDrawnChanged bool  drawn  )  [signal]
 

This signal is emitted whenever gridIsDrawn() changes value.

bool hasMouseTracking  )  const
 

Returns true if mouseMoveEvent() is called even when no mouse button is pressed.

You need to setMouseTracking() to true in order to use MouseGrabber (see mouseGrabber()). See details in the QWidget documentation.

int height  )  const
 

Returns viewer's widget height (in pixels). See QGLWidget documentation.

void help  )  [virtual, slot]
 

Opens a modal help window that includes three tabs, respectively filled with helpString(), keyboardString() and mouseString().

Rich html-like text can be used (see the QStyleSheet documentation). This method is called when the user presses the HELP (default is 'H').

Use helpWidget() to access to the help widget (to add/remove tabs, change layout...). The "About" button (helpWidget()->cornerWidget()) is connected to the aboutQGLViewer() slot.

The helpRequired() signal is emitted.

void helpRequired  )  [signal]
 

Signal emitted by the default QGLViewer::help() method.

Connect this signal to your own help method or overload help().

virtual QString helpString  )  const [virtual]
 

Returns the QString displayed in the help() window main tab.

Overload this method to define your own help string, which should shortly describe your application and explain how it works. Rich-text (HTML) tags can be used (see QStyleSheet() documentation for available tags):

  QString myViewer::helpString() const
  {
    QString text("<h2>M y V i e w e r</h2>");
    text += "Displays a <b>Scene</b> using OpenGL. Move the camera using the mouse.";
    return text;
  }

See also mouseString() and keyboardString().

QTabWidget* helpWidget  )  [protected]
 

Returns a pointer to the help widget.

Use this only if you want to directly modify the help widget. Otherwise use helpString(), setKeyDescription() and setMouseBindingDescription() to customize the text displayed in the help window tabs.

virtual void init  )  [protected, virtual]
 

Initializes the viewer OpenGL context.

This method is called before the first drawing and should be overloaded to initialize some of the OpenGL flags. The default implementation is empty. See initializeGL().

Typical usage include camera() initialization (showEntireScene()), previous viewer state restoration (restoreStateFromFile()), OpenGL state modification and display list creation.

Note that initializeGL() modifies the standard OpenGL context. These values can be restored back in this method.

Attention:
You should not call updateGL() (or any method that calls it) in this method, as it will result in an infinite loop. The different QGLViewer set methods (setAxisIsDrawn(), setFPSIsDisplayed()...) are protected against this problem and can safely be called.
Note:
All the OpenGL specific initializations must be done in this method: the OpenGL context is not yet available in your viewer constructor.

void initFromDOMElement const QDomElement &  element  )  [virtual, slot]
 

Restores the QGLViewer state from a QDomElement created by domElement().

Used by restoreStateFromFile() to restore the QGLViewer state from a file.

Overload this method to retrieve custom attributes from the QGLViewer state file. This code corresponds to the one given in the domElement() documentation:

 void Viewer::initFromDOMElement(const QDomElement& element)
 {
   // Restore standard state
   QGLViewer::initFromDOMElement(element);

   QDomElement child=element.firstChild().toElement();
   while (!child.isNull())
   {
     if (child.tagName() == "Light")
     {
       if (child.hasAttribute("state"))
         setLightOn(child.attribute("state").lower() == "on");

       // Assumes there is only one child. Otherwise you need to parse child's children recursively.
       QDomElement lf = child.firstChild().toElement();
       if (!lf.isNull() && lf.tagName() == "LightFrame")
         lightManipulatedFrame()->initFromDomElement(lf);
     }
     child = child.nextSibling().toElement();
   }
 }

See also qglviewer::Camera::initFromDOMElement(), qglviewer::ManipulatedFrame::initFromDOMElement().

Note:
The manipulatedFrame() pointer is not modified by this method. If it is defined, its state is however restored from the element values.

void initializeGL  )  [protected, virtual]
 

Initializes the QGLViewer OpenGL context and then calls user-defined init().

This method is automatically called once, before the first call to paintGL().

Overload init() instead of this method to modify viewer specific OpenGL state or to create display lists.

To make beginners' life easier and to simplify the examples, this method slightly modifies the standard OpenGL state:

 glEnable(GL_LIGHT0);
 glEnable(GL_LIGHTING);
 glEnable(GL_DEPTH_TEST);
 glEnable(GL_COLOR_MATERIAL);

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.

bool isFullScreen  )  const
 

Returns true if the viewer is in fullScreen mode.

Default value is false. Set by setFullScreen() or toggleFullScreen().

Note that if the QGLViewer is embedded in an other QWidget, it returns true when the top level widget is in full screen mode.

bool isSharing  )  const
 

Returns true if display list sharing with another QGLWidget was requested in the constructor. See QGLWidget documentation.

bool isValid  )  const
 

Returns true if the widget has a valid GL rendering context. See QGLWidget documentation.

QString keyboardString  )  const [virtual]
 

Returns a QString that describes the application keyboard shortcut bindings, and that will be displayed in the help() window Keyboard tab.

Default value is a table that describes the custom shortcuts defined using setKeyDescription() as well as the standard QGLViewer::KeyboardAction shortcuts (defined using setShortcut()). See the keyboard page for details on key customization.

See also helpString() and mouseString().

void keyPressEvent QKeyEvent *  e  )  [protected, virtual]
 

Overloading of the QWidget method.

Default keyboard shortcuts are defined using setShortcut(). Overload this method to implement a specific keyboard binding. Call the original method if you do not catch the event to preserve the viewer default key bindings:

 void Viewer::keyPressEvent(QKeyEvent *e)
 {
   // Retrieve state keys
   const Qt::ButtonState state = (Qt::ButtonState)(e->state() & Qt::KeyButtonMask);

   // Defines the Alt+R shortcut. Call updateGL to refresh display.
   if ((state == Qt::AltButton) && (e->key() == Qt::Key_R))
     {
       myResetFunction();
       updateGL();
     }
   else
     QGLViewer::keyPressEvent(e);
 }
When you define a new keyboard shortcut, use setKeyDescription() to provide a short description which is displayed in the help() window Keyboard tab. See the keyboardAndMouse example for an illustration.

See also QGLWidget::keyReleaseEvent().

virtual void makeCurrent  )  [virtual]
 

Makes this widget's rendering context the current OpenGL rendering context. Useful with several viewers. See QGLWidget documentation.

qglviewer::ManipulatedFrame* manipulatedFrame  )  const
 

Returns the viewer's qglviewer::ManipulatedFrame.

This qglviewer::ManipulatedFrame can be moved with the mouse when the associated mouse bindings are used (default is when pressing the Control key with any mouse button). Use setMouseBinding() to define new bindings.

See the manipulatedFrame example for a complete implementation.

Default value is NULL, meaning that no qglviewer::ManipulatedFrame is set.

QGLViewer::MouseAction mouseAction int  buttonState  )  const
 

Returns the MouseAction associated with the Qt::ButtonState buttonState. Returns NO_MOUSE_ACTION if no action is associated.

For instance, to know which motion corresponds to Alt-LeftButton, do:

 QGLViewer::MouseAction mm = mouseAction(Qt::AltButton | Qt::LeftButton);
 if (mm != NO_MOUSE_ACTION) ...

Use mouseHandler() to know which object (CAMERA or FRAME) will perform this motion.

Qt::ButtonState mouseButtonState MouseHandler  handler,
MouseAction  action,
bool  withConstraint = true
const
 

Returns the Qt::ButtonState (if any) that has to be used to activate action on handler (with constraint or not).

If no Qt::ButtonState is associated, returns Qt::NoButton which is an impossible case since at least one mouse button has to be specified in setMouseBinding().

To know which keys and mouse buttons have to be pressed to translate the camera, use tests like:

 Qt::ButtonState bs = mouseButtonState(CAMERA, TRANSLATE);
 if (bs & Qt::RightButton) ... // Right button needed to translate the camera
 if (bs & Qt::AltButton)   ... // Alt key needed
 if (bs & Qt::KeyButtonMask == Qt::NoButton) ... // No state key needed

Note that mouse bindings are displayed in the 'Mouse' help window tab (use the 'H' key).

See also mouseAction() and mouseHandler().

void mouseDoubleClickEvent QMouseEvent *  e  )  [protected, virtual]
 

Overloading of the QWidget method.

The behavior of the mouse double click depends on the mouse binding. See setMouseBinding() and the mouse page.

qglviewer::MouseGrabber* mouseGrabber  )  const
 

Returns the current qglviewer::MouseGrabber, or NULL if no qglviewer::MouseGrabber currently grabs mouse events.

When qglviewer::MouseGrabber::grabsMouse(), the different mouse events are sent to the mouseGrabber() instead of their usual targets (camera() or manipulatedFrame()).

See the qglviewer::MouseGrabber documentation for details on MouseGrabber's mode of operation.

In order to use MouseGrabbers, you need to enable mouse tracking (so that mouseMoveEvent() is called even when no mouse button is pressed). Add this line in init() or in your viewer constructor:

Note that mouse tracking is disabled by default. Use QWidget::hasMouseTracking() to retrieve current state.

void mouseGrabberChanged qglviewer::MouseGrabber mouseGrabber  )  [signal]
 

Signal emitted by setMouseGrabber() when the mouseGrabber() is changed.

mouseGrabber is a pointer to the new MouseGrabber. Note that this signal is emitted with a NULL parameter each time a MouseGrabber stops grabbing mouse.

bool mouseGrabberIsEnabled const qglviewer::MouseGrabber *const   mouseGrabber  ) 
 

Returns true if mouseGrabber is enabled.

Default value is true for all MouseGrabbers. When set to false using setMouseGrabberIsEnabled(), the specified mouseGrabber will never become the mouseGrabber() of this QGLViewer. This is useful when you use several viewers: some MouseGrabbers may only have a meaning for some specific viewers and should not be selectable in others.

You can also use qglviewer::MouseGrabber::removeFromMouseGrabberPool() to completely disable a MouseGrabber in all the QGLViewers.

int mouseHandler int  buttonState  )  const
 

Returns the MouseHandler associated with the Qt::ButtonState buttonState. If no action is associated, returns -1.

For instance, to know which handler receives the Alt-LeftButton, do:

 int mh = mouseHandler(Qt::AltButton | Qt::LeftButton);
 if (mh == CAMERA) ...

Use mouseAction() to know which action (see the MouseAction enum) will be perform on this handler.

void mouseMoveEvent QMouseEvent *  e  )  [protected, virtual]
 

Overloading of the QWidget method.

Mouse move event is sent to the mouseGrabber() (if any) or to the camera() or the manipulatedFrame(), depending on mouse bindings (see setMouseBinding()).

If you want to define your own mouse behavior, do something like this:

 void Viewer::mousePressEvent(QMouseEvent* e)
 {
   // Qt::KeyButtonMask separates the Qt::ControlButton/Qt::AltButton/Qt::ShiftButton state key
   // from the Qt::LeftButton/Qt::MidButton/Qt::RightButton mouse buttons.
   if ((e->state() & Qt::KeyButtonMask) == myStateKeyCombo)
     myMouseBehavior = true;
   else
     QGLViewer::mousePressEvent(e);
 }

 void Viewer::mouseMoveEvent(QMouseEvent *e)
 {
   if (myMouseBehavior)
     // Use e->x() and e->y() as you want...
   else
     QGLViewer::mouseMoveEvent(e);
 }

 void Viewer::mouseReleaseEvent(QMouseEvent* e)
 {
   if (myMouseBehavior)
     myMouseBehavior = false;
   else
     QGLViewer::mouseReleaseEvent(e);
 }

void mousePressEvent QMouseEvent *  e  )  [protected, virtual]
 

Overloading of the QWidget method.

When the user clicks on the mouse:

Mouse bindings customization can be achieved using setMouseBinding() and setWheelBinding(). See the mouse page for a complete description of mouse bindings.

See the mouseMoveEvent() documentation for an example of more complex mouse behavior customization using overloading.

Note:
When the mouseGrabber() is a manipulatedFrame(), the modifier keys are not taken into account. This allows for a direct manipulation of the manipulatedFrame() when the mouse hovers, which is probably what is expected.

void mouseReleaseEvent QMouseEvent *  e  )  [protected, virtual]
 

Overloading of the QWidget method.

Calls the mouseGrabber(), camera() or manipulatedFrame mouseReleaseEvent method.

See the mouseMoveEvent() documentation for an example of mouse behavior customization.

QString mouseString  )  const [virtual]
 

Returns a QString that describes the application mouse bindings, displayed in the help() window Mouse tab.

Result is a table that describes custom application mouse binding descriptions defined using setMouseBindingDescription() as well as standard mouse bindings (defined using setMouseBinding() and setWheelBinding()). See the mouse page for details on mouse bindings.

See also helpString() and keyboardString().

void openSnapshotFormatDialog  )  [slot]
 

Opens a dialog that displays the different available snapshot formats.

Then calls setSnapshotFormat() with the selected one (unless the user cancels).

void paintGL  )  [protected, virtual]
 

Main paint method, inherited from QGLWidget.

Calls the following methods, in that order:

Qt::Key pathKey int  index  )  const
 

Returns the keyboard key associated to camera Key Frame path index.

Default values are F1..F12 for indexes 1..12.

addKeyFrameStateKey() (resp. playPathStateKey()) define the state key(s) that must be pressed with this key to add a KeyFrame to (resp. to play) the associated Key Frame path. If you quickly press twice the pathKey(), the path is reset (resp. deleted).

Use camera()->keyFrameInterpolator( index ) to retrieve the KeyFrameInterpolator that defines the path.

If several keys are binded to a given index (see setPathKey()), one of them is returned. Returns 0 if no key is associated with this index.

See also the keyboard page.

Qt::ButtonState playPathStateKey  )  const
 

Returns the state key that must be pressed with a pathKey() to play a camera KeyFrame path.

It can be Qt::NoButton, Qt::ControlButton, Qt::ShiftButton, Qt::AltButton, or a combination of these (using the bit '|' operator, see setHandlerStateKey()). Default value is Qt::NoButton, defined using setPlayPathStateKey().

See also addKeyFrameStateKey().

void pointSelected const QMouseEvent *  e  )  [signal]
 

Signal emitted by select().

Connect this signal to your selection method or overload select(), or more probably simply drawWithNames().

void postDraw  )  [protected, virtual]
 

Called after draw() to draw viewer visual hints.

Default implementation displays axis, grid, FPS... when the respective flags are sets.

See the multiSelect and thumbnail examples for an overloading illustration.

The GLContext (color, LIGHTING, BLEND...) should not be modified by this method, so that in draw(), the user can rely on the OpenGL context. Respect this convention (by pushing/popping the different attributes) if you overload this method.

virtual void postSelection const QPoint &  point  )  [protected, virtual]
 

This method is called at the end of the select() procedure. It should finalize 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 selected). See the select example for an illustration.

void preDraw  )  [protected, virtual]
 

Sets OpenGL state before draw().

Default behavior clears screen and sets the projection and modelView matrices:

 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

 camera()->loadProjectionMatrix();
 camera()->loadModelViewMatrix();

Emits the drawNeeded() signal once this is done (see the callback example).

void preDrawStereo bool  leftBuffer = true  )  [protected, virtual]
 

Called before draw() (instead of preDraw()) when viewer displaysInStereo().

Same as preDraw() except that the glDrawBuffer() is set to GL_BACK_LEFT or GL_BACK_RIGHT depending on leftBuffer, and it uses qglviewer::Camera::loadProjectionMatrixStereo() and qglviewer::Camera::loadModelViewMatrixStereo() instead.

void qglClearColor const QColor &  color  )  const
 

Calls glClearColor. See QGLWidget documentation.

void qglColor const QColor &  color  )  const
 

Calls glColor3. See QGLWidget::qglColor().

static int QGLViewerIndex const QGLViewer *const   viewer  )  [static]
 

Returns the index of the QGLViewer viewer in the QGLViewerPool(). This index in unique and can be used to identify the different created QGLViewers (see stateFileName() for an application example).

When a QGLViewer is deleted, the following QGLViewers' indexes are shifted down. Returns -1 if the QGLViewer could not be found (which should not be possible).

static const QPtrList<QGLViewer>& QGLViewerPool  )  [static]
 

Returns a QPtrList (see Qt documentation) that contains all the created QGLViewer.

Can be useful to apply a method or to connect a signal to all the viewers:

  QPtrListIterator<QGLViewer> it(QGLViewer::QGLViewerPool());
  for (QGLViewer* viewer; (viewer = it.current()) != NULL; ++it)
    connect(myObject, SIGNAL(mySignal), viewer, SLOT(updateGL()));

virtual void resize int  width,
int  height
[virtual, slot]
 

Resizes the widget to size width by height pixels. See also width() and height().

void resizeGL int  width,
int  height
[protected, virtual]
 

Callback method used when the widget size is modified.

If you overload this method, first call the inherited method. Also called when the widget is created, before its first display.

bool restoreStateFromFile  )  [virtual, slot]
 

Restores the QGLViewer state from the stateFileName() file using initFromDOMElement().

States are saved using saveStateToFile(), which is automatically called on viewer exit.

Returns true when the restoration is successful. Possible problems are an non existing or unreadable stateFileName() file, an empty stateFileName() or an XML syntax error.

A manipulatedFrame() should be defined before calling this method, so that its state can be restored. Initialization code put after this function will override saved values:

 void Viewer::init()
 {
   // Default initialization goes here (including the declaration of a possible manipulatedFrame).

   if (!restoreStateFromFile())
     showEntireScene(); // Previous state cannot be restored: fit camera to scene.

   // Specific initialization that overrides file savings goes here.
 }

void saveSnapshot const QString &  filename,
bool  overwrite = false
[slot]
 

Same as saveSnapshot(), except that it uses filename instead of snapshotFilename().

If filename is empty, opens a file dialog to select the name.

Uses snapshotFormat() and snapshotQuality() for the snapshot. A correct file extension is added if not provided in filename.

Asks for confirmation when the file already exists and overwrite is false (default).

void saveSnapshot bool  automatic = false,
bool  overwrite = false
[slot]
 

Saves a snapshot of the current image displayed by the widget.

Options are set using snapshotFormat(), snapshotFilename() and snapshotQuality(). For non vectorial image formats, the image size is equal to the current viewer's dimensions (see width() and height()). See snapshotFormat() for details on supported formats.

If automatic is false (or if snapshotFilename() is empty), a file dialog is opened to ask for the file name.

When automatic is true, the filename is set to NAME-NUMBER, where NAME is snapshotFilename() and NUMBER is snapshotCounter(). The snapshotCounter() is automatically incremented after each snapshot saving. This is useful to create videos from your application:

 void Viewer::init()
 {
   resize(720, 576); // PAL DV format (use 720x480 for NTSC DV)
   connect(this, SIGNAL(drawFinished(bool)), SLOT(saveSnapshot(bool)));
 }
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:

 void Viewer::createQuicktime()
 {
   const int nbImages = 36;
   for (int i=0; i<nbImages; ++i)
     {
       camera()->setOrientation(2.0*M_PI/nbImages, 0.0); // Theta-Phi orientation
       showEntireScene();
       updateGL();  // calls draw(), which emits drawFinished(), which calls saveSnapshot()
     }
 }

When overwrite is set to false (default), a pop-up window asks for confirmation (when automatic is false) or the snapshotCounter() is incremented until a non-existing file name is found (when automatic is true). Otherwise the file is overwritten without confirmation.

Remove that anti-aliassing option to correctly display generated PS and EPS results. The VRender library was written by Cyril Soler (Cyril dot Soler at imag dot fr).

Note:
In order to correctly grab the frame buffer, the QGLViewer window is raised in front of other windows by this method.

void saveStateToFile  )  [virtual, slot]
 

Saves in stateFileName() an XML representation of the QGLViewer state, obtained from domElement().

Use restoreStateFromFile() to restore this viewer state.

This method is automatically called when a viewer is closed (using Escape or using the window's upper right x close button). setStateFileName() to QString::null to prevent this.

qglviewer::Vec sceneCenter  )  const
 

Returns the scene center, defined in world coordinates.

See sceneRadius() for details.

Default value is (0,0,0). Simply a wrapper for camera()->sceneCenter(). Set using setSceneCenter().

Do not mismatch this value (that only depends on the scene) with the qglviewer::Camera::revolveAroundPoint().

float sceneRadius  )  const
 

Returns the scene radius.

The entire displayed scene should be included in a sphere of radius sceneRadius(), centered on sceneCenter().

This approximate value is used by the camera() to set qglviewer::Camera::zNear() and qglviewer::Camera::zFar(). It is also used to showEntireScene() or to scale the world axis display..

Default value is 1.0. This method is equivalent to camera()->sceneRadius(). See setSceneRadius().

void select const QPoint &  point  )  [virtual, slot]
 

This method performs a selection in the scene from pixel coordinates.

It is called when the user clicks on the SELECT QGLViewer::ClickAction binded button(s) (default is Shift + LeftButton).

This method successively calls four other methods:

The default implementation of these methods is as follows (see the methods' documentation for more details):

  • drawWithNames() is empty and should be overloaded. It draws each selectable object of the scene, enclosed by calls to glPushName() / glPopName() to tag the object with an integer id.
  • endSelection() then restores GL_RENDER mode and analyzes the selectBuffer() to set in selectedName() the id of the object that was drawn in the region. If several object are in the region, the closest one in the depth buffer is chosen. If no object has been drawn under cursor, selectedName() is set to -1.
  • postSelection() is empty and can be overloaded for possible signal/display/interface update.
See the 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() 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 privilege 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.

point is the center pixel (origin in the upper left corner) of the selection region. Use qglviewer::Camera::convertClickToLine() to transform these coordinates in a 3D ray if you want to perform an analytical intersection.

Attention:
GL_SELECT mode seems to report wrong results when used in conjunction with backface culling. If you encounter problems try to glDisable(GL_CULL_FACE).

void select const QMouseEvent *  event  )  [virtual, slot]
 

Simple wrapper method: calls select(event->pos()).

Emits pointSelected(e) which is useful only if you rely on the Qt signal-slot mechanism and you did not overload QGLViewer. If you choose to derive your own viewer class, simply overload select() (or probably simply drawWithNames(), see the select example) to implement your selection mechanism.

This method is called when you use the SELECT mouse binding(s) (default is Shift + left button). Overload to make the selection mechanism depend on the event state (keyboard modifiers).

GLuint* selectBuffer  ) 
 

Returns a pointer to an array of GLuint.

This buffer is used by the GL_SELECT mode in select() to perform object selection. The buffer size can be modified using setSelectBufferSize(). If you overload endSelection(), you will analyze the content of this buffer. See the glSelectBuffer() man page for details.

int selectBufferSize  )  const
 

Returns the selectBuffer() size.

See the select() documentation for details. 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 drawn under the mouse cursor.

int selectedName  )  const
 

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 method returns -1 if the selectBuffer() was empty, meaning that no object was selected.

Return value is -1 before the first call to select(). This value is modified using setSelectedName().

int selectRegionHeight  )  const
 

See the selectRegionWidth() documentation. Default value is 3 pixels.

int selectRegionWidth  )  const
 

Returns the width (in pixels) of a selection frustum, centered on the mouse cursor, that is used to select objects.

The height of the selection frustum is defined by selectRegionHeight().

The objects that will be drawn in this region by drawWithNames() will be recorded in the selectBuffer(). endSelection() then analyzes this buffer and setSelectedName() to the name of the closest object. 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.

void setAddKeyFrameStateKey int  buttonState  )  [virtual, slot]
 

Sets the addKeyFrameStateKey().

void setAnimationPeriod int  period  )  [slot]
 

Sets the animationPeriod(), in milliseconds.

void setAutoBufferSwap bool  on  )  [protected, slot]
 

Sets the autoBufferSwap() value.

void setAxisIsDrawn bool  draw = true  )  [slot]
 

Sets the state of axisIsDrawn(). Emits the axisIsDrawnChanged() signal. See also toggleAxisIsDrawn().

void setBackgroundColor const QColor &  color  )  [slot]
 

Sets the backgroundColor() of the viewer and calls qglClearColor(). See also setForegroundColor().

void setCamera qglviewer::Camera *const   camera  )  [slot]
 

Associates a new qglviewer::Camera to the viewer.

You should only use this method when you derive a new class from qglviewer::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::addKeyFrameToPath() and qglviewer::Camera::playPath() instead.

This method silently ignores NULL camera pointers. The calling method is responsible for deleting the previous camera pointer in order to prevent memory leaks if needed.

The sceneRadius() and sceneCenter() of camera are set to the current QGLViewer values.

All the camera qglviewer::Camera::keyFrameInterpolator() qglviewer::KeyFrameInterpolator::interpolated() signals are connected to the viewer updateGL() slot. The connections with the previous viewer's camera are removed.

void setCameraIsEdited bool  edit = true  )  [slot]
 

Starts (edit = true, default) or stops (edit=false) the edition of the camera().

Current implementation is limited to paths display. Get current state using cameraIsEdited().

Attention:
This method sets the qglviewer::Camera::zClippingCoefficient() to 5.0 when edit is true, so that the Camera paths (see qglviewer::Camera::keyFrameInterpolator()) are not clipped. It restores the previous value when edit is false.

void setForegroundColor const QColor &  color  )  [slot]
 

Sets the foregroundColor() of the viewer, used to draw visual hints. See also setBackgroundColor().

void setFPSIsDisplayed bool  display = true  )  [slot]
 

Sets the state of FPSIsDisplayed(). Emits the FPSIsDisplayedChanged() signal. See also toggleFPSIsDisplayed().

void setFullScreen bool  fullScreen = true  )  [slot]
 

Sets the isFullScreen() state.

If the QGLViewer is embedded in an other QWidget (see QWidget::topLevelWidget()), this widget is displayed in full screen instead.

void setGridIsDrawn bool  draw = true  )  [slot]
 

Sets the state of gridIsDrawn(). Emits the gridIsDrawnChanged() signal. See also toggleGridIsDrawn().

void setHandlerStateKey MouseHandler  handler,
int  buttonState
[slot]
 

Associates a given state key to a specific MouseHandler.

The buttonState is Qt::AltButton, Qt::ShiftButton, Qt::ControlButton, Qt::MetaButton or a combinaison of these using the '|' bitwise operator.

All the handler's associated bindings will then need the specified buttonState key to be activated.

With this code,

 setHandlerStateKey(CAMERA, Qt::AltButton);
 setHandlerStateKey(FRAME,  Qt::NoButton);
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 method has a very basic implementation: every action binded to handler has its state keys replaced by buttonState. If the MouseHandler had some actions binded to different state keys, these settings will be lost. You should hence consider using setMouseBinding() for finer tuning.

The default binding associates Qt::ControlButton to all the FRAME actions and Qt::NoButton to CAMERA actions. See mouse page for details.

Attention:
This method calls setMouseBinding(), which ensures that only one action is binded to a given buttonState. If you want to swap the CAMERA and FRAME state keys, you have to use a temporary dummy buttonState (as if you were swapping two variables) or else the first call will overwrite the previous settings:
 // Associate FRAME with Alt (temporary value)
 setHandlerStateKey(FRAME, Qt::Alt);
 // Control is associated with CAMERA
 setHandlerStateKey(CAMERA, Qt::ControlButton);
 // And finally, FRAME can be associated with NoButton
 setHandlerStateKey(FRAME, Qt::NoButton);

void setKeyDescription int  key,
QString  description
[slot]
 

Defines a custom keyboard shortcut description, that will be displayed in the help() window Keyboard tab.

The key definition is given as an int using Qt enumerated values. Set an empty description to remove a shortcut description:

 setKeyDescription(Key_W, "Toggles wireframe display");
 setKeyDescription(CTRL+Key_L, "Loads a new scene");
 // Removes a description
 setKeyDescription(CTRL+Key_C, "");

See the keyboardAndMouse example for illustration and the keyboard page for details.

void setManipulatedFrame qglviewer::ManipulatedFrame frame  )  [slot]
 

Sets the viewer's manipulatedFrame().

Note that a qglviewer::ManipulatedCameraFrame can be set as the manipulatedFrame(): it is possible to manipulate the camera of a first viewer in a second viewer.

Defining the own viewer's camera()->frame() as the manipulatedFrame() is possible and will result in a classical camera manipulation. See the luxo example for an illustration.

void setMouseBinding int  buttonState,
ClickAction  action,
bool  doubleClick = false,
int  buttonBefore = Qt::NoButton
[slot]
 

Associates a ClickAction to any Qt::ButtonState mouse button and state key combination.

The parameters should read: when the buttonState mouse button(s) is (are) pressed (possibly with Alt, Control, Shift or any combination of these), and possibly with a doubleClick, perform action.

If buttonBefore is specified (valid only when doubleClick is true), then this mouse button(s) have to pressed before the double click occurs in order to perform action. For instance, with the default binding, pressing the right button, then double clicking on the left button will call RAP_FROM_PIXEL (which defines the new qglviewer::Camera::revolveAroundPoint() as the point under the mouse cursor, if any).

The list of all possible ClickAction, some binding examples and default bindings are provided in the mouse page. See also the setMouseBinding() documentation.

See the keyboardAndMouse example for an illustration.

The binding is ignored if no mouse button is specified in buttonState.

void setMouseBinding int  buttonState,
MouseHandler  handler,
MouseAction  action,
bool  withConstraint = true
[slot]
 

Associates a MouseAction to any Qt::ButtonState mouse button and state key combination. The receiver of the mouse events is a MouseHandler (CAMERA or FRAME).

The parameters should read: when the buttonState mouse button and state key are pressed, activate action on handler. If withConstraint is true (default), the qglviewer::Frame::constraint() associated with the Frame will be enforced during motion.

Use the '|' bitwise operator to combine keys and buttons:

 // Left and right buttons together make a camera zoom: emulates a mouse third button if needed.
 setMouseBinding(Qt::LeftButton | Qt::RightButton, CAMERA, ZOOM);

 // Alt + Shift + Left button rotates the manipulatedFrame().
 setMouseBinding(Qt::AltButton | Qt::ShiftButton | Qt::LeftButton, FRAME, ROTATE);

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 buttonState, the binding is ignored. If an action was previously associated with this buttonState, it is silently overwritten (use mouseAction() before to know if the buttonState is already binded).

To remove a specific mouse binding, use code like:

 setMouseBinding(myButtonStateKeyCombo, myHandler, NO_MOUSE_ACTION);

See also setMouseBinding(int, ClickAction, bool, int) and setWheelBinding().

void setMouseBindingDescription int  buttonState,
QString  description,
bool  doubleClick = false
[slot]
 

Provides a custom mouse binding description, displayed in the help() window Mouse tab.

buttonState is a combination of modifier keys (Qt::ControlButton, Qt::AltButton, Qt::ShiftButton) and mouse buttons (Qt::LeftButton, Qt::MidButton and Qt::RightButton), combined using the "|" bitwise operator.

doubleClick indicates whether or not the user has to double click this button. Set an empty description to remove a mouse binding description.

 // Left and Right button together simulate a middle button
 setMouseBindingDescription(Qt::LeftButton | Qt::RightButton, "Emulates a middle button");

 // A left button double click toggles full screen
 setMouseBindingDescription(Qt::LeftButton, "Toggles full screen mode", true);

 // Remove the description of Ctrl+Right button
 setMouseBindingDescription(Qt::ControlButton | Qt::RightButton, "");

Overload mouseMoveEvent() and friends to implement your custom mouse behavior (see the mouseMoveEvent() documentation for an example). See the keyboardAndMouse example for an illustration.

Use setMouseBinding() and setWheelBinding() to change the standard mouse action bindings.

void setMouseGrabber qglviewer::MouseGrabber mouseGrabber  )  [slot]
 

Directly defines the mouseGrabber().

You should not call this method directly as it bypasses the qglviewer::MouseGrabber::checkIfGrabsMouse() test performed by mouseMoveEvent().

If the MouseGrabber is disabled (see mouseGrabberIsEnabled()), this method silently does nothing.

void setMouseGrabberIsEnabled const qglviewer::MouseGrabber *const   mouseGrabber,
bool  enabled = true
 

Sets the mouseGrabberIsEnabled() state.

virtual void setMouseTracking bool  enable  )  [virtual, slot]
 

Sets the hasMouseTracking() value.

void setPathKey int  key,
int  index = 0
[virtual, slot]
 

Sets the pathKey() associated with the camera Key Frame path index.

Several keys can be binded to the same index. Use a negated key value to delete the binding (the index value is then ignored):

 // Press 'space' to play/pause/add/delete camera path 0.
 setPathKey(Qt::Key_Space, 0);

 // Remove this binding
 setPathKey(-Qt::Key_Space);

void setPlayPathStateKey int  buttonState  )  [virtual, slot]
 

Sets the playPathStateKey().

void setSceneBoundingBox const qglviewer::Vec min,
const qglviewer::Vec max
[slot]
 

Convenient way to call setSceneCenter() and setSceneRadius() from a (world axis aligned) bounding box of the scene.

This is equivalent to:

  setSceneCenter((m+M)/2.0);
  setSceneRadius(0.5*(M-m).norm());

void setSceneCenter const qglviewer::Vec center  )  [slot]
 

Sets the sceneCenter(), defined in world coordinates.

Attention:
The qglviewer::Camera::revolveAroundPoint() is set to the sceneCenter() value by this method.

void setSceneRadius float  radius  )  [slot]
 

Sets the sceneRadius().

The camera() qglviewer::Camera::flySpeed() is set to 1% of this value by this method. Simple wrapper around camera()->setSceneRadius().

void setSelectBufferSize int  size  )  [slot]
 

Sets the selectBufferSize().

The previous selectBuffer() is deleted and a new one is created.

void setSelectedName int  id  )  [slot]
 

Set the selectedName() value.

Used in endSelection() during a selection. You should only call this method if you overload the endSelection() method.

void setSelectRegionHeight int  height  )  [slot]
 

Sets the selectRegionHeight().

void setSelectRegionWidth int  width  )  [slot]
 

Sets the selectRegionWidth().

void setShortcut KeyboardAction  action,
int  key
[slot]
 

Defines the shortcut() that triggers a given QGLViewer::KeyboardAction.

Here are some examples:

 // Press 'Q' to exit application
 setShortcut(EXIT_VIEWER, Key_Q);

 // Alt+M toggles camera mode
 setShortcut(CAMERA_MODE, ALT+Key_M);

 // The DISPLAY_FPS action is disabled
 setShortcut(DISPLAY_FPS, 0);

Only one shortcut can be assigned to a given QGLViewer::KeyboardAction (new bindings replace previous ones). If several KeyboardAction are binded to the same shortcut, only one of them is active.

void setSnapshotCounter int  counter  )  [slot]
 

Sets the snapshotCounter().

void setSnapshotFilename const QString &  name  )  [slot]
 

Sets snapshotFilename().

void setSnapshotFormat const QString &  format  )  [slot]
 

Sets the snapshotFormat().

void setSnapshotQuality int  quality  )  [slot]
 

Sets the snapshotQuality().

void setStateFileName const QString &  name  )  [slot]
 

Defines the stateFileName() used by saveStateToFile() and restoreStateFromFile().

The file name can have an optional prefix directory (no prefix meaning current directory). If the directory does not exist, it will be created by saveStateToFile().

  // Name depends on the displayed 3D model. Saved in current directory.
  setStateFileName(displayedModelName() + ".xml");

  // Files are stored in a dedicated directory under user's home directory.
  setStateFileName(QDir::homeDirPath + "/.config/myApp.xml");

void setStereoDisplay bool  stereo = true  )  [slot]
 

Toggles the state of isFullScreen(). See also setFullScreen().

void setTextIsEnabled bool  enable = true  )  [slot]
 

Sets the state of textIsEnabled(). Emits the textIsEnabledChanged() signal. See also toggleTextIsEnabled().

void setWheelBinding int  buttonState,
MouseHandler  handler,
MouseAction  action,
bool  withConstraint = true
[slot]
 

Associates a MouseAction and a MouseHandler to a mouse wheel event.

This method is very similar to setMouseBinding(), but specific to the wheel.

In the current implementation only ZOOM can be associated with FRAME, while CAMERA can receive ZOOM and MOVE_FORWARD.

The difference between ZOOM and MOVE_FORWARD is that ZOOM speed depends on the distance to the object, while MOVE_FORWARD moves at a constant speed defined by qglviewer::Camera::flySpeed().

void setZBufferIsDisplayed bool  display = true  )  [slot]
 

Sets the state of zBufferIsDisplayed(). Emits the zBufferIsDisplayedChanged() signal. See also toggleZBufferIsDisplayed().

int shortcut KeyboardAction  action  )  const
 

Returns the keyboard shortcut associated to a given QGLViewer::KeyboardAction.

Result is an int defined using Qt enumerated values, as in Key_Q, CTRL+Key_X or CTRL+ALT+Key_Up. Use Qt::MODIFIER_MASK to separate the key from the state keys. Returns 0 if the KeyboardAction is disabled (not binded). Set using setShortcut().

If you want to define keyboard shortcuts for custom actions (say, open a scene file), overload keyPressEvent() and then setKeyDescription().

These shortcuts and their descriptions are automatically included in the help() window Keyboard tab.

See the keyboard page for details and default values and the keyboardAndMouse example for a practical illustration.

void showEntireScene  )  [slot]
 

Moves the camera so that the entire scene is visible.

Simple wrapper around qglviewer::Camera::showEntireScene().

virtual QSize sizeHint  )  const [virtual]
 

Returns the recommended size for the QGLViewer. Default value is 600x400 pixels.

int snapshotCounter  )  const
 

Returns the value of the counter used to name snapshots in saveSnapshot() when automatic is true.

Set using setSnapshotCounter(). Default value is 0, and it is incremented after each automatic snapshot. See saveSnapshot() for details.

const QString& snapshotFilename  )  const
 

Returns the snapshot filename used by saveSnapshot().

This value is used in automatic mode (see saveSnapshot()). A dialog is otherwise popped-up to set it.

You can also directly provide a file name using saveSnapshot(const QString&, bool).

If the filename is relative, the current working directory at the moment of the method call is used. Set using setSnapshotFilename().

const QString& snapshotFormat  )  const
 

Returns the snapshot file format used by saveSnapshot().

This value is used when saveSnapshot() is passed the automatic flag. It is defined using a saveAs pop-up dialog otherwise.

The available formats are those handled by Qt. Classical values are "JPEG", "PNG", "PPM, \c "BMP". Use the following code to get the actual list:

   QStringList formatList = QImage::outputFormatList();
   for (QStringList::Iterator it = formatList.begin(); it != formatList.end(); ++it)
     qWarning(*it);

If the library was compiled with the vectorial rendering option (default), three additional vectorial formats are available: "EPS", "PS" and "XFIG". "SVG" and "PDF" formats should soon be available. The VRender library was created by Cyril Soler.

Note that the VRender library has some limitations: vertex shader effects are not reproduced and PASS_THROUGH tokens are not handled so one can not change point and line size in the middle of a drawing.

Default value is the first supported among "JPEG, PNG, EPS, PS, PPM, BMP", in that order.

This value is set using setSnapshotFormat() or with openSnapshotFormatDialog().

Attention:
No verification is performed on the provided format validity. The next call to saveSnapshot() may fail if the format string is not supported.

int snapshotQuality  ) 
 

Defines the image quality of the snapshots produced with saveSnapshot().

Values must be in the range -1..100. Use 0 for lowest quality and 100 for highest quality (and larger files). -1 means use Qt default quality. Default value is 95.

Set using setSnapshotQuality(). See also the QImage::save() documentation.

Note:
This value has no impact on the images produced in vectorial format.

void startAnimation  )  [virtual, slot]
 

Starts the animation loop. See animationIsStarted().

void startScreenCoordinatesSystem bool  upward = false  )  const [virtual]
 

Modify the projection matrix so that drawing can be done directly with 2D screen coordinates.

Once called, the x and y coordinates passed to glVertex are expressed in pixels screen coordinates. The origin (0,0) is in the upper left corner of the widget by default. This follows the Qt standards, so that you can directly use the pos() provided by for instance QMouseEvent. Set upward to true to place the origin in the lower left corner, thus following the OpenGL and mathematical standards. It is always possible to switch between the two representations using newY = height() - y.

You need to call stopScreenCoordinatesSystem() at the end of the drawing block to restore the previous camera matrix.

In practice, this method should be used in draw(). It sets an appropriate orthographic projection matrix and then sets glMatrixMode to GL_MODELVIEW.

See the screenCoordSystem, multiSelect and backgroundImage examples for an illustration.

You may want to disable GL_LIGHTING, to enable GL_LINE_SMOOTH or GL_BLEND to draw when this method is used.

If you want to link 2D drawings to 3D objects, use qglviewer::Camera::projectedCoordinatesOf() to compute the 2D projection on screen of a 3D point (see the screenCoordSystem example). See also drawText().

In this mode, you should use z values that are in the [0.0, 1.0[ range (0.0 corresponding to the near clipping plane and 1.0 being just beyond the far clipping plane). This interval matches the values that can be read from the z-buffer. Note that if you use the convenient glVertex2i() to provide coordinates, the implicit 0.0 z coordinate will make your drawings appear on top of the rest of the scene.

QString stateFileName  )  const
 

Returns the state file name. Default value is .qglviewer.xml.

This is the name of the XML file where saveStateToFile() saves the viewer state (camera state, widget geometry, display flags... see domElement()) on exit. Use restoreStateFromFile() to restore this state later (usually in your init() method).

Setting this value to QString::null will disable the automatic state file saving that normally occurs on exit.

If more than one viewer are created by the application, this function will return a numbered file name (as in ".qglviewer1.xml", ".qglviewer2.xml"... using QGLViewer::QGLViewerIndex()) for extra viewers. Each viewer will then read back its own information in restoreStateFromFile(), provided that the viewers are created in the same order, which is usually the case.

void stereoChanged bool  on  )  [signal]
 

This signal is emitted whenever displaysInStereo() changes value.

void stopAnimation  )  [virtual, slot]
 

Stops animation. See animationIsStarted().

void stopScreenCoordinatesSystem  )  const [virtual]
 

Stops the pixel coordinate drawing block started by startScreenCoordinatesSystem().

The GL_MODELVIEW and GL_PROJECTION matrices modified in startScreenCoordinatesSystem() are restored. glMatrixMode is set to GL_MODELVIEW.

bool textIsEnabled  )  const
 

Returns true if text display (see drawText()) is enabled.

Set by setTextIsEnabled() or toggleTextIsEnabled(). This feature conveniently removes all the possibly displayed text, cleaning display. Default value is true.

void textIsEnabledChanged bool  enabled  )  [signal]
 

This signal is emitted whenever textIsEnabled() changes value.

void timerEvent QTimerEvent *   )  [protected, virtual]
 

Overloading of the QObject method.

If animationIsStarted(), calls animate() and draw().

void toggleAnimation  )  [slot]
 

Calls startAnimation() or stopAnimation(), depending on animationIsStarted().

void toggleAxisIsDrawn  )  [slot]
 

Toggles the state of axisIsDrawn(). See also setAxisIsDrawn().

void toggleCameraIsEdited  )  [slot]
 

Toggles the state of cameraIsEdited(). See also setCameraIsEdited().

void toggleCameraMode  )  [slot]
 

Swaps between two predefined camera mouse bindings.

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 respectively binded to:

The current mode is determined by checking if a mouse button is binded to ROTATE for the CAMERA (using mouseButtonState()). The state key that was previously used to move the camera is preserved.

void toggleFPSIsDisplayed  )  [slot]
 

Toggles the state of FPSIsDisplayed(). See also setFPSIsDisplayed().

void toggleFullScreen  )  [slot]
 

Toggles the state of displaysInStereo(). See setStereoDisplay().

void toggleGridIsDrawn  )  [slot]
 

Toggles the state of gridIsDrawn(). See also setGridIsDrawn().

void toggleStereoDisplay  )  [slot]
 

void toggleTextIsEnabled  )  [slot]
 

Toggles the state of textIsEnabled(). See also setTextIsEnabled().

void toggleZBufferIsDisplayed  )  [slot]
 

Toggles the state of zBufferIsDisplayed(). See also setZBufferIsDisplayed().

virtual void updateGL  )  [virtual]
 

Updates the display. Do not call draw() directly, use this method instead. See QGLWidget documentation.

void viewerInitialized  )  [signal]
 

Signal emitted by the default init() method.

Connect this signal to the methods that need to be called to initialize your viewer or overload init().

QGLViewer::MouseAction wheelAction int  buttonState  )  const
 

Same as mouseAction(), but for the wheel action.

int wheelButtonState MouseHandler  handler,
MouseAction  action,
bool  withConstraint = true
const
 

Same as mouseButtonState(), but for the wheel.

Attention:
Returns -1 when no Qt::ButtonState was associated with this handler/ action/ withConstraint value (mouseButtonState() returns Qt::NoButton instead).

void wheelEvent QWheelEvent *  e  )  [protected, virtual]
 

Overloading of the QWidget method.

If defined, the wheel event is sent to the mouseGrabber(). It is otherwise sent according to wheel bindings (see setWheelBinding()).

int wheelHandler int  buttonState  )  const
 

Same as mouseHandler but for the wheel action.

int width  )  const
 

Returns viewer's widget width (in pixels). See QGLWidget documentation.

bool zBufferIsDisplayed  )  const
 

void zBufferIsDisplayedChanged bool  displayed  )  [signal]
 

This signal is emitted whenever zBufferIsDisplayed() changes value..


Generated on Thu Jul 7 11:49:19 2005 for libQGLViewer by  doxygen 1.4.3