From a6163888f3c56123b1db313743c6147ba498732c Mon Sep 17 00:00:00 2001 From: Yuval Adam Date: Fri, 8 Aug 2014 14:42:07 +0300 Subject: Add third_party libs --- .../fltk-1.1.10/documentation/Fl_Gl_Window.html | 246 +++++++++++++++++++++ 1 file changed, 246 insertions(+) create mode 100644 third_party/windows/fltk-1.1.10/documentation/Fl_Gl_Window.html (limited to 'third_party/windows/fltk-1.1.10/documentation/Fl_Gl_Window.html') diff --git a/third_party/windows/fltk-1.1.10/documentation/Fl_Gl_Window.html b/third_party/windows/fltk-1.1.10/documentation/Fl_Gl_Window.html new file mode 100644 index 0000000..75743c7 --- /dev/null +++ b/third_party/windows/fltk-1.1.10/documentation/Fl_Gl_Window.html @@ -0,0 +1,246 @@ + + + Fl_Gl_Window + + + + + +

class Fl_Gl_Window

+ +
+ +

Class Hierarchy

+ + + +

Include Files

+ + + +

Additional Libraries

+ + + +

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.

+

Please note that the FLTK drawing and clipping functions +will not work inside an Fl_Gl_Window. All drawing +should be done using OpenGL calls exclusively. +Even though Fl_Gl_Window is derived from Fl_Group, +it is not useful to add other FLTK Widgets as children, +unless those Widgets are modified to draw using OpenGL calls.

+ +

Methods

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

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

+

mode() must not be called within draw() since it +changes the current context.

+

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

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

+ +Return or set a pointer to the GLContext that this window is +using. This is a system-dependent structure, but it is portable to copy +the context from one window to another. You can also set it to NULL, +which will force FLTK to recreate the context the next time make_current() is called, this is +useful for getting around bugs in OpenGL implementations. + +

If destroy_flag is true the context will be destroyed by +fltk when the window is destroyed, or when the mode() is changed, or the next time +context(x) is called. + +

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

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

+Fl_Gl_Window::context_valid() will only be set if the +OpenGL context is created or recreated. It differs from +Fl_Gl_Window::valid() which is also set whenever the context +changes size. + +

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