Class Hierarchy
Fl_Widget
|
+----Fl_Gl_Window
|
+----Fl_Pack, Fl_Scroll, Fl_Tabs, Fl_Tile, Fl_Window
Include Files
#include <FL/Fl_Gl_Window.H>
Description
The Fl_Gl_Window widget sets things up so OpenGL works, and
also keeps an OpenGL "context" for that window, so that changes to the
lighting and projection may be reused between redraws. Fl_Gl_Window
also flushes the OpenGL streams and swaps buffers after draw()
returns.
OpenGL hardware typically provides some overlay bit planes, which
are very useful for drawing UI controls atop your 3D graphics. If the
overlay hardware is not provided, FLTK tries to simulate the overlay,
This works pretty well if your graphics are double buffered, but not
very well for single-buffered.
Methods
Creates a new Fl_Gl_Window widget using the given position,
size, and label string. The default boxtype is FL_NO_BOX. The
default mode is FL_RGB|FL_DOUBLE|FL_DEPTH.
The destructor removes the widget and destroys the OpenGL context
associated with it.
Fl_Gl_Window::draw() is a pure virtual method. You must
subclass Fl_Gl_Window and provide an implementation for
draw(). You may also provide an implementation of draw_overlay()
if you want to draw into the overlay planes. You can avoid
reinitializing the viewport and lights and other things by checking
valid() at the start of draw() and only doing the
initialization if it is false.
The draw() method can only use OpenGL calls. Do not
attempt to call X, any of the functions in <FL/fl_draw.H>, or glX
directly. Do not call gl_start() or gl_finish().
If double-buffering is enabled in the window, the back and front
buffers are swapped after this function is completed.
Set or change the OpenGL capabilites of the window. The value can be
any of the following OR'd together:
- FL_RGB - RGB color (not indexed)
- FL_RGB8 - RGB color with at least 8 bits of each color
- FL_INDEX - Indexed mode
- FL_SINGLE - not double buffered
- FL_DOUBLE - double buffered
- FL_ACCUM - accumulation buffer
- FL_ALPHA - alpha channel in color
- FL_DEPTH - depth buffer
- FL_STENCIL - stencil buffer
- FL_MULTISAMPLE - multisample antialiasing
FL_RGB and FL_SINGLE have a value of zero, so they
are "on" unless you give FL_INDEX or FL_DOUBLE.
If the desired combination cannot be done, FLTK will try turning off
FL_MULTISAMPLE. If this also fails the show() will call
Fl::error() and not show the window.
You can change the mode while the window is displayed. This is most
useful for turning double-buffering on and off. Under X this will
cause the old X window to be destroyed and a new one to be created. If
this is a top-level window this will unfortunately also cause the
window to blink, raise to the top, and be de-iconized, and the xid()
will change, possibly breaking other code. It is best to make the GL
window a child of another window if you wish to do this!
Returns non-zero if the hardware supports the given or current OpenGL
mode.
Fl_Gl_Window::valid() is turned off when FLTK creates a new
context for this window or when the window resizes, and is turned on
afterdraw() is called. You can use this inside your
draw() method to avoid unneccessarily initializing the OpenGL
context. Just do this:
void mywindow::draw() {
if (!valid()) {
glViewport(0,0,w(),h());
glFrustum(...);
glLight(...);
...other initialization...
}
... draw your geometry here ...
}
Fl_Gl_Window::valid() is turned off when FLTK creates a
new context for this window and by the window resizing, and is turned
on after draw() is called. You can use this inside your draw()
method to avoid unneccessarily initializing the OpenGL context. Just
do this:
void mywindow::draw() {
if (!valid()) {
glViewport(0,0,w(),h());
glFrustum(...);
glLight(...);
...other initilization...
}
... draw your geometry here ...
}
You can turn valid() on by calling valid(1). You
should only do this after fixing the transformation inside a draw()
or after make_current(). This is done automatically after
draw() returns.
The invalidate() method turns off valid() and is
equivalent to calling value(0).
Set the projection so 0,0 is in the lower left of the window and each
pixel is 1 unit wide/tall. If you are drawing 2D images, your
draw() method may want to call this if valid() is false.
The make_current() method selects the OpenGL context for the
widget. It is called automatically prior to the draw() method
being called and can also be used to implement feedback and/or
selection within the handle() method.
The make_overlay_current() method selects the OpenGL context
for the widget's overlay. It is called automatically prior to the
draw_overlay() method being called and can also be used to
implement feedback and/or selection within the handle()
method.
The swap_buffers() method swaps the back and front buffers.
It is called automatically after the draw() method is called.
Hides the window and destroys the OpenGL context.
Returns true if the hardware overlay is possible. If this is false,
FLTK will try to simulate the overlay, with significant loss of update
speed. Calling this will cause FLTK to open the display.
This method causes draw_overlay to be called at a later time.
Initially the overlay is clear, if you want the window to display
something in the overlay when it first appears, you must call this
immediately after you show() your window.
You must implement this virtual function if you want to draw into the
overlay. The overlay is cleared before this is called. You should
draw anything that is not clear using OpenGL. You must use
gl_color(i) to choose colors (it allocates them from the colormap
using system-specific calls), and remember that you are in an indexed
OpenGL mode and drawing anything other than flat-shaded will probably
not work.
Both this function and Fl_Gl_Window::draw() should check
Fl_Gl_Window::valid() and set the same transformation. If you
don't your code may not work on other systems. Depending on the OS,
and on whether overlays are real or simulated, the OpenGL context may
be the same or different between the overlay and main window.