From 87dd7f0d23eba5c09e71ec6efeb34c6844f5e95f Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Tue, 29 Dec 1998 14:21:17 +0000 Subject: Revised documentation files. git-svn-id: file:///fltk/svn/fltk/trunk@177 ea41ed52-d2ee-0310-a9c1-e6b18d33e121 --- documentation/Fl_Gl_Window.html | 265 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 documentation/Fl_Gl_Window.html (limited to 'documentation/Fl_Gl_Window.html') diff --git a/documentation/Fl_Gl_Window.html b/documentation/Fl_Gl_Window.html new file mode 100644 index 000000000..47828b47c --- /dev/null +++ b/documentation/Fl_Gl_Window.html @@ -0,0 +1,265 @@ + + + +

+ +

class Fl_Gl_Window

+ +

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

+ + + + + + + + + + + +

Fl_Gl_Window +
~Fl_Gl_Window +
can_do +
can_do_overlay +

draw +
draw_overlay +
handle +

hide +
invalidate +
make_current +

make_overlay_current +
mode +
ortho +

redraw_overlay +
swap_buffers +
valid +

+ + +

Fl_Gl_Window::Fl_Gl_Window(int x, int y, int w, int h, const char *label = 0)

+ +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. + +

virtual Fl_Gl_Window::~Fl_Gl_Window()

+ +The destructor removes the widget and destroys the OpenGL context associated +with it. + +

virtual void Fl_Gl_Window::draw(void)

+ +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. + +

const int Fl_Gl_Window::mode() const
+int Fl_Gl_Window::mode(int m)

+ +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! + +

static int Fl_Gl_Window::can_do(int)
+int Fl_Gl_Window::can_do() const

+ +Returns non-zero if the hardware supports the given or current OpenGL mode. + +

char Fl_Gl_Window::valid() const
+void Fl_Gl_Window::valid(char i)

+ +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 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 initialization...
+  }
+  ... draw your geometry here ...
+}
+
+
void Fl_Gl_Window::invalidate();
+
void Fl_Gl_Window::valid(char i);
+
+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. + +void Fl_Gl_Window::invalidate() + +The invalidate() method turns off valid() and is +equivalent to calling value(0). + +void Fl_Gl_Window::ortho() + +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. + +void Fl_Gl_Window::make_current() + +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. + +void Fl_Gl_Window::make_overlay_current() + +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. + +void Fl_Gl_Window::swap_buffers() + +The swap_buffers() method swaps the back and front buffers. +It is called automatically after the draw() method is called. + +void Fl_Gl_Window::hide() + +Hides the window and destroys the OpenGL context. + +int Fl_Gl_Window::can_do_overlay() + +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. + +void Fl_Gl_Window::redraw_overlay() + +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. + +virtual void Fl_Gl_Window::draw_overlay() + +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. + + + -- cgit v1.2.3