From 09daf20b81cdae78772f07c0af22a571d7cc73eb Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Thu, 29 Nov 2001 19:24:00 +0000 Subject: Documentation updates galore (up to chapter 7, still need to do chapter 8 and 9, tweek the appendices, and recapture the screenshots...) git-svn-id: file:///fltk/svn/fltk/branches/branch-1.1@1786 ea41ed52-d2ee-0310-a9c1-e6b18d33e121 --- documentation/Fl_Gl_Window.html | 142 ++++++++++++++++++++-------------------- 1 file changed, 71 insertions(+), 71 deletions(-) (limited to 'documentation/Fl_Gl_Window.html') diff --git a/documentation/Fl_Gl_Window.html b/documentation/Fl_Gl_Window.html index 21276d2e0..fd5957e57 100644 --- a/documentation/Fl_Gl_Window.html +++ b/documentation/Fl_Gl_Window.html @@ -17,15 +17,15 @@

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

@@ -64,32 +64,32 @@ very well for single-buffered.

-

Fl_Gl_Window::Fl_Gl_Window(int x, +

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

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: + Set or change the OpenGL capabilites of the window. The value can be +any of the following OR'd together: -FL_RGB and FL_SINGLE have a value of zero, so they -are "on" unless you give FL_INDEX or FL_DOUBLE. +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 +

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 + 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. + Returns non-zero if the hardware supports the given or current OpenGL +mode.

void* Fl_Gl_Window::context() const;
void Fl_Gl_Window::context(void*, int destroy_flag = false);

@@ -136,11 +136,11 @@ href=#Fl_Gl_Window.mode>mode() is changed, or the next time

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 +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: +draw() method to avoid unneccessarily initializing the OpenGL +context. Just do this: -You can turn valid() on by calling valid(1). You +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. +draw() returns.

void Fl_Gl_Window::invalidate()

- The invalidate() method turns off valid() and is -equivalent to calling value(0). + 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 + 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. +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 + 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 + 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 +draw_overlay() method being called and can also be used to implement feedback and/or selection within the handle() - method. + 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. + 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 + 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 + 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 + 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 + 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. +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 +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