From cf97ff84a9c8a613ce124fe9e0cdf64589b31518 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 11 Oct 2010 07:54:46 +0000 Subject: [PATCH 001/130] Fixed issue [#2072]: "Box2 constructor bug". --- Source/OpenTK/Math/Box2.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/OpenTK/Math/Box2.cs b/Source/OpenTK/Math/Box2.cs index cbc22b4c..4c54b622 100644 --- a/Source/OpenTK/Math/Box2.cs +++ b/Source/OpenTK/Math/Box2.cs @@ -45,8 +45,8 @@ namespace OpenTK { Left = topLeft.X; Top = topLeft.Y; - Right = topLeft.X; - Bottom = topLeft.Y; + Right = bottomRight.X; + Bottom = bottomRight.Y; } /// From 6f815689e78d312d439d6b48c3d37da3d73439ce Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 13 Oct 2010 20:42:58 +0000 Subject: [PATCH 002/130] Added UNSIGNED_INT to ActiveUniformType enum. Fixes issue [#2077]: "Add UnsignedInt to ActiveUniformType". --- Source/Bind/Specifications/GL2/enumext.spec | 1 + Source/OpenTK/Graphics/OpenGL/GLEnums.cs | 1 + 2 files changed, 2 insertions(+) diff --git a/Source/Bind/Specifications/GL2/enumext.spec b/Source/Bind/Specifications/GL2/enumext.spec index 4cfc17c3..5409b724 100644 --- a/Source/Bind/Specifications/GL2/enumext.spec +++ b/Source/Bind/Specifications/GL2/enumext.spec @@ -7393,6 +7393,7 @@ VertexAttribParameter enum: ActiveUniformType enum: SAMPLER_CUBE_SHADOW = 0x8DC5 + use DataType UNSIGNED_INT UNSIGNED_INT_VEC2 = 0x8DC6 UNSIGNED_INT_VEC3 = 0x8DC7 UNSIGNED_INT_VEC4 = 0x8DC8 diff --git a/Source/OpenTK/Graphics/OpenGL/GLEnums.cs b/Source/OpenTK/Graphics/OpenGL/GLEnums.cs index a96dd848..de3acffc 100644 --- a/Source/OpenTK/Graphics/OpenGL/GLEnums.cs +++ b/Source/OpenTK/Graphics/OpenGL/GLEnums.cs @@ -77,6 +77,7 @@ namespace OpenTK.Graphics.OpenGL public enum ActiveUniformType : int { Int = ((int)0x1404), + UnsignedInt = ((int)0x1405), Float = ((int)0x1406), FloatVec2 = ((int)0x8B50), FloatVec3 = ((int)0x8B51), From 1fc5e96a253057df1877f5484b27db76750751f1 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 18 Oct 2010 15:25:25 +0000 Subject: [PATCH 003/130] * Source/OpenTK/NativeWindow.cs: * Source/OpenTK/INativeWindow.cs: * Source/OpenTK/Platform/X11/API.cs: * Source/OpenTK/Platform/X11/X11GLNative.cs: * Source/OpenTK/Platform/Windows/WinGLNative.cs: * Source/OpenTK/Platform/MacOS/CarbonGLNative.cs: * Source/Examples/OpenTK/Test/GameWindowStates.cs: Initial implementation of CursorVisible API. See issue [#1560]. --- .../Examples/OpenTK/Test/GameWindowStates.cs | 33 +++++++++++++++++-- Source/OpenTK/INativeWindow.cs | 10 ++++++ Source/OpenTK/NativeWindow.cs | 18 ++++++++++ .../OpenTK/Platform/MacOS/CarbonGLNative.cs | 6 ++++ Source/OpenTK/Platform/Windows/WinGLNative.cs | 10 ++++++ Source/OpenTK/Platform/X11/API.cs | 20 +++++++++++ Source/OpenTK/Platform/X11/X11GLNative.cs | 32 ++++++++++++++++++ 7 files changed, 127 insertions(+), 2 deletions(-) diff --git a/Source/Examples/OpenTK/Test/GameWindowStates.cs b/Source/Examples/OpenTK/Test/GameWindowStates.cs index c15c0c21..8d6b9b67 100644 --- a/Source/Examples/OpenTK/Test/GameWindowStates.cs +++ b/Source/Examples/OpenTK/Test/GameWindowStates.cs @@ -23,6 +23,7 @@ namespace Examples.Tests bool mouse_in_window = false; bool viewport_changed = true; bool refresh_text = true; + bool move_window = false; public GameWindowStates() : base(800, 600) @@ -38,7 +39,8 @@ namespace Examples.Tests Resize += delegate { refresh_text = true; }; WindowBorderChanged += delegate { refresh_text = true; }; WindowStateChanged += delegate { refresh_text = true; }; - Mouse.Move += delegate { refresh_text = true; }; + Mouse.Move += MouseMoveHandler; + Mouse.ButtonDown += MouseButtonHandler; } void KeyDownHandler(object sender, KeyboardKeyEventArgs e) @@ -68,7 +70,33 @@ namespace Examples.Tests case Key.Minus: Size -= new Size(16, 16); break; } } - + + void MouseMoveHandler(object sender, MouseMoveEventArgs e) + { + refresh_text = true; + + if (move_window) + { + Location = new Point(X + e.XDelta, Y + e.YDelta); + } + } + + void MouseButtonHandler(object sender, MouseButtonEventArgs e) + { + refresh_text = true; + + if (e.IsPressed) + { + CursorVisible = false; + move_window = true; + } + else + { + CursorVisible = true; + move_window = false; + } + } + static int Clamp(int val, int min, int max) { return val > max ? max : val < min ? min : val; @@ -97,6 +125,7 @@ namespace Examples.Tests DrawString(gfx, String.Format("Focused: {0}.", this.Focused), line++); DrawString(gfx, String.Format("Mouse {0} window.", mouse_in_window ? "inside" : "outside of"), line++); DrawString(gfx, String.Format("Mouse position: {0}", new Vector3(Mouse.X, Mouse.Y, Mouse.Wheel)), line++); + DrawString(gfx, String.Format("Mouse visible: {0}", CursorVisible), line++); DrawString(gfx, String.Format("Window.Bounds: {0}", Bounds), line++); DrawString(gfx, String.Format("Window.Location: {0}, Size: {1}", Location, Size), line++); DrawString(gfx, String.Format("Window.{{X={0}, Y={1}, Width={2}, Height={3}}}", X, Y, Width, Height), line++); diff --git a/Source/OpenTK/INativeWindow.cs b/Source/OpenTK/INativeWindow.cs index 6bb3b33b..03927607 100644 --- a/Source/OpenTK/INativeWindow.cs +++ b/Source/OpenTK/INativeWindow.cs @@ -132,6 +132,16 @@ namespace OpenTK [Obsolete] OpenTK.Input.IInputDriver InputDriver { get; } + /// + /// Gets or sets a value, indicating whether the mouse cursor is visible. + /// + bool CursorVisible { get; set; } + +// /// +// /// Gets or sets a value, indicating whether the mouse cursor is confined inside the window size. +// /// +// bool CursorGrabbed { get; set; } + /// /// Closes this window. /// diff --git a/Source/OpenTK/NativeWindow.cs b/Source/OpenTK/NativeWindow.cs index f6f00857..681eb3ef 100644 --- a/Source/OpenTK/NativeWindow.cs +++ b/Source/OpenTK/NativeWindow.cs @@ -49,6 +49,7 @@ namespace OpenTK private readonly INativeWindow implementation; private bool disposed, events; + private bool cursor_visible = true; #endregion @@ -541,6 +542,23 @@ namespace OpenTK #endregion + #region CursorVisible + + /// + /// Gets or sets a value indicating whether the mouse cursor is visible. + /// + public bool CursorVisible + { + get { return cursor_visible; } + set + { + cursor_visible = value; + implementation.CursorVisible = value; + } + } + + #endregion + #endregion #region Events diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index aa483365..2919ca54 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -925,6 +925,12 @@ namespace OpenTK.Platform.MacOS } } + public bool CursorVisible + { + get { return true; } + set { } + } + public void Close() { CancelEventArgs e = new CancelEventArgs(); diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 438b49cf..442e02f9 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -836,6 +836,16 @@ namespace OpenTK.Platform.Windows public bool Exists { get { return exists; } } + #endregion + + #region CursorVisible + + public bool CursorVisible + { + get { return true; } + set { } + } + #endregion #region Close diff --git a/Source/OpenTK/Platform/X11/API.cs b/Source/OpenTK/Platform/X11/API.cs index 442842e5..eaa80214 100644 --- a/Source/OpenTK/Platform/X11/API.cs +++ b/Source/OpenTK/Platform/X11/API.cs @@ -1562,6 +1562,26 @@ XF86VidModeGetGammaRampSize( #endregion #endregion + + public static Pixmap XCreateBitmapFromData(Display display, Window d, byte[,] data) + { + if (data == null) + throw new ArgumentNullException("data"); + + unsafe + { + fixed (byte* pdata = data) + { + return XCreateBitmapFromData(display, d, pdata, data.GetLength(0), data.GetLength(1)); + } + } + } + + [DllImport(X11Library)] + unsafe public static extern Pixmap XCreateBitmapFromData(Display display, Window d, byte* data, int width, int height); + + [DllImport("libX11", EntryPoint = "XAllocColor")] + public static extern Status XAllocNamedColor(Display display, Colormap colormap, string color_name, out XColor screen_def_return, out XColor exact_def_return); } /* [StructLayout(LayoutKind.Sequential)] diff --git a/Source/OpenTK/Platform/X11/X11GLNative.cs b/Source/OpenTK/Platform/X11/X11GLNative.cs index 7119095f..054b7c66 100644 --- a/Source/OpenTK/Platform/X11/X11GLNative.cs +++ b/Source/OpenTK/Platform/X11/X11GLNative.cs @@ -1300,6 +1300,38 @@ namespace OpenTK.Platform.X11 #endregion + public bool CursorVisible + { + get { return true; } + set + { + if (value) + { + using (new XLock(window.Display)) + { + Functions.XUndefineCursor(window.Display, window.WindowHandle); + } + } + else + { + using (new XLock(window.Display)) + { + XColor black, dummy; + IntPtr cmap = Functions.XDefaultColormap(window.Display, window.Screen); + Functions.XAllocNamedColor(window.Display, cmap, "black", out black, out dummy); + IntPtr bmp_empty = Functions.XCreateBitmapFromData(window.Display, + window.WindowHandle, new byte[,] { { 0 } }); + IntPtr cursor_empty = Functions.XCreatePixmapCursor(window.Display, + bmp_empty, bmp_empty, ref black, ref black, 0, 0); + + Functions.XDefineCursor(window.Display, window.WindowHandle, cursor_empty); + + Functions.XFreeCursor(window.Display, cursor_empty); + } + } + } + } + #endregion #region --- INativeGLWindow Members --- From e1cf566c81732d50a21d4194d5194c9d88b659b5 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 18 Oct 2010 15:48:32 +0000 Subject: [PATCH 004/130] * Source/Examples/OpenTK/Test/GameWindowStates.cs: Handle MouseButtonUp event to make mouse visible. --- .../Examples/OpenTK/Test/GameWindowStates.cs | 20 +++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/Source/Examples/OpenTK/Test/GameWindowStates.cs b/Source/Examples/OpenTK/Test/GameWindowStates.cs index 8d6b9b67..202d1d5b 100644 --- a/Source/Examples/OpenTK/Test/GameWindowStates.cs +++ b/Source/Examples/OpenTK/Test/GameWindowStates.cs @@ -41,6 +41,7 @@ namespace Examples.Tests WindowStateChanged += delegate { refresh_text = true; }; Mouse.Move += MouseMoveHandler; Mouse.ButtonDown += MouseButtonHandler; + Mouse.ButtonUp += MouseButtonHandler; } void KeyDownHandler(object sender, KeyboardKeyEventArgs e) @@ -85,15 +86,18 @@ namespace Examples.Tests { refresh_text = true; - if (e.IsPressed) + if (e.Button == MouseButton.Left) { - CursorVisible = false; - move_window = true; - } - else - { - CursorVisible = true; - move_window = false; + if (e.IsPressed) + { + CursorVisible = false; + move_window = true; + } + else + { + CursorVisible = true; + move_window = false; + } } } From 60a9af59398979789b9da965e2ff47736eaec754 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 18 Oct 2010 16:14:38 +0000 Subject: [PATCH 005/130] * Source/OpenTK/Platform/Windows/API.cs: * Source/OpenTK/Platform/Windows/WinGLNative.cs: Implemented CursorVisible. --- Source/OpenTK/Platform/Windows/API.cs | 6 ++++++ Source/OpenTK/Platform/Windows/WinGLNative.cs | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/Source/OpenTK/Platform/Windows/API.cs b/Source/OpenTK/Platform/Windows/API.cs index 920d081b..ed39f0f2 100644 --- a/Source/OpenTK/Platform/Windows/API.cs +++ b/Source/OpenTK/Platform/Windows/API.cs @@ -951,6 +951,12 @@ namespace OpenTK.Platform.Windows [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)] public static extern IntPtr SetFocus(IntPtr hwnd); + [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)] + public static extern int ShowCursor(bool show); + + [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)] + public static extern bool ClipCursor(ref RECT rcClip); + #region Async input #region GetCursorPos diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 442e02f9..99c3efa3 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -843,7 +843,7 @@ namespace OpenTK.Platform.Windows public bool CursorVisible { get { return true; } - set { } + set { Functions.ShowCursor(value); } } #endregion From 9c524e0d5235940cb42b978bf893105c2e8d6ae5 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 18 Oct 2010 16:14:50 +0000 Subject: [PATCH 006/130] * Source/OpenTK/Platform/MacOS/CarbonGLNative.cs: Removed unused code. --- Source/OpenTK/Platform/MacOS/CarbonGLNative.cs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index 2919ca54..ea517095 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -694,8 +694,6 @@ namespace OpenTK.Platform.MacOS public Point PointToClient(Point point) { - IntPtr handle = window.WindowRef; - Rect r = Carbon.API.GetWindowBounds(window.WindowRef, WindowRegionCode.ContentRegion); Debug.Print("Rect: {0}", r); @@ -703,8 +701,6 @@ namespace OpenTK.Platform.MacOS } public Point PointToScreen(Point point) { - IntPtr handle = window.WindowRef; - Rect r = Carbon.API.GetWindowBounds(window.WindowRef, WindowRegionCode.ContentRegion); Debug.Print("Rect: {0}", r); From f302a62fc15b02cc3ec7cb1c8c0e0d7224aec13e Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 19 Oct 2010 09:20:59 +0000 Subject: [PATCH 007/130] Added initial code for mouse grabbing. Modified GameWindowStates to test this. --- .../Examples/OpenTK/Test/GameWindowStates.cs | 20 ++++++--------- Source/OpenTK/Platform/Windows/API.cs | 3 +++ Source/OpenTK/Platform/Windows/WinGLNative.cs | 25 +++++++++++++++++-- 3 files changed, 34 insertions(+), 14 deletions(-) diff --git a/Source/Examples/OpenTK/Test/GameWindowStates.cs b/Source/Examples/OpenTK/Test/GameWindowStates.cs index 202d1d5b..b2e33b2b 100644 --- a/Source/Examples/OpenTK/Test/GameWindowStates.cs +++ b/Source/Examples/OpenTK/Test/GameWindowStates.cs @@ -48,7 +48,12 @@ namespace Examples.Tests { switch (e.Key) { - case OpenTK.Input.Key.Escape: this.Exit(); break; + case OpenTK.Input.Key.Escape: + if (!CursorVisible) + CursorVisible = true; + else + Exit(); + break; case Key.Number1: WindowState = WindowState.Normal; break; case Key.Number2: WindowState = WindowState.Maximized; break; @@ -86,18 +91,9 @@ namespace Examples.Tests { refresh_text = true; - if (e.Button == MouseButton.Left) + if (e.Button == MouseButton.Left && e.IsPressed) { - if (e.IsPressed) - { - CursorVisible = false; - move_window = true; - } - else - { - CursorVisible = true; - move_window = false; - } + CursorVisible = false; } } diff --git a/Source/OpenTK/Platform/Windows/API.cs b/Source/OpenTK/Platform/Windows/API.cs index ed39f0f2..20cb38a7 100644 --- a/Source/OpenTK/Platform/Windows/API.cs +++ b/Source/OpenTK/Platform/Windows/API.cs @@ -957,6 +957,9 @@ namespace OpenTK.Platform.Windows [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)] public static extern bool ClipCursor(ref RECT rcClip); + [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)] + public static extern bool ClipCursor(IntPtr rcClip); + #region Async input #region GetCursorPos diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 99c3efa3..2efd2c78 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -93,6 +93,8 @@ namespace OpenTK.Platform.Windows KeyPressEventArgs key_press = new KeyPressEventArgs((char)0); + int cursor_visible_count = 0; + #endregion #region Contructors @@ -842,8 +844,27 @@ namespace OpenTK.Platform.Windows public bool CursorVisible { - get { return true; } - set { Functions.ShowCursor(value); } + get { return cursor_visible_count > 0; } + set + { + if (value && cursor_visible_count < 0) + { + cursor_visible_count = Functions.ShowCursor(true); + + if (!Functions.ClipCursor(IntPtr.Zero)) + Debug.WriteLine(String.Format("Failed to grab cursor. Error: {0}", + Marshal.GetLastWin32Error())); + } + else if (!value && cursor_visible_count >= 0) + { + cursor_visible_count = Functions.ShowCursor(false); + + Win32Rectangle rect = Win32Rectangle.From(ClientRectangle); + if (!Functions.ClipCursor(ref rect)) + Debug.WriteLine(String.Format("Failed to grab cursor. Error: {0}", + Marshal.GetLastWin32Error())); + } + } } #endregion From 63b35badeeac0cf0094f7c6a0ce1486f2728a6d4 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 19 Oct 2010 09:25:09 +0000 Subject: [PATCH 008/130] Take into account the fact that ShowCursor(true/false) calls are cumulative (we want boolean behavior instead). --- Source/OpenTK/Platform/Windows/WinGLNative.cs | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 2efd2c78..6c084f62 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -849,7 +849,11 @@ namespace OpenTK.Platform.Windows { if (value && cursor_visible_count < 0) { - cursor_visible_count = Functions.ShowCursor(true); + do + { + cursor_visible_count = Functions.ShowCursor(true); + } + while (cursor_visible_count < 0); if (!Functions.ClipCursor(IntPtr.Zero)) Debug.WriteLine(String.Format("Failed to grab cursor. Error: {0}", @@ -857,9 +861,13 @@ namespace OpenTK.Platform.Windows } else if (!value && cursor_visible_count >= 0) { - cursor_visible_count = Functions.ShowCursor(false); + do + { + cursor_visible_count = Functions.ShowCursor(false); + } + while (cursor_visible_count >= 0); - Win32Rectangle rect = Win32Rectangle.From(ClientRectangle); + Win32Rectangle rect = Win32Rectangle.From(Bounds); if (!Functions.ClipCursor(ref rect)) Debug.WriteLine(String.Format("Failed to grab cursor. Error: {0}", Marshal.GetLastWin32Error())); From 527cdf862238c39bedc6322c33e3d740988f9513 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 20 Oct 2010 09:19:34 +0000 Subject: [PATCH 009/130] * Source/OpenTK/Platform/X11/X11GLNative.cs: Refactored empty cursor creation into its own function. Create one empty cursor for the lifetime of the window. --- Source/OpenTK/Platform/X11/X11GLNative.cs | 35 +++++++++++++++-------- 1 file changed, 23 insertions(+), 12 deletions(-) diff --git a/Source/OpenTK/Platform/X11/X11GLNative.cs b/Source/OpenTK/Platform/X11/X11GLNative.cs index 054b7c66..4277c54e 100644 --- a/Source/OpenTK/Platform/X11/X11GLNative.cs +++ b/Source/OpenTK/Platform/X11/X11GLNative.cs @@ -113,6 +113,8 @@ namespace OpenTK.Platform.X11 readonly char[] chars = new char[16]; readonly KeyPressEventArgs KPEventArgs = new KeyPressEventArgs('\0'); + readonly IntPtr EmptyCursor; + #endregion #region Constructors @@ -195,6 +197,8 @@ namespace OpenTK.Platform.X11 driver = new X11Input(window); + EmptyCursor = CreateEmptyCursor(window); + Debug.WriteLine(String.Format("X11GLNative window created successfully (id: {0}).", Handle)); Debug.Unindent(); @@ -677,6 +681,22 @@ namespace OpenTK.Platform.X11 } } + static IntPtr CreateEmptyCursor(X11WindowInfo window) + { + IntPtr cursor = IntPtr.Zero; + using (new XLock(window.Display)) + { + XColor black, dummy; + IntPtr cmap = Functions.XDefaultColormap(window.Display, window.Screen); + Functions.XAllocNamedColor(window.Display, cmap, "black", out black, out dummy); + IntPtr bmp_empty = Functions.XCreateBitmapFromData(window.Display, + window.WindowHandle, new byte[,] { { 0 } }); + cursor = Functions.XCreatePixmapCursor(window.Display, + bmp_empty, bmp_empty, ref black, ref black, 0, 0); + } + return cursor; + } + #endregion #region INativeWindow Members @@ -1302,7 +1322,7 @@ namespace OpenTK.Platform.X11 public bool CursorVisible { - get { return true; } + get { return true; } // Not used set { if (value) @@ -1316,17 +1336,7 @@ namespace OpenTK.Platform.X11 { using (new XLock(window.Display)) { - XColor black, dummy; - IntPtr cmap = Functions.XDefaultColormap(window.Display, window.Screen); - Functions.XAllocNamedColor(window.Display, cmap, "black", out black, out dummy); - IntPtr bmp_empty = Functions.XCreateBitmapFromData(window.Display, - window.WindowHandle, new byte[,] { { 0 } }); - IntPtr cursor_empty = Functions.XCreatePixmapCursor(window.Display, - bmp_empty, bmp_empty, ref black, ref black, 0, 0); - - Functions.XDefineCursor(window.Display, window.WindowHandle, cursor_empty); - - Functions.XFreeCursor(window.Display, cursor_empty); + Functions.XDefineCursor(window.Display, window.WindowHandle, EmptyCursor); } } } @@ -1553,6 +1563,7 @@ namespace OpenTK.Platform.X11 { using (new XLock(window.Display)) { + Functions.XFreeCursor(window.Display, EmptyCursor); Functions.XDestroyWindow(window.Display, window.WindowHandle); } From 33529aff6312287a2956634d4dd0b27c24d61e39 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 20 Oct 2010 09:50:49 +0000 Subject: [PATCH 010/130] * Source/OpenTK/Platform/X11/X11GLNative.cs: Confine pointer to window when it becomes invisible. --- Source/OpenTK/Platform/X11/X11GLNative.cs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Source/OpenTK/Platform/X11/X11GLNative.cs b/Source/OpenTK/Platform/X11/X11GLNative.cs index 4277c54e..9ef2de18 100644 --- a/Source/OpenTK/Platform/X11/X11GLNative.cs +++ b/Source/OpenTK/Platform/X11/X11GLNative.cs @@ -1329,6 +1329,7 @@ namespace OpenTK.Platform.X11 { using (new XLock(window.Display)) { + Functions.XUngrabPointer(window.Display, IntPtr.Zero); Functions.XUndefineCursor(window.Display, window.WindowHandle); } } @@ -1337,6 +1338,11 @@ namespace OpenTK.Platform.X11 using (new XLock(window.Display)) { Functions.XDefineCursor(window.Display, window.WindowHandle, EmptyCursor); + Functions.XGrabPointer(window.Display, window.WindowHandle, true, + EventMask.PointerMotionMask | EventMask.ButtonPressMask | EventMask.ButtonReleaseMask, + GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, window.WindowHandle, IntPtr.Zero, + IntPtr.Zero); + } } } From 7e3182b1fc399ebf66d7c03a4838a1bc11ed3f39 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 20 Oct 2010 14:33:23 +0000 Subject: [PATCH 011/130] * Source/OpenTK/OpenTK.csproj: * Source/OpenTK/Input/Keyboard.cs: * Source/OpenTK/Input/InputDriver.cs: * Source/OpenTK/Input/KeyboardState.cs: * Source/OpenTK/Input/IKeyboardDriver.cs: * Source/OpenTK/Platform/X11/X11Input.cs: * Source/OpenTK/Platform/X11/Functions.cs: * Source/OpenTK/Platform/X11/X11Factory.cs: * Source/OpenTK/Platform/Windows/WMInput.cs: * Source/OpenTK/Platform/X11/X11Keyboard.cs: * Source/OpenTK/Platform/MacOS/CarbonInput.cs: * Source/OpenTK/Platform/Windows/WinGLNative.cs: * Source/OpenTK/Platform/Windows/WinRawInput.cs: * Source/OpenTK/Platform/Windows/WinRawKeyboard.cs: Added initial OpenTK.Input.Keyboard implementation for X11. --- Source/OpenTK/Input/IKeyboardDriver.cs | 13 ++ Source/OpenTK/Input/InputDriver.cs | 10 ++ Source/OpenTK/Input/Keyboard.cs | 17 +-- Source/OpenTK/Input/KeyboardState.cs | 63 +++++++-- Source/OpenTK/OpenTK.csproj | 3 +- Source/OpenTK/Platform/MacOS/CarbonInput.cs | 10 ++ Source/OpenTK/Platform/Windows/WMInput.cs | 10 ++ Source/OpenTK/Platform/Windows/WinGLNative.cs | 12 +- Source/OpenTK/Platform/Windows/WinRawInput.cs | 10 ++ .../OpenTK/Platform/Windows/WinRawKeyboard.cs | 10 ++ Source/OpenTK/Platform/X11/Functions.cs | 6 + Source/OpenTK/Platform/X11/X11Factory.cs | 2 +- Source/OpenTK/Platform/X11/X11Input.cs | 10 ++ Source/OpenTK/Platform/X11/X11Keyboard.cs | 131 ++++++++++++++++++ 14 files changed, 277 insertions(+), 30 deletions(-) create mode 100644 Source/OpenTK/Platform/X11/X11Keyboard.cs diff --git a/Source/OpenTK/Input/IKeyboardDriver.cs b/Source/OpenTK/Input/IKeyboardDriver.cs index e14493f9..b2806917 100644 --- a/Source/OpenTK/Input/IKeyboardDriver.cs +++ b/Source/OpenTK/Input/IKeyboardDriver.cs @@ -19,5 +19,18 @@ namespace OpenTK.Input /// Gets the list of available KeyboardDevices. /// IList Keyboard { get; } + + /// + /// Retrieves the KeyboardState for the default keyboard device. + /// + /// A structure containing the state of the keyboard device. + KeyboardState GetState(); + + /// + /// Retrieves the KeyboardState for the specified keyboard device. + /// + /// The index of the keyboard device. + /// A structure containing the state of the keyboard device. + KeyboardState GetState(int index); } } diff --git a/Source/OpenTK/Input/InputDriver.cs b/Source/OpenTK/Input/InputDriver.cs index a1087842..3c3cf5a5 100644 --- a/Source/OpenTK/Input/InputDriver.cs +++ b/Source/OpenTK/Input/InputDriver.cs @@ -73,6 +73,16 @@ namespace OpenTK get { return inputDriver.Keyboard; } } + public KeyboardState GetState() + { + return inputDriver.GetState(); + } + + public KeyboardState GetState(int index) + { + return inputDriver.GetState(index); + } + #endregion #region --- IMouseDriver Members --- diff --git a/Source/OpenTK/Input/Keyboard.cs b/Source/OpenTK/Input/Keyboard.cs index 562d63af..104a92fd 100644 --- a/Source/OpenTK/Input/Keyboard.cs +++ b/Source/OpenTK/Input/Keyboard.cs @@ -38,17 +38,8 @@ namespace OpenTK.Input { #region Fields - //static IKeyboardDriver driver; - - #endregion - - #region Constructors - - static Keyboard() - { - throw new NotImplementedException(); - //driver = Platform.Factory.Default.CreateKeyboardDriver(); - } + static readonly IKeyboardDriver driver = + Platform.Factory.Default.CreateKeyboardDriver(); #endregion @@ -60,7 +51,7 @@ namespace OpenTK.Input /// A structure containing the state of the keyboard device. public static KeyboardState GetState() { - return new KeyboardState(); + return driver.GetState(); } /// @@ -70,7 +61,7 @@ namespace OpenTK.Input /// A structure containing the state of the keyboard device. public static KeyboardState GetState(int index) { - return new KeyboardState(); + return driver.GetState(index); } #endregion diff --git a/Source/OpenTK/Input/KeyboardState.cs b/Source/OpenTK/Input/KeyboardState.cs index f97c7625..9d05a32a 100644 --- a/Source/OpenTK/Input/KeyboardState.cs +++ b/Source/OpenTK/Input/KeyboardState.cs @@ -26,7 +26,7 @@ #endregion using System; -using System.Collections.Generic; +using System.Collections.Specialized; using System.Text; namespace OpenTK.Input @@ -39,9 +39,8 @@ namespace OpenTK.Input #region Fields const int NumKeys = ((int)Key.LastKey + 16) / 32; - // Todo: The following line triggers bogus CS0214 in gmcs 2.0.1, sigh... - // Need to add a workaround using either ExplicitLayout or another trick. - //unsafe fixed int Keys[NumKeys]; + // The following line triggers bogus CS0214 in gmcs 2.0.1, sigh... + unsafe fixed int Keys[NumKeys]; #endregion @@ -57,7 +56,7 @@ namespace OpenTK.Input /// The to check. public bool IsKeyDown(Key key) { - return ReadBit((int)key) != 0; + return ReadBit((int)key); } /// @@ -66,24 +65,50 @@ namespace OpenTK.Input /// The to check. public bool IsKeyUp(Key key) { - return ReadBit((int)key) == 0; + return !ReadBit((int)key); } #endregion #region Internal Members - internal int ReadBit(int offset) + internal bool ReadBit(int offset) { - return 0; - //unsafe { return (Keys[(offset / 32)] & (1 << (offset % 32))); } + int int_offset = offset / 32; + int bit_offset = offset % 32; + unsafe + { + fixed (int* k = Keys) + { + return (*(k + int_offset) & (1 << bit_offset)) != 0u; + } + } } - internal enum BitValue { Zero = 0, One = 1 } - internal void WriteBit(int offset, BitValue bit) + internal void EnableBit(int offset) { - // Todo: this is completely broken. - //unsafe { Keys[offset / 32] = Keys[offset / 32] ^ (~(int)bit << (offset % 32)); } + int int_offset = offset / 32; + int bit_offset = offset % 32; + unsafe + { + fixed (int* k = Keys) + { + *(k + int_offset) |= 1 << bit_offset; + } + } + } + + internal void DisableBit(int offset) + { + int int_offset = offset / 32; + int bit_offset = offset % 32; + unsafe + { + fixed (int* k = Keys) + { + *(k + int_offset) &= ~(1 << bit_offset); + } + } } #endregion @@ -97,7 +122,17 @@ namespace OpenTK.Input /// True, if both instances are equal; false otherwise. public bool Equals(KeyboardState other) { - throw new NotImplementedException(); + bool equal = true; + unsafe + { + fixed (int* k1 = Keys) + fixed (int* k2 = Keys) + { + for (int i = 0; equal && i < NumKeys; i++) + equal &= *(k1 + i) == *(k2 + i); + } + } + return equal; } #endregion diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index dc177639..0510e48d 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -1,4 +1,4 @@ - + Local @@ -756,6 +756,7 @@ Always + diff --git a/Source/OpenTK/Platform/MacOS/CarbonInput.cs b/Source/OpenTK/Platform/MacOS/CarbonInput.cs index b8d08b51..c9c3b997 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonInput.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonInput.cs @@ -35,6 +35,16 @@ namespace OpenTK.Platform.MacOS get { return dummy_keyboard_list; } } + public KeyboardState GetState() + { + throw new NotImplementedException(); + } + + public KeyboardState GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region IMouseDriver Members diff --git a/Source/OpenTK/Platform/Windows/WMInput.cs b/Source/OpenTK/Platform/Windows/WMInput.cs index 4015170e..d62b9af6 100644 --- a/Source/OpenTK/Platform/Windows/WMInput.cs +++ b/Source/OpenTK/Platform/Windows/WMInput.cs @@ -246,6 +246,16 @@ namespace OpenTK.Platform.Windows get { return keyboards; } } + public KeyboardState GetState() + { + throw new NotImplementedException(); + } + + public KeyboardState GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region IMouseDriver Members diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 6c084f62..cffe637b 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -844,7 +844,7 @@ namespace OpenTK.Platform.Windows public bool CursorVisible { - get { return cursor_visible_count > 0; } + get { return cursor_visible_count > 0; } // Not used set { if (value && cursor_visible_count < 0) @@ -1186,6 +1186,16 @@ namespace OpenTK.Platform.Windows get { return keyboards; } } + public KeyboardState GetState() + { + throw new NotImplementedException(); + } + + public KeyboardState GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region IMouseDriver Members diff --git a/Source/OpenTK/Platform/Windows/WinRawInput.cs b/Source/OpenTK/Platform/Windows/WinRawInput.cs index bd815741..3c3ad291 100644 --- a/Source/OpenTK/Platform/Windows/WinRawInput.cs +++ b/Source/OpenTK/Platform/Windows/WinRawInput.cs @@ -207,6 +207,16 @@ namespace OpenTK.Platform.Windows get { return keyboardDriver.Keyboard; } } + public KeyboardState GetState() + { + throw new NotImplementedException(); + } + + public KeyboardState GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region IMouseDriver Members diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index 4bf8b994..b4012dde 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -237,6 +237,16 @@ namespace OpenTK.Platform.Windows get { return keyboards; } } + public KeyboardState GetState() + { + throw new NotImplementedException(); + } + + public KeyboardState GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region --- IDisposable Members --- diff --git a/Source/OpenTK/Platform/X11/Functions.cs b/Source/OpenTK/Platform/X11/Functions.cs index 1cbf5f97..88a53e40 100644 --- a/Source/OpenTK/Platform/X11/Functions.cs +++ b/Source/OpenTK/Platform/X11/Functions.cs @@ -176,6 +176,12 @@ namespace OpenTK.Platform.X11 [DllImport("libX11", EntryPoint = "XTranslateCoordinates")] public extern static bool XTranslateCoordinates(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return); + [DllImport("libX11", EntryPoint = "XGrabKeyboard")] + public extern static int XGrabKeyboard(IntPtr display, IntPtr window, bool owner_events, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr timestamp); + + [DllImport("libX11", EntryPoint = "XUngrabKeyboard")] + public extern static int XUngrabKeyboard(IntPtr display, IntPtr timestamp); + [DllImport("libX11", EntryPoint = "XGetGeometry")] public extern static bool XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth); diff --git a/Source/OpenTK/Platform/X11/X11Factory.cs b/Source/OpenTK/Platform/X11/X11Factory.cs index 97ddf3e2..16dbaafe 100644 --- a/Source/OpenTK/Platform/X11/X11Factory.cs +++ b/Source/OpenTK/Platform/X11/X11Factory.cs @@ -80,7 +80,7 @@ namespace OpenTK.Platform.X11 public virtual OpenTK.Input.IKeyboardDriver CreateKeyboardDriver() { - throw new NotImplementedException(); + return new X11Keyboard(null); } #endregion diff --git a/Source/OpenTK/Platform/X11/X11Input.cs b/Source/OpenTK/Platform/X11/X11Input.cs index ae4473b1..b34e0601 100644 --- a/Source/OpenTK/Platform/X11/X11Input.cs +++ b/Source/OpenTK/Platform/X11/X11Input.cs @@ -219,6 +219,16 @@ namespace OpenTK.Platform.X11 get { return dummy_keyboard_list; }//return keyboardDriver.Keyboard; } + public KeyboardState GetState() + { + throw new NotImplementedException(); + } + + public KeyboardState GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region public IList Mouse diff --git a/Source/OpenTK/Platform/X11/X11Keyboard.cs b/Source/OpenTK/Platform/X11/X11Keyboard.cs new file mode 100644 index 00000000..96422b71 --- /dev/null +++ b/Source/OpenTK/Platform/X11/X11Keyboard.cs @@ -0,0 +1,131 @@ + #region License + // + // The Open Toolkit Library License + // + // Copyright (c) 2006 - 2010 the Open Toolkit library. + // + // Permission is hereby granted, free of charge, to any person obtaining a copy + // of this software and associated documentation files (the "Software"), to deal + // in the Software without restriction, including without limitation the rights to + // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + // the Software, and to permit persons to whom the Software is furnished to do + // so, subject to the following conditions: + // + // The above copyright notice and this permission notice shall be included in all + // copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + // OTHER DEALINGS IN THE SOFTWARE. + // + #endregion + +using System; +using System.Collections.Generic; +using OpenTK.Input; + +namespace OpenTK.Platform.X11 +{ + // Standard keyboard driver that relies on xlib input events. + // Only one keyboard supported. + sealed class X11Keyboard : IKeyboardDriver + { + readonly X11WindowInfo window = new X11WindowInfo(); + readonly X11KeyMap keymap = new X11KeyMap(); + KeyboardState state = new KeyboardState(); + + // Can either attach itself to the specified window or can hook the root window. + public X11Keyboard(X11WindowInfo win) + { + if (win != null) + { + window = win; + } + else + { + using (new XLock(API.DefaultDisplay)) + { + window.Display = API.DefaultDisplay; + window.Screen = Functions.XDefaultScreen(window.Display); + window.RootWindow = Functions.XRootWindow(window.Display, window.Screen); + window.WindowHandle = window.RootWindow; + window.EventMask =EventMask.KeyPressMask | EventMask.KeyReleaseMask | EventMask.KeymapStateMask; + + Functions.XGrabKeyboard(window.Display, window.RootWindow, true, + GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, IntPtr.Zero); + Functions.XSelectInput(window.Display, window.RootWindow, new IntPtr((int)window.EventMask)); + } + } + } + + // Todo: remove this + public IList Keyboard { get { throw new NotSupportedException(); } } + + public KeyboardState GetState() + { + ProcessEvents(); + return state; + } + + public KeyboardState GetState(int index) + { + ProcessEvents(); + return state; + } + + void ProcessEvents() + { + XEvent e = new XEvent(); + + while (true) + { + using (new XLock(window.Display)) + { + if (!Functions.XCheckWindowEvent(window.Display, window.WindowHandle, window.EventMask, ref e)) + break; + + switch (e.type) + { + case XEventName.KeyPress: + case XEventName.KeyRelease: + bool pressed = e.type == XEventName.KeyPress; + + IntPtr keysym = API.LookupKeysym(ref e.KeyEvent, 0); + IntPtr keysym2 = API.LookupKeysym(ref e.KeyEvent, 1); + + if (keymap.ContainsKey((XKey)keysym)) + { + if (pressed) + state.EnableBit((int)keymap[(XKey)keysym]); + else + state.DisableBit((int)keymap[(XKey)keysym]); + } + else if (keymap.ContainsKey((XKey)keysym2)) + { + if (pressed) + state.EnableBit((int)keymap[(XKey)keysym2]); + else + state.DisableBit((int)keymap[(XKey)keysym2]); + } + else + { + System.Diagnostics.Debug.Print("KeyCode {0} (Keysym: {1}, {2}) not mapped.", + e.KeyEvent.keycode, (XKey)keysym, (XKey)keysym2); + } + break; + + case XEventName.KeymapNotify: + System.Diagnostics.Debug.Print("Keymap event: {0}", e.KeymapEvent.key_vector0); + break; + } + } + } + } + } +} + From 85c37f06003f581933a3fb290f1e95a02e8d4372 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 20 Oct 2010 14:58:38 +0000 Subject: [PATCH 012/130] * Source/OpenTK/Input/Mouse.cs: * Source/OpenTK/Platform/Factory.cs: * Source/OpenTK/Input/InputDriver.cs: * Source/OpenTK/Input/IMouseDriver.cs: * Source/OpenTK/Platform/X11/X11Input.cs: * Source/OpenTK/Platform/X11/X11Factory.cs: * Source/OpenTK/Platform/Windows/WMInput.cs: * Source/OpenTK/Platform/IPlatformFactory.cs: * Source/OpenTK/Platform/MacOS/CarbonInput.cs: * Source/OpenTK/Platform/Windows/WinFactory.cs: * Source/OpenTK/Platform/MacOS/MacOSFactory.cs: * Source/OpenTK/Platform/Windows/WinGLNative.cs: * Source/OpenTK/Platform/Windows/WinRawMouse.cs: * Source/OpenTK/Platform/Windows/WinRawInput.cs: Added new MouseDriver interface and added stub internal implementations. --- Source/OpenTK/Input/IMouseDriver.cs | 13 +++++++++++ Source/OpenTK/Input/InputDriver.cs | 14 ++++++++++-- Source/OpenTK/Input/Mouse.cs | 22 ++++++++++--------- Source/OpenTK/Platform/Factory.cs | 10 +++++++++ Source/OpenTK/Platform/IPlatformFactory.cs | 2 ++ Source/OpenTK/Platform/MacOS/CarbonInput.cs | 10 +++++++++ Source/OpenTK/Platform/MacOS/MacOSFactory.cs | 7 +++++- Source/OpenTK/Platform/Windows/WMInput.cs | 10 +++++++++ Source/OpenTK/Platform/Windows/WinFactory.cs | 5 +++++ Source/OpenTK/Platform/Windows/WinGLNative.cs | 10 +++++++++ Source/OpenTK/Platform/Windows/WinRawInput.cs | 10 +++++++++ Source/OpenTK/Platform/Windows/WinRawMouse.cs | 10 +++++++++ Source/OpenTK/Platform/X11/X11Factory.cs | 6 +++++ Source/OpenTK/Platform/X11/X11Input.cs | 10 +++++++++ 14 files changed, 126 insertions(+), 13 deletions(-) diff --git a/Source/OpenTK/Input/IMouseDriver.cs b/Source/OpenTK/Input/IMouseDriver.cs index 52abe7af..9e60a5db 100644 --- a/Source/OpenTK/Input/IMouseDriver.cs +++ b/Source/OpenTK/Input/IMouseDriver.cs @@ -19,5 +19,18 @@ namespace OpenTK.Input /// Gets the list of available MouseDevices. /// IList Mouse { get; } + + /// + /// Retrieves the MouseState for the default keyboard device. + /// + /// A structure containing the state of the mouse device. + MouseState GetState(); + + /// + /// Retrieves the MouseState for the specified keyboard device. + /// + /// The index of the keyboard device. + /// A structure containing the state of the mouse device. + MouseState GetState(int index); } } diff --git a/Source/OpenTK/Input/InputDriver.cs b/Source/OpenTK/Input/InputDriver.cs index 3c3cf5a5..4a137c99 100644 --- a/Source/OpenTK/Input/InputDriver.cs +++ b/Source/OpenTK/Input/InputDriver.cs @@ -75,12 +75,12 @@ namespace OpenTK public KeyboardState GetState() { - return inputDriver.GetState(); + return (inputDriver as IKeyboardDriver).GetState(); } public KeyboardState GetState(int index) { - return inputDriver.GetState(index); + return (inputDriver as IKeyboardDriver).GetState(index); } #endregion @@ -92,6 +92,16 @@ namespace OpenTK get { return inputDriver.Mouse; } } + MouseState IMouseDriver.GetState() + { + throw new NotImplementedException(); + } + + MouseState IMouseDriver.GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region --- IJoystickDriver Members --- diff --git a/Source/OpenTK/Input/Mouse.cs b/Source/OpenTK/Input/Mouse.cs index f94aa3c9..faecb812 100644 --- a/Source/OpenTK/Input/Mouse.cs +++ b/Source/OpenTK/Input/Mouse.cs @@ -38,20 +38,22 @@ namespace OpenTK.Input { #region Fields - //static IMouseDriver driver; - - #endregion - - #region Constructors - - static Mouse() - { - } + static readonly IMouseDriver driver = + Platform.Factory.Default.CreateMouseDriver(); #endregion #region Public Members + /// + /// Retrieves the MouseState for the specified mouse device. + /// + /// A structure containing the state of the mouse device. + public static MouseState GetState() + { + return driver.GetState(); + } + /// /// Retrieves the MouseState for the specified mouse device. /// @@ -59,7 +61,7 @@ namespace OpenTK.Input /// A structure containing the state of the mouse device. public static MouseState GetState(int index) { - throw new NotImplementedException(); + return driver.GetState(index); } #endregion diff --git a/Source/OpenTK/Platform/Factory.cs b/Source/OpenTK/Platform/Factory.cs index 3ac7c3da..b352c714 100644 --- a/Source/OpenTK/Platform/Factory.cs +++ b/Source/OpenTK/Platform/Factory.cs @@ -119,6 +119,11 @@ namespace OpenTK.Platform return default_implementation.CreateKeyboardDriver(); } + public OpenTK.Input.IMouseDriver CreateMouseDriver() + { + return default_implementation.CreateMouseDriver(); + } + class UnsupportedPlatform : IPlatformFactory { #region Fields @@ -168,6 +173,11 @@ namespace OpenTK.Platform { throw new PlatformNotSupportedException(error_string); } + + public OpenTK.Input.IMouseDriver CreateMouseDriver() + { + throw new PlatformNotSupportedException(error_string); + } #endregion } diff --git a/Source/OpenTK/Platform/IPlatformFactory.cs b/Source/OpenTK/Platform/IPlatformFactory.cs index 8bd81b5a..caae6db1 100644 --- a/Source/OpenTK/Platform/IPlatformFactory.cs +++ b/Source/OpenTK/Platform/IPlatformFactory.cs @@ -48,5 +48,7 @@ namespace OpenTK.Platform IGraphicsMode CreateGraphicsMode(); OpenTK.Input.IKeyboardDriver CreateKeyboardDriver(); + + OpenTK.Input.IMouseDriver CreateMouseDriver(); } } diff --git a/Source/OpenTK/Platform/MacOS/CarbonInput.cs b/Source/OpenTK/Platform/MacOS/CarbonInput.cs index c9c3b997..5355a443 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonInput.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonInput.cs @@ -54,6 +54,16 @@ namespace OpenTK.Platform.MacOS get { return dummy_mice_list; } } + MouseState IMouseDriver.GetState() + { + throw new NotImplementedException(); + } + + MouseState IMouseDriver.GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region IJoystickDriver Members diff --git a/Source/OpenTK/Platform/MacOS/MacOSFactory.cs b/Source/OpenTK/Platform/MacOS/MacOSFactory.cs index 00282dd1..25619903 100644 --- a/Source/OpenTK/Platform/MacOS/MacOSFactory.cs +++ b/Source/OpenTK/Platform/MacOS/MacOSFactory.cs @@ -74,7 +74,12 @@ namespace OpenTK.Platform.MacOS { throw new NotImplementedException(); } - + + public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() + { + throw new NotImplementedException(); + } + #endregion } } diff --git a/Source/OpenTK/Platform/Windows/WMInput.cs b/Source/OpenTK/Platform/Windows/WMInput.cs index d62b9af6..90399ebc 100644 --- a/Source/OpenTK/Platform/Windows/WMInput.cs +++ b/Source/OpenTK/Platform/Windows/WMInput.cs @@ -265,6 +265,16 @@ namespace OpenTK.Platform.Windows get { return mice; } } + MouseState IMouseDriver.GetState() + { + throw new NotImplementedException(); + } + + MouseState IMouseDriver.GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region IJoystickDriver Members diff --git a/Source/OpenTK/Platform/Windows/WinFactory.cs b/Source/OpenTK/Platform/Windows/WinFactory.cs index 461e5be2..30b25b74 100644 --- a/Source/OpenTK/Platform/Windows/WinFactory.cs +++ b/Source/OpenTK/Platform/Windows/WinFactory.cs @@ -80,6 +80,11 @@ namespace OpenTK.Platform.Windows else return new WMInput(null); } + + public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() + { + throw new NotImplementedException(); + } #endregion } diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index cffe637b..50c1c12e 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -1205,6 +1205,16 @@ namespace OpenTK.Platform.Windows get { return mice; } } + MouseState IMouseDriver.GetState() + { + throw new NotImplementedException(); + } + + MouseState IMouseDriver.GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region IJoystickDriver Members diff --git a/Source/OpenTK/Platform/Windows/WinRawInput.cs b/Source/OpenTK/Platform/Windows/WinRawInput.cs index 3c3ad291..3cd04ec6 100644 --- a/Source/OpenTK/Platform/Windows/WinRawInput.cs +++ b/Source/OpenTK/Platform/Windows/WinRawInput.cs @@ -226,6 +226,16 @@ namespace OpenTK.Platform.Windows get { return mouseDriver.Mouse; } } + MouseState IMouseDriver.GetState() + { + throw new NotImplementedException(); + } + + MouseState IMouseDriver.GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region IJoystickDriver Members diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index cfaf2c78..46ab54f4 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -52,6 +52,16 @@ namespace OpenTK.Platform.Windows get { return mice; } } + public MouseState GetState() + { + throw new NotImplementedException(); + } + + public MouseState GetState(int index) + { + throw new NotImplementedException(); + } + #region public int RegisterDevices() public int RegisterDevices() diff --git a/Source/OpenTK/Platform/X11/X11Factory.cs b/Source/OpenTK/Platform/X11/X11Factory.cs index 16dbaafe..fd9cb473 100644 --- a/Source/OpenTK/Platform/X11/X11Factory.cs +++ b/Source/OpenTK/Platform/X11/X11Factory.cs @@ -83,6 +83,12 @@ namespace OpenTK.Platform.X11 return new X11Keyboard(null); } + public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() + { + //return new X11Mouse(null); + throw new NotImplementedException(); + } + #endregion } } diff --git a/Source/OpenTK/Platform/X11/X11Input.cs b/Source/OpenTK/Platform/X11/X11Input.cs index b34e0601..3d77cd99 100644 --- a/Source/OpenTK/Platform/X11/X11Input.cs +++ b/Source/OpenTK/Platform/X11/X11Input.cs @@ -238,6 +238,16 @@ namespace OpenTK.Platform.X11 get { return (IList)dummy_mice_list; } //return mouseDriver.Mouse; } + MouseState IMouseDriver.GetState() + { + throw new NotImplementedException(); + } + + MouseState IMouseDriver.GetState(int index) + { + throw new NotImplementedException(); + } + #endregion #region public IList Joysticks From ca30b85badc3d2b87dc6c814ade211ff0ee5e89b Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 20 Oct 2010 15:14:26 +0000 Subject: [PATCH 013/130] * Input/KeyboardState.cs: Fixed the amount of storage for keyboard keys (the code would allocate one less int than necessary when "number of keys % 32" falls between 1 and 15). Fixed the implementation of the Equals method to compare the two instances (instead of comparing this instance against itself). --- Source/OpenTK/Input/KeyboardState.cs | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/Source/OpenTK/Input/KeyboardState.cs b/Source/OpenTK/Input/KeyboardState.cs index 9d05a32a..955ef547 100644 --- a/Source/OpenTK/Input/KeyboardState.cs +++ b/Source/OpenTK/Input/KeyboardState.cs @@ -38,13 +38,10 @@ namespace OpenTK.Input { #region Fields - const int NumKeys = ((int)Key.LastKey + 16) / 32; + // Allocate enough ints to store all keyboard keys + const int NumInts = ((int)Key.LastKey + 31) / 32; // The following line triggers bogus CS0214 in gmcs 2.0.1, sigh... - unsafe fixed int Keys[NumKeys]; - - #endregion - - #region Constructors + unsafe fixed int Keys[NumInts]; #endregion @@ -126,9 +123,9 @@ namespace OpenTK.Input unsafe { fixed (int* k1 = Keys) - fixed (int* k2 = Keys) + fixed (int* k2 = other.Keys) { - for (int i = 0; equal && i < NumKeys; i++) + for (int i = 0; equal && i < NumInts; i++) equal &= *(k1 + i) == *(k2 + i); } } From 362a8536645e05768fc031b0ba9eebc6e920c90a Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 20 Oct 2010 15:14:38 +0000 Subject: [PATCH 014/130] * Input/MouseState.cs: Implemented MouseState structure. --- Source/OpenTK/Input/MouseState.cs | 86 +++++++++++++++++++++++++++++-- 1 file changed, 81 insertions(+), 5 deletions(-) diff --git a/Source/OpenTK/Input/MouseState.cs b/Source/OpenTK/Input/MouseState.cs index feab5a18..77d044fb 100644 --- a/Source/OpenTK/Input/MouseState.cs +++ b/Source/OpenTK/Input/MouseState.cs @@ -36,10 +36,76 @@ namespace OpenTK.Input /// public struct MouseState : IEquatable { - #region Constructors + #region Fields - internal MouseState(MouseButton[] buttons) + // Allocate enough ints to store all mouse buttons + const int NumInts = ((int)MouseButton.LastButton + 31) / 32; + // The following line triggers bogus CS0214 in gmcs 2.0.1, sigh... + unsafe fixed int Buttons[NumInts]; + + #endregion + + #region Public Members + + /// + /// Gets a indicating whether this button is down. + /// + /// The to check. + public bool IsKeyDown(MouseButton button) { + return ReadBit((int)button); + } + + /// + /// Gets a indicating whether this button is up. + /// + /// The to check. + public bool IsKeyUp(MouseButton button) + { + return !ReadBit((int)button); + } + + #endregion + + #region Internal Members + + internal bool ReadBit(int offset) + { + int int_offset = offset / 32; + int bit_offset = offset % 32; + unsafe + { + fixed (int* b = Buttons) + { + return (*(b + int_offset) & (1 << bit_offset)) != 0u; + } + } + } + + internal void EnableBit(int offset) + { + int int_offset = offset / 32; + int bit_offset = offset % 32; + unsafe + { + fixed (int* b = Buttons) + { + *(b + int_offset) |= 1 << bit_offset; + } + } + } + + internal void DisableBit(int offset) + { + int int_offset = offset / 32; + int bit_offset = offset % 32; + unsafe + { + fixed (int* b = Buttons) + { + *(b + int_offset) &= ~(1 << bit_offset); + } + } } #endregion @@ -47,13 +113,23 @@ namespace OpenTK.Input #region IEquatable Members /// - /// Compares two MouseState instances for equality. + /// Compares two MouseState instances. /// - /// The instance to compare to. + /// The instance to compare two. /// True, if both instances are equal; false otherwise. public bool Equals(MouseState other) { - throw new NotImplementedException(); + bool equal = true; + unsafe + { + fixed (int* b1 = Buttons) + fixed (int* b2 = other.Buttons) + { + for (int i = 0; equal && i < NumInts; i++) + equal &= *(b1 + i) == *(b2 + i); + } + } + return equal; } #endregion From 3c238a01f6de6f552e6d67913d310960ddf0d014 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 20 Oct 2010 15:16:55 +0000 Subject: [PATCH 015/130] * X11Keyboard.cs: Do not allocate an X11WindowInfo unnecessarily. --- Source/OpenTK/Platform/X11/X11Keyboard.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Source/OpenTK/Platform/X11/X11Keyboard.cs b/Source/OpenTK/Platform/X11/X11Keyboard.cs index 96422b71..8bf6919c 100644 --- a/Source/OpenTK/Platform/X11/X11Keyboard.cs +++ b/Source/OpenTK/Platform/X11/X11Keyboard.cs @@ -35,7 +35,7 @@ namespace OpenTK.Platform.X11 // Only one keyboard supported. sealed class X11Keyboard : IKeyboardDriver { - readonly X11WindowInfo window = new X11WindowInfo(); + readonly X11WindowInfo window; readonly X11KeyMap keymap = new X11KeyMap(); KeyboardState state = new KeyboardState(); @@ -50,6 +50,7 @@ namespace OpenTK.Platform.X11 { using (new XLock(API.DefaultDisplay)) { + window = new X11WindowInfo(); window.Display = API.DefaultDisplay; window.Screen = Functions.XDefaultScreen(window.Display); window.RootWindow = Functions.XRootWindow(window.Display, window.Screen); From 1a8f589f5cb0d47345934ba587bac0579825eb83 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 21 Oct 2010 07:56:37 +0000 Subject: [PATCH 016/130] * OpenTK.csproj: * Input/MouseState.cs: * Input/ButtonState.cs: * Platform/X11/X11Mouse.cs: * Platform/X11/X11Factory.cs: Added initial implementation of OpenTK.Input.Mouse for X11. --- Source/OpenTK/Input/ButtonState.cs | 46 ++++++ Source/OpenTK/Input/MouseState.cs | 147 ++++++++++++++++++- Source/OpenTK/OpenTK.csproj | 5 + Source/OpenTK/Platform/X11/X11Factory.cs | 3 +- Source/OpenTK/Platform/X11/X11Mouse.cs | 173 +++++++++++++++++++++++ 5 files changed, 370 insertions(+), 4 deletions(-) create mode 100644 Source/OpenTK/Input/ButtonState.cs create mode 100644 Source/OpenTK/Platform/X11/X11Mouse.cs diff --git a/Source/OpenTK/Input/ButtonState.cs b/Source/OpenTK/Input/ButtonState.cs new file mode 100644 index 00000000..597611f8 --- /dev/null +++ b/Source/OpenTK/Input/ButtonState.cs @@ -0,0 +1,46 @@ + #region License + // + // The Open Toolkit Library License + // + // Copyright (c) 2006 - 2010 the Open Toolkit library. + // + // Permission is hereby granted, free of charge, to any person obtaining a copy + // of this software and associated documentation files (the "Software"), to deal + // in the Software without restriction, including without limitation the rights to + // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + // the Software, and to permit persons to whom the Software is furnished to do + // so, subject to the following conditions: + // + // The above copyright notice and this permission notice shall be included in all + // copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + // OTHER DEALINGS IN THE SOFTWARE. + // + #endregion + +namespace OpenTK.Input +{ + /// + /// Enumerates possible mouse button states. + /// + public enum ButtonState + { + /// + /// Indicates that a mouse button is released. + /// + Released = 0, + + /// + /// Indicates that a mouse button is pressed. + /// + Pressed = 1 + } +} + diff --git a/Source/OpenTK/Input/MouseState.cs b/Source/OpenTK/Input/MouseState.cs index 77d044fb..feae30d5 100644 --- a/Source/OpenTK/Input/MouseState.cs +++ b/Source/OpenTK/Input/MouseState.cs @@ -42,6 +42,8 @@ namespace OpenTK.Input const int NumInts = ((int)MouseButton.LastButton + 31) / 32; // The following line triggers bogus CS0214 in gmcs 2.0.1, sigh... unsafe fixed int Buttons[NumInts]; + int x, y; + float wheel; #endregion @@ -51,7 +53,7 @@ namespace OpenTK.Input /// Gets a indicating whether this button is down. /// /// The to check. - public bool IsKeyDown(MouseButton button) + public bool IsButtonDown(MouseButton button) { return ReadBit((int)button); } @@ -60,11 +62,151 @@ namespace OpenTK.Input /// Gets a indicating whether this button is up. /// /// The to check. - public bool IsKeyUp(MouseButton button) + public bool IsButtonUp(MouseButton button) { return !ReadBit((int)button); } + /// + /// Gets the absolute wheel position in integer units. + /// To support high-precision mice, it is recommended to use instead. + /// + public int Wheel + { + get { return (int)Math.Round(wheel, MidpointRounding.AwayFromZero); } + } + + /// + /// Gets the absolute wheel position in floating-point units. + /// + public float WheelPrecise + { + get { return wheel; } + internal set + { + wheel = value; + } + } + + /// + /// Gets an integer representing the absolute x position of the pointer, in window pixel coordinates. + /// + public int X + { + get { return x; } + internal set { x = value; } + } + + /// + /// Gets an integer representing the absolute y position of the pointer, in window pixel coordinates. + /// + public int Y + { + get { return y; } + internal set { y = value; } + } + + /// + /// Gets a System.Boolean indicating the state of the specified MouseButton. + /// + /// The MouseButton to check. + /// True if the MouseButton is pressed, false otherwise. + public bool this[MouseButton button] + { + get + { + return IsButtonDown(button); + } + } + + /// + /// Gets a + public ButtonState LeftButton + { + get { return IsButtonDown(MouseButton.Left) ? ButtonState.Pressed : ButtonState.Released; } + } + + /// + /// Gets a + public ButtonState MiddleButton + { + get { return IsButtonDown(MouseButton.Middle) ? ButtonState.Pressed : ButtonState.Released; } + } + + /// + /// Gets a + public ButtonState RightButton + { + get { return IsButtonDown(MouseButton.Right) ? ButtonState.Pressed : ButtonState.Released; } + } + + /// + /// Gets a + public ButtonState XButton1 + { + get { return IsButtonDown(MouseButton.Button1) ? ButtonState.Pressed : ButtonState.Released; } + } + + /// + /// Gets a + public ButtonState XButton2 + { + get { return IsButtonDown(MouseButton.Button2) ? ButtonState.Pressed : ButtonState.Released; } + } + + /// + /// Gets the absolute wheel position in integer units. This property is intended for XNA compatibility. + /// To support high-precision mice, it is recommended to use instead. + /// + public int ScrollWheelValue + { + get { return Wheel; } + } + + /// + /// Checks whether two instances are equal. + /// + /// + /// A instance. + /// + /// + /// A instance. + /// + /// + /// True if both left is equal to right; false otherwise. + /// + public static bool operator ==(MouseState left, MouseState right) + { + return left.Equals(right); + } + + /// + /// Checks whether two instances are not equal. + /// + /// + /// A instance. + /// + /// + /// A instance. + /// + /// + /// True if both left is not equal to right; false otherwise. + /// + public static bool operator !=(MouseState left, MouseState right) + { + return !left.Equals(right); + } + #endregion #region Internal Members @@ -128,6 +270,7 @@ namespace OpenTK.Input for (int i = 0; equal && i < NumInts; i++) equal &= *(b1 + i) == *(b2 + i); } + equal &= X == other.X && Y == other.Y && WheelPrecise == other.WheelPrecise; } return equal; } diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index 0510e48d..693d87bb 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -76,6 +76,9 @@ ..\..\Binaries\OpenTK\Release\ + none + 4 + true true @@ -757,6 +760,8 @@ Always + + diff --git a/Source/OpenTK/Platform/X11/X11Factory.cs b/Source/OpenTK/Platform/X11/X11Factory.cs index fd9cb473..b1212377 100644 --- a/Source/OpenTK/Platform/X11/X11Factory.cs +++ b/Source/OpenTK/Platform/X11/X11Factory.cs @@ -85,8 +85,7 @@ namespace OpenTK.Platform.X11 public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() { - //return new X11Mouse(null); - throw new NotImplementedException(); + return new X11Mouse(null); } #endregion diff --git a/Source/OpenTK/Platform/X11/X11Mouse.cs b/Source/OpenTK/Platform/X11/X11Mouse.cs new file mode 100644 index 00000000..49c8bedc --- /dev/null +++ b/Source/OpenTK/Platform/X11/X11Mouse.cs @@ -0,0 +1,173 @@ + #region License + // + // The Open Toolkit Library License + // + // Copyright (c) 2006 - 2010 the Open Toolkit library. + // + // Permission is hereby granted, free of charge, to any person obtaining a copy + // of this software and associated documentation files (the "Software"), to deal + // in the Software without restriction, including without limitation the rights to + // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + // the Software, and to permit persons to whom the Software is furnished to do + // so, subject to the following conditions: + // + // The above copyright notice and this permission notice shall be included in all + // copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + // OTHER DEALINGS IN THE SOFTWARE. + // + #endregion + +using System; +using System.Collections.Generic; +using OpenTK.Input; + +namespace OpenTK.Platform.X11 +{ + sealed class X11Mouse : IMouseDriver + { + MouseState mouse = new MouseState(); + X11WindowInfo window; + + // Can either attach itself to the specified window or can hook the root window. + public X11Mouse(X11WindowInfo win) + { + if (win != null) + { + window = win; + } + else + { + using (new XLock(API.DefaultDisplay)) + { + window = new X11WindowInfo(); + window.Display = API.DefaultDisplay; + window.Screen = Functions.XDefaultScreen(window.Display); + window.RootWindow = Functions.XRootWindow(window.Display, window.Screen); + window.WindowHandle = window.RootWindow; + window.EventMask = EventMask.ButtonMotionMask | + EventMask.ButtonPressMask | EventMask.ButtonReleaseMask; + + //Functions.XGrabPointer(window.Display, window.RootWindow, true, + // window.EventMask, GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, IntPtr.Zero, + // IntPtr.Zero, IntPtr.Zero); + //Functions.XSelectInput(window.Display, window.RootWindow, new IntPtr((int)window.EventMask)); + } + } + } + + // Todo: remove this + public IList Mouse { get { throw new NotSupportedException(); } } + + public MouseState GetState() + { + ProcessEvents(); + return mouse; + } + + public MouseState GetState(int index) + { + + // X11Mouse supports a single mouse only + if (index < 0 || index > 1) + throw new ArgumentOutOfRangeException("index"); + + ProcessEvents(); + return mouse; + } + + void WriteBit(MouseButton offset, int enabled) + { + if (enabled != 0) + mouse.EnableBit((int)offset); + else + mouse.DisableBit((int)offset); + } + + void ProcessEvents() + { + IntPtr root, child; + int root_x, root_y, win_x, win_y; + int buttons; + Functions.XQueryPointer(window.Display, window.WindowHandle, out root, out child, + out root_x, out root_y, out win_x, out win_y, out buttons); + mouse.X = root_x; + mouse.Y = root_y; + WriteBit(MouseButton.Left, buttons & (int)MouseMask.Button1Mask); + WriteBit(MouseButton.Middle, buttons & (int)MouseMask.Button2Mask); + WriteBit(MouseButton.Right, buttons & (int)MouseMask.Button3Mask); + if ((buttons & (int)MouseMask.Button4Mask) != 0) + mouse.WheelPrecise++; + if ((buttons & (int)MouseMask.Button5Mask) != 0) + mouse.WheelPrecise--; + WriteBit(MouseButton.Button1, buttons & (int)MouseMask.Button6Mask); + WriteBit(MouseButton.Button2, buttons & (int)MouseMask.Button7Mask); + WriteBit(MouseButton.Button3, buttons & (int)MouseMask.Button8Mask); + +// XEvent e = new XEvent(); +// +// while (true) +// { +// using (new XLock(window.Display)) +// { +// if (!Functions.XCheckWindowEvent(window.Display, window.WindowHandle, window.EventMask, ref e)) +// break; +// +// switch (e.type) +// { +// case XEventName.ButtonPress: +// switch (e.ButtonEvent.button) +// { +// case 1: mouse.EnableBit((int)MouseButton.Left); break; +// case 2: mouse.EnableBit((int)MouseButton.Middle); break; +// case 3: mouse.EnableBit((int)MouseButton.Right); break; +// case 4: mouse.WheelPrecise++; break; +// case 5: mouse.WheelPrecise--; break; +// case 6: mouse.EnableBit((int)MouseButton.Button1); break; +// case 7: mouse.EnableBit((int)MouseButton.Button2); break; +// case 8: mouse.EnableBit((int)MouseButton.Button3); break; +// case 9: mouse.EnableBit((int)MouseButton.Button4); break; +// case 10: mouse.EnableBit((int)MouseButton.Button5); break; +// case 11: mouse.EnableBit((int)MouseButton.Button6); break; +// case 12: mouse.EnableBit((int)MouseButton.Button7); break; +// case 13: mouse.EnableBit((int)MouseButton.Button8); break; +// case 15: mouse.EnableBit((int)MouseButton.Button9); break; +// } +// break; +// +// case XEventName.ButtonRelease: +// switch (e.ButtonEvent.button) +// { +// case 1: mouse.DisableBit((int)MouseButton.Left); break; +// case 2: mouse.DisableBit((int)MouseButton.Middle); break; +// case 3: mouse.DisableBit((int)MouseButton.Right); break; +// case 6: mouse.DisableBit((int)MouseButton.Button1); break; +// case 7: mouse.DisableBit((int)MouseButton.Button2); break; +// case 8: mouse.DisableBit((int)MouseButton.Button3); break; +// case 9: mouse.DisableBit((int)MouseButton.Button4); break; +// case 10: mouse.DisableBit((int)MouseButton.Button5); break; +// case 11: mouse.DisableBit((int)MouseButton.Button6); break; +// case 12: mouse.DisableBit((int)MouseButton.Button7); break; +// case 13: mouse.DisableBit((int)MouseButton.Button8); break; +// case 15: mouse.DisableBit((int)MouseButton.Button9); break; +// } +// break; +// +// case XEventName.MotionNotify: +// mouse.X = e.MotionEvent.x; +// mouse.Y = e.MotionEvent.y; +// break; +// } +// } +// } + } + } +} + From 23ad81d12b5bc5345aa11c044453c0d27821662d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 21 Oct 2010 07:56:48 +0000 Subject: [PATCH 017/130] * Platform/X11/X11Keyboard.cs: Added index bounds check for GetState. --- Source/OpenTK/Platform/X11/X11Keyboard.cs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Source/OpenTK/Platform/X11/X11Keyboard.cs b/Source/OpenTK/Platform/X11/X11Keyboard.cs index 8bf6919c..d346e4fd 100644 --- a/Source/OpenTK/Platform/X11/X11Keyboard.cs +++ b/Source/OpenTK/Platform/X11/X11Keyboard.cs @@ -75,6 +75,10 @@ namespace OpenTK.Platform.X11 public KeyboardState GetState(int index) { + // X11Keyboard supports a single keyboard only + if (index < 0 || index > 1) + throw new ArgumentOutOfRangeException("index"); + ProcessEvents(); return state; } From 80ee257777df05f85e0faa0a80c8e8156ad50022 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 21 Oct 2010 12:32:00 +0000 Subject: [PATCH 018/130] * OpenTK.csproj: * Input/MouseState.cs: * Platform/X11/Structs.cs: * Platform/X11/XI2Mouse.cs: * Platform/X11/Functions.cs: * Platform/X11/X11Factory.cs: Added XInput2 driver for mice. Multi-mouse support pending. * Platform/X11/X11Mouse.cs: Log the driver type for debugging purposes. --- Source/OpenTK/Input/MouseState.cs | 38 +++++ Source/OpenTK/OpenTK.csproj | 1 + Source/OpenTK/Platform/X11/Functions.cs | 34 +++- Source/OpenTK/Platform/X11/Structs.cs | 192 +++++++++++++++++++++++ Source/OpenTK/Platform/X11/X11Factory.cs | 8 + Source/OpenTK/Platform/X11/X11Mouse.cs | 3 + Source/OpenTK/Platform/X11/XI2Mouse.cs | 188 ++++++++++++++++++++++ 7 files changed, 462 insertions(+), 2 deletions(-) create mode 100644 Source/OpenTK/Platform/X11/XI2Mouse.cs diff --git a/Source/OpenTK/Input/MouseState.cs b/Source/OpenTK/Input/MouseState.cs index feae30d5..937833df 100644 --- a/Source/OpenTK/Input/MouseState.cs +++ b/Source/OpenTK/Input/MouseState.cs @@ -207,6 +207,44 @@ namespace OpenTK.Input return !left.Equals(right); } + /// + /// Compares to an object instance for equality. + /// + /// + /// The to compare to. + /// + /// + /// True if this instance is equal to obj; false otherwise. + /// + public override bool Equals(object obj) + { + if (obj is MouseState) + { + return this == (MouseState)obj; + } + else + { + return false; + } + } + + /// + /// Generates a hashcode for the current instance. + /// + /// + /// A represting the hashcode for this instance. + /// + public override int GetHashCode() + { + unsafe + { + fixed (int* b = Buttons) + { + return b->GetHashCode() ^ X.GetHashCode() ^ Y.GetHashCode() ^ WheelPrecise.GetHashCode(); + } + } + } + #endregion #region Internal Members diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index 693d87bb..8719568a 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -762,6 +762,7 @@ + diff --git a/Source/OpenTK/Platform/X11/Functions.cs b/Source/OpenTK/Platform/X11/Functions.cs index 88a53e40..68a93386 100644 --- a/Source/OpenTK/Platform/X11/Functions.cs +++ b/Source/OpenTK/Platform/X11/Functions.cs @@ -94,7 +94,16 @@ namespace OpenTK.Platform.X11 public extern static Bool XCheckWindowEvent(Display display, Window w, EventMask event_mask, ref XEvent event_return); [DllImport("libX11")] public extern static Bool XCheckTypedWindowEvent(Display display, Window w, XEventName event_type, ref XEvent event_return); - + [DllImport("libX11")] + public extern static Bool XCheckTypedEvent(Display display, XEventName event_type, out XEvent event_return); + + + public delegate Bool EventPredicate(IntPtr display, ref XEvent e, IntPtr arg); + [DllImport("libX11")] + public extern static Bool XIfEvent(Display display, ref XEvent e, IntPtr predicate, IntPtr arg ); + [DllImport("libX11")] + public extern static Bool XCheckIfEvent(Display display, ref XEvent e, IntPtr predicate, IntPtr arg ); + [DllImport("libX11")] public extern static int XConnectionNumber(IntPtr diplay); [DllImport("libX11")] @@ -325,7 +334,7 @@ namespace OpenTK.Platform.X11 public extern static int XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height); [DllImport("libX11", EntryPoint = "XQueryExtension")] - public extern static int XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error); + public extern static int XQueryExtension(IntPtr display, string extension_name, out int major, out int first_event, out int first_error); [DllImport("libX11", EntryPoint = "XWhitePixel")] public extern static IntPtr XWhitePixel(IntPtr display, int screen_no); @@ -462,6 +471,27 @@ namespace OpenTK.Platform.X11 [DllImport("libX11")] public static extern int XRefreshKeyboardMapping(ref XMappingEvent event_map); + [DllImport("libX11")] + public static extern int XGetEventData(IntPtr display, ref XGenericEventCookie cookie); + + [DllImport("libX11")] + public static extern void XFreeEventData(IntPtr display, ref XGenericEventCookie cookie); + + [DllImport("libXi")] + static extern int XISelectEvents(IntPtr dpy, Window win, [In] XIEventMask[] masks, int num_masks); + [DllImport("libXi")] + static extern int XISelectEvents(IntPtr dpy, Window win, [In] ref XIEventMask masks, int num_masks); + + public static int XISelectEvents(IntPtr dpy, Window win, XIEventMask[] masks) + { + return XISelectEvents(dpy, win, masks, masks.Length); + } + + public static int XISelectEvents(IntPtr dpy, Window win, XIEventMask mask) + { + return XISelectEvents(dpy, win, ref mask, 1); + } + static readonly IntPtr CopyFromParent = IntPtr.Zero; public static void SendNetWMMessage(X11WindowInfo window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) diff --git a/Source/OpenTK/Platform/X11/Structs.cs b/Source/OpenTK/Platform/X11/Structs.cs index bc7e84a7..180f455d 100644 --- a/Source/OpenTK/Platform/X11/Structs.cs +++ b/Source/OpenTK/Platform/X11/Structs.cs @@ -36,6 +36,10 @@ using System.Runtime.InteropServices; // X11 Version namespace OpenTK.Platform.X11 { + using Bool = System.Boolean; + using Time = System.IntPtr; + using Window = System.IntPtr; + // // In the structures below, fields of type long are mapped to IntPtr. // This will work on all platforms where sizeof(long)==sizeof(void*), which @@ -545,6 +549,29 @@ namespace OpenTK.Platform.X11 public IntPtr pad23; } + [StructLayout(LayoutKind.Sequential)] + internal struct XGenericEvent + { + public int type; // of event. Always GenericEvent + public IntPtr serial; // # of last request processed + public bool send_event; // true if from SendEvent request + public IntPtr display; // Display the event was read from + public int extension; // major opcode of extension that caused the event + public int evtype; // actual event type. + } + + internal struct XGenericEventCookie + { + public int type; // of event. Always GenericEvent + public IntPtr serial; // # of last request processed + public bool send_event; // true if from SendEvent request + public IntPtr display; // Display the event was read from + public int extension; // major opcode of extension that caused the event + public int evtype; // actual event type. + public uint cookie; // unique event cookie + public IntPtr data; // actual event data + } + [StructLayout(LayoutKind.Explicit)] internal struct XEvent { @@ -612,6 +639,10 @@ namespace OpenTK.Platform.X11 public XErrorEvent ErrorEvent; [FieldOffset(0)] public XKeymapEvent KeymapEvent; + [FieldOffset(0)] + public XGenericEvent GenericEvent; + [FieldOffset(0)] + public XGenericEventCookie GenericEventCookie; //[MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=24)] //[ FieldOffset(0) ] public int[] pad; @@ -753,6 +784,7 @@ namespace OpenTK.Platform.X11 ColormapNotify = 32, ClientMessage = 33, MappingNotify = 34, + GenericEvent = 35, LASTEvent } @@ -1623,4 +1655,164 @@ namespace OpenTK.Platform.X11 XYPixmap = 1, ZPixmap } + + // XInput2 structures + + struct XIDeviceInfo + { + public int deviceid; + public IntPtr name; // byte* + public int use; + public int attachment; + public Bool enabled; + public int num_classes; + public IntPtr classes; // XIAnyClassInfo ** + } + + struct XIAnyClassInfo + { + public int type; + public int sourceid; + } + + struct XIDeviceEvent + { + public int type; /* GenericEvent */ + public IntPtr serial; /* # of last request processed by server */ + public bool send_event; /* true if this came from a SendEvent request */ + public IntPtr display; /* Display the event was read from */ + public int extension; /* XI extension offset */ + public XIEventType evtype; + public Time time; + public int deviceid; + public int sourceid; + public int detail; + public Window root; + public Window @event; + public Window child; + public double root_x; + public double root_y; + public double event_x; + public double event_y; + public int flags; + public XIButtonState buttons; + public XIValuatorState valuators; + public XIModifierState mods; + public XIGroupState @group; + } + + struct XIRawEvent + { + public int type; /* GenericEvent */ + public IntPtr serial; /* # of last request processed by server */ + public Bool send_event; /* true if this came from a SendEvent request */ + public IntPtr display; /* Display the event was read from */ + public int extension; /* XI extension offset */ + public XIEventType evtype; /* XI_RawKeyPress, XI_RawKeyRelease, etc. */ + public Time time; + public int deviceid; + public int sourceid; + public int detail; + public int flags; + public XIValuatorState valuators; + public IntPtr raw_values; // double * + } + + struct XIButtonState + { + public int mask_len; + public IntPtr mask; // byte* + } + + struct XIModifierState + { + public int @base; + public int latched; + public int locked; + public int effective; + } + + struct XIGroupState + { + public int @base; + public int latched; + public int locked; + public int effective; + } + + struct XIValuatorState + { + public int mask_len; + public IntPtr mask; // byte* + public IntPtr values; // double* + } + + struct XIEventMask : IDisposable + { + public int deviceid; // 0 = XIAllDevices, 1 = XIAllMasterDevices + int mask_len; + unsafe XIEventMasks* mask; + + public XIEventMask(int id, XIEventMasks m) + { + deviceid = id; + mask_len = sizeof(XIEventMasks); + unsafe + { + mask = (XIEventMasks*)Marshal.AllocHGlobal(mask_len); + *mask = m; + } + } + + public void Dispose() + { + unsafe + { + Marshal.FreeHGlobal(new IntPtr((void*)mask)); + } + } + } + + enum XIEventType + { + DeviceChanged = 1, + KeyPress, + KeyRelease, + ButtonPress, + ButtonRelease, + Motion, + Enter, + Leave, + FocusIn, + FocusOut, + HierarchyChanged, + PropertyEvent, + RawKeyPress, + RawKeyRelease, + RawButtonPress, + RawButtonRelease, + RawMotion, + LastEvent = RawMotion + } + + enum XIEventMasks + { + DeviceChangedMask = (1 << (int)XIEventType.DeviceChanged), + KeyPressMask = (1 << (int)XIEventType.KeyPress), + KeyReleaseMask = (1 << (int)XIEventType.KeyRelease), + ButtonPressMask = (1 << (int)XIEventType.ButtonPress), + ButtonReleaseMask = (1 << (int)XIEventType.ButtonRelease), + MotionMask = (1 << (int)XIEventType.Motion), + EnterMask = (1 << (int)XIEventType.Enter), + LeaveMask = (1 << (int)XIEventType.Leave), + FocusInMask = (1 << (int)XIEventType.FocusIn), + FocusOutMask = (1 << (int)XIEventType.FocusOut), + HierarchyChangedMask = (1 << (int)XIEventType.HierarchyChanged), + PropertyEventMask = (1 << (int)XIEventType.PropertyEvent), + RawKeyPressMask = (1 << (int)XIEventType.RawKeyPress), + RawKeyReleaseMask = (1 << (int)XIEventType.RawKeyRelease), + RawButtonPressMask = (1 << (int)XIEventType.RawButtonPress), + RawButtonReleaseMask = (1 << (int)XIEventType.RawButtonRelease), + RawMotionMask = (1 << (int)XIEventType.RawMotion), + } } diff --git a/Source/OpenTK/Platform/X11/X11Factory.cs b/Source/OpenTK/Platform/X11/X11Factory.cs index b1212377..96dd6162 100644 --- a/Source/OpenTK/Platform/X11/X11Factory.cs +++ b/Source/OpenTK/Platform/X11/X11Factory.cs @@ -85,6 +85,14 @@ namespace OpenTK.Platform.X11 public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() { + try + { + // Only supported on xorg 1.7 or higher. + return new XI2Mouse(null); + } + catch (NotSupportedException) { } + + // Should always be supported. return new X11Mouse(null); } diff --git a/Source/OpenTK/Platform/X11/X11Mouse.cs b/Source/OpenTK/Platform/X11/X11Mouse.cs index 49c8bedc..4b636a99 100644 --- a/Source/OpenTK/Platform/X11/X11Mouse.cs +++ b/Source/OpenTK/Platform/X11/X11Mouse.cs @@ -27,6 +27,7 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using OpenTK.Input; namespace OpenTK.Platform.X11 @@ -60,6 +61,8 @@ namespace OpenTK.Platform.X11 // IntPtr.Zero, IntPtr.Zero); //Functions.XSelectInput(window.Display, window.RootWindow, new IntPtr((int)window.EventMask)); } + + Debug.WriteLine("Using X11Mouse."); } } diff --git a/Source/OpenTK/Platform/X11/XI2Mouse.cs b/Source/OpenTK/Platform/X11/XI2Mouse.cs new file mode 100644 index 00000000..0451aa27 --- /dev/null +++ b/Source/OpenTK/Platform/X11/XI2Mouse.cs @@ -0,0 +1,188 @@ + #region License + // + // The Open Toolkit Library License + // + // Copyright (c) 2006 - 2010 the Open Toolkit library. + // + // Permission is hereby granted, free of charge, to any person obtaining a copy + // of this software and associated documentation files (the "Software"), to deal + // in the Software without restriction, including without limitation the rights to + // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + // the Software, and to permit persons to whom the Software is furnished to do + // so, subject to the following conditions: + // + // The above copyright notice and this permission notice shall be included in all + // copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + // OTHER DEALINGS IN THE SOFTWARE. + // + #endregion + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Runtime.InteropServices; +using OpenTK.Input; + +namespace OpenTK.Platform.X11 +{ + // Todo: multi-mouse support. Right now we aggregate all data into a single mouse device. + // This should be easy: just read the device id and route the data to the correct device. + sealed class XI2Mouse : IMouseDriver + { + MouseState state = new MouseState(); + X11WindowInfo window; + readonly int XIOpCode; + + static readonly Functions.EventPredicate PredicateImpl = IsEventValid; + readonly IntPtr Predicate = Marshal.GetFunctionPointerForDelegate(PredicateImpl); + + // Can either attach itself to the specified window or can hook the root window. + public XI2Mouse(X11WindowInfo win) + { + if (win != null) + { + window = win; + } + else + { + using (new XLock(API.DefaultDisplay)) + { + window = new X11WindowInfo(); + window.Display = API.DefaultDisplay; + window.Screen = Functions.XDefaultScreen(window.Display); + window.RootWindow = Functions.XRootWindow(window.Display, window.Screen); + window.WindowHandle = window.RootWindow; + } + } + + using (new XLock(window.Display)) + { + int major, ev, error; + if (Functions.XQueryExtension(window.Display, "XInputExtension", out major, out ev, out error) == 0) + { + Debug.WriteLine("XInput2 not supported."); + throw new NotSupportedException(); + } + XIOpCode = major; + + using (XIEventMask mask = new XIEventMask(1, XIEventMasks.RawButtonPressMask | + XIEventMasks.RawButtonReleaseMask | XIEventMasks.RawMotionMask)) + { + Functions.XISelectEvents(window.Display, window.WindowHandle, mask); + } + } + Debug.WriteLine("Using XI2Mouse."); + } + + // Todo: remove this + public IList Mouse { get { throw new NotSupportedException(); } } + + public MouseState GetState() + { + ProcessEvents(); + return state; + } + + public MouseState GetState(int index) + { + ProcessEvents(); + return state; + } + + void ProcessEvents() + { + while (true) + { + XEvent e = new XEvent(); + XGenericEventCookie cookie; + + using (new XLock(window.Display)) + { + if (!Functions.XCheckIfEvent(window.Display, ref e, Predicate, new IntPtr(XIOpCode))) + return; + + cookie = e.GenericEventCookie; + if (Functions.XGetEventData(window.Display, ref cookie) != 0) + { + XIRawEvent raw = (XIRawEvent) + Marshal.PtrToStructure(cookie.data, typeof(XIRawEvent)); + + switch (raw.evtype) + { + case XIEventType.RawMotion: + if (IsBitSet(raw.valuators.mask, 0)) + state.X += (int)BitConverter.Int64BitsToDouble(Marshal.ReadInt64(raw.raw_values, 0)); + if (IsBitSet(raw.valuators.mask, 1)) + state.Y += (int)BitConverter.Int64BitsToDouble(Marshal.ReadInt64(raw.raw_values, 8)); + break; + + case XIEventType.RawButtonPress: + switch (raw.detail) + { + case 1: state.EnableBit((int)MouseButton.Left); break; + case 2: state.EnableBit((int)MouseButton.Middle); break; + case 3: state.EnableBit((int)MouseButton.Right); break; + case 4: state.WheelPrecise++; break; + case 5: state.WheelPrecise--; break; + case 6: state.EnableBit((int)MouseButton.Button1); break; + case 7: state.EnableBit((int)MouseButton.Button2); break; + case 8: state.EnableBit((int)MouseButton.Button3); break; + case 9: state.EnableBit((int)MouseButton.Button4); break; + case 10: state.EnableBit((int)MouseButton.Button5); break; + case 11: state.EnableBit((int)MouseButton.Button6); break; + case 12: state.EnableBit((int)MouseButton.Button7); break; + case 13: state.EnableBit((int)MouseButton.Button8); break; + case 14: state.EnableBit((int)MouseButton.Button9); break; + } + break; + + case XIEventType.RawButtonRelease: + switch (raw.detail) + { + case 1: state.DisableBit((int)MouseButton.Left); break; + case 2: state.DisableBit((int)MouseButton.Middle); break; + case 3: state.DisableBit((int)MouseButton.Right); break; + case 6: state.DisableBit((int)MouseButton.Button1); break; + case 7: state.DisableBit((int)MouseButton.Button2); break; + case 8: state.DisableBit((int)MouseButton.Button3); break; + case 9: state.DisableBit((int)MouseButton.Button4); break; + case 10: state.DisableBit((int)MouseButton.Button5); break; + case 11: state.DisableBit((int)MouseButton.Button6); break; + case 12: state.DisableBit((int)MouseButton.Button7); break; + case 13: state.DisableBit((int)MouseButton.Button8); break; + case 14: state.DisableBit((int)MouseButton.Button9); break; + } + break; + } + } + Functions.XFreeEventData(window.Display, ref cookie); + } + } + } + + static bool IsEventValid(IntPtr display, ref XEvent e, IntPtr arg) + { + return e.GenericEventCookie.extension == arg.ToInt32() && + (e.GenericEventCookie.evtype == (int)XIEventType.RawMotion || + e.GenericEventCookie.evtype == (int)XIEventType.RawButtonPress || + e.GenericEventCookie.evtype == (int)XIEventType.RawButtonRelease); + } + + static bool IsBitSet(IntPtr mask, int bit) + { + unsafe + { + return (*((byte*)mask + (bit >> 3)) & (1 << (bit & 7))) != 0; + } + } + } +} + From da0e4f3887f2fedf0abb59ee13f939bd69ec5fca Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 21 Oct 2010 12:55:45 +0000 Subject: [PATCH 019/130] * QuickStart.sln: * Source/QuickStart/QuickStart.csproj: Added missing QuickStart solution. Fixes issue [#2093]: "QuickStart.sln doesn't exist in "latest version of OpenTK"". --- QuickStart.sln | 20 ++++++++++++ Source/QuickStart/QuickStart.csproj | 49 +++++++++++++++++++++++++++++ 2 files changed, 69 insertions(+) create mode 100644 QuickStart.sln create mode 100644 Source/QuickStart/QuickStart.csproj diff --git a/QuickStart.sln b/QuickStart.sln new file mode 100644 index 00000000..510dc6f4 --- /dev/null +++ b/QuickStart.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual Studio 2005 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QuickStart", "Source\QuickStart\QuickStart.csproj", "{90762BBE-CB23-42FF-9D3E-486D2F6CA485}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|AnyCPU = Debug|AnyCPU + Release|AnyCPU = Release|AnyCPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {90762BBE-CB23-42FF-9D3E-486D2F6CA485}.Debug|AnyCPU.ActiveCfg = Debug|Any CPU + {90762BBE-CB23-42FF-9D3E-486D2F6CA485}.Debug|AnyCPU.Build.0 = Debug|Any CPU + {90762BBE-CB23-42FF-9D3E-486D2F6CA485}.Release|AnyCPU.ActiveCfg = Release|Any CPU + {90762BBE-CB23-42FF-9D3E-486D2F6CA485}.Release|AnyCPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(MonoDevelopProperties) = preSolution + StartupItem = Source\QuickStart\QuickStart.csproj + EndGlobalSection +EndGlobal diff --git a/Source/QuickStart/QuickStart.csproj b/Source/QuickStart/QuickStart.csproj new file mode 100644 index 00000000..969a8d79 --- /dev/null +++ b/Source/QuickStart/QuickStart.csproj @@ -0,0 +1,49 @@ + + + + Debug + AnyCPU + 9.0.21022 + 2.0 + {90762BBE-CB23-42FF-9D3E-486D2F6CA485} + Exe + QuickStart + QuickStart + + + true + full + false + bin\Debug + DEBUG + prompt + 4 + AnyCPU + false + + + none + false + bin\Release + prompt + 4 + AnyCPU + false + + + + + + + + False + ..\..\Binaries\OpenTK\Release\OpenTK.dll + + + + + OpenTK.dll.config + PreserveNewest + + + \ No newline at end of file From 4d66cf307083ed9fdf683e3f06d1fd7869357a46 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 21 Oct 2010 13:14:36 +0000 Subject: [PATCH 020/130] * Test/GameWindowStates.cs: Added relative mouse motion indicator. Improved text antialiasing. Moved to GameWindow category. --- .../Examples/OpenTK/Test/GameWindowStates.cs | 23 +++++++++++-------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/Source/Examples/OpenTK/Test/GameWindowStates.cs b/Source/Examples/OpenTK/Test/GameWindowStates.cs index b2e33b2b..d29474f4 100644 --- a/Source/Examples/OpenTK/Test/GameWindowStates.cs +++ b/Source/Examples/OpenTK/Test/GameWindowStates.cs @@ -14,16 +14,16 @@ using OpenTK.Input; namespace Examples.Tests { - [Example("GameWindow states", ExampleCategory.OpenTK, "Test", Documentation = "GameWindowStates")] + [Example("GameWindow States", ExampleCategory.OpenTK, "GameWindow", 4, Documentation = "GameWindowStates")] public class GameWindowStates : GameWindow { - static readonly Font TextFont = new Font(FontFamily.GenericSansSerif, 12); + static readonly Font TextFont = new Font(FontFamily.GenericSansSerif, 11); Bitmap TextBitmap = new Bitmap(512, 512); int texture; bool mouse_in_window = false; bool viewport_changed = true; bool refresh_text = true; - bool move_window = false; + MouseState mouse, mouse_old; public GameWindowStates() : base(800, 600) @@ -80,11 +80,6 @@ namespace Examples.Tests void MouseMoveHandler(object sender, MouseMoveEventArgs e) { refresh_text = true; - - if (move_window) - { - Location = new Point(X + e.XDelta, Y + e.YDelta); - } } void MouseButtonHandler(object sender, MouseButtonEventArgs e) @@ -109,6 +104,11 @@ namespace Examples.Tests protected override void OnUpdateFrame(FrameEventArgs e) { + mouse = OpenTK.Input.Mouse.GetState(); + if (mouse != mouse_old) + refresh_text = true; + mouse_old = mouse; + if (refresh_text) { refresh_text = false; @@ -118,14 +118,15 @@ namespace Examples.Tests int line = 0; gfx.Clear(Color.MidnightBlue); - gfx.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit; + gfx.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit; DrawString(gfx, String.Format("[1 - 4]: change WindowState (current: {0}).", this.WindowState), line++); DrawString(gfx, String.Format("[5 - 7]: change WindowBorder (current: {0}).", this.WindowBorder), line++); DrawString(gfx, String.Format("Focused: {0}.", this.Focused), line++); DrawString(gfx, String.Format("Mouse {0} window.", mouse_in_window ? "inside" : "outside of"), line++); - DrawString(gfx, String.Format("Mouse position: {0}", new Vector3(Mouse.X, Mouse.Y, Mouse.Wheel)), line++); DrawString(gfx, String.Format("Mouse visible: {0}", CursorVisible), line++); + DrawString(gfx, String.Format("Mouse position (absolute): {0}", new Vector3(Mouse.X, Mouse.Y, Mouse.Wheel)), line++); + DrawString(gfx, String.Format("Mouse position (relative): {0}", new Vector3(mouse.X, mouse.Y, mouse.WheelPrecise)), line++); DrawString(gfx, String.Format("Window.Bounds: {0}", Bounds), line++); DrawString(gfx, String.Format("Window.Location: {0}, Size: {1}", Location, Size), line++); DrawString(gfx, String.Format("Window.{{X={0}, Y={1}, Width={2}, Height={3}}}", X, Y, Width, Height), line++); @@ -149,6 +150,8 @@ namespace Examples.Tests GL.ClearColor(Color.MidnightBlue); GL.Enable(EnableCap.Texture2D); + GL.Enable(EnableCap.Blend); + GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.OneMinusSrcAlpha); texture = GL.GenTexture(); GL.BindTexture(TextureTarget.Texture2D, texture); From eeefbd1a9c5f53198e791ee3668cf5613bf77077 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 21 Oct 2010 14:53:10 +0000 Subject: [PATCH 021/130] * Input/Mouse.cs: * Platform/X11/X11Mouse.cs: * Platform/X11/XI2Mouse.cs: Added internal list of mouse devices in preparation for multi-mouse support. --- Source/OpenTK/Input/Mouse.cs | 2 ++ Source/OpenTK/Platform/X11/X11Mouse.cs | 11 +++++------ Source/OpenTK/Platform/X11/XI2Mouse.cs | 26 +++++++++++++++++++++----- 3 files changed, 28 insertions(+), 11 deletions(-) diff --git a/Source/OpenTK/Input/Mouse.cs b/Source/OpenTK/Input/Mouse.cs index faecb812..e8239e97 100644 --- a/Source/OpenTK/Input/Mouse.cs +++ b/Source/OpenTK/Input/Mouse.cs @@ -61,6 +61,8 @@ namespace OpenTK.Input /// A structure containing the state of the mouse device. public static MouseState GetState(int index) { + if (index < 0) + throw new ArgumentOutOfRangeException("index"); return driver.GetState(index); } diff --git a/Source/OpenTK/Platform/X11/X11Mouse.cs b/Source/OpenTK/Platform/X11/X11Mouse.cs index 4b636a99..5a57364b 100644 --- a/Source/OpenTK/Platform/X11/X11Mouse.cs +++ b/Source/OpenTK/Platform/X11/X11Mouse.cs @@ -77,13 +77,12 @@ namespace OpenTK.Platform.X11 public MouseState GetState(int index) { - - // X11Mouse supports a single mouse only - if (index < 0 || index > 1) - throw new ArgumentOutOfRangeException("index"); - ProcessEvents(); - return mouse; + // X11Mouse supports only one device + if (index == 0) + return mouse; + else + return new MouseState(); } void WriteBit(MouseButton offset, int enabled) diff --git a/Source/OpenTK/Platform/X11/XI2Mouse.cs b/Source/OpenTK/Platform/X11/XI2Mouse.cs index 0451aa27..b4026905 100644 --- a/Source/OpenTK/Platform/X11/XI2Mouse.cs +++ b/Source/OpenTK/Platform/X11/XI2Mouse.cs @@ -37,8 +37,10 @@ namespace OpenTK.Platform.X11 // This should be easy: just read the device id and route the data to the correct device. sealed class XI2Mouse : IMouseDriver { - MouseState state = new MouseState(); - X11WindowInfo window; + List mice = new List(); + Dictionary rawids = new Dictionary(); // maps raw ids to mouse ids + int first_mouse; + readonly X11WindowInfo window; readonly int XIOpCode; static readonly Functions.EventPredicate PredicateImpl = IsEventValid; @@ -88,13 +90,19 @@ namespace OpenTK.Platform.X11 public MouseState GetState() { ProcessEvents(); - return state; + if (mice.Count > 0) + return mice[0]; + else + return new MouseState(); } public MouseState GetState(int index) { ProcessEvents(); - return state; + if (mice.Count > index) + return mice[index]; + else + return new MouseState(); } void ProcessEvents() @@ -114,7 +122,14 @@ namespace OpenTK.Platform.X11 { XIRawEvent raw = (XIRawEvent) Marshal.PtrToStructure(cookie.data, typeof(XIRawEvent)); - + + if (!rawids.ContainsKey(raw.deviceid)) + { + mice.Add(new MouseState()); + rawids.Add(raw.deviceid, mice.Count - 1); + } + MouseState state = mice[rawids[raw.deviceid]]; + switch (raw.evtype) { case XIEventType.RawMotion: @@ -162,6 +177,7 @@ namespace OpenTK.Platform.X11 } break; } + mice[rawids[raw.deviceid]] = state; } Functions.XFreeEventData(window.Display, ref cookie); } From 4d2759eb780358975959535d35b92a0c9d46bd70 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 22 Oct 2010 07:41:56 +0000 Subject: [PATCH 022/130] * XI2Mouse.cs: * X11Factory.cs: Detect whether XInput2 is not supported without throwing an exception. --- Source/OpenTK/Platform/X11/X11Factory.cs | 13 +++---- Source/OpenTK/Platform/X11/XI2Mouse.cs | 45 ++++++++++++++++-------- 2 files changed, 35 insertions(+), 23 deletions(-) diff --git a/Source/OpenTK/Platform/X11/X11Factory.cs b/Source/OpenTK/Platform/X11/X11Factory.cs index 96dd6162..a5a82c08 100644 --- a/Source/OpenTK/Platform/X11/X11Factory.cs +++ b/Source/OpenTK/Platform/X11/X11Factory.cs @@ -85,15 +85,10 @@ namespace OpenTK.Platform.X11 public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() { - try - { - // Only supported on xorg 1.7 or higher. - return new XI2Mouse(null); - } - catch (NotSupportedException) { } - - // Should always be supported. - return new X11Mouse(null); + if (XI2Mouse.IsSupported(IntPtr.Zero)) + return new XI2Mouse(null); // Requires xorg 1.7 or higher. + else + return new X11Mouse(null); // Always supported. } #endregion diff --git a/Source/OpenTK/Platform/X11/XI2Mouse.cs b/Source/OpenTK/Platform/X11/XI2Mouse.cs index b4026905..c92984fd 100644 --- a/Source/OpenTK/Platform/X11/XI2Mouse.cs +++ b/Source/OpenTK/Platform/X11/XI2Mouse.cs @@ -41,7 +41,7 @@ namespace OpenTK.Platform.X11 Dictionary rawids = new Dictionary(); // maps raw ids to mouse ids int first_mouse; readonly X11WindowInfo window; - readonly int XIOpCode; + static int XIOpCode; static readonly Functions.EventPredicate PredicateImpl = IsEventValid; readonly IntPtr Predicate = Marshal.GetFunctionPointerForDelegate(PredicateImpl); @@ -65,25 +65,40 @@ namespace OpenTK.Platform.X11 } } - using (new XLock(window.Display)) - { - int major, ev, error; - if (Functions.XQueryExtension(window.Display, "XInputExtension", out major, out ev, out error) == 0) - { - Debug.WriteLine("XInput2 not supported."); - throw new NotSupportedException(); - } - XIOpCode = major; + if (!IsSupported(window.Display)) + throw new NotSupportedException("XInput2 not supported."); - using (XIEventMask mask = new XIEventMask(1, XIEventMasks.RawButtonPressMask | + using (XIEventMask mask = new XIEventMask(1, XIEventMasks.RawButtonPressMask | XIEventMasks.RawButtonReleaseMask | XIEventMasks.RawMotionMask)) - { - Functions.XISelectEvents(window.Display, window.WindowHandle, mask); - } + { + Functions.XISelectEvents(window.Display, window.WindowHandle, mask); } + Debug.WriteLine("Using XI2Mouse."); } + // Checks whether XInput2 is supported on the specified display. + // If a display is not specified, the default display is used. + internal static bool IsSupported(IntPtr display) + { + if (display == IntPtr.Zero) + display = API.DefaultDisplay; + + using (new XLock(display)) + { + int major, ev, error; + if (Functions.XQueryExtension(display, "XInputExtension", out major, out ev, out error) == 0) + { + return false; + } + XIOpCode = major; + } + + return true; + } + + #region IMouseDriver Members + // Todo: remove this public IList Mouse { get { throw new NotSupportedException(); } } @@ -105,6 +120,8 @@ namespace OpenTK.Platform.X11 return new MouseState(); } + #endregion + void ProcessEvents() { while (true) From b63db9329d9a19af035c08f66b18dc37af892d8a Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 22 Oct 2010 08:16:37 +0000 Subject: [PATCH 023/130] Removed fixed expression that caused compilation error on VS2010 (but not Mono 2.6.7). --- Source/OpenTK/Input/KeyboardState.cs | 2 +- Source/OpenTK/Input/MouseState.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/OpenTK/Input/KeyboardState.cs b/Source/OpenTK/Input/KeyboardState.cs index 955ef547..91c019a8 100644 --- a/Source/OpenTK/Input/KeyboardState.cs +++ b/Source/OpenTK/Input/KeyboardState.cs @@ -122,8 +122,8 @@ namespace OpenTK.Input bool equal = true; unsafe { + int* k2 = other.Keys; fixed (int* k1 = Keys) - fixed (int* k2 = other.Keys) { for (int i = 0; equal && i < NumInts; i++) equal &= *(k1 + i) == *(k2 + i); diff --git a/Source/OpenTK/Input/MouseState.cs b/Source/OpenTK/Input/MouseState.cs index 937833df..e0b5b458 100644 --- a/Source/OpenTK/Input/MouseState.cs +++ b/Source/OpenTK/Input/MouseState.cs @@ -302,8 +302,8 @@ namespace OpenTK.Input bool equal = true; unsafe { + int* b2 = other.Buttons; fixed (int* b1 = Buttons) - fixed (int* b2 = other.Buttons) { for (int i = 0; equal && i < NumInts; i++) equal &= *(b1 + i) == *(b2 + i); From 6231931fcccc154d09c7ab5f1023e6b543781c68 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 22 Oct 2010 09:29:41 +0000 Subject: [PATCH 024/130] Fixed text anti-aliasing on Windows. --- Source/Examples/OpenTK/Test/GameWindowStates.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Source/Examples/OpenTK/Test/GameWindowStates.cs b/Source/Examples/OpenTK/Test/GameWindowStates.cs index d29474f4..c53a3fa8 100644 --- a/Source/Examples/OpenTK/Test/GameWindowStates.cs +++ b/Source/Examples/OpenTK/Test/GameWindowStates.cs @@ -117,8 +117,8 @@ namespace Examples.Tests { int line = 0; - gfx.Clear(Color.MidnightBlue); - gfx.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit; + gfx.Clear(Color.Black); + gfx.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit; DrawString(gfx, String.Format("[1 - 4]: change WindowState (current: {0}).", this.WindowState), line++); DrawString(gfx, String.Format("[5 - 7]: change WindowBorder (current: {0}).", this.WindowBorder), line++); @@ -151,7 +151,7 @@ namespace Examples.Tests GL.Enable(EnableCap.Texture2D); GL.Enable(EnableCap.Blend); - GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.OneMinusSrcAlpha); + GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.OneMinusSrcColor); texture = GL.GenTexture(); GL.BindTexture(TextureTarget.Texture2D, texture); From 38f54630cb4b04bf47fd4972af22fe4373d595d4 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 22 Oct 2010 13:22:28 +0000 Subject: [PATCH 025/130] Implemented PointToScreen and fixed mouse grab rectangle to match the client rectangle exactly. --- Source/OpenTK/Platform/Windows/WinGLNative.cs | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 50c1c12e..88db66c5 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -856,7 +856,7 @@ namespace OpenTK.Platform.Windows while (cursor_visible_count < 0); if (!Functions.ClipCursor(IntPtr.Zero)) - Debug.WriteLine(String.Format("Failed to grab cursor. Error: {0}", + Debug.WriteLine(String.Format("Failed to ungrab cursor. Error: {0}", Marshal.GetLastWin32Error())); } else if (!value && cursor_visible_count >= 0) @@ -867,7 +867,10 @@ namespace OpenTK.Platform.Windows } while (cursor_visible_count >= 0); - Win32Rectangle rect = Win32Rectangle.From(Bounds); + Win32Rectangle rect = Win32Rectangle.From(ClientRectangle); + Point pos = PointToScreen(new Point(rect.left, rect.top)); + rect.left = pos.X; + rect.top = pos.Y; if (!Functions.ClipCursor(ref rect)) Debug.WriteLine(String.Format("Failed to grab cursor. Error: {0}", Marshal.GetLastWin32Error())); @@ -1064,7 +1067,7 @@ namespace OpenTK.Platform.Windows { if (!Functions.ScreenToClient(window.WindowHandle, ref point)) throw new InvalidOperationException(String.Format( - "Could not convert point {0} from client to screen coordinates. Windows error: {1}", + "Could not convert point {0} from screen to client coordinates. Windows error: {1}", point.ToString(), Marshal.GetLastWin32Error())); return point; @@ -1074,9 +1077,14 @@ namespace OpenTK.Platform.Windows #region PointToScreen - public Point PointToScreen(Point p) + public Point PointToScreen(Point point) { - throw new NotImplementedException(); + if (!Functions.ClientToScreen(window.WindowHandle, ref point)) + throw new InvalidOperationException(String.Format( + "Could not convert point {0} from screen to client coordinates. Windows error: {1}", + point.ToString(), Marshal.GetLastWin32Error())); + + return point; } #endregion From 687594db4ca32cf9087a8605fa5e290ed209d16d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 22 Oct 2010 13:36:05 +0000 Subject: [PATCH 026/130] Fixed CursorVisible getter. If necessary, re-grab the cursor whenever the window changes position/size. --- Source/OpenTK/Platform/Windows/WinGLNative.cs | 44 ++++++++++++++----- 1 file changed, 33 insertions(+), 11 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 88db66c5..e350ad33 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -209,6 +209,10 @@ namespace OpenTK.Platform.Windows if (suppress_resize <= 0 && Resize != null) Resize(this, EventArgs.Empty); } + + // Ensure cursor remains grabbed + if (!CursorVisible) + GrabCursor(); } } break; @@ -228,6 +232,10 @@ namespace OpenTK.Platform.Windows } } + // Ensure cursor remains grabbed + if (!CursorVisible) + GrabCursor(); + break; case WindowMessage.SIZE: @@ -250,6 +258,10 @@ namespace OpenTK.Platform.Windows WindowStateChanged(this, EventArgs.Empty); } + // Ensure cursor remains grabbed + if (!CursorVisible) + GrabCursor(); + break; #endregion @@ -630,6 +642,24 @@ namespace OpenTK.Platform.Windows suppress_resize--; } + void GrabCursor() + { + Win32Rectangle rect = Win32Rectangle.From(ClientRectangle); + Point pos = PointToScreen(new Point(rect.left, rect.top)); + rect.left = pos.X; + rect.top = pos.Y; + if (!Functions.ClipCursor(ref rect)) + Debug.WriteLine(String.Format("Failed to grab cursor. Error: {0}", + Marshal.GetLastWin32Error())); + } + + static void UngrabCursor() + { + if (!Functions.ClipCursor(IntPtr.Zero)) + Debug.WriteLine(String.Format("Failed to ungrab cursor. Error: {0}", + Marshal.GetLastWin32Error())); + } + #endregion #region INativeWindow Members @@ -844,7 +874,7 @@ namespace OpenTK.Platform.Windows public bool CursorVisible { - get { return cursor_visible_count > 0; } // Not used + get { return cursor_visible_count >= 0; } // Not used set { if (value && cursor_visible_count < 0) @@ -855,9 +885,7 @@ namespace OpenTK.Platform.Windows } while (cursor_visible_count < 0); - if (!Functions.ClipCursor(IntPtr.Zero)) - Debug.WriteLine(String.Format("Failed to ungrab cursor. Error: {0}", - Marshal.GetLastWin32Error())); + UngrabCursor(); } else if (!value && cursor_visible_count >= 0) { @@ -867,13 +895,7 @@ namespace OpenTK.Platform.Windows } while (cursor_visible_count >= 0); - Win32Rectangle rect = Win32Rectangle.From(ClientRectangle); - Point pos = PointToScreen(new Point(rect.left, rect.top)); - rect.left = pos.X; - rect.top = pos.Y; - if (!Functions.ClipCursor(ref rect)) - Debug.WriteLine(String.Format("Failed to grab cursor. Error: {0}", - Marshal.GetLastWin32Error())); + GrabCursor(); } } } From ef6c910d307f60aa91372e8b4b45d056973bf42c Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 22 Oct 2010 13:41:42 +0000 Subject: [PATCH 027/130] Initial implementation of raw mouse input on Windows. --- Source/OpenTK/Platform/Windows/API.cs | 130 ++++------ Source/OpenTK/Platform/Windows/WinFactory.cs | 5 +- Source/OpenTK/Platform/Windows/WinRawInput.cs | 7 +- Source/OpenTK/Platform/Windows/WinRawMouse.cs | 228 ++++++++---------- 4 files changed, 166 insertions(+), 204 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/API.cs b/Source/OpenTK/Platform/Windows/API.cs index 20cb38a7..94081054 100644 --- a/Source/OpenTK/Platform/Windows/API.cs +++ b/Source/OpenTK/Platform/Windows/API.cs @@ -851,6 +851,9 @@ namespace OpenTK.Platform.Windows [DllImport("user32.dll", SetLastError = true)] public static extern BOOL BringWindowToTop(HWND hWnd); + [DllImport("user32.dll", SetLastError = true)] + public static extern BOOL SetParent(HWND child, HWND newParent); + #endregion #region Display settings @@ -1353,17 +1356,6 @@ namespace OpenTK.Platform.Windows /// /// GetRawInputData gets the raw input one RawInput structure at a time. In contrast, GetRawInputBuffer gets an array of RawInput structures. /// - [CLSCompliant(false)] - [System.Security.SuppressUnmanagedCodeSecurity] - [DllImport("user32.dll", SetLastError = true)] - internal static extern UINT GetRawInputData( - HRAWINPUT RawInput, - GetRawInputDataEnum Command, - [Out] LPVOID Data, - [In, Out] ref UINT Size, - UINT SizeHeader - ); - [System.Security.SuppressUnmanagedCodeSecurity] [DllImport("user32.dll", SetLastError = true)] internal static extern INT GetRawInputData( @@ -1395,17 +1387,6 @@ namespace OpenTK.Platform.Windows /// /// GetRawInputData gets the raw input one RawInput structure at a time. In contrast, GetRawInputBuffer gets an array of RawInput structures. /// - [CLSCompliant(false)] - [System.Security.SuppressUnmanagedCodeSecurity] - [DllImport("user32.dll", SetLastError = true)] - internal static extern UINT GetRawInputData( - HRAWINPUT RawInput, - GetRawInputDataEnum Command, - /*[MarshalAs(UnmanagedType.LPStruct)]*/ [Out] out RawInput Data, - [In, Out] ref UINT Size, - UINT SizeHeader - ); - [System.Security.SuppressUnmanagedCodeSecurity] [DllImport("user32.dll", SetLastError = true)] internal static extern INT GetRawInputData( @@ -1416,6 +1397,16 @@ namespace OpenTK.Platform.Windows INT SizeHeader ); + [System.Security.SuppressUnmanagedCodeSecurity] + [DllImport("user32.dll", SetLastError = true)] + unsafe internal static extern INT GetRawInputData( + HRAWINPUT RawInput, + GetRawInputDataEnum Command, + RawInput* Data, + [In, Out] ref INT Size, + INT SizeHeader + ); + #endregion #region IntPtr NextRawInputStructure(IntPtr data) @@ -1487,7 +1478,7 @@ namespace OpenTK.Platform.Windows #region --- Constants --- - internal struct Constants + static class Constants { // Found in winuser.h internal const int KEYBOARD_OVERRUN_MAKE_CODE = 0xFF; @@ -1574,6 +1565,8 @@ namespace OpenTK.Platform.Windows // (found in winuser.h) internal const int ENUM_REGISTRY_SETTINGS = -2; internal const int ENUM_CURRENT_SETTINGS = -1; + + internal static readonly IntPtr MESSAGE_ONLY = new IntPtr(-3); } #endregion @@ -2231,25 +2224,11 @@ namespace OpenTK.Platform.Windows /// To get device specific information, call GetRawInputDeviceInfo with the hDevice from RAWINPUTHEADER. /// Raw input is available only when the application calls RegisterRawInputDevices with valid device specifications. /// - [StructLayout(LayoutKind.Sequential)] - internal struct RawInput + [StructLayout(LayoutKind.Sequential, Pack = 1)] + struct RawInput { - internal RawInputHeader Header; - internal RawInputData Data; - - internal byte[] ToByteArray() - { - unsafe - { - byte[] dump = new byte[API.RawInputSize]; - fixed (RawInputDeviceType* ptr = &Header.Type) - { - for (int i = 0; i < API.RawInputSize; i++) - dump[i] = *((byte*)ptr + i); - return dump; - } - } - } + public RawInputHeader Header; + public RawInputData Data; } [StructLayout(LayoutKind.Explicit)] @@ -2350,38 +2329,9 @@ namespace OpenTK.Platform.Windows /// /// Contains information about the state of the mouse. /// - [StructLayout(LayoutKind.Sequential, Pack=1)] + [StructLayout(LayoutKind.Explicit)] internal struct RawMouse { - //internal RawMouseFlags Flags; // USHORT in winuser.h, but only INT works -- USHORT returns 0. - USHORT flags; - byte for_alignment; // Not used -- used for alignment - /// - /// Reserved. - /// - //ULONG Buttons; - internal USHORT buttonFlags; - /// - /// If usButtonFlags is RI_MOUSE_WHEEL, this member is a signed value that specifies the wheel delta. - /// - internal USHORT ButtonData;// { get { return (USHORT)((Buttons & 0xFFFF0000) >> 16); } } - /// - /// Raw state of the mouse buttons. - /// - internal ULONG RawButtons; - /// - /// Motion in the X direction. This is signed relative motion or absolute motion, depending on the value of usFlags. - /// - internal LONG LastX; - /// - /// Motion in the Y direction. This is signed relative motion or absolute motion, depending on the value of usFlags. - /// - internal LONG LastY; - /// - /// Device-specific additional information for the event. - /// - internal ULONG ExtraInformation; - /// /// Mouse state. This member can be any reasonable combination of the following. /// MOUSE_ATTRIBUTES_CHANGED @@ -2393,12 +2343,34 @@ namespace OpenTK.Platform.Windows /// MOUSE_VIRTUAL_DESKTOP /// Mouse coordinates are mapped to the virtual desktop (for a multiple monitor system). /// - internal RawMouseFlags Flags { get { return (RawMouseFlags)(flags); } } + [FieldOffset(0)] public RawMouseFlags Flags; // USHORT in winuser.h, but only INT works -- USHORT returns 0. + + [FieldOffset(4)] public RawInputMouseState ButtonFlags; /// - /// Transition state of the mouse buttons. + /// If usButtonFlags is RI_MOUSE_WHEEL, this member is a signed value that specifies the wheel delta. /// - internal RawInputMouseState ButtonFlags { get { return (RawInputMouseState)(buttonFlags); } } + [FieldOffset(6)] public USHORT ButtonData; + + /// + /// Raw state of the mouse buttons. + /// + [FieldOffset(8)] public ULONG RawButtons; + + /// + /// Motion in the X direction. This is signed relative motion or absolute motion, depending on the value of usFlags. + /// + [FieldOffset(12)] public LONG LastX; + + /// + /// Motion in the Y direction. This is signed relative motion or absolute motion, depending on the value of usFlags. + /// + [FieldOffset(16)] public LONG LastY; + + /// + /// Device-specific additional information for the event. + /// + [FieldOffset(20)] public ULONG ExtraInformation; } #endregion @@ -2483,10 +2455,11 @@ namespace OpenTK.Platform.Windows /// Number of HID inputs in bRawData. /// internal DWORD Count; - /// - /// Raw input data as an array of bytes. - /// - internal BYTE RawData; + // The RawData field must be marshalled manually. + ///// + ///// Raw input data as an array of bytes. + ///// + //internal IntPtr RawData; } #endregion @@ -3239,6 +3212,7 @@ namespace OpenTK.Platform.Windows /// /// Mouse indicator flags (found in winuser.h). /// + [Flags] internal enum RawMouseFlags : ushort { /// diff --git a/Source/OpenTK/Platform/Windows/WinFactory.cs b/Source/OpenTK/Platform/Windows/WinFactory.cs index 30b25b74..2616e770 100644 --- a/Source/OpenTK/Platform/Windows/WinFactory.cs +++ b/Source/OpenTK/Platform/Windows/WinFactory.cs @@ -83,7 +83,10 @@ namespace OpenTK.Platform.Windows public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() { - throw new NotImplementedException(); + if (System.Environment.OSVersion.Version.Major >= 5) + return new WinRawMouse(); + else + return new WMInput(null); } #endregion diff --git a/Source/OpenTK/Platform/Windows/WinRawInput.cs b/Source/OpenTK/Platform/Windows/WinRawInput.cs index 3cd04ec6..4d4a2f77 100644 --- a/Source/OpenTK/Platform/Windows/WinRawInput.cs +++ b/Source/OpenTK/Platform/Windows/WinRawInput.cs @@ -38,9 +38,10 @@ namespace OpenTK.Platform.Windows Debug.Indent(); AssignHandle(parent.WindowHandle); + WinWindowInfo win = new WinWindowInfo(this.Handle, parent); Debug.Print("Input window attached to parent {0}", parent); keyboardDriver = new WinRawKeyboard(this.Handle); - mouseDriver = new WinRawMouse(this.Handle); + mouseDriver = new WinRawMouse(); Debug.Unindent(); @@ -93,9 +94,7 @@ namespace OpenTK.Platform.Windows return; case RawInputDeviceType.MOUSE: - if (!mouseDriver.ProcessEvent(data)) - Functions.DefRawInputProc(ref data, 1, (uint)API.RawInputHeaderSize); - return; + throw new NotSupportedException(); case RawInputDeviceType.HID: Functions.DefRawInputProc(ref data, 1, (uint)API.RawInputHeaderSize); diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index 46ab54f4..f242bd89 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -6,12 +6,11 @@ using System; using System.Collections.Generic; -using System.Text; -using OpenTK.Input; using System.Diagnostics; +using System.Drawing; using System.Runtime.InteropServices; using Microsoft.Win32; -using System.Drawing; +using OpenTK.Input; namespace OpenTK.Platform.Windows { @@ -19,54 +18,64 @@ namespace OpenTK.Platform.Windows /// /// Contains methods to register for and process mouse WM_INPUT messages. /// - internal class WinRawMouse : IMouseDriver, IDisposable + internal class WinRawMouse : IMouseDriver { - private List mice = new List(); - private IntPtr window; - - #region --- Constructors --- + List mice; + Dictionary rawids; // ContextHandle instead of IntPtr for fast dictionary access + readonly INativeWindow native; + readonly IntPtr window; + readonly WindowProcedure WndProc; + readonly IntPtr OldWndProc; internal WinRawMouse() - : this(IntPtr.Zero) - { - } - - internal WinRawMouse(IntPtr windowHandle) { Debug.WriteLine("Initializing mouse driver (WinRawMouse)."); Debug.Indent(); - this.window = windowHandle; + // Create a new message-only window to retrieve WM_INPUT messages. + native = new NativeWindow(); + window = (native.WindowInfo as WinWindowInfo).WindowHandle; + //Functions.SetParent(window, Constants.MESSAGE_ONLY); + // Subclass the window to retrieve the events we are interested in. + WndProc = WindowProcedure; + OldWndProc = Functions.SetWindowLong(window, WndProc); + native.ProcessEvents(); - RegisterDevices(); + RegisterDevices(window, out mice, out rawids); Debug.Unindent(); } - #endregion + #region IMouseDriver Members - #region --- IMouseDriver Members --- - - public IList Mouse - { - get { return mice; } - } + public IList Mouse { get { throw new NotImplementedException(); } } public MouseState GetState() { - throw new NotImplementedException(); + native.ProcessEvents(); + if (mice.Count > 0) + return mice[0]; + else + return new MouseState(); } public MouseState GetState(int index) { - throw new NotImplementedException(); + native.ProcessEvents(); + if (index < mice.Count) + return mice[index]; + else + return new MouseState(); } - #region public int RegisterDevices() + #endregion - public int RegisterDevices() + static int RegisterDevices(IntPtr window, out List mice, out Dictionary rawids) { int count = WinRawInput.DeviceCount; + mice = new List(); + rawids = new Dictionary(); + RawInputDeviceList[] ridl = new RawInputDeviceList[count]; for (int i = 0; i < count; i++) ridl[i] = new RawInputDeviceList(); @@ -114,22 +123,14 @@ namespace OpenTK.Platform.Windows if (!String.IsNullOrEmpty(deviceClass) && deviceClass.ToLower().Equals("mouse")) { - OpenTK.Input.MouseDevice mouse = new OpenTK.Input.MouseDevice(); - mouse.Description = deviceDesc; - - // Register the keyboard: + // Register the device: RawInputDeviceInfo info = new RawInputDeviceInfo(); int devInfoSize = API.RawInputDeviceInfoSize; Functions.GetRawInputDeviceInfo(ridl[i].Device, RawInputDeviceInfoEnum.DEVICEINFO, info, ref devInfoSize); - mouse.NumberOfButtons = info.Device.Mouse.NumberOfButtons; - mouse.NumberOfWheels = info.Device.Mouse.HasHorizontalWheel ? 1 : 0; - - mouse.DeviceID = ridl[i].Device;//(IntPtr)info.Device.Mouse.Id; - - this.RegisterRawDevice(mouse); - mice.Add(mouse); + mice.Add(RegisterRawDevice(deviceDesc, window)); + rawids.Add(new ContextHandle(ridl[i].Device), mice.Count - 1); } } } @@ -137,14 +138,9 @@ namespace OpenTK.Platform.Windows return count; } - #endregion - - #endregion - - #region internal void RegisterRawDevice(OpenTK.Input.Mouse mouse) - - internal void RegisterRawDevice(OpenTK.Input.MouseDevice mouse) + static MouseState RegisterRawDevice(string device, IntPtr window) { + MouseState state = new MouseState(); RawInputDevice[] rid = new RawInputDevice[1]; // Mouse is 1/2 (page/id). See http://www.microsoft.com/whdc/device/input/HID_HWID.mspx rid[0] = new RawInputDevice(); @@ -164,106 +160,96 @@ namespace OpenTK.Platform.Windows } else { - Debug.Print("Registered mouse {0}", mouse.ToString()); + Debug.Print("Registered mouse {0}", device); Point p = new Point(); if (Functions.GetCursorPos(ref p)) - mouse.Position = p; + { + state.X = p.X; + state.Y = p.Y; + } } + + return state; } - #endregion - - #region internal bool ProcessEvent(API.RawInput rin) - - /// - /// Processes raw input events. - /// - /// - /// - internal bool ProcessEvent(RawInput rin) + IntPtr WindowProcedure(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam) { - //MouseDevice mouse = mice.Find(delegate(MouseDevice m) - //{ - // return m.DeviceID == rin.Header.Device; - //}); - MouseDevice mouse; - if (mice.Count > 0) mouse = mice[0]; - else return false; - - switch (rin.Header.Type) + switch (message) { - case RawInputDeviceType.MOUSE: - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.LEFT_BUTTON_DOWN) != 0) mouse[MouseButton.Left] = true; - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.LEFT_BUTTON_UP) != 0) mouse[MouseButton.Left] = false; - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.RIGHT_BUTTON_DOWN) != 0) mouse[MouseButton.Right] = true; - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.RIGHT_BUTTON_UP) != 0) mouse[MouseButton.Right] = false; - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.MIDDLE_BUTTON_DOWN) != 0) mouse[MouseButton.Middle] = true; - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.MIDDLE_BUTTON_UP) != 0) mouse[MouseButton.Middle] = false; - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.BUTTON_4_DOWN) != 0) mouse[MouseButton.Button1] = true; - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.BUTTON_4_UP) != 0) mouse[MouseButton.Button1] = false; - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.BUTTON_5_DOWN) != 0) mouse[MouseButton.Button2] = true; - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.BUTTON_5_UP) != 0) mouse[MouseButton.Button2] = false; + case WindowMessage.INPUT: + int expected_size = 0, real_size = 0; + RawInput data = new RawInput(); - if ((rin.Data.Mouse.ButtonFlags & RawInputMouseState.WHEEL) != 0) - mouse.Wheel += (short)rin.Data.Mouse.ButtonData / 120; - - if ((rin.Data.Mouse.Flags & RawMouseFlags.MOUSE_MOVE_ABSOLUTE) != 0) - { - mouse.Position = new Point(rin.Data.Mouse.LastX, rin.Data.Mouse.LastY); - } - else - { // Seems like MOUSE_MOVE_RELATIVE is the default, unless otherwise noted. - mouse.Position = new Point(mouse.X + rin.Data.Mouse.LastX, - mouse.Y + rin.Data.Mouse.LastY); - } - - if ((rin.Data.Mouse.Flags & RawMouseFlags.MOUSE_VIRTUAL_DESKTOP) != 0) - Debug.WriteLine(String.Format("Mouse {0} defines MOUSE_VIRTUAL_DESKTOP flag, please report at http://www.opentk.com", mouse.ToString())); + // Get the size of the input buffer + Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, + IntPtr.Zero, ref expected_size, API.RawInputHeaderSize); - return true; + // Read the actual data + unsafe + { + real_size = Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, + &data, ref expected_size, API.RawInputHeaderSize); + } + + if (real_size == expected_size) + { + if (data.Header.Type == RawInputDeviceType.MOUSE) + { + if (ProcessEvent(data.Header.Device, data.Data.Mouse)) + { + return IntPtr.Zero; + } + } + } + // We didn't handle this message after all, give it back to the old WndProc. + goto default; default: - throw new ApplicationException("WinRawMouse driver received invalid data."); + return Functions.CallWindowProc(OldWndProc, handle, message, wParam, lParam); } } - #endregion - - #region public void Poll() - - public void Poll() + bool ProcessEvent(IntPtr device, RawMouse raw) { - } + if (mice.Count == 0) + return false; - #endregion + ContextHandle handle = new ContextHandle(device); + MouseState mouse; + if (rawids.ContainsKey(handle)) + mouse = mice[rawids[handle]]; + else + return false; - #region --- IDisposable Members --- + if ((raw.ButtonFlags & RawInputMouseState.LEFT_BUTTON_DOWN) != 0) mouse.EnableBit((int)MouseButton.Left); + if ((raw.ButtonFlags & RawInputMouseState.LEFT_BUTTON_UP) != 0) mouse.DisableBit((int)MouseButton.Left); + if ((raw.ButtonFlags & RawInputMouseState.RIGHT_BUTTON_DOWN) != 0) mouse.EnableBit((int)MouseButton.Right); + if ((raw.ButtonFlags & RawInputMouseState.RIGHT_BUTTON_UP) != 0) mouse.DisableBit((int)MouseButton.Right); + if ((raw.ButtonFlags & RawInputMouseState.MIDDLE_BUTTON_DOWN) != 0) mouse.EnableBit((int)MouseButton.Middle); + if ((raw.ButtonFlags & RawInputMouseState.MIDDLE_BUTTON_UP) != 0) mouse.DisableBit((int)MouseButton.Middle); + if ((raw.ButtonFlags & RawInputMouseState.BUTTON_4_DOWN) != 0) mouse.EnableBit((int)MouseButton.Button1); + if ((raw.ButtonFlags & RawInputMouseState.BUTTON_4_UP) != 0) mouse.DisableBit((int)MouseButton.Button1); + if ((raw.ButtonFlags & RawInputMouseState.BUTTON_5_DOWN) != 0) mouse.EnableBit((int)MouseButton.Button2); + if ((raw.ButtonFlags & RawInputMouseState.BUTTON_5_UP) != 0) mouse.DisableBit((int)MouseButton.Button2); - private bool disposed; + if ((raw.ButtonFlags & RawInputMouseState.WHEEL) != 0) + mouse.WheelPrecise += (short)raw.ButtonData / 120.0f; - public void Dispose() - { - Dispose(true); - GC.SuppressFinalize(this); - } - - private void Dispose(bool manual) - { - if (!disposed) + if ((raw.Flags & RawMouseFlags.MOUSE_MOVE_ABSOLUTE) != 0) { - if (manual) - { - mice.Clear(); - } - disposed = true; + mouse.X = raw.LastX; + mouse.Y = raw.LastY; } + else + { // Seems like MOUSE_MOVE_RELATIVE is the default, unless otherwise noted. + mouse.X += raw.LastX; + mouse.Y += raw.LastY; + } + + mice[rawids[handle]] = mouse; + return true; } - ~WinRawMouse() - { - Dispose(false); - } - #endregion } } From 3c2c07361a946c777d6700cff267d91a9ee3a385 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 22 Oct 2010 14:57:06 +0000 Subject: [PATCH 028/130] Implemented raw keyboard input for Windows. Improved the interface for receiving input. Moved raw input window to its own thread. --- Source/OpenTK/Input/IInputDriver2.cs | 41 +++ Source/OpenTK/Input/InputDriver.cs | 146 ----------- Source/OpenTK/OpenTK.csproj | 6 +- Source/OpenTK/Platform/Windows/WMInput.cs | 46 +++- Source/OpenTK/Platform/Windows/WinFactory.cs | 35 ++- Source/OpenTK/Platform/Windows/WinRawInput.cs | 246 ++++++++++++------ .../OpenTK/Platform/Windows/WinRawKeyboard.cs | 29 ++- Source/OpenTK/Platform/Windows/WinRawMouse.cs | 94 +++---- 8 files changed, 328 insertions(+), 315 deletions(-) create mode 100644 Source/OpenTK/Input/IInputDriver2.cs delete mode 100644 Source/OpenTK/Input/InputDriver.cs diff --git a/Source/OpenTK/Input/IInputDriver2.cs b/Source/OpenTK/Input/IInputDriver2.cs new file mode 100644 index 00000000..5cfbcdfd --- /dev/null +++ b/Source/OpenTK/Input/IInputDriver2.cs @@ -0,0 +1,41 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.Input +{ + // Defines the interface for a 2nd generation input driver. + interface IInputDriver2 + { + IMouseDriver MouseDriver { get; } + IKeyboardDriver KeyboardDriver { get; } + IJoystickDriver JoystickDriver { get; } + } +} diff --git a/Source/OpenTK/Input/InputDriver.cs b/Source/OpenTK/Input/InputDriver.cs deleted file mode 100644 index 4a137c99..00000000 --- a/Source/OpenTK/Input/InputDriver.cs +++ /dev/null @@ -1,146 +0,0 @@ -#region --- License --- -/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos - * See license.txt for license info - */ -#endregion - -using System; -using System.Collections.Generic; -using System.Text; - -using OpenTK.Input; -using OpenTK.Platform; - -namespace OpenTK -{ - internal class InputDriver : IInputDriver - { - private IInputDriver inputDriver; - - #region --- Constructors --- - - public InputDriver(GameWindow parent) - { - if (parent == null) - throw new ArgumentException("A valid window (IWindowInfo) must be specified to construct an InputDriver"); - - switch (Environment.OSVersion.Platform) - { - case PlatformID.Win32Windows: - case PlatformID.Win32NT: - case PlatformID.Win32S: - case PlatformID.WinCE: - if (Environment.OSVersion.Version.Major > 5 || - (Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor >= 1)) - { - inputDriver = new OpenTK.Platform.Windows.WinRawInput((OpenTK.Platform.Windows.WinWindowInfo)parent.WindowInfo); - } - else - { - // Legacy or unknown windows version: - inputDriver = new OpenTK.Platform.Windows.WMInput((OpenTK.Platform.Windows.WinWindowInfo)parent.WindowInfo); - } - break; - - case PlatformID.Unix: - // TODO: Input is currently handled asychronously by the driver in X11GLNative. - //inputDriver = new OpenTK.Platform.X11.X11Input(parent.WindowInfo); - - break; - - default: - throw new PlatformNotSupportedException( - "Input handling is not supported on the current platform. Please report the problem to http://opentk.sourceforge.net"); - - } - } - - #endregion - - #region --- IInputDriver Members --- - - public void Poll() - { - inputDriver.Poll(); - } - - #endregion - - #region --- IKeyboardDriver Members --- - - public IList Keyboard - { - get { return inputDriver.Keyboard; } - } - - public KeyboardState GetState() - { - return (inputDriver as IKeyboardDriver).GetState(); - } - - public KeyboardState GetState(int index) - { - return (inputDriver as IKeyboardDriver).GetState(index); - } - - #endregion - - #region --- IMouseDriver Members --- - - public IList Mouse - { - get { return inputDriver.Mouse; } - } - - MouseState IMouseDriver.GetState() - { - throw new NotImplementedException(); - } - - MouseState IMouseDriver.GetState(int index) - { - throw new NotImplementedException(); - } - - #endregion - - #region --- IJoystickDriver Members --- - - public IList Joysticks - { - get { return inputDriver.Joysticks; } - } - - #endregion - - #region --- IDisposable Members --- - - private bool disposed; - - public void Dispose() - { - this.Dispose(true); - GC.SuppressFinalize(this); - } - - private void Dispose(bool manual) - { - if (!disposed) - { - if (manual) - { - inputDriver.Dispose(); - } - - disposed = true; - } - } - - ~InputDriver() - { - this.Dispose(false); - } - - #endregion - } -} diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index 8719568a..353f108b 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -1,4 +1,4 @@ - + Local @@ -131,6 +131,7 @@ Code + Code @@ -551,9 +552,6 @@ Code - - Code - Code diff --git a/Source/OpenTK/Platform/Windows/WMInput.cs b/Source/OpenTK/Platform/Windows/WMInput.cs index 90399ebc..c1b04ef1 100644 --- a/Source/OpenTK/Platform/Windows/WMInput.cs +++ b/Source/OpenTK/Platform/Windows/WMInput.cs @@ -1,7 +1,28 @@ -#region --- License --- -/* Copyright (c) 2007 Stefanos Apostolopoulos - * See license.txt for license information - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion using System; @@ -16,7 +37,7 @@ using System.Drawing; namespace OpenTK.Platform.Windows { // Input driver for legacy (pre XP) Windows platforms. - sealed class WMInput : System.Windows.Forms.NativeWindow, IInputDriver + sealed class WMInput : System.Windows.Forms.NativeWindow, IInputDriver, IInputDriver2 { #region --- Fields --- @@ -315,5 +336,20 @@ namespace OpenTK.Platform.Windows } #endregion + + public IMouseDriver MouseDriver + { + get { throw new NotImplementedException(); } + } + + public IKeyboardDriver KeyboardDriver + { + get { throw new NotImplementedException(); } + } + + public IJoystickDriver JoystickDriver + { + get { return joystick_driver; } + } } } diff --git a/Source/OpenTK/Platform/Windows/WinFactory.cs b/Source/OpenTK/Platform/Windows/WinFactory.cs index 2616e770..b4c55db3 100644 --- a/Source/OpenTK/Platform/Windows/WinFactory.cs +++ b/Source/OpenTK/Platform/Windows/WinFactory.cs @@ -36,6 +36,9 @@ namespace OpenTK.Platform.Windows class WinFactory : IPlatformFactory { + readonly object SyncRoot = new object(); + IInputDriver2 inputDriver; + #region IPlatformFactory Members public virtual INativeWindow CreateNativeWindow(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) @@ -73,22 +76,34 @@ namespace OpenTK.Platform.Windows public virtual OpenTK.Input.IKeyboardDriver CreateKeyboardDriver() { - throw new NotImplementedException(); - // If Windows version is NT5 or higher, we are able to use raw input. - if (System.Environment.OSVersion.Version.Major >= 5) - return new WinRawKeyboard(); - else - return new WMInput(null); + + return InputDriver.KeyboardDriver; } public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() { - if (System.Environment.OSVersion.Version.Major >= 5) - return new WinRawMouse(); - else - return new WMInput(null); + return InputDriver.MouseDriver; } #endregion + + IInputDriver2 InputDriver + { + get + { + lock (SyncRoot) + { + if (inputDriver == null) + { + // If Windows version is NT5 or higher, we are able to use raw input. + if (System.Environment.OSVersion.Version.Major >= 5) + inputDriver = new WinRawInput(); + else + inputDriver = new WMInput(null); + } + return inputDriver; + } + } + } } } diff --git a/Source/OpenTK/Platform/Windows/WinRawInput.cs b/Source/OpenTK/Platform/Windows/WinRawInput.cs index 4d4a2f77..baebfb92 100644 --- a/Source/OpenTK/Platform/Windows/WinRawInput.cs +++ b/Source/OpenTK/Platform/Windows/WinRawInput.cs @@ -1,7 +1,28 @@ -#region --- License --- -/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos - * See license.txt for license info - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion #region --- Using directives --- @@ -13,49 +34,51 @@ using System.Runtime.InteropServices; using System.Diagnostics; using System.Windows.Forms; using OpenTK.Input; +using System.Threading; #endregion namespace OpenTK.Platform.Windows { // Not complete. - sealed class WinRawInput : System.Windows.Forms.NativeWindow, IInputDriver + sealed class WinRawInput : IInputDriver, IInputDriver2 { // Input event data. - RawInput data = new RawInput(); - // The total number of input devices connected to this system. - static int deviceCount; - int rawInputStructSize = API.RawInputSize; + static RawInput data = new RawInput(); + static readonly int rawInputStructSize = API.RawInputSize; + static readonly Thread InputThread = new Thread(ProcessEvents); - private WinRawKeyboard keyboardDriver; - private WinRawMouse mouseDriver; + static WinRawKeyboard keyboardDriver; + static WinRawMouse mouseDriver; + static readonly WinMMJoystick joystickDriver = new WinMMJoystick(); - #region --- Constructors --- + static INativeWindow Native; + static WinWindowInfo Parent { get { return Native.WindowInfo as WinWindowInfo; } } + static readonly WindowProcedure WndProc = WindowProcedureImplementation; + static IntPtr OldWndProc; - internal WinRawInput(WinWindowInfo parent) + #region Constructors + + public WinRawInput() { - Debug.WriteLine("Initalizing windows raw input driver."); - Debug.Indent(); + InputThread.IsBackground = true; + InputThread.Start(); - AssignHandle(parent.WindowHandle); - WinWindowInfo win = new WinWindowInfo(this.Handle, parent); - Debug.Print("Input window attached to parent {0}", parent); - keyboardDriver = new WinRawKeyboard(this.Handle); - mouseDriver = new WinRawMouse(); - - Debug.Unindent(); - - //AllocateBuffer(); + while (mouseDriver == null || keyboardDriver == null) + Thread.Sleep(0); } #endregion - #region internal static int DeviceCount + #region Public Members - internal static int DeviceCount + #region DeviceCount + + public static int DeviceCount { get { + int deviceCount = 0; Functions.GetRawInputDeviceList(null, ref deviceCount, API.RawInputDeviceListSize); return deviceCount; } @@ -63,72 +86,103 @@ namespace OpenTK.Platform.Windows #endregion - #region protected override void WndProc(ref Message msg) + #endregion - /// - /// Processes the input Windows Message, routing the buffer to the correct Keyboard, Mouse or HID. - /// - /// The WM_INPUT message, containing the buffer on the input event. - protected override void WndProc(ref Message msg) + #region Private Members + + #region ConstructMessageWindow + + static INativeWindow ConstructMessageWindow() { - switch ((WindowMessage)msg.Msg) - { - case WindowMessage.INPUT: - int size = 0; - // Get the size of the input buffer - Functions.GetRawInputData(msg.LParam, GetRawInputDataEnum.INPUT, - IntPtr.Zero, ref size, API.RawInputHeaderSize); + Debug.WriteLine("Initializing windows raw input driver."); + Debug.Indent(); - //if (buffer == null || API.RawInputSize < size) - //{ - // throw new ApplicationException("Critical error when processing raw windows input."); - //} - if (size == Functions.GetRawInputData(msg.LParam, GetRawInputDataEnum.INPUT, - out data, ref size, API.RawInputHeaderSize)) - { - switch (data.Header.Type) - { - case RawInputDeviceType.KEYBOARD: - if (!keyboardDriver.ProcessKeyboardEvent(data)) - Functions.DefRawInputProc(ref data, 1, (uint)API.RawInputHeaderSize); - return; + // Create a new message-only window to retrieve WM_INPUT messages. + Native = new NativeWindow(); + Native.ProcessEvents(); + Functions.SetParent(Parent.WindowHandle, Constants.MESSAGE_ONLY); + Native.ProcessEvents(); - case RawInputDeviceType.MOUSE: - throw new NotSupportedException(); + // Subclass the window to retrieve the events we are interested in. + OldWndProc = Functions.SetWindowLong(Parent.WindowHandle, WndProc); - case RawInputDeviceType.HID: - Functions.DefRawInputProc(ref data, 1, (uint)API.RawInputHeaderSize); - return; + Debug.Print("Input window attached to parent {0}", Parent); + keyboardDriver = new WinRawKeyboard(Parent.WindowHandle); + mouseDriver = new WinRawMouse(Parent.WindowHandle); - default: - break; - } - } - else - { - throw new ApplicationException(String.Format( - "GetRawInputData returned invalid buffer. Windows error {0}. Please file a bug at http://opentk.sourceforge.net", - Marshal.GetLastWin32Error())); - } - break; - - case WindowMessage.DESTROY: - Debug.Print("Input window detached from parent {0}.", Handle); - ReleaseHandle(); - break; - - case WindowMessage.QUIT: - Debug.WriteLine("Input window quit."); - this.Dispose(); - break; - } - - base.WndProc(ref msg); + Debug.Unindent(); + return Native; } #endregion - #region --- IInputDriver Members --- + #region WindowProcedureImplementation + + // Processes the input Windows Message, routing the buffer to the correct Keyboard, Mouse or HID. + static IntPtr WindowProcedureImplementation(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam) + { + switch (message) + { + case WindowMessage.INPUT: + int size = 0; + // Get the size of the input buffer + Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, + IntPtr.Zero, ref size, API.RawInputHeaderSize); + + // Read the actual raw input structure + if (size == Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, + out data, ref size, API.RawInputHeaderSize)) + { + switch (data.Header.Type) + { + case RawInputDeviceType.KEYBOARD: + if (keyboardDriver.ProcessKeyboardEvent(data)) + return IntPtr.Zero; + break; + + case RawInputDeviceType.MOUSE: + if (mouseDriver.ProcessMouseEvent(data)) + return IntPtr.Zero; + break; + + case RawInputDeviceType.HID: + break; + } + } + break; + } + return Functions.CallWindowProc(OldWndProc, handle, message, wParam, lParam); + } + + #endregion + + #region ProcessEvents + + static void ProcessEvents() + { + INativeWindow native = ConstructMessageWindow(); + + MSG msg = new MSG(); + while (native.Exists) + { + int ret = Functions.GetMessage(ref msg, Parent.WindowHandle, 0, 0); + if (ret == -1) + { + throw new PlatformException(String.Format( + "An error happened while processing the message queue. Windows error: {0}", + Marshal.GetLastWin32Error())); + } + + Functions.TranslateMessage(ref msg); + Functions.DispatchMessage(ref msg); + } + } + + #endregion + + #endregion + + #region IInputDriver Members #region IInputDriver Members @@ -203,7 +257,7 @@ namespace OpenTK.Platform.Windows public IList Keyboard { - get { return keyboardDriver.Keyboard; } + get { return KeyboardDriver.Keyboard; } } public KeyboardState GetState() @@ -222,7 +276,7 @@ namespace OpenTK.Platform.Windows public IList Mouse { - get { return mouseDriver.Mouse; } + get { return MouseDriver.Mouse; } } MouseState IMouseDriver.GetState() @@ -248,7 +302,26 @@ namespace OpenTK.Platform.Windows #endregion - #region --- IDisposable Members --- + #region IInputDriver2 Members + + public IMouseDriver MouseDriver + { + get { return mouseDriver; } + } + + public IKeyboardDriver KeyboardDriver + { + get { return keyboardDriver; } + } + + public IJoystickDriver JoystickDriver + { + get { return joystickDriver; } + } + + #endregion + + #region IDisposable Members private bool disposed; @@ -265,7 +338,7 @@ namespace OpenTK.Platform.Windows if (manual) { keyboardDriver.Dispose(); - this.ReleaseHandle(); + //mouseDriver.Dispose(); } disposed = true; @@ -274,6 +347,7 @@ namespace OpenTK.Platform.Windows ~WinRawInput() { + Debug.Print("[Warning] Resource leaked: {0}.", this); Dispose(false); } diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index b4012dde..995d716e 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -1,7 +1,28 @@ -#region --- License --- -/* Copyright (c) 2007 Stefanos Apostolopoulos - * See license.txt for license info - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion #region --- Using directives --- diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index f242bd89..86ad4a33 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -1,7 +1,28 @@ -#region --- License --- -/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos - * See license.txt for license info - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion using System; @@ -22,25 +43,17 @@ namespace OpenTK.Platform.Windows { List mice; Dictionary rawids; // ContextHandle instead of IntPtr for fast dictionary access - readonly INativeWindow native; - readonly IntPtr window; - readonly WindowProcedure WndProc; - readonly IntPtr OldWndProc; + readonly IntPtr Window; - internal WinRawMouse() + public WinRawMouse(IntPtr window) { Debug.WriteLine("Initializing mouse driver (WinRawMouse)."); Debug.Indent(); - // Create a new message-only window to retrieve WM_INPUT messages. - native = new NativeWindow(); - window = (native.WindowInfo as WinWindowInfo).WindowHandle; - //Functions.SetParent(window, Constants.MESSAGE_ONLY); - // Subclass the window to retrieve the events we are interested in. - WndProc = WindowProcedure; - OldWndProc = Functions.SetWindowLong(window, WndProc); - native.ProcessEvents(); + if (window == IntPtr.Zero) + throw new ArgumentNullException("window"); + Window = window; RegisterDevices(window, out mice, out rawids); Debug.Unindent(); @@ -52,7 +65,6 @@ namespace OpenTK.Platform.Windows public MouseState GetState() { - native.ProcessEvents(); if (mice.Count > 0) return mice[0]; else @@ -61,7 +73,6 @@ namespace OpenTK.Platform.Windows public MouseState GetState(int index) { - native.ProcessEvents(); if (index < mice.Count) return mice[index]; else @@ -172,49 +183,14 @@ namespace OpenTK.Platform.Windows return state; } - IntPtr WindowProcedure(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam) - { - switch (message) - { - case WindowMessage.INPUT: - int expected_size = 0, real_size = 0; - RawInput data = new RawInput(); - - // Get the size of the input buffer - Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, - IntPtr.Zero, ref expected_size, API.RawInputHeaderSize); - - // Read the actual data - unsafe - { - real_size = Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, - &data, ref expected_size, API.RawInputHeaderSize); - } - - if (real_size == expected_size) - { - if (data.Header.Type == RawInputDeviceType.MOUSE) - { - if (ProcessEvent(data.Header.Device, data.Data.Mouse)) - { - return IntPtr.Zero; - } - } - } - // We didn't handle this message after all, give it back to the old WndProc. - goto default; - - default: - return Functions.CallWindowProc(OldWndProc, handle, message, wParam, lParam); - } - } - - bool ProcessEvent(IntPtr device, RawMouse raw) + public bool ProcessMouseEvent(RawInput rin) { if (mice.Count == 0) return false; - ContextHandle handle = new ContextHandle(device); + RawMouse raw = rin.Data.Mouse; + ContextHandle handle = new ContextHandle(rin.Header.Device); + MouseState mouse; if (rawids.ContainsKey(handle)) mouse = mice[rawids[handle]]; @@ -249,7 +225,5 @@ namespace OpenTK.Platform.Windows mice[rawids[handle]] = mouse; return true; } - - } } From 7c5d4fab58adf851b41cebfbeebe7b2789982e38 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 22 Oct 2010 15:03:06 +0000 Subject: [PATCH 029/130] Do not use deprecated methods. --- Source/Examples/OpenGL/1.x/VBODynamic.cs | 4 ++-- Source/Examples/OpenGL/2.x/GeometryShaderAdvanced.cs | 12 ++++++------ Source/Examples/OpenGL/2.x/SimpleGLSL.cs | 4 ++-- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/Source/Examples/OpenGL/1.x/VBODynamic.cs b/Source/Examples/OpenGL/1.x/VBODynamic.cs index 72d6bacc..d1831634 100644 --- a/Source/Examples/OpenGL/1.x/VBODynamic.cs +++ b/Source/Examples/OpenGL/1.x/VBODynamic.cs @@ -57,8 +57,8 @@ namespace Examples.Tutorial GL.Hint(HintTarget.PointSmoothHint, HintMode.Nicest); // Setup VBO state - GL.EnableClientState(EnableCap.ColorArray); - GL.EnableClientState(EnableCap.VertexArray); + GL.EnableClientState(ArrayCap.ColorArray); + GL.EnableClientState(ArrayCap.VertexArray); GL.GenBuffers(1, out VBOHandle); diff --git a/Source/Examples/OpenGL/2.x/GeometryShaderAdvanced.cs b/Source/Examples/OpenGL/2.x/GeometryShaderAdvanced.cs index 8935d340..c0457bcd 100644 --- a/Source/Examples/OpenGL/2.x/GeometryShaderAdvanced.cs +++ b/Source/Examples/OpenGL/2.x/GeometryShaderAdvanced.cs @@ -730,9 +730,9 @@ namespace Examples.Tutorial //GL.Arb.DrawArraysInstanced(BeginMode.Triangles, 0, cubeData.Length/8, 1); GL.DrawArrays(BeginMode.Triangles, 0, cubeData.Length / (vboCubeStride / sizeof(float))); - GL.DisableClientState(EnableCap.VertexArray); - GL.DisableClientState(EnableCap.NormalArray); - GL.DisableClientState(EnableCap.TextureCoordArray); + GL.DisableClientState(ArrayCap.VertexArray); + GL.DisableClientState(ArrayCap.NormalArray); + GL.DisableClientState(ArrayCap.TextureCoordArray); } void renderSphereVBO() @@ -753,9 +753,9 @@ namespace Examples.Tutorial //GL.Arb.DrawArraysInstanced(BeginMode.Triangles, 0, cubeData.Length/8, 1); //GL.DrawArrays(BeginMode.Triangles, 0, sphereData.Length / (vboSphereStride / sizeof(float))); - GL.DisableClientState(EnableCap.VertexArray); - GL.DisableClientState(EnableCap.NormalArray); - GL.DisableClientState(EnableCap.TextureCoordArray); + GL.DisableClientState(ArrayCap.VertexArray); + GL.DisableClientState(ArrayCap.NormalArray); + GL.DisableClientState(ArrayCap.TextureCoordArray); } void renderCubemap() diff --git a/Source/Examples/OpenGL/2.x/SimpleGLSL.cs b/Source/Examples/OpenGL/2.x/SimpleGLSL.cs index 8d55db3d..319ac663 100644 --- a/Source/Examples/OpenGL/2.x/SimpleGLSL.cs +++ b/Source/Examples/OpenGL/2.x/SimpleGLSL.cs @@ -261,8 +261,8 @@ namespace Examples.Tutorial //GL.DrawArrays(GL.Enums.BeginMode.POINTS, 0, shape.Vertices.Length); - GL.DisableClientState(EnableCap.VertexArray); - GL.DisableClientState(EnableCap.ColorArray); + GL.DisableClientState(ArrayCap.VertexArray); + GL.DisableClientState(ArrayCap.ColorArray); //int error = GL.GetError(); From 23b2cd74fde681071eea0b073dde6ea5e8524adc Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 22 Oct 2010 15:03:35 +0000 Subject: [PATCH 030/130] Suppressed unused field warnings. The code is like that on purpose. --- .../OpenTK/Test/BlittableValueTypes.cs | 94 ++++++++++--------- 1 file changed, 48 insertions(+), 46 deletions(-) diff --git a/Source/Examples/OpenTK/Test/BlittableValueTypes.cs b/Source/Examples/OpenTK/Test/BlittableValueTypes.cs index 3b0fab6e..2f7f2b15 100644 --- a/Source/Examples/OpenTK/Test/BlittableValueTypes.cs +++ b/Source/Examples/OpenTK/Test/BlittableValueTypes.cs @@ -1,44 +1,46 @@ // This code is in the Public Domain. It is provided "as is" -// without express or implied warranty of any kind. - -using System; -using System.Diagnostics; -using System.Reflection; -using OpenTK; - -namespace Examples.Tests -{ - struct Simple { public int Value; } - struct Generic { public T Value; } - enum Enum { First, Second } - struct Complex { public Simple Value; } - struct Complex { public Generic Value; } - struct Complex2 { public Enum Value; } - struct Complex3 { public Class Value; } - struct Complex4 : Interface { public Class Value; } - class Class { public int Value; } - class Class { public T Value; } - interface Interface { } - - [Example("Blittable Value Types", ExampleCategory.OpenTK, "Test", Documentation="BlittableValueTypes")] - public class BlittableValueTypes - { - public static void Main() - { - TestType(new Simple()); - TestType(new Generic()); - TestType(new Generic()); - TestType(new Complex()); - TestType(new Complex()); - TestType(new Complex2()); - TestType(new Complex3()); - TestType(new Complex4()); - TestType(new Class()); - TestType(new Class()); - } - - // Tests whether specified type is blittable and prints its marshalled size if so. - static void TestType(T instance) +// without express or implied warranty of any kind. + +using System; +using System.Diagnostics; +using System.Reflection; +using OpenTK; + +#pragma warning disable 0649 // Do not warn about unitialized fields, this is on purpose + +namespace Examples.Tests +{ + struct Simple { public int Value; } + struct Generic { public T Value; } + enum Enum { First, Second } + struct Complex { public Simple Value; } + struct Complex { public Generic Value; } + struct Complex2 { public Enum Value; } + struct Complex3 { public Class Value; } + struct Complex4 : Interface { public Class Value; } + class Class { public int Value; } + class Class { public T Value; } + interface Interface { } + + [Example("Blittable Value Types", ExampleCategory.OpenTK, "Test", Documentation="BlittableValueTypes")] + public class BlittableValueTypes + { + public static void Main() + { + TestType(new Simple()); + TestType(new Generic()); + TestType(new Generic()); + TestType(new Complex()); + TestType(new Complex()); + TestType(new Complex2()); + TestType(new Complex3()); + TestType(new Complex4()); + TestType(new Class()); + TestType(new Class()); + } + + // Tests whether specified type is blittable and prints its marshalled size if so. + static void TestType(T instance) { PrintType(); @@ -52,9 +54,9 @@ namespace Examples.Tests catch (Exception e) { Trace.Write(String.Format("({0})", e.GetType().Name)); - } - - Trace.WriteLine(""); + } + + Trace.WriteLine(""); } // Prints a simple description for the type. @@ -71,6 +73,6 @@ namespace Examples.Tests Trace.Write(typename.Substring(typename.LastIndexOf('.') + 1)); Trace.Write(" } "); - } - } -} + } + } +} From eb04d4996c768f9b8477287eef3c9c52cc738e48 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 22 Oct 2010 15:04:04 +0000 Subject: [PATCH 031/130] Avoid using deprecated GLControl.GrabScreenshot() method. --- .../OpenTK/GLControl/GLControlGameLoop.cs | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/Source/Examples/OpenTK/GLControl/GLControlGameLoop.cs b/Source/Examples/OpenTK/GLControl/GLControlGameLoop.cs index 816fb039..66b5bff5 100644 --- a/Source/Examples/OpenTK/GLControl/GLControlGameLoop.cs +++ b/Source/Examples/OpenTK/GLControl/GLControlGameLoop.cs @@ -66,7 +66,9 @@ namespace Examples.WinForms void glControl_KeyUp(object sender, KeyEventArgs e) { if (e.KeyCode == Keys.F12) - glControl.GrabScreenshot().Save("screenshot.png"); + { + GrabScreenshot().Save("screenshot.png"); + } } #endregion @@ -204,6 +206,23 @@ namespace Examples.WinForms #endregion + #region private void GrabScreenshot() + + Bitmap GrabScreenshot() + { + Bitmap bmp = new Bitmap(this.ClientSize.Width, this.ClientSize.Height); + System.Drawing.Imaging.BitmapData data = + bmp.LockBits(this.ClientRectangle, System.Drawing.Imaging.ImageLockMode.WriteOnly, + System.Drawing.Imaging.PixelFormat.Format24bppRgb); + GL.ReadPixels(0, 0, this.ClientSize.Width, this.ClientSize.Height, PixelFormat.Bgr, PixelType.UnsignedByte, + data.Scan0); + bmp.UnlockBits(data); + bmp.RotateFlip(RotateFlipType.RotateNoneFlipY); + return bmp; + } + + #endregion + #region public static void Main() /// From c9502aae544d565fbd5cf42debd2482c058fc7a8 Mon Sep 17 00:00:00 2001 From: chrisbrandtner Date: Sun, 24 Oct 2010 14:29:27 +0000 Subject: [PATCH 032/130] Added OpenGL Diagnostics program, similar to OpenAL Diagnostics. --- .../Examples/OpenGL/1.x/OpenGLDiagnostics.cs | 438 ++++++++++++++++++ .../Examples/OpenGL/1.x/OpenGLDiagnostics.rtf | Bin 0 -> 477 bytes Source/Examples/OpenTK.Examples.csproj | 2 + 3 files changed, 440 insertions(+) create mode 100644 Source/Examples/OpenGL/1.x/OpenGLDiagnostics.cs create mode 100644 Source/Examples/OpenGL/1.x/OpenGLDiagnostics.rtf diff --git a/Source/Examples/OpenGL/1.x/OpenGLDiagnostics.cs b/Source/Examples/OpenGL/1.x/OpenGLDiagnostics.cs new file mode 100644 index 00000000..429f4d9e --- /dev/null +++ b/Source/Examples/OpenGL/1.x/OpenGLDiagnostics.cs @@ -0,0 +1,438 @@ +using System; +using System.Drawing; +using System.Collections.Generic; +using System.Diagnostics; + +using OpenTK; +using OpenTK.Graphics; +using OpenTK.Graphics.OpenGL; +using OpenTK.Input; + +namespace Examples.Tutorial +{ + [Example( "OpenGL Diagnostics", ExampleCategory.OpenGL, "1.x", Documentation = "OpenGLDiagnostics" )] + + class GLDiagnostics : GameWindow + { + /// Creates a 800x600 window with the specified title. + public GLDiagnostics() + : base(80, 60, GraphicsMode.Default, "OpenTK Quick Start Sample", GameWindowFlags.Default, DisplayDevice.Default, 3, 1, GraphicsContextFlags.Default) + { + VSync = VSyncMode.On; + this.Context.ErrorChecking = false; + } + + struct TexFormat + { + public PixelInternalFormat pif; + public PixelFormat pf; + public PixelType pt; + + public TexFormat(PixelInternalFormat _pif, PixelFormat _pf, PixelType _pt) + { + pif = _pif; + pf = _pf; + pt = _pt; + } + } + + TexFormat[] TextureFormats = new TexFormat[] + { + new TexFormat( PixelInternalFormat.Alpha, PixelFormat.Alpha, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Alpha4, PixelFormat.Alpha, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Alpha8, PixelFormat.Alpha, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Alpha12, PixelFormat.Alpha, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Alpha16, PixelFormat.Alpha, PixelType.UnsignedByte), + new TexFormat( (PixelInternalFormat)All.Alpha16fArb, PixelFormat.Alpha, PixelType.HalfFloat), + new TexFormat( (PixelInternalFormat)All.Alpha32fArb, PixelFormat.Alpha, PixelType.Float), + + new TexFormat( PixelInternalFormat.DepthComponent, PixelFormat.DepthComponent, PixelType.Int), + new TexFormat( PixelInternalFormat.DepthComponent16, PixelFormat.DepthComponent, PixelType.Float), + new TexFormat( PixelInternalFormat.DepthComponent24, PixelFormat.DepthComponent, PixelType.Float), + new TexFormat( PixelInternalFormat.DepthComponent32, PixelFormat.DepthComponent, PixelType.Float), + new TexFormat( PixelInternalFormat.DepthComponent32f, PixelFormat.DepthComponent, PixelType.Float), + new TexFormat( PixelInternalFormat.DepthStencil, PixelFormat.DepthStencil, PixelType.UnsignedInt248), + new TexFormat( PixelInternalFormat.Depth24Stencil8, PixelFormat.DepthStencil, PixelType.UnsignedInt248), + new TexFormat( PixelInternalFormat.Depth32fStencil8, PixelFormat.DepthStencil, PixelType.Float32UnsignedInt248Rev), + + new TexFormat( PixelInternalFormat.One, PixelFormat.Red, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Two, PixelFormat.Rg, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rgb, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rgba, PixelFormat.Rgba, PixelType.UnsignedByte), + + new TexFormat( PixelInternalFormat.Srgb, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.SrgbAlpha, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Srgb8, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Srgb8Alpha8, PixelFormat.Rgba, PixelType.UnsignedByte), + + new TexFormat( PixelInternalFormat.R16f, PixelFormat.Red, PixelType.HalfFloat), + new TexFormat( PixelInternalFormat.Rg16f, PixelFormat.Rg, PixelType.HalfFloat), + new TexFormat( PixelInternalFormat.Rgb16f, PixelFormat.Rgb, PixelType.HalfFloat), + new TexFormat( PixelInternalFormat.Rgba16f, PixelFormat.Rgba, PixelType.HalfFloat), + new TexFormat( PixelInternalFormat.R32f, PixelFormat.Red, PixelType.Float), + new TexFormat( PixelInternalFormat.Rg32f, PixelFormat.Rg, PixelType.Float), + new TexFormat( PixelInternalFormat.Rgb32f, PixelFormat.Rgb, PixelType.Float), + new TexFormat( PixelInternalFormat.Rgba32f, PixelFormat.Rgba, PixelType.Float), + + new TexFormat( PixelInternalFormat.R8, PixelFormat.Red, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rg8, PixelFormat.Rg, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rgb8, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rgba8, PixelFormat.Rgba, PixelType.UnsignedByte), + + new TexFormat( PixelInternalFormat.R8ui, PixelFormat.Red, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rg8ui, PixelFormat.Rg, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rgb8ui, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rgba8ui, PixelFormat.Rgba, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.R16ui, PixelFormat.Red, PixelType.UnsignedShort), + new TexFormat( PixelInternalFormat.Rg16ui, PixelFormat.Rg, PixelType.UnsignedShort), + new TexFormat( PixelInternalFormat.Rgb16ui, PixelFormat.Rgb, PixelType.UnsignedShort), + new TexFormat( PixelInternalFormat.Rgba16ui, PixelFormat.Rgba, PixelType.UnsignedShort), + new TexFormat( PixelInternalFormat.R32ui, PixelFormat.Red, PixelType.UnsignedInt), + new TexFormat( PixelInternalFormat.Rg32ui, PixelFormat.Rg, PixelType.UnsignedInt), + new TexFormat( PixelInternalFormat.Rgb32ui, PixelFormat.Rgb, PixelType.UnsignedInt), + new TexFormat( PixelInternalFormat.Rgba32ui, PixelFormat.Rgba, PixelType.UnsignedInt), + + new TexFormat( PixelInternalFormat.R8i, PixelFormat.Red, PixelType.Byte), + new TexFormat( PixelInternalFormat.Rg8i, PixelFormat.Rg, PixelType.Byte), + new TexFormat( PixelInternalFormat.Rgb8i, PixelFormat.Rgb, PixelType.Byte), + new TexFormat( PixelInternalFormat.Rgba8i, PixelFormat.Rgba, PixelType.Byte), + new TexFormat( PixelInternalFormat.R16i, PixelFormat.Red, PixelType.Short), + new TexFormat( PixelInternalFormat.Rg16i, PixelFormat.Rg, PixelType.Short), + new TexFormat( PixelInternalFormat.Rgb16i, PixelFormat.Rgb, PixelType.Short), + new TexFormat( PixelInternalFormat.Rgba16i, PixelFormat.Rgba, PixelType.Short), + new TexFormat( PixelInternalFormat.R32i, PixelFormat.Red, PixelType.Int), + new TexFormat( PixelInternalFormat.Rg32i, PixelFormat.Rg, PixelType.Int), + new TexFormat( PixelInternalFormat.Rgb32i, PixelFormat.Rgb, PixelType.Int), + new TexFormat( PixelInternalFormat.Rgba32i, PixelFormat.Rgba, PixelType.Int), + + new TexFormat( PixelInternalFormat.R3G3B2, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rgb10A2, PixelFormat.Rgba, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rgb5A1, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.Rgb9E5, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.R11fG11fB10f, PixelFormat.Rgb, PixelType.UnsignedByte), + + new TexFormat( PixelInternalFormat.CompressedAlpha, PixelFormat.Alpha, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedIntensity, PixelFormat.Luminance, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedLuminance, PixelFormat.Luminance, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedLuminanceAlpha, PixelFormat.LuminanceAlpha, PixelType.UnsignedByte), + new TexFormat( (PixelInternalFormat)All.CompressedLuminanceLatc1Ext, PixelFormat.Luminance, PixelType.UnsignedByte), + new TexFormat( (PixelInternalFormat)All.CompressedLuminanceAlphaLatc2Ext, PixelFormat.LuminanceAlpha, PixelType.UnsignedByte), + + new TexFormat( PixelInternalFormat.CompressedRed, PixelFormat.Red, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedRedRgtc1, PixelFormat.Red, PixelType.UnsignedByte), + new TexFormat( (PixelInternalFormat)All.CompressedRedGreenRgtc2Ext, PixelFormat.Rg, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedRg, PixelFormat.Rg, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedRgRgtc2, PixelFormat.Rg, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedRgb, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( (PixelInternalFormat)All.CompressedRgbFxt13Dfx, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedRgba, PixelFormat.Rgba, PixelType.UnsignedByte), + new TexFormat( (PixelInternalFormat)All.CompressedRgbaFxt13Dfx, PixelFormat.Rgba, PixelType.UnsignedByte), + + new TexFormat( (PixelInternalFormat)All.CompressedSignedLuminanceAlphaLatc2Ext, PixelFormat.LuminanceAlpha, PixelType.UnsignedByte), + new TexFormat( (PixelInternalFormat)All.CompressedSignedLuminanceLatc1Ext, PixelFormat.Luminance, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedSignedRedRgtc1, PixelFormat.Red, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedSignedRgRgtc2, PixelFormat.Rg, PixelType.UnsignedByte), + + new TexFormat( PixelInternalFormat.CompressedSluminance, PixelFormat.Luminance, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedSluminanceAlpha, PixelFormat.LuminanceAlpha, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedSrgb, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedSrgbAlpha, PixelFormat.Rgba, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedSrgbS3tcDxt1Ext, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedSrgbAlphaS3tcDxt1Ext, PixelFormat.Rgba, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedSrgbAlphaS3tcDxt3Ext, PixelFormat.Rgba, PixelType.UnsignedByte), + new TexFormat( PixelInternalFormat.CompressedSrgbAlphaS3tcDxt5Ext, PixelFormat.Rgba, PixelType.UnsignedByte), + + new TexFormat( (PixelInternalFormat)All.CompressedRgbS3tcDxt1Ext, PixelFormat.Rgb, PixelType.UnsignedByte), + new TexFormat( (PixelInternalFormat)All.CompressedRgbaS3tcDxt1Ext, PixelFormat.Rgba, PixelType.UnsignedByte), + new TexFormat( (PixelInternalFormat)All.CompressedRgbaS3tcDxt3Ext, PixelFormat.Rgba, PixelType.UnsignedByte), + new TexFormat( (PixelInternalFormat)All.CompressedRgbaS3tcDxt5Ext, PixelFormat.Rgba, PixelType.UnsignedByte), + + }; + + #region GL.Get* Helper + + public enum eType + { + Boolean, + Int, + IntEnum, + IntArray2, + IntArray4, + Float, + FloatArray2, + FloatArray4, + } + + public void Analyze(GetPName pname, eType type) + { + bool result1b; + int result1i; + int[] result2i = new int[2]; + int[] result4i = new int[4]; + float result1f; + Vector2 result2f; + Vector4 result4f; + string output; + + switch (type) + { + case eType.Boolean: + GL.GetBoolean(pname, out result1b); + output = pname + ": " + result1b; + break; + case eType.Int: + GL.GetInteger(pname, out result1i); + output = pname + ": " + result1i; + break; + case eType.IntEnum: + GL.GetInteger(pname, out result1i); + output = pname + ": " + (All)result1i; + break; + case eType.IntArray2: + GL.GetInteger(pname, result2i); + output = pname + ": ( " + result2i[0] + ", " + result2i[1] + " )"; + break; + case eType.IntArray4: + GL.GetInteger(pname, result4i); + output = pname + ": ( " + result4i[0] + ", " + result4i[1] + " ) ( " + result4i[2] + ", " + result4i[3] + " )"; + break; + case eType.Float: + GL.GetFloat(pname, out result1f); + output = pname + ": " + result1f; + break; + case eType.FloatArray2: + GL.GetFloat(pname, out result2f); + output = pname + ": ( " + result2f.X + ", " + result2f.Y + " )"; + break; + case eType.FloatArray4: + GL.GetFloat(pname, out result4f); + output = pname + ": ( " + result4f.X + ", " + result4f.Y + ", " + result4f.Z + ", " + result4f.W + " )"; + break; + default: throw new NotImplementedException(); + } + + ErrorCode err = GL.GetError(); + if (err != ErrorCode.NoError) + Trace.WriteLine("Unsupported Token: " + pname); + else + Trace.WriteLine(output); + + } + + #endregion GL.Get* Helper + + /// Load resources here. + /// Not used. + protected override void OnLoad(EventArgs e) + { + base.OnLoad(e); + + GL.ClearColor(System.Drawing.Color.MidnightBlue); + GL.Enable(EnableCap.DepthTest); + + // returns 0 formats, driver broken? + /* + int CompressedTextureFormatCount; + GL.GetInteger(GetPName.NumCompressedTextureFormats, out CompressedTextureFormatCount); + if (CompressedTextureFormatCount > 0) + { + int[] CompressedTextureFormats = new int[CompressedTextureFormatCount]; + GL.GetInteger(GetPName.CompressedTextureFormats, CompressedTextureFormats); + Trace.WriteLine("Supported compressed Texture formats:"); + for (int i = 0; i < CompressedTextureFormats.Length; i++) + Trace.Write((All)CompressedTextureFormats[i] + ", "); + } + */ + + string Renderer = GL.GetString(StringName.Renderer); + string GLSLang = GL.GetString(StringName.ShadingLanguageVersion); + string Vendor = GL.GetString(StringName.Vendor); + string Version = GL.GetString(StringName.Version); + + string ExtensionsRaw = GL.GetString(StringName.Extensions); + string[] splitter = new string[] { " " }; + string[] Extensions = ExtensionsRaw.Split(splitter, StringSplitOptions.None); + + Trace.WriteLine("Vendor: " + Vendor); + Trace.WriteLine("Renderer: " + Renderer); + Trace.WriteLine("GL Version: " + Version); + Analyze(GetPName.MajorVersion, eType.Int); + Analyze(GetPName.MinorVersion, eType.Int); + Trace.WriteLine("GLSL Version: " + GLSLang); + Trace.WriteLine("Extensions: "); + for (int i = 0; i < Extensions.Length; i++) + Trace.WriteLine(Extensions[i]); + + Trace.WriteLine("--- Framebuffer ---"); + Analyze(GetPName.Doublebuffer, eType.Boolean); + Analyze(GetPName.MaxColorAttachments, eType.Int); + Analyze(GetPName.MaxDrawBuffers, eType.Int); + Analyze(GetPName.AuxBuffers, eType.Int); + Analyze(GetPName.DrawBuffer, eType.IntEnum); + Analyze(GetPName.MaxSamples, eType.Int); + Analyze(GetPName.MaxViewportDims, eType.IntArray2); + Analyze(GetPName.Viewport, eType.IntArray4); + + Trace.WriteLine("--- Framebuffer channels ---"); + Analyze(GetPName.RedBits, eType.Int); + Analyze(GetPName.GreenBits, eType.Int); + Analyze(GetPName.BlueBits, eType.Int); + Analyze(GetPName.AlphaBits, eType.Int); + Analyze(GetPName.DepthBits, eType.Int); + Analyze(GetPName.StencilBits, eType.Int); + + Analyze(GetPName.AccumRedBits, eType.Int); + Analyze(GetPName.AccumGreenBits, eType.Int); + Analyze(GetPName.AccumBlueBits, eType.Int); + Analyze(GetPName.AccumAlphaBits, eType.Int); + + Trace.WriteLine("--- Textures ---"); + Analyze(GetPName.MaxCombinedTextureImageUnits, eType.Int); + Analyze(GetPName.MaxVertexTextureImageUnits, eType.Int); + Analyze(GetPName.MaxTextureImageUnits, eType.Int); + Analyze(GetPName.MaxTextureUnits, eType.Int); + Analyze(GetPName.MaxTextureSize, eType.Int); + Analyze(GetPName.Max3DTextureSize, eType.Int); + Analyze(GetPName.MaxCubeMapTextureSize, eType.Int); + Analyze(GetPName.MaxRenderbufferSize, eType.Int); + Analyze(GetPName.MaxTextureLodBias, eType.Int); + + Queue Supported = new Queue(); + Queue Unsupported = new Queue(); + + uint DummyTexture; + foreach (TexFormat t in TextureFormats) + { + GL.GenTextures(1, out DummyTexture); + GL.BindTexture(TextureTarget.Texture2D, DummyTexture); + GL.TexImage2D(TextureTarget.Texture2D, 0, t.pif, 4, 4, 0, t.pf, t.pt, IntPtr.Zero); + if (GL.GetError() == ErrorCode.NoError) + Supported.Enqueue(t); + else + Unsupported.Enqueue(t); + GL.DeleteTextures(1, ref DummyTexture); + } + GL.BindTexture(TextureTarget.Texture2D, 0); + + Trace.WriteLine("--- UN-supported Texture formats ---"); + while (Unsupported.Count > 0) + { + TexFormat tex = Unsupported.Dequeue(); + Trace.Write((All)tex.pif+", "); + } + Trace.WriteLine( " " ); + + Trace.WriteLine("--- SUPPORTED Texture formats ---"); + while (Supported.Count > 0) + { + TexFormat tex = Supported.Dequeue(); + Trace.WriteLine((All)tex.pif+" " +tex.pf + " "+tex.pt); + } + Trace.WriteLine(" "); + + Trace.WriteLine("--- Point&Line volumes ---"); + Analyze(GetPName.AliasedPointSizeRange, eType.FloatArray2); + Analyze(GetPName.PointSizeMin, eType.Float); + Analyze(GetPName.PointSizeMax, eType.Float); + Analyze(GetPName.PointSizeGranularity, eType.Float); + Analyze(GetPName.PointSizeRange, eType.FloatArray2); + + Analyze(GetPName.AliasedLineWidthRange, eType.FloatArray2); + Analyze(GetPName.LineWidthGranularity, eType.Float); + Analyze(GetPName.LineWidthRange, eType.FloatArray2); + + Trace.WriteLine("--- VBO ---"); + Analyze(GetPName.MaxElementsIndices, eType.Int); + Analyze(GetPName.MaxElementsVertices, eType.Int); + Analyze(GetPName.MaxVertexAttribs, eType.Int); + + Trace.WriteLine("--- GLSL ---"); + Analyze(GetPName.MaxCombinedFragmentUniformComponents, eType.Int); + Analyze(GetPName.MaxCombinedGeometryUniformComponents, eType.Int); + Analyze(GetPName.MaxCombinedVertexUniformComponents, eType.Int); + Analyze(GetPName.MaxFragmentUniformComponents, eType.Int); + Analyze(GetPName.MaxVertexUniformComponents, eType.Int); + + Analyze(GetPName.MaxCombinedUniformBlocks, eType.Int); + Analyze(GetPName.MaxFragmentUniformBlocks, eType.Int); + Analyze(GetPName.MaxGeometryUniformBlocks, eType.Int); + Analyze(GetPName.MaxVertexUniformBlocks, eType.Int); + Analyze(GetPName.MaxUniformBlockSize, eType.Int); + Analyze(GetPName.MaxUniformBufferBindings, eType.Int); + + Analyze(GetPName.MaxVaryingFloats, eType.Int); + + Trace.WriteLine("--- Transform Feedback ---"); + Analyze(GetPName.MaxTransformFeedbackInterleavedComponents, eType.Int); + Analyze(GetPName.MaxTransformFeedbackSeparateAttribs, eType.Int); + Analyze(GetPName.MaxTransformFeedbackSeparateComponents, eType.Int); + + Trace.WriteLine("--- Fixed-Func Stacks, GL.Push* and GL.Pop* ---"); + Analyze(GetPName.MaxClientAttribStackDepth, eType.Int); + Analyze(GetPName.MaxAttribStackDepth, eType.Int); + Analyze(GetPName.MaxProjectionStackDepth, eType.Int); + Analyze(GetPName.MaxModelviewStackDepth, eType.Int); + Analyze(GetPName.MaxTextureStackDepth, eType.Int); + Analyze(GetPName.MaxNameStackDepth, eType.Int); + + Trace.WriteLine("--- Fixed-Func misc. stuff ---"); + Analyze(GetPName.MaxEvalOrder, eType.Int); + Analyze(GetPName.MaxClipPlanes, eType.Int); + Analyze(GetPName.MaxArrayTextureLayers, eType.Int); + Analyze(GetPName.MaxListNesting, eType.Int); + Analyze(GetPName.MaxLights, eType.Int); + Analyze(GetPName.MaxTextureCoords, eType.Int); + + this.Exit(); + } + + /// + /// Called when your window is resized. Set your viewport here. It is also + /// a good place to set up your projection matrix (which probably changes + /// along when the aspect ratio of your window). + /// + /// Not used. + protected override void OnResize(EventArgs e) + { + base.OnResize(e); + + GL.Viewport(ClientRectangle); + } + + /// + /// Called when it is time to setup the next frame. Add you game logic here. + /// + /// Contains timing information for framerate independent logic. + protected override void OnUpdateFrame(FrameEventArgs e) + { + base.OnUpdateFrame(e); + + if (Keyboard[Key.Escape]) + Exit(); + } + + /// + /// Called when it is time to render the next frame. Add your rendering code here. + /// + /// Contains timing information. + protected override void OnRenderFrame(FrameEventArgs e) + { + base.OnRenderFrame(e); + } + + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + // The 'using' idiom guarantees proper resource cleanup. + // We request 30 UpdateFrame events per second, and unlimited + // RenderFrame events (as fast as the computer can handle). + using (GLDiagnostics game = new GLDiagnostics()) + { + game.Run(10.0); + } + } + } +} \ No newline at end of file diff --git a/Source/Examples/OpenGL/1.x/OpenGLDiagnostics.rtf b/Source/Examples/OpenGL/1.x/OpenGLDiagnostics.rtf new file mode 100644 index 0000000000000000000000000000000000000000..662fae65ad27848081e5929388d0fb6f5f870321 GIT binary patch literal 477 zcmYk2Piw<448?aY>^tbZLrBtgZ1gmC7=!&g?5K;A$cd>VXR^Gmlz#WQO$P%bWc>5f zdpe+~tqf80o&k%WDYhc z)K#}j?1hNy3LBrOt~O`t276)>qe0*`TBXh@tcz7u)cLH-`^^!*9qqP`yA`Ik!pTU7 zZT9C4_f@%EVuLo;cks+Ap-Zj0z}RGOv93?_^ Code + Code @@ -543,6 +544,7 @@ Always + From ceca4403adf90735b095f341c932d62060109b32 Mon Sep 17 00:00:00 2001 From: chrisbrandtner Date: Wed, 27 Oct 2010 16:28:38 +0000 Subject: [PATCH 033/130] Added anaglyph rendering example (for red/cyan glasses). --- Source/Examples/OpenGL/1.x/Anaglyph.cs | 204 ++++++++++++++++++++++++ Source/Examples/OpenGL/1.x/Anaglyph.rtf | Bin 0 -> 686 bytes Source/Examples/OpenTK.Examples.csproj | 6 +- 3 files changed, 209 insertions(+), 1 deletion(-) create mode 100644 Source/Examples/OpenGL/1.x/Anaglyph.cs create mode 100644 Source/Examples/OpenGL/1.x/Anaglyph.rtf diff --git a/Source/Examples/OpenGL/1.x/Anaglyph.cs b/Source/Examples/OpenGL/1.x/Anaglyph.cs new file mode 100644 index 00000000..b433987b --- /dev/null +++ b/Source/Examples/OpenGL/1.x/Anaglyph.cs @@ -0,0 +1,204 @@ +using System; +using System.Drawing; +using System.Collections.Generic; +using System.Diagnostics; + +using OpenTK; +using OpenTK.Graphics; +using OpenTK.Graphics.OpenGL; +using OpenTK.Input; + +namespace Examples.Tutorial +{ + [Example( "Anaglyph Stereo", ExampleCategory.OpenGL, "1.x", Documentation = "Anaglyph" )] + + class Anaglyph : GameWindow + { + + Examples.Shapes.DrawableShape Object; + + /// Creates a 800x600 window with the specified title. + public Anaglyph() + : base(800, 600, GraphicsMode.Default, "OpenTK Quick Start Sample", GameWindowFlags.Default, DisplayDevice.Default, 3, 1, GraphicsContextFlags.Default) + { + VSync = VSyncMode.On; + } + + /// Load resources here. + /// Not used. + protected override void OnLoad(EventArgs e) + { + base.OnLoad(e); + + GL.ClearColor(System.Drawing.Color.Black); + GL.Enable(EnableCap.DepthTest); + + GL.Enable( EnableCap.Lighting ); + GL.Enable( EnableCap.Light0 ); + + Object = new Examples.Shapes.MengerSponge(1.0, Shapes.MengerSponge.eSubdivisions.Two, true ); + // Object = new Examples.Shapes.TorusKnot( 256, 32, 0.1, 3, 4, 1, true ); + } + + protected override void OnUnload( EventArgs e ) + { + base.OnUnload( e ); + + Object.Dispose(); + } + + /// + /// Called when your window is resized. Set your viewport here. It is also + /// a good place to set up your projection matrix (which probably changes + /// along when the aspect ratio of your window). + /// + /// Not used. + protected override void OnResize(EventArgs e) + { + base.OnResize(e); + + GL.Viewport(ClientRectangle); + } + + /// + /// Called when it is time to setup the next frame. Add you game logic here. + /// + /// Contains timing information for framerate independent logic. + protected override void OnUpdateFrame(FrameEventArgs e) + { + base.OnUpdateFrame(e); + + if (Keyboard[Key.Escape]) + Exit(); + } + + struct Camera + { + public Vector3 Position, Direction, Up; + public double NearPlane, FarPlane; + public double EyeSeparation; + public double Aperture; // FOV in degrees + public double FocalLength; + } + + enum Eye + { + left, + right, + } + + void SetupCamera( Eye eye ) + { + Camera camera; + + camera.Position = Vector3.UnitZ; + camera.Up = Vector3.UnitY; + camera.Direction = -Vector3.UnitZ; + camera.NearPlane = 1.0; + camera.FarPlane = 5.0; + camera.FocalLength = 2.0; + camera.EyeSeparation = camera.FocalLength / 30.0; + camera.Aperture = 75.0; + + double left, right, + bottom, top; + + double widthdiv2 = camera.NearPlane * Math.Tan( MathHelper.DegreesToRadians( (float)( camera.Aperture / 2.0 ) ) ); // aperture in radians + double precalc1 = ClientRectangle.Width / (double)ClientRectangle.Height * widthdiv2; + double precalc2 = 0.5 * camera.EyeSeparation * camera.NearPlane / camera.FocalLength; + + Vector3 Right = Vector3.Cross( camera.Direction, camera.Up ); // Each unit vectors + Right.Normalize(); + + Right.X *= (float)( camera.EyeSeparation / 2.0 ); + Right.Y *= (float)( camera.EyeSeparation / 2.0 ); + Right.Z *= (float)( camera.EyeSeparation / 2.0 ); + + // Projection Matrix + top = widthdiv2; + bottom = -widthdiv2; + if ( eye == Eye.right ) + { + left = -precalc1 - precalc2; + right = precalc1 - precalc2; + } + else + { + left = -precalc1 + precalc2; + right = precalc1 + precalc2; + } + + GL.MatrixMode( MatrixMode.Projection ); + GL.LoadIdentity(); + GL.Frustum( left, right, bottom, top, camera.NearPlane, camera.FarPlane ); + + // Modelview Matrix + Matrix4 modelview; + if ( eye == Eye.right ) + { + modelview = Matrix4.LookAt( + new Vector3( camera.Position.X + Right.X, camera.Position.Y + Right.Y, camera.Position.Z + Right.Z ), + new Vector3( camera.Position.X + Right.X + camera.Direction.X, camera.Position.Y + Right.Y + camera.Direction.Y, camera.Position.Z + Right.Z + camera.Direction.Z ), + camera.Up ); + } + else + { + modelview = Matrix4.LookAt( + new Vector3( camera.Position.X - Right.X, camera.Position.Y - Right.Y, camera.Position.Z - Right.Z ), + new Vector3( camera.Position.X - Right.X + camera.Direction.X, camera.Position.Y - Right.Y + camera.Direction.Y, camera.Position.Z - Right.Z + camera.Direction.Z ), + camera.Up ); + } + GL.MatrixMode( MatrixMode.Modelview ); + GL.LoadIdentity(); + GL.MultMatrix( ref modelview ); + + } + + float Angle; + + void Draw() + { + GL.Translate( 0f, 0f, -2f ); + GL.Rotate( Angle, Vector3.UnitY ); + Object.Draw(); + } + + /// + /// Called when it is time to render the next frame. Add your rendering code here. + /// + /// Contains timing information. + protected override void OnRenderFrame( FrameEventArgs e ) + { + Angle += (float)(e.Time *20.0); + + + GL.Clear( ClearBufferMask.DepthBufferBit | ClearBufferMask.ColorBufferBit ); + SetupCamera( Eye.right ); + GL.ColorMask( true, false, false, true ); + Draw(); + + GL.Clear( ClearBufferMask.DepthBufferBit ); // + SetupCamera( Eye.left ); + GL.ColorMask( false, true, true, true ); + Draw(); + + GL.ColorMask( true, true, true, true ); + SwapBuffers(); + } + + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + // The 'using' idiom guarantees proper resource cleanup. + // We request 30 UpdateFrame events per second, and unlimited + // RenderFrame events (as fast as the computer can handle). + using (Anaglyph game = new Anaglyph()) + { + game.Run(10.0); + } + } + } +} \ No newline at end of file diff --git a/Source/Examples/OpenGL/1.x/Anaglyph.rtf b/Source/Examples/OpenGL/1.x/Anaglyph.rtf new file mode 100644 index 0000000000000000000000000000000000000000..07ab7750d77a7a395ded8cb4c9b78bffd86099f6 GIT binary patch literal 686 zcmb_aU27FF5cRpx|1k8i5BqhyqTVMF!J-zCz7*zVHks^(rpb~?T+6clc60A4>bnqz z*mF?x*mnH^H5=2cXo62^aOKjV@z$YH6Gh?Fz}sla9k=cBVnr2P zh=m77jI7(22OJ}_?^+yO=B_=%%?>s@*7wJA>NSq+IZ_G{K8s1LZGyhKX{)ZBzIlDz z@SEl3(RzJ@S+zJ*)ToMRM}BOZ!vP00(!GLPpJLEiB^x{rMX+?;iG6vo$NR|&@OOHe z9fM3^5hwvtfXH5R1oAYx=XnB2967*DHVT-cEDOV8(^QxmYEaMQVRR(IQo;RHK6wzE z7&MEDc3^>2P^+0>;HhYbV#}7K$dn2zk#!aPt*%%)HQch(D_)~<+ImUrhlelkzka&C z`v_N4O7ok#c0rM=7LvKj3stOhMY;Yl4)>a*lzz_*|8X${A$KOgS!i!tNo*F%Zs1x0Q4>Z literal 0 HcmV?d00001 diff --git a/Source/Examples/OpenTK.Examples.csproj b/Source/Examples/OpenTK.Examples.csproj index 9254124a..20ca3931 100644 --- a/Source/Examples/OpenTK.Examples.csproj +++ b/Source/Examples/OpenTK.Examples.csproj @@ -143,7 +143,10 @@ Code - + + + Code + Code @@ -545,6 +548,7 @@ Always + From 7c78cc4205b0755137d6be3ac5924e3021425cd6 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 08:12:24 +0000 Subject: [PATCH 034/130] Fixed ref overloads of GenSources and GenBuffers to follow the rest of the OpenTK design. Fixes invalid return values on x64 systems. --- Source/OpenTK/Audio/OpenAL/AL/AL.cs | 60 +++++++++++++++++++++++++---- 1 file changed, 52 insertions(+), 8 deletions(-) diff --git a/Source/OpenTK/Audio/OpenAL/AL/AL.cs b/Source/OpenTK/Audio/OpenAL/AL/AL.cs index 295756d0..ae180ccc 100644 --- a/Source/OpenTK/Audio/OpenAL/AL/AL.cs +++ b/Source/OpenTK/Audio/OpenAL/AL/AL.cs @@ -1272,15 +1272,37 @@ namespace OpenTK.Audio.OpenAL /// This function generates one or more buffers, which contain audio buffer (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). /// The number of buffers to be generated. /// Pointer to an array of uint values which will store the names of the new buffers. - [CLSCompliant(false)] [DllImport(AL.Lib, EntryPoint = "alGenBuffers", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity] - public static extern void GenBuffers(int n, out uint buffers); + unsafe public static extern void GenBuffers(int n, [Out] int* buffers); /// This function generates one or more buffers, which contain audio buffer (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). /// The number of buffers to be generated. /// Pointer to an array of uint values which will store the names of the new buffers. - [DllImport(AL.Lib, EntryPoint = "alGenBuffers", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity] - public static extern void GenBuffers(int n, out int buffers); + [CLSCompliant(false)] + public static void GenBuffers(int n, out uint buffers) + { + unsafe + { + fixed (uint* pbuffers = &buffers) + { + GenBuffers(n, pbuffers); + } + } + } + + /// This function generates one or more buffers, which contain audio buffer (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). + /// The number of buffers to be generated. + /// Pointer to an array of uint values which will store the names of the new buffers. + public static void GenBuffers(int n, out int buffers) + { + unsafe + { + fixed (int* pbuffers = &buffers) + { + GenBuffers(n, pbuffers); + } + } + } /// This function generates one or more buffers, which contain audio data (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). /// The number of buffers to be generated. @@ -1324,15 +1346,37 @@ namespace OpenTK.Audio.OpenAL /// This function deletes one or more buffers, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. /// The number of buffers to be deleted. /// Pointer to an array of buffer names identifying the buffers to be deleted. - [CLSCompliant(false)] [DllImport(AL.Lib, EntryPoint = "alDeleteBuffers", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] - public static extern void DeleteBuffers(int n, [In] ref uint buffers); + unsafe public static extern void DeleteBuffers(int n, [In] int* buffers); /// This function deletes one or more buffers, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. /// The number of buffers to be deleted. /// Pointer to an array of buffer names identifying the buffers to be deleted. - [DllImport(AL.Lib, EntryPoint = "alDeleteBuffers", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] - public static extern void DeleteBuffers(int n, [In] ref int buffers); + [CLSCompliant(false)] + public static void DeleteBuffers(int n, [In] ref uint buffers) + { + unsafe + { + fixed (uint* pbuffers = &buffers) + { + DeleteBuffers(n, pbuffers); + } + } + } + + /// This function deletes one or more buffers, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. + /// The number of buffers to be deleted. + /// Pointer to an array of buffer names identifying the buffers to be deleted. + public static void DeleteBuffers(int n, [In] ref int buffers) + { + unsafe + { + fixed (int* pbuffers = &buffers) + { + DeleteBuffers(n, pbuffers); + } + } + } /// This function deletes one buffer only, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. /// Pointer to a buffer name identifying the buffer to be deleted. From 76db3e188f621ffe0a7b547faacce973de396277 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 08:13:42 +0000 Subject: [PATCH 035/130] Minor fixes for code clarity. --- Source/OpenTK/Platform/Windows/WinRawMouse.cs | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index 86ad4a33..ed614dfe 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -73,7 +73,7 @@ namespace OpenTK.Platform.Windows public MouseState GetState(int index) { - if (index < mice.Count) + if (mice.Count > index) return mice[index]; else return new MouseState(); @@ -192,10 +192,12 @@ namespace OpenTK.Platform.Windows ContextHandle handle = new ContextHandle(rin.Header.Device); MouseState mouse; - if (rawids.ContainsKey(handle)) - mouse = mice[rawids[handle]]; - else - return false; + if (!rawids.ContainsKey(handle)) + { + mice.Add(new MouseState()); + rawids.Add(handle, mice.Count - 1); + } + mouse = mice[rawids[handle]]; if ((raw.ButtonFlags & RawInputMouseState.LEFT_BUTTON_DOWN) != 0) mouse.EnableBit((int)MouseButton.Left); if ((raw.ButtonFlags & RawInputMouseState.LEFT_BUTTON_UP) != 0) mouse.DisableBit((int)MouseButton.Left); From 821a8e11175c6f402a476dbc4fef75efc64b169c Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 08:14:28 +0000 Subject: [PATCH 036/130] Always validate parameters to ReadBit/EnableBit/DisableBit before using them. --- Source/OpenTK/Input/KeyboardState.cs | 37 +++++++++++++++++++- Source/OpenTK/Input/MouseState.cs | 50 ++++++++++++++++++++-------- 2 files changed, 72 insertions(+), 15 deletions(-) diff --git a/Source/OpenTK/Input/KeyboardState.cs b/Source/OpenTK/Input/KeyboardState.cs index 91c019a8..612dc963 100644 --- a/Source/OpenTK/Input/KeyboardState.cs +++ b/Source/OpenTK/Input/KeyboardState.cs @@ -39,7 +39,8 @@ namespace OpenTK.Input #region Fields // Allocate enough ints to store all keyboard keys - const int NumInts = ((int)Key.LastKey + 31) / 32; + const int IntSize = sizeof(int); + const int NumInts = ((int)Key.LastKey + IntSize - 1) / IntSize; // The following line triggers bogus CS0214 in gmcs 2.0.1, sigh... unsafe fixed int Keys[NumInts]; @@ -47,6 +48,24 @@ namespace OpenTK.Input #region Public Members + /// + /// Gets a indicating whether the specified + /// is pressed. + /// + /// The to check. + /// True if key is pressed; false otherwise. + public bool this[Key key] + { + get { return IsKeyDown(key); } + internal set + { + if (value) + EnableBit((int)key); + else + DisableBit((int)key); + } + } + /// /// Gets a indicating whether this key is down. /// @@ -71,6 +90,8 @@ namespace OpenTK.Input internal bool ReadBit(int offset) { + ValidateOffset(offset); + int int_offset = offset / 32; int bit_offset = offset % 32; unsafe @@ -84,6 +105,8 @@ namespace OpenTK.Input internal void EnableBit(int offset) { + ValidateOffset(offset); + int int_offset = offset / 32; int bit_offset = offset % 32; unsafe @@ -97,6 +120,8 @@ namespace OpenTK.Input internal void DisableBit(int offset) { + ValidateOffset(offset); + int int_offset = offset / 32; int bit_offset = offset % 32; unsafe @@ -110,6 +135,16 @@ namespace OpenTK.Input #endregion + #region Private Members + + static void ValidateOffset(int offset) + { + if (offset < 0 || offset >= NumInts * IntSize) + throw new ArgumentOutOfRangeException("offset"); + } + + #endregion + #region IEquatable Members /// diff --git a/Source/OpenTK/Input/MouseState.cs b/Source/OpenTK/Input/MouseState.cs index e0b5b458..a4449aad 100644 --- a/Source/OpenTK/Input/MouseState.cs +++ b/Source/OpenTK/Input/MouseState.cs @@ -39,7 +39,8 @@ namespace OpenTK.Input #region Fields // Allocate enough ints to store all mouse buttons - const int NumInts = ((int)MouseButton.LastButton + 31) / 32; + const int IntSize = sizeof(int); + const int NumInts = ((int)MouseButton.LastButton + IntSize - 1) / IntSize; // The following line triggers bogus CS0214 in gmcs 2.0.1, sigh... unsafe fixed int Buttons[NumInts]; int x, y; @@ -49,6 +50,24 @@ namespace OpenTK.Input #region Public Members + /// + /// Gets a indicating whether the specified + /// is pressed. + /// + /// The to check. + /// True if key is pressed; false otherwise. + public bool this[MouseButton button] + { + get { return IsButtonDown(button); } + internal set + { + if (value) + EnableBit((int)button); + else + DisableBit((int)button); + } + } + /// /// Gets a indicating whether this button is down. /// @@ -106,19 +125,6 @@ namespace OpenTK.Input internal set { y = value; } } - /// - /// Gets a System.Boolean indicating the state of the specified MouseButton. - /// - /// The MouseButton to check. - /// True if the MouseButton is pressed, false otherwise. - public bool this[MouseButton button] - { - get - { - return IsButtonDown(button); - } - } - /// /// Gets a = NumInts * IntSize) + throw new ArgumentOutOfRangeException("offset"); + } + + #endregion + #region IEquatable Members /// From 22ae245306deb04703756b8d834aa590c0374f78 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 08:14:39 +0000 Subject: [PATCH 037/130] Do not rebuild documentation file on each build. OpenTK.Compatibility is not developed anymore, so we can just cache the last documentation file to speed up builds significantly. --- .../Compatibility/OpenTK.Compatibility.csproj | 9 +- Source/Compatibility/OpenTK.Compatibility.xml | 105220 +++++++++++++++ 2 files changed, 105226 insertions(+), 3 deletions(-) create mode 100644 Source/Compatibility/OpenTK.Compatibility.xml diff --git a/Source/Compatibility/OpenTK.Compatibility.csproj b/Source/Compatibility/OpenTK.Compatibility.csproj index 6a47f980..3815374e 100644 --- a/Source/Compatibility/OpenTK.Compatibility.csproj +++ b/Source/Compatibility/OpenTK.Compatibility.csproj @@ -47,7 +47,8 @@ DEBUG;TRACE; - OpenTK.Compatibility.xml + + true 4096 false @@ -65,7 +66,8 @@ TRACE; - OpenTK.Compatibility.xml + + 4096 true ..\..\Binaries\OpenTK\Release\ @@ -85,7 +87,8 @@ TRACE; - OpenTK.Compatibility.xml + + 4096 true ..\..\Binaries\OpenTK\Release\ diff --git a/Source/Compatibility/OpenTK.Compatibility.xml b/Source/Compatibility/OpenTK.Compatibility.xml new file mode 100644 index 00000000..1d6b86b7 --- /dev/null +++ b/Source/Compatibility/OpenTK.Compatibility.xml @@ -0,0 +1,105220 @@ + + + + OpenTK.Compatibility + + + + The X-Ram Extension is provided on the top-end Sound Blaster X-Fi solutions (Sound Blaster X-Fi Fatal1ty, Sound Blaster X-Fi Elite Pro, or later). These products feature 64MB of X-Ram that can only be used for audio purposes, which can be controlled by this Extension. + + + This function is used to set the storage Mode of an array of OpenAL Buffers. + The number of OpenAL Buffers pointed to by buffer. + An array of OpenAL Buffer handles. + The storage mode that should be used for all the given buffers. Should be the value of one of the following enum names: XRamStorage.Automatic, XRamStorage.Hardware, XRamStorage.Accessible + True if all the Buffers were successfully set to the requested storage mode, False otherwise. + + + This function is used to set the storage Mode of an array of OpenAL Buffers. + The number of OpenAL Buffers pointed to by buffer. + An array of OpenAL Buffer handles. + The storage mode that should be used for all the given buffers. Should be the value of one of the following enum names: XRamStorage.Automatic, XRamStorage.Hardware, XRamStorage.Accessible + True if all the Buffers were successfully set to the requested storage mode, False otherwise. + + + This function is used to retrieve the storage Mode of a single OpenAL Buffer. + The handle of an OpenAL Buffer. + The current Mode of the Buffer. + + + This function is used to retrieve the storage Mode of a single OpenAL Buffer. + The handle of an OpenAL Buffer. + The current Mode of the Buffer. + + + Returns True if the X-Ram Extension has been found and could be initialized. + + + Query total amount of X-RAM in bytes. + + + Query free X-RAM available in bytes. + + + This enum is used to abstract the need of using AL.GetEnumValue() with the Extension. The values do NOT correspond to AL_STORAGE_* tokens! + + + Put an Open AL Buffer into X-RAM if memory is available, otherwise use host RAM. This is the default mode. + + + Force an Open AL Buffer into X-RAM, good for non-streaming buffers. + + + Force an Open AL Buffer into 'accessible' (currently host) RAM, good for streaming buffers. + + + Alc = Audio Library Context + + + This function creates a context using a specified device. + a pointer to a device + a pointer to a set of attributes: ALC_FREQUENCY, ALC_MONO_SOURCES, ALC_REFRESH, ALC_STEREO_SOURCES, ALC_SYNC + Returns a pointer to the new context (NULL on failure). The attribute list can be NULL, or a zero terminated list of integer pairs composed of valid ALC attribute tokens and requested values. + + + This function creates a context using a specified device. + a pointer to a device + an array of a set of attributes: ALC_FREQUENCY, ALC_MONO_SOURCES, ALC_REFRESH, ALC_STEREO_SOURCES, ALC_SYNC + Returns a pointer to the new context (NULL on failure). + The attribute list can be NULL, or a zero terminated list of integer pairs composed of valid ALC attribute tokens and requested values. + + + This function makes a specified context the current context. + A pointer to the new context. + Returns True on success, or False on failure. + + + This function tells a context to begin processing. When a context is suspended, changes in OpenAL state will be accepted but will not be processed. alcSuspendContext can be used to suspend a context, and then all the OpenAL state changes can be applied at once, followed by a call to alcProcessContext to apply all the state changes immediately. In some cases, this procedure may be more efficient than application of properties in a non-suspended state. In some implementations, process and suspend calls are each a NOP. + a pointer to the new context + + + This function suspends processing on a specified context. When a context is suspended, changes in OpenAL state will be accepted but will not be processed. A typical use of alcSuspendContext would be to suspend a context, apply all the OpenAL state changes at once, and then call alcProcessContext to apply all the state changes at once. In some cases, this procedure may be more efficient than application of properties in a non-suspended state. In some implementations, process and suspend calls are each a NOP. + a pointer to the context to be suspended. + + + This function destroys a context. + a pointer to the new context. + + + This function retrieves the current context. + Returns a pointer to the current context. + + + This function retrieves a context's device pointer. + a pointer to a context. + Returns a pointer to the specified context's device. + + + This function opens a device by name. + a null-terminated string describing a device. + Returns a pointer to the opened device. The return value will be NULL if there is an error. + + + This function closes a device by name. + a pointer to an opened device + True will be returned on success or False on failure. Closing a device will fail if the device contains any contexts or buffers. + + + This function retrieves the current context error state. + a pointer to the device to retrieve the error state from + Errorcode Int32. + + + This function queries if a specified context extension is available. + a pointer to the device to be queried for an extension. + a null-terminated string describing the extension. + Returns True if the extension is available, False if the extension is not available. + + + This function retrieves the address of a specified context extension function. + a pointer to the device to be queried for the function. + a null-terminated string describing the function. + Returns the address of the function, or NULL if it is not found. + + + This function retrieves the enum value for a specified enumeration name. + a pointer to the device to be queried. + a null terminated string describing the enum value. + Returns the enum value described by the enumName string. This is most often used for querying an enum value for an ALC extension. + + + This function returns pointers to strings related to the context. + + ALC_DEFAULT_DEVICE_SPECIFIER will return the name of the default output device. + ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER will return the name of the default capture device. + ALC_DEVICE_SPECIFIER will return the name of the specified output device if a pointer is supplied, or will return a list of all available devices if a NULL device pointer is supplied. A list is a pointer to a series of strings separated by NULL characters, with the list terminated by two NULL characters. See Enumeration Extension for more details. + ALC_CAPTURE_DEVICE_SPECIFIER will return the name of the specified capture device if a pointer is supplied, or will return a list of all available devices if a NULL device pointer is supplied. + ALC_EXTENSIONS returns a list of available context extensions, with each extension separated by a space and the list terminated by a NULL character. + + a pointer to the device to be queried. + an attribute to be retrieved: ALC_DEFAULT_DEVICE_SPECIFIER, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER, ALC_DEVICE_SPECIFIER, ALC_CAPTURE_DEVICE_SPECIFIER, ALC_EXTENSIONS + A string containing the name of the Device. + + + This function returns a List of strings related to the context. + + ALC_DEVICE_SPECIFIER will return the name of the specified output device if a pointer is supplied, or will return a list of all available devices if a NULL device pointer is supplied. A list is a pointer to a series of strings separated by NULL characters, with the list terminated by two NULL characters. See Enumeration Extension for more details. + ALC_CAPTURE_DEVICE_SPECIFIER will return the name of the specified capture device if a pointer is supplied, or will return a list of all available devices if a NULL device pointer is supplied. + ALC_EXTENSIONS returns a list of available context extensions, with each extension separated by a space and the list terminated by a NULL character. + + a pointer to the device to be queried. + an attribute to be retrieved: ALC_DEVICE_SPECIFIER, ALC_CAPTURE_DEVICE_SPECIFIER, ALC_ALL_DEVICES_SPECIFIER + A List of strings containing the names of the Devices. + + + This function returns integers related to the context. + a pointer to the device to be queried. + an attribute to be retrieved: ALC_MAJOR_VERSION, ALC_MINOR_VERSION, ALC_ATTRIBUTES_SIZE, ALC_ALL_ATTRIBUTES + the size of the destination buffer provided, in number of integers. + a pointer to the buffer to be returned + + + This function returns integers related to the context. + a pointer to the device to be queried. + an attribute to be retrieved: ALC_MAJOR_VERSION, ALC_MINOR_VERSION, ALC_ATTRIBUTES_SIZE, ALC_ALL_ATTRIBUTES + the size of the destination buffer provided, in number of integers. + a pointer to the buffer to be returned + + + This function opens a capture device by name. + a pointer to a device name string. + the frequency that the buffer should be captured at. + the requested capture buffer format. + the size of the capture buffer in samples, not bytes. + Returns the capture device pointer, or NULL on failure. + + + This function opens a capture device by name. + a pointer to a device name string. + the frequency that the buffer should be captured at. + the requested capture buffer format. + the size of the capture buffer in samples, not bytes. + Returns the capture device pointer, or NULL on failure. + + + This function closes the specified capture device. + a pointer to a capture device. + Returns True if the close operation was successful, False on failure. + + + This function begins a capture operation. + alcCaptureStart will begin recording to an internal ring buffer of the size specified when opening the capture device. The application can then retrieve the number of samples currently available using the ALC_CAPTURE_SAPMPLES token with alcGetIntegerv. When the application determines that enough samples are available for processing, then it can obtain them with a call to alcCaptureSamples. + a pointer to a capture device. + + + This function stops a capture operation. + a pointer to a capture device. + + + This function completes a capture operation, and does not block. + a pointer to a capture device. + a pointer to a buffer, which must be large enough to accommodate the number of samples. + the number of samples to be retrieved. + + + This function completes a capture operation, and does not block. + a pointer to a capture device. + a reference to a buffer, which must be large enough to accommodate the number of samples. + the number of samples to be retrieved. + + + This function completes a capture operation, and does not block. + a pointer to a capture device. + a buffer, which must be large enough to accommodate the number of samples. + the number of samples to be retrieved. + + + This function completes a capture operation, and does not block. + a pointer to a capture device. + a buffer, which must be large enough to accommodate the number of samples. + the number of samples to be retrieved. + + + This function completes a capture operation, and does not block. + a pointer to a capture device. + a buffer, which must be large enough to accommodate the number of samples. + the number of samples to be retrieved. + + + + Encapsulates a sound stream and provides decoding and streaming capabilities. + + + + Creates a new AudioReader that can read the specified sound file. + The path to the sound file. + A new OpenTK.Audio.AudioReader, which can be used to read from the specified sound file. + + + Creates a new AudioReader that can read the specified soundstream. + The System.IO.Stream to read from. + A new OpenTK.Audio.AudioReader, which can be used to read from the specified sound stream. + + + When overriden in a derived class, checks if the decoder supports the specified sound stream. + The System.IO.Stream to check. + True if the sound stream is supported; false otherwise. + + + + When overriden in a derived class, reads and decodes the specified number of samples from the sound stream. + + The number of samples to read and decode. + An OpenTK.Audio.SoundData object that contains the decoded buffer. + + + + When overriden in a derived class, reads and decodes the sound stream. + + An OpenTK.Audio.SoundData object that contains the decoded buffer. + + + Closes the underlying Stream and disposes of the AudioReader resources. + + + + Finalizes this AudioReader. + + + + + + + + + + Returns true if the AudioReader has reached the end of the file. + + + + + Gets or sets the input of the AudioReader. + + + + + OpenGL binding for .NET, implementing OpenGL 2.1, plus extensions. + + + + This class contains all OpenGL enums and functions defined in the 2.1 specification. + The official .spec files can be found at: http://opengl.org/registry/. + + + We rely on static initialization to obtain the entry points for OpenGL functions. + Please ensure that a valid OpenGL context has been made current in the pertinent thread before + any OpenGL functions are called (toolkits like GLUT, SDL or GLFW will automatically take care of + the context initialization process). Without a valid OpenGL context, we will only be able + to retrieve statically exported entry points (typically corresponding to OpenGL version 1.1 under Windows, + 1.3 under Linux and 1.4 under Windows Vista), and extension methods will need to be loaded manually. + + + If you prefer to have more control on extension loading, you can use the + ReloadFunctions or ReloadFunction methods to manually force the initialisation of OpenGL entry points. + The ReloadFunctions method should be called whenever you change an existing visual or pixelformat. This + generally happens when you change the color/stencil/depth buffer associated with a window (but probably + not the resolution). This may or may not be necessary under Linux/MacOS, but is generally required for + Windows. + + + You can use the Gl.IsExtensionSupported method to check whether any given category of extension functions + exists in the current OpenGL context. The results can be cached to speed up future searches. + Keep in mind that different OpenGL contexts may support different extensions, and under different entry + points. Always check if all required extensions are still supported when changing visuals or pixel + formats. + + + You may retrieve the entry point for an OpenGL function using the Gl.GetDelegate method. + + + + + + + + + + + + Determines whether the specified OpenGL extension category is available in + the current OpenGL context. Equivalent to IsExtensionSupported(name, true) + + The string for the OpenGL extension category (eg. "GL_ARB_multitexture") + True if the specified extension is available, false otherwise. + + + + Creates a System.Delegate that can be used to call an OpenGL function, core or extension. + + The name of the OpenGL function (eg. "glNewList") + The signature of the OpenGL function. + + A System.Delegate that can be used to call this OpenGL function, or null if the specified + function name did not correspond to an OpenGL function. + + + + + Loads all OpenGL functions (core and extensions). + + + + This function will be automatically called the first time you use any opengl function. There is + + + Call this function manually whenever you need to update OpenGL entry points. + This need may arise if you change the pixelformat/visual, or in case you cannot + (or do not want) to use the automatic initialization of the GL class. + + + + + + Tries to reload the given OpenGL function (core or extension). + + The name of the OpenGL function (i.e. glShaderSource) + True if the function was found and reloaded, false otherwise. + + + Use this function if you require greater granularity when loading OpenGL entry points. + + + While the automatic initialisation will load all OpenGL entry points, in some cases + the initialisation can take place before an OpenGL Context has been established. + In this case, use this function to load the entry points for the OpenGL functions + you will need, or use ReloadFunctions() to load all available entry points. + + + This function returns true if the given OpenGL function is supported, false otherwise. + + + To query for supported extensions use the IsExtensionSupported() function instead. + + + + + + Builds a cache of all supported extensions. + + + + + Retrieves the entry point for a dynamically exported OpenGL function. + + The function string for the OpenGL function (eg. "glNewList") + + An IntPtr contaning the address for the entry point, or IntPtr.Zero if the specified + OpenGL function is not dynamically exported. + + + + The Marshal.GetDelegateForFunctionPointer method can be used to turn the return value + into a call-able delegate. + + + This function is cross-platform. It determines the underlying platform and uses the + correct wgl, glx or agl GetAddress function to retrieve the function pointer. + + + + + + + Executes "uname" which returns a string representing the name of the + underlying Unix kernel. + + "Unix", "Linux", "Darwin" or null. + Source code from "Mono: A Developer's Notebook" + + + + Creates a System.Delegate that can be used to call a dynamically exported OpenGL function. + + The name of the OpenGL function (eg. "glNewList") + The signature of the OpenGL function. + + A System.Delegate that can be used to call this OpenGL function or null + if the function is not available in the current OpenGL context. + + + + + Contains DllImports for the core OpenGL functions. + + + + + Build a string->MethodInfo map to speed up extension loading. + + + + + OpenGL bindings for .NET, implementing OpenGL 3.1, plus extensions. + + + + This class contains all OpenGL enums and functions defined in the 3.1 specification. + The official .spec files can be found at: http://opengl.org/registry/. + + A valid OpenGL context must be created before calling any OpenGL function. + + Use the GL.Load and GL.LoadAll methods to prepare function entry points prior to use. To maintain + cross-platform compatibility, this must be done for both core and extension functions. The GameWindow + and the GLControl class will take care of this automatically. + + + You can use the GL.SupportsExtension method to check whether any given category of extension functions + exists in the current OpenGL context. Keep in mind that different OpenGL contexts may support different + extensions, and under different entry points. Always check if all required extensions are still supported + when changing visuals or pixel formats. + + + You may retrieve the entry point for an OpenGL function using the GL.GetDelegate method. + + + + + + + + + + + Operate on the accumulation buffer + + + + Specifies the accumulation buffer operation. Symbolic constants GL_ACCUM, GL_LOAD, GL_ADD, GL_MULT, and GL_RETURN are accepted. + + + + + Specifies a floating-point value used in the accumulation buffer operation. op determines how value is used. + + + + + + Select active texture unit + + + + Specifies which texture unit to make active. The number of texture units is implementation dependent, but must be at least two. texture must be one of GL_TEXTURE, where i ranges from 0 to the larger of (GL_MAX_TEXTURE_COORDS - 1) and (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1). The initial value is GL_TEXTURE0. + + + + + + Specify the alpha test function + + + + Specifies the alpha comparison function. Symbolic constants GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, and GL_ALWAYS are accepted. The initial value is GL_ALWAYS. + + + + + Specifies the reference value that incoming alpha values are compared to. This value is clamped to the range [0,1], where 0 represents the lowest possible alpha value and 1 the highest possible value. The initial reference value is 0. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Render a vertex using the specified vertex array element + + + + Specifies an index into the enabled vertex data arrays. + + + + + + Attaches a shader object to a program object + + + + Specifies the program object to which a shader object will be attached. + + + + + Specifies the shader object that is to be attached. + + + + + + Attaches a shader object to a program object + + + + Specifies the program object to which a shader object will be attached. + + + + + Specifies the shader object that is to be attached. + + + + + + Delimit the vertices of a primitive or a group of like primitives + + + + Specifies the primitive or primitives that will be created from vertices presented between glBegin and the subsequent glEnd. Ten symbolic constants are accepted: GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, and GL_POLYGON. + + + + + + Delimit the boundaries of a query object + + + + Specifies the target type of query object established between glBeginQuery and the subsequent glEndQuery. The symbolic constant must be GL_SAMPLES_PASSED. + + + + + Specifies the name of a query object. + + + + + + Delimit the boundaries of a query object + + + + Specifies the target type of query object established between glBeginQuery and the subsequent glEndQuery. The symbolic constant must be GL_SAMPLES_PASSED. + + + + + Specifies the name of a query object. + + + + + + Associates a generic vertex attribute index with a named attribute variable + + + + Specifies the handle of the program object in which the association is to be made. + + + + + Specifies the index of the generic vertex attribute to be bound. + + + + + Specifies a null terminated string containing the name of the vertex shader attribute variable to which index is to be bound. + + + + + + Associates a generic vertex attribute index with a named attribute variable + + + + Specifies the handle of the program object in which the association is to be made. + + + + + Specifies the index of the generic vertex attribute to be bound. + + + + + Specifies a null terminated string containing the name of the vertex shader attribute variable to which index is to be bound. + + + + + + Bind a named buffer object + + + + Specifies the target to which the buffer object is bound. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the name of a buffer object. + + + + + + Bind a named buffer object + + + + Specifies the target to which the buffer object is bound. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the name of a buffer object. + + + + + + Bind a named texture to a texturing target + + + + Specifies the target to which the texture is bound. Must be either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, or GL_TEXTURE_CUBE_MAP. + + + + + Specifies the name of a texture. + + + + + + Bind a named texture to a texturing target + + + + Specifies the target to which the texture is bound. Must be either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, or GL_TEXTURE_CUBE_MAP. + + + + + Specifies the name of a texture. + + + + + + Draw a bitmap + + + + Specify the pixel width and height of the bitmap image. + + + + + Specify the location of the origin in the bitmap image. The origin is measured from the lower left corner of the bitmap, with right and up being the positive axes. + + + + + Specify the x and y offsets to be added to the current raster position after the bitmap is drawn. + + + + + Specifies the address of the bitmap image. + + + + + + Draw a bitmap + + + + Specify the pixel width and height of the bitmap image. + + + + + Specify the location of the origin in the bitmap image. The origin is measured from the lower left corner of the bitmap, with right and up being the positive axes. + + + + + Specify the x and y offsets to be added to the current raster position after the bitmap is drawn. + + + + + Specifies the address of the bitmap image. + + + + + + Draw a bitmap + + + + Specify the pixel width and height of the bitmap image. + + + + + Specify the location of the origin in the bitmap image. The origin is measured from the lower left corner of the bitmap, with right and up being the positive axes. + + + + + Specify the x and y offsets to be added to the current raster position after the bitmap is drawn. + + + + + Specifies the address of the bitmap image. + + + + + + Set the blend color + + + + specify the components of GL_BLEND_COLOR + + + + + + Specify the equation used for both the RGB blend equation and the Alpha blend equation + + + + specifies how source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + + Specify the equation used for both the RGB blend equation and the Alpha blend equation + + + + specifies how source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + + Specify the equation used for both the RGB blend equation and the Alpha blend equation + + + + specifies how source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + + Set the RGB blend equation and the alpha blend equation separately + + + + specifies the RGB blend equation, how the red, green, and blue components of the source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + specifies the alpha blend equation, how the alpha component of the source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + + Set the RGB blend equation and the alpha blend equation separately + + + + specifies the RGB blend equation, how the red, green, and blue components of the source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + specifies the alpha blend equation, how the alpha component of the source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + + Set the RGB blend equation and the alpha blend equation separately + + + + specifies the RGB blend equation, how the red, green, and blue components of the source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + specifies the alpha blend equation, how the alpha component of the source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + + Specify pixel arithmetic + + + + Specifies how the red, green, blue, and alpha source blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE. The initial value is GL_ONE. + + + + + Specifies how the red, green, blue, and alpha destination blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA. GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA. The initial value is GL_ZERO. + + + + + + Specify pixel arithmetic + + + + Specifies how the red, green, blue, and alpha source blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE. The initial value is GL_ONE. + + + + + Specifies how the red, green, blue, and alpha destination blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA. GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA. The initial value is GL_ZERO. + + + + + + Specify pixel arithmetic + + + + Specifies how the red, green, blue, and alpha source blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE. The initial value is GL_ONE. + + + + + Specifies how the red, green, blue, and alpha destination blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA. GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA. The initial value is GL_ZERO. + + + + + + Specify pixel arithmetic for RGB and alpha components separately + + + + Specifies how the red, green, and blue blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE. The initial value is GL_ONE. + + + + + Specifies how the red, green, and blue destination blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA. GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA. The initial value is GL_ZERO. + + + + + Specified how the alpha source blending factor is computed. The same symbolic constants are accepted as for srcRGB. The initial value is GL_ONE. + + + + + Specified how the alpha destination blending factor is computed. The same symbolic constants are accepted as for dstRGB. The initial value is GL_ZERO. + + + + + + Specify pixel arithmetic for RGB and alpha components separately + + + + Specifies how the red, green, and blue blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE. The initial value is GL_ONE. + + + + + Specifies how the red, green, and blue destination blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA. GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA. The initial value is GL_ZERO. + + + + + Specified how the alpha source blending factor is computed. The same symbolic constants are accepted as for srcRGB. The initial value is GL_ONE. + + + + + Specified how the alpha destination blending factor is computed. The same symbolic constants are accepted as for dstRGB. The initial value is GL_ZERO. + + + + + + Specify pixel arithmetic for RGB and alpha components separately + + + + Specifies how the red, green, and blue blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE. The initial value is GL_ONE. + + + + + Specifies how the red, green, and blue destination blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA. GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA. The initial value is GL_ZERO. + + + + + Specified how the alpha source blending factor is computed. The same symbolic constants are accepted as for srcRGB. The initial value is GL_ONE. + + + + + Specified how the alpha destination blending factor is computed. The same symbolic constants are accepted as for dstRGB. The initial value is GL_ZERO. + + + + + + Creates and initializes a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the size in bytes of the buffer object's new data store. + + + + + Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied. + + + + + Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. + + + + + + Creates and initializes a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the size in bytes of the buffer object's new data store. + + + + + Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied. + + + + + Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. + + + + + + Creates and initializes a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the size in bytes of the buffer object's new data store. + + + + + Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied. + + + + + Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. + + + + + + Creates and initializes a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the size in bytes of the buffer object's new data store. + + + + + Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied. + + + + + Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. + + + + + + Creates and initializes a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the size in bytes of the buffer object's new data store. + + + + + Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied. + + + + + Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. + + + + + + Updates a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store where data replacement will begin, measured in bytes. + + + + + Specifies the size in bytes of the data store region being replaced. + + + + + Specifies a pointer to the new data that will be copied into the data store. + + + + + + Updates a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store where data replacement will begin, measured in bytes. + + + + + Specifies the size in bytes of the data store region being replaced. + + + + + Specifies a pointer to the new data that will be copied into the data store. + + + + + + Updates a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store where data replacement will begin, measured in bytes. + + + + + Specifies the size in bytes of the data store region being replaced. + + + + + Specifies a pointer to the new data that will be copied into the data store. + + + + + + Updates a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store where data replacement will begin, measured in bytes. + + + + + Specifies the size in bytes of the data store region being replaced. + + + + + Specifies a pointer to the new data that will be copied into the data store. + + + + + + Updates a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store where data replacement will begin, measured in bytes. + + + + + Specifies the size in bytes of the data store region being replaced. + + + + + Specifies a pointer to the new data that will be copied into the data store. + + + + + + Execute a display list + + + + Specifies the integer name of the display list to be executed. + + + + + + Execute a display list + + + + Specifies the integer name of the display list to be executed. + + + + + + Execute a list of display lists + + + + Specifies the number of display lists to be executed. + + + + + Specifies the type of values in lists. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, GL_2_BYTES, GL_3_BYTES, and GL_4_BYTES are accepted. + + + + + Specifies the address of an array of name offsets in the display list. The pointer type is void because the offsets can be bytes, shorts, ints, or floats, depending on the value of type. + + + + + + Execute a list of display lists + + + + Specifies the number of display lists to be executed. + + + + + Specifies the type of values in lists. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, GL_2_BYTES, GL_3_BYTES, and GL_4_BYTES are accepted. + + + + + Specifies the address of an array of name offsets in the display list. The pointer type is void because the offsets can be bytes, shorts, ints, or floats, depending on the value of type. + + + + + + Execute a list of display lists + + + + Specifies the number of display lists to be executed. + + + + + Specifies the type of values in lists. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, GL_2_BYTES, GL_3_BYTES, and GL_4_BYTES are accepted. + + + + + Specifies the address of an array of name offsets in the display list. The pointer type is void because the offsets can be bytes, shorts, ints, or floats, depending on the value of type. + + + + + + Execute a list of display lists + + + + Specifies the number of display lists to be executed. + + + + + Specifies the type of values in lists. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, GL_2_BYTES, GL_3_BYTES, and GL_4_BYTES are accepted. + + + + + Specifies the address of an array of name offsets in the display list. The pointer type is void because the offsets can be bytes, shorts, ints, or floats, depending on the value of type. + + + + + + Execute a list of display lists + + + + Specifies the number of display lists to be executed. + + + + + Specifies the type of values in lists. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, GL_2_BYTES, GL_3_BYTES, and GL_4_BYTES are accepted. + + + + + Specifies the address of an array of name offsets in the display list. The pointer type is void because the offsets can be bytes, shorts, ints, or floats, depending on the value of type. + + + + + + Clear buffers to preset values + + + + Bitwise OR of masks that indicate the buffers to be cleared. The four masks are GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, and GL_STENCIL_BUFFER_BIT. + + + + + + Specify clear values for the accumulation buffer + + + + Specify the red, green, blue, and alpha values used when the accumulation buffer is cleared. The initial values are all 0. + + + + + + Specify clear values for the color buffers + + + + Specify the red, green, blue, and alpha values used when the color buffers are cleared. The initial values are all 0. + + + + + + Specify the clear value for the depth buffer + + + + Specifies the depth value used when the depth buffer is cleared. The initial value is 1. + + + + + + Specify the clear value for the color index buffers + + + + Specifies the index used when the color index buffers are cleared. The initial value is 0. + + + + + + Specify the clear value for the stencil buffer + + + + Specifies the index used when the stencil buffer is cleared. The initial value is 0. + + + + + + Select active texture unit + + + + Specifies which texture unit to make active. The number of texture units is implementation dependent, but must be at least two. texture must be one of GL_TEXTURE, where i ranges from 0 to the value of GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. The initial value is GL_TEXTURE0. + + + + + + Specify a plane against which all geometry is clipped + + + + Specifies which clipping plane is being positioned. Symbolic names of the form GL_CLIP_PLANEi, where i is an integer between 0 and GL_MAX_CLIP_PLANES - 1, are accepted. + + + + + Specifies the address of an array of four double-precision floating-point values. These values are interpreted as a plane equation. + + + + + + Specify a plane against which all geometry is clipped + + + + Specifies which clipping plane is being positioned. Symbolic names of the form GL_CLIP_PLANEi, where i is an integer between 0 and GL_MAX_CLIP_PLANES - 1, are accepted. + + + + + Specifies the address of an array of four double-precision floating-point values. These values are interpreted as a plane equation. + + + + + + Specify a plane against which all geometry is clipped + + + + Specifies which clipping plane is being positioned. Symbolic names of the form GL_CLIP_PLANEi, where i is an integer between 0 and GL_MAX_CLIP_PLANES - 1, are accepted. + + + + + Specifies the address of an array of four double-precision floating-point values. These values are interpreted as a plane equation. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Set the current color + + + + Specify new red, green, and blue values for the current color. + + + + + Specifies a new alpha value for the current color. Included only in the four-argument glColor4 commands. + + + + + + Enable and disable writing of frame buffer color components + + + + Specify whether red, green, blue, and alpha can or cannot be written into the frame buffer. The initial values are all GL_TRUE, indicating that the color components can be written. + + + + + + Enable and disable writing of frame buffer color components + + + + Specify whether red, green, blue, and alpha can or cannot be written into the frame buffer. The initial values are all GL_TRUE, indicating that the color components can be written. + + + + + + Enable and disable writing of frame buffer color components + + + + Specify whether red, green, blue, and alpha can or cannot be written into the frame buffer. The initial values are all GL_TRUE, indicating that the color components can be written. + + + + + + Cause a material color to track the current color + + + + Specifies whether front, back, or both front and back material parameters should track the current color. Accepted values are GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK. The initial value is GL_FRONT_AND_BACK. + + + + + Specifies which of several material parameters track the current color. Accepted values are GL_EMISSION, GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, and GL_AMBIENT_AND_DIFFUSE. The initial value is GL_AMBIENT_AND_DIFFUSE. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The number of table entries to replace. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to replace the specified region of the color table. + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The number of table entries to replace. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to replace the specified region of the color table. + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The number of table entries to replace. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to replace the specified region of the color table. + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The number of table entries to replace. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to replace the specified region of the color table. + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The number of table entries to replace. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to replace the specified region of the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Compiles a shader object + + + + Specifies the shader object to be compiled. + + + + + + Compiles a shader object + + + + Specifies the shader object to be compiled. + + + + + + Specify a one-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels wide and cube-mapped texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be Must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels high and cube-mapped texture images that are at least 16 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels wide and cube-mapped texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be Must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels high and cube-mapped texture images that are at least 16 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels wide and cube-mapped texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be Must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels high and cube-mapped texture images that are at least 16 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels wide and cube-mapped texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be Must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels high and cube-mapped texture images that are at least 16 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels wide and cube-mapped texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be Must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels high and cube-mapped texture images that are at least 16 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Define a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_RGB, and GL_RGBA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_RGB, and GL_RGBA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_RGB, and GL_RGBA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_RGB, and GL_RGBA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_RGB, and GL_RGBA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The height of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a two-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The height of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a two-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The height of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a two-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The height of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a two-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The height of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a two-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The window coordinates of the left corner of the row of pixels to be copied. + + + + + The number of table entries to replace. + + + + + + Copy pixels into a color table + + + + The color table target. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal storage format of the texture image. Must be one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The x coordinate of the lower-left corner of the pixel rectangle to be transferred to the color table. + + + + + The y coordinate of the lower-left corner of the pixel rectangle to be transferred to the color table. + + + + + The width of the pixel rectangle. + + + + + + Copy pixels into a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The window space coordinates of the lower-left coordinate of the pixel array to copy. + + + + + The width of the pixel array to copy. + + + + + + Copy pixels into a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The window space coordinates of the lower-left coordinate of the pixel array to copy. + + + + + The width of the pixel array to copy. + + + + + The height of the pixel array to copy. + + + + + + Copy pixels in the frame buffer + + + + Specify the window coordinates of the lower left corner of the rectangular region of pixels to be copied. + + + + + Specify the dimensions of the rectangular region of pixels to be copied. Both must be nonnegative. + + + + + Specifies whether color values, depth values, or stencil values are to be copied. Symbolic constants GL_COLOR, GL_DEPTH, and GL_STENCIL are accepted. + + + + + + Copy pixels into a 1D texture image + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the internal format of the texture. Must be one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_RGB, GL_R3_G3_B2, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specify the window coordinates of the left corner of the row of pixels to be copied. + + + + + Specifies the width of the texture image. Must be 0 or 2 sup n + 2 ( border ) for some integer . The height of the texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + + Copy pixels into a 2D texture image + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the internal format of the texture. Must be one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_RGB, GL_R3_G3_B2, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specify the window coordinates of the lower left corner of the rectangular region of pixels to be copied. + + + + + Specifies the width of the texture image. Must be 0 or 2 sup n + 2 ( border ) for some integer . + + + + + Specifies the height of the texture image. Must be 0 or 2 sup m + 2 ( border ) for some integer . + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + + Copy a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the texel offset within the texture array. + + + + + Specify the window coordinates of the left corner of the row of pixels to be copied. + + + + + Specifies the width of the texture subimage. + + + + + + Copy a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specify the window coordinates of the lower left corner of the rectangular region of pixels to be copied. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + + Copy a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specify the window coordinates of the lower left corner of the rectangular region of pixels to be copied. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + + Creates a program object + + + + + Creates a shader object + + + + Specifies the type of shader to be created. Must be either GL_VERTEX_SHADER or GL_FRAGMENT_SHADER. + + + + + + Specify whether front- or back-facing facets can be culled + + + + Specifies whether front- or back-facing facets are candidates for culling. Symbolic constants GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK are accepted. The initial value is GL_BACK. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete a contiguous group of display lists + + + + Specifies the integer name of the first display list to delete. + + + + + Specifies the number of display lists to delete. + + + + + + Delete a contiguous group of display lists + + + + Specifies the integer name of the first display list to delete. + + + + + Specifies the number of display lists to delete. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Deletes a shader object + + + + Specifies the shader object to be deleted. + + + + + + Deletes a shader object + + + + Specifies the shader object to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Specify the value used for depth buffer comparisons + + + + Specifies the depth comparison function. Symbolic constants GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, and GL_ALWAYS are accepted. The initial value is GL_LESS. + + + + + + Enable or disable writing into the depth buffer + + + + Specifies whether the depth buffer is enabled for writing. If flag is GL_FALSE, depth buffer writing is disabled. Otherwise, it is enabled. Initially, depth buffer writing is enabled. + + + + + + Specify mapping of depth values from normalized device coordinates to window coordinates + + + + Specifies the mapping of the near clipping plane to window coordinates. The initial value is 0. + + + + + Specifies the mapping of the far clipping plane to window coordinates. The initial value is 1. + + + + + + Detaches a shader object from a program object to which it is attached + + + + Specifies the program object from which to detach the shader object. + + + + + Specifies the shader object to be detached. + + + + + + Detaches a shader object from a program object to which it is attached + + + + Specifies the program object from which to detach the shader object. + + + + + Specifies the shader object to be detached. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the starting index in the enabled arrays. + + + + + Specifies the number of indices to be rendered. + + + + + + Specify which color buffers are to be drawn into + + + + Specifies up to four color buffers to be drawn into. Symbolic constants GL_NONE, GL_FRONT_LEFT, GL_FRONT_RIGHT, GL_BACK_LEFT, GL_BACK_RIGHT, GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT, GL_FRONT_AND_BACK, and GL_AUXi, where i is between 0 and the value of GL_AUX_BUFFERS minus 1, are accepted. (GL_AUX_BUFFERS is not the upper limit; use glGet to query the number of available aux buffers.) The initial value is GL_FRONT for single-buffered contexts, and GL_BACK for double-buffered contexts. + + + + + + Specifies a list of color buffers to be drawn into + + + + Specifies the number of buffers in bufs. + + + + + Points to an array of symbolic constants specifying the buffers into which fragment colors or data values will be written. + + + + + + Specifies a list of color buffers to be drawn into + + + + Specifies the number of buffers in bufs. + + + + + Points to an array of symbolic constants specifying the buffers into which fragment colors or data values will be written. + + + + + + Specifies a list of color buffers to be drawn into + + + + Specifies the number of buffers in bufs. + + + + + Points to an array of symbolic constants specifying the buffers into which fragment colors or data values will be written. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Write a block of pixels to the frame buffer + + + + Specify the dimensions of the pixel rectangle to be written into the frame buffer. + + + + + Specifies the format of the pixel data. Symbolic constants GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA are accepted. + + + + + Specifies the data type for data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Specifies a pointer to the pixel data. + + + + + + Write a block of pixels to the frame buffer + + + + Specify the dimensions of the pixel rectangle to be written into the frame buffer. + + + + + Specifies the format of the pixel data. Symbolic constants GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA are accepted. + + + + + Specifies the data type for data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Specifies a pointer to the pixel data. + + + + + + Write a block of pixels to the frame buffer + + + + Specify the dimensions of the pixel rectangle to be written into the frame buffer. + + + + + Specifies the format of the pixel data. Symbolic constants GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA are accepted. + + + + + Specifies the data type for data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Specifies a pointer to the pixel data. + + + + + + Write a block of pixels to the frame buffer + + + + Specify the dimensions of the pixel rectangle to be written into the frame buffer. + + + + + Specifies the format of the pixel data. Symbolic constants GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA are accepted. + + + + + Specifies the data type for data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Specifies a pointer to the pixel data. + + + + + + Write a block of pixels to the frame buffer + + + + Specify the dimensions of the pixel rectangle to be written into the frame buffer. + + + + + Specifies the format of the pixel data. Symbolic constants GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA are accepted. + + + + + Specifies the data type for data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Specifies a pointer to the pixel data. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Flag edges as either boundary or nonboundary + + + + Specifies the current edge flag value, either GL_TRUE or GL_FALSE. The initial value is GL_TRUE. + + + + + + Define an array of edge flags + + + + Specifies the byte offset between consecutive edge flags. If stride is 0, the edge flags are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first edge flag in the array. The initial value is 0. + + + + + + Define an array of edge flags + + + + Specifies the byte offset between consecutive edge flags. If stride is 0, the edge flags are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first edge flag in the array. The initial value is 0. + + + + + + Define an array of edge flags + + + + Specifies the byte offset between consecutive edge flags. If stride is 0, the edge flags are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first edge flag in the array. The initial value is 0. + + + + + + Define an array of edge flags + + + + Specifies the byte offset between consecutive edge flags. If stride is 0, the edge flags are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first edge flag in the array. The initial value is 0. + + + + + + Define an array of edge flags + + + + Specifies the byte offset between consecutive edge flags. If stride is 0, the edge flags are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first edge flag in the array. The initial value is 0. + + + + + + Flag edges as either boundary or nonboundary + + + + Specifies the current edge flag value, either GL_TRUE or GL_FALSE. The initial value is GL_TRUE. + + + + + + Enable or disable server-side GL capabilities + + + + Specifies a symbolic constant indicating a GL capability. + + + + + + Enable or disable client-side capability + + + + Specifies the capability to enable. Symbolic constants GL_COLOR_ARRAY, GL_EDGE_FLAG_ARRAY, GL_FOG_COORD_ARRAY, GL_INDEX_ARRAY, GL_NORMAL_ARRAY, GL_SECONDARY_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY, and GL_VERTEX_ARRAY are accepted. + + + + + + Enable or disable server-side GL capabilities + + + + Specifies a symbolic constant indicating a GL capability. + + + + + + Enable or disable server-side GL capabilities + + + + Specifies a symbolic constant indicating a GL capability. + + + + + + Enable or disable a generic vertex attribute array + + + + Specifies the index of the generic vertex attribute to be enabled or disabled. + + + + + + Enable or disable a generic vertex attribute array + + + + Specifies the index of the generic vertex attribute to be enabled or disabled. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Evaluate enabled one- and two-dimensional maps + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap1 or glMap2 command. + + + + + Specifies a value that is the domain coordinate to the basis function defined in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. + + + + + + Compute a one- or two-dimensional grid of points or lines + + + + In glEvalMesh1, specifies whether to compute a one-dimensional mesh of points or lines. Symbolic constants GL_POINT and GL_LINE are accepted. + + + + + Specify the first and last integer values for grid domain variable . + + + + + + Compute a one- or two-dimensional grid of points or lines + + + + In glEvalMesh1, specifies whether to compute a one-dimensional mesh of points or lines. Symbolic constants GL_POINT and GL_LINE are accepted. + + + + + Specify the first and last integer values for grid domain variable . + + + + + + Generate and evaluate a single point in a mesh + + + + Specifies the integer value for grid domain variable . + + + + + Specifies the integer value for grid domain variable (glEvalPoint2 only). + + + + + + Generate and evaluate a single point in a mesh + + + + Specifies the integer value for grid domain variable . + + + + + Specifies the integer value for grid domain variable (glEvalPoint2 only). + + + + + + Controls feedback mode + + + + Specifies the maximum number of values that can be written into buffer. + + + + + Specifies a symbolic constant that describes the information that will be returned for each vertex. GL_2D, GL_3D, GL_3D_COLOR, GL_3D_COLOR_TEXTURE, and GL_4D_COLOR_TEXTURE are accepted. + + + + + Returns the feedback data. + + + + + + Controls feedback mode + + + + Specifies the maximum number of values that can be written into buffer. + + + + + Specifies a symbolic constant that describes the information that will be returned for each vertex. GL_2D, GL_3D, GL_3D_COLOR, GL_3D_COLOR_TEXTURE, and GL_4D_COLOR_TEXTURE are accepted. + + + + + Returns the feedback data. + + + + + + Controls feedback mode + + + + Specifies the maximum number of values that can be written into buffer. + + + + + Specifies a symbolic constant that describes the information that will be returned for each vertex. GL_2D, GL_3D, GL_3D_COLOR, GL_3D_COLOR_TEXTURE, and GL_4D_COLOR_TEXTURE are accepted. + + + + + Returns the feedback data. + + + + + + Block until all GL execution is complete + + + + + Force execution of GL commands in finite time + + + + + Set the current fog coordinates + + + + Specify the fog distance. + + + + + + Set the current fog coordinates + + + + Specify the fog distance. + + + + + + Set the current fog coordinates + + + + Specify the fog distance. + + + + + + Set the current fog coordinates + + + + Specify the fog distance. + + + + + + Define an array of fog coordinates + + + + Specifies the data type of each fog coordinate. Symbolic constants GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive fog coordinates. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first fog coordinate in the array. The initial value is 0. + + + + + + Define an array of fog coordinates + + + + Specifies the data type of each fog coordinate. Symbolic constants GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive fog coordinates. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first fog coordinate in the array. The initial value is 0. + + + + + + Define an array of fog coordinates + + + + Specifies the data type of each fog coordinate. Symbolic constants GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive fog coordinates. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first fog coordinate in the array. The initial value is 0. + + + + + + Define an array of fog coordinates + + + + Specifies the data type of each fog coordinate. Symbolic constants GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive fog coordinates. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first fog coordinate in the array. The initial value is 0. + + + + + + Define an array of fog coordinates + + + + Specifies the data type of each fog coordinate. Symbolic constants GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive fog coordinates. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first fog coordinate in the array. The initial value is 0. + + + + + + Specify fog parameters + + + + Specifies a single-valued fog parameter. GL_FOG_MODE, GL_FOG_DENSITY, GL_FOG_START, GL_FOG_END, GL_FOG_INDEX, and GL_FOG_COORD_SRC are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify fog parameters + + + + Specifies a single-valued fog parameter. GL_FOG_MODE, GL_FOG_DENSITY, GL_FOG_START, GL_FOG_END, GL_FOG_INDEX, and GL_FOG_COORD_SRC are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify fog parameters + + + + Specifies a single-valued fog parameter. GL_FOG_MODE, GL_FOG_DENSITY, GL_FOG_START, GL_FOG_END, GL_FOG_INDEX, and GL_FOG_COORD_SRC are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify fog parameters + + + + Specifies a single-valued fog parameter. GL_FOG_MODE, GL_FOG_DENSITY, GL_FOG_START, GL_FOG_END, GL_FOG_INDEX, and GL_FOG_COORD_SRC are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify fog parameters + + + + Specifies a single-valued fog parameter. GL_FOG_MODE, GL_FOG_DENSITY, GL_FOG_START, GL_FOG_END, GL_FOG_INDEX, and GL_FOG_COORD_SRC are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify fog parameters + + + + Specifies a single-valued fog parameter. GL_FOG_MODE, GL_FOG_DENSITY, GL_FOG_START, GL_FOG_END, GL_FOG_INDEX, and GL_FOG_COORD_SRC are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Define front- and back-facing polygons + + + + Specifies the orientation of front-facing polygons. GL_CW and GL_CCW are accepted. The initial value is GL_CCW. + + + + + + Multiply the current matrix by a perspective matrix + + + + Specify the coordinates for the left and right vertical clipping planes. + + + + + Specify the coordinates for the bottom and top horizontal clipping planes. + + + + + Specify the distances to the near and far depth clipping planes. Both distances must be positive. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate a contiguous set of empty display lists + + + + Specifies the number of contiguous empty display lists to be generated. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Returns information about an active attribute variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the attribute variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the attribute variable. + + + + + Returns the data type of the attribute variable. + + + + + Returns a null terminated string containing the name of the attribute variable. + + + + + + Returns information about an active attribute variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the attribute variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the attribute variable. + + + + + Returns the data type of the attribute variable. + + + + + Returns a null terminated string containing the name of the attribute variable. + + + + + + Returns information about an active attribute variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the attribute variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the attribute variable. + + + + + Returns the data type of the attribute variable. + + + + + Returns a null terminated string containing the name of the attribute variable. + + + + + + Returns information about an active attribute variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the attribute variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the attribute variable. + + + + + Returns the data type of the attribute variable. + + + + + Returns a null terminated string containing the name of the attribute variable. + + + + + + Returns information about an active uniform variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the uniform variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the uniform variable. + + + + + Returns the data type of the uniform variable. + + + + + Returns a null terminated string containing the name of the uniform variable. + + + + + + Returns information about an active uniform variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the uniform variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the uniform variable. + + + + + Returns the data type of the uniform variable. + + + + + Returns a null terminated string containing the name of the uniform variable. + + + + + + Returns information about an active uniform variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the uniform variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the uniform variable. + + + + + Returns the data type of the uniform variable. + + + + + Returns a null terminated string containing the name of the uniform variable. + + + + + + Returns information about an active uniform variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the uniform variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the uniform variable. + + + + + Returns the data type of the uniform variable. + + + + + Returns a null terminated string containing the name of the uniform variable. + + + + + + Returns the handles of the shader objects attached to a program object + + + + Specifies the program object to be queried. + + + + + Specifies the size of the array for storing the returned object names. + + + + + Returns the number of names actually returned in objects. + + + + + Specifies an array that is used to return the names of attached shader objects. + + + + + + Returns the handles of the shader objects attached to a program object + + + + Specifies the program object to be queried. + + + + + Specifies the size of the array for storing the returned object names. + + + + + Returns the number of names actually returned in objects. + + + + + Specifies an array that is used to return the names of attached shader objects. + + + + + + Returns the handles of the shader objects attached to a program object + + + + Specifies the program object to be queried. + + + + + Specifies the size of the array for storing the returned object names. + + + + + Returns the number of names actually returned in objects. + + + + + Specifies an array that is used to return the names of attached shader objects. + + + + + + Returns the handles of the shader objects attached to a program object + + + + Specifies the program object to be queried. + + + + + Specifies the size of the array for storing the returned object names. + + + + + Returns the number of names actually returned in objects. + + + + + Specifies an array that is used to return the names of attached shader objects. + + + + + + Returns the handles of the shader objects attached to a program object + + + + Specifies the program object to be queried. + + + + + Specifies the size of the array for storing the returned object names. + + + + + Returns the number of names actually returned in objects. + + + + + Specifies an array that is used to return the names of attached shader objects. + + + + + + Returns the handles of the shader objects attached to a program object + + + + Specifies the program object to be queried. + + + + + Specifies the size of the array for storing the returned object names. + + + + + Returns the number of names actually returned in objects. + + + + + Specifies an array that is used to return the names of attached shader objects. + + + + + + Returns the location of an attribute variable + + + + Specifies the program object to be queried. + + + + + Points to a null terminated string containing the name of the attribute variable whose location is to be queried. + + + + + + Returns the location of an attribute variable + + + + Specifies the program object to be queried. + + + + + Points to a null terminated string containing the name of the attribute variable whose location is to be queried. + + + + + + Return parameters of a buffer object + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the symbolic name of a buffer object parameter. Accepted values are GL_BUFFER_ACCESS, GL_BUFFER_MAPPED, GL_BUFFER_SIZE, or GL_BUFFER_USAGE. + + + + + Returns the requested parameter. + + + + + + Return parameters of a buffer object + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the symbolic name of a buffer object parameter. Accepted values are GL_BUFFER_ACCESS, GL_BUFFER_MAPPED, GL_BUFFER_SIZE, or GL_BUFFER_USAGE. + + + + + Returns the requested parameter. + + + + + + Return parameters of a buffer object + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the symbolic name of a buffer object parameter. Accepted values are GL_BUFFER_ACCESS, GL_BUFFER_MAPPED, GL_BUFFER_SIZE, or GL_BUFFER_USAGE. + + + + + Returns the requested parameter. + + + + + + Return the pointer to a mapped buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the pointer to be returned. The symbolic constant must be GL_BUFFER_MAP_POINTER. + + + + + Returns the pointer value specified by pname. + + + + + + Return the pointer to a mapped buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the pointer to be returned. The symbolic constant must be GL_BUFFER_MAP_POINTER. + + + + + Returns the pointer value specified by pname. + + + + + + Return the pointer to a mapped buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the pointer to be returned. The symbolic constant must be GL_BUFFER_MAP_POINTER. + + + + + Returns the pointer value specified by pname. + + + + + + Return the pointer to a mapped buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the pointer to be returned. The symbolic constant must be GL_BUFFER_MAP_POINTER. + + + + + Returns the pointer value specified by pname. + + + + + + Return the pointer to a mapped buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the pointer to be returned. The symbolic constant must be GL_BUFFER_MAP_POINTER. + + + + + Returns the pointer value specified by pname. + + + + + + Returns a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store from which data will be returned, measured in bytes. + + + + + Specifies the size in bytes of the data store region being returned. + + + + + Specifies a pointer to the location where buffer object data is returned. + + + + + + Returns a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store from which data will be returned, measured in bytes. + + + + + Specifies the size in bytes of the data store region being returned. + + + + + Specifies a pointer to the location where buffer object data is returned. + + + + + + Returns a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store from which data will be returned, measured in bytes. + + + + + Specifies the size in bytes of the data store region being returned. + + + + + Specifies a pointer to the location where buffer object data is returned. + + + + + + Returns a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store from which data will be returned, measured in bytes. + + + + + Specifies the size in bytes of the data store region being returned. + + + + + Specifies a pointer to the location where buffer object data is returned. + + + + + + Returns a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store from which data will be returned, measured in bytes. + + + + + Specifies the size in bytes of the data store region being returned. + + + + + Specifies a pointer to the location where buffer object data is returned. + + + + + + Return the coefficients of the specified clipping plane + + + + Specifies a clipping plane. The number of clipping planes depends on the implementation, but at least six clipping planes are supported. They are identified by symbolic names of the form GL_CLIP_PLANE where i ranges from 0 to the value of GL_MAX_CLIP_PLANES - 1. + + + + + Returns four double-precision values that are the coefficients of the plane equation of plane in eye coordinates. The initial value is (0, 0, 0, 0). + + + + + + Return the coefficients of the specified clipping plane + + + + Specifies a clipping plane. The number of clipping planes depends on the implementation, but at least six clipping planes are supported. They are identified by symbolic names of the form GL_CLIP_PLANE where i ranges from 0 to the value of GL_MAX_CLIP_PLANES - 1. + + + + + Returns four double-precision values that are the coefficients of the plane equation of plane in eye coordinates. The initial value is (0, 0, 0, 0). + + + + + + Return the coefficients of the specified clipping plane + + + + Specifies a clipping plane. The number of clipping planes depends on the implementation, but at least six clipping planes are supported. They are identified by symbolic names of the form GL_CLIP_PLANE where i ranges from 0 to the value of GL_MAX_CLIP_PLANES - 1. + + + + + Returns four double-precision values that are the coefficients of the plane equation of plane in eye coordinates. The initial value is (0, 0, 0, 0). + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Return a compressed texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, and GL_TEXTURE_3D GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Returns the compressed texture image. + + + + + + Return a compressed texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, and GL_TEXTURE_3D GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Returns the compressed texture image. + + + + + + Return a compressed texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, and GL_TEXTURE_3D GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Returns the compressed texture image. + + + + + + Return a compressed texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, and GL_TEXTURE_3D GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Returns the compressed texture image. + + + + + + Return a compressed texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, and GL_TEXTURE_3D GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Returns the compressed texture image. + + + + + + Get current 1D or 2D convolution filter kernel + + + + The filter to be retrieved. Must be one of GL_CONVOLUTION_1D or GL_CONVOLUTION_2D. + + + + + Format of the output image. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output image. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the output image. + + + + + + Get current 1D or 2D convolution filter kernel + + + + The filter to be retrieved. Must be one of GL_CONVOLUTION_1D or GL_CONVOLUTION_2D. + + + + + Format of the output image. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output image. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the output image. + + + + + + Get current 1D or 2D convolution filter kernel + + + + The filter to be retrieved. Must be one of GL_CONVOLUTION_1D or GL_CONVOLUTION_2D. + + + + + Format of the output image. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output image. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the output image. + + + + + + Get current 1D or 2D convolution filter kernel + + + + The filter to be retrieved. Must be one of GL_CONVOLUTION_1D or GL_CONVOLUTION_2D. + + + + + Format of the output image. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output image. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the output image. + + + + + + Get current 1D or 2D convolution filter kernel + + + + The filter to be retrieved. Must be one of GL_CONVOLUTION_1D or GL_CONVOLUTION_2D. + + + + + Format of the output image. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output image. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the output image. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Return error information + + + + + Get histogram table + + + + Must be GL_HISTOGRAM. + + + + + If GL_TRUE, each component counter that is actually returned is reset to zero. (Other counters are unaffected.) If GL_FALSE, none of the counters in the histogram table is modified. + + + + + The format of values to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of values to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned histogram table. + + + + + + Get histogram table + + + + Must be GL_HISTOGRAM. + + + + + If GL_TRUE, each component counter that is actually returned is reset to zero. (Other counters are unaffected.) If GL_FALSE, none of the counters in the histogram table is modified. + + + + + The format of values to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of values to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned histogram table. + + + + + + Get histogram table + + + + Must be GL_HISTOGRAM. + + + + + If GL_TRUE, each component counter that is actually returned is reset to zero. (Other counters are unaffected.) If GL_FALSE, none of the counters in the histogram table is modified. + + + + + The format of values to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of values to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned histogram table. + + + + + + Get histogram table + + + + Must be GL_HISTOGRAM. + + + + + If GL_TRUE, each component counter that is actually returned is reset to zero. (Other counters are unaffected.) If GL_FALSE, none of the counters in the histogram table is modified. + + + + + The format of values to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of values to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned histogram table. + + + + + + Get histogram table + + + + Must be GL_HISTOGRAM. + + + + + If GL_TRUE, each component counter that is actually returned is reset to zero. (Other counters are unaffected.) If GL_FALSE, none of the counters in the histogram table is modified. + + + + + The format of values to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of values to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned histogram table. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Return light source parameter values + + + + Specifies a light source. The number of possible lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT where ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a light source parameter for light. Accepted symbolic names are GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_POSITION, GL_SPOT_DIRECTION, GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION. + + + + + Returns the requested data. + + + + + + Return light source parameter values + + + + Specifies a light source. The number of possible lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT where ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a light source parameter for light. Accepted symbolic names are GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_POSITION, GL_SPOT_DIRECTION, GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION. + + + + + Returns the requested data. + + + + + + Return light source parameter values + + + + Specifies a light source. The number of possible lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT where ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a light source parameter for light. Accepted symbolic names are GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_POSITION, GL_SPOT_DIRECTION, GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION. + + + + + Returns the requested data. + + + + + + Return light source parameter values + + + + Specifies a light source. The number of possible lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT where ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a light source parameter for light. Accepted symbolic names are GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_POSITION, GL_SPOT_DIRECTION, GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION. + + + + + Returns the requested data. + + + + + + Return light source parameter values + + + + Specifies a light source. The number of possible lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT where ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a light source parameter for light. Accepted symbolic names are GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_POSITION, GL_SPOT_DIRECTION, GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION. + + + + + Returns the requested data. + + + + + + Return light source parameter values + + + + Specifies a light source. The number of possible lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT where ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a light source parameter for light. Accepted symbolic names are GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_POSITION, GL_SPOT_DIRECTION, GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION. + + + + + Returns the requested data. + + + + + + Return evaluator parameters + + + + Specifies the symbolic name of a map. Accepted values are GL_MAP1_COLOR_4, GL_MAP1_INDEX, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, GL_MAP1_TEXTURE_COORD_4, GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP2_COLOR_4, GL_MAP2_INDEX, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, GL_MAP2_TEXTURE_COORD_4, GL_MAP2_VERTEX_3, and GL_MAP2_VERTEX_4. + + + + + Specifies which parameter to return. Symbolic names GL_COEFF, GL_ORDER, and GL_DOMAIN are accepted. + + + + + Returns the requested data. + + + + + + Return evaluator parameters + + + + Specifies the symbolic name of a map. Accepted values are GL_MAP1_COLOR_4, GL_MAP1_INDEX, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, GL_MAP1_TEXTURE_COORD_4, GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP2_COLOR_4, GL_MAP2_INDEX, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, GL_MAP2_TEXTURE_COORD_4, GL_MAP2_VERTEX_3, and GL_MAP2_VERTEX_4. + + + + + Specifies which parameter to return. Symbolic names GL_COEFF, GL_ORDER, and GL_DOMAIN are accepted. + + + + + Returns the requested data. + + + + + + Return evaluator parameters + + + + Specifies the symbolic name of a map. Accepted values are GL_MAP1_COLOR_4, GL_MAP1_INDEX, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, GL_MAP1_TEXTURE_COORD_4, GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP2_COLOR_4, GL_MAP2_INDEX, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, GL_MAP2_TEXTURE_COORD_4, GL_MAP2_VERTEX_3, and GL_MAP2_VERTEX_4. + + + + + Specifies which parameter to return. Symbolic names GL_COEFF, GL_ORDER, and GL_DOMAIN are accepted. + + + + + Returns the requested data. + + + + + + Return evaluator parameters + + + + Specifies the symbolic name of a map. Accepted values are GL_MAP1_COLOR_4, GL_MAP1_INDEX, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, GL_MAP1_TEXTURE_COORD_4, GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP2_COLOR_4, GL_MAP2_INDEX, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, GL_MAP2_TEXTURE_COORD_4, GL_MAP2_VERTEX_3, and GL_MAP2_VERTEX_4. + + + + + Specifies which parameter to return. Symbolic names GL_COEFF, GL_ORDER, and GL_DOMAIN are accepted. + + + + + Returns the requested data. + + + + + + Return evaluator parameters + + + + Specifies the symbolic name of a map. Accepted values are GL_MAP1_COLOR_4, GL_MAP1_INDEX, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, GL_MAP1_TEXTURE_COORD_4, GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP2_COLOR_4, GL_MAP2_INDEX, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, GL_MAP2_TEXTURE_COORD_4, GL_MAP2_VERTEX_3, and GL_MAP2_VERTEX_4. + + + + + Specifies which parameter to return. Symbolic names GL_COEFF, GL_ORDER, and GL_DOMAIN are accepted. + + + + + Returns the requested data. + + + + + + Return evaluator parameters + + + + Specifies the symbolic name of a map. Accepted values are GL_MAP1_COLOR_4, GL_MAP1_INDEX, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, GL_MAP1_TEXTURE_COORD_4, GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP2_COLOR_4, GL_MAP2_INDEX, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, GL_MAP2_TEXTURE_COORD_4, GL_MAP2_VERTEX_3, and GL_MAP2_VERTEX_4. + + + + + Specifies which parameter to return. Symbolic names GL_COEFF, GL_ORDER, and GL_DOMAIN are accepted. + + + + + Returns the requested data. + + + + + + Return evaluator parameters + + + + Specifies the symbolic name of a map. Accepted values are GL_MAP1_COLOR_4, GL_MAP1_INDEX, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, GL_MAP1_TEXTURE_COORD_4, GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP2_COLOR_4, GL_MAP2_INDEX, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, GL_MAP2_TEXTURE_COORD_4, GL_MAP2_VERTEX_3, and GL_MAP2_VERTEX_4. + + + + + Specifies which parameter to return. Symbolic names GL_COEFF, GL_ORDER, and GL_DOMAIN are accepted. + + + + + Returns the requested data. + + + + + + Return evaluator parameters + + + + Specifies the symbolic name of a map. Accepted values are GL_MAP1_COLOR_4, GL_MAP1_INDEX, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, GL_MAP1_TEXTURE_COORD_4, GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP2_COLOR_4, GL_MAP2_INDEX, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, GL_MAP2_TEXTURE_COORD_4, GL_MAP2_VERTEX_3, and GL_MAP2_VERTEX_4. + + + + + Specifies which parameter to return. Symbolic names GL_COEFF, GL_ORDER, and GL_DOMAIN are accepted. + + + + + Returns the requested data. + + + + + + Return evaluator parameters + + + + Specifies the symbolic name of a map. Accepted values are GL_MAP1_COLOR_4, GL_MAP1_INDEX, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, GL_MAP1_TEXTURE_COORD_4, GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP2_COLOR_4, GL_MAP2_INDEX, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, GL_MAP2_TEXTURE_COORD_4, GL_MAP2_VERTEX_3, and GL_MAP2_VERTEX_4. + + + + + Specifies which parameter to return. Symbolic names GL_COEFF, GL_ORDER, and GL_DOMAIN are accepted. + + + + + Returns the requested data. + + + + + + Return material parameters + + + + Specifies which of the two materials is being queried. GL_FRONT or GL_BACK are accepted, representing the front and back materials, respectively. + + + + + Specifies the material parameter to return. GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS, and GL_COLOR_INDEXES are accepted. + + + + + Returns the requested data. + + + + + + Return material parameters + + + + Specifies which of the two materials is being queried. GL_FRONT or GL_BACK are accepted, representing the front and back materials, respectively. + + + + + Specifies the material parameter to return. GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS, and GL_COLOR_INDEXES are accepted. + + + + + Returns the requested data. + + + + + + Return material parameters + + + + Specifies which of the two materials is being queried. GL_FRONT or GL_BACK are accepted, representing the front and back materials, respectively. + + + + + Specifies the material parameter to return. GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS, and GL_COLOR_INDEXES are accepted. + + + + + Returns the requested data. + + + + + + Return material parameters + + + + Specifies which of the two materials is being queried. GL_FRONT or GL_BACK are accepted, representing the front and back materials, respectively. + + + + + Specifies the material parameter to return. GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS, and GL_COLOR_INDEXES are accepted. + + + + + Returns the requested data. + + + + + + Return material parameters + + + + Specifies which of the two materials is being queried. GL_FRONT or GL_BACK are accepted, representing the front and back materials, respectively. + + + + + Specifies the material parameter to return. GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS, and GL_COLOR_INDEXES are accepted. + + + + + Returns the requested data. + + + + + + Return material parameters + + + + Specifies which of the two materials is being queried. GL_FRONT or GL_BACK are accepted, representing the front and back materials, respectively. + + + + + Specifies the material parameter to return. GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS, and GL_COLOR_INDEXES are accepted. + + + + + Returns the requested data. + + + + + + Get minimum and maximum pixel values + + + + Must be GL_MINMAX. + + + + + If GL_TRUE, all entries in the minmax table that are actually returned are reset to their initial values. (Other entries are unaltered.) If GL_FALSE, the minmax table is unaltered. + + + + + The format of the data to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of the data to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned values. + + + + + + Get minimum and maximum pixel values + + + + Must be GL_MINMAX. + + + + + If GL_TRUE, all entries in the minmax table that are actually returned are reset to their initial values. (Other entries are unaltered.) If GL_FALSE, the minmax table is unaltered. + + + + + The format of the data to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of the data to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned values. + + + + + + Get minimum and maximum pixel values + + + + Must be GL_MINMAX. + + + + + If GL_TRUE, all entries in the minmax table that are actually returned are reset to their initial values. (Other entries are unaltered.) If GL_FALSE, the minmax table is unaltered. + + + + + The format of the data to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of the data to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned values. + + + + + + Get minimum and maximum pixel values + + + + Must be GL_MINMAX. + + + + + If GL_TRUE, all entries in the minmax table that are actually returned are reset to their initial values. (Other entries are unaltered.) If GL_FALSE, the minmax table is unaltered. + + + + + The format of the data to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of the data to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned values. + + + + + + Get minimum and maximum pixel values + + + + Must be GL_MINMAX. + + + + + If GL_TRUE, all entries in the minmax table that are actually returned are reset to their initial values. (Other entries are unaltered.) If GL_FALSE, the minmax table is unaltered. + + + + + The format of the data to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of the data to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned values. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the specified pixel map + + + + Specifies the name of the pixel map to return. Accepted values are GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, and GL_PIXEL_MAP_A_TO_A. + + + + + Returns the pixel map contents. + + + + + + Return the address of the specified pointer + + + + Specifies the array or buffer pointer to be returned. Symbolic constants GL_COLOR_ARRAY_POINTER, GL_EDGE_FLAG_ARRAY_POINTER, GL_FOG_COORD_ARRAY_POINTER, GL_FEEDBACK_BUFFER_POINTER, GL_INDEX_ARRAY_POINTER, GL_NORMAL_ARRAY_POINTER, GL_SECONDARY_COLOR_ARRAY_POINTER, GL_SELECTION_BUFFER_POINTER, GL_TEXTURE_COORD_ARRAY_POINTER, or GL_VERTEX_ARRAY_POINTER are accepted. + + + + + Returns the pointer value specified by pname. + + + + + + Return the address of the specified pointer + + + + Specifies the array or buffer pointer to be returned. Symbolic constants GL_COLOR_ARRAY_POINTER, GL_EDGE_FLAG_ARRAY_POINTER, GL_FOG_COORD_ARRAY_POINTER, GL_FEEDBACK_BUFFER_POINTER, GL_INDEX_ARRAY_POINTER, GL_NORMAL_ARRAY_POINTER, GL_SECONDARY_COLOR_ARRAY_POINTER, GL_SELECTION_BUFFER_POINTER, GL_TEXTURE_COORD_ARRAY_POINTER, or GL_VERTEX_ARRAY_POINTER are accepted. + + + + + Returns the pointer value specified by pname. + + + + + + Return the address of the specified pointer + + + + Specifies the array or buffer pointer to be returned. Symbolic constants GL_COLOR_ARRAY_POINTER, GL_EDGE_FLAG_ARRAY_POINTER, GL_FOG_COORD_ARRAY_POINTER, GL_FEEDBACK_BUFFER_POINTER, GL_INDEX_ARRAY_POINTER, GL_NORMAL_ARRAY_POINTER, GL_SECONDARY_COLOR_ARRAY_POINTER, GL_SELECTION_BUFFER_POINTER, GL_TEXTURE_COORD_ARRAY_POINTER, or GL_VERTEX_ARRAY_POINTER are accepted. + + + + + Returns the pointer value specified by pname. + + + + + + Return the address of the specified pointer + + + + Specifies the array or buffer pointer to be returned. Symbolic constants GL_COLOR_ARRAY_POINTER, GL_EDGE_FLAG_ARRAY_POINTER, GL_FOG_COORD_ARRAY_POINTER, GL_FEEDBACK_BUFFER_POINTER, GL_INDEX_ARRAY_POINTER, GL_NORMAL_ARRAY_POINTER, GL_SECONDARY_COLOR_ARRAY_POINTER, GL_SELECTION_BUFFER_POINTER, GL_TEXTURE_COORD_ARRAY_POINTER, or GL_VERTEX_ARRAY_POINTER are accepted. + + + + + Returns the pointer value specified by pname. + + + + + + Return the address of the specified pointer + + + + Specifies the array or buffer pointer to be returned. Symbolic constants GL_COLOR_ARRAY_POINTER, GL_EDGE_FLAG_ARRAY_POINTER, GL_FOG_COORD_ARRAY_POINTER, GL_FEEDBACK_BUFFER_POINTER, GL_INDEX_ARRAY_POINTER, GL_NORMAL_ARRAY_POINTER, GL_SECONDARY_COLOR_ARRAY_POINTER, GL_SELECTION_BUFFER_POINTER, GL_TEXTURE_COORD_ARRAY_POINTER, or GL_VERTEX_ARRAY_POINTER are accepted. + + + + + Returns the pointer value specified by pname. + + + + + + Return the polygon stipple pattern + + + + Returns the stipple pattern. The initial value is all 1's. + + + + + + Return the polygon stipple pattern + + + + Returns the stipple pattern. The initial value is all 1's. + + + + + + Return the polygon stipple pattern + + + + Returns the stipple pattern. The initial value is all 1's. + + + + + + Returns the information log for a program object + + + + Specifies the program object whose information log is to be queried. + + + + + Specifies the size of the character buffer for storing the returned information log. + + + + + Returns the length of the string returned in infoLog (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the information log. + + + + + + Returns the information log for a program object + + + + Specifies the program object whose information log is to be queried. + + + + + Specifies the size of the character buffer for storing the returned information log. + + + + + Returns the length of the string returned in infoLog (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the information log. + + + + + + Returns the information log for a program object + + + + Specifies the program object whose information log is to be queried. + + + + + Specifies the size of the character buffer for storing the returned information log. + + + + + Returns the length of the string returned in infoLog (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the information log. + + + + + + Returns the information log for a program object + + + + Specifies the program object whose information log is to be queried. + + + + + Specifies the size of the character buffer for storing the returned information log. + + + + + Returns the length of the string returned in infoLog (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the information log. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Return parameters of a query object target + + + + Specifies a query object target. Must be GL_SAMPLES_PASSED. + + + + + Specifies the symbolic name of a query object target parameter. Accepted values are GL_CURRENT_QUERY or GL_QUERY_COUNTER_BITS. + + + + + Returns the requested data. + + + + + + Return parameters of a query object target + + + + Specifies a query object target. Must be GL_SAMPLES_PASSED. + + + + + Specifies the symbolic name of a query object target parameter. Accepted values are GL_CURRENT_QUERY or GL_QUERY_COUNTER_BITS. + + + + + Returns the requested data. + + + + + + Return parameters of a query object target + + + + Specifies a query object target. Must be GL_SAMPLES_PASSED. + + + + + Specifies the symbolic name of a query object target parameter. Accepted values are GL_CURRENT_QUERY or GL_QUERY_COUNTER_BITS. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Returns the information log for a shader object + + + + Specifies the shader object whose information log is to be queried. + + + + + Specifies the size of the character buffer for storing the returned information log. + + + + + Returns the length of the string returned in infoLog (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the information log. + + + + + + Returns the information log for a shader object + + + + Specifies the shader object whose information log is to be queried. + + + + + Specifies the size of the character buffer for storing the returned information log. + + + + + Returns the length of the string returned in infoLog (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the information log. + + + + + + Returns the information log for a shader object + + + + Specifies the shader object whose information log is to be queried. + + + + + Specifies the size of the character buffer for storing the returned information log. + + + + + Returns the length of the string returned in infoLog (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the information log. + + + + + + Returns the information log for a shader object + + + + Specifies the shader object whose information log is to be queried. + + + + + Specifies the size of the character buffer for storing the returned information log. + + + + + Returns the length of the string returned in infoLog (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the information log. + + + + + + Returns a parameter from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_SHADER_TYPE, GL_DELETE_STATUS, GL_COMPILE_STATUS, GL_INFO_LOG_LENGTH, GL_SHADER_SOURCE_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_SHADER_TYPE, GL_DELETE_STATUS, GL_COMPILE_STATUS, GL_INFO_LOG_LENGTH, GL_SHADER_SOURCE_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_SHADER_TYPE, GL_DELETE_STATUS, GL_COMPILE_STATUS, GL_INFO_LOG_LENGTH, GL_SHADER_SOURCE_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_SHADER_TYPE, GL_DELETE_STATUS, GL_COMPILE_STATUS, GL_INFO_LOG_LENGTH, GL_SHADER_SOURCE_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_SHADER_TYPE, GL_DELETE_STATUS, GL_COMPILE_STATUS, GL_INFO_LOG_LENGTH, GL_SHADER_SOURCE_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_SHADER_TYPE, GL_DELETE_STATUS, GL_COMPILE_STATUS, GL_INFO_LOG_LENGTH, GL_SHADER_SOURCE_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns the source code string from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the size of the character buffer for storing the returned source code string. + + + + + Returns the length of the string returned in source (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the source code string. + + + + + + Returns the source code string from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the size of the character buffer for storing the returned source code string. + + + + + Returns the length of the string returned in source (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the source code string. + + + + + + Returns the source code string from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the size of the character buffer for storing the returned source code string. + + + + + Returns the length of the string returned in source (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the source code string. + + + + + + Returns the source code string from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the size of the character buffer for storing the returned source code string. + + + + + Returns the length of the string returned in source (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the source code string. + + + + + + Return a string describing the current GL connection + + + + Specifies a symbolic constant, one of GL_VENDOR, GL_RENDERER, GL_VERSION, GL_SHADING_LANGUAGE_VERSION, or GL_EXTENSIONS. + + + + + + Return a string describing the current GL connection + + + + Specifies a symbolic constant, one of GL_VENDOR, GL_RENDERER, GL_VERSION, GL_SHADING_LANGUAGE_VERSION, or GL_EXTENSIONS. + + + + + + Return a string describing the current GL connection + + + + Specifies a symbolic constant, one of GL_VENDOR, GL_RENDERER, GL_VERSION, GL_SHADING_LANGUAGE_VERSION, or GL_EXTENSIONS. + + + + + + Return texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL, or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a texture environment parameter. Accepted values are GL_TEXTURE_ENV_MODE, GL_TEXTURE_ENV_COLOR, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Returns the requested data. + + + + + + Return texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL, or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a texture environment parameter. Accepted values are GL_TEXTURE_ENV_MODE, GL_TEXTURE_ENV_COLOR, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Returns the requested data. + + + + + + Return texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL, or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a texture environment parameter. Accepted values are GL_TEXTURE_ENV_MODE, GL_TEXTURE_ENV_COLOR, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Returns the requested data. + + + + + + Return texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL, or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a texture environment parameter. Accepted values are GL_TEXTURE_ENV_MODE, GL_TEXTURE_ENV_COLOR, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Returns the requested data. + + + + + + Return texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL, or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a texture environment parameter. Accepted values are GL_TEXTURE_ENV_MODE, GL_TEXTURE_ENV_COLOR, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Returns the requested data. + + + + + + Return texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL, or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a texture environment parameter. Accepted values are GL_TEXTURE_ENV_MODE, GL_TEXTURE_ENV_COLOR, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Returns the requested data. + + + + + + Return texture coordinate generation parameters + + + + Specifies a texture coordinate. Must be GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the value(s) to be returned. Must be either GL_TEXTURE_GEN_MODE or the name of one of the texture generation plane equations: GL_OBJECT_PLANE or GL_EYE_PLANE. + + + + + Returns the requested data. + + + + + + Return texture coordinate generation parameters + + + + Specifies a texture coordinate. Must be GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the value(s) to be returned. Must be either GL_TEXTURE_GEN_MODE or the name of one of the texture generation plane equations: GL_OBJECT_PLANE or GL_EYE_PLANE. + + + + + Returns the requested data. + + + + + + Return texture coordinate generation parameters + + + + Specifies a texture coordinate. Must be GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the value(s) to be returned. Must be either GL_TEXTURE_GEN_MODE or the name of one of the texture generation plane equations: GL_OBJECT_PLANE or GL_EYE_PLANE. + + + + + Returns the requested data. + + + + + + Return texture coordinate generation parameters + + + + Specifies a texture coordinate. Must be GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the value(s) to be returned. Must be either GL_TEXTURE_GEN_MODE or the name of one of the texture generation plane equations: GL_OBJECT_PLANE or GL_EYE_PLANE. + + + + + Returns the requested data. + + + + + + Return texture coordinate generation parameters + + + + Specifies a texture coordinate. Must be GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the value(s) to be returned. Must be either GL_TEXTURE_GEN_MODE or the name of one of the texture generation plane equations: GL_OBJECT_PLANE or GL_EYE_PLANE. + + + + + Returns the requested data. + + + + + + Return texture coordinate generation parameters + + + + Specifies a texture coordinate. Must be GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the value(s) to be returned. Must be either GL_TEXTURE_GEN_MODE or the name of one of the texture generation plane equations: GL_OBJECT_PLANE or GL_EYE_PLANE. + + + + + Returns the requested data. + + + + + + Return texture coordinate generation parameters + + + + Specifies a texture coordinate. Must be GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the value(s) to be returned. Must be either GL_TEXTURE_GEN_MODE or the name of one of the texture generation plane equations: GL_OBJECT_PLANE or GL_EYE_PLANE. + + + + + Returns the requested data. + + + + + + Return texture coordinate generation parameters + + + + Specifies a texture coordinate. Must be GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the value(s) to be returned. Must be either GL_TEXTURE_GEN_MODE or the name of one of the texture generation plane equations: GL_OBJECT_PLANE or GL_EYE_PLANE. + + + + + Returns the requested data. + + + + + + Return texture coordinate generation parameters + + + + Specifies a texture coordinate. Must be GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the value(s) to be returned. Must be either GL_TEXTURE_GEN_MODE or the name of one of the texture generation plane equations: GL_OBJECT_PLANE or GL_EYE_PLANE. + + + + + Returns the requested data. + + + + + + Return a texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies a pixel format for the returned data. The supported formats are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies a pixel type for the returned data. The supported types are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Returns the texture image. Should be a pointer to an array of the type specified by type. + + + + + + Return a texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies a pixel format for the returned data. The supported formats are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies a pixel type for the returned data. The supported types are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Returns the texture image. Should be a pointer to an array of the type specified by type. + + + + + + Return a texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies a pixel format for the returned data. The supported formats are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies a pixel type for the returned data. The supported types are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Returns the texture image. Should be a pointer to an array of the type specified by type. + + + + + + Return a texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies a pixel format for the returned data. The supported formats are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies a pixel type for the returned data. The supported types are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Returns the texture image. Should be a pointer to an array of the type specified by type. + + + + + + Return a texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies a pixel format for the returned data. The supported formats are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies a pixel type for the returned data. The supported types are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Returns the texture image. Should be a pointer to an array of the type specified by type. + + + + + + Return texture parameter values for a specific level of detail + + + + Specifies the symbolic name of the target texture, either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_PROXY_TEXTURE_1D, GL_PROXY_TEXTURE_2D, GL_PROXY_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_WIDTH, GL_TEXTURE_HEIGHT, GL_TEXTURE_DEPTH, GL_TEXTURE_INTERNAL_FORMAT, GL_TEXTURE_BORDER, GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE, GL_TEXTURE_LUMINANCE_SIZE, GL_TEXTURE_INTENSITY_SIZE, GL_TEXTURE_DEPTH_SIZE, GL_TEXTURE_COMPRESSED, and GL_TEXTURE_COMPRESSED_IMAGE_SIZE are accepted. + + + + + Returns the requested data. + + + + + + Return texture parameter values for a specific level of detail + + + + Specifies the symbolic name of the target texture, either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_PROXY_TEXTURE_1D, GL_PROXY_TEXTURE_2D, GL_PROXY_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_WIDTH, GL_TEXTURE_HEIGHT, GL_TEXTURE_DEPTH, GL_TEXTURE_INTERNAL_FORMAT, GL_TEXTURE_BORDER, GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE, GL_TEXTURE_LUMINANCE_SIZE, GL_TEXTURE_INTENSITY_SIZE, GL_TEXTURE_DEPTH_SIZE, GL_TEXTURE_COMPRESSED, and GL_TEXTURE_COMPRESSED_IMAGE_SIZE are accepted. + + + + + Returns the requested data. + + + + + + Return texture parameter values for a specific level of detail + + + + Specifies the symbolic name of the target texture, either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_PROXY_TEXTURE_1D, GL_PROXY_TEXTURE_2D, GL_PROXY_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_WIDTH, GL_TEXTURE_HEIGHT, GL_TEXTURE_DEPTH, GL_TEXTURE_INTERNAL_FORMAT, GL_TEXTURE_BORDER, GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE, GL_TEXTURE_LUMINANCE_SIZE, GL_TEXTURE_INTENSITY_SIZE, GL_TEXTURE_DEPTH_SIZE, GL_TEXTURE_COMPRESSED, and GL_TEXTURE_COMPRESSED_IMAGE_SIZE are accepted. + + + + + Returns the requested data. + + + + + + Return texture parameter values for a specific level of detail + + + + Specifies the symbolic name of the target texture, either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_PROXY_TEXTURE_1D, GL_PROXY_TEXTURE_2D, GL_PROXY_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_WIDTH, GL_TEXTURE_HEIGHT, GL_TEXTURE_DEPTH, GL_TEXTURE_INTERNAL_FORMAT, GL_TEXTURE_BORDER, GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE, GL_TEXTURE_LUMINANCE_SIZE, GL_TEXTURE_INTENSITY_SIZE, GL_TEXTURE_DEPTH_SIZE, GL_TEXTURE_COMPRESSED, and GL_TEXTURE_COMPRESSED_IMAGE_SIZE are accepted. + + + + + Returns the requested data. + + + + + + Return texture parameter values for a specific level of detail + + + + Specifies the symbolic name of the target texture, either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_PROXY_TEXTURE_1D, GL_PROXY_TEXTURE_2D, GL_PROXY_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_WIDTH, GL_TEXTURE_HEIGHT, GL_TEXTURE_DEPTH, GL_TEXTURE_INTERNAL_FORMAT, GL_TEXTURE_BORDER, GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE, GL_TEXTURE_LUMINANCE_SIZE, GL_TEXTURE_INTENSITY_SIZE, GL_TEXTURE_DEPTH_SIZE, GL_TEXTURE_COMPRESSED, and GL_TEXTURE_COMPRESSED_IMAGE_SIZE are accepted. + + + + + Returns the requested data. + + + + + + Return texture parameter values for a specific level of detail + + + + Specifies the symbolic name of the target texture, either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_PROXY_TEXTURE_1D, GL_PROXY_TEXTURE_2D, GL_PROXY_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_WIDTH, GL_TEXTURE_HEIGHT, GL_TEXTURE_DEPTH, GL_TEXTURE_INTERNAL_FORMAT, GL_TEXTURE_BORDER, GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE, GL_TEXTURE_LUMINANCE_SIZE, GL_TEXTURE_INTENSITY_SIZE, GL_TEXTURE_DEPTH_SIZE, GL_TEXTURE_COMPRESSED, and GL_TEXTURE_COMPRESSED_IMAGE_SIZE are accepted. + + + + + Returns the requested data. + + + + + + Return texture parameter values + + + + Specifies the symbolic name of the target texture. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, and GL_TEXTURE_CUBE_MAP are accepted. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_BORDER_COLOR, GL_TEXTURE_PRIORITY, GL_TEXTURE_RESIDENT, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, and GL_GENERATE_MIPMAP are accepted. + + + + + Returns the texture parameters. + + + + + + Return texture parameter values + + + + Specifies the symbolic name of the target texture. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, and GL_TEXTURE_CUBE_MAP are accepted. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_BORDER_COLOR, GL_TEXTURE_PRIORITY, GL_TEXTURE_RESIDENT, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, and GL_GENERATE_MIPMAP are accepted. + + + + + Returns the texture parameters. + + + + + + Return texture parameter values + + + + Specifies the symbolic name of the target texture. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, and GL_TEXTURE_CUBE_MAP are accepted. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_BORDER_COLOR, GL_TEXTURE_PRIORITY, GL_TEXTURE_RESIDENT, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, and GL_GENERATE_MIPMAP are accepted. + + + + + Returns the texture parameters. + + + + + + Return texture parameter values + + + + Specifies the symbolic name of the target texture. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, and GL_TEXTURE_CUBE_MAP are accepted. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_BORDER_COLOR, GL_TEXTURE_PRIORITY, GL_TEXTURE_RESIDENT, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, and GL_GENERATE_MIPMAP are accepted. + + + + + Returns the texture parameters. + + + + + + Return texture parameter values + + + + Specifies the symbolic name of the target texture. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, and GL_TEXTURE_CUBE_MAP are accepted. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_BORDER_COLOR, GL_TEXTURE_PRIORITY, GL_TEXTURE_RESIDENT, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, and GL_GENERATE_MIPMAP are accepted. + + + + + Returns the texture parameters. + + + + + + Return texture parameter values + + + + Specifies the symbolic name of the target texture. GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, and GL_TEXTURE_CUBE_MAP are accepted. + + + + + Specifies the symbolic name of a texture parameter. GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_BORDER_COLOR, GL_TEXTURE_PRIORITY, GL_TEXTURE_RESIDENT, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, and GL_GENERATE_MIPMAP are accepted. + + + + + Returns the texture parameters. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the location of a uniform variable + + + + Specifies the program object to be queried. + + + + + Points to a null terminated string containing the name of the uniform variable whose location is to be queried. + + + + + + Returns the location of a uniform variable + + + + Specifies the program object to be queried. + + + + + Points to a null terminated string containing the name of the uniform variable whose location is to be queried. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return the address of the specified generic vertex attribute pointer + + + + Specifies the generic vertex attribute parameter to be returned. + + + + + Specifies the symbolic name of the generic vertex attribute parameter to be returned. Must be GL_VERTEX_ATTRIB_ARRAY_POINTER. + + + + + Returns the pointer value. + + + + + + Return the address of the specified generic vertex attribute pointer + + + + Specifies the generic vertex attribute parameter to be returned. + + + + + Specifies the symbolic name of the generic vertex attribute parameter to be returned. Must be GL_VERTEX_ATTRIB_ARRAY_POINTER. + + + + + Returns the pointer value. + + + + + + Return the address of the specified generic vertex attribute pointer + + + + Specifies the generic vertex attribute parameter to be returned. + + + + + Specifies the symbolic name of the generic vertex attribute parameter to be returned. Must be GL_VERTEX_ATTRIB_ARRAY_POINTER. + + + + + Returns the pointer value. + + + + + + Return the address of the specified generic vertex attribute pointer + + + + Specifies the generic vertex attribute parameter to be returned. + + + + + Specifies the symbolic name of the generic vertex attribute parameter to be returned. Must be GL_VERTEX_ATTRIB_ARRAY_POINTER. + + + + + Returns the pointer value. + + + + + + Return the address of the specified generic vertex attribute pointer + + + + Specifies the generic vertex attribute parameter to be returned. + + + + + Specifies the symbolic name of the generic vertex attribute parameter to be returned. Must be GL_VERTEX_ATTRIB_ARRAY_POINTER. + + + + + Returns the pointer value. + + + + + + Return the address of the specified generic vertex attribute pointer + + + + Specifies the generic vertex attribute parameter to be returned. + + + + + Specifies the symbolic name of the generic vertex attribute parameter to be returned. Must be GL_VERTEX_ATTRIB_ARRAY_POINTER. + + + + + Returns the pointer value. + + + + + + Return the address of the specified generic vertex attribute pointer + + + + Specifies the generic vertex attribute parameter to be returned. + + + + + Specifies the symbolic name of the generic vertex attribute parameter to be returned. Must be GL_VERTEX_ATTRIB_ARRAY_POINTER. + + + + + Returns the pointer value. + + + + + + Return the address of the specified generic vertex attribute pointer + + + + Specifies the generic vertex attribute parameter to be returned. + + + + + Specifies the symbolic name of the generic vertex attribute parameter to be returned. Must be GL_VERTEX_ATTRIB_ARRAY_POINTER. + + + + + Returns the pointer value. + + + + + + Return the address of the specified generic vertex attribute pointer + + + + Specifies the generic vertex attribute parameter to be returned. + + + + + Specifies the symbolic name of the generic vertex attribute parameter to be returned. Must be GL_VERTEX_ATTRIB_ARRAY_POINTER. + + + + + Returns the pointer value. + + + + + + Return the address of the specified generic vertex attribute pointer + + + + Specifies the generic vertex attribute parameter to be returned. + + + + + Specifies the symbolic name of the generic vertex attribute parameter to be returned. Must be GL_VERTEX_ATTRIB_ARRAY_POINTER. + + + + + Returns the pointer value. + + + + + + Specify implementation-specific hints + + + + Specifies a symbolic constant indicating the behavior to be controlled. GL_FOG_HINT, GL_GENERATE_MIPMAP_HINT, GL_LINE_SMOOTH_HINT, GL_PERSPECTIVE_CORRECTION_HINT, GL_POINT_SMOOTH_HINT, GL_POLYGON_SMOOTH_HINT, GL_TEXTURE_COMPRESSION_HINT, and GL_FRAGMENT_SHADER_DERIVATIVE_HINT are accepted. + + + + + Specifies a symbolic constant indicating the desired behavior. GL_FASTEST, GL_NICEST, and GL_DONT_CARE are accepted. + + + + + + Define histogram table + + + + The histogram whose parameters are to be set. Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The number of entries in the histogram table. Must be a power of 2. + + + + + The format of entries in the histogram table. Must be one of GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + If GL_TRUE, pixels will be consumed by the histogramming process and no drawing or texture loading will take place. If GL_FALSE, pixels will proceed to the minmax process after histogramming. + + + + + + Set the current color index + + + + Specifies the new value for the current color index. + + + + + + + + + Set the current color index + + + + Specifies the new value for the current color index. + + + + + + + + + Set the current color index + + + + Specifies the new value for the current color index. + + + + + + + + + Set the current color index + + + + Specifies the new value for the current color index. + + + + + + + + + Set the current color index + + + + Specifies the new value for the current color index. + + + + + + + + + Set the current color index + + + + Specifies the new value for the current color index. + + + + + + + + + Control the writing of individual bits in the color index buffers + + + + Specifies a bit mask to enable and disable the writing of individual bits in the color index buffers. Initially, the mask is all 1's. + + + + + + Control the writing of individual bits in the color index buffers + + + + Specifies a bit mask to enable and disable the writing of individual bits in the color index buffers. Initially, the mask is all 1's. + + + + + + Define an array of color indexes + + + + Specifies the data type of each color index in the array. Symbolic constants GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive color indexes. If stride is 0, the color indexes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first index in the array. The initial value is 0. + + + + + + Define an array of color indexes + + + + Specifies the data type of each color index in the array. Symbolic constants GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive color indexes. If stride is 0, the color indexes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first index in the array. The initial value is 0. + + + + + + Define an array of color indexes + + + + Specifies the data type of each color index in the array. Symbolic constants GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive color indexes. If stride is 0, the color indexes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first index in the array. The initial value is 0. + + + + + + Define an array of color indexes + + + + Specifies the data type of each color index in the array. Symbolic constants GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive color indexes. If stride is 0, the color indexes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first index in the array. The initial value is 0. + + + + + + Define an array of color indexes + + + + Specifies the data type of each color index in the array. Symbolic constants GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive color indexes. If stride is 0, the color indexes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first index in the array. The initial value is 0. + + + + + + Set the current color index + + + + Specifies the new value for the current color index. + + + + + + + + + Set the current color index + + + + Specifies the new value for the current color index. + + + + + + + + + Set the current color index + + + + Specifies the new value for the current color index. + + + + + + + + + Set the current color index + + + + Specifies the new value for the current color index. + + + + + + + + + Initialize the name stack + + + + + Simultaneously specify and enable several interleaved arrays + + + + Specifies the type of array to enable. Symbolic constants GL_V2F, GL_V3F, GL_C4UB_V2F, GL_C4UB_V3F, GL_C3F_V3F, GL_N3F_V3F, GL_C4F_N3F_V3F, GL_T2F_V3F, GL_T4F_V4F, GL_T2F_C4UB_V3F, GL_T2F_C3F_V3F, GL_T2F_N3F_V3F, GL_T2F_C4F_N3F_V3F, and GL_T4F_C4F_N3F_V4F are accepted. + + + + + Specifies the offset in bytes between each aggregate array element. + + + + + + Simultaneously specify and enable several interleaved arrays + + + + Specifies the type of array to enable. Symbolic constants GL_V2F, GL_V3F, GL_C4UB_V2F, GL_C4UB_V3F, GL_C3F_V3F, GL_N3F_V3F, GL_C4F_N3F_V3F, GL_T2F_V3F, GL_T4F_V4F, GL_T2F_C4UB_V3F, GL_T2F_C3F_V3F, GL_T2F_N3F_V3F, GL_T2F_C4F_N3F_V3F, and GL_T4F_C4F_N3F_V4F are accepted. + + + + + Specifies the offset in bytes between each aggregate array element. + + + + + + Simultaneously specify and enable several interleaved arrays + + + + Specifies the type of array to enable. Symbolic constants GL_V2F, GL_V3F, GL_C4UB_V2F, GL_C4UB_V3F, GL_C3F_V3F, GL_N3F_V3F, GL_C4F_N3F_V3F, GL_T2F_V3F, GL_T4F_V4F, GL_T2F_C4UB_V3F, GL_T2F_C3F_V3F, GL_T2F_N3F_V3F, GL_T2F_C4F_N3F_V3F, and GL_T4F_C4F_N3F_V4F are accepted. + + + + + Specifies the offset in bytes between each aggregate array element. + + + + + + Simultaneously specify and enable several interleaved arrays + + + + Specifies the type of array to enable. Symbolic constants GL_V2F, GL_V3F, GL_C4UB_V2F, GL_C4UB_V3F, GL_C3F_V3F, GL_N3F_V3F, GL_C4F_N3F_V3F, GL_T2F_V3F, GL_T4F_V4F, GL_T2F_C4UB_V3F, GL_T2F_C3F_V3F, GL_T2F_N3F_V3F, GL_T2F_C4F_N3F_V3F, and GL_T4F_C4F_N3F_V4F are accepted. + + + + + Specifies the offset in bytes between each aggregate array element. + + + + + + Simultaneously specify and enable several interleaved arrays + + + + Specifies the type of array to enable. Symbolic constants GL_V2F, GL_V3F, GL_C4UB_V2F, GL_C4UB_V3F, GL_C3F_V3F, GL_N3F_V3F, GL_C4F_N3F_V3F, GL_T2F_V3F, GL_T4F_V4F, GL_T2F_C4UB_V3F, GL_T2F_C3F_V3F, GL_T2F_N3F_V3F, GL_T2F_C4F_N3F_V3F, and GL_T4F_C4F_N3F_V4F are accepted. + + + + + Specifies the offset in bytes between each aggregate array element. + + + + + + Determine if a name corresponds to a buffer object + + + + Specifies a value that may be the name of a buffer object. + + + + + + Determine if a name corresponds to a buffer object + + + + Specifies a value that may be the name of a buffer object. + + + + + + Test whether a capability is enabled + + + + Specifies a symbolic constant indicating a GL capability. + + + + + + Test whether a capability is enabled + + + + Specifies a symbolic constant indicating a GL capability. + + + + + + Test whether a capability is enabled + + + + Specifies a symbolic constant indicating a GL capability. + + + + + + Determine if a name corresponds to a display list + + + + Specifies a potential display list name. + + + + + + Determine if a name corresponds to a display list + + + + Specifies a potential display list name. + + + + + + Determines if a name corresponds to a program object + + + + Specifies a potential program object. + + + + + + Determines if a name corresponds to a program object + + + + Specifies a potential program object. + + + + + + Determine if a name corresponds to a query object + + + + Specifies a value that may be the name of a query object. + + + + + + Determine if a name corresponds to a query object + + + + Specifies a value that may be the name of a query object. + + + + + + Determines if a name corresponds to a shader object + + + + Specifies a potential shader object. + + + + + + Determines if a name corresponds to a shader object + + + + Specifies a potential shader object. + + + + + + Determine if a name corresponds to a texture + + + + Specifies a value that may be the name of a texture. + + + + + + Determine if a name corresponds to a texture + + + + Specifies a value that may be the name of a texture. + + + + + + Set light source parameters + + + + Specifies a light. The number of lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT , where i ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a single-valued light source parameter for light. GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION are accepted. + + + + + Specifies the value that parameter pname of light source light will be set to. + + + + + + Set light source parameters + + + + Specifies a light. The number of lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT , where i ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a single-valued light source parameter for light. GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION are accepted. + + + + + Specifies the value that parameter pname of light source light will be set to. + + + + + + Set light source parameters + + + + Specifies a light. The number of lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT , where i ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a single-valued light source parameter for light. GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION are accepted. + + + + + Specifies the value that parameter pname of light source light will be set to. + + + + + + Set light source parameters + + + + Specifies a light. The number of lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT , where i ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a single-valued light source parameter for light. GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION are accepted. + + + + + Specifies the value that parameter pname of light source light will be set to. + + + + + + Set light source parameters + + + + Specifies a light. The number of lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT , where i ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a single-valued light source parameter for light. GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION are accepted. + + + + + Specifies the value that parameter pname of light source light will be set to. + + + + + + Set light source parameters + + + + Specifies a light. The number of lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHT , where i ranges from 0 to the value of GL_MAX_LIGHTS - 1. + + + + + Specifies a single-valued light source parameter for light. GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION are accepted. + + + + + Specifies the value that parameter pname of light source light will be set to. + + + + + + Set the lighting model parameters + + + + Specifies a single-valued lighting model parameter. GL_LIGHT_MODEL_LOCAL_VIEWER, GL_LIGHT_MODEL_COLOR_CONTROL, and GL_LIGHT_MODEL_TWO_SIDE are accepted. + + + + + Specifies the value that param will be set to. + + + + + + Set the lighting model parameters + + + + Specifies a single-valued lighting model parameter. GL_LIGHT_MODEL_LOCAL_VIEWER, GL_LIGHT_MODEL_COLOR_CONTROL, and GL_LIGHT_MODEL_TWO_SIDE are accepted. + + + + + Specifies the value that param will be set to. + + + + + + Set the lighting model parameters + + + + Specifies a single-valued lighting model parameter. GL_LIGHT_MODEL_LOCAL_VIEWER, GL_LIGHT_MODEL_COLOR_CONTROL, and GL_LIGHT_MODEL_TWO_SIDE are accepted. + + + + + Specifies the value that param will be set to. + + + + + + Set the lighting model parameters + + + + Specifies a single-valued lighting model parameter. GL_LIGHT_MODEL_LOCAL_VIEWER, GL_LIGHT_MODEL_COLOR_CONTROL, and GL_LIGHT_MODEL_TWO_SIDE are accepted. + + + + + Specifies the value that param will be set to. + + + + + + Set the lighting model parameters + + + + Specifies a single-valued lighting model parameter. GL_LIGHT_MODEL_LOCAL_VIEWER, GL_LIGHT_MODEL_COLOR_CONTROL, and GL_LIGHT_MODEL_TWO_SIDE are accepted. + + + + + Specifies the value that param will be set to. + + + + + + Set the lighting model parameters + + + + Specifies a single-valued lighting model parameter. GL_LIGHT_MODEL_LOCAL_VIEWER, GL_LIGHT_MODEL_COLOR_CONTROL, and GL_LIGHT_MODEL_TWO_SIDE are accepted. + + + + + Specifies the value that param will be set to. + + + + + + Specify the line stipple pattern + + + + Specifies a multiplier for each bit in the line stipple pattern. If factor is 3, for example, each bit in the pattern is used three times before the next bit in the pattern is used. factor is clamped to the range [1, 256] and defaults to 1. + + + + + Specifies a 16-bit integer whose bit pattern determines which fragments of a line will be drawn when the line is rasterized. Bit zero is used first; the default pattern is all 1's. + + + + + + Specify the line stipple pattern + + + + Specifies a multiplier for each bit in the line stipple pattern. If factor is 3, for example, each bit in the pattern is used three times before the next bit in the pattern is used. factor is clamped to the range [1, 256] and defaults to 1. + + + + + Specifies a 16-bit integer whose bit pattern determines which fragments of a line will be drawn when the line is rasterized. Bit zero is used first; the default pattern is all 1's. + + + + + + Specify the width of rasterized lines + + + + Specifies the width of rasterized lines. The initial value is 1. + + + + + + Links a program object + + + + Specifies the handle of the program object to be linked. + + + + + + Links a program object + + + + Specifies the handle of the program object to be linked. + + + + + + Set the display-list base for glCallLists + + + + Specifies an integer offset that will be added to glCallLists offsets to generate display-list names. The initial value is 0. + + + + + + Set the display-list base for glCallLists + + + + Specifies an integer offset that will be added to glCallLists offsets to generate display-list names. The initial value is 0. + + + + + + Replace the current matrix with the identity matrix + + + + + Replace the current matrix with the specified matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 column-major matrix. + + + + + + Replace the current matrix with the specified matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 column-major matrix. + + + + + + Replace the current matrix with the specified matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 column-major matrix. + + + + + + Replace the current matrix with the specified matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 column-major matrix. + + + + + + Replace the current matrix with the specified matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 column-major matrix. + + + + + + Replace the current matrix with the specified matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 column-major matrix. + + + + + + Load a name onto the name stack + + + + Specifies a name that will replace the top value on the name stack. + + + + + + Load a name onto the name stack + + + + Specifies a name that will replace the top value on the name stack. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Specify a logical pixel operation for color index rendering + + + + Specifies a symbolic constant that selects a logical operation. The following symbols are accepted: GL_CLEAR, GL_SET, GL_COPY, GL_COPY_INVERTED, GL_NOOP, GL_INVERT, GL_AND, GL_NAND, GL_OR, GL_NOR, GL_XOR, GL_EQUIV, GL_AND_REVERSE, GL_AND_INVERTED, GL_OR_REVERSE, and GL_OR_INVERTED. The initial value is GL_COPY. + + + + + + Define a one-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP1_INDEX, GL_MAP1_COLOR_4, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, and GL_MAP1_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord1, to u hat, the variable that is evaluated by the equations specified by this command. + + + + + Specifies the number of floats or doubles between the beginning of one control point and the beginning of the next one in the data structure referenced in points. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. + + + + + Specifies the number of control points. Must be positive. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a one-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP1_INDEX, GL_MAP1_COLOR_4, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, and GL_MAP1_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord1, to u hat, the variable that is evaluated by the equations specified by this command. + + + + + Specifies the number of floats or doubles between the beginning of one control point and the beginning of the next one in the data structure referenced in points. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. + + + + + Specifies the number of control points. Must be positive. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a one-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP1_INDEX, GL_MAP1_COLOR_4, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, and GL_MAP1_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord1, to u hat, the variable that is evaluated by the equations specified by this command. + + + + + Specifies the number of floats or doubles between the beginning of one control point and the beginning of the next one in the data structure referenced in points. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. + + + + + Specifies the number of control points. Must be positive. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a one-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP1_INDEX, GL_MAP1_COLOR_4, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, and GL_MAP1_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord1, to u hat, the variable that is evaluated by the equations specified by this command. + + + + + Specifies the number of floats or doubles between the beginning of one control point and the beginning of the next one in the data structure referenced in points. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. + + + + + Specifies the number of control points. Must be positive. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a one-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP1_INDEX, GL_MAP1_COLOR_4, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, and GL_MAP1_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord1, to u hat, the variable that is evaluated by the equations specified by this command. + + + + + Specifies the number of floats or doubles between the beginning of one control point and the beginning of the next one in the data structure referenced in points. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. + + + + + Specifies the number of control points. Must be positive. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a one-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP1_VERTEX_3, GL_MAP1_VERTEX_4, GL_MAP1_INDEX, GL_MAP1_COLOR_4, GL_MAP1_NORMAL, GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, and GL_MAP1_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord1, to u hat, the variable that is evaluated by the equations specified by this command. + + + + + Specifies the number of floats or doubles between the beginning of one control point and the beginning of the next one in the data structure referenced in points. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. + + + + + Specifies the number of control points. Must be positive. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a two-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP2_VERTEX_3, GL_MAP2_VERTEX_4, GL_MAP2_INDEX, GL_MAP2_COLOR_4, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, and GL_MAP2_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to u hat, one of the two variables that are evaluated by the equations specified by this command. Initially, u1 is 0 and u2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { (i+1) j }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of ustride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to v hat, one of the two variables that are evaluated by the equations specified by this command. Initially, v1 is 0 and v2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { i (j+1) }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of vstride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a two-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP2_VERTEX_3, GL_MAP2_VERTEX_4, GL_MAP2_INDEX, GL_MAP2_COLOR_4, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, and GL_MAP2_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to u hat, one of the two variables that are evaluated by the equations specified by this command. Initially, u1 is 0 and u2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { (i+1) j }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of ustride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to v hat, one of the two variables that are evaluated by the equations specified by this command. Initially, v1 is 0 and v2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { i (j+1) }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of vstride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a two-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP2_VERTEX_3, GL_MAP2_VERTEX_4, GL_MAP2_INDEX, GL_MAP2_COLOR_4, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, and GL_MAP2_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to u hat, one of the two variables that are evaluated by the equations specified by this command. Initially, u1 is 0 and u2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { (i+1) j }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of ustride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to v hat, one of the two variables that are evaluated by the equations specified by this command. Initially, v1 is 0 and v2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { i (j+1) }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of vstride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a two-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP2_VERTEX_3, GL_MAP2_VERTEX_4, GL_MAP2_INDEX, GL_MAP2_COLOR_4, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, and GL_MAP2_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to u hat, one of the two variables that are evaluated by the equations specified by this command. Initially, u1 is 0 and u2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { (i+1) j }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of ustride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to v hat, one of the two variables that are evaluated by the equations specified by this command. Initially, v1 is 0 and v2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { i (j+1) }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of vstride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a two-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP2_VERTEX_3, GL_MAP2_VERTEX_4, GL_MAP2_INDEX, GL_MAP2_COLOR_4, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, and GL_MAP2_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to u hat, one of the two variables that are evaluated by the equations specified by this command. Initially, u1 is 0 and u2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { (i+1) j }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of ustride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to v hat, one of the two variables that are evaluated by the equations specified by this command. Initially, v1 is 0 and v2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { i (j+1) }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of vstride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specifies a pointer to the array of control points. + + + + + + Define a two-dimensional evaluator + + + + Specifies the kind of values that are generated by the evaluator. Symbolic constants GL_MAP2_VERTEX_3, GL_MAP2_VERTEX_4, GL_MAP2_INDEX, GL_MAP2_COLOR_4, GL_MAP2_NORMAL, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, and GL_MAP2_TEXTURE_COORD_4 are accepted. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to u hat, one of the two variables that are evaluated by the equations specified by this command. Initially, u1 is 0 and u2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { (i+1) j }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of ustride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specify a linear mapping of , as presented to glEvalCoord2, to v hat, one of the two variables that are evaluated by the equations specified by this command. Initially, v1 is 0 and v2 is 1. + + + + + Specifies the number of floats or doubles between the beginning of control point R sub ij and the beginning of control point R sub { i (j+1) }, where and are the and control point indices, respectively. This allows control points to be embedded in arbitrary data structures. The only constraint is that the values for a particular control point must occupy contiguous memory locations. The initial value of vstride is 0. + + + + + Specifies the dimension of the control point array in the axis. Must be positive. The initial value is 1. + + + + + Specifies a pointer to the array of control points. + + + + + + Map a buffer object's data store + + + + Specifies the target buffer object being mapped. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the access policy, indicating whether it will be possible to read from, write to, or both read from and write to the buffer object's mapped data store. The symbolic constant must be GL_READ_ONLY, GL_WRITE_ONLY, or GL_READ_WRITE. + + + + + + Define a one- or two-dimensional mesh + + + + Specifies the number of partitions in the grid range interval [u1, u2]. Must be positive. + + + + + Specify the mappings for integer grid domain values i = 0 and i = un. + + + + + Specifies the number of partitions in the grid range interval [v1, v2] (glMapGrid2 only). + + + + + Specify the mappings for integer grid domain values j = 0 and j = vn (glMapGrid2 only). + + + + + + Define a one- or two-dimensional mesh + + + + Specifies the number of partitions in the grid range interval [u1, u2]. Must be positive. + + + + + Specify the mappings for integer grid domain values i = 0 and i = un. + + + + + Specifies the number of partitions in the grid range interval [v1, v2] (glMapGrid2 only). + + + + + Specify the mappings for integer grid domain values j = 0 and j = vn (glMapGrid2 only). + + + + + + Define a one- or two-dimensional mesh + + + + Specifies the number of partitions in the grid range interval [u1, u2]. Must be positive. + + + + + Specify the mappings for integer grid domain values i = 0 and i = un. + + + + + Specifies the number of partitions in the grid range interval [v1, v2] (glMapGrid2 only). + + + + + Specify the mappings for integer grid domain values j = 0 and j = vn (glMapGrid2 only). + + + + + + Define a one- or two-dimensional mesh + + + + Specifies the number of partitions in the grid range interval [u1, u2]. Must be positive. + + + + + Specify the mappings for integer grid domain values i = 0 and i = un. + + + + + Specifies the number of partitions in the grid range interval [v1, v2] (glMapGrid2 only). + + + + + Specify the mappings for integer grid domain values j = 0 and j = vn (glMapGrid2 only). + + + + + + Specify material parameters for the lighting model + + + + Specifies which face or faces are being updated. Must be one of GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK. + + + + + Specifies the single-valued material parameter of the face or faces that is being updated. Must be GL_SHININESS. + + + + + Specifies the value that parameter GL_SHININESS will be set to. + + + + + + Specify material parameters for the lighting model + + + + Specifies which face or faces are being updated. Must be one of GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK. + + + + + Specifies the single-valued material parameter of the face or faces that is being updated. Must be GL_SHININESS. + + + + + Specifies the value that parameter GL_SHININESS will be set to. + + + + + + Specify material parameters for the lighting model + + + + Specifies which face or faces are being updated. Must be one of GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK. + + + + + Specifies the single-valued material parameter of the face or faces that is being updated. Must be GL_SHININESS. + + + + + Specifies the value that parameter GL_SHININESS will be set to. + + + + + + Specify material parameters for the lighting model + + + + Specifies which face or faces are being updated. Must be one of GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK. + + + + + Specifies the single-valued material parameter of the face or faces that is being updated. Must be GL_SHININESS. + + + + + Specifies the value that parameter GL_SHININESS will be set to. + + + + + + Specify material parameters for the lighting model + + + + Specifies which face or faces are being updated. Must be one of GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK. + + + + + Specifies the single-valued material parameter of the face or faces that is being updated. Must be GL_SHININESS. + + + + + Specifies the value that parameter GL_SHININESS will be set to. + + + + + + Specify material parameters for the lighting model + + + + Specifies which face or faces are being updated. Must be one of GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK. + + + + + Specifies the single-valued material parameter of the face or faces that is being updated. Must be GL_SHININESS. + + + + + Specifies the value that parameter GL_SHININESS will be set to. + + + + + + Specify which matrix is the current matrix + + + + Specifies which matrix stack is the target for subsequent matrix operations. Three values are accepted: GL_MODELVIEW, GL_PROJECTION, and GL_TEXTURE. The initial value is GL_MODELVIEW. Additionally, if the ARB_imaging extension is supported, GL_COLOR is also accepted. + + + + + + Define minmax table + + + + The minmax table whose parameters are to be set. Must be GL_MINMAX. + + + + + The format of entries in the minmax table. Must be one of GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + If GL_TRUE, pixels will be consumed by the minmax process and no drawing or texture loading will take place. If GL_FALSE, pixels will proceed to the final conversion process after minmax. + + + + + + Render multiple sets of primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of starting indices in the enabled arrays. + + + + + Points to an array of the number of indices to be rendered. + + + + + Specifies the size of the first and count + + + + + + Render multiple sets of primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of starting indices in the enabled arrays. + + + + + Points to an array of the number of indices to be rendered. + + + + + Specifies the size of the first and count + + + + + + Render multiple sets of primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of starting indices in the enabled arrays. + + + + + Points to an array of the number of indices to be rendered. + + + + + Specifies the size of the first and count + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Multiply the current matrix with the specified matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 column-major matrix. + + + + + + Multiply the current matrix with the specified matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 column-major matrix. + + + + + + Multiply the current matrix with the specified matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 column-major matrix. + + + + + + Multiply the current matrix with the specified matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 column-major matrix. + + + + + + Multiply the current matrix with the specified matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 column-major matrix. + + + + + + Multiply the current matrix with the specified matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 column-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Create or replace a display list + + + + Specifies the display-list name. + + + + + Specifies the compilation mode, which can be GL_COMPILE or GL_COMPILE_AND_EXECUTE. + + + + + + Create or replace a display list + + + + Specifies the display-list name. + + + + + Specifies the compilation mode, which can be GL_COMPILE or GL_COMPILE_AND_EXECUTE. + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Set the current normal vector + + + + Specify the , , and coordinates of the new current normal. The initial value of the current normal is the unit vector, (0, 0, 1). + + + + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Multiply the current matrix with an orthographic matrix + + + + Specify the coordinates for the left and right vertical clipping planes. + + + + + Specify the coordinates for the bottom and top horizontal clipping planes. + + + + + Specify the distances to the nearer and farther depth clipping planes. These values are negative if the plane is to be behind the viewer. + + + + + + Place a marker in the feedback buffer + + + + Specifies a marker value to be placed in the feedback buffer following a GL_PASS_THROUGH_TOKEN. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set up pixel transfer maps + + + + Specifies a symbolic map name. Must be one of the following: GL_PIXEL_MAP_I_TO_I, GL_PIXEL_MAP_S_TO_S, GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, GL_PIXEL_MAP_R_TO_R, GL_PIXEL_MAP_G_TO_G, GL_PIXEL_MAP_B_TO_B, or GL_PIXEL_MAP_A_TO_A. + + + + + Specifies the size of the map being defined. + + + + + Specifies an array of mapsize values. + + + + + + Set pixel storage modes + + + + Specifies the symbolic name of the parameter to be set. Six values affect the packing of pixel data into memory: GL_PACK_SWAP_BYTES, GL_PACK_LSB_FIRST, GL_PACK_ROW_LENGTH, GL_PACK_IMAGE_HEIGHT, GL_PACK_SKIP_PIXELS, GL_PACK_SKIP_ROWS, GL_PACK_SKIP_IMAGES, and GL_PACK_ALIGNMENT. Six more affect the unpacking of pixel data from memory: GL_UNPACK_SWAP_BYTES, GL_UNPACK_LSB_FIRST, GL_UNPACK_ROW_LENGTH, GL_UNPACK_IMAGE_HEIGHT, GL_UNPACK_SKIP_PIXELS, GL_UNPACK_SKIP_ROWS, GL_UNPACK_SKIP_IMAGES, and GL_UNPACK_ALIGNMENT. + + + + + Specifies the value that pname is set to. + + + + + + Set pixel storage modes + + + + Specifies the symbolic name of the parameter to be set. Six values affect the packing of pixel data into memory: GL_PACK_SWAP_BYTES, GL_PACK_LSB_FIRST, GL_PACK_ROW_LENGTH, GL_PACK_IMAGE_HEIGHT, GL_PACK_SKIP_PIXELS, GL_PACK_SKIP_ROWS, GL_PACK_SKIP_IMAGES, and GL_PACK_ALIGNMENT. Six more affect the unpacking of pixel data from memory: GL_UNPACK_SWAP_BYTES, GL_UNPACK_LSB_FIRST, GL_UNPACK_ROW_LENGTH, GL_UNPACK_IMAGE_HEIGHT, GL_UNPACK_SKIP_PIXELS, GL_UNPACK_SKIP_ROWS, GL_UNPACK_SKIP_IMAGES, and GL_UNPACK_ALIGNMENT. + + + + + Specifies the value that pname is set to. + + + + + + Set pixel transfer modes + + + + Specifies the symbolic name of the pixel transfer parameter to be set. Must be one of the following: GL_MAP_COLOR, GL_MAP_STENCIL, GL_INDEX_SHIFT, GL_INDEX_OFFSET, GL_RED_SCALE, GL_RED_BIAS, GL_GREEN_SCALE, GL_GREEN_BIAS, GL_BLUE_SCALE, GL_BLUE_BIAS, GL_ALPHA_SCALE, GL_ALPHA_BIAS, GL_DEPTH_SCALE, or GL_DEPTH_BIAS. + + + Additionally, if the ARB_imaging extension is supported, the following symbolic names are accepted: GL_POST_COLOR_MATRIX_RED_SCALE, GL_POST_COLOR_MATRIX_GREEN_SCALE, GL_POST_COLOR_MATRIX_BLUE_SCALE, GL_POST_COLOR_MATRIX_ALPHA_SCALE, GL_POST_COLOR_MATRIX_RED_BIAS, GL_POST_COLOR_MATRIX_GREEN_BIAS, GL_POST_COLOR_MATRIX_BLUE_BIAS, GL_POST_COLOR_MATRIX_ALPHA_BIAS, GL_POST_CONVOLUTION_RED_SCALE, GL_POST_CONVOLUTION_GREEN_SCALE, GL_POST_CONVOLUTION_BLUE_SCALE, GL_POST_CONVOLUTION_ALPHA_SCALE, GL_POST_CONVOLUTION_RED_BIAS, GL_POST_CONVOLUTION_GREEN_BIAS, GL_POST_CONVOLUTION_BLUE_BIAS, and GL_POST_CONVOLUTION_ALPHA_BIAS. + + + + + Specifies the value that pname is set to. + + + + + + Set pixel transfer modes + + + + Specifies the symbolic name of the pixel transfer parameter to be set. Must be one of the following: GL_MAP_COLOR, GL_MAP_STENCIL, GL_INDEX_SHIFT, GL_INDEX_OFFSET, GL_RED_SCALE, GL_RED_BIAS, GL_GREEN_SCALE, GL_GREEN_BIAS, GL_BLUE_SCALE, GL_BLUE_BIAS, GL_ALPHA_SCALE, GL_ALPHA_BIAS, GL_DEPTH_SCALE, or GL_DEPTH_BIAS. + + + Additionally, if the ARB_imaging extension is supported, the following symbolic names are accepted: GL_POST_COLOR_MATRIX_RED_SCALE, GL_POST_COLOR_MATRIX_GREEN_SCALE, GL_POST_COLOR_MATRIX_BLUE_SCALE, GL_POST_COLOR_MATRIX_ALPHA_SCALE, GL_POST_COLOR_MATRIX_RED_BIAS, GL_POST_COLOR_MATRIX_GREEN_BIAS, GL_POST_COLOR_MATRIX_BLUE_BIAS, GL_POST_COLOR_MATRIX_ALPHA_BIAS, GL_POST_CONVOLUTION_RED_SCALE, GL_POST_CONVOLUTION_GREEN_SCALE, GL_POST_CONVOLUTION_BLUE_SCALE, GL_POST_CONVOLUTION_ALPHA_SCALE, GL_POST_CONVOLUTION_RED_BIAS, GL_POST_CONVOLUTION_GREEN_BIAS, GL_POST_CONVOLUTION_BLUE_BIAS, and GL_POST_CONVOLUTION_ALPHA_BIAS. + + + + + Specifies the value that pname is set to. + + + + + + Specify the pixel zoom factors + + + + Specify the and zoom factors for pixel write operations. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify the diameter of rasterized points + + + + Specifies the diameter of rasterized points. The initial value is 1. + + + + + + Select a polygon rasterization mode + + + + Specifies the polygons that mode applies to. Must be GL_FRONT for front-facing polygons, GL_BACK for back-facing polygons, or GL_FRONT_AND_BACK for front- and back-facing polygons. + + + + + Specifies how polygons will be rasterized. Accepted values are GL_POINT, GL_LINE, and GL_FILL. The initial value is GL_FILL for both front- and back-facing polygons. + + + + + + Set the scale and units used to calculate depth values + + + + Specifies a scale factor that is used to create a variable depth offset for each polygon. The initial value is 0. + + + + + Is multiplied by an implementation-specific value to create a constant depth offset. The initial value is 0. + + + + + + Set the polygon stippling pattern + + + + Specifies a pointer to a 32 times 32 stipple pattern that will be unpacked from memory in the same way that glDrawPixels unpacks pixels. + + + + + + Set the polygon stippling pattern + + + + Specifies a pointer to a 32 times 32 stipple pattern that will be unpacked from memory in the same way that glDrawPixels unpacks pixels. + + + + + + Set the polygon stippling pattern + + + + Specifies a pointer to a 32 times 32 stipple pattern that will be unpacked from memory in the same way that glDrawPixels unpacks pixels. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Push and pop the server attribute stack + + + + Specifies a mask that indicates which attributes to save. Values for mask are listed below. + + + + + + Push and pop the client attribute stack + + + + Specifies a mask that indicates which attributes to save. Values for mask are listed below. + + + + + + Push and pop the current matrix stack + + + + + Push and pop the name stack + + + + Specifies a name that will be pushed onto the name stack. + + + + + + Push and pop the name stack + + + + Specifies a name that will be pushed onto the name stack. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Specify the raster position for pixel operations + + + + Specify the , , , and object coordinates (if present) for the raster position. + + + + + + Select a color buffer source for pixels + + + + Specifies a color buffer. Accepted values are GL_FRONT_LEFT, GL_FRONT_RIGHT, GL_BACK_LEFT, GL_BACK_RIGHT, GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT, and GL_AUXi, where i is between 0 and the value of GL_AUX_BUFFERS minus 1. + + + + + + Read a block of pixels from the frame buffer + + + + Specify the window coordinates of the first pixel that is read from the frame buffer. This location is the lower left corner of a rectangular block of pixels. + + + + + Specify the dimensions of the pixel rectangle. width and height of one correspond to a single pixel. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. Must be one of GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, or GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Returns the pixel data. + + + + + + Read a block of pixels from the frame buffer + + + + Specify the window coordinates of the first pixel that is read from the frame buffer. This location is the lower left corner of a rectangular block of pixels. + + + + + Specify the dimensions of the pixel rectangle. width and height of one correspond to a single pixel. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. Must be one of GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, or GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Returns the pixel data. + + + + + + Read a block of pixels from the frame buffer + + + + Specify the window coordinates of the first pixel that is read from the frame buffer. This location is the lower left corner of a rectangular block of pixels. + + + + + Specify the dimensions of the pixel rectangle. width and height of one correspond to a single pixel. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. Must be one of GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, or GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Returns the pixel data. + + + + + + Read a block of pixels from the frame buffer + + + + Specify the window coordinates of the first pixel that is read from the frame buffer. This location is the lower left corner of a rectangular block of pixels. + + + + + Specify the dimensions of the pixel rectangle. width and height of one correspond to a single pixel. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. Must be one of GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, or GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Returns the pixel data. + + + + + + Read a block of pixels from the frame buffer + + + + Specify the window coordinates of the first pixel that is read from the frame buffer. This location is the lower left corner of a rectangular block of pixels. + + + + + Specify the dimensions of the pixel rectangle. width and height of one correspond to a single pixel. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. Must be one of GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, or GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Returns the pixel data. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Draw a rectangle + + + + Specify one vertex of a rectangle. + + + + + Specify the opposite vertex of the rectangle. + + + + + + Set rasterization mode + + + + Specifies the rasterization mode. Three values are accepted: GL_RENDER, GL_SELECT, and GL_FEEDBACK. The initial value is GL_RENDER. + + + + + + Reset histogram table entries to zero + + + + Must be GL_HISTOGRAM. + + + + + + Reset minmax table entries to initial values + + + + Must be GL_MINMAX. + + + + + + Multiply the current matrix by a rotation matrix + + + + Specifies the angle of rotation, in degrees. + + + + + Specify the x, y, and z coordinates of a vector, respectively. + + + + + + Multiply the current matrix by a rotation matrix + + + + Specifies the angle of rotation, in degrees. + + + + + Specify the x, y, and z coordinates of a vector, respectively. + + + + + + Specify multisample coverage parameters + + + + Specify a single floating-point sample coverage value. The value is clamped to the range [0 ,1]. The initial value is 1.0. + + + + + Specify a single boolean value representing if the coverage masks should be inverted. GL_TRUE and GL_FALSE are accepted. The initial value is GL_FALSE. + + + + + + Multiply the current matrix by a general scaling matrix + + + + Specify scale factors along the x, y, and z axes, respectively. + + + + + + Multiply the current matrix by a general scaling matrix + + + + Specify scale factors along the x, y, and z axes, respectively. + + + + + + Define the scissor box + + + + Specify the lower left corner of the scissor box. Initially (0, 0). + + + + + Specify the width and height of the scissor box. When a GL context is first attached to a window, width and height are set to the dimensions of that window. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Define an array of secondary colors + + + + Specifies the number of components per color. Must be 3. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of secondary colors + + + + Specifies the number of components per color. Must be 3. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of secondary colors + + + + Specifies the number of components per color. Must be 3. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of secondary colors + + + + Specifies the number of components per color. Must be 3. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of secondary colors + + + + Specifies the number of components per color. Must be 3. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Establish a buffer for selection mode values + + + + Specifies the size of buffer. + + + + + Returns the selection data. + + + + + + Establish a buffer for selection mode values + + + + Specifies the size of buffer. + + + + + Returns the selection data. + + + + + + Establish a buffer for selection mode values + + + + Specifies the size of buffer. + + + + + Returns the selection data. + + + + + + Establish a buffer for selection mode values + + + + Specifies the size of buffer. + + + + + Returns the selection data. + + + + + + Establish a buffer for selection mode values + + + + Specifies the size of buffer. + + + + + Returns the selection data. + + + + + + Establish a buffer for selection mode values + + + + Specifies the size of buffer. + + + + + Returns the selection data. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Select flat or smooth shading + + + + Specifies a symbolic value representing a shading technique. Accepted values are GL_FLAT and GL_SMOOTH. The initial value is GL_SMOOTH. + + + + + + Replaces the source code in a shader object + + + + Specifies the handle of the shader object whose source code is to be replaced. + + + + + Specifies the number of elements in the string and length arrays. + + + + + Specifies an array of pointers to strings containing the source code to be loaded into the shader. + + + + + Specifies an array of string lengths. + + + + + + Replaces the source code in a shader object + + + + Specifies the handle of the shader object whose source code is to be replaced. + + + + + Specifies the number of elements in the string and length arrays. + + + + + Specifies an array of pointers to strings containing the source code to be loaded into the shader. + + + + + Specifies an array of string lengths. + + + + + + Replaces the source code in a shader object + + + + Specifies the handle of the shader object whose source code is to be replaced. + + + + + Specifies the number of elements in the string and length arrays. + + + + + Specifies an array of pointers to strings containing the source code to be loaded into the shader. + + + + + Specifies an array of string lengths. + + + + + + Replaces the source code in a shader object + + + + Specifies the handle of the shader object whose source code is to be replaced. + + + + + Specifies the number of elements in the string and length arrays. + + + + + Specifies an array of pointers to strings containing the source code to be loaded into the shader. + + + + + Specifies an array of string lengths. + + + + + + Set front and back function and reference value for stencil testing + + + + Specifies the test function. Eight symbolic constants are valid: GL_NEVER, GL_LESS, GL_LEQUAL, GL_GREATER, GL_GEQUAL, GL_EQUAL, GL_NOTEQUAL, and GL_ALWAYS. The initial value is GL_ALWAYS. + + + + + Specifies the reference value for the stencil test. ref is clamped to the range [0, 2 sup n - 1], where is the number of bitplanes in the stencil buffer. The initial value is 0. + + + + + Specifies a mask that is ANDed with both the reference value and the stored stencil value when the test is done. The initial value is all 1's. + + + + + + Set front and back function and reference value for stencil testing + + + + Specifies the test function. Eight symbolic constants are valid: GL_NEVER, GL_LESS, GL_LEQUAL, GL_GREATER, GL_GEQUAL, GL_EQUAL, GL_NOTEQUAL, and GL_ALWAYS. The initial value is GL_ALWAYS. + + + + + Specifies the reference value for the stencil test. ref is clamped to the range [0, 2 sup n - 1], where is the number of bitplanes in the stencil buffer. The initial value is 0. + + + + + Specifies a mask that is ANDed with both the reference value and the stored stencil value when the test is done. The initial value is all 1's. + + + + + + Set front and/or back function and reference value for stencil testing + + + + Specifies whether front and/or back stencil state is updated. Three symbolic constants are valid: GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK. + + + + + Specifies the test function. Eight symbolic constants are valid: GL_NEVER, GL_LESS, GL_LEQUAL, GL_GREATER, GL_GEQUAL, GL_EQUAL, GL_NOTEQUAL, and GL_ALWAYS. The initial value is GL_ALWAYS. + + + + + Specifies the reference value for the stencil test. ref is clamped to the range [0, 2 sup n - 1], where is the number of bitplanes in the stencil buffer. The initial value is 0. + + + + + Specifies a mask that is ANDed with both the reference value and the stored stencil value when the test is done. The initial value is all 1's. + + + + + + Set front and/or back function and reference value for stencil testing + + + + Specifies whether front and/or back stencil state is updated. Three symbolic constants are valid: GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK. + + + + + Specifies the test function. Eight symbolic constants are valid: GL_NEVER, GL_LESS, GL_LEQUAL, GL_GREATER, GL_GEQUAL, GL_EQUAL, GL_NOTEQUAL, and GL_ALWAYS. The initial value is GL_ALWAYS. + + + + + Specifies the reference value for the stencil test. ref is clamped to the range [0, 2 sup n - 1], where is the number of bitplanes in the stencil buffer. The initial value is 0. + + + + + Specifies a mask that is ANDed with both the reference value and the stored stencil value when the test is done. The initial value is all 1's. + + + + + + Control the front and back writing of individual bits in the stencil planes + + + + Specifies a bit mask to enable and disable writing of individual bits in the stencil planes. Initially, the mask is all 1's. + + + + + + Control the front and back writing of individual bits in the stencil planes + + + + Specifies a bit mask to enable and disable writing of individual bits in the stencil planes. Initially, the mask is all 1's. + + + + + + Control the front and/or back writing of individual bits in the stencil planes + + + + Specifies whether the front and/or back stencil writemask is updated. Three symbolic constants are valid: GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK. + + + + + Specifies a bit mask to enable and disable writing of individual bits in the stencil planes. Initially, the mask is all 1's. + + + + + + Control the front and/or back writing of individual bits in the stencil planes + + + + Specifies whether the front and/or back stencil writemask is updated. Three symbolic constants are valid: GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK. + + + + + Specifies a bit mask to enable and disable writing of individual bits in the stencil planes. Initially, the mask is all 1's. + + + + + + Set front and back stencil test actions + + + + Specifies the action to take when the stencil test fails. Eight symbolic constants are accepted: GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_INCR_WRAP, GL_DECR, GL_DECR_WRAP, and GL_INVERT. The initial value is GL_KEEP. + + + + + Specifies the stencil action when the stencil test passes, but the depth test fails. dpfail accepts the same symbolic constants as sfail. The initial value is GL_KEEP. + + + + + Specifies the stencil action when both the stencil test and the depth test pass, or when the stencil test passes and either there is no depth buffer or depth testing is not enabled. dppass accepts the same symbolic constants as sfail. The initial value is GL_KEEP. + + + + + + Set front and/or back stencil test actions + + + + Specifies whether front and/or back stencil state is updated. Three symbolic constants are valid: GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK. + + + + + Specifies the action to take when the stencil test fails. Eight symbolic constants are accepted: GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_INCR_WRAP, GL_DECR, GL_DECR_WRAP, and GL_INVERT. The initial value is GL_KEEP. + + + + + Specifies the stencil action when the stencil test passes, but the depth test fails. dpfail accepts the same symbolic constants as sfail. The initial value is GL_KEEP. + + + + + Specifies the stencil action when both the stencil test and the depth test pass, or when the stencil test passes and either there is no depth buffer or depth testing is not enabled. dppass accepts the same symbolic constants as sfail. The initial value is GL_KEEP. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specify s, t, r, and q texture coordinates. Not all parameters are present in all forms of the command. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Set texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a single-valued texture environment parameter. May be either GL_TEXTURE_ENV_MODE, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Specifies a single symbolic constant, one of GL_ADD, GL_ADD_SIGNED, GL_INTERPOLATE, GL_MODULATE, GL_DECAL, GL_BLEND, GL_REPLACE, GL_SUBTRACT, GL_COMBINE, GL_TEXTURE, GL_CONSTANT, GL_PRIMARY_COLOR, GL_PREVIOUS, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, a single boolean value for the point sprite texture coordinate replacement, a single floating-point value for the texture level-of-detail bias, or 1.0, 2.0, or 4.0 when specifying the GL_RGB_SCALE or GL_ALPHA_SCALE. + + + + + + Set texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a single-valued texture environment parameter. May be either GL_TEXTURE_ENV_MODE, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Specifies a single symbolic constant, one of GL_ADD, GL_ADD_SIGNED, GL_INTERPOLATE, GL_MODULATE, GL_DECAL, GL_BLEND, GL_REPLACE, GL_SUBTRACT, GL_COMBINE, GL_TEXTURE, GL_CONSTANT, GL_PRIMARY_COLOR, GL_PREVIOUS, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, a single boolean value for the point sprite texture coordinate replacement, a single floating-point value for the texture level-of-detail bias, or 1.0, 2.0, or 4.0 when specifying the GL_RGB_SCALE or GL_ALPHA_SCALE. + + + + + + Set texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a single-valued texture environment parameter. May be either GL_TEXTURE_ENV_MODE, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Specifies a single symbolic constant, one of GL_ADD, GL_ADD_SIGNED, GL_INTERPOLATE, GL_MODULATE, GL_DECAL, GL_BLEND, GL_REPLACE, GL_SUBTRACT, GL_COMBINE, GL_TEXTURE, GL_CONSTANT, GL_PRIMARY_COLOR, GL_PREVIOUS, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, a single boolean value for the point sprite texture coordinate replacement, a single floating-point value for the texture level-of-detail bias, or 1.0, 2.0, or 4.0 when specifying the GL_RGB_SCALE or GL_ALPHA_SCALE. + + + + + + Set texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a single-valued texture environment parameter. May be either GL_TEXTURE_ENV_MODE, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Specifies a single symbolic constant, one of GL_ADD, GL_ADD_SIGNED, GL_INTERPOLATE, GL_MODULATE, GL_DECAL, GL_BLEND, GL_REPLACE, GL_SUBTRACT, GL_COMBINE, GL_TEXTURE, GL_CONSTANT, GL_PRIMARY_COLOR, GL_PREVIOUS, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, a single boolean value for the point sprite texture coordinate replacement, a single floating-point value for the texture level-of-detail bias, or 1.0, 2.0, or 4.0 when specifying the GL_RGB_SCALE or GL_ALPHA_SCALE. + + + + + + Set texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a single-valued texture environment parameter. May be either GL_TEXTURE_ENV_MODE, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Specifies a single symbolic constant, one of GL_ADD, GL_ADD_SIGNED, GL_INTERPOLATE, GL_MODULATE, GL_DECAL, GL_BLEND, GL_REPLACE, GL_SUBTRACT, GL_COMBINE, GL_TEXTURE, GL_CONSTANT, GL_PRIMARY_COLOR, GL_PREVIOUS, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, a single boolean value for the point sprite texture coordinate replacement, a single floating-point value for the texture level-of-detail bias, or 1.0, 2.0, or 4.0 when specifying the GL_RGB_SCALE or GL_ALPHA_SCALE. + + + + + + Set texture environment parameters + + + + Specifies a texture environment. May be GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL or GL_POINT_SPRITE. + + + + + Specifies the symbolic name of a single-valued texture environment parameter. May be either GL_TEXTURE_ENV_MODE, GL_TEXTURE_LOD_BIAS, GL_COMBINE_RGB, GL_COMBINE_ALPHA, GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, GL_RGB_SCALE, GL_ALPHA_SCALE, or GL_COORD_REPLACE. + + + + + Specifies a single symbolic constant, one of GL_ADD, GL_ADD_SIGNED, GL_INTERPOLATE, GL_MODULATE, GL_DECAL, GL_BLEND, GL_REPLACE, GL_SUBTRACT, GL_COMBINE, GL_TEXTURE, GL_CONSTANT, GL_PRIMARY_COLOR, GL_PREVIOUS, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, a single boolean value for the point sprite texture coordinate replacement, a single floating-point value for the texture level-of-detail bias, or 1.0, 2.0, or 4.0 when specifying the GL_RGB_SCALE or GL_ALPHA_SCALE. + + + + + + Control the generation of texture coordinates + + + + Specifies a texture coordinate. Must be one of GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the texture-coordinate generation function. Must be GL_TEXTURE_GEN_MODE. + + + + + Specifies a single-valued texture generation parameter, one of GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, GL_NORMAL_MAP, or GL_REFLECTION_MAP. + + + + + + Control the generation of texture coordinates + + + + Specifies a texture coordinate. Must be one of GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the texture-coordinate generation function. Must be GL_TEXTURE_GEN_MODE. + + + + + Specifies a single-valued texture generation parameter, one of GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, GL_NORMAL_MAP, or GL_REFLECTION_MAP. + + + + + + Control the generation of texture coordinates + + + + Specifies a texture coordinate. Must be one of GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the texture-coordinate generation function. Must be GL_TEXTURE_GEN_MODE. + + + + + Specifies a single-valued texture generation parameter, one of GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, GL_NORMAL_MAP, or GL_REFLECTION_MAP. + + + + + + Control the generation of texture coordinates + + + + Specifies a texture coordinate. Must be one of GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the texture-coordinate generation function. Must be GL_TEXTURE_GEN_MODE. + + + + + Specifies a single-valued texture generation parameter, one of GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, GL_NORMAL_MAP, or GL_REFLECTION_MAP. + + + + + + Control the generation of texture coordinates + + + + Specifies a texture coordinate. Must be one of GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the texture-coordinate generation function. Must be GL_TEXTURE_GEN_MODE. + + + + + Specifies a single-valued texture generation parameter, one of GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, GL_NORMAL_MAP, or GL_REFLECTION_MAP. + + + + + + Control the generation of texture coordinates + + + + Specifies a texture coordinate. Must be one of GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the texture-coordinate generation function. Must be GL_TEXTURE_GEN_MODE. + + + + + Specifies a single-valued texture generation parameter, one of GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, GL_NORMAL_MAP, or GL_REFLECTION_MAP. + + + + + + Control the generation of texture coordinates + + + + Specifies a texture coordinate. Must be one of GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the texture-coordinate generation function. Must be GL_TEXTURE_GEN_MODE. + + + + + Specifies a single-valued texture generation parameter, one of GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, GL_NORMAL_MAP, or GL_REFLECTION_MAP. + + + + + + Control the generation of texture coordinates + + + + Specifies a texture coordinate. Must be one of GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the texture-coordinate generation function. Must be GL_TEXTURE_GEN_MODE. + + + + + Specifies a single-valued texture generation parameter, one of GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, GL_NORMAL_MAP, or GL_REFLECTION_MAP. + + + + + + Control the generation of texture coordinates + + + + Specifies a texture coordinate. Must be one of GL_S, GL_T, GL_R, or GL_Q. + + + + + Specifies the symbolic name of the texture-coordinate generation function. Must be GL_TEXTURE_GEN_MODE. + + + + + Specifies a single-valued texture generation parameter, one of GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, GL_NORMAL_MAP, or GL_REFLECTION_MAP. + + + + + + Specify a one-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level is the n sup th mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup k + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level is the n sup th mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup k + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level is the n sup th mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup k + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level is the n sup th mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup k + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level is the n sup th mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup k + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Set texture parameters + + + + Specifies the target texture, which must be either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, or GL_TEXTURE_CUBE_MAP. + + + + + Specifies the symbolic name of a single-valued texture parameter. pname can be one of the following: GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_PRIORITY, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, or GL_GENERATE_MIPMAP. + + + + + Specifies the value of pname. + + + + + + Set texture parameters + + + + Specifies the target texture, which must be either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, or GL_TEXTURE_CUBE_MAP. + + + + + Specifies the symbolic name of a single-valued texture parameter. pname can be one of the following: GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_PRIORITY, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, or GL_GENERATE_MIPMAP. + + + + + Specifies the value of pname. + + + + + + Set texture parameters + + + + Specifies the target texture, which must be either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, or GL_TEXTURE_CUBE_MAP. + + + + + Specifies the symbolic name of a single-valued texture parameter. pname can be one of the following: GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_PRIORITY, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, or GL_GENERATE_MIPMAP. + + + + + Specifies the value of pname. + + + + + + Set texture parameters + + + + Specifies the target texture, which must be either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, or GL_TEXTURE_CUBE_MAP. + + + + + Specifies the symbolic name of a single-valued texture parameter. pname can be one of the following: GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_PRIORITY, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, or GL_GENERATE_MIPMAP. + + + + + Specifies the value of pname. + + + + + + Set texture parameters + + + + Specifies the target texture, which must be either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, or GL_TEXTURE_CUBE_MAP. + + + + + Specifies the symbolic name of a single-valued texture parameter. pname can be one of the following: GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_PRIORITY, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, or GL_GENERATE_MIPMAP. + + + + + Specifies the value of pname. + + + + + + Set texture parameters + + + + Specifies the target texture, which must be either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, or GL_TEXTURE_CUBE_MAP. + + + + + Specifies the symbolic name of a single-valued texture parameter. pname can be one of the following: GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_PRIORITY, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_COMPARE_FUNC, GL_DEPTH_TEXTURE_MODE, or GL_GENERATE_MIPMAP. + + + + + Specifies the value of pname. + + + + + + Specify a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Multiply the current matrix by a translation matrix + + + + Specify the x, y, and z coordinates of a translation vector. + + + + + + Multiply the current matrix by a translation matrix + + + + Specify the x, y, and z coordinates of a translation vector. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Installs a program object as part of current rendering state + + + + Specifies the handle of the program object whose executables are to be used as part of current rendering state. + + + + + + Installs a program object as part of current rendering state + + + + Specifies the handle of the program object whose executables are to be used as part of current rendering state. + + + + + + Validates a program object + + + + Specifies the handle of the program object to be validated. + + + + + + Validates a program object + + + + Specifies the handle of the program object to be validated. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specify a vertex + + + + Specify x, y, z, and w coordinates of a vertex. Not all parameters are present in all forms of the command. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Set the viewport + + + + Specify the lower left corner of the viewport rectangle, in pixels. The initial value is (0,0). + + + + + Specify the width and height of the viewport. When a GL context is first attached to a window, width and height are set to the dimensions of that window. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Determines whether the specified OpenGL extension category is available in + the current OpenGL context. Equivalent to IsExtensionSupported(name, true) + + The string for the OpenGL extension category (eg. "GL_ARB_multitexture") + True if the specified extension is available, false otherwise. + + + + Returns a System.Delegate wrapping the specified OpenGL function. You must use the + base OpenGL name of the function (e.g. "glVertex3fv" instead of "Vertex3"). + + The name of the OpenGL function (eg. "glNewList") + + A System.Delegate that can be used to call this OpenGL function or null, if the specified + function name does not correspond to an OpenGL function or if the function is not + supported by the video drivers. + + + + + Returns a System.Delegate wrapping an OpenGL function. + + The name of the OpenGL function (eg. "glNewList") + The signature of the OpenGL function. + + A System.Delegate that can be used to call this OpenGL function, or null if the specified + function name did not correspond to an OpenGL function. + + + + + Loads all OpenGL functions (core and extensions). + + + + This function will be automatically called the first time you use any opengl function. There is + + + Call this function manually whenever you need to update OpenGL entry points. + This need may arise if you change the pixelformat/visual, or in case you cannot + (or do not want) to use the automatic initialization of the GL class. + + + + + + Tries to reload the given OpenGL function (core or extension). + + The name of the OpenGL function (i.e. glShaderSource) + True if the function was found and reloaded, false otherwise. + + + Use this function if you require greater granularity when loading OpenGL entry points. + + + While the automatic initialisation will load all OpenGL entry points, in some cases + the initialisation can take place before an OpenGL Context has been established. + In this case, use this function to load the entry points for the OpenGL functions + you will need, or use ReloadFunctions() to load all available entry points. + + + This function returns true if the given OpenGL function is supported, false otherwise. + + + To query for supported extensions use the IsExtensionSupported() function instead. + + + + + + + Loads an OpenGL function into a type-safe System.Delegate. + + The name of the OpenGL function (eg. "glNewList") + The signature of the OpenGL function. + + A System.Delegate that can be used to call this OpenGL function, or null if the specified + function name did not correspond to an OpenGL function. + + + + + Checks if a given OpenGL function is supported by the current context + + The name of the OpenGL function (i.e. glShaderSource) + True if the function is supported, false otherwise + + + + Checks if a given OpenGL function is supported by the current context + + The name of the OpenGL function (e.g. glShaderSource) + The name of the extension catagory (e.g. ARB, EXT, ATI, ...) + True if the function is supported, false otherwise + + + + Checks if a given OpenGL function is supported by the current context. + + The System.Reflection.MethodInfo for the OpenGL function. + True if the function is supported, false otherwise. + + + + Builds a cache of the supported extensions to speed up searches. + + + + + Retrieves the entry point for a dynamically exported OpenGL function. + + The function string for the OpenGL function (eg. "glNewList") + + An IntPtr contaning the address for the entry point, or IntPtr.Zero if the specified + OpenGL function is not dynamically exported. + + + + The Marshal.GetDelegateForFunctionPointer method can be used to turn the return value + into a call-able delegate. + + + This function is cross-platform. It determines the underlying platform and uses the + correct wgl, glx or agl GetAddress function to retrieve the function pointer. + + + + + + Creates a System.Delegate that can be used to call a dynamically exported OpenGL function. + + The name of the OpenGL function (eg. "glNewList") + The signature of the OpenGL function. + + A System.Delegate that can be used to call this OpenGL function or null + if the function is not available in the current OpenGL context. + + + + + Helper function that defines the coordinate origin of the Point Sprite. + + + A OpenTK.Graphics.OpenGL.GL.PointSpriteCoordOriginParameter token, + denoting the origin of the Point Sprite. + + + + + Select active texture unit + + + + Specifies which texture unit to make active. The number of texture units is implementation dependent, but must be at least two. texture must be one of GL_TEXTURE, where i ranges from 0 to the larger of (GL_MAX_TEXTURE_COORDS - 1) and (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1). The initial value is GL_TEXTURE0. + + + + + + Delimit the boundaries of a query object + + + + Specifies the target type of query object established between glBeginQuery and the subsequent glEndQuery. The symbolic constant must be GL_SAMPLES_PASSED. + + + + + Specifies the name of a query object. + + + + + + Delimit the boundaries of a query object + + + + Specifies the target type of query object established between glBeginQuery and the subsequent glEndQuery. The symbolic constant must be GL_SAMPLES_PASSED. + + + + + Specifies the name of a query object. + + + + + + Associates a generic vertex attribute index with a named attribute variable + + + + Specifies the handle of the program object in which the association is to be made. + + + + + Specifies the index of the generic vertex attribute to be bound. + + + + + Specifies a null terminated string containing the name of the vertex shader attribute variable to which index is to be bound. + + + + + + Associates a generic vertex attribute index with a named attribute variable + + + + Specifies the handle of the program object in which the association is to be made. + + + + + Specifies the index of the generic vertex attribute to be bound. + + + + + Specifies a null terminated string containing the name of the vertex shader attribute variable to which index is to be bound. + + + + + + Bind a named buffer object + + + + Specifies the target to which the buffer object is bound. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the name of a buffer object. + + + + + + Bind a named buffer object + + + + Specifies the target to which the buffer object is bound. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the name of a buffer object. + + + + + + Creates and initializes a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the size in bytes of the buffer object's new data store. + + + + + Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied. + + + + + Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. + + + + + + Creates and initializes a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the size in bytes of the buffer object's new data store. + + + + + Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied. + + + + + Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. + + + + + + Creates and initializes a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the size in bytes of the buffer object's new data store. + + + + + Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied. + + + + + Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. + + + + + + Creates and initializes a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the size in bytes of the buffer object's new data store. + + + + + Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied. + + + + + Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. + + + + + + Creates and initializes a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the size in bytes of the buffer object's new data store. + + + + + Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied. + + + + + Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. + + + + + + Updates a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store where data replacement will begin, measured in bytes. + + + + + Specifies the size in bytes of the data store region being replaced. + + + + + Specifies a pointer to the new data that will be copied into the data store. + + + + + + Updates a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store where data replacement will begin, measured in bytes. + + + + + Specifies the size in bytes of the data store region being replaced. + + + + + Specifies a pointer to the new data that will be copied into the data store. + + + + + + Updates a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store where data replacement will begin, measured in bytes. + + + + + Specifies the size in bytes of the data store region being replaced. + + + + + Specifies a pointer to the new data that will be copied into the data store. + + + + + + Updates a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store where data replacement will begin, measured in bytes. + + + + + Specifies the size in bytes of the data store region being replaced. + + + + + Specifies a pointer to the new data that will be copied into the data store. + + + + + + Updates a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store where data replacement will begin, measured in bytes. + + + + + Specifies the size in bytes of the data store region being replaced. + + + + + Specifies a pointer to the new data that will be copied into the data store. + + + + + + Select active texture unit + + + + Specifies which texture unit to make active. The number of texture units is implementation dependent, but must be at least two. texture must be one of GL_TEXTURE, where i ranges from 0 to the value of GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. The initial value is GL_TEXTURE0. + + + + + + Compiles a shader object + + + + Specifies the shader object to be compiled. + + + + + + Compiles a shader object + + + + Specifies the shader object to be compiled. + + + + + + Specify a one-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D or GL_PROXY_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels wide and cube-mapped texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be Must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels high and cube-mapped texture images that are at least 16 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels wide and cube-mapped texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be Must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels high and cube-mapped texture images that are at least 16 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels wide and cube-mapped texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be Must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels high and cube-mapped texture images that are at least 16 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels wide and cube-mapped texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be Must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels high and cube-mapped texture images that are at least 16 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_PROXY_TEXTURE_CUBE_MAP. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels wide and cube-mapped texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be Must be 2 sup n + 2 ( border ) for some integer . All implementations support 2D texture images that are at least 64 texels high and cube-mapped texture images that are at least 16 texels high. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture image in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a one-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a two-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Specify a three-dimensional texture subimage in a compressed format + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the compressed image data stored at address data. + + + + + Specifies the number of unsigned bytes of image data starting at the address specified by data. + + + + + Specifies a pointer to the compressed image data in memory. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Delete named buffer objects + + + + Specifies the number of buffer objects to be deleted. + + + + + Specifies an array of buffer objects to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Delete named query objects + + + + Specifies the number of query objects to be deleted. + + + + + Specifies an array of query objects to be deleted. + + + + + + Specifies a list of color buffers to be drawn into + + + + Specifies the number of buffers in bufs. + + + + + Points to an array of symbolic constants specifying the buffers into which fragment colors or data values will be written. + + + + + + Specifies a list of color buffers to be drawn into + + + + Specifies the number of buffers in bufs. + + + + + Points to an array of symbolic constants specifying the buffers into which fragment colors or data values will be written. + + + + + + Specifies a list of color buffers to be drawn into + + + + Specifies the number of buffers in bufs. + + + + + Points to an array of symbolic constants specifying the buffers into which fragment colors or data values will be written. + + + + + + Enable or disable a generic vertex attribute array + + + + Specifies the index of the generic vertex attribute to be enabled or disabled. + + + + + + Enable or disable a generic vertex attribute array + + + + Specifies the index of the generic vertex attribute to be enabled or disabled. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate buffer object names + + + + Specifies the number of buffer object names to be generated. + + + + + Specifies an array in which the generated buffer object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Generate query object names + + + + Specifies the number of query object names to be generated. + + + + + Specifies an array in which the generated query object names are stored. + + + + + + Returns information about an active attribute variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the attribute variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the attribute variable. + + + + + Returns the data type of the attribute variable. + + + + + Returns a null terminated string containing the name of the attribute variable. + + + + + + Returns information about an active attribute variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the attribute variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the attribute variable. + + + + + Returns the data type of the attribute variable. + + + + + Returns a null terminated string containing the name of the attribute variable. + + + + + + Returns information about an active attribute variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the attribute variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the attribute variable. + + + + + Returns the data type of the attribute variable. + + + + + Returns a null terminated string containing the name of the attribute variable. + + + + + + Returns information about an active attribute variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the attribute variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the attribute variable. + + + + + Returns the data type of the attribute variable. + + + + + Returns a null terminated string containing the name of the attribute variable. + + + + + + Returns information about an active uniform variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the uniform variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the uniform variable. + + + + + Returns the data type of the uniform variable. + + + + + Returns a null terminated string containing the name of the uniform variable. + + + + + + Returns information about an active uniform variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the uniform variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the uniform variable. + + + + + Returns the data type of the uniform variable. + + + + + Returns a null terminated string containing the name of the uniform variable. + + + + + + Returns information about an active uniform variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the uniform variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the uniform variable. + + + + + Returns the data type of the uniform variable. + + + + + Returns a null terminated string containing the name of the uniform variable. + + + + + + Returns information about an active uniform variable for the specified program object + + + + Specifies the program object to be queried. + + + + + Specifies the index of the uniform variable to be queried. + + + + + Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by name. + + + + + Returns the number of characters actually written by OpenGL in the string indicated by name (excluding the null terminator) if a value other than NULL is passed. + + + + + Returns the size of the uniform variable. + + + + + Returns the data type of the uniform variable. + + + + + Returns a null terminated string containing the name of the uniform variable. + + + + + + Returns the location of an attribute variable + + + + Specifies the program object to be queried. + + + + + Points to a null terminated string containing the name of the attribute variable whose location is to be queried. + + + + + + Returns the location of an attribute variable + + + + Specifies the program object to be queried. + + + + + Points to a null terminated string containing the name of the attribute variable whose location is to be queried. + + + + + + Returns a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store from which data will be returned, measured in bytes. + + + + + Specifies the size in bytes of the data store region being returned. + + + + + Specifies a pointer to the location where buffer object data is returned. + + + + + + Returns a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store from which data will be returned, measured in bytes. + + + + + Specifies the size in bytes of the data store region being returned. + + + + + Specifies a pointer to the location where buffer object data is returned. + + + + + + Returns a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store from which data will be returned, measured in bytes. + + + + + Specifies the size in bytes of the data store region being returned. + + + + + Specifies a pointer to the location where buffer object data is returned. + + + + + + Returns a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store from which data will be returned, measured in bytes. + + + + + Specifies the size in bytes of the data store region being returned. + + + + + Specifies a pointer to the location where buffer object data is returned. + + + + + + Returns a subset of a buffer object's data store + + + + Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the offset into the buffer object's data store from which data will be returned, measured in bytes. + + + + + Specifies the size in bytes of the data store region being returned. + + + + + Specifies a pointer to the location where buffer object data is returned. + + + + + + Return a compressed texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, and GL_TEXTURE_3D GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Returns the compressed texture image. + + + + + + Return a compressed texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, and GL_TEXTURE_3D GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Returns the compressed texture image. + + + + + + Return a compressed texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, and GL_TEXTURE_3D GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Returns the compressed texture image. + + + + + + Return a compressed texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, and GL_TEXTURE_3D GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Returns the compressed texture image. + + + + + + Return a compressed texture image + + + + Specifies which texture is to be obtained. GL_TEXTURE_1D, GL_TEXTURE_2D, and GL_TEXTURE_3D GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z are accepted. + + + + + Specifies the level-of-detail number of the desired image. Level 0 is the base image level. Level is the th mipmap reduction image. + + + + + Returns the compressed texture image. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Return parameters of a query object + + + + Specifies the name of a query object. + + + + + Specifies the symbolic name of a query object parameter. Accepted values are GL_QUERY_RESULT or GL_QUERY_RESULT_AVAILABLE. + + + + + Returns the requested data. + + + + + + Returns the source code string from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the size of the character buffer for storing the returned source code string. + + + + + Returns the length of the string returned in source (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the source code string. + + + + + + Returns the source code string from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the size of the character buffer for storing the returned source code string. + + + + + Returns the length of the string returned in source (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the source code string. + + + + + + Returns the source code string from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the size of the character buffer for storing the returned source code string. + + + + + Returns the length of the string returned in source (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the source code string. + + + + + + Returns the source code string from a shader object + + + + Specifies the shader object to be queried. + + + + + Specifies the size of the character buffer for storing the returned source code string. + + + + + Returns the length of the string returned in source (excluding the null terminator). + + + + + Specifies an array of characters that is used to return the source code string. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the location of a uniform variable + + + + Specifies the program object to be queried. + + + + + Points to a null terminated string containing the name of the uniform variable whose location is to be queried. + + + + + + Returns the location of a uniform variable + + + + Specifies the program object to be queried. + + + + + Points to a null terminated string containing the name of the uniform variable whose location is to be queried. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Determine if a name corresponds to a buffer object + + + + Specifies a value that may be the name of a buffer object. + + + + + + Determine if a name corresponds to a buffer object + + + + Specifies a value that may be the name of a buffer object. + + + + + + Determines if a name corresponds to a program object + + + + Specifies a potential program object. + + + + + + Determines if a name corresponds to a program object + + + + Specifies a potential program object. + + + + + + Determine if a name corresponds to a query object + + + + Specifies a value that may be the name of a query object. + + + + + + Determine if a name corresponds to a query object + + + + Specifies a value that may be the name of a query object. + + + + + + Links a program object + + + + Specifies the handle of the program object to be linked. + + + + + + Links a program object + + + + Specifies the handle of the program object to be linked. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Replace the current matrix with the specified row-major ordered matrix + + + + Specifies a pointer to 16 consecutive values, which are used as the elements of a 4 times 4 row-major matrix. + + + + + + Map a buffer object's data store + + + + Specifies the target buffer object being mapped. The symbolic constant must be GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, or GL_PIXEL_UNPACK_BUFFER. + + + + + Specifies the access policy, indicating whether it will be possible to read from, write to, or both read from and write to the buffer object's mapped data store. The symbolic constant must be GL_READ_ONLY, GL_WRITE_ONLY, or GL_READ_WRITE. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Set the current texture coordinates + + + + Specifies the texture unit whose coordinates should be modified. The number of texture units is implementation dependent, but must be at least two. Symbolic constant must be one of GL_TEXTURE, where i ranges from 0 to GL_MAX_TEXTURE_COORDS - 1, which is an implementation-dependent value. + + + + + Specify s, t, r, and q texture coordinates for target texture unit. Not all parameters are present in all forms of the command. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Multiply the current matrix with the specified row-major ordered matrix + + + + Points to 16 consecutive values that are used as the elements of a 4 times 4 row-major matrix. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify multisample coverage parameters + + + + Specify a single floating-point sample coverage value. The value is clamped to the range [0 ,1]. The initial value is 1.0. + + + + + Specify a single boolean value representing if the coverage masks should be inverted. GL_TRUE and GL_FALSE are accepted. The initial value is GL_FALSE. + + + + + + Replaces the source code in a shader object + + + + Specifies the handle of the shader object whose source code is to be replaced. + + + + + Specifies the number of elements in the string and length arrays. + + + + + Specifies an array of pointers to strings containing the source code to be loaded into the shader. + + + + + Specifies an array of string lengths. + + + + + + Replaces the source code in a shader object + + + + Specifies the handle of the shader object whose source code is to be replaced. + + + + + Specifies the number of elements in the string and length arrays. + + + + + Specifies an array of pointers to strings containing the source code to be loaded into the shader. + + + + + Specifies an array of string lengths. + + + + + + Replaces the source code in a shader object + + + + Specifies the handle of the shader object whose source code is to be replaced. + + + + + Specifies the number of elements in the string and length arrays. + + + + + Specifies an array of pointers to strings containing the source code to be loaded into the shader. + + + + + Specifies an array of string lengths. + + + + + + Replaces the source code in a shader object + + + + Specifies the handle of the shader object whose source code is to be replaced. + + + + + Specifies the number of elements in the string and length arrays. + + + + + Specifies an array of pointers to strings containing the source code to be loaded into the shader. + + + + + Specifies an array of string lengths. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Validates a program object + + + + Specifies the handle of the program object to be validated. + + + + + + Validates a program object + + + + Specifies the handle of the program object to be validated. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specifies a list of color buffers to be drawn into + + + + Specifies the number of buffers in bufs. + + + + + Points to an array of symbolic constants specifying the buffers into which fragment colors or data values will be written. + + + + + + Specifies a list of color buffers to be drawn into + + + + Specifies the number of buffers in bufs. + + + + + Points to an array of symbolic constants specifying the buffers into which fragment colors or data values will be written. + + + + + + Specifies a list of color buffers to be drawn into + + + + Specifies the number of buffers in bufs. + + + + + Points to an array of symbolic constants specifying the buffers into which fragment colors or data values will be written. + + + + + + Set front and/or back function and reference value for stencil testing + + + + Specifies whether front and/or back stencil state is updated. Three symbolic constants are valid: GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK. + + + + + Specifies the test function. Eight symbolic constants are valid: GL_NEVER, GL_LESS, GL_LEQUAL, GL_GREATER, GL_GEQUAL, GL_EQUAL, GL_NOTEQUAL, and GL_ALWAYS. The initial value is GL_ALWAYS. + + + + + Specifies the reference value for the stencil test. ref is clamped to the range [0, 2 sup n - 1], where is the number of bitplanes in the stencil buffer. The initial value is 0. + + + + + Specifies a mask that is ANDed with both the reference value and the stored stencil value when the test is done. The initial value is all 1's. + + + + + + Set front and/or back function and reference value for stencil testing + + + + Specifies whether front and/or back stencil state is updated. Three symbolic constants are valid: GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK. + + + + + Specifies the test function. Eight symbolic constants are valid: GL_NEVER, GL_LESS, GL_LEQUAL, GL_GREATER, GL_GEQUAL, GL_EQUAL, GL_NOTEQUAL, and GL_ALWAYS. The initial value is GL_ALWAYS. + + + + + Specifies the reference value for the stencil test. ref is clamped to the range [0, 2 sup n - 1], where is the number of bitplanes in the stencil buffer. The initial value is 0. + + + + + Specifies a mask that is ANDed with both the reference value and the stored stencil value when the test is done. The initial value is all 1's. + + + + + + Set front and/or back stencil test actions + + + + Specifies whether front and/or back stencil state is updated. Three symbolic constants are valid: GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK. + + + + + Specifies the action to take when the stencil test fails. Eight symbolic constants are accepted: GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_INCR_WRAP, GL_DECR, GL_DECR_WRAP, and GL_INVERT. The initial value is GL_KEEP. + + + + + Specifies the stencil action when the stencil test passes, but the depth test fails. dpfail accepts the same symbolic constants as sfail. The initial value is GL_KEEP. + + + + + Specifies the stencil action when both the stencil test and the depth test pass, or when the stencil test passes and either there is no depth buffer or depth testing is not enabled. dppass accepts the same symbolic constants as sfail. The initial value is GL_KEEP. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Determine if textures are loaded in texture memory + + + + Specifies the number of textures to be queried. + + + + + Specifies an array containing the names of the textures to be queried. + + + + + Specifies an array in which the texture residence status is returned. The residence status of a texture named by an element of textures is returned in the corresponding element of residences. + + + + + + Render a vertex using the specified vertex array element + + + + Specifies an index into the enabled vertex data arrays. + + + + + + Bind a named texture to a texturing target + + + + Specifies the target to which the texture is bound. Must be either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, or GL_TEXTURE_CUBE_MAP. + + + + + Specifies the name of a texture. + + + + + + Bind a named texture to a texturing target + + + + Specifies the target to which the texture is bound. Must be either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, or GL_TEXTURE_CUBE_MAP. + + + + + Specifies the name of a texture. + + + + + + Set the blend color + + + + specify the components of GL_BLEND_COLOR + + + + + + Specify the equation used for both the RGB blend equation and the Alpha blend equation + + + + specifies how source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + + Set the RGB blend equation and the alpha blend equation separately + + + + specifies the RGB blend equation, how the red, green, and blue components of the source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + specifies the alpha blend equation, how the alpha component of the source and destination colors are combined. It must be GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX. + + + + + + Specify pixel arithmetic for RGB and alpha components separately + + + + Specifies how the red, green, and blue blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE. The initial value is GL_ONE. + + + + + Specifies how the red, green, and blue destination blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA. GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA. The initial value is GL_ZERO. + + + + + Specified how the alpha source blending factor is computed. The same symbolic constants are accepted as for srcRGB. The initial value is GL_ONE. + + + + + Specified how the alpha destination blending factor is computed. The same symbolic constants are accepted as for dstRGB. The initial value is GL_ZERO. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The number of table entries to replace. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to replace the specified region of the color table. + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The number of table entries to replace. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to replace the specified region of the color table. + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The number of table entries to replace. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to replace the specified region of the color table. + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The number of table entries to replace. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to replace the specified region of the color table. + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The number of table entries to replace. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to replace the specified region of the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_RGB, and GL_RGBA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_RGB, and GL_RGBA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_RGB, and GL_RGBA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_RGB, and GL_RGBA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_RGB, and GL_RGBA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The height of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a two-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The height of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a two-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The height of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a two-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The height of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a two-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Define a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The width of the pixel array referenced by data. + + + + + The height of the pixel array referenced by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in data. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a two-dimensional array of pixel data that is processed to build the convolution filter kernel. + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Set convolution parameters + + + + The target for the convolution parameter. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be set. Must be GL_CONVOLUTION_BORDER_MODE. + + + + + The parameter value. Must be one of GL_REDUCE, GL_CONSTANT_BORDER, GL_REPLICATE_BORDER. + + + + + + + + + Respecify a portion of a color table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The starting index of the portion of the color table to be replaced. + + + + + The window coordinates of the left corner of the row of pixels to be copied. + + + + + The number of table entries to replace. + + + + + + Copy pixels into a one-dimensional convolution filter + + + + Must be GL_CONVOLUTION_1D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The window space coordinates of the lower-left coordinate of the pixel array to copy. + + + + + The width of the pixel array to copy. + + + + + + Copy pixels into a two-dimensional convolution filter + + + + Must be GL_CONVOLUTION_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The window space coordinates of the lower-left coordinate of the pixel array to copy. + + + + + The width of the pixel array to copy. + + + + + The height of the pixel array to copy. + + + + + + Copy pixels into a 1D texture image + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the internal format of the texture. Must be one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_RGB, GL_R3_G3_B2, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specify the window coordinates of the left corner of the row of pixels to be copied. + + + + + Specifies the width of the texture image. Must be 0 or 2 sup n + 2 ( border ) for some integer . The height of the texture image is 1. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + + Copy pixels into a 2D texture image + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the internal format of the texture. Must be one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_RGB, GL_R3_G3_B2, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specify the window coordinates of the lower left corner of the rectangular region of pixels to be copied. + + + + + Specifies the width of the texture image. Must be 0 or 2 sup n + 2 ( border ) for some integer . + + + + + Specifies the height of the texture image. Must be 0 or 2 sup m + 2 ( border ) for some integer . + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + + Copy a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies the texel offset within the texture array. + + + + + Specify the window coordinates of the left corner of the row of pixels to be copied. + + + + + Specifies the width of the texture subimage. + + + + + + Copy a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specify the window coordinates of the lower left corner of the rectangular region of pixels to be copied. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + + Copy a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specify the window coordinates of the lower left corner of the rectangular region of pixels to be copied. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Delete named textures + + + + Specifies the number of textures to be deleted. + + + + + Specifies an array of textures to be deleted. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the starting index in the enabled arrays. + + + + + Specifies the number of indices to be rendered. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Render primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Specifies the minimum array index contained in indices. + + + + + Specifies the maximum array index contained in indices. + + + + + Specifies the number of elements to be rendered. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + + Define an array of edge flags + + + + Specifies the byte offset between consecutive edge flags. If stride is 0, the edge flags are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first edge flag in the array. The initial value is 0. + + + + + + Define an array of edge flags + + + + Specifies the byte offset between consecutive edge flags. If stride is 0, the edge flags are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first edge flag in the array. The initial value is 0. + + + + + + Define an array of edge flags + + + + Specifies the byte offset between consecutive edge flags. If stride is 0, the edge flags are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first edge flag in the array. The initial value is 0. + + + + + + Set the current fog coordinates + + + + Specify the fog distance. + + + + + + Set the current fog coordinates + + + + Specify the fog distance. + + + + + + Set the current fog coordinates + + + + Specify the fog distance. + + + + + + Set the current fog coordinates + + + + Specify the fog distance. + + + + + + Define an array of fog coordinates + + + + Specifies the data type of each fog coordinate. Symbolic constants GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive fog coordinates. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first fog coordinate in the array. The initial value is 0. + + + + + + Define an array of fog coordinates + + + + Specifies the data type of each fog coordinate. Symbolic constants GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive fog coordinates. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first fog coordinate in the array. The initial value is 0. + + + + + + Define an array of fog coordinates + + + + Specifies the data type of each fog coordinate. Symbolic constants GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive fog coordinates. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first fog coordinate in the array. The initial value is 0. + + + + + + Define an array of fog coordinates + + + + Specifies the data type of each fog coordinate. Symbolic constants GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive fog coordinates. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first fog coordinate in the array. The initial value is 0. + + + + + + Define an array of fog coordinates + + + + Specifies the data type of each fog coordinate. Symbolic constants GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive fog coordinates. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first fog coordinate in the array. The initial value is 0. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Generate texture names + + + + Specifies the number of texture names to be generated. + + + + + Specifies an array in which the generated texture names are stored. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get current 1D or 2D convolution filter kernel + + + + The filter to be retrieved. Must be one of GL_CONVOLUTION_1D or GL_CONVOLUTION_2D. + + + + + Format of the output image. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output image. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the output image. + + + + + + Get current 1D or 2D convolution filter kernel + + + + The filter to be retrieved. Must be one of GL_CONVOLUTION_1D or GL_CONVOLUTION_2D. + + + + + Format of the output image. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output image. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the output image. + + + + + + Get current 1D or 2D convolution filter kernel + + + + The filter to be retrieved. Must be one of GL_CONVOLUTION_1D or GL_CONVOLUTION_2D. + + + + + Format of the output image. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output image. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the output image. + + + + + + Get current 1D or 2D convolution filter kernel + + + + The filter to be retrieved. Must be one of GL_CONVOLUTION_1D or GL_CONVOLUTION_2D. + + + + + Format of the output image. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output image. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the output image. + + + + + + Get current 1D or 2D convolution filter kernel + + + + The filter to be retrieved. Must be one of GL_CONVOLUTION_1D or GL_CONVOLUTION_2D. + + + + + Format of the output image. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output image. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the output image. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get convolution parameters + + + + The filter whose parameters are to be retrieved. Must be one of GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, or GL_SEPARABLE_2D. + + + + + The parameter to be retrieved. Must be one of GL_CONVOLUTION_BORDER_MODE, GL_CONVOLUTION_BORDER_COLOR, GL_CONVOLUTION_FILTER_SCALE, GL_CONVOLUTION_FILTER_BIAS, GL_CONVOLUTION_FORMAT, GL_CONVOLUTION_WIDTH, GL_CONVOLUTION_HEIGHT, GL_MAX_CONVOLUTION_WIDTH, or GL_MAX_CONVOLUTION_HEIGHT. + + + + + Pointer to storage for the parameters to be retrieved. + + + + + + Get histogram table + + + + Must be GL_HISTOGRAM. + + + + + If GL_TRUE, each component counter that is actually returned is reset to zero. (Other counters are unaffected.) If GL_FALSE, none of the counters in the histogram table is modified. + + + + + The format of values to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of values to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned histogram table. + + + + + + Get histogram table + + + + Must be GL_HISTOGRAM. + + + + + If GL_TRUE, each component counter that is actually returned is reset to zero. (Other counters are unaffected.) If GL_FALSE, none of the counters in the histogram table is modified. + + + + + The format of values to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of values to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned histogram table. + + + + + + Get histogram table + + + + Must be GL_HISTOGRAM. + + + + + If GL_TRUE, each component counter that is actually returned is reset to zero. (Other counters are unaffected.) If GL_FALSE, none of the counters in the histogram table is modified. + + + + + The format of values to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of values to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned histogram table. + + + + + + Get histogram table + + + + Must be GL_HISTOGRAM. + + + + + If GL_TRUE, each component counter that is actually returned is reset to zero. (Other counters are unaffected.) If GL_FALSE, none of the counters in the histogram table is modified. + + + + + The format of values to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of values to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned histogram table. + + + + + + Get histogram table + + + + Must be GL_HISTOGRAM. + + + + + If GL_TRUE, each component counter that is actually returned is reset to zero. (Other counters are unaffected.) If GL_FALSE, none of the counters in the histogram table is modified. + + + + + The format of values to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of values to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned histogram table. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get histogram parameters + + + + Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The name of the parameter to be retrieved. Must be one of GL_HISTOGRAM_WIDTH, GL_HISTOGRAM_FORMAT, GL_HISTOGRAM_RED_SIZE, GL_HISTOGRAM_GREEN_SIZE, GL_HISTOGRAM_BLUE_SIZE, GL_HISTOGRAM_ALPHA_SIZE, GL_HISTOGRAM_LUMINANCE_SIZE, or GL_HISTOGRAM_SINK. + + + + + Pointer to storage for the returned values. + + + + + + Get minimum and maximum pixel values + + + + Must be GL_MINMAX. + + + + + If GL_TRUE, all entries in the minmax table that are actually returned are reset to their initial values. (Other entries are unaltered.) If GL_FALSE, the minmax table is unaltered. + + + + + The format of the data to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of the data to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned values. + + + + + + Get minimum and maximum pixel values + + + + Must be GL_MINMAX. + + + + + If GL_TRUE, all entries in the minmax table that are actually returned are reset to their initial values. (Other entries are unaltered.) If GL_FALSE, the minmax table is unaltered. + + + + + The format of the data to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of the data to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned values. + + + + + + Get minimum and maximum pixel values + + + + Must be GL_MINMAX. + + + + + If GL_TRUE, all entries in the minmax table that are actually returned are reset to their initial values. (Other entries are unaltered.) If GL_FALSE, the minmax table is unaltered. + + + + + The format of the data to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of the data to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned values. + + + + + + Get minimum and maximum pixel values + + + + Must be GL_MINMAX. + + + + + If GL_TRUE, all entries in the minmax table that are actually returned are reset to their initial values. (Other entries are unaltered.) If GL_FALSE, the minmax table is unaltered. + + + + + The format of the data to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of the data to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned values. + + + + + + Get minimum and maximum pixel values + + + + Must be GL_MINMAX. + + + + + If GL_TRUE, all entries in the minmax table that are actually returned are reset to their initial values. (Other entries are unaltered.) If GL_FALSE, the minmax table is unaltered. + + + + + The format of the data to be returned in values. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + The type of the data to be returned in values. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + A pointer to storage for the returned values. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get minmax parameters + + + + Must be GL_MINMAX. + + + + + The parameter to be retrieved. Must be one of GL_MINMAX_FORMAT or GL_MINMAX_SINK. + + + + + A pointer to storage for the retrieved parameters. + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Get separable convolution filter kernel images + + + + The separable filter to be retrieved. Must be GL_SEPARABLE_2D. + + + + + Format of the output images. Must be one of GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR GL_RGBA, GL_BGRA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA. + + + + + Data type of components in the output images. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to storage for the row filter image. + + + + + Pointer to storage for the column filter image. + + + + + Pointer to storage for the span filter image (currently unused). + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Returns the value of a uniform variable + + + + Specifies the program object to be queried. + + + + + Specifies the location of the uniform variable to be queried. + + + + + Returns the value of the specified uniform variable. + + + + + + Define histogram table + + + + The histogram whose parameters are to be set. Must be one of GL_HISTOGRAM or GL_PROXY_HISTOGRAM. + + + + + The number of entries in the histogram table. Must be a power of 2. + + + + + The format of entries in the histogram table. Must be one of GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + If GL_TRUE, pixels will be consumed by the histogramming process and no drawing or texture loading will take place. If GL_FALSE, pixels will proceed to the minmax process after histogramming. + + + + + + Define an array of color indexes + + + + Specifies the data type of each color index in the array. Symbolic constants GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive color indexes. If stride is 0, the color indexes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first index in the array. The initial value is 0. + + + + + + Define an array of color indexes + + + + Specifies the data type of each color index in the array. Symbolic constants GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive color indexes. If stride is 0, the color indexes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first index in the array. The initial value is 0. + + + + + + Define an array of color indexes + + + + Specifies the data type of each color index in the array. Symbolic constants GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive color indexes. If stride is 0, the color indexes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first index in the array. The initial value is 0. + + + + + + Define an array of color indexes + + + + Specifies the data type of each color index in the array. Symbolic constants GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive color indexes. If stride is 0, the color indexes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first index in the array. The initial value is 0. + + + + + + Define an array of color indexes + + + + Specifies the data type of each color index in the array. Symbolic constants GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive color indexes. If stride is 0, the color indexes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first index in the array. The initial value is 0. + + + + + + Determine if a name corresponds to a texture + + + + Specifies a value that may be the name of a texture. + + + + + + Determine if a name corresponds to a texture + + + + Specifies a value that may be the name of a texture. + + + + + + Define minmax table + + + + The minmax table whose parameters are to be set. Must be GL_MINMAX. + + + + + The format of entries in the minmax table. Must be one of GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + If GL_TRUE, pixels will be consumed by the minmax process and no drawing or texture loading will take place. If GL_FALSE, pixels will proceed to the final conversion process after minmax. + + + + + + Render multiple sets of primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of starting indices in the enabled arrays. + + + + + Points to an array of the number of indices to be rendered. + + + + + Specifies the size of the first and count + + + + + + Render multiple sets of primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of starting indices in the enabled arrays. + + + + + Points to an array of the number of indices to be rendered. + + + + + Specifies the size of the first and count + + + + + + Render multiple sets of primitives from array data + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of starting indices in the enabled arrays. + + + + + Points to an array of the number of indices to be rendered. + + + + + Specifies the size of the first and count + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Render multiple sets of primitives by specifying indices of array data elements + + + + Specifies what kind of primitives to render. Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON are accepted. + + + + + Points to an array of the elements counts. + + + + + Specifies the type of the values in indices. Must be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT. + + + + + Specifies a pointer to the location where the indices are stored. + + + + + Specifies the size of the count array. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Set the scale and units used to calculate depth values + + + + Specifies a scale factor that is used to create a variable depth offset for each polygon. The initial value is 0. + + + + + Is multiplied by an implementation-specific value to create a constant depth offset. The initial value is 0. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Set texture residence priority + + + + Specifies the number of textures to be prioritized. + + + + + Specifies an array containing the names of the textures to be prioritized. + + + + + Specifies an array containing the texture priorities. A priority given in an element of priorities applies to the texture named by the corresponding element of textures. + + + + + + Reset histogram table entries to zero + + + + Must be GL_HISTOGRAM. + + + + + + Reset minmax table entries to initial values + + + + Must be GL_MINMAX. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Set the current secondary color + + + + Specify new red, green, and blue values for the current secondary color. + + + + + + Define an array of secondary colors + + + + Specifies the number of components per color. Must be 3. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of secondary colors + + + + Specifies the number of components per color. Must be 3. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of secondary colors + + + + Specifies the number of components per color. Must be 3. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of secondary colors + + + + Specifies the number of components per color. Must be 3. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of secondary colors + + + + Specifies the number of components per color. Must be 3. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define a separable two-dimensional convolution filter + + + + Must be GL_SEPARABLE_2D. + + + + + The internal format of the convolution filter kernel. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The number of elements in the pixel array referenced by row. (This is the width of the separable filter kernel.) + + + + + The number of elements in the pixel array referenced by column. (This is the height of the separable filter kernel.) + + + + + The format of the pixel data in row and column. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_INTENSITY, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + The type of the pixel data in row and column. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the row filter kernel. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the column filter kernel. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Specify a three-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level is the n sup th mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup k + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level is the n sup th mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup k + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level is the n sup th mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup k + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level is the n sup th mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup k + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture image + + + + Specifies the target texture. Must be GL_TEXTURE_3D or GL_PROXY_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level is the n sup th mipmap reduction image. + + + + + Specifies the number of color components in the texture. Must be 1, 2, 3, or 4, or one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8. + + + + + Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup n + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels wide. + + + + + Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup m + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels high. + + + + + Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 2 sup k + 2 ( border ) for some integer . All implementations support 3D texture images that are at least 16 texels deep. + + + + + Specifies the width of the border. Must be either 0 or 1. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a one-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_1D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a two-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, or GL_TEXTURE_CUBE_MAP_NEGATIVE_Z. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify a three-dimensional texture subimage + + + + Specifies the target texture. Must be GL_TEXTURE_3D. + + + + + Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image. + + + + + Specifies a texel offset in the x direction within the texture array. + + + + + Specifies a texel offset in the y direction within the texture array. + + + + + Specifies a texel offset in the z direction within the texture array. + + + + + Specifies the width of the texture subimage. + + + + + Specifies the height of the texture subimage. + + + + + Specifies the depth of the texture subimage. + + + + + Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA. + + + + + Specifies the data type of the pixel data. The following symbolic values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Specifies a pointer to the image data in memory. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Specify the value of a uniform variable for the current program object + + + + Specifies the location of the uniform variable to be modified. + + + + + Specifies the new values to be used for the specified uniform variable. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Specify pixel arithmetic for RGB and alpha components separately + + + + Specifies how the red, green, and blue blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE. The initial value is GL_ONE. + + + + + Specifies how the red, green, and blue destination blending factors are computed. The following symbolic constants are accepted: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA. GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA. The initial value is GL_ZERO. + + + + + Specified how the alpha source blending factor is computed. The same symbolic constants are accepted as for srcRGB. The initial value is GL_ONE. + + + + + Specified how the alpha destination blending factor is computed. The same symbolic constants are accepted as for dstRGB. The initial value is GL_ZERO. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of colors + + + + Specifies the number of components per color. Must be 3 or 4. The initial value is 4. + + + + + Specifies the data type of each color component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive colors. If stride is 0, the colors are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first color element in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of normals + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, and GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive normals. If stride is 0, the normals are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first normal in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of texture coordinates + + + + Specifies the number of coordinates per array element. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each texture coordinate. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive texture coordinate sets. If stride is 0, the array elements are understood to be tightly packed. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first texture coordinate set in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Define an array of vertex data + + + + Specifies the number of coordinates per vertex. Must be 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each coordinate in the array. Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies the byte offset between consecutive vertices. If stride is 0, the vertices are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the raster position in window coordinates for pixel operations + + + + Specify the , , coordinates for the raster position. + + + + + + Specify the clear value for the depth buffer + + + + Specifies the depth value used when the depth buffer is cleared. The initial value is 1. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Deletes a program object + + + + Specifies the program object to be deleted. + + + + + + Specify mapping of depth values from normalized device coordinates to window coordinates + + + + Specifies the mapping of the near clipping plane to window coordinates. The initial value is 0. + + + + + Specifies the mapping of the far clipping plane to window coordinates. The initial value is 1. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Returns a parameter from a program object + + + + Specifies the program object to be queried. + + + + + Specifies the object parameter. Accepted symbolic names are GL_DELETE_STATUS, GL_LINK_STATUS, GL_VALIDATE_STATUS, GL_INFO_LOG_LENGTH, GL_ATTACHED_SHADERS, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH. + + + + + Returns the requested object parameter. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Return a generic vertex attribute parameter + + + + Specifies the generic vertex attribute parameter to be queried. + + + + + Specifies the symbolic name of the vertex attribute parameter to be queried. Accepted values are GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, or GL_CURRENT_VERTEX_ATTRIB. + + + + + Returns the requested data. + + + + + + Determines if a name corresponds to a program object + + + + Specifies a potential program object. + + + + + + Determines if a name corresponds to a program object + + + + Specifies a potential program object. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Specifies the value of a generic vertex attribute + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the new values to be used for the specified vertex attribute. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Define an array of generic vertex attribute data + + + + Specifies the index of the generic vertex attribute to be modified. + + + + + Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, or 4. The initial value is 4. + + + + + Specifies the data type of each component in the array. Symbolic constants GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE are accepted. The initial value is GL_FLOAT. + + + + + Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed. + + + + + Specifies the byte offset between consecutive generic vertex attributes. If stride is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0. + + + + + Specifies a pointer to the first component of the first generic vertex attribute in the array. The initial value is 0. + + + + + + Specify implementation-specific hints + + + + Specifies a symbolic constant indicating the behavior to be controlled. GL_FOG_HINT, GL_GENERATE_MIPMAP_HINT, GL_LINE_SMOOTH_HINT, GL_PERSPECTIVE_CORRECTION_HINT, GL_POINT_SMOOTH_HINT, GL_POLYGON_SMOOTH_HINT, GL_TEXTURE_COMPRESSION_HINT, and GL_FRAGMENT_SHADER_DERIVATIVE_HINT are accepted. + + + + + Specifies a symbolic constant indicating the desired behavior. GL_FASTEST, GL_NICEST, and GL_DONT_CARE are accepted. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Set color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a texture color lookup table parameter. Must be one of GL_COLOR_TABLE_SCALE or GL_COLOR_TABLE_BIAS. + + + + + A pointer to an array where the values of the parameters are stored. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Define a color lookup table + + + + Must be one of GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal format of the color table. The allowable values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, and GL_RGBA16. + + + + + The number of entries in the color lookup table specified by data. + + + + + The format of the pixel data in data. The allowable values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in data. The allowable values are GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV. + + + + + Pointer to a one-dimensional array of pixel data that is processed to build the color table. + + + + + + Copy pixels into a color table + + + + The color table target. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The internal storage format of the texture image. Must be one of the following symbolic constants: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16. + + + + + The x coordinate of the lower-left corner of the pixel rectangle to be transferred to the color table. + + + + + The y coordinate of the lower-left corner of the pixel rectangle to be transferred to the color table. + + + + + The width of the pixel rectangle. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Get color lookup table parameters + + + + The target color table. Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, or GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The symbolic name of a color lookup table parameter. Must be one of GL_COLOR_TABLE_BIAS, GL_COLOR_TABLE_SCALE, GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE, or GL_COLOR_TABLE_INTENSITY_SIZE. + + + + + A pointer to an array where the values of the parameter will be stored. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Retrieve contents of a color lookup table + + + + Must be GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, or GL_POST_COLOR_MATRIX_COLOR_TABLE. + + + + + The format of the pixel data in table. The possible values are GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. + + + + + The type of the pixel data in table. Symbolic constants GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV are accepted. + + + + + Pointer to a one-dimensional array of pixel data containing the contents of the color table. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Specify point parameters + + + + Specifies a single-valued point parameter. GL_POINT_SIZE_MIN, GL_POINT_SIZE_MAX, GL_POINT_FADE_THRESHOLD_SIZE, and GL_POINT_SPRITE_COORD_ORIGIN are accepted. + + + + + Specifies the value that pname will be set to. + + + + + + Defines available quality levels for text printing. + + + + Use the default quality, as specified by the operating system. + + + Use fast, low quality text (typically non-antialiased) . + + + Use medium quality text (typically grayscale antialiased). + + + Use slow, high quality text (typically subpixel antialiased). + + + + Represents a single character of a specific Font. + + + + + Represents an item that can be packed with the TexturePacker. + + The type of the packable item. + + + + Checks whether the given object is equal (memberwise) to the current Glyph. + + The obj to check. + True, if the object is identical to the current Glyph. + + + + Describes this Glyph object. + + Returns a System.String describing this Glyph. + + + + Calculates the hashcode for this Glyph. + + A System.Int32 containing a hashcode that uniquely identifies this Glyph. + + + + Compares the current Glyph with the given Glyph. + + The Glyph to compare to. + True if both Glyphs represent the same character of the same Font, false otherwise. + + + + Gets the character represented by this Glyph. + + + + + Gets the Font of this Glyph. + + + + + Gets the size of this Glyph. + + + + + Gets the bounding box of this Glyph. + + + + + Gets an integer representing the width of the Glyph in pixels. + + + + + Gets an integer representing the height of the Glyph in pixels. + + + + + Constructs a new TextureFont, using the specified System.Drawing.Font. + + The System.Drawing.Font to use. + + + + Constructs a new TextureFont, using the specified parameters. + + The System.Drawing.FontFamily to use for the typeface. + The em size to use for the typeface. + + + + Constructs a new TextureFont, using the specified parameters. + + The System.Drawing.FontFamily to use for the typeface. + The em size to use for the typeface. + The style to use for the typeface. + + + + Prepares the specified glyphs for rendering. + + The glyphs to prepare for rendering. + + + + Prepares the specified glyph for rendering. + + The glyph to prepare for rendering. + + + + Returns the characteristics of a loaded glyph. + + The character corresponding to this glyph. + The width of this glyph. + The height of this glyph (line spacing). + The bounding box of the texture buffer of this glyph. + The handle to the texture that contains this glyph. + True if the glyph has been loaded, false otherwise. + + + + + Measures the width of the specified string. + + The string to measure. + The measured width. + The measured height. + If true, adds space to account for glyph overhangs. Set to true if you wish to measure a complete string. Set to false if you wish to perform layout on adjacent strings. + + + + Measures the width of the specified string. + + The string to measure. + The measured width. + The measured height. + + + + + Calculates size information for the specified text. + + The string to measure. + A RectangleF containing the bounding box for the specified text. + + + + Calculates size information for the specified text. + + The string to measure. + A SizeF structure containing the maximum desired width and height of the text. Default is SizeF.Empty. + A RectangleF containing the bounding box for the specified text. + + + + Calculates size information for the specified text. + + The string to measure. + A SizeF structure containing the maximum desired width and height of the text. Pass SizeF.Empty to disable wrapping calculations. A width or height of 0 disables the relevant calculation. + A StringFormat object which specifies the measurement format of the string. Pass null to use the default StringFormat (StringFormat.GenericTypographic). + A RectangleF containing the bounding box for the specified text. + + + + Calculates size information for the specified text. + + The string to measure. + A SizeF structure containing the maximum desired width and height of the text. Pass SizeF.Empty to disable wrapping calculations. A width or height of 0 disables the relevant calculation. + A StringFormat object which specifies the measurement format of the string. Pass null to use the default StringFormat (StringFormat.GenericDefault). + Fills the specified IList of RectangleF structures with position information for individual characters. If this argument is null, these calculations are skipped. + A RectangleF containing the bounding box for the specified text. + + + + Calculates the optimal size for the font texture and TexturePacker, and creates both. + + + + + Releases all resources used by this OpenTK.Graphics.TextureFont. + + + + + Finalizes this TextureFont. + + + + + Gets a float indicating the default line spacing of this font. + + + + + Gets a float indicating the default size of this font, in points. + + + + + Gets the handle to the texture were this font resides. + + + + + Provides text printing through OpenGL 1.1 Display Lists. + + + + + Defines the interface for TextPrinter implementations. + + + + + Caches a text fragment for future use. + + The vertex array for the text fragment. + The index array for the text fragment. Please use the indexCount parameter + instead of indices.Count, as the indices array may be larger than necessary for performance reasons. + The actual number of indices in the text fragment. + A TextHandle that can be used to draw the text fragment. + + + + Draws the specified cached text fragment. + + The TextHandle corresponding to the desired text fragment. + + + + Draws a text fragment, without caching. + + The vertex array for the text fragment. + The index array for the text fragment. Please use the indexCount parameter + instead of indices.Count, as the indices array may be larger than necessary for performance reasons. + The actual number of indices in the text fragment. + + + + Provides access to the OpenGL Utilities library. + Methods i this library are considered deprecated and should be avoided. + + + + + Creates a System.Delegate that can be used to call a GLU function, core or extension. + + The name of the GLU function (eg. "gluBuild2DMipmaps") + The signature of the GLU function. + + A System.Delegate that can be used to call this GLU function, or null if the specified + function name did not correspond to an GLU function. + + + + + Loads all GLU functions (core and extensions). + + + + Call this function manually whenever you need to update GLU entry points. + This need will never arise under normal usage patterns. + + + + + + Tries to reload the given GLU function (core or extension). + + The name of the GLU function. + True if the function was found and reloaded, false otherwise. + + + While the automatic initialisation will load all GLU entry points, in some cases + the initialization can take place before a render context has been established. + In this case, use this function to load the entry points for the GLU functions + you will need, or use LoadAll() to load all available entry points. + + + This function returns true if the given GLU function is supported, false otherwise. + + + To query for supported extensions use the IsExtensionSupported() function instead. + + + + + + Determines whether the specified GLU extension is available in + the current GLU context. + + The string for the GLU extension. + True if the specified extension is available, false otherwise. + + + + Builds a cache of the supported extensions to speed up searches. + + + + + Represents exceptions related to IGraphicsResources. + + + + Constructs a new GraphicsResourceException. + + + Constructs a new string with the specified error message. + + + This function enables a feature of the OpenAL driver. There are no capabilities defined in OpenAL 1.1 to be used with this function, but it may be used by an extension. + The name of a capability to enable. + + + This function disables a feature of the OpenAL driver. + The name of a capability to disable. + + + This function returns a boolean indicating if a specific feature is enabled in the OpenAL driver. + The name of a capability to enable. + True if enabled, False if disabled. + + + This function retrieves an OpenAL string property. + The property to be returned: Vendor, Version, Renderer and Extensions + Returns a pointer to a null-terminated string. + + + This function retrieves an OpenAL string property. + The human-readable errorstring to be returned. + Returns a pointer to a null-terminated string. + + + This function returns an integer OpenAL state. + the state to be queried: DistanceModel. + The integer state described by param will be returned. + + + This function returns a floating-point OpenAL state. + the state to be queried: DopplerFactor, SpeedOfSound. + The floating-point state described by param will be returned. + + + Error support. Obtain the most recent error generated in the AL state machine. When an error is detected by AL, a flag is set and the error code is recorded. Further errors, if they occur, do not affect this recorded code. When alGetError is called, the code is returned and the flag is cleared, so that a further error will again record its code. + The first error that occured. can be used with AL.GetString. Returns an Alenum representing the error state. When an OpenAL error occurs, the error state is set and will not be changed until the error state is retrieved using alGetError. Whenever alGetError is called, the error state is cleared and the last state (the current state when the call was made) is returned. To isolate error detection to a specific portion of code, alGetError should be called before the isolated section to clear the current error state. + + + This function tests if a specific Extension is available for the OpenAL driver. + A string naming the desired extension. Example: "EAX-RAM" + Returns True if the Extension is available or False if not available. + + + This function returns the address of an OpenAL extension function. Handle with care. + A string containing the function name. + The return value is a pointer to the specified function. The return value will be IntPtr.Zero if the function is not found. + + + This function returns the enumeration value of an OpenAL token, described by a string. + A string describing an OpenAL token. Example "AL_DISTANCE_MODEL" + Returns the actual ALenum described by a string. Returns 0 if the string doesn’t describe a valid OpenAL token. + + + This function sets a floating-point property for the listener. + The name of the attribute to be set: ALListenerf.Gain + The float value to set the attribute to. + + + This function sets a floating-point property for the listener. + The name of the attribute to set: ALListener3f.Position, ALListener3f.Velocity + The value to set the attribute to. + The value to set the attribute to. + The value to set the attribute to. + + + This function sets a Math.Vector3 property for the listener. + The name of the attribute to set: ALListener3f.Position, ALListener3f.Velocity + The Math.Vector3 to set the attribute to. + + + This function sets a floating-point vector property of the listener. + The name of the attribute to be set: ALListener3f.Position, ALListener3f.Velocity, ALListenerfv.Orientation + Pointer to floating-point vector values. + + + This function sets two Math.Vector3 properties of the listener. + The name of the attribute to be set: ALListenerfv.Orientation + A Math.Vector3 for the At-Vector. + A Math.Vector3 for the Up-Vector. + + + This function retrieves a floating-point property of the listener. + the name of the attribute to be retrieved: ALListenerf.Gain + a pointer to the floating-point value being retrieved. + + + This function retrieves a set of three floating-point values from a property of the listener. + The name of the attribute to be retrieved: ALListener3f.Position, ALListener3f.Velocity + Pointers to the three floating-point being retrieved. + Pointers to the three floating-point being retrieved. + Pointers to the three floating-point being retrieved. + + + This function retrieves a Math.Vector3 from a property of the listener. + The name of the attribute to be retrieved: ALListener3f.Position, ALListener3f.Velocity + A Math.Vector3 to hold the three floats being retrieved. + + + This function retrieves a floating-point vector property of the listener. You must pin it manually. + the name of the attribute to be retrieved: ALListener3f.Position, ALListener3f.Velocity, ALListenerfv.Orientation + A pointer to the floating-point vector value being retrieved. + + + This function retrieves two Math.Vector3 properties of the listener. + the name of the attribute to be retrieved: ALListenerfv.Orientation + A Math.Vector3 for the At-Vector. + A Math.Vector3 for the Up-Vector. + + + This function generates one or more sources. References to sources are uint values, which are used wherever a source reference is needed (in calls such as AL.DeleteSources and AL.Source with parameter ALSourcei). + The number of sources to be generated. + Pointer to an array of uint values which will store the names of the new sources. + + + This function generates one or more sources. References to sources are int values, which are used wherever a source reference is needed (in calls such as AL.DeleteSources and AL.Source with parameter ALSourcei). + The number of sources to be generated. + Pointer to an array of int values which will store the names of the new sources. + + + This function generates one or more sources. References to sources are int values, which are used wherever a source reference is needed (in calls such as AL.DeleteSources and AL.Source with parameter ALSourcei). + Pointer to an array of int values which will store the names of the new sources. + + + This function generates one or more sources. References to sources are int values, which are used wherever a source reference is needed (in calls such as AL.DeleteSources and AL.Source with parameter ALSourcei). + The number of sources to be generated. + Pointer to an array of int values which will store the names of the new sources. + + + This function generates one source only. References to sources are int values, which are used wherever a source reference is needed (in calls such as AL.DeleteSources and AL.Source with parameter ALSourcei). + Pointer to an int value which will store the name of the new source. + + + This function generates one source only. References to sources are uint values, which are used wherever a source reference is needed (in calls such as AL.DeleteSources and AL.Source with parameter ALSourcei). + Pointer to an uint value which will store the name of the new source. + + + This function deletes one or more sources. + The number of sources to be deleted. + Pointer to an array of source names identifying the sources to be deleted. + + + This function deletes one or more sources. + The number of sources to be deleted. + Reference to a single source, or an array of source names identifying the sources to be deleted. + + + This function deletes one or more sources. + The number of sources to be deleted. + Reference to a single source, or an array of source names identifying the sources to be deleted. + + + This function deletes one or more sources. + An array of source names identifying the sources to be deleted. + + + This function deletes one or more sources. + An array of source names identifying the sources to be deleted. + + + This function deletes one source only. + Pointer to a source name identifying the source to be deleted. + + + This function deletes one source only. + Pointer to a source name identifying the source to be deleted. + + + This function tests if a source name is valid, returning True if valid and False if not. + A source name to be tested for validity + Success. + + + This function tests if a source name is valid, returning True if valid and False if not. + A source name to be tested for validity + Success. + + + This function sets a floating-point property of a source. + Source name whose attribute is being set + The name of the attribute to set: ALSourcef.Pitch, Gain, MinGain, MaxGain, MaxDistance, RolloffFactor, ConeOuterGain, ConeInnerAngle, ConeOuterAngle, ReferenceDistance, EfxAirAbsorptionFactor, EfxRoomRolloffFactor, EfxConeOuterGainHighFrequency. + The value to set the attribute to. + + + This function sets a floating-point property of a source. + Source name whose attribute is being set + The name of the attribute to set: ALSourcef.Pitch, Gain, MinGain, MaxGain, MaxDistance, RolloffFactor, ConeOuterGain, ConeInnerAngle, ConeOuterAngle, ReferenceDistance, EfxAirAbsorptionFactor, EfxRoomRolloffFactor, EfxConeOuterGainHighFrequency. + The value to set the attribute to. + + + This function sets a source property requiring three floating-point values. + Source name whose attribute is being set. + The name of the attribute to set: ALSource3f.Position, Velocity, Direction. + The three ALfloat values which the attribute will be set to. + The three ALfloat values which the attribute will be set to. + The three ALfloat values which the attribute will be set to. + + + This function sets a source property requiring three floating-point values. + Source name whose attribute is being set. + The name of the attribute to set: ALSource3f.Position, Velocity, Direction. + The three ALfloat values which the attribute will be set to. + The three ALfloat values which the attribute will be set to. + The three ALfloat values which the attribute will be set to. + + + This function sets a source property requiring three floating-point values. + Source name whose attribute is being set. + The name of the attribute to set: ALSource3f.Position, Velocity, Direction. + A Math.Vector3 which the attribute will be set to. + + + This function sets a source property requiring three floating-point values. + Source name whose attribute is being set. + The name of the attribute to set: ALSource3f.Position, Velocity, Direction. + A Math.Vector3 which the attribute will be set to. + + + This function sets an integer property of a source. + Source name whose attribute is being set. + The name of the attribute to set: ALSourcei.SourceRelative, ConeInnerAngle, ConeOuterAngle, Looping, Buffer, SourceState. + The value to set the attribute to. + + + This function sets an integer property of a source. + Source name whose attribute is being set. + The name of the attribute to set: ALSourcei.SourceRelative, ConeInnerAngle, ConeOuterAngle, Looping, Buffer, SourceState. + The value to set the attribute to. + + + This function sets an bool property of a source. + Source name whose attribute is being set. + The name of the attribute to set: ALSourceb.SourceRelative, Looping. + The value to set the attribute to. + + + This function sets an bool property of a source. + Source name whose attribute is being set. + The name of the attribute to set: ALSourceb.SourceRelative, Looping. + The value to set the attribute to. + + + (Helper) Binds a Buffer to a Source handle. + Source name to attach the Buffer to. + Buffer name which is attached to the Source. + + + (Helper) Binds a Buffer to a Source handle. + Source name to attach the Buffer to. + Buffer name which is attached to the Source. + + + This function sets 3 integer properties of a source. This property is used to establish connections between Sources and Auxiliary Effect Slots. + Source name whose attribute is being set. + The name of the attribute to set: EfxAuxiliarySendFilter + The value to set the attribute to. (EFX Extension) The destination Auxiliary Effect Slot ID + The value to set the attribute to. (EFX Extension) The Auxiliary Send number. + The value to set the attribute to. (EFX Extension) optional Filter ID. + + + This function sets 3 integer properties of a source. This property is used to establish connections between Sources and Auxiliary Effect Slots. + Source name whose attribute is being set. + The name of the attribute to set: EfxAuxiliarySendFilter + The value to set the attribute to. (EFX Extension) The destination Auxiliary Effect Slot ID + The value to set the attribute to. (EFX Extension) The Auxiliary Send number. + The value to set the attribute to. (EFX Extension) optional Filter ID. + + + This function retrieves a floating-point property of a source. + Source name whose attribute is being retrieved. + The name of the attribute to set: ALSourcef.Pitch, Gain, MinGain, MaxGain, MaxDistance, RolloffFactor, ConeOuterGain, ConeInnerAngle, ConeOuterAngle, ReferenceDistance, EfxAirAbsorptionFactor, EfxRoomRolloffFactor, EfxConeOuterGainHighFrequency. + A pointer to the floating-point value being retrieved + + + This function retrieves a floating-point property of a source. + Source name whose attribute is being retrieved. + The name of the attribute to set: ALSourcef.Pitch, Gain, MinGain, MaxGain, MaxDistance, RolloffFactor, ConeOuterGain, ConeInnerAngle, ConeOuterAngle, ReferenceDistance, EfxAirAbsorptionFactor, EfxRoomRolloffFactor, EfxConeOuterGainHighFrequency. + A pointer to the floating-point value being retrieved + + + This function retrieves three floating-point values representing a property of a source. + Source name whose attribute is being retrieved. + the name of the attribute being retrieved: ALSource3f.Position, Velocity, Direction. + Pointer to the value to retrieve. + Pointer to the value to retrieve. + Pointer to the value to retrieve. + + + This function retrieves three floating-point values representing a property of a source. + Source name whose attribute is being retrieved. + the name of the attribute being retrieved: ALSource3f.Position, Velocity, Direction. + Pointer to the value to retrieve. + Pointer to the value to retrieve. + Pointer to the value to retrieve. + + + This function retrieves three floating-point values representing a property of a source. + Source name whose attribute is being retrieved. + the name of the attribute being retrieved: ALSource3f.Position, Velocity, Direction. + A Math.Vector3 to retrieve the values to. + + + This function retrieves three floating-point values representing a property of a source. + Source name whose attribute is being retrieved. + the name of the attribute being retrieved: ALSource3f.Position, Velocity, Direction. + A Math.Vector3 to retrieve the values to. + + + This function retrieves an integer property of a source. + Source name whose attribute is being retrieved. + The name of the attribute to retrieve: ALSourcei.SourceRelative, Buffer, SourceState, BuffersQueued, BuffersProcessed. + A pointer to the integer value being retrieved. + + + This function retrieves an integer property of a source. + Source name whose attribute is being retrieved. + The name of the attribute to retrieve: ALSourcei.SourceRelative, Buffer, SourceState, BuffersQueued, BuffersProcessed. + A pointer to the integer value being retrieved. + + + This function retrieves a bool property of a source. + Source name whose attribute is being retrieved. + The name of the attribute to get: ALSourceb.SourceRelative, Looping. + A pointer to the bool value being retrieved. + + + This function retrieves a bool property of a source. + Source name whose attribute is being retrieved. + The name of the attribute to get: ALSourceb.SourceRelative, Looping. + A pointer to the bool value being retrieved. + + + This function plays a set of sources. The playing sources will have their state changed to ALSourceState.Playing. When called on a source which is already playing, the source will restart at the beginning. When the attached buffer(s) are done playing, the source will progress to the ALSourceState.Stopped state. + The number of sources to be played. + A pointer to an array of sources to be played. + + + This function plays a set of sources. The playing sources will have their state changed to ALSourceState.Playing. When called on a source which is already playing, the source will restart at the beginning. When the attached buffer(s) are done playing, the source will progress to the ALSourceState.Stopped state. + The number of sources to be played. + A pointer to an array of sources to be played. + + + This function plays a set of sources. The playing sources will have their state changed to ALSourceState.Playing. When called on a source which is already playing, the source will restart at the beginning. When the attached buffer(s) are done playing, the source will progress to the ALSourceState.Stopped state. + The number of sources to be played. + A pointer to an array of sources to be played. + + + This function plays a set of sources. The playing sources will have their state changed to ALSourceState.Playing. When called on a source which is already playing, the source will restart at the beginning. When the attached buffer(s) are done playing, the source will progress to the ALSourceState.Stopped state. + The number of sources to be played. + A pointer to an array of sources to be played. + + + This function stops a set of sources. The stopped sources will have their state changed to ALSourceState.Stopped. + The number of sources to stop. + A pointer to an array of sources to be stopped. + + + This function stops a set of sources. The stopped sources will have their state changed to ALSourceState.Stopped. + The number of sources to stop. + A pointer to an array of sources to be stopped. + + + This function stops a set of sources. The stopped sources will have their state changed to ALSourceState.Stopped. + The number of sources to stop. + A pointer to an array of sources to be stopped. + + + This function stops a set of sources. The stopped sources will have their state changed to ALSourceState.Stopped. + The number of sources to stop. + A pointer to an array of sources to be stopped. + + + This function stops a set of sources and sets all their states to ALSourceState.Initial. + The number of sources to be rewound. + A pointer to an array of sources to be rewound. + + + This function stops a set of sources and sets all their states to ALSourceState.Initial. + The number of sources to be rewound. + A pointer to an array of sources to be rewound. + + + This function stops a set of sources and sets all their states to ALSourceState.Initial. + The number of sources to be rewound. + A pointer to an array of sources to be rewound. + + + This function stops a set of sources and sets all their states to ALSourceState.Initial. + The number of sources to be rewound. + A pointer to an array of sources to be rewound. + + + This function pauses a set of sources. The paused sources will have their state changed to ALSourceState.Paused. + The number of sources to be paused. + A pointer to an array of sources to be paused. + + + This function pauses a set of sources. The paused sources will have their state changed to ALSourceState.Paused. + The number of sources to be paused. + A pointer to an array of sources to be paused. + + + This function pauses a set of sources. The paused sources will have their state changed to ALSourceState.Paused. + The number of sources to be paused. + A pointer to an array of sources to be paused. + + + This function pauses a set of sources. The paused sources will have their state changed to ALSourceState.Paused. + The number of sources to be paused. + A pointer to an array of sources to be paused. + + + This function plays, replays or resumes a source. The playing source will have it's state changed to ALSourceState.Playing. When called on a source which is already playing, the source will restart at the beginning. When the attached buffer(s) are done playing, the source will progress to the ALSourceState.Stopped state. + The name of the source to be played. + + + This function plays, replays or resumes a source. The playing source will have it's state changed to ALSourceState.Playing. When called on a source which is already playing, the source will restart at the beginning. When the attached buffer(s) are done playing, the source will progress to the ALSourceState.Stopped state. + The name of the source to be played. + + + This function stops a source. The stopped source will have it's state changed to ALSourceState.Stopped. + The name of the source to be stopped. + + + This function stops a source. The stopped source will have it's state changed to ALSourceState.Stopped. + The name of the source to be stopped. + + + This function stops the source and sets its state to ALSourceState.Initial. + The name of the source to be rewound. + + + This function stops the source and sets its state to ALSourceState.Initial. + The name of the source to be rewound. + + + This function pauses a source. The paused source will have its state changed to ALSourceState.Paused. + The name of the source to be paused. + + + This function pauses a source. The paused source will have its state changed to ALSourceState.Paused. + The name of the source to be paused. + + + This function queues a set of buffers on a source. All buffers attached to a source will be played in sequence, and the number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed. When first created, a source will be of type ALSourceType.Undetermined. A successful AL.SourceQueueBuffers call will change the source type to ALSourceType.Streaming. + The name of the source to queue buffers onto. + The number of buffers to be queued. + A pointer to an array of buffer names to be queued. + + + This function queues a set of buffers on a source. All buffers attached to a source will be played in sequence, and the number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed. When first created, a source will be of type ALSourceType.Undetermined. A successful AL.SourceQueueBuffers call will change the source type to ALSourceType.Streaming. + The name of the source to queue buffers onto. + The number of buffers to be queued. + A pointer to an array of buffer names to be queued. + + + This function queues a set of buffers on a source. All buffers attached to a source will be played in sequence, and the number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed. When first created, a source will be of type ALSourceType.Undetermined. A successful AL.SourceQueueBuffers call will change the source type to ALSourceType.Streaming. + The name of the source to queue buffers onto. + The number of buffers to be queued. + A pointer to an array of buffer names to be queued. + + + This function queues a set of buffers on a source. All buffers attached to a source will be played in sequence, and the number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed. When first created, a source will be of type ALSourceType.Undetermined. A successful AL.SourceQueueBuffers call will change the source type to ALSourceType.Streaming. + The name of the source to queue buffers onto. + The number of buffers to be queued. + A pointer to an array of buffer names to be queued. + + + This function queues a set of buffers on a source. All buffers attached to a source will be played in sequence, and the number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed. When first created, a source will be of type ALSourceType.Undetermined. A successful AL.SourceQueueBuffers call will change the source type to ALSourceType.Streaming. + The name of the source to queue buffers onto. + The name of the buffer to be queued. + + + This function unqueues a set of buffers attached to a source. The number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed, which is the maximum number of buffers that can be unqueued using this call. The unqueue operation will only take place if all n buffers can be removed from the queue. + The name of the source to unqueue buffers from. + The number of buffers to be unqueued. + A pointer to an array of buffer names that were removed. + + + This function unqueues a set of buffers attached to a source. The number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed, which is the maximum number of buffers that can be unqueued using this call. The unqueue operation will only take place if all n buffers can be removed from the queue. + The name of the source to unqueue buffers from. + The number of buffers to be unqueued. + A pointer to an array of buffer names that were removed. + + + This function unqueues a set of buffers attached to a source. The number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed, which is the maximum number of buffers that can be unqueued using this call. The unqueue operation will only take place if all n buffers can be removed from the queue. + The name of the source to unqueue buffers from. + The number of buffers to be unqueued. + A pointer to an array of buffer names that were removed. + + + This function unqueues a set of buffers attached to a source. The number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed, which is the maximum number of buffers that can be unqueued using this call. The unqueue operation will only take place if all n buffers can be removed from the queue. + The name of the source to unqueue buffers from. + The number of buffers to be unqueued. + A pointer to an array of buffer names that were removed. + + + This function unqueues a set of buffers attached to a source. The number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed, which is the maximum number of buffers that can be unqueued using this call. The unqueue operation will only take place if all n buffers can be removed from the queue. + The name of the source to unqueue buffers from. + The number of buffers to be unqueued. + A pointer to an array of buffer names that were removed. + + + This function unqueues a set of buffers attached to a source. The number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed, which is the maximum number of buffers that can be unqueued using this call. The unqueue operation will only take place if all n buffers can be removed from the queue. + The name of the source to unqueue buffers from. + + + This function unqueues a set of buffers attached to a source. The number of processed buffers can be detected using AL.GetSource with parameter ALGetSourcei.BuffersProcessed, which is the maximum number of buffers that can be unqueued using this call. The unqueue operation will only take place if all n buffers can be removed from the queue. + The name of the source to unqueue buffers from. + The number of buffers to be unqueued. + + + This function generates one or more buffers, which contain audio buffer (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). + The number of buffers to be generated. + Pointer to an array of uint values which will store the names of the new buffers. + + + This function generates one or more buffers, which contain audio buffer (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). + The number of buffers to be generated. + Pointer to an array of uint values which will store the names of the new buffers. + + + This function generates one or more buffers, which contain audio buffer (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). + The number of buffers to be generated. + Pointer to an array of uint values which will store the names of the new buffers. + + + This function generates one or more buffers, which contain audio data (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). + The number of buffers to be generated. + Pointer to an array of uint values which will store the names of the new buffers. + + + This function generates one buffer only, which contain audio data (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). + Pointer to an uint value which will store the name of the new buffer. + + + This function generates one buffer only, which contain audio data (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). + Pointer to an uint value which will store the names of the new buffer. + + + This function deletes one or more buffers, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. + The number of buffers to be deleted. + Pointer to an array of buffer names identifying the buffers to be deleted. + + + This function deletes one or more buffers, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. + The number of buffers to be deleted. + Pointer to an array of buffer names identifying the buffers to be deleted. + + + This function deletes one or more buffers, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. + The number of buffers to be deleted. + Pointer to an array of buffer names identifying the buffers to be deleted. + + + This function deletes one buffer only, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. + Pointer to a buffer name identifying the buffer to be deleted. + + + This function deletes one or more buffers, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. + Pointer to an array of buffer names identifying the buffers to be deleted. + + + This function deletes one buffer only, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. + Pointer to a buffer name identifying the buffer to be deleted. + + + This function deletes one buffer only, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. + Pointer to a buffer name identifying the buffer to be deleted. + + + This function tests if a buffer name is valid, returning True if valid, False if not. + A buffer Handle previously allocated with . + Success. + + + This function tests if a buffer name is valid, returning True if valid, False if not. + A buffer Handle previously allocated with . + Success. + + + This function fills a buffer with audio buffer. All the pre-defined formats are PCM buffer, but this function may be used by extensions to load other buffer types as well. + buffer Handle/Name to be filled with buffer. + Format type from among the following: ALFormat.Mono8, ALFormat.Mono16, ALFormat.Stereo8, ALFormat.Stereo16. + Pointer to a pinned audio buffer. + The size of the audio buffer in bytes. + The frequency of the audio buffer. + + + This function fills a buffer with audio buffer. All the pre-defined formats are PCM buffer, but this function may be used by extensions to load other buffer types as well. + buffer Handle/Name to be filled with buffer. + Format type from among the following: ALFormat.Mono8, ALFormat.Mono16, ALFormat.Stereo8, ALFormat.Stereo16. + Pointer to a pinned audio buffer. + The size of the audio buffer in bytes. + The frequency of the audio buffer. + + + This function fills a buffer with audio buffer. All the pre-defined formats are PCM buffer, but this function may be used by extensions to load other buffer types as well. + buffer Handle/Name to be filled with buffer. + Format type from among the following: ALFormat.Mono8, ALFormat.Mono16, ALFormat.Stereo8, ALFormat.Stereo16. + The audio buffer. + The size of the audio buffer in bytes. + The frequency of the audio buffer. + + + This function fills a buffer with audio buffer (PCM format). + Buffer Handle/Name to be filled with buffer. + A SoundData object containing the buffer to upload. + + + This function fills a buffer with audio buffer (PCM format). + Buffer Handle/Name to be filled with buffer. + A SoundData object containing the buffer to upload. + + + This function retrieves an integer property of a buffer. + Buffer name whose attribute is being retrieved + The name of the attribute to be retrieved: ALGetBufferi.Frequency, Bits, Channels, Size, and the currently hidden AL_DATA (dangerous). + A pointer to an int to hold the retrieved buffer + + + This function retrieves an integer property of a buffer. + Buffer name whose attribute is being retrieved + The name of the attribute to be retrieved: ALGetBufferi.Frequency, Bits, Channels, Size, and the currently hidden AL_DATA (dangerous). + A pointer to an int to hold the retrieved buffer + + + AL.DopplerFactor is a simple scaling of source and listener velocities to exaggerate or deemphasize the Doppler (pitch) shift resulting from the calculation. + A negative value will result in an error, the command is then ignored. The default value is 1f. The current setting can be queried using AL.Get with parameter ALGetFloat.SpeedOfSound. + + + This function is deprecated and should not be used. + The default is 1.0f. + + + AL.SpeedOfSound allows the application to change the reference (propagation) speed used in the Doppler calculation. The source and listener velocities should be expressed in the same units as the speed of sound. + A negative or zero value will result in an error, and the command is ignored. Default: 343.3f (appropriate for velocity units of meters and air as the propagation medium). The current setting can be queried using AL.Get with parameter ALGetFloat.SpeedOfSound. + + + This function selects the OpenAL distance model – ALDistanceModel.InverseDistance, ALDistanceModel.InverseDistanceClamped, ALDistanceModel.LinearDistance, ALDistanceModel.LinearDistanceClamped, ALDistanceModel.ExponentDistance, ALDistanceModel.ExponentDistanceClamped, or ALDistanceModel.None. The default distance model in OpenAL is ALDistanceModel.InverseDistanceClamped. + + The ALDistanceModel .InverseDistance model works according to the following formula: + gain = ALSourcef.ReferenceDistance / (ALSourcef.ReferenceDistance + ALSourcef.RolloffFactor * (distance – ALSourcef.ReferenceDistance)); + + The ALDistanceModel .InverseDistanceClamped model works according to the following formula: + distance = max(distance,ALSourcef.ReferenceDistance); + distance = min(distance,ALSourcef.MaxDistance); + gain = ALSourcef.ReferenceDistance / (ALSourcef.ReferenceDistance + ALSourcef.RolloffFactor * (distance – ALSourcef.ReferenceDistance)); + + The ALDistanceModel.LinearDistance model works according to the following formula: + distance = min(distance, ALSourcef.MaxDistance) // avoid negative gain + gain = (1 – ALSourcef.RolloffFactor * (distance – ALSourcef.ReferenceDistance) / (ALSourcef.MaxDistance – ALSourcef.ReferenceDistance)) + + The ALDistanceModel.LinearDistanceClamped model works according to the following formula: + distance = max(distance, ALSourcef.ReferenceDistance) + distance = min(distance, ALSourcef.MaxDistance) + gain = (1 – ALSourcef.RolloffFactor * (distance – ALSourcef.ReferenceDistance) / (ALSourcef.MaxDistance – ALSourcef.ReferenceDistance)) + + The ALDistanceModel.ExponentDistance model works according to the following formula: + gain = (distance / ALSourcef.ReferenceDistance) ^ (- ALSourcef.RolloffFactor) + + The ALDistanceModel.ExponentDistanceClamped model works according to the following formula: + distance = max(distance, ALSourcef.ReferenceDistance) + distance = min(distance, ALSourcef.MaxDistance) + gain = (distance / ALSourcef.ReferenceDistance) ^ (- ALSourcef.RolloffFactor) + + The ALDistanceModel.None model works according to the following formula: + gain = 1f; + + + + + (Helper) Returns Source state information. + The source to be queried. + state information from OpenAL. + + + (Helper) Returns Source state information. + The source to be queried. + state information from OpenAL. + + + (Helper) Returns Source type information. + The source to be queried. + type information from OpenAL. + + + (Helper) Returns Source type information. + The source to be queried. + type information from OpenAL. + + + A list of valid 32-bit Float Effect/GetEffect parameters + + + Reverb Modal Density controls the coloration of the late reverb. Lowering the value adds more coloration to the late reverb. Range [0.0f .. 1.0f] Default: 1.0f + + + The Reverb Diffusion property controls the echo density in the reverberation decay. The default 1.0f provides the highest density. Reducing diffusion gives the reverberation a more "grainy" character that is especially noticeable with percussive sound sources. If you set a diffusion value of 0.0f, the later reverberation sounds like a succession of distinct echoes. Range [0.0f .. 1.0f] Default: 1.0f + + + The Reverb Gain property is the master volume control for the reflected sound - both early reflections and reverberation - that the reverb effect adds to all sound sources. Ranges from 1.0 (0db) (the maximum amount) to 0.0 (-100db) (no reflected sound at all) are accepted. Units: Linear gain Range [0.0f .. 1.0f] Default: 0.32f + + + The Reverb Gain HF property further tweaks reflected sound by attenuating it at high frequencies. It controls a low-pass filter that applies globally to the reflected sound of all sound sources feeding the particular instance of the reverb effect. Ranges from 1.0f (0db) (no filter) to 0.0f (-100db) (virtually no reflected sound) are accepted. Units: Linear gain Range [0.0f .. 1.0f] Default: 0.89f + + + The Decay Time property sets the reverberation decay time. It ranges from 0.1f (typically a small room with very dead surfaces) to 20.0 (typically a large room with very live surfaces). Unit: Seconds Range [0.1f .. 20.0f] Default: 1.49f + + + The Decay HF Ratio property sets the spectral quality of the Decay Time parameter. It is the ratio of high-frequency decay time relative to the time set by Decay Time.. Unit: linear multiplier Range [0.1f .. 2.0f] Default: 0.83f + + + The Reflections Gain property controls the overall amount of initial reflections relative to the Gain property. The value of Reflections Gain ranges from a maximum of 3.16f (+10 dB) to a minimum of 0.0f (-100 dB) (no initial reflections at all), and is corrected by the value of the Gain property. Unit: Linear gain Range [0.0f .. 3.16f] Default: 0.05f + + + The Reflections Delay property is the amount of delay between the arrival time of the direct path from the source to the first reflection from the source. It ranges from 0 to 300 milliseconds. Unit: Seconds Range [0.0f .. 0.3f] Default: 0.007f + + + The Late Reverb Gain property controls the overall amount of later reverberation relative to the Gain property. The value of Late Reverb Gain ranges from a maximum of 10.0f (+20 dB) to a minimum of 0.0f (-100 dB) (no late reverberation at all). Unit: Linear gain Range [0.0f .. 10.0f] Default: 1.26f + + + The Late Reverb Delay property defines the begin time of the late reverberation relative to the time of the initial reflection (the first of the early reflections). It ranges from 0 to 100 milliseconds. Unit: Seconds Range [0.0f .. 0.1f] Default: 0.011f + + + The Air Absorption Gain HF property controls the distance-dependent attenuation at high frequencies caused by the propagation medium and applies to reflected sound only. Unit: Linear gain per meter Range [0.892f .. 1.0f] Default: 0.994f + + + The Room Rolloff Factor property is one of two methods available to attenuate the reflected sound (containing both reflections and reverberation) according to source-listener distance. It's defined the same way as OpenAL's Rolloff Factor, but operates on reverb sound instead of direct-path sound. Unit: Linear multiplier Range [0.0f .. 10.0f] Default: 0.0f + + + This property sets the modulation rate of the low-frequency oscillator that controls the delay time of the delayed signals. Unit: Hz Range [0.0f .. 10.0f] Default: 1.1f + + + This property controls the amount by which the delay time is modulated by the low-frequency oscillator. Range [0.0f .. 1.0f] Default: 0.1f + + + This property controls the amount of processed signal that is fed back to the input of the chorus effect. Negative values will reverse the phase of the feedback signal. At full magnitude the identical sample will repeat endlessly. Range [-1.0f .. +1.0f] Default: +0.25f + + + This property controls the average amount of time the sample is delayed before it is played back, and with feedback, the amount of time between iterations of the sample. Larger values lower the pitch. Unit: Seconds Range [0.0f .. 0.016f] Default: 0.016f + + + This property controls the shape of the distortion. The higher the value for Edge, the "dirtier" and "fuzzier" the effect. Range [0.0f .. 1.0f] Default: 0.2f + + + This property allows you to attenuate the distorted sound. Range [0.01f .. 1.0f] Default: 0.05f + + + Input signals can have a low pass filter applied, to limit the amount of high frequency signal feeding into the distortion effect. Unit: Hz Range [80.0f .. 24000.0f] Default: 8000.0f + + + This property controls the frequency at which the post-distortion attenuation (Distortion Gain) is active. Unit: Hz Range [80.0f .. 24000.0f] Default: 3600.0f + + + This property controls the bandwidth of the post-distortion attenuation. Unit: Hz Range [80.0f .. 24000.0f] Default: 3600.0f + + + This property controls the delay between the original sound and the first "tap", or echo instance. Subsequently, the value for Echo Delay is used to determine the time delay between each "second tap" and the next "first tap". Unit: Seconds Range [0.0f .. 0.207f] Default: 0.1f + + + This property controls the delay between the "first tap" and the "second tap". Subsequently, the value for Echo LR Delay is used to determine the time delay between each "first tap" and the next "second tap". Unit: Seconds Range [0.0f .. 0.404f] Default: 0.1f + + + This property controls the amount of high frequency damping applied to each echo. As the sound is subsequently fed back for further echoes, damping results in an echo which progressively gets softer in tone as well as intensity. Range [0.0f .. 0.99f] Default: 0.5f + + + This property controls the amount of feedback the output signal fed back into the input. Use this parameter to create "cascading" echoes. At full magnitude, the identical sample will repeat endlessly. Below full magnitude, the sample will repeat and fade. Range [0.0f .. 1.0f] Default: 0.5f + + + This property controls how hard panned the individual echoes are. With a value of 1.0f, the first "tap" will be panned hard left, and the second "tap" hard right. –1.0f gives the opposite result and values near to 0.0f result in less emphasized panning. Range [-1.0f .. +1.0f] Default: -1.0f + + + The number of times per second the low-frequency oscillator controlling the amount of delay repeats. Range [0.0f .. 10.0f] Default: 0.27f + + + The ratio by which the delay time is modulated by the low-frequency oscillator. Range [0.0f .. 1.0f] Default: 1.0f + + + This is the amount of the output signal level fed back into the effect's input. A negative value will reverse the phase of the feedback signal. Range [-1.0f .. +1.0f] Default: -0.5f + + + The average amount of time the sample is delayed before it is played back. When used with the Feedback property it's the amount of time between iterations of the sample. Unit: Seconds Range [0.0f .. 0.004f] Default: 0.002f + + + This is the carrier frequency. For carrier frequencies below the audible range, the single sideband modulator may produce phaser effects, spatial effects or a slight pitch-shift. As the carrier frequency increases, the timbre of the sound is affected. Unit: Hz Range [0.0f .. 24000.0f] Default: 0.0f + + + This controls the frequency of the low-frequency oscillator used to morph between the two phoneme filters. Unit: Hz Range [0.0f .. 10.0f] Default: 1.41f + + + This is the frequency of the carrier signal. If the carrier signal is slowly varying (less than 20 Hz), the result is a slow amplitude variation effect (tremolo). Unit: Hz Range [0.0f .. 8000.0f] Default: 440.0f + + + This controls the cutoff frequency at which the input signal is high-pass filtered before being ring modulated. Unit: Hz Range [0.0f .. 24000.0f] Default: 800.0f + + + This property controls the time the filtering effect takes to sweep from minimum to maximum center frequency when it is triggered by input signal. Unit: Seconds Range [0.0001f .. 1.0f] Default: 0.06f + + + This property controls the time the filtering effect takes to sweep from maximum back to base center frequency, when the input signal ends. Unit: Seconds Range [0.0001f .. 1.0f] Default: 0.06f + + + This property controls the resonant peak, sometimes known as emphasis or Q, of the auto-wah band-pass filter. Range [2.0f .. 1000.0f] Default: 1000.0f + + + This property controls the input signal level at which the band-pass filter will be fully opened. Range [0.00003f .. 31621.0f] Default: 11.22f + + + This property controls amount of cut or boost on the low frequency range. Range [0.126f .. 7.943f] Default: 1.0f + + + This property controls the low frequency below which signal will be cut off. Unit: Hz Range [50.0f .. 800.0f] Default: 200.0f + + + This property allows you to cut/boost signal on the "mid1" range. Range [0.126f .. 7.943f] Default: 1.0f + + + This property sets the center frequency for the "mid1" range. Unit: Hz Range [200.0f .. 3000.0f] Default: 500.0f + + + This property controls the width of the "mid1" range. Range [0.01f .. 1.0f] Default: 1.0f + + + This property allows you to cut/boost signal on the "mid2" range. Range [0.126f .. 7.943f] Default: 1.0f + + + This property sets the center frequency for the "mid2" range. Unit: Hz Range [1000.0f .. 8000.0f] Default: 3000.0f + + + This property controls the width of the "mid2" range. Range [0.01f .. 1.0f] Default: 1.0f + + + This property allows to cut/boost the signal at high frequencies. Range [0.126f .. 7.943f] Default: 1.0f + + + This property controls the high frequency above which signal will be cut off. Unit: Hz Range [4000.0f .. 16000.0f] Default: 6000.0f + + + Reverb Modal Density controls the coloration of the late reverb. Range [0.0f .. 1.0f] Default: 1.0f + + + The Reverb Diffusion property controls the echo density in the reverberation decay. Range [0.0f .. 1.0f] Default: 1.0f + + + Reverb Gain controls the level of the reverberant sound in an environment. A high level of reverb is characteristic of rooms with highly reflective walls and/or small dimensions. Unit: Linear gain Range [0.0f .. 1.0f] Default: 0.32f + + + Gain HF is used to attenuate the high frequency content of all the reflected sound in an environment. You can use this property to give a room specific spectral characteristic. Unit: Linear gain Range [0.0f .. 1.0f] Default: 0.89f + + + Gain LF is the low frequency counterpart to Gain HF. Use this to reduce or boost the low frequency content in an environment. Unit: Linear gain Range [0.0f .. 1.0f] Default: 1.0f + + + The Decay Time property sets the reverberation decay time. It ranges from 0.1f (typically a small room with very dead surfaces) to 20.0f (typically a large room with very live surfaces). Unit: Seconds Range [0.1f .. 20.0f] Default: 1.49f + + + Decay HF Ratio scales the decay time of high frequencies relative to the value of the Decay Time property. By changing this value, you are changing the amount of time it takes for the high frequencies to decay compared to the mid frequencies of the reverb. Range [0.1f .. 2.0f] Default: 0.83f + + + Decay LF Ratio scales the decay time of low frequencies in the reverberation in the same manner that Decay HF Ratio handles high frequencies. Unit: Linear multiplier Range [0.1f .. 2.0f] Default: 1.0f + + + Reflections Gain sets the level of the early reflections in an environment. Early reflections are used as a cue for determining the size of the environment we are in. Unit: Linear gain Range [0.0f .. 3.16f] Default: 0.05f + + + Reflections Delay controls the amount of time it takes for the first reflected wave front to reach the listener, relative to the arrival of the direct-path sound. Unit: Seconds Range [0.0f .. 0.3f] Default: 0.007f + + + The Late Reverb Gain property controls the overall amount of later reverberation relative to the Gain property. Range [0.0f .. 10.0f] Default: 1.26f + + + The Late Reverb Delay property defines the begin time of the late reverberation relative to the time of the initial reflection (the first of the early reflections). It ranges from 0 to 100 milliseconds. Unit: Seconds Range [0.0f .. 0.1f] Default: 0.011f + + + Echo Time controls the rate at which the cyclic echo repeats itself along the reverberation decay. Range [0.075f .. 0.25f] Default: 0.25f + + + Echo Depth introduces a cyclic echo in the reverberation decay, which will be noticeable with transient or percussive sounds. Range [0.0f .. 1.0f] Default: 0.0f + + + Modulation Time controls the speed of the rate of periodic changes in pitch (vibrato). Range [0.04f .. 4.0f] Default: 0.25f + + + Modulation Depth controls the amount of pitch change. Low values of Diffusion will contribute to reinforcing the perceived effect by reducing the mixing of overlapping reflections in the reverberation decay. Range [0.0f .. 1.0f] Default: 0.0f + + + The Air Absorption Gain HF property controls the distance-dependent attenuation at high frequencies caused by the propagation medium. It applies to reflected sound only. Range [0.892f .. 1.0f] Default: 0.994f + + + The property HF reference determines the frequency at which the high-frequency effects created by Reverb properties are measured. Unit: Hz Range [1000.0f .. 20000.0f] Default: 5000.0f + + + The property LF reference determines the frequency at which the low-frequency effects created by Reverb properties are measured. Unit: Hz Range [20.0f .. 1000.0f] Default: 250.0f + + + The Room Rolloff Factor property is one of two methods available to attenuate the reflected sound (containing both reflections and reverberation) according to source-listener distance. It's defined the same way as OpenAL Rolloff Factor, but operates on reverb sound instead of direct-path sound. Range [0.0f .. 10.0f] Default: 0.0f + + + A list of valid Math.Vector3 Effect/GetEffect parameters + + + Reverb Pan does for the Reverb what Reflections Pan does for the Reflections. Unit: Vector3 of length 0f to 1f Default: {0.0f, 0.0f, 0.0f} + + + This Vector3 controls the spatial distribution of the cluster of early reflections. The direction of this vector controls the global direction of the reflections, while its magnitude controls how focused the reflections are towards this direction. For legacy reasons this Vector3 follows a left-handed co-ordinate system! Note that OpenAL uses a right-handed coordinate system. Unit: Vector3 of length 0f to 1f Default: {0.0f, 0.0f, 0.0f} + + + A list of valid Int32 Effect/GetEffect parameters + + + This property sets the waveform shape of the low-frequency oscillator that controls the delay time of the delayed signals. Unit: (0) Sinusoid, (1) Triangle Range [0 .. 1] Default: 1 + + + This property controls the phase difference between the left and right low-frequency oscillators. At zero degrees the two low-frequency oscillators are synchronized. Unit: Degrees Range [-180 .. 180] Default: 90 + + + Selects the shape of the low-frequency oscillator waveform that controls the amount of the delay of the sampled signal. Unit: (0) Sinusoid, (1) Triangle Range [0 .. 1] Default: 1 + + + This changes the phase difference between the left and right low-frequency oscillator's. At zero degrees the two low-frequency oscillators are synchronized. Range [-180 .. +180] Default: 0 + + + These select which internal signals are added together to produce the output. Unit: (0) Down, (1) Up, (2) Off Range [0 .. 2] Default: 0 + + + These select which internal signals are added together to produce the output. Unit: (0) Down, (1) Up, (2) Off Range [0 .. 2] Default: 0 + + + Sets the vocal morpher 4-band formant filter A, used to impose vocal tract effects upon the input signal. The vocal morpher is not necessarily intended for use on voice signals; it is primarily intended for pitched noise effects, vocal-like wind effects, etc. Unit: Use enum EfxFormantFilterSettings Range [0 .. 29] Default: 0, "Phoneme A" + + + This is used to adjust the pitch of phoneme filter A in 1-semitone increments. Unit: Semitones Range [-24 .. +24] Default: 0 + + + Sets the vocal morpher 4-band formant filter B, used to impose vocal tract effects upon the input signal. The vocal morpher is not necessarily intended for use on voice signals; it is primarily intended for pitched noise effects, vocal-like wind effects, etc. Unit: Use enum EfxFormantFilterSettings Range [0 .. 29] Default: 10, "Phoneme ER" + + + This is used to adjust the pitch of phoneme filter B in 1-semitone increments. Unit: Semitones Range [-24 .. +24] Default: 0 + + + This controls the shape of the low-frequency oscillator used to morph between the two phoneme filters. Unit: (0) Sinusoid, (1) Triangle, (2) Sawtooth Range [0 .. 2] Default: 0 + + + This sets the number of semitones by which the pitch is shifted. There are 12 semitones per octave. Unit: Semitones Range [-12 .. +12] Default: +12 + + + This sets the number of cents between Semitones a pitch is shifted. A Cent is 1/100th of a Semitone. Unit: Cents Range [-50 .. +50] Default: 0 + + + This controls which waveform is used as the carrier signal. Traditional ring modulator and tremolo effects generally use a sinusoidal carrier. Unit: (0) Sinusoid, (1) Sawtooth, (2) Square Range [0 .. 2] Default: 0 + + + Enabling this will result in audio exhibiting smaller variation in intensity between the loudest and quietest portions. Unit: (0) Off, (1) On Range [0 .. 1] Default: 1 + + + When this flag is set, the high-frequency decay time automatically stays below a limit value that's derived from the setting of the property Air Absorption HF. Unit: (0) False, (1) True Range [False, True] Default: True + + + When this flag is set, the high-frequency decay time automatically stays below a limit value that's derived from the setting of the property AirAbsorptionGainHF. Unit: (0) False, (1) True Range [False, True] Default: True + + + Used with the enum EfxEffectType as it's parameter. + + + Vocal morpher effect parameters. If both parameters are set to the same phoneme, that determines the filtering effect that will be heard. If these two parameters are set to different phonemes, the filtering effect will morph between the two settings at a rate specified by EfxEffectf.VocalMorpherRate. + + + Effect type definitions to be used with EfxEffecti.EffectType. + + + No Effect, disable. This Effect type is used when an Effect object is initially created. + + + The Reverb effect is the standard Effects Extension's environmental reverberation effect. It is available on all Generic Software and Generic Hardware devices. + + + The Chorus effect essentially replays the input audio accompanied by another slightly delayed version of the signal, creating a "doubling" effect. + + + The Distortion effect simulates turning up (overdriving) the gain stage on a guitar amplifier or adding a distortion pedal to an instrument's output. + + + The Echo effect generates discrete, delayed instances of the input signal. + + + The Flanger effect creates a "tearing" or "whooshing" sound, like a jet flying overhead. + + + The Frequency shifter is a single-sideband modulator, which translates all the component frequencies of the input signal by an equal amount. + + + The Vocal morpher consists of a pair of 4-band formant filters, used to impose vocal tract effects upon the input signal. + + + The Pitch shifter applies time-invariant pitch shifting to the input signal, over a one octave range and controllable at a semi-tone and cent resolution. + + + The Ring modulator multiplies an input signal by a carrier signal in the time domain, resulting in tremolo or inharmonic effects. + + + The Auto-wah effect emulates the sound of a wah-wah pedal used with an electric guitar, or a mute on a brass instrument. + + + The Compressor will boost quieter portions of the audio, while louder portions will stay the same or may even be reduced. + + + The Equalizer is very flexible, providing tonal control over four different adjustable frequency ranges. + + + The EAX Reverb has a more advanced parameter set than EfxEffectType.Reverb, but is only natively supported on devices that support the EAX 3.0 or above. + + + A list of valid Int32 AuxiliaryEffectSlot/GetAuxiliaryEffectSlot parameters + + + This property is used to attach an Effect object to the Auxiliary Effect Slot object. After the attachment, the Auxiliary Effect Slot object will contain the effect type and have the same effect parameters that were stored in the Effect object. Any Sources feeding the Auxiliary Effect Slot will immediate feed the new effect type and new effect parameters. + + + This property is used to enable or disable automatic send adjustments based on the physical positions of the sources and the listener. This property should be enabled when an application wishes to use a reverb effect to simulate the environment surrounding a listener or a collection of Sources. Range [False, True] Default: True + + + A list of valid 32-bits Float AuxiliaryEffectSlot/GetAuxiliaryEffectSlot parameters + + + This property is used to specify an output level for the Auxiliary Effect Slot. Setting the gain to 0.0f mutes the output. Range [0.0f .. 1.0f] Default: 1.0f + + + A list of valid 32-bits Float Filter/GetFilter parameters + + + Range [0.0f .. 1.0f] Default: 1.0f + + + Range [0.0f .. 1.0f] Default: 1.0f + + + Range [0.0f .. 1.0f] Default: 1.0f + + + Range [0.0f .. 1.0f] Default: 1.0f + + + Range [0.0f .. 1.0f] Default: 1.0f + + + Range [0.0f .. 1.0f] Default: 1.0f + + + Range [0.0f .. 1.0f] Default: 1.0f + + + A list of valid Int32 Filter/GetFilter parameters + + + Used with the enum EfxFilterType as Parameter to select a filter logic. + + + Filter type definitions to be used with EfxFilteri.FilterType. + + + No Filter, disable. This Filter type is used when a Filter object is initially created. + + + A low-pass filter is used to remove high frequency content from a signal. + + + Currently not implemented. A high-pass filter is used to remove low frequency content from a signal. + + + Currently not implemented. A band-pass filter is used to remove high and low frequency content from a signal. + + + 2-component Vector of the Half type. Occupies 4 Byte total. + + + The X component of the Half2. + + + The Y component of the Half2. + + + + The new Half2 instance will avoid conversion and copy directly from the Half parameters. + + An Half instance of a 16-bit half-precision floating-point number. + An Half instance of a 16-bit half-precision floating-point number. + + + + The new Half2 instance will convert the 2 parameters into 16-bit half-precision floating-point. + + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + + + + The new Half2 instance will convert the 2 parameters into 16-bit half-precision floating-point. + + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half2 instance will convert the Vector2 into 16-bit half-precision floating-point. + + OpenTK.Vector2 + + + + The new Half2 instance will convert the Vector2 into 16-bit half-precision floating-point. + + OpenTK.Vector2 + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half2 instance will convert the Vector2 into 16-bit half-precision floating-point. + This is the fastest constructor. + + OpenTK.Vector2 + + + + The new Half2 instance will convert the Vector2 into 16-bit half-precision floating-point. + + OpenTK.Vector2 + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half2 instance will convert the Vector2d into 16-bit half-precision floating-point. + + OpenTK.Vector2d + + + + The new Half2 instance will convert the Vector2d into 16-bit half-precision floating-point. + + OpenTK.Vector2d + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half2 instance will convert the Vector2d into 16-bit half-precision floating-point. + This is the faster constructor. + + OpenTK.Vector2d + + + + The new Half2 instance will convert the Vector2d into 16-bit half-precision floating-point. + + OpenTK.Vector2d + Enable checks that will throw if the conversion result is not meaningful. + + + + Returns this Half2 instance's contents as Vector2. + + OpenTK.Vector2 + + + + Returns this Half2 instance's contents as Vector2d. + + + + Converts OpenTK.Vector2 to OpenTK.Half2. + The Vector2 to convert. + The resulting Half vector. + + + Converts OpenTK.Vector2d to OpenTK.Half2. + The Vector2d to convert. + The resulting Half vector. + + + Converts OpenTK.Half2 to OpenTK.Vector2. + The Half2 to convert. + The resulting Vector2. + + + Converts OpenTK.Half2 to OpenTK.Vector2d. + The Half2 to convert. + The resulting Vector2d. + + + The size in bytes for an instance of the Half2 struct is 4. + + + Constructor used by ISerializable to deserialize the object. + + + + + Used by ISerialize to serialize the object. + + + + + Updates the X and Y components of this instance by reading from a Stream. + A BinaryReader instance associated with an open Stream. + + + Writes the X and Y components of this instance into a Stream. + A BinaryWriter instance associated with an open Stream. + + + Returns a value indicating whether this instance is equal to a specified OpenTK.Half2 vector. + OpenTK.Half2 to compare to this instance.. + True, if other is equal to this instance; false otherwise. + + + Returns a string that contains this Half2's numbers in human-legible form. + + + Returns the Half2 as an array of bytes. + The Half2 to convert. + The input as byte array. + + + Converts an array of bytes into Half2. + A Half2 in it's byte[] representation. + The starting position within value. + A new Half2 instance. + + + + Contains mathematical functions for the OpenTK.Math toolkit. + + + + + Returns the next power of two that is larger than the specified number. + + The specified number. + The next power of two. + + + + Returns the next power of two that is larger than the specified number. + + The specified number. + The next power of two. + + + + Returns the next power of two that is larger than the specified number. + + The specified number. + The next power of two. + + + + Returns the next power of two that is larger than the specified number. + + The specified number. + The next power of two. + + + Calculates the factorial of a given natural number. + + The number. + n! + + + + Calculates the binomial coefficient above . + + The n. + The k. + n! / (k! * (n - k)!) + + + + Returns an approximation of the inverse square root of left number. + + A number. + An approximation of the inverse square root of the specified number, with an upper error bound of 0.001 + + This is an improved implementation of the the method known as Carmack's inverse square root + which is found in the Quake III source code. This implementation comes from + http://www.codemaestro.com/reviews/review00000105.html. For the history of this method, see + http://www.beyond3d.com/content/articles/8/ + + + + + Returns an approximation of the inverse square root of left number. + + A number. + An approximation of the inverse square root of the specified number, with an upper error bound of 0.001 + + This is an improved implementation of the the method known as Carmack's inverse square root + which is found in the Quake III source code. This implementation comes from + http://www.codemaestro.com/reviews/review00000105.html. For the history of this method, see + http://www.beyond3d.com/content/articles/8/ + + + + + Convert degrees to radians + + An angle in degrees + The angle expressed in radians + + + + Convert radians to degrees + + An angle in radians + The angle expressed in degrees + + + + Represents a bezier curve with as many points as you want. + + + + + The parallel value. + + This value defines whether the curve should be calculated as a + parallel curve to the original bezier curve. A value of 0.0f represents + the original curve, 5.0f i.e. stands for a curve that has always a distance + of 5.0f to the orignal curve at any point. + + + + Constructs a new . + + The points. + + + + Constructs a new . + + The points. + + + + Constructs a new . + + The parallel value. + The points. + + + + Constructs a new . + + The parallel value. + The points. + + + + Calculates the point with the specified t. + + The t value, between 0.0f and 1.0f. + Resulting point. + + + + Calculates the length of this bezier curve. + + The precision. + Length of curve. + The precision gets better as the + value gets smaller. + + + + Calculates the length of the specified bezier curve. + + The points. + The precision value. + The precision gets better as the + value gets smaller. + + + + Calculates the length of the specified bezier curve. + + The points. + The precision value. + The parallel value. + Length of curve. + The precision gets better as the + value gets smaller. + The parameter defines whether the curve should be calculated as a + parallel curve to the original bezier curve. A value of 0.0f represents + the original curve, 5.0f represents a curve that has always a distance + of 5.0f to the orignal curve. + + + + Calculates the point on the given bezier curve with the specified t parameter. + + The points. + The t parameter, a value between 0.0f and 1.0f. + Resulting point. + + + + Calculates the point on the given bezier curve with the specified t parameter. + + The points. + The t parameter, a value between 0.0f and 1.0f. + The parallel value. + Resulting point. + The parameter defines whether the curve should be calculated as a + parallel curve to the original bezier curve. A value of 0.0f represents + the original curve, 5.0f represents a curve that has always a distance + of 5.0f to the orignal curve. + + + + Calculates the point with the specified t of the derivative of the given bezier function. + + The points. + The t parameter, value between 0.0f and 1.0f. + Resulting point. + + + + Gets the points of this curve. + + The first point and the last points represent the anchor points. + + + + Provides methods to perform layout and print hardware accelerated text. + + + + + Defines the interface for a TextPrinter. + + + + + Prints text using the specified color and layout options. + + The System.String to print. + The System.Drawing.Font that will be used to print text. + The System.Drawing.Color that will be used to print text. + + + + Prints text using the specified color and layout options. + + The System.String to print. + The System.Drawing.Font that will be used to print text. + The System.Drawing.Color that will be used to print text. + The System.Drawing.Rectangle that defines the bounds for text layout. + + + + Prints text using the specified color and layout options. + + The System.String to print. + The System.Drawing.Font that will be used to print text. + The System.Drawing.Color that will be used to print text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to print text. + + + + Prints text using the specified color and layout options. + + The System.String to print. + The System.Drawing.Font that will be used to print text. + The System.Drawing.Color that will be used to print text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to print text. + The OpenTK.Graphics.TextAlignment that will be used to print text. + + + + Prints text using the specified color and layout options. + + The System.String to print. + The System.Drawing.Font that will be used to print text. + The System.Drawing.Color that will be used to print text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to print text. + The OpenTK.Graphics.TextAlignment that will be used to print text. + The OpenTK.Graphics.TextDirection that will be used to print text. + + + + Measures text using the specified layout options. + + The System.String to measure. + The System.Drawing.Font that will be used to measure text. + An OpenTK.Graphics.TextExtents instance that contains the results of the measurement. + + + + Measures text using the specified layout options. + + The System.String to measure. + The System.Drawing.Font that will be used to measure text. + The System.Drawing.Rectangle that defines the bounds for text layout. + An OpenTK.Graphics.TextExtents instance that contains the results of the measurement. + + + + Measures text using the specified layout options. + + The System.String to measure. + The System.Drawing.Font that will be used to measure text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to measure text. + An OpenTK.Graphics.TextExtents instance that contains the results of the measurement. + + + + Measures text using the specified layout options. + + The System.String to measure. + The System.Drawing.Font that will be used to measure text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to measure text. + The OpenTK.Graphics.TextAlignment that will be used to measure text. + An OpenTK.Graphics.TextExtents instance that contains the results of the measurement. + + + + Measures text using the specified layout options. + + The System.String to measure. + The System.Drawing.Font that will be used to measure text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to measure text. + The OpenTK.Graphics.TextAlignment that will be used to measure text. + The OpenTK.Graphics.TextDirection that will be used to measure text. + An OpenTK.Graphics.TextExtents instance that contains the results of the measurement. + + + + Sets up a resolution-dependent orthographic projection. + + + + + Restores the projection and modelview matrices to their previous state. + + + + + Constructs a new TextPrinter instance. + + + + + Constructs a new TextPrinter instance with the specified TextQuality level. + + The desired TextQuality of this TextPrinter. + + + + Prints text using the specified color and layout options. + + The System.String to print. + The System.Drawing.Font that will be used to print text. + The System.Drawing.Color that will be used to print text. + + + + Prints text using the specified color and layout options. + + The System.String to print. + The System.Drawing.Font that will be used to print text. + The System.Drawing.Color that will be used to print text. + The System.Drawing.Rectangle that defines the bounds for text layout. + + + + Prints text using the specified color and layout options. + + The System.String to print. + The System.Drawing.Font that will be used to print text. + The System.Drawing.Color that will be used to print text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to print text. + + + + Prints text using the specified color and layout options. + + The System.String to print. + The System.Drawing.Font that will be used to print text. + The System.Drawing.Color that will be used to print text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to print text. + The OpenTK.Graphics.TextAlignment that will be used to print text. + + + + Prints text using the specified color and layout options. + + The System.String to print. + The System.Drawing.Font that will be used to print text. + The System.Drawing.Color that will be used to print text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to print text. + The OpenTK.Graphics.TextAlignment that will be used to print text. + The OpenTK.Graphics.TextDirection that will be used to print text. + + + + Measures text using the specified layout options. + + The System.String to measure. + The System.Drawing.Font that will be used to measure text. + An OpenTK.Graphics.TextExtents instance that contains the results of the measurement. + + + + Measures text using the specified layout options. + + The System.String to measure. + The System.Drawing.Font that will be used to measure text. + The System.Drawing.Rectangle that defines the bounds for text layout. + An OpenTK.Graphics.TextExtents instance that contains the results of the measurement. + + + + Measures text using the specified layout options. + + The System.String to measure. + The System.Drawing.Font that will be used to measure text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to measure text. + An OpenTK.Graphics.TextExtents instance that contains the results of the measurement. + + + + Measures text using the specified layout options. + + The System.String to measure. + The System.Drawing.Font that will be used to measure text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to measure text. + The OpenTK.Graphics.TextAlignment that will be used to measure text. + An OpenTK.Graphics.TextExtents instance that contains the results of the measurement. + + + + Measures text using the specified layout options. + + The System.String to measure. + The System.Drawing.Font that will be used to measure text. + The System.Drawing.Rectangle that defines the bounds for text layout. + The OpenTK.Graphics.TextPrinterOptions that will be used to measure text. + The OpenTK.Graphics.TextAlignment that will be used to measure text. + The OpenTK.Graphics.TextDirection that will be used to measure text. + An OpenTK.Graphics.TextExtents instance that contains the results of the measurement. + + + + Sets up a resolution-dependent orthographic projection. + + + + + Restores the projection and modelview matrices to their previous state. + + + + + Frees the resources consumed by this TextPrinter object. + + + + + Creates a System.Delegate that can be used to call a dynamically exported OpenAL function. + + The function string for the OpenAL function + The signature of the OpenAL function. + + A System.Delegate that can be used to call this OpenAL function or null + if the function is not available in the current OpenAL context. + + + + + 3-component Vector of the Half type. Occupies 6 Byte total. + + + + The X component of the Half3. + + + The Y component of the Half3. + + + The Z component of the Half3. + + + + The new Half3 instance will avoid conversion and copy directly from the Half parameters. + + An Half instance of a 16-bit half-precision floating-point number. + An Half instance of a 16-bit half-precision floating-point number. + An Half instance of a 16-bit half-precision floating-point number. + + + + The new Half3 instance will convert the 3 parameters into 16-bit half-precision floating-point. + + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + + + + The new Half3 instance will convert the 3 parameters into 16-bit half-precision floating-point. + + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half3 instance will convert the Vector3 into 16-bit half-precision floating-point. + + OpenTK.Vector3 + + + + The new Half3 instance will convert the Vector3 into 16-bit half-precision floating-point. + + OpenTK.Vector3 + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half3 instance will convert the Vector3 into 16-bit half-precision floating-point. + This is the fastest constructor. + + OpenTK.Vector3 + + + + The new Half3 instance will convert the Vector3 into 16-bit half-precision floating-point. + + OpenTK.Vector3 + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half3 instance will convert the Vector3d into 16-bit half-precision floating-point. + + OpenTK.Vector3d + + + + The new Half3 instance will convert the Vector3d into 16-bit half-precision floating-point. + + OpenTK.Vector3d + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half3 instance will convert the Vector3d into 16-bit half-precision floating-point. + This is the faster constructor. + + OpenTK.Vector3d + + + + The new Half3 instance will convert the Vector3d into 16-bit half-precision floating-point. + + OpenTK.Vector3d + Enable checks that will throw if the conversion result is not meaningful. + + + + Returns this Half3 instance's contents as Vector3. + + OpenTK.Vector3 + + + + Returns this Half3 instance's contents as Vector3d. + + + + Converts OpenTK.Vector3 to OpenTK.Half3. + The Vector3 to convert. + The resulting Half vector. + + + Converts OpenTK.Vector3d to OpenTK.Half3. + The Vector3d to convert. + The resulting Half vector. + + + Converts OpenTK.Half3 to OpenTK.Vector3. + The Half3 to convert. + The resulting Vector3. + + + Converts OpenTK.Half3 to OpenTK.Vector3d. + The Half3 to convert. + The resulting Vector3d. + + + The size in bytes for an instance of the Half3 struct is 6. + + + Constructor used by ISerializable to deserialize the object. + + + + + Used by ISerialize to serialize the object. + + + + + Updates the X,Y and Z components of this instance by reading from a Stream. + A BinaryReader instance associated with an open Stream. + + + Writes the X,Y and Z components of this instance into a Stream. + A BinaryWriter instance associated with an open Stream. + + + Returns a value indicating whether this instance is equal to a specified OpenTK.Half3 vector. + OpenTK.Half3 to compare to this instance.. + True, if other is equal to this instance; false otherwise. + + + Returns a string that contains this Half3's numbers in human-legible form. + + + Returns the Half3 as an array of bytes. + The Half3 to convert. + The input as byte array. + + + Converts an array of bytes into Half3. + A Half3 in it's byte[] representation. + The starting position within value. + A new Half3 instance. + + + + Gets or sets an OpenTK.Vector2h with the X and Y components of this instance. + + + + + Defines a common interface to all OpenGL resources. + + + + + Gets the GraphicsContext that owns this resource. + + + + + Gets the Id of this IGraphicsResource. + + + + + Defines available alignments for text. + + + + The text is aligned to the near side (left for left-to-right text and right for right-to-left text). + + + The text is aligned to the center. + + + The text is aligned to the far side (right for left-to-right text and left for right-to-left text). + + + Gets the width of the texture. + + + Gets the height of the texture. + + + + Discards all packed items. + + + + + Changes the dimensions of the TexturePacker surface. + + The new width of the TexturePacker surface. + The new height of the TexturePacker surface. + Changing the size of the TexturePacker surface will implicitly call TexturePacker.Clear(). + + + + Alut, FreeAlut = Free Audio Library Utilities + + + Alut.Init initializes the ALUT internals and creates an OpenAL context on the default device and makes it the current OpenAL context. If you want something more complex than that (e.g. running on a non-default device or opening multiple contexts on multiple devices), you can use alutInitWithoutContext instead. alutInit examines the commandline arguments passed to it and remove those it recognizes. It is acceptable to pass two NULL pointers in settings where no useful information can be obtained from argc and argv. + Application Main Parameters. Can be IntPtr.Zero. + Application Main Parameters. Can be IntPtr.Zero. + Success. + + + Parameterless function for convenience. Internally passes IntPtr.Zero as parameters. + Success. + + + Alut.InitWithoutContext initializes the ALUT internals. It does not create any OpenAL context or device, so this has to be done via the usual ALC calls. alutInitWithoutContext examines the commandline arguments passed to it and remove those it recognizes. It is acceptable to pass two NULL pointers in settings where no useful information can be obtained from argc and argv. + Application Main Parameters + Application Main Parameters + Success. + + + Alut.InitWithoutContext initializes the ALUT internals. It does not create any OpenAL context or device, so this has to be done via the usual ALC calls. alutInitWithoutContext examines the commandline arguments passed to it and remove those it recognizes. It is acceptable to pass two NULL pointers in settings where no useful information can be obtained from argc and argv. + Success. + + + When the application has finished playing audio, it should shut down ALUT using Alut.Exit. This closes any OpenAL device/context that ALUT may have created in alutInit (but not any that the application created using ALC). After calling alutExit, you may subsequently call alutInit or alutInitWithoutContext again. Note that under well-behaved operating systems, it should be acceptable to simply exit from your program without bothering to call alutExit, relying on the OS to clean up after you. However, it is dangerous to rely on this behavior if portable operation is expected. + Success. + + + Any ALUT routine that fails will return AL_FALSE / AL_NONE / NULL and set the global error state. If a subsequent error occurs while there is still an error recorded internally, the second error will simply be ignored. Calling alutGetError will reset the error code to ALUT_ERROR_NO_ERROR. Note that the error state is not cleared by other successful ALUT calls. Alut.GetError can be called in any ALUT state and will never fail. + + + + Alut.GetErrorString can be used to convert an error code into a human-readable description. The precise text of these descriptions may vary from implementation to implementation and should not be relied upon by the application. + Retrieve first occured error with Alut.GetError + A human-readable description of the Error. + + + Alut.CreateBufferFromFile tries to guess the sound buffer format by looking at the filename and/or the file contents and loads the sound buffer into an OpenAL buffer. + The file to be loaded + OpenAL Buffer, 0 on failure. + + + Alut.CreateBufferFromFileImage tries to guess the sound buffer format by looking at the contents of the memory region given as parameters and loads the sound buffer into an OpenAL buffer. + A Pointer to the sound buffer in memory. + Size in Bytes of the sound buffer. + OpenAL Buffer, 0 on failure. + + + Alut.CreateBufferHelloWorld returns a handle to an OpenAL buffer containing the sound of someone saying 'Hello, world!'. + OpenAL Buffer, 0 on failure. + + + Alut.CreateBufferWaveform returns a handle to an OpenAL buffer containing a snippet of audio with the specified waveshape at the specified frequency (in hertz), phase (in degrees: -180 to +180) and duration (in seconds). + + Frequency in hertz [Hz]. + Phase (in degrees: -180 to +180) + Duration (in seconds) + OpenAL Buffer, 0 on failure. + + + Alut.GetMIMETypes returns a comma-separated list of supported MIME types for the given loader type, e.g. something like "audio/basic,audio/mpeg,audio/x-wav". + It is possible that AlutLoader.Memory loaders will be unable to support some file types that AlutLoader.Buffer loaders can support (although the reverse is never the case). Furthermore, it is possible that for some file types (notably audio/x-wav) the support may be only for a few sub-formats. For example, an implementation may advertise that audio/x-wav is supported when in fact it only supports uncompressed (i.e. PCM) WAV files and not any of the compressed subformats. In this event, the various ALUT loaders may return an error and set ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE rather than ALUT_ERROR_UNSUPPORTED_FILE_TYPE which would indicate that no files of this type are allowed. + + + A comma-separated list of supported MIME types. + + + Alut.GetMajorVersion returns the major version number of the ALUT in use, which will match the major version number of the corresponding ALUT specification document. Can be compared using AlutVersions. + Major Version Number. + + + Alut.GetMinorVersion returns the minor version number of the ALUT in use, which will match the minor version number of the corresponding ALUT specification document. Can be compared using AlutVersions. + Minor Version Number. + + + + GLU (OpenGL Utility) binding for .NET, implementing GLU 1.3. + + + + Binds functions and definitions in glu32.dll or libGLU.so. + + + The OpenGL Utility (GLU) library contains several groups of functions that + complement the core OpenGL interface by providing support for auxiliary features. + These features include: mipmapping, matrix manipulation, polygon tessellation, + quadrics, NURBS, and error handling. + + + Mipmapping routines include image scaling and automatic mipmap generation. A + variety of matrix manipulation functions build projection and viewing matrices, + or project vertices from one coordinate system to another. Polygon tessellation + routines convert concave polygons into triangles for easy rendering. Quadrics + support renders a few basic quadrics such as spheres and cones. NURBS code maps + complicated NURBS curves and trimmed surfaces into simpler OpenGL evaluators. + Lastly, an error lookup routine translates OpenGL and GLU error codes into + strings. GLU library routines may call OpenGL library routines. Thus, an OpenGL + context should be made current before calling any GLU functions. Otherwise an + OpenGL error may occur. + + + These utility functions make use of core OpenGL functions, so any OpenGL + implementation is guaranteed to support the utility functions. + + + + + + Specifies the calling convention. + + + Specifies for Windows and + Linux, to indicate that the default should be used. + + + + + GLU API revision. + + + Specifies GLU 1.1. + + + + + GLU API revision. + + + Specifies GLU 1.2. + + + + + GLU API revision. + + + Specifies GLU 1.3. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Unknown. Unable to locate definitive documentation on this constant. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Called from . + + + This method is not CLS-compliant due to naming conventions. + + + + + Delimits a Non-Uniform Rational B-Spline (NURBS) curve definition. + + + The NURBS object (created with ). + + + + Use gluBeginCurve to mark the beginning of a NURBS curve definition. + After calling gluBeginCurve, make one or more calls to + to define the attributes of the curve. Exactly + one of the calls to must have a curve type of + or . To + mark the end of the NURBS curve definition, call . + + + OpenGL evaluators are used to render the NURBS curve as a series of line + segments. Evaluator state is preserved during rendering with + Gl.glPushAttrib(Gl.GL_EVAL_BIT) and Gl.glPopAttrib. For + information on exactly what state these calls preserve, see + . + + + EXAMPLE + + + The following commands render a textured NURBS curve with normals; texture + coordinates and normals are also specified as NURBS curves: + + + + Glu.gluBeginCurve(nobj); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_TEXTURE_COORD_2); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_NORMAL); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_VERTEX_4); + Glu.gluEndCurve(nobj); + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + + gluBeginPolygon delimits the definition of a nonconvex polygon. To + define such a polygon, first call gluBeginPolygon. Then define the + contours of the polygon by calling for each + vertex and to start each new contour. Finally, + call to signal the end of the definition. See + the and reference + pages for more details. + + + Once is called, the polygon is tessellated, and + the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + NOTES + + + This command is obsolete and is provided for backward compatibility only. + Calls to gluBeginPolygon are mapped to + followed by + . Calls to + are mapped to followed by + . + + + EXAMPLE + + + A quadrilateral with a triangular hole in it can be described like this: + + + + Glu.gluBeginPolygon(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluNextContour(tobj, Glu.GLU_INTERIOR); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluEndPolygon(tobj); + + + + + + + + + + + + + Delimits a NURBS surface definition. + + + The NURBS object (created with ). + + + + Use gluBeginSurface to mark the beginning of a NURBS surface + definition. After calling gluBeginSurface, make one or more calls to + to define the attributes of the surface. + Exactly one of these calls to must have a + surface type of or + . To mark the end of the NURBS surface + definition, call . + + + Trimming of NURBS surfaces is supported with , + , , and + . See the reference + page for details. + + + OpenGL evaluators are used to render the NURBS surface as a set of polygons. + Evaluator state is preserved during rendering with + Gl.glPushAttrib(Gl.GL_EVAL_BIT) and Gl.glPopAttrib(). See the + reference page for details on exactly what + state these calls preserve. + + + EXAMPLE + + + The following commands render a textured NURBS surface with normals; the + texture coordinates and normals are also described as NURBS surfaces: + + + + Glu.gluBeginSurface(nobj); + Glu.gluNurbsSurface(nobj, ..., Gl.GL_MAP2_TEXTURE_COORD_2); + Glu.gluNurbsSurface(nobj, ..., Gl.GL_MAP2_NORMAL); + Glu.gluNurbsSurface(nobj, ..., Gl.GL_MAP2_VERTEX_4); + Glu.gluEndSurface(nobj); + + + + + + + + + + + + + Delimits a NURBS trimming loop definition. + + + The NURBS object (created with ). + + + + Use gluBeginTrim to mark the beginning of a trimming loop, and + to mark the end of a trimming loop. A trimming + loop is a set of oriented curve segments (forming a closed curve) that define + boundaries of a NURBS surface. You include these trimming loops in the + definition of a NURBS surface, between calls to + and . + + + The definition for a NURBS surface can contain many trimming loops. For + example, if you wrote a definition for a NURBS surface that resembled a + rectangle with a hole punched out, the definition would contain two trimming + loops. One loop would define the outer edge of the rectangle; the other + would define the hole punched out of the rectangle. The definitions of each + of these trimming loops would be bracketed by a gluBeginTrim and + pair. + + + The definition of a single closed trimming loop can consist of multiple curve + segments, each described as a piecewise linear curve (see + ) or as a single NURBS curve (see + ), or as a combination of both in any order. The + only library calls that can appear in a trimming loop definition (between the + calls to gluBeginTrim and ) are + and . + + + The area of the NURBS surface that is displayed is the region in the domain + to the left of the trimming curve as the curve parameter increases. Thus, + the retained region of the NURBS surface is inside a counterclockwise + trimming loop and outside a clockwise trimming loop. For the rectangle + mentioned earlier, the trimming loop for the outer edge of the rectangle runs + counterclockwise, while the trimming loop for the punched-out hole runs + clockwise. + + + If you use more than one curve to define a single trimming loop, the curve + segments must form a closed loop (that is, the endpoint of each curve must be + the starting point of the next curve, and the endpoint of the final curve + must be the starting point of the first curve). If the endpoints of the + curve are sufficiently close together but not exactly coincident, they will + be coerced to match. If the endpoints are not sufficiently close, an error + results (see ). + + + If a trimming loop definition contains multiple curves, the direction of the + curves must be consistent (that is, the inside must be to the left of all of + the curves). Nested trimming loops are legal as long as the curve + orientations alternate correctly. If trimming curves are self-intersecting, + or intersect one another, an error results. + + + If no trimming information is given for a NURBS surface, the entire surface + is drawn. + + + EXAMPLE + + + This code fragment defines a trimming loop that consists of one piecewise + linear curve, and two NURBS curves: + + + + Glu.gluBeginTrim(nobj); + Glu.gluPwlCurve(..., Glu.GLU_MAP1_TRIM_2); + Glu.gluNurbsCurve(..., Glu.GLU_MAP1_TRIM_2); + Glu.gluNurbsCurve(..., Glu.GLU_MAP1_TRIM_3); + Glu.gluEndTrim(nobj); + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of one-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + or 4 or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + or . + + + Specifies the width in pixels of the texture image. This should be a power of 2. + + + Specifies the format of the pixel data. Must be one of: + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmapLevels builds a subset of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half until size 1Χ1 is reached. At each level, each texel + in the halved mipmap level is an average of the corresponding two texels in + the larger mipmap level. is called to load + these mipmap levels from min to max. If max is larger + than the highest mipmap level for the texture of the specified size, then a + GLU error code is returned (see ) and nothing is + loaded. + + + For example, if level is 2 and width is 16, the following + levels are possible: 16Χ1, 8Χ1, 4Χ1, 2Χ1, 1Χ1. These correspond to levels 2 + through 6 respectively. If min is 3 and max is 5, then only + mipmap levels 8Χ1, 4Χ1 and 2Χ1 are loaded. However, if max is 7 then + an error is returned and nothing is loaded since max is larger than + the highest mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2((width)*(2^level)). + + + See the reference page for a description of + the acceptable values for type parameter. See the + reference page for a description of the + acceptable values for level parameter. + + + NOTES + + + gluBuild1DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width is < 1. + + + is returned if internalFormat, + format, or type are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a one-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , or + . + + + Specifies the width, in pixels, of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild1DMipmaps builds a series of prefiltered one-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width of data is checked to see if it is a power + of 2. If not, a copy of data is scaled up or down to the nearest + power of 2. (If width is exactly between powers of 2, then the copy + of data will scale upwards.) This copy will be used for subsequent + mipmapping operations described below. For example, if width is 57 + then a copy of data will scale up to 64 before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, width + is continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half until size 1Χ1 is reached. At each level, each texel in the halved + mipmap level is an average of the corresponding two texels in the larger + mipmap level. + + + glTexImage1D is called to load each of these mipmap levels. Level 0 + is a copy of data. The highest level is log2(width). For + example, if width is 64 and the implementation can store a texture of + this size, the following mipmap levels are built: 64Χ1, 32Χ1, 16Χ1, 8Χ1, 4Χ1, + 2Χ1 and 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for the type parameter. See the + reference page for a description of the + acceptable values for the data parameter. + + + NOTES + + + Note that there is no direct way of querying the maximum level. This can be + derived indirectly via . First, + query for the width actually used at level 0. (The width may not be equal to + width since proxy textures might have scaled it to fit the + implementation.) Then the maximum level can be derived from the formula + log2(width). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater, and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width is < 1. + + + is returned if format or type + are not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of two-dimensional mipmap levels. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies the width, in pixels, of the texture image. Should be a power of 2. + + + Specifies the height, in pixels, of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmapLevels builds a subset of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding four texels in the larger mipmap level. (In the case of + rectangular images, the decimation will ultimately reach an NΧ1 or 1ΧN + configuration. Here, two texels are averaged instead.) + is called to load these mipmap levels from + min to max. If max is larger than the highest mipmap + level for the texture of the specified size, then a GLU error code is + returned (see ) and nothing is loaded. + + + For example, if level is 2 and width is 16 and height is + 8, the following levels are possible: 16Χ8, 8Χ4, 4Χ2, 2Χ1, 1Χ1. These + correspond to levels 2 through 6 respectively. If min is 3 and + max is 5, then only mipmap levels 8Χ4, 4Χ2 and 2Χ1 are loaded. + However, if max is 7 then an error is returned and nothing is loaded + since max is larger than the highest mipmap level which is, in this + case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild2DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a two-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or + . + + + Specifies, in pixels, the width of the texture image. + + + Specifies, in pixels, the height of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild2DMipmaps builds a series of prefiltered two-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for + the antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width and height of data are checked to + see if they are a power of 2. If not, a copy of data (not data + itself), is scaled up or down to the nearest power of 2. This copy will be + used for subsequent mipmapping operations described below. (If width + or height is exactly between powers of 2, then the copy of data + will scale upwards.) For example, if width is 57 and height is + 23 then a copy of data will scale up to 64 in width and down to + 16 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, both + dimensions are continually halved until it fits. (If the OpenGL version is + <= 1.0, both maximum texture dimensions are clamped to the value returned + by with the argument + .) + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along both dimensions until size 1Χ1 is reached. At each level, each + texel in the halved mipmap level is an average of the corresponding four + texels in the larger mipmap level. (In the case of rectangular images, the + decimation will ultimately reach an NΧ1 or 1ΧN configuration. Here, two + texels are averaged instead.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height)). For example, if width is 64 and + height is 16 and the implementation can store a texture of this size, + the following mipmap levels are built: 64Χ16, 32Χ8, 16Χ4, 8Χ2, 4Χ1, 2Χ1 and + 1Χ1. These correspond to levels 0 through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width and height actually used at level 0. (The width and height may not + be equal to width and height respectively since proxy textures + might have scaled them to fit the implementation.) Then the maximum level + can be derived from the formula log2(max(width,height)). + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater and if the GLU version is 1.3 or greater. + + + ERRORS + + + is returned if width or height + is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a subset of three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width of the texture image. Should be a power of 2. + + + Specifies, in pixels, the height of the texture image. Should be a power of 2. + + + Specifies, in pixels, the depth of the texture image. Should be a power of 2. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies the mipmap level of the image data. + + + Specifies the minimum mipmap level to pass to . + + + Specifies the maximum mipmap level to pass to . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmapLevels builds a subset of prefiltered + three-dimensional texture maps of decreasing resolutions called a mipmap. + This is used for the antialiasing of texture mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + A series of mipmap levels from min to max is built by + decimating data in half along both dimensions until size 1Χ1Χ1 is + reached. At each level, each texel in the halved mipmap level is an average + of the corresponding eight texels in the larger mipmap level. (If exactly + one of the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + is called to load these mipmap levels from min to max. If + max is larger than the highest mipmap level for the texture of the + specified size, then a GLU error code is returned (see + ) and nothing is loaded. + + + For example, if level is 2 and width is 16, height is 8 + and depth is 4, the following levels are possible: 16Χ8Χ4, 8Χ4Χ2, + 4Χ2Χ1, 2Χ1Χ1, 1Χ1Χ1. These correspond to levels 2 through 6 respectively. + If min is 3 and max is 5, then only mipmap levels 8Χ4Χ2, + 4Χ2Χ1 and 2Χ1Χ1 are loaded. However, if max is 7 then an error is + returned and nothing is loaded since max is larger than the highest + mipmap level which is, in this case, 6. + + + The highest mipmap level can be derived from the formula + log2(max(width,height,depth)*(2^level)). + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + gluBuild3DMipmapLevels is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if level > min, + min < 0, max < min or max is > the + highest mipmap level for data. + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Builds a three-dimensional mipmap. + + + Specifies the target texture. Must be . + + + Requests the internal storage format of the texture image. Must be 1, 2, 3, + 4, or one of the following symbolic constants: , + , , + , , + , , + , , + , , + , + , + , + , + , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , , + , or . + + + Specifies, in pixels, the width in pixels of the texture image. + + + Specifies, in pixels, the height in pixels of the texture image. + + + Specifies, in pixels, the depth in pixels of the texture image. + + + Specifies the format of the pixel data. Must be one of + , , + , , + , , + , , + , , + , or . + + + Specifies the data type for data. Must be one of: + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + Specifies a pointer to the image data in memory. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluBuild3DMipmaps builds a series of prefiltered three-dimensional + texture maps of decreasing resolutions called a mipmap. This is used for the + antialiasing of texture-mapped primitives. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + Initially, the width, height and depth of data + are checked to see if they are a power of two. If not, a copy of data + (not data itself), is scaled up or down to the nearest power of two. + This copy will be used for subsequent mipmapping operations described below. + (If width, height or depth is exactly between powers of + 2, then the copy of data will scale upwards.) For example, if + width is 57, height is 23 and depth is 24 then a copy of + data will scale up to 64 in width, down to 16 in height + and up to 32 in depth, before mipmapping takes place. + + + Then, proxy textures (see ) are used to + determine if the implementation can fit the requested texture. If not, all + three dimensions are continually halved until it fits. + + + Next, a series of mipmap levels is built by decimating a copy of data + in half along all three dimensions until size 1Χ1Χ1 is reached. At each + level, each texel in the halved mipmap level is an average of the + corresponding eight texels in the larger mipmap level. (If exactly one of + the dimensions is 1, four texels are averaged. If exactly two of the + dimensions are 1, two texels are averaged.) + + + is called to load each of these mipmap levels. + Level 0 is a copy of data. The highest level is + log2(max(width,height,depth)). For example, if width is 64, + height is 16 and depth is 32, and the implementation can store + a texture of this size, the following mipmap levels are built: 64Χ16Χ32, + 32Χ8Χ16, 16Χ4Χ8, 8Χ2Χ4, 4Χ1Χ2, 2Χ1Χ1 and 1Χ1Χ1. These correspond to levels 0 + through 6, respectively. + + + See the reference page for a description of + the acceptable values for format parameter. See the + reference page for a description of the + acceptable values for type parameter. + + + NOTES + + + There is no direct way of querying the maximum level. This can be derived + indirectly via . First, query for + the width, height and depth actually used at level 0. (The width, height + and depth may not be equal to width, height and depth + respectively since proxy textures might have scaled them to fit the + implementation.) Then the maximum level can be derived from the formula + log2(max(width,height,depth)). + + + gluBuild3DMipmaps is only available if the GLU version is 1.3 or + greater. + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if width, height, + or depth is < 1. + + + is returned if internalFormat, + format, or type is not legal. + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is not + . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + is returned if type is + or + and format is neither + nor . + + + + + + + + + + + + + + + + + + Determines if an extension name is supported. + + + Specifies an extension name. + + + Specifies a space-separated list of extension names supported. + + + Returns if extensionName is supported + otherwise is returned. + + + + gluCheckExtension is used to check for the presence for OpenGL, GLU or + GLX extension names by passing the extension strings returned by + , , + /*see cref="glXGetClientString" />*/, /*see cref="glXQueryExtensionsString" />*/, + or /*see cref="glXQueryServerString" />*/, respectively, as + extensionString. + + + Returns if extensionName is supported + otherwise is returned. + + + NOTES + + + Cases where one extension name is a substring of another are correctly + handled. + + + There may or may not be leading or trailing blanks in extensionString. + + + Extension names should not contain embedded spaces. + + + All strings are null-terminated. + + + + + /*seealso cref="glXGetClientString" />*/ + /*seealso cref="glXQueryExtensionsString" />*/ + /*seealso cref="glXQueryServerString" />*/ + + + + Draws a cylinder. + + + Specifies the quadrics object (created with ). + + + Specifies the radius of the cylinder at z = 0. + + + Specifies the radius of the cylinder at z = height. If top is + set to 0, this subroutine generates a cone. + + + Specifies the height of the cylinder. + + + Specifies the number of subdivisions around the z axis. + + + Specifies the number of subdivisions along the z axis. + + + + gluCylinder draws a cylinder oriented along the z axis. The base of + the cylinder is placed at z = 0, and the top at z = height. Like a sphere, + a cylinder is subdivided around the z axis into slices, and along the z axis + into stacks. + + + Note that if top is set to 0.0, this routine generates a cone. + + + If the orientation is set to (with + ), then any generated normals point away + from the z axis. Otherwise, they point toward the z axis. + + + If texturing is turned on using the + subroutine, texture coordinates are generated so that t ranges linearly from + 0.0 at z = 0 to 1.0 at z = height, and s ranges from 0.0 at the +y axis to + 0.25 at the +x axis, as well as up to 0.5 at the -y axis and 0.75 at the + -x axis, then back to 1.0 at the +y axis. + + + + + + + + + + + + Destroys a NURBS object. + + + The NURBS object to be destroyed (created with + ). + + + gluDeleteNurbsRenderer destroys the NURBS object (which was created with + ) and frees any memory it uses. Once + gluDeleteNurbsRenderer has been called, nurb cannot be used again. + + + + + + Destroys a quadrics object. + + + The quadric object to be destroyed (created with + ). + + + gluDeleteQuadric destroys the quadrics object (created with + ) and frees any memory it uses. Once + gluDeleteQuadric has been called, quad cannot be used again. + + + + + + Destroys a tessellation object. + + + The tessellation object to destroy (created with ). + + + gluDeleteTess destroys the indicated tessellation object (which was + created with ) and frees any memory that it used. + Once gluDeleteTess has been called, tess cannot be used again. + + + + + + + + Draws a disk. + + + The quadric object (created with ). + + + The inner radius of the disk (may be zero). + + + The outer radius of the disk. + + + The number of subdivisions around the z-axis. + + + The number of concentric rings about the origin into which the disk is subdivided. + + + + gluDisk renders a disk on the z = 0 plane. The disk has a radius of + outerRadius, and contains a concentric circular hole with a radius of + innerRadius. If innerRadius is 0, then no hole is generated. + The disk is subdivided around the z axis into slices (like pizza slices), + and also about the z axis into rings (as specified by slices and + loops, respectively). + + + With respect to orientation, the +z side of the disk is considered to be + "outside" (see ). This means that if the + orientation is set to , then any normals generated + point along the +z axis. Otherwise, they point along the -z axis. + + + If texturing has been turned on (with ), + texture coordinates are generated linearly such that where r = outerRadius, + the value at (r, 0, 0) is (1, 0.5), at (0, r, 0) it is (0.5, 1), at + (-r, 0, 0) it is (0, 0.5), and at (0, -r, 0) it is (0.5, 0). + + + + + + + + + + + + Delimits a Non-Uniform Rational B-Spline (NURBS) curve definition. + + + The NURBS object (created with ). + + + + Use to mark the beginning of a NURBS curve + definition. After calling , make one or more + calls to to define the attributes of the curve. + Exactly one of the calls to must have a curve + type of or + . To mark the end of the NURBS curve + definition, call gluEndCurve. + + + OpenGL evaluators are used to render the NURBS curve as a series of line + segments. Evaluator state is preserved during rendering with + Gl.glPushAttrib(Gl.GL_EVAL_BIT) and Gl.glPopAttrib. For + information on exactly what state these calls preserve, see + . + + + EXAMPLE + + + The following commands render a textured NURBS curve with normals; texture + coordinates and normals are also specified as NURBS curves: + + + + Glu.gluBeginCurve(nobj); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_TEXTURE_COORD_2); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_NORMAL); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_VERTEX_4); + Glu.gluEndCurve(nobj); + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + + delimits the definition of a nonconvex + polygon. To define such a polygon, first call + . Then define the contours of the polygon by + calling for each vertex and + to start each new contour. Finally, call + gluEndPolygon to signal the end of the definition. See the + and reference + pages for more details. + + + Once gluEndPolygon is called, the polygon is tessellated, and the + resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + NOTES + + + This command is obsolete and is provided for backward compatibility only. + Calls to are mapped to + followed by + . Calls to gluEndPolygon are mapped + to followed by + . + + + EXAMPLE + + + A quadrilateral with a triangular hole in it can be described like this: + + + + Glu.gluBeginPolygon(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluNextContour(tobj, Glu.GLU_INTERIOR); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluEndPolygon(tobj); + + + + + + + + + + + + + Delimits a NURBS surface definition. + + + The NURBS object (created with ). + + + + Use to mark the beginning of a NURBS surface + definition. After calling , make one or more + calls to to define the attributes of the + surface. Exactly one of these calls to must + have a surface type of or + . To mark the end of the NURBS surface + definition, call gluEndSurface. + + + Trimming of NURBS surfaces is supported with , + , , and + . See the reference + page for details. + + + OpenGL evaluators are used to render the NURBS surface as a set of polygons. + Evaluator state is preserved during rendering with + Gl.glPushAttrib(Gl.GL_EVAL_BIT) and Gl.glPopAttrib(). See the + reference page for details on exactly what + state these calls preserve. + + + EXAMPLE + + + The following commands render a textured NURBS surface with normals; the + texture coordinates and normals are also described as NURBS surfaces: + + + + Glu.gluBeginSurface(nobj); + Glu.gluNurbsSurface(nobj, ..., Gl.GL_MAP2_TEXTURE_COORD_2); + Glu.gluNurbsSurface(nobj, ..., Gl.GL_MAP2_NORMAL); + Glu.gluNurbsSurface(nobj, ..., Gl.GL_MAP2_VERTEX_4); + Glu.gluEndSurface(nobj); + + + + + + + + + + + + + Delimits a NURBS trimming loop definition. + + + The NURBS object (created with ). + + + + Use to mark the beginning of a trimming loop, and + gluEndTrim to mark the end of a trimming loop. A trimming loop is a + set of oriented curve segments (forming a closed curve) that define + boundaries of a NURBS surface. You include these trimming loops in the + definition of a NURBS surface, between calls to + and . + + + The definition for a NURBS surface can contain many trimming loops. For + example, if you wrote a definition for a NURBS surface that resembled a + rectangle with a hole punched out, the definition would contain two trimming + loops. One loop would define the outer edge of the rectangle; the other + would define the hole punched out of the rectangle. The definitions of each + of these trimming loops would be bracketed by a + and gluEndTrim pair. + + + The definition of a single closed trimming loop can consist of multiple curve + segments, each described as a piecewise linear curve (see + ) or as a single NURBS curve (see + ), or as a combination of both in any order. The + only library calls that can appear in a trimming loop definition (between the + calls to and gluEndTrim are + and . + + + The area of the NURBS surface that is displayed is the region in the domain + to the left of the trimming curve as the curve parameter increases. Thus, + the retained region of the NURBS surface is inside a counterclockwise + trimming loop and outside a clockwise trimming loop. For the rectangle + mentioned earlier, the trimming loop for the outer edge of the rectangle runs + counterclockwise, while the trimming loop for the punched-out hole runs + clockwise. + + + If you use more than one curve to define a single trimming loop, the curve + segments must form a closed loop (that is, the endpoint of each curve must be + the starting point of the next curve, and the endpoint of the final curve + must be the starting point of the first curve). If the endpoints of the + curve are sufficiently close together but not exactly coincident, they will + be coerced to match. If the endpoints are not sufficiently close, an error + results (see ). + + + If a trimming loop definition contains multiple curves, the direction of the + curves must be consistent (that is, the inside must be to the left of all of + the curves). Nested trimming loops are legal as long as the curve + orientations alternate correctly. If trimming curves are self-intersecting, + or intersect one another, an error results. + + + If no trimming information is given for a NURBS surface, the entire surface + is drawn. + + + EXAMPLE + + + This code fragment defines a trimming loop that consists of one piecewise + linear curve, and two NURBS curves: + + + + Glu.gluBeginTrim(nobj); + Glu.gluPwlCurve(..., Glu.GLU_MAP1_TRIM_2); + Glu.gluNurbsCurve(..., Glu.GLU_MAP1_TRIM_2); + Glu.gluNurbsCurve(..., Glu.GLU_MAP1_TRIM_3); + Glu.gluEndTrim(nobj); + + + + + + + + + + + + + Produces an error string from a GL or GLU error code. + + + An OpenGL or GLU error code. + + + A string representation of the error. + + + + gluErrorString produces an error string from a GL or GLU error code. + The string is in ISO Latin 1 format. For example, + gluErrorString(Gl.GL_OUT_OF_MEMORY) returns the string 'out of + memory'. + + + The standard GLU error codes are , + , and . + Certain other GLU functions can return specialized error codes through + callbacks. See the reference page for the list + of GL error codes. + + + ERRORS + + + NULL is returned if errorCode is not a valid GL or GLU error + code. + + + + + + + + + + Produces an error string from a GL or GLU error code. + + + An OpenGL or GLU error code. + + + A string representation of the error. + + + + gluErrorStringWIN produces an error string from a GL or GLU error + code. The string is in UNICODE format. For example, + gluErrorStringWIN(Gl.GL_OUT_OF_MEMORY) returns the string 'out of + memory'. + + + The standard GLU error codes are , + , and . + Certain other GLU functions can return specialized error codes through + callbacks. See the reference page for the list + of GL error codes. + + + ERRORS + + + NULL is returned if errorCode is not a valid GL or GLU error + code. + + + + + + + + + + Produces an error string from a GL or GLU error code. + + + An OpenGL or GLU error code. + + + A Unicode string representation of the error. + + + + gluErrorString produces an error string from a GL or GLU error code. + The string is in UNICODE format. For example, + gluErrorString(Gl.GL_OUT_OF_MEMORY) returns the string 'out of + memory'. + + + The standard GLU error codes are , + , and . + Certain other GLU functions can return specialized error codes through + callbacks. See the reference page for the list + of GL error codes. + + + ERRORS + + + NULL is returned if errorCode is not a valid GL or GLU error + code. + + + + + + + + + + Gets a NURBS property. + + + The NURBS object (created with ). + + + The property whose value is to be retrieved. The following values are valid: + , , + , , + , + , , and + . + + + A pointer to the location into which the value of the named property is + written. + + + gluGetNurbsProperty retrieves properties stored in a NURBS object. + These properties affect the way that NURBS curves and surfaces are rendered. + See the reference page for information about + what the properties are and what they do. + + + + + + + Gets a NURBS property. + + + The NURBS object (created with ). + + + The property whose value is to be retrieved. The following values are valid: + , , + , , + , + , , and + . + + + A pointer to the location into which the value of the named property is + written. + + + gluGetNurbsProperty retrieves properties stored in a NURBS object. + These properties affect the way that NURBS curves and surfaces are rendered. + See the reference page for information about + what the properties are and what they do. + + + + + + + Gets a NURBS property. + + + The NURBS object (created with ). + + + The property whose value is to be retrieved. The following values are valid: + , , + , , + , + , , and + . + + + A pointer to the location into which the value of the named property is + written. + + + gluGetNurbsProperty retrieves properties stored in a NURBS object. + These properties affect the way that NURBS curves and surfaces are rendered. + See the reference page for information about + what the properties are and what they do. + + + + + + + Gets a string that describes the GLU version number or supported GLU extension + calls. + + + Either the version number of GLU () or available + vendor-specific extension calls (). + + + Returns a string describing the GLU version or the GLU extensions that are + supported. + + + + gluGetString returns a string describing the GLU version or the GLU + extensions that are supported. When name is + , the returned string is a value that represents + the version number of GLU. The format of the version number is as follows: + + + <version number><space><vendor-specific information> + (for example, "1.2.11 Microsoft Windows NT") + + + The version number has the form "major_number.minor_number" or + "major_number.minor_number.release_number". The vendor-specific information + is optional, and the format and contents depend on the implementation. + + + When name is , the returned string + contains a list of names of supported GLU extensions that are separated by + spaces. The format of the returned list of names is as follows: + + + <extension_name><space><extension_name><space> . . . + (for example, "GLU_NURBS GL_TESSELATION") + + + The extension names cannot contain any spaces. + + + NOTES + + + The gluGetString function is valid for GLU version 1.1 or later. + + + All strings are NULL-terminated. + + + gluGetString only returns information about GLU extensions. Call + to get a list of GL extensions. + + + gluGetString is an initialization routine. Calling it after a + results in undefined behavior. + + + ERRORS + + + NULL is returned if name is not or + . + + + + + + + Gets a tessellation object property. + + + The tessellation object (created with ). + + + The property whose value is to be retrieved. The following values are valid: + , , + and . + + + A pointer to the location where the value of the named property is written. + + + gluGetTessProperty retrieves properties stored in a tessellation + object. These properties affect the way that tessellation objects are + interpreted and rendered. See the reference + page for information about the properties and what they do. + + + + + + + Gets a tessellation object property. + + + The tessellation object (created with ). + + + The property whose value is to be retrieved. The following values are valid: + , , + and . + + + A pointer to the location where the value of the named property is written. + + + gluGetTessProperty retrieves properties stored in a tessellation + object. These properties affect the way that tessellation objects are + interpreted and rendered. See the reference + page for information about the properties and what they do. + + + + + + + Gets a tessellation object property. + + + The tessellation object (created with ). + + + The property whose value is to be retrieved. The following values are valid: + , , + and . + + + A pointer to the location where the value of the named property is written. + + + gluGetTessProperty retrieves properties stored in a tessellation + object. These properties affect the way that tessellation objects are + interpreted and rendered. See the reference + page for information about the properties and what they do. + + + + + + + Loads NURBS sampling and culling matrices. + + + The NURBS object (created with ). + + + A modelview matrix (as from a call). + + + A projection matrix (as from a call). + + + A viewport (as from a call). + + + + gluLoadSamplingMatrices uses modelMatrix, + projectionMatrix, and viewport to recompute the sampling and + culling matrices stored in nurb. The sampling matrix determines how + finely a NURBS curve or surface must be tessellated to satisfy the sampling + tolerance (as determined by the + property). The culling matrix is used in deciding if a NURBS curve or + surface should be culled before rendering (when the + property is turned on). + + + gluLoadSamplingMatrices is necessary only if the + property is turned off (see + ). Although it can be convenient to leave the + property turned on, there can be a + performance penalty for doing so. (A round trip to the GL server is needed + to fetch the current values of the modelview matrix, projection matrix, and + viewport.) + + + + + + + + + + + Defines a viewing transformation. + + + The x axis position of the eye point. + + + The y axis position of the eye point. + + + The z axis position of the eye point. + + + The x axis position of the reference point. + + + The y axis position of the reference point. + + + The z axis position of the reference point. + + + The x axis direction of the up vector. + + + The y axis direction of the up vector. + + + The z axis direction of the up vector. + + + + gluLookAt creates a viewing matrix derived from an eye point, a + reference point indicating the center of the scene, and an UP vector. + + + The matrix maps the reference point to the negative z axis and the eye point + to the origin. When a typical projection matrix is used, the center of the + scene therefore maps to the center of the viewport. Similarly, the direction + described by the UP vector projected onto the viewing plane is mapped to the + positive y axis so that it points upward in the viewport. The UP vector must + not be parallel to the line of sight from the eye point to the reference + point. + + + The matrix generated by gluLookAt postmultiplies the current matrix. + + + The matrix M generated by the OpenGL could be computed as follows: + + + Let E be the 3d column vector (eyeX, eyeY, eyeZ). + Let C be the 3d column vector (centerX, centerY, centerZ). + Let U be the 3d column vector (upX, upY, upZ). + Compute L = C - E. + Normalize L. + Compute S = L x U. + Normalize S. + Compute U' = S x L. + + + M is the matrix whose columns are, in order: + + + (S, 0), (U', 0), (-L, 0), (-E, 1) (all column vectors) + + + Note: This matrix is defined for use in systems where the the modelling + coordinate vector is a column vector and is multiplied on the left by the + matrices. If you prefer a row vector which gets multiplied by matrices to + its right, then use the transpose of this matrix M. + + + Note: It is necessary that the UP vector NOT be parallel to the line + connecting the center point with the eye point. + + + + + + + + Creates a NURBS object. + + + Returns a pointer to a new NURBS object. + + + gluNewNurbsRenderer creates and returns a pointer to a new NURBS + object. This object must be referred to when calling NURBS rendering and + control functions. A return value of 0 means that there is not enough memory + to allocate the object. + + + + + + + + + + + Creates a quadrics object. + + + Returns a pointer to a new quadrics object. + + + gluNewQuadric creates and returns a pointer to a new quadrics object. + This object must be referred to when calling quadrics rendering and control + functions. A return value of 0 means that there is not enough memory to + allocate the object. + + + + + + + + + + + + + + + Creates a tessellation object. + + + Returns a pointer to a new tessellation object. + + + gluNewTess creates and returns a pointer to a new tessellation object. + This object must be referred to when calling tessellation functions. A + return value of 0 means that there is not enough memory to allocate the + object. + + + + + + + + Marks the beginning of another contour. + + + The tessellation object (created with ). + + + + The type of the contour being defined. The following values are valid: + + + + + Value + Description + + + + + An exterior contour defines an exterior boundary of the polygon. + + + + + + An interior contour defines an interior boundary of the polygon + (such as a hole). + + + + + + An unknown contour is analyzed by the library to determine + whether it is interior or exterior. + + + + , + + + The first or + contour defined is considered to be exterior. All other + contours are considered to be exterior if they are oriented + in the same direction (clockwise or counterclockwise) as the + first contour, and interior if they are not. + + + If one contour is of type or + , then all contours must be of the same + type (if they are not, then all and + contours will be changed to + ). Note that there is no real + difference between the and + contour types. + + + + + + + + + gluNextContour is used in describing polygons with multiple contours. + After the first contour has been described through a series of + calls, a gluNextContour call indicates + that the previous contour is complete and that the next contour is about to + begin. Another series of calls is then used to + describe the new contour. This process can be repeated until all contours + have been described. + + + Before the first contour is described, gluNextContour can be called to + define the type of the first contour. If gluNextContour is not called + before the first contour, then the first contour is marked + . + + + This command is obsolete and is provided for backward compatibility only. + Calls to gluNextContour are mapped to + followed by . + + + EXAMPLE + + + You can describe a quadrilateral with a triangular hole in it as follows: + + + + Glu.gluBeginPolygon(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluEndPolygon(tess); + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + The gluNurbsCallback mehtod defines a callback for a NURBS object. + + + The NURBS object (created with ). + + + + The callback being defined. The legal callbacks are as follows: + + + + + Value + Description + + + + + The begin callback indicates the start of a primitive. The + function takes a single argument of type , + which can be one of , + , + , + , + , or + . The default begin callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The color callback is invoked as the color of a vertex is + generated. The components of the color are stored in the + parameter colorData. This callback is effective only when + the user provides a color map ( + or ). colorData + contains four components: R,G,B,A. The default color callback + function is null. The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The end callback is invoked at the end of a primitive. The + default end callback function is null. The delegate + prototype for this callback is . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The error function is called when an error is encountered. Its + single argument is of type , and it indicates + the specific error that occurred. There are 37 errors unique to + NURBS named through + . Character strings describing + these errors can be retrieved with . + The delegate prototype for this callback is + . + + + + + + The normal callback is invoked as the vertex normal is generated. + The components of the normal are stored in the parameter + normalData. In the case of a NURBS curve, the callback + function is effective only when the user provides a normal map + (). In the case of a NURBS + surface, if a normal map () is + provided, then the generated normal is computed from the normal + map. If a normal map is not provided then a surface normal is + computed in a manner similar to that described for evaluators + when is enabled. The default + normal callback function is null. The delegate + prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is a + copy of the pointer that was specified at the last call to + . The default callback + function is null. The delegate prototype for this + callback is . + + + + + + The texture callback is invoked as the texture coordinates of a + vertex are generated. These coordinates are stored in the + parameter texCoord. The number of texture coordinates can + be 1, 2, 3, or 4 depending on which type of texture map is + specified (, + , + , + , + , + , + , + ). If no texture map is + specified, this callback function will not be called. The + default texture callback function is null. The delegate + prototype for this callback is + . + + + + + + This is the same as the + callback, except that it takes an additional pointer argument. + This pointer is a copy of the pointer that was specified at the + last call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + The vertex callback indicates a vertex of the primitive. The + coordinates of the vertex are stored in the parameter + vertexData. All the generated vertices have dimension 3, + that is, homogeneous coordinates have been transformed into + affine coordinates. The default vertex callback function is + null. The delegate prototype for this callback is + . + + + + + + This is the same as the callback, + except that it takes an additional pointer argument. This + pointer is a copy of the pointer that was specified at the last + call to . The default + callback function is null. The delegate prototype for + this callback is . + + + + + + + The function that the callback invokes. + + + + gluNurbsCallback is used to define a callback to be used by a NURBS + object. If the specified callback is already defined, then it is replaced. + If func is null, then this callback will not get invoked and + the related data, if any, will be lost. + + + Except the error callback, these callbacks are used by NURBS tessellator + (when is set to be + ) to return back the OpenGL polygon + primitives resulting from the tessellation. Note that there are two + versions of each callback: one with a user data pointer and one without. If + both versions for a particular callback are specified then the callback with + the user data pointer will be used. Note that userData is a copy of + the pointer that was specified at the last call to + . + + + The error callback function is effective no matter which value that + is set to. All other callback functions are + effective only when is set to + . + + + NOTES + + + gluNurbsCallback is available only if the GLU version is 1.2 or + greater. + + + GLU version 1.2 supports only the parameter for + which. The value is deprecated in GLU + version 1.3 in favor of . All other + accepted values for func are available only if the GLU version is 1.3 + or greater. + + + + + + + + + + + + + + + + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + + gluNurbsCallbackData is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + NOTES + + + gluNurbsCallbackData is available only if the GLU version is 1.3 or + greater. + + + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Sets a user data pointer. + + + The NURBS object (created with ). + + + A pointer to the user's data. + + + gluNurbsCallbackDataEXT is used to pass a pointer to the application's + data to NURBS tessellator. A copy of this pointer will be passed by the + tessellator in the NURBS callback functions (set by + ). + + + + + + Defines the shape of a NURBS curve. + + + The NURBS object (created with ). + + + The number of knots in knot. The knotCount parameter equals + the number of control points plus the order. + + + An array of knotCount nondecreasing knot values. + + + The offset (as a number of single-precision floating-point values) between + successive curve control points. + + + A pointer to an array of control points. The coordinates must agree with + type. + + + The order of the NURBS curve. The order parameter equals degree + 1; + hence a cubic curve has an order of 4. + + + The type of the curve. If this curve is defined within a + / pair, then the type + can be any of the valid one-dimensional evaluator types (such as + or ). + Between a / pair, the + only valid types are and + . + + + + Use gluNurbsCurve to describe a NURBS curve. + + + When gluNurbsCurve appears between a + / pair, it is used to + describe a curve to be rendered. Positional, texture, and color coordinates + are associated by presenting each as a separate gluNurbsCurve between + a / pair. No more than + one call to gluNurbsCurve for each of color, position, and texture + data can be made within a single + / pair. Exactly one + call must be made to describe the position of the curve (a type of + or ). + + + When gluNurbsCurve appears between a + / pair, it is used to + describe a trimming curve on a NURBS surface. If type is + , then it describes a curve in two-dimensional + (u and v) parameter space. If it is , then it + describes a curve in two-dimensional homogeneous (u, v, and w) parameter + space. See the reference page for more + discussion about trimming curves. + + + NOTES + + + To define trim curves which stitch well, use . + + + EXAMPLE + + + The following commands render a textured NURBS curve with normals: + + + + Glu.gluBeginCurve(nobj); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_TEXTURE_COORD_2); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_NORMAL); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_VERTEX_4); + Glu.gluEndCurve(nobj); + + + + + + + + + + + + + Defines the shape of a NURBS curve. + + + The NURBS object (created with ). + + + The number of knots in knot. The knotCount parameter equals + the number of control points plus the order. + + + An array of knotCount nondecreasing knot values. + + + The offset (as a number of single-precision floating-point values) between + successive curve control points. + + + A pointer to an array of control points. The coordinates must agree with + type. + + + The order of the NURBS curve. The order parameter equals degree + 1; + hence a cubic curve has an order of 4. + + + The type of the curve. If this curve is defined within a + / pair, then the type + can be any of the valid one-dimensional evaluator types (such as + or ). + Between a / pair, the + only valid types are and + . + + + + Use gluNurbsCurve to describe a NURBS curve. + + + When gluNurbsCurve appears between a + / pair, it is used to + describe a curve to be rendered. Positional, texture, and color coordinates + are associated by presenting each as a separate gluNurbsCurve between + a / pair. No more than + one call to gluNurbsCurve for each of color, position, and texture + data can be made within a single + / pair. Exactly one + call must be made to describe the position of the curve (a type of + or ). + + + When gluNurbsCurve appears between a + / pair, it is used to + describe a trimming curve on a NURBS surface. If type is + , then it describes a curve in two-dimensional + (u and v) parameter space. If it is , then it + describes a curve in two-dimensional homogeneous (u, v, and w) parameter + space. See the reference page for more + discussion about trimming curves. + + + NOTES + + + To define trim curves which stitch well, use . + + + EXAMPLE + + + The following commands render a textured NURBS curve with normals: + + + + Glu.gluBeginCurve(nobj); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_TEXTURE_COORD_2); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_NORMAL); + Glu.gluNurbsCurve(nobj, ..., Gl.GL_MAP1_VERTEX_4); + Glu.gluEndCurve(nobj); + + + + + + + + + + + + + Sets a NURBS property. + + + The NURBS object (created with ). + + + The property to be set. Valid values are + , , + , , + , , + , , or + . + + + The value of the indicated property. It may be a numeric value, or one of + , , + , , + , , + , , + , or . + + + + gluNurbsProperty is used to control properties stored in a NURBS + object. These properties affect the way that a NURBS curve is rendered. The + accepted values for property are as follows: + + + + + Value + Description + + + + + val should be set to be either + or + . When set to + , NURBS objects are tessellated + into OpenGL primitives and sent to the pipeline for rendering. + When set to , NURBS objects + are tessellated into OpenGL primitives but the vertices, normals, + colors, and/or textures are retrieved back through a callback + interface (see ). This allows the + user to cache the tessellated results for further processing. + The initial value is . + + + + + + + Specifies how a NURBS surface should be tessellated. + val may be one of , + , + , + , or + . When set to + , the surface is rendered so + that the maximum length, in pixels, of the edges of the + tessellation polygons is no greater than what is specified by + . + + + specifies that the + surface is rendered in such a way that the value specified by + describes the maximum + distance, in pixels, between the tessellation polygons and + the surfaces they approximate. + + + allows users to specify, + in parametric coordinates, how many sample points per unit + length are taken in u, v direction. + + + is similar to + except that it is view + independent, that is, the surface is rendered so that the + maximum length, in object space, of edges of the tessellation + polygons is no greater than what is specified by + . + + + is similar to + except that it is view + independent, that is, the surface is rendered in such a way + that the value specified by + describes the maximum + distance, in object space, between the tessellation polygons + and the surfaces they approximate. + + + The initial value of is + . + + + + + + + Specifies the maximum length, in pixels or in object space length + unit, to use when the sampling method is set to + or + . The NURBS code is + conservative when rendering a curve or surface, so the actual + length can be somewhat shorter. The initial value is 50.0 + pixels. + + + + + + Specifies the maximum distance, in pixels or in object space + length unit, to use when the sampling method is + or + . The initial value is + 0.5. + + + + + + Specifies the number of sample points per unit length taken along + the u axis in parametric coordinates. It is needed when + is set to + . The initial value is 100. + + + + + + Specifies the number of sample points per unit length taken along + the v axis in parametric coordinate. It is needed when + is set to + . The initial value is 100. + + + + + + + val can be set to , + , or . + When is set to be + , val defines how a + NURBS surface should be rendered. When val is set to + , the surface is rendered as a set of + polygons. When val is set to + , the NURBS library draws + only the outlines of the polygons created by tessellation. + When val is set to + just the outlines of patches + and trim curves defined by the user are drawn. + + + When is set to be + , val defines how + a NURBS surface should be tessellated. When + is set to + or + , the NURBS surface is + tessellated into OpenGL triangle primitives which can be + retrieved back through callback functions. If + is set to + , only the outlines of the + patches and trim curves are generated as a sequence of + line strips which can be retrieved back through callback + functions. + + + The initial value is . + + + + + + + val is a boolean value that, when set to + , indicates that a NURBS curve should be + discarded prior to tessellation if its control points lie outside + the current viewport. The initial value is + . + + + + + + + val is a boolean value. When set to + , the NURBS code downloads the + projection matrix, the modelview matrix, and the viewport + from the GL server to compute sampling and culling matrices + for each NURBS curve that is rendered. Sampling and culling + matrices are required to determine the tessellation of a + NURBS surface into line segments or polygons and to cull a + NURBS surface if it lies outside the viewport. + + + If this mode is set to , then the + program needs to provide a projection matrix, a modelview + matrix, and a viewport for the NURBS renderer to use to + construct sampling and culling matrices. This can be done + with the function. + This mode is initially set to . + Changing it from to + does not affect the sampling and + culling matrices until + is called. + + + + + + + NOTES + + + If is true, sampling and culling may be + executed incorrectly if NURBS routines are compiled into a display list. + + + A property of , + , , or + , or a val of , + , are + only available if the GLU version is 1.1 or greater. They are not valid + parameters in GLU 1.0. + + + can be used to determine the GLU version. + + + is only availble if the GLU version is 1.3 or + greater. + + + The and + values for the + property are only available if the GLU + version is 1.3 or greater. + + + + + + + + + + + Defines the shape of a NURBS surface. + + + The NURBS object (created with ). + + + The number of knots in the parametric u direction. + + + An array of sKnotCount nondecreasing knot values in the parametric + u direction + + + The number of knots in the parametric v direction. + + + An array of tKnotCount nondecreasing knot values in the parametric + v direction. + + + The offset (as a number of single-precision floating-point values) between + successive control points in the parametric u direction in control. + + + The offset (in single-precision floating-point values) between successive + control points in the parametric v direction in control. + + + An array containing control points for the NURBS surface. The offsets + between successive control points in the parametric u and v directions are + given by sStride and tStride. + + + The order of the NURBS surface in the parametric u direction. The order is + one more than the degree, hence a surface that is cubic in u has a u order of + 4. + + + The order of the NURBS surface in the parametric v direction. The order is + one more than the degree, hence a surface that is cubic in v has a v order of + 4. + + + The type of the surface. The type parameter can be any of the valid + two-dimensional evaluator types (such as + or ). + + + + Use gluNurbsSurface within a NURBS (Non-Uniform Rational B-Spline) + surface definition to describe the shape of a NURBS surface (before any + trimming). To mark the beginning of a NURBS surface definition, use the + command. To mark the end of a NURBS surface + definition, use the command. Call + gluNurbsSurface within a NURBS surface definition only. + + + Positional, texture, and color coordinates are associated with a surface by + presenting each as a separate gluNurbsSurface between a + / pair. No more + than one call to gluNurbsSurface for each of color, position, and + texture data can be made within a single + / pair. Exactly + one call must be made to describe the position of the surface (a type of + or ). + + + A NURBS surface can be trimmed by using the commands + and between calls to + and . + + + Note that a gluNurbsSurface with sKnotCount knots in the u + direction and tKnotCount knots in the v direction with orders + sOrder and tOrder must have (sKnotCount - sOrder) + multiplied by (tKnotCount - tOrder) control points. + + + EXAMPLE + + + + Glu.gluBeginSurface(nobj); + Glu.gluNurbsSurface(nobj, . . ., Gl.GL_MAP2_TEXTURE_COORD_2); + Glu.gluNurbsSurface(nobj, . . ., Gl.GL_MAP2_NORMAL); + Glu.gluNurbsSurface(nobj, . . ., Gl.GL_MAP2_VERTEX_4); + Glu.gluEndSurface(nobj); + + + + + + + + + + + + + + Defines the shape of a NURBS surface. + + + The NURBS object (created with ). + + + The number of knots in the parametric u direction. + + + An array of sKnotCount nondecreasing knot values in the parametric + u direction + + + The number of knots in the parametric v direction. + + + An array of tKnotCount nondecreasing knot values in the parametric + v direction. + + + The offset (as a number of single-precision floating-point values) between + successive control points in the parametric u direction in control. + + + The offset (in single-precision floating-point values) between successive + control points in the parametric v direction in control. + + + An array containing control points for the NURBS surface. The offsets + between successive control points in the parametric u and v directions are + given by sStride and tStride. + + + The order of the NURBS surface in the parametric u direction. The order is + one more than the degree, hence a surface that is cubic in u has a u order of + 4. + + + The order of the NURBS surface in the parametric v direction. The order is + one more than the degree, hence a surface that is cubic in v has a v order of + 4. + + + The type of the surface. The type parameter can be any of the valid + two-dimensional evaluator types (such as + or ). + + + + Use gluNurbsSurface within a NURBS (Non-Uniform Rational B-Spline) + surface definition to describe the shape of a NURBS surface (before any + trimming). To mark the beginning of a NURBS surface definition, use the + command. To mark the end of a NURBS surface + definition, use the command. Call + gluNurbsSurface within a NURBS surface definition only. + + + Positional, texture, and color coordinates are associated with a surface by + presenting each as a separate gluNurbsSurface between a + / pair. No more + than one call to gluNurbsSurface for each of color, position, and + texture data can be made within a single + / pair. Exactly + one call must be made to describe the position of the surface (a type of + or ). + + + A NURBS surface can be trimmed by using the commands + and between calls to + and . + + + Note that a gluNurbsSurface with sKnotCount knots in the u + direction and tKnotCount knots in the v direction with orders + sOrder and tOrder must have (sKnotCount - sOrder) + multiplied by (tKnotCount - tOrder) control points. + + + EXAMPLE + + + + Glu.gluBeginSurface(nobj); + Glu.gluNurbsSurface(nobj, . . ., Gl.GL_MAP2_TEXTURE_COORD_2); + Glu.gluNurbsSurface(nobj, . . ., Gl.GL_MAP2_NORMAL); + Glu.gluNurbsSurface(nobj, . . ., Gl.GL_MAP2_VERTEX_4); + Glu.gluEndSurface(nobj); + + + + + + + + + + + + + + Defines the shape of a NURBS surface. + + + The NURBS object (created with ). + + + The number of knots in the parametric u direction. + + + An array of sKnotCount nondecreasing knot values in the parametric + u direction + + + The number of knots in the parametric v direction. + + + An array of tKnotCount nondecreasing knot values in the parametric + v direction. + + + The offset (as a number of single-precision floating-point values) between + successive control points in the parametric u direction in control. + + + The offset (in single-precision floating-point values) between successive + control points in the parametric v direction in control. + + + An array containing control points for the NURBS surface. The offsets + between successive control points in the parametric u and v directions are + given by sStride and tStride. + + + The order of the NURBS surface in the parametric u direction. The order is + one more than the degree, hence a surface that is cubic in u has a u order of + 4. + + + The order of the NURBS surface in the parametric v direction. The order is + one more than the degree, hence a surface that is cubic in v has a v order of + 4. + + + The type of the surface. The type parameter can be any of the valid + two-dimensional evaluator types (such as + or ). + + + + Use gluNurbsSurface within a NURBS (Non-Uniform Rational B-Spline) + surface definition to describe the shape of a NURBS surface (before any + trimming). To mark the beginning of a NURBS surface definition, use the + command. To mark the end of a NURBS surface + definition, use the command. Call + gluNurbsSurface within a NURBS surface definition only. + + + Positional, texture, and color coordinates are associated with a surface by + presenting each as a separate gluNurbsSurface between a + / pair. No more + than one call to gluNurbsSurface for each of color, position, and + texture data can be made within a single + / pair. Exactly + one call must be made to describe the position of the surface (a type of + or ). + + + A NURBS surface can be trimmed by using the commands + and between calls to + and . + + + Note that a gluNurbsSurface with sKnotCount knots in the u + direction and tKnotCount knots in the v direction with orders + sOrder and tOrder must have (sKnotCount - sOrder) + multiplied by (tKnotCount - tOrder) control points. + + + EXAMPLE + + + + Glu.gluBeginSurface(nobj); + Glu.gluNurbsSurface(nobj, . . ., Gl.GL_MAP2_TEXTURE_COORD_2); + Glu.gluNurbsSurface(nobj, . . ., Gl.GL_MAP2_NORMAL); + Glu.gluNurbsSurface(nobj, . . ., Gl.GL_MAP2_VERTEX_4); + Glu.gluEndSurface(nobj); + + + + + + + + + + + + + + Defines a 2D orthographic projection matrix. + + + The coordinates for the leftvertical clipping planes. + + + The coordinates for the right vertical clipping planes. + + + The coordinates for the bottom horizontal clipping planes. + + + The coordinates for the top horizontal clipping planes. + + + The gluOrtho2D function sets up a two-dimensional orthographic viewing + region. This is equivalent to calling with + near = –1 and far = 1. + + + + + + + Draws an arc of a disk. + + + A quadric object (created with ). + + + The inner radius of the partial disk (can be zero). + + + The outer radius of the partial disk. + + + The number of subdivisions around the z-axis. + + + The number of concentric rings about the origin into which the partial disk + is subdivided. + + + The starting angle, in degrees, of the disk portion. + + + The sweep angle, in degrees, of the disk portion. + + + + gluPartialDisk renders a partial disk on the z = 0 plane. A partial + disk is similar to a full disk, except that only the subset of the disk from + startAngle through startAngle + sweepAngle is included + (where 0 degrees is along the +y axis, 90 degrees along the +x axis, 180 + degrees along the -y axis, and 270 degrees along the -x axis). + + + The partial disk has a radius of outerRadius, and contains a + concentric circular hole with a radius of innerRadius. If + innerRadius is 0, then no hole is generated. The partial disk is + subdivided around the z axis into slices (like pizza slices), and also about + the z axis into rings (as specified by slices and loops, + respectively). + + + With respect to orientation, the +z side of the partial disk is considered + to be outside (see ). This means that if + the orientation is set to , then any normals + generated point along the +z axis. Otherwise, they point along the -z axis. + + + If texturing is turned on (with ), texture + coordinates are generated linearly such that where r = outerRadius, + the value at (r, 0, 0) is (1.0, 0.5), at (0, r, 0) it is (0.5, 1.0), at + (-r, 0, 0) it is (0.0, 0.5), and at (0, -r, 0) it is (0.5, 0.0). + + + + + + + + + + + + Sets up a perspective projection matrix. + + + The field of view angle, in degrees, in the y-direction. + + + The aspect ratio that determines the field of view in the x-direction. The + aspect ratio is the ratio of x (width) to y (height). + + + The distance from the viewer to the near clipping plane (always positive). + + + The distance from the viewer to the far clipping plane (always positive). + + + + The gluPerspective subroutine specifies a viewing frustum into the + world coordinate system. Generally, the aspect ratio used with this + subroutine should match that of its associated viewport. For example, an + aspect ratio value of aspect = 2.0 means the viewer's angle of view is twice + as wide in x as it is in y. If the viewport is twice as wide as it is tall, + it displays the image without distortion. + + + The matrix generated by gluPerspective is multipled by the current + matrix, just as if Gl.glMultMatrix* were called with the generated matrix. + To load the perspective matrix onto the current matrix stack instead, + precede the call to gluPerspective with a call to + . + + + Given f defined as follows: + + + f = cotangent(fovY / 2) + + + The generated matrix is: + + + + ( f ) + | ------ 0 0 0 | + | aspectRatio | + | | + | | + | 0 f 0 0 | + | | + | | + | zFar+zNear 2*zFar*zNear | + | 0 0 ---------- ------------ | + | zNear-zFar zNear-zFar | + | | + | | + | 0 0 -1 0 | + ( ) + + + + NOTES + + + Depth buffer precision is affected by the values specified for zNear + and zFar. The greater the ratio of zFar to zNear is, + the less effective the depth buffer will be at distinguishing between + surfaces that are near each other. If r = zFar / zNear roughly + log2(r) bits of depth buffer precision are lost. Because r approaches + infinity as zNear approaches 0, zNear must never be set to 0. + + + + + + + + + Defines a picking region. + + + The center of a picking region in x axis window coordinates. + + + The center of a picking region in y axis window coordinates. + + + The width of the picking region in window coordinates. + + + The height of the picking region in window coordinates. + + + The current viewport (as from a call). + + + + gluPickMatrix creates a projection matrix that can be used to restrict + drawing to a small region of the viewport. This is typically useful to + determine what objects are being drawn near the cursor. Use + gluPickMatrix to restrict drawing to a small region around the cursor. + Then, enter selection mode (with ) and rerender + the scene. All primitives that would have been drawn near the cursor are + identified and stored in the selection buffer. + + + The matrix created by gluPickMatrix is multiplied by the current + matrix just as if Gl.glMultMatrix* is called with the generated matrix. + To effectively use the generated pick matrix for picking, first call + to load an identity matrix onto the + perspective matrix stack. Then call gluPickMatrix, and finally, call + a command (such as ) to multiply the perspective + matrix by the pick matrix. + + + When using gluPickMatrix to pick NURBS, be careful to turn off the + NURBS property . If + is not turned off, then any NURBS + surface rendered is subdivided differently with the pick matrix than the way + it was subdivided without the pick matrix. + + + EXAMPLE + + + When rendering a scene as follows: + + + + Gl.glMatrixMode(Gl.GL_PROJECTION); + Gl.glLoadIdentity(); + Glu.gluPerspective(. . .); + Gl.glMatrixMode(Gl.GL_MODELVIEW); + // Draw the scene + + + + The following code selects a portion of the viewport: + + + + Gl.glMatrixMode(Gl.GL_PROJECTION); + Gl.glLoadIdentity(); + Glu.gluPickMatrix(x, y, width, height, viewport); + Glu.gluPerspective(. . .); + Gl.glMatrixMode(Gl.GL_MODELVIEW); + // Draw the scene + + + + + + + + + + Maps object coordinates to window coordinates. + + + The object's x axis coordinate. + + + The object's y axis coordinate. + + + The object's z axis coordinate. + + + The current modelview matrix (as from a call). + + + The current projection matrix (as from a + call). + + + The current viewport (as from a call). + + + The computed window's x axis coordinate. + + + The computed window's y axis coordinate. + + + The computed window's z axis coordinate. + + + Returns indicates success, a return value of + indicates failure. + + + + gluProject transforms the specified object coordinates into window + coordinates using modelMatrix, projectionMatrix, and + viewport. The result is stored in winX, winY, and + winZ. A return value of indicates success, + a return value of indicates failure. + + + To compute the coordinates, let v = (objX, objY, objZ, 1.0) + represented as a matrix with 4 rows and 1 column. Then gluProject + computes v' as follows: + + + v' = P x M x v + + + Where P is the current projection matrix projectionMatrix, M is the + current modelview matrix modelMatrix (both represented as 4x4 matrices + in column-major order) and 'x' represents matrix multiplication. + + + The window coordinates are then computed as follows: + + + + winX = view(0) + view(2) * (v'(0) + 1) / 2 + winY = view(1) + view(3) * (v'(1) + 1) / 2 + winZ = (v'(2) + 1) / 2 + + + + + + + + + + Describes a piecewise linear NURBS trimming curve. + + + The NURBS object (created with ). + + + The number of points on the curve. + + + An array containing the curve points. + + + The offset (a number of single-precision floating-point values) between + points on the curve. + + + The type of curve. Must be either or + . + + + + gluPwlCurve describes a piecewise linear trimming curve for a NURBS + surface. A piecewise linear curve consists of a list of coordinates of + points in the parameter space for the NURBS surface to be trimmed. These + points are connected with line segments to form a curve. If the curve is an + approximation to a curve that is not piecewise linear, the points should be + close enough in parameter space that the resulting path appears curved at the + resolution used in the application. + + + If type is , then it describes a curve in + two-dimensional (u and v) parameter space. If it is + , then it describes a curve in two-dimensional + homogeneous (u, v, and w) parameter space. See the + reference page for more information about + trimming curves. + + + NOTES + + + To describe a trim curve that closely follows the contours of a NURBS + surface, call . + + + + + + + + + + Describes a piecewise linear NURBS trimming curve. + + + The NURBS object (created with ). + + + The number of points on the curve. + + + An array containing the curve points. + + + The offset (a number of single-precision floating-point values) between + points on the curve. + + + The type of curve. Must be either or + . + + + + gluPwlCurve describes a piecewise linear trimming curve for a NURBS + surface. A piecewise linear curve consists of a list of coordinates of + points in the parameter space for the NURBS surface to be trimmed. These + points are connected with line segments to form a curve. If the curve is an + approximation to a curve that is not piecewise linear, the points should be + close enough in parameter space that the resulting path appears curved at the + resolution used in the application. + + + If type is , then it describes a curve in + two-dimensional (u and v) parameter space. If it is + , then it describes a curve in two-dimensional + homogeneous (u, v, and w) parameter space. See the + reference page for more information about + trimming curves. + + + NOTES + + + To describe a trim curve that closely follows the contours of a NURBS + surface, call . + + + + + + + + + + Defines a callback for a quadric object. + + + The quadric object (created with ). + + + The callback being defined. The only valid value is + . + + + The function to be called. + + + + gluQuadricCallback is used to define a new callback to be used by a + quadrics object. If the specified callback is already defined, then it is + replaced. If func is null, then any existing callback is + erased. + + + The one legal callback is : + + + + + Value + Description + + + + + The function is called when an error is encountered. Its single + argument is of type , and it indicates the + specific error that occurred. Character strings describing these + errors can be retrieved with the + call. + + + + + + + + + + + + Specifies the draw style desired for quadrics. + + + The quadric object (created with ). + + + + The desired draw style. The following values are valid: + + + + + Value + Description + + + + + Quadrics are rendered with polygon primitives. The polygons are + drawn in a counterclockwise fashion with respect to their normals + (as defined with ). + + + + + + Quadrics are rendered as a set of lines. + + + + + + Quadrics are rendered as a set of lines, except that edges + separating coplanar faces will not be drawn. + + + + + + Quadrics are rendered as a set of points. + + + + + + + gluQuadricDrawStyle specifies the draw style for quadrics rendered + with quad. + + + + + + + + + Specifies what kind of normals are to be used for quadrics. + + + The quadric object (created with ). + + + + The desired type of normals. The following values are valid: + + + + + Value + Description + + + + + No normals are generated. + + + + + + One normal is generated for every facet of a quadric. + + + + + + One normal is generated for every vertex of a quadric. This is + the default value. + + + + + + + gluQuadricNormals specifies what kind of normals are desired for + quadrics rendered with quad. + + + + + + + + + Specifies inside or outside orientation for quadrics. + + + The quadric object (created with ). + + + + The desired orientation. The following values are valid: + + + + + Value + Description + + + + + Draw quadrics with normals pointing outward. This is the default + value. + + + + + + Draw quadrics with normals pointing inward. + + + + + + + + gluQuadricOrientation specifies what kind of orientation is desired + for quadrics rendered with quad. + + + The interpretation of outward and inward depends on the quadric being drawn. + + + + + + + + + + Specifies whether quadrics are to be textured. + + + The quadric object (created with ). + + + + A flag indicating whether texture coordinates are to be generated. The + following values are valid: + + + + + Value + Description + + + + + Generate texture coordinates. + + + + + + Do not generate texture coordinates. This is the default value. + + + + + + + + gluQuadricTexture specifies if texture coordinates should be generated + for quadrics rendered with quad. + + + The manner in which texture coordinates are generated depends upon the + specific quadric rendered. + + + + + + + + + + Scales an image to an arbitrary size. + + + The format of the pixel data. The following symbolic values are valid: + , , + , , + , , + , , + , , + , , and + . + + + The width of the source image that is scaled. + + + The height of the source image that is scaled. + + + The data type for dataIn. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , and + . + + + A pointer to the source image. + + + The width of the destination image. + + + The height of the destination image. + + + The data type for dataOut. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + A pointer to the destination image. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluScaleImage scales a pixel image using the appropriate pixel store + modes to unpack data from the source image and pack data into the + destination image. + + + When shrinking an image, gluScaleImage uses a box filter to sample the + source image and create pixels for the destination image. When magnifying an + image, the pixels from the source image are linearly interpolated to create + the destination image. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + See the reference page for a description of + the acceptable values for the format, typeIn, and + typeOut parameters. + + + NOTES + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if widthIn, + heightIn, widthOut, or heightOut is negative. + + + is returned if format, typeIn, + or typeOut is not legal. + + + is returned if typeIn or + typeOut is or + and format is not + . + + + is returned if typeIn or + typeOut is or + and format is not + . + + + is returned if typeIn or + typeOut is or + and format is neither + nor . + + + is returned if typeIn or + typeOut is or + and format is neither + nor . + + + is returned if typeIn or + typeOut is or + and format is neither + nor . + + + is returned if typeIn or + typeOut is or + and format is neither + nor . + + + + + + + + + + + + Scales an image to an arbitrary size. + + + The format of the pixel data. The following symbolic values are valid: + , , + , , + , , + , , + , , + , , and + . + + + The width of the source image that is scaled. + + + The height of the source image that is scaled. + + + The data type for dataIn. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , and + . + + + A pointer to the source image. + + + The width of the destination image. + + + The height of the destination image. + + + The data type for dataOut. Must be one of + , , + , , + , , + , , + , + , + , + , + , + , + , + , + , + , + , or + . + + + A pointer to the destination image. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + + gluScaleImage scales a pixel image using the appropriate pixel store + modes to unpack data from the source image and pack data into the + destination image. + + + When shrinking an image, gluScaleImage uses a box filter to sample the + source image and create pixels for the destination image. When magnifying an + image, the pixels from the source image are linearly interpolated to create + the destination image. + + + A return value of zero indicates success, otherwise a GLU error code is + returned (see ). + + + See the reference page for a description of + the acceptable values for the format, typeIn, and + typeOut parameters. + + + NOTES + + + Formats , and , and types + , + , + , + , + , + , + , + , + , + , + , and + are only available if the GL + version is 1.2 or greater. + + + ERRORS + + + is returned if widthIn, + heightIn, widthOut, or heightOut is negative. + + + is returned if format, typeIn, + or typeOut is not legal. + + + is returned if typeIn or + typeOut is or + and format is not + . + + + is returned if typeIn or + typeOut is or + and format is not + . + + + is returned if typeIn or + typeOut is or + and format is neither + nor . + + + is returned if typeIn or + typeOut is or + and format is neither + nor . + + + is returned if typeIn or + typeOut is or + and format is neither + nor . + + + is returned if typeIn or + typeOut is or + and format is neither + nor . + + + + + + + + + + + + Draws a sphere. + + + The quadric object (created with ). + + + The radius of the sphere. + + + The number of subdivisions around the z-axis (similar to lines of longitude. + + + The number of subdivisions along the z-axis (similar to lines of latitude). + + + + gluSphere draws a sphere of the given radius centered around the + origin. The sphere is subdivided around the z axis into slices and along the + z axis into stacks (similar to lines of longitude and latitude). + + + If the orientation is set to (with + ), then any normals generated point away + from the center of the sphere. Otherwise, they point toward the center of + the sphere. + + + If texturing is turned on (with ), then + texture coordinates are generated so that t ranges from 0.0 at z = -radius + to 1.0 at z = radius (t increases linearly along longitudinal lines), and + s ranges from 0.0 at the +y axis, to 0.25 at the +x axis, to 0.5 at the -y + axis, to 0.75 at the -x axis, and back to 1.0 at the +y axis. + + + + + + + + + + + + Delimits a contour description. + + + The tessellation object (created with ). + + + gluTessBeginContour and delimit the + definition of a polygon contour. Within each + gluTessBeginContour/ pair, there can + be zero or more calls to . The vertices specify + a closed contour (the last vertex of each contour is automatically linked to + the first). See the reference page for more + details. gluTessBeginContour can only be called between + and . + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + A pointer to a programmer defined–polygon data structure. + + + + gluTessBeginPolygon and delimit the + definition of a convex, concave or self-intersecting polygon. Within each + gluTessBeginPolygon/ pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + data is a pointer to a user-defined data structure. If the + appropriate callback(s) are specified (see ), + then this pointer is returned to the callback function(s). Thus, it is a + convenient way to store per-polygon information. + + + Once is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines a callback for a tessellation object. + + + The tessellation object (created with ). + + + + The callback being defined. The following values are valid: + + + + + Value + Description + + + + + The begin callback is invoked like to + indicate the start of a (triangle) primitive. The function takes + a single argument of type . If the + property is set to + , then the argument is set to either + , + , or + . If the + property is set to + , then the argument will be set to + . The delegate prototype for this + callback is . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The combine callback is called to create a new vertex when + the tessellation detects an intersection, or wishes to merge + features. The function takes four arguments: an array of + three elements each of type , an + array of four pointers, an array of four elements each of + type , and a pointer to a pointer. The + delegate prototype for this callback is + . + + + The vertex is defined as a linear combination of up to four + existing vertices, stored in vertexData. The + coefficients of the linear combination are given by + weight; these weights always add up to 1. All + vertex pointers are valid even when some of the weights are + 0. coordinates gives the location of the new vertex. + + + The user must allocate another vertex, interpolate parameters + using vertexData and weight, and return the new + vertex pointer in outData. This handle is supplied + during rendering callbacks. The user is responsible for + freeing the memory some time after + is called. + + + For example, if the polygon lies in an arbitrary plane in + 3-space, and a color is associated with each vertex, the + GLU_TESS_COMBINE callback might look like this: + + + + void myCombine(GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut) { + VERTEX *newVertex = new_vertex(); + newVertex->x = coords[0]; + newVertex->y = coords[1]; + newVertex->z = coords[2]; + newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r + + w[3]*d[3]->r; + newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g + + w[3]*d[3]->g; + newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b + + w[3]*d[3]->b; + newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a + + w[3]*d[3]->a; + *dataOut = newVertex; + } + + + + If the tessellation detects an intersection, then the + GLU_TESS_COMBINE or + callback (see below) + must be defined, and it must write a non-NULL pointer into + outData. Otherwise the + error occurs, + and no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The edge flag callback is similar to + . The function takes a single + boolean flag that indicates which edges lie on the polygon + boundary. If the flag is , then + each vertex that follows begins an edge that lies on the + polygon boundary, that is, an edge that separates an interior + region from an exterior one. If the flag is + , then each vertex that follows + begins an edge that lies in the polygon interior. The edge + flag callback (if defined) is invoked before the first + vertex callback. + + + Since triangle fans and triangle strips do not support edge + flags, the begin callback is not called with + or + if a non-NULL edge flag + callback is provided. (If the callback is initialized to + null, there is no impact on performance). Instead, + the fans and strips are converted to independent triangles. + The delegate prototype for this callback is + . + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The end callback serves the same purpose as + . It indicates the end of a primitive and + it takes no arguments. The delegate prototype for this callback + is . + + + + + + The same as the callback except that + it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The error callback is called when an error is encountered. + The one argument is of type ; it + indicates the specific error that occurred and will be set to + one of , + , + , + , + , + or + . Character strings + describing these errors can be retrieved with the + call. The delegate prototype + for this callback is . + + + The GLU library will recover from the first four errors by + inserting the missing call(s). + indicates that some + vertex coordinate exceeded the predefined constant + in absolute value, and that + the value has been clamped. (Coordinate values must be small + enough so that two can be multiplied together without + overflow.) + indicates that the tessellation detected an intersection + between two edges in the input data, and the + or + callback was not + provided. No output is generated. + indicates that there is not + enough memory so no output is generated. + + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + The vertex callback is invoked between the begin and end + callbacks. It is similar to Gl.glVertex*, and it defines the + vertices of the triangles created by the tessellation process. + The function takes a pointer as its only argument. This pointer + is identical to the opaque pointer provided by the user when the + vertex was described (see ). The + delegate prototype for this callback is + . + + + + + + The same as the callback except + that it takes an additional pointer argument. This pointer is + identical to the opaque pointer provided when + was called. The delegate + prototype for this callback is + . + + + + + + + The function to be called. + + + + gluTessCallback is used to indicate a callback to be used by a + tessellation object. If the specified callback is already defined, then it + is replaced. If func is null, then the existing callback + becomes undefined. + + + These callbacks are used by the tessellation object to describe how a polygon + specified by the user is broken into triangles. Note that there are two + versions of each callback: one with user-specified polygon data and one + without. If both versions of a particular callback are specified, then the + callback with user-specified polygon data will be used. Note that the + polygonData parameter used by some of the functions is a copy of the + pointer that was specified when was + called. + + + EXAMPLE + + + You can directly render tessallated polygons as follows: + + + + Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Gl.glBegin)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback(Gl.glVertex3dv)); + Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(Gl.glEnd)); + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v, v); + . . . + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + + + + + + + + + + + + + + + + + + + + + + + + + Delimits a contour description. + + + The tessellation object (created with ). + + + and gluTessEndContour delimit the + definition of a polygon contour. Within each + /gluTessEndContour pair, there can + be zero or more calls to . The vertices specify + a closed contour (the last vertex of each contour is automatically linked to + the first). See the reference page for more + details. can only be called between + and . + + + + + + + + + + + + + Delimits a polygon description. + + + The tessellation object (created with ). + + + + and gluTessEndPolygon delimit the + definition of a convex, concave or self-intersecting polygon. Within each + /gluTessEndPolygon pair, there must + be one or more calls to + /. Within + each contour, there are zero or more calls to . + The vertices specify a closed contour (the last vertex of each contour is + automatically linked to the first). See the , + , and + reference pages for more details. + + + Once gluTessEndPolygon is called, the polygon is tessellated, + and the resulting triangles are described through callbacks. See + for descriptions of the callback functions. + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tobj, null); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v1, v1); + Glu.gluTessVertex(tobj, v2, v2); + Glu.gluTessVertex(tobj, v3, v3); + Glu.gluTessVertex(tobj, v4, v4); + Glu.gluTessEndContour(tobj); + Glu.gluTessBeginContour(tobj); + Glu.gluTessVertex(tobj, v5, v5); + Glu.gluTessVertex(tobj, v6, v6); + Glu.gluTessVertex(tobj, v7, v7); + Glu.gluTessEndContour(tobj); + Glu.gluTessEndPolygon(tobj); + + + + + + + + + + + + + + Specifies a normal for a polygon. + + + The tessellation object (created with ). + + + The x-coordinate component of a normal. + + + The y-coordinate component of a normal. + + + The z-coordinate component of a normal. + + + + gluTessNormal describes a normal for a polygon that the program is + defining. All input data will be projected onto a plane perpendicular to one + of the three coordinate axes before tessellation and all output triangles + will be oriented CCW with respect to the normal (CW orientation can be + obtained by reversing the sign of the supplied normal). For example, if you + know that all polygons lie in the x-y plane, call + Glu.gluTessNormal(tess, 0.0, 0.0, 1.0) before rendering any polygons. + + + If the supplied normal is (0.0, 0.0, 0.0) (the initial value), the normal is + determined as follows. The direction of the normal, up to its sign, is found + by fitting a plane to the vertices, without regard to how the vertices are + connected. It is expected that the input data lies approximately in the + plane; otherwise, projection perpendicular to one of the three coordinate + axes may substantially change the geometry. The sign of the normal is chosen + so that the sum of the signed areas of all input contours is nonnegative + (where a CCW contour has positive area). + + + The supplied normal persists until it is changed by another call to + gluTessNormal. + + + + + + + + + Sets the property of a tessellation object. + + + The tessellation object (created with ). + + + + The property value to set. The following values are valid: + + + + + Value + Description + + + + + + Determines which parts of the polygon are on the "interior". + data may be set to one of + , + , + , or + , or + . + + + To understand how the winding rule works, consider that the + input contours partition the plane into regions. The winding + rule determines which of these regions are inside the + polygon. + + + For a single contour C, the winding number of a point x is + simply the signed number of revolutions we make around x as + we travel once around C (where CCW is positive). When there + are several contours, the individual winding numbers are + summed. This procedure associates a signed integer value + with each point x in the plane. Note that the winding number + is the same for all points in a single region. + + + The winding rule classifies a region as "inside" if its + winding number belongs to the chosen category (odd, nonzero, + positive, negative, or absolute value of at least two). The + previous GLU tessellator (prior to GLU 1.2) used the "odd" + rule. The "nonzero" rule is another common way to define the + interior. The other three rules are useful for polygon CSG + operations. + + + + + + + Is a boolean value ("value" should be set to + or ). When + set to , a set of closed contours + separating the polygon interior and exterior are returned instead + of a tessellation. Exterior contours are oriented CCW with + respect to the normal; interior contours are oriented CW. The + and + callbacks use the type + for each contour. + + + + + + + Specifies a tolerance for merging features to reduce the size + of the output. For example, two vertices that are very close + to each other might be replaced by a single vertex. The + tolerance is multiplied by the largest coordinate magnitude + of any input vertex; this specifies the maximum distance that + any feature can move as the result of a single merge + operation. If a single feature takes part in several merge + operations, the total distance moved could be larger. + + + Feature merging is completely optional; the tolerance is only + a hint. The implementation is free to merge in some cases + and not in others, or to never merge features at all. The + initial tolerance is 0. + + + The current implementation merges vertices only if they are + exactly coincident, regardless of the current tolerance. A + vertex is spliced into an edge only if the implementation is + unable to distinguish which side of the edge the vertex lies + on. Two edges are merged only when both endpoints are + identical. + + + + + + + + The value of the indicated property. + + + gluTessProperty is used to control properties stored in a tessellation + object. These properties affect the way that the polygons are interpreted + and rendered. + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Specifies a vertex on a polygon. + + + The tessellation object (created with ). + + + The location of the vertex. + + + A pointer passed back to the program with the vertex callback (as specified + by ). + + + + gluTessVertex describes a vertex on a polygon that the program + defines. Successive gluTessVertex calls describe a closed contour. + For example, to describe a quadrilateral gluTessVertex should be + called four times. gluTessVertex can only be called between + and . + + + data normally points to a structure containing the vertex location, + as well as other per-vertex attributes such as color and normal. This + pointer is passed back to the user through the + or callback after tessellation (see the + reference page). + + + EXAMPLE + + + The following describes a quadrilateral with a triangular hole: + + + + Glu.gluTessBeginPolygon(tess, null); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v1, v1); + Glu.gluTessVertex(tess, v2, v2); + Glu.gluTessVertex(tess, v3, v3); + Glu.gluTessVertex(tess, v4, v4); + Glu.gluTessEndContour(tess); + Glu.gluNextContour(tess, Glu.GLU_INTERIOR); + Glu.gluTessBeginContour(tess); + Glu.gluTessVertex(tess, v5, v5); + Glu.gluTessVertex(tess, v6, v6); + Glu.gluTessVertex(tess, v7, v7); + Glu.gluTessEndContour(tess); + Glu.gluTessEndPolygon(tess); + + + + NOTES + + + It is a common error to use a local variable for location or + data and store values into it as part of a loop. For example: + + + + for(int i = 0; i < NVERTICES; ++i) { + double data[3]; + data[0] = vertex[i, 0]; + data[1] = vertex[i, 1]; + data[2] = vertex[i, 2]; + Glu.gluTessVertex(tobj, data, data); + } + + + + This doesn't work. Because the pointers specified by location and + data might not be dereferenced until + is executed, all the vertex coordinates but the very last set could be + overwritten before tessellation begins. + + + Two common symptoms of this problem are consists of a single point (when a + local variable is used for data) and a + error (when a local variable + is used for location). + + + + + + + + + + + + + Maps window coordinates to object coordinates. + + + The window's x axis coordinate to be mapped. + + + The window's y axis coordinate to be mapped. + + + The window's z axis coordinate to be mapped. + + + The modelview matrix (as from a call). + + + The projection matrix (as from a call). + + + The viewport (as from a call). + + + The computed object's x axis coordinate. + + + The computed object's y axis coordinate. + + + The computed object's z axis coordinate. + + + A return value of indicates success; a return value + of indicates failure. + + + + gluUnProject maps the specified window coordinates into object + coordinates using modelMatrix, projectionMatrix, and + viewport. The result is stored in objX, objY, and + objZ. A return value of indicates success; + a return value of indicates failure. + + + To compute the coordinates (objX, objY, and objZ), + gluUnProject multiplies the normalized device coordinates by the + inverse of modelMatrix multiplied by projectionMatrix as + follows: + + + + ( 2(winX - viewport[0]) ) + | ----------------- - 1 | + | viewport[2] | + ( ) | | + | objX | | 2(winY - viewport[1]) | + | objY | = INV(PM)| ----------------- - 1 | + | objZ | | viewport[3] | + ( W ) | | + | 2(winZ) - 1 | + | | + ( 1 ) + + + + INV() denotes matrix inversion. W is an unused variable, included for + consistent matrix notation. + + + + + + + + + Maps window and clip coordinates to object coordinates. + + + The window's x axis coordinate to be mapped. + + + The window's y axis coordinate to be mapped. + + + The window's z axis coordinate to be mapped. + + + The clip w coordinate to be mapped. + + + The modelview matrix (as from a call). + + + The projection matrix (as from a call). + + + The viewport (as from a call). + + + The near plane (as from a call). + + + The far plane (as from a call). + + + The computed object's x axis coordinate. + + + The computed object's y axis coordinate. + + + The computed object's z axis coordinate. + + + The computed object's clip w coordinate. + + + A return value of indicates success; a return + value of indicates failure. + + + + gluUnProject4 maps the specified window coordinates winX, + winY and winZ and its clip w coordinate clipW into + object coordinates (objX, objY, objZ, objW) + using modelMatrix, projectionMatrix and viewport. + clipW can be other than 1 as for vertices in + when data type + is returned. This also handles the + case where the nearVal and farVal planes are different from the + default, 0 and 1, respectively. A return value of + indicates success; a return value of indicates + failure. + + + To compute the coordinates (objX, objY, objZ and + objW), gluUnProject4 multiplies the normalized device + coordinates by the inverse of modelMatrix multiplied by + projectionMatrix as follows: + + + + ( 2(winX - viewport[0] ) + | ---------------- - 1 | + | viewport[2] | + | | + | 2(winY - viewport[1] | + ( objX ) | ---------------- - 1 | + | objY | = INV(PM) * | viewport[3] | + | objZ | | | + ( objW ) | 2(winZ - nearVal) | + | -------------- - 1 | + | farVal - nearVal | + | | + ( clipW ) + + + + INV() denotes matrix inversion. + + + gluUnProject4 is equivalent to when + clipW is 1, nearVal is 0 and farVal is 1. + + + gluUnProject4 is available only if the GLU version is 1.3 or greater. + + + + + + + + + + + Defines a GLU NURBS object. + + + + + Keeps the struct from being garbage collected prematurely. + + + + + Defines a GLU quadric object. + + + + + Keeps the struct from being garbage collected prematurely. + + + + + Defines a GLU tesselator object. + + + + + Keeps the struct from being garbage collected prematurely. + + + + + Defines a GLU NURBS object. + + + + + Keeps the struct from being garbage collected prematurely. + + + + + Defines a GLU quadric object. + + + + + Keeps the struct from being garbage collected prematurely. + + + + + Defines a GLU tesselator object. + + + + + Keeps the struct from being garbage collected prematurely. + + + + + Defines a GLU triangulator object. + + + + + Keeps the struct from being garbage collected prematurely. + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + Callback (delegate) for use with . + + + + + + 4-component Vector of the Half type. Occupies 8 Byte total. + + + + The X component of the Half4. + + + The Y component of the Half4. + + + The Z component of the Half4. + + + The W component of the Half4. + + + + The new Half4 instance will avoid conversion and copy directly from the Half parameters. + + An Half instance of a 16-bit half-precision floating-point number. + An Half instance of a 16-bit half-precision floating-point number. + An Half instance of a 16-bit half-precision floating-point number. + An Half instance of a 16-bit half-precision floating-point number. + + + + The new Half4 instance will convert the 4 parameters into 16-bit half-precision floating-point. + + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + + + + The new Half4 instance will convert the 4 parameters into 16-bit half-precision floating-point. + + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + 32-bit single-precision floating-point number. + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half4 instance will convert the Vector4 into 16-bit half-precision floating-point. + + OpenTK.Vector4 + + + + The new Half4 instance will convert the Vector4 into 16-bit half-precision floating-point. + + OpenTK.Vector4 + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half4 instance will convert the Vector4 into 16-bit half-precision floating-point. + This is the fastest constructor. + + OpenTK.Vector4 + + + + The new Half4 instance will convert the Vector4 into 16-bit half-precision floating-point. + + OpenTK.Vector4 + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half4 instance will convert the Vector4d into 16-bit half-precision floating-point. + + OpenTK.Vector4d + + + + The new Half4 instance will convert the Vector4d into 16-bit half-precision floating-point. + + OpenTK.Vector4d + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half4 instance will convert the Vector4d into 16-bit half-precision floating-point. + This is the faster constructor. + + OpenTK.Vector4d + + + + The new Half4 instance will convert the Vector4d into 16-bit half-precision floating-point. + + OpenTK.Vector4d + Enable checks that will throw if the conversion result is not meaningful. + + + + Returns this Half4 instance's contents as Vector4. + + OpenTK.Vector4 + + + + Returns this Half4 instance's contents as Vector4d. + + + + Converts OpenTK.Vector4 to OpenTK.Half4. + The Vector4 to convert. + The resulting Half vector. + + + Converts OpenTK.Vector4d to OpenTK.Half4. + The Vector4d to convert. + The resulting Half vector. + + + Converts OpenTK.Half4 to OpenTK.Vector4. + The Half4 to convert. + The resulting Vector4. + + + Converts OpenTK.Half4 to OpenTK.Vector4d. + The Half4 to convert. + The resulting Vector4d. + + + The size in bytes for an instance of the Half4 struct is 8. + + + Constructor used by ISerializable to deserialize the object. + + + + + Used by ISerialize to serialize the object. + + + + + Updates the X,Y,Z and W components of this instance by reading from a Stream. + A BinaryReader instance associated with an open Stream. + + + Writes the X,Y,Z and W components of this instance into a Stream. + A BinaryWriter instance associated with an open Stream. + + + Returns a value indicating whether this instance is equal to a specified OpenTK.Half4 vector. + OpenTK.Half4 to compare to this instance.. + True, if other is equal to this instance; false otherwise. + + + Returns a string that contains this Half4's numbers in human-legible form. + + + Returns the Half4 as an array of bytes. + The Half4 to convert. + The input as byte array. + + + Converts an array of bytes into Half4. + A Half4 in it's byte[] representation. + The starting position within value. + A new Half4 instance. + + + + Gets or sets an OpenTK.Vector2h with the X and Y components of this instance. + + + + + Gets or sets an OpenTK.Vector3h with the X, Y and Z components of this instance. + + + + + Holds part or the whole of a 2d OpenGL texture. + + + + A list of valid Enable/Disable/IsEnabled parameters + + + Currently no state toggles exist for vanilla OpenAL and no Extension uses it. + + + A list of valid 32-bit Float Listener/GetListener parameters + + + Indicate the gain (Volume amplification) applied. Type: float Range: [0.0f - ? ] A value of 1.0 means un-attenuated/unchanged. Each division by 2 equals an attenuation of -6dB. Each multiplicaton with 2 equals an amplification of +6dB. A value of 0.0f is interpreted as zero volume and the channel is effectively disabled. + + + (EFX Extension) This setting is critical if Air Absorption effects are enabled because the amount of Air Absorption applied is directly related to the real-world distance between the Source and the Listener. centimeters 0.01f meters 1.0f kilometers 1000.0f Range [float.MinValue .. float.MaxValue] Default: 1.0f + + + A list of valid Math.Vector3 Listener/GetListener parameters + + + Specify the current location in three dimensional space. OpenAL, like OpenGL, uses a right handed coordinate system, where in a frontal default view X (thumb) points right, Y points up (index finger), and Z points towards the viewer/camera (middle finger). To switch from a left handed coordinate system, flip the sign on the Z coordinate. Listener position is always in the world coordinate system. + + + Specify the current velocity in three dimensional space. + + + A list of valid float[] Listener/GetListener parameters + + + Indicate Listener orientation. Expects two Vector3, At followed by Up. + + + A list of valid 32-bit Float Source/GetSource parameters + + + Source specific reference distance. Type: float Range: [0.0f - float.PositiveInfinity] At 0.0f, no distance attenuation occurs. Type: float Default: 1.0f. + + + Indicate distance above which Sources are not attenuated using the inverse clamped distance model. Default: float.PositiveInfinity Type: float Range: [0.0f - float.PositiveInfinity] + + + Source specific rolloff factor. Type: float Range: [0.0f - float.PositiveInfinity] + + + Specify the pitch to be applied, either at Source, or on mixer results, at Listener. Range: [0.5f - 2.0f] Default: 1.0f + + + Indicate the gain (volume amplification) applied. Type: float. Range: [0.0f - ? ] A value of 1.0 means un-attenuated/unchanged. Each division by 2 equals an attenuation of -6dB. Each multiplicaton with 2 equals an amplification of +6dB. A value of 0.0f is meaningless with respect to a logarithmic scale; it is interpreted as zero volume - the channel is effectively disabled. + + + Indicate minimum Source attenuation. Type: float Range: [0.0f - 1.0f] (Logarthmic) + + + Indicate maximum Source attenuation. Type: float Range: [0.0f - 1.0f] (Logarthmic) + + + Directional Source, inner cone angle, in degrees. Range: [0-360] Default: 360 + + + Directional Source, outer cone angle, in degrees. Range: [0-360] Default: 360 + + + Directional Source, outer cone gain. Default: 0.0f Range: [0.0f - 1.0] (Logarithmic) + + + The playback position, expressed in seconds. + + + (EFX Extension) This property is a multiplier on the amount of Air Absorption applied to the Source. The AL_AIR_ABSORPTION_FACTOR is multiplied by an internal Air Absorption Gain HF value of 0.994 (-0.05dB) per meter which represents normal atmospheric humidity and temperature. Range [0.0f .. 10.0f] Default: 0.0f + + + (EFX Extension) This property is defined the same way as the Reverb Room Rolloff property: it is one of two methods available in the Effect Extension to attenuate the reflected sound (early reflections and reverberation) according to source-listener distance. Range [0.0f .. 10.0f] Default: 0.0f + + + (EFX Extension) A directed Source points in a specified direction. The Source sounds at full volume when the listener is directly in front of the source; it is attenuated as the listener circles the Source away from the front. Range [0.0f .. 1.0f] Default: 1.0f + + + A list of valid Math.Vector3 Source/GetSource parameters + + + Specify the current location in three dimensional space. OpenAL, like OpenGL, uses a right handed coordinate system, where in a frontal default view X (thumb) points right, Y points up (index finger), and Z points towards the viewer/camera (middle finger). To switch from a left handed coordinate system, flip the sign on the Z coordinate. Listener position is always in the world coordinate system. + + + Specify the current velocity in three dimensional space. + + + Specify the current direction vector. + + + A list of valid 8-bit boolean Source/GetSource parameters + + + Indicate that the Source has relative coordinates. Type: bool Range: [True, False] + + + Indicate whether the Source is looping. Type: bool Range: [True, False] Default: False. + + + (EFX Extension) If this Source property is set to True, this Source’s direct-path is automatically filtered according to the orientation of the source relative to the listener and the setting of the Source property Sourcef.ConeOuterGainHF. Type: bool Range [False, True] Default: True + + + (EFX Extension) If this Source property is set to True, the intensity of this Source’s reflected sound is automatically attenuated according to source-listener distance and source directivity (as determined by the cone parameters). If it is False, the reflected sound is not attenuated according to distance and directivity. Type: bool Range [False, True] Default: True + + + (EFX Extension) If this Source property is AL_TRUE (its default value), the intensity of this Source’s reflected sound at high frequencies will be automatically attenuated according to the high-frequency source directivity as set by the Sourcef.ConeOuterGainHF property. If this property is AL_FALSE, the Source’s reflected sound is not filtered at all according to the Source’s directivity. Type: bool Range [False, True] Default: True + + + A list of valid Int32 Source parameters + + + The playback position, expressed in bytes. + + + The playback position, expressed in samples. + + + Indicate the Buffer to provide sound samples. Type: uint Range: any valid Buffer Handle. + + + Source type (Static, Streaming or undetermined). Use enum AlSourceType for comparison + + + (EFX Extension) This Source property is used to apply filtering on the direct-path (dry signal) of a Source. + + + A list of valid 3x Int32 Source/GetSource parameters + + + (EFX Extension) This Source property is used to establish connections between Sources and Auxiliary Effect Slots. For a Source to feed an Effect that has been loaded into an Auxiliary Effect Slot the application must configure one of the Source’s auxiliary sends. This process involves setting 3 variables – the destination Auxiliary Effect Slot ID, the Auxiliary Send number, and an optional Filter ID. Type: uint Range: any valid Filter Handle. + + + A list of valid Int32 GetSource parameters + + + The playback position, expressed in bytes. AL_EXT_OFFSET Extension. + + + The playback position, expressed in samples. AL_EXT_OFFSET Extension. + + + Indicate the Buffer to provide sound samples. Type: uint Range: any valid Buffer Handle. + + + The state of the source (Stopped, Playing, etc.) Use the enum AlSourceState for comparison. + + + The number of buffers queued on this source. + + + The number of buffers in the queue that have been processed. + + + Source type (Static, Streaming or undetermined). Use enum AlSourceType for comparison. + + + Source state information, can be retrieved by AL.Source() with ALSourcei.SourceState. + + + Default State when loaded, can be manually set with AL.SourceRewind(). + + + The source is currently playing. + + + The source has paused playback. + + + The source is not playing. + + + Source type information, can be retrieved by AL.Source() with ALSourcei.SourceType. + + + Source is Static if a Buffer has been attached using AL.Source with the parameter Sourcei.Buffer. + + + Source is Streaming if one or more Buffers have been attached using AL.SourceQueueBuffers + + + Source is undetermined when it has a null Buffer attached + + + Sound samples: Format specifier. + + + 1 Channel, 8 bits per sample. + + + 1 Channel, 16 bits per sample. + + + 2 Channels, 8 bits per sample each. + + + 2 Channels, 16 bits per sample each. + + + 1 Channel, A-law encoded data. Requires Extension: AL_EXT_ALAW + + + 2 Channels, A-law encoded data. Requires Extension: AL_EXT_ALAW + + + 1 Channel, µ-law encoded data. Requires Extension: AL_EXT_MULAW + + + 2 Channels, µ-law encoded data. Requires Extension: AL_EXT_MULAW + + + Ogg Vorbis encoded data. Requires Extension: AL_EXT_vorbis + + + MP3 encoded data. Requires Extension: AL_EXT_mp3 + + + 1 Channel, IMA4 ADPCM encoded data. Requires Extension: AL_EXT_IMA4 + + + 2 Channels, IMA4 ADPCM encoded data. Requires Extension: AL_EXT_IMA4 + + + 1 Channel, single-precision floating-point data. Requires Extension: AL_EXT_float32 + + + 2 Channels, single-precision floating-point data. Requires Extension: AL_EXT_float32 + + + 1 Channel, double-precision floating-point data. Requires Extension: AL_EXT_double + + + 2 Channels, double-precision floating-point data. Requires Extension: AL_EXT_double + + + Multichannel 5.1, 16-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 5.1, 32-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 5.1, 8-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 6.1, 16-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 6.1, 32-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 6.1, 8-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 7.1, 16-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 7.1, 32-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 7.1, 8-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 4.0, 16-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 4.0, 32-bit data. Requires Extension: AL_EXT_MCFORMATS + + + Multichannel 4.0, 8-bit data. Requires Extension: AL_EXT_MCFORMATS + + + 1 Channel rear speaker, 16-bit data. See Quadrophonic setups. Requires Extension: AL_EXT_MCFORMATS + + + 1 Channel rear speaker, 32-bit data. See Quadrophonic setups. Requires Extension: AL_EXT_MCFORMATS + + + 1 Channel rear speaker, 8-bit data. See Quadrophonic setups. Requires Extension: AL_EXT_MCFORMATS + + + A list of valid Int32 GetBuffer parameters + + + Sound sample's frequency, in units of hertz [Hz]. This is the number of samples per second. Half of the sample frequency marks the maximum significant frequency component. + + + Bit depth of the buffer. Should be 8 or 16. + + + Number of channels in buffer. > 1 is valid, but buffer won’t be positioned when played. 1 for Mono, 2 for Stereo. + + + size of the Buffer in bytes. + + + Buffer state. Not supported for public use (yet). + + + Buffer state. Not supported for public use (yet). + + + Buffer state. Not supported for public use (yet). + + + Buffer state. Not supported for public use (yet). + + + Returned by AL.GetError + + + No OpenAL Error. + + + Invalid Name paramater passed to OpenAL call. + + + Invalid parameter passed to OpenAL call. + + + Invalid parameter passed to OpenAL call. + + + Invalid OpenAL enum parameter value. + + + Illegal OpenAL call. + + + Illegal OpenAL call. + + + No OpenAL memory left. + + + A list of valid string AL.Get() parameters + + + Gets the Vendor name. + + + Gets the driver version. + + + Gets the renderer mode. + + + Gets a list of all available Extensions, separated with spaces. + + + A list of valid 32-bit Float AL.Get() parameters + + + Doppler scale. Default 1.0f + + + Tweaks speed of propagation. This functionality is deprecated. + + + Speed of Sound in units per second. Default: 343.3f + + + A list of valid Int32 AL.Get() parameters + + + See enum ALDistanceModel. + + + Used by AL.DistanceModel(), the distance model can be retrieved by AL.Get() with ALGetInteger.DistanceModel + + + Bypasses all distance attenuation calculation for all Sources. + + + InverseDistance is equivalent to the IASIG I3DL2 model with the exception that ALSourcef.ReferenceDistance does not imply any clamping. + + + InverseDistanceClamped is the IASIG I3DL2 model, with ALSourcef.ReferenceDistance indicating both the reference distance and the distance below which gain will be clamped. + + + AL_EXT_LINEAR_DISTANCE extension. + + + AL_EXT_LINEAR_DISTANCE extension. + + + AL_EXT_EXPONENT_DISTANCE extension. + + + AL_EXT_EXPONENT_DISTANCE extension. + + + + Defines a 2d box (rectangle). + + + + + The left boundary of the structure. + + + + + The right boundary of the structure. + + + + + The top boundary of the structure. + + + + + The bottom boundary of the structure. + + + + + Constructs a new Box2 with the specified dimensions. + + AnOpenTK.Vector2 describing the top-left corner of the Box2. + An OpenTK.Vector2 describing the bottom-right corner of the Box2. + + + + Constructs a new Box2 with the specified dimensions. + + The position of the left boundary. + The position of the top boundary. + The position of the right boundary. + The position of the bottom boundary. + + + + Creates a new Box2 with the specified dimensions. + + The position of the top boundary. + The position of the left boundary. + The position of the right boundary. + The position of the bottom boundary. + A new OpenTK.Box2 with the specfied dimensions. + + + + Gets a float describing the width of the Box2 structure. + + + + + Gets a float describing the height of the Box2 structure. + + + + + Represents a 4x4 Matrix + + + + + Top row of the matrix + + + + + 2nd row of the matrix + + + + + 3rd row of the matrix + + + + + Bottom row of the matrix + + + + + The identity matrix + + + + + Constructs a new instance. + + Top row of the matrix + Second row of the matrix + Third row of the matrix + Bottom row of the matrix + + + + Constructs a new instance. + + First item of the first row of the matrix. + Second item of the first row of the matrix. + Third item of the first row of the matrix. + Fourth item of the first row of the matrix. + First item of the second row of the matrix. + Second item of the second row of the matrix. + Third item of the second row of the matrix. + Fourth item of the second row of the matrix. + First item of the third row of the matrix. + Second item of the third row of the matrix. + Third item of the third row of the matrix. + First item of the third row of the matrix. + Fourth item of the fourth row of the matrix. + Second item of the fourth row of the matrix. + Third item of the fourth row of the matrix. + Fourth item of the fourth row of the matrix. + + + + Calculates the transpose of this instance. + + + + + Build a rotation matrix from the specified axis/angle rotation. + + The axis to rotate about. + Angle in radians to rotate counter-clockwise (looking in the direction of the given axis). + A matrix instance. + + + + Build a rotation matrix from the specified axis/angle rotation. + + The axis to rotate about. + Angle in radians to rotate counter-clockwise (looking in the direction of the given axis). + A matrix instance. + + + + Creates a translation matrix. + + X translation. + Y translation. + Z translation. + The resulting Matrix4 instance. + + + + Creates a translation matrix. + + The translation vector. + The resulting Matrix4 instance. + + + + Creates a translation matrix. + + X translation. + Y translation. + Z translation. + The resulting Matrix4 instance. + + + + Creates a translation matrix. + + The translation vector. + The resulting Matrix4 instance. + + + + Creates an orthographic projection matrix. + + The width of the projection volume. + The height of the projection volume. + The near edge of the projection volume. + The far edge of the projection volume. + The resulting Matrix4 instance. + + + + Creates an orthographic projection matrix. + + The width of the projection volume. + The height of the projection volume. + The near edge of the projection volume. + The far edge of the projection volume. + The resulting Matrix4 instance. + + + + Creates an orthographic projection matrix. + + The left edge of the projection volume. + The right edge of the projection volume. + The bottom edge of the projection volume. + The top edge of the projection volume. + The near edge of the projection volume. + The far edge of the projection volume. + The resulting Matrix4 instance. + + + + Creates an orthographic projection matrix. + + The left edge of the projection volume. + The right edge of the projection volume. + The bottom edge of the projection volume. + The top edge of the projection volume. + The near edge of the projection volume. + The far edge of the projection volume. + The resulting Matrix4 instance. + + + + Creates a perspective projection matrix. + + Angle of the field of view in the y direction (in radians) + Aspect ratio of the view (width / height) + Distance to the near clip plane + Distance to the far clip plane + A projection matrix that transforms camera space to raster space + + Thrown under the following conditions: + + fovy is zero, less than zero or larger than Math.PI + aspect is negative or zero + zNear is negative or zero + zFar is negative or zero + zNear is larger than zFar + + + + + + Creates a perspective projection matrix. + + Angle of the field of view in the y direction (in radians) + Aspect ratio of the view (width / height) + Distance to the near clip plane + Distance to the far clip plane + A projection matrix that transforms camera space to raster space + + Thrown under the following conditions: + + fovy is zero, less than zero or larger than Math.PI + aspect is negative or zero + zNear is negative or zero + zFar is negative or zero + zNear is larger than zFar + + + + + + Creates an perspective projection matrix. + + Left edge of the view frustum + Right edge of the view frustum + Bottom edge of the view frustum + Top edge of the view frustum + Distance to the near clip plane + Distance to the far clip plane + A projection matrix that transforms camera space to raster space + + Thrown under the following conditions: + + zNear is negative or zero + zFar is negative or zero + zNear is larger than zFar + + + + + + Creates an perspective projection matrix. + + Left edge of the view frustum + Right edge of the view frustum + Bottom edge of the view frustum + Top edge of the view frustum + Distance to the near clip plane + Distance to the far clip plane + A projection matrix that transforms camera space to raster space + + Thrown under the following conditions: + + zNear is negative or zero + zFar is negative or zero + zNear is larger than zFar + + + + + + Builds a translation matrix. + + The translation vector. + A new Matrix4 instance. + + + + Build a translation matrix with the given translation + + X translation + Y translation + Z translation + A Translation matrix + + + + Build a scaling matrix + + Single scale factor for x,y and z axes + A scaling matrix + + + + Build a scaling matrix + + Scale factors for x,y and z axes + A scaling matrix + + + + Build a scaling matrix + + Scale factor for x-axis + Scale factor for y-axis + Scale factor for z-axis + A scaling matrix + + + + Build a rotation matrix that rotates about the x-axis + + angle in radians to rotate counter-clockwise around the x-axis + A rotation matrix + + + + Build a rotation matrix that rotates about the y-axis + + angle in radians to rotate counter-clockwise around the y-axis + A rotation matrix + + + + Build a rotation matrix that rotates about the z-axis + + angle in radians to rotate counter-clockwise around the z-axis + A rotation matrix + + + + Build a rotation matrix to rotate about the given axis + + the axis to rotate about + angle in radians to rotate counter-clockwise (looking in the direction of the given axis) + A rotation matrix + + + + Build a rotation matrix from a quaternion + + the quaternion + A rotation matrix + + + + Build a world space to camera space matrix + + Eye (camera) position in world space + Target position in world space + Up vector in world space (should not be parallel to the camera direction, that is target - eye) + A Matrix4 that transforms world space to camera space + + + + Build a world space to camera space matrix + + Eye (camera) position in world space + Eye (camera) position in world space + Eye (camera) position in world space + Target position in world space + Target position in world space + Target position in world space + Up vector in world space (should not be parallel to the camera direction, that is target - eye) + Up vector in world space (should not be parallel to the camera direction, that is target - eye) + Up vector in world space (should not be parallel to the camera direction, that is target - eye) + A Matrix4 that transforms world space to camera space + + + + Build a projection matrix + + Left edge of the view frustum + Right edge of the view frustum + Bottom edge of the view frustum + Top edge of the view frustum + Distance to the near clip plane + Distance to the far clip plane + A projection matrix that transforms camera space to raster space + + + + Build a projection matrix + + Angle of the field of view in the y direction (in radians) + Aspect ratio of the view (width / height) + Distance to the near clip plane + Distance to the far clip plane + A projection matrix that transforms camera space to raster space + + + + Multiplies two instances. + + The left operand of the multiplication. + The right operand of the multiplication. + A new instance that is the result of the multiplication + + + + Multiplies two instances. + + The left operand of the multiplication. + The right operand of the multiplication. + A new instance that is the result of the multiplication + + + + Calculate the inverse of the given matrix + + The matrix to invert + The inverse of the given matrix if it has one, or the input if it is singular + Thrown if the Matrix4 is singular. + + + + Calculate the transpose of the given matrix + + The matrix to transpose + The transpose of the given matrix + + + + Calculate the transpose of the given matrix + + The matrix to transpose + The result of the calculation + + + + Matrix multiplication + + left-hand operand + right-hand operand + A new Matrix44 which holds the result of the multiplication + + + + Returns a System.String that represents the current Matrix44. + + + + + + Returns the hashcode for this instance. + + A System.Int32 containing the unique hashcode for this instance. + + + + Indicates whether this instance and a specified object are equal. + + The object to compare tresult. + True if the instances are equal; false otherwise. + + + Indicates whether the current matrix is equal to another matrix. + An matrix to compare with this matrix. + true if the current matrix is equal to the matrix parameter; otherwise, false. + + + + The determinant of this matrix + + + + + The first column of this matrix + + + + + The second column of this matrix + + + + + The third column of this matrix + + + + + The fourth column of this matrix + + + + + Gets or sets the value at row 1, column 1 of this instance. + + + + + Gets or sets the value at row 1, column 2 of this instance. + + + + + Gets or sets the value at row 1, column 3 of this instance. + + + + + Gets or sets the value at row 1, column 4 of this instance. + + + + + Gets or sets the value at row 2, column 1 of this instance. + + + + + Gets or sets the value at row 2, column 2 of this instance. + + + + + Gets or sets the value at row 2, column 3 of this instance. + + + + + Gets or sets the value at row 2, column 4 of this instance. + + + + + Gets or sets the value at row 3, column 1 of this instance. + + + + + Gets or sets the value at row 3, column 2 of this instance. + + + + + Gets or sets the value at row 3, column 3 of this instance. + + + + + Gets or sets the value at row 3, column 4 of this instance. + + + + + Gets or sets the value at row 4, column 1 of this instance. + + + + + Gets or sets the value at row 4, column 3 of this instance. + + + + + Gets or sets the value at row 4, column 3 of this instance. + + + + + Gets or sets the value at row 4, column 4 of this instance. + + + + Represents a 2D vector using two double-precision floating-point numbers. + + + The X coordinate of this instance. + + + The Y coordinate of this instance. + + + + Defines a unit-length Vector2d that points towards the X-axis. + + + + + Defines a unit-length Vector2d that points towards the Y-axis. + + + + + Defines a zero-length Vector2d. + + + + + Defines an instance with all components set to 1. + + + + + Defines the size of the Vector2d struct in bytes. + + + + Constructs left vector with the given coordinates. + The X coordinate. + The Y coordinate. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Multiply this instance by a scalar. + Scalar operand. + + + Divide this instance by a scalar. + Scalar operand. + + + + Scales the Vector2 to unit length. + + + + + Scales the current Vector2 by the given amounts. + + The scale of the X component. + The scale of the Y component. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Calculate the dot (scalar) product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Calculate the dot (scalar) product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Interpolate 3 Vectors using Barycentric coordinates + + First input Vector + Second input Vector + Third input Vector + First Barycentric Coordinate + Second Barycentric Coordinate + a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + Interpolate 3 Vectors using Barycentric coordinates + First input Vector. + Second input Vector. + Third input Vector. + First Barycentric Coordinate. + Second Barycentric Coordinate. + Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + + Adds two instances. + + The left instance. + The right instance. + The result of the operation. + + + + Subtracts two instances. + + The left instance. + The right instance. + The result of the operation. + + + + Negates an instance. + + The instance. + The result of the operation. + + + + Multiplies an instance by a scalar. + + The instance. + The scalar. + The result of the operation. + + + + Multiply an instance by a scalar. + + The scalar. + The instance. + The result of the operation. + + + + Divides an instance by a scalar. + + The instance. + The scalar. + The result of the operation. + + + + Compares two instances for equality. + + The left instance. + The right instance. + True, if both instances are equal; false otherwise. + + + + Compares two instances for ienquality. + + The left instance. + The right instance. + True, if the instances are not equal; false otherwise. + + + Converts OpenTK.Vector2 to OpenTK.Vector2d. + The Vector2 to convert. + The resulting Vector2d. + + + Converts OpenTK.Vector2d to OpenTK.Vector2. + The Vector2d to convert. + The resulting Vector2. + + + + Returns a System.String that represents the current instance. + + + + + + Returns the hashcode for this instance. + + A System.Int32 containing the unique hashcode for this instance. + + + + Indicates whether this instance and a specified object are equal. + + The object to compare to. + True if the instances are equal; false otherwise. + + + Indicates whether the current vector is equal to another vector. + A vector to compare with this vector. + true if the current vector is equal to the vector parameter; otherwise, false. + + + + Gets the length (magnitude) of the vector. + + + + + + Gets the square of the vector length (magnitude). + + + This property avoids the costly square root operation required by the Length property. This makes it more suitable + for comparisons. + + + + + + Gets the perpendicular vector on the right side of this vector. + + + + + Gets the perpendicular vector on the left side of this vector. + + + + + Provides a simple OpenGL control allowing quick development of Windows.Forms-based + OpenGL applications. Relies on OpenTK.GLControl for cross-platform compatibility. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Constructor. Creates contexts and sets properties. + + + + + + + + + + Sends an see cref="UserControl.Invalidate" command to this control, thus + forcing a redraw to occur. + + + + + Creates the OpenGL contexts. + + + + + Paints the control. + + The paint event arguments. + + + + Loads the bitmap from the assembly's manifest resource. + + + + + Initializes the control's styles. + + + + + Gets the number of logical pixels or dots per inch (dpi) in X-direction + + + + + Gets the number of logical pixels or dots per inch (dpi) in Y-direction + + + + + Gets and sets the OpenGL control's accumulation buffer depth. + + + + + Gets and sets the OpenGL control's color buffer depth. + + + + + Gets and sets the OpenGL control's depth buffer (Z-buffer) depth. + + + + + Gets and sets the OpenGL control's stencil buffer depth. + + + + + Gets and sets the OpenGL control's automatic sending of a glGetError command + after drawing. + + + + + Gets and sets the OpenGL control's automatic sending of a glFinish command + after drawing. + + + + + Gets and sets the OpenGL control's automatic forcing of the rendering context to + be current before drawing. + + + + + Gets and sets the OpenGL control's automatic sending of a SwapBuffers command + after drawing. + + + + + Overrides the control's class style parameters. + + + + + Provides access to the OpenAL effects extension. + + + + (Helper) Selects the Effect type used by this Effect handle. + Effect id returned from a successful call to GenEffects. + Effect type. + + + (Helper) Selects the Effect type used by this Effect handle. + Effect id returned from a successful call to GenEffects. + Effect type. + + + (Helper) reroutes the output of a Source through a Filter. + A valid Source handle. + A valid Filter handle. + + + (Helper) reroutes the output of a Source through a Filter. + A valid Source handle. + A valid Filter handle. + + + (Helper) Attaches an Effect to an Auxiliary Effect Slot. + The slot handle to attach the Effect to. + The Effect handle that is being attached. + + + (Helper) Attaches an Effect to an Auxiliary Effect Slot. + The slot handle to attach the Effect to. + The Effect handle that is being attached. + + + (Helper) Reroutes a Source's output into an Auxiliary Effect Slot. + The Source handle who's output is forwarded. + The Auxiliary Effect Slot handle that receives input from the Source. + Every Source has only a limited number of slots it can feed buffer to. The number must stay below AlcContextAttributes.EfxMaxAuxiliarySends + Filter handle to be attached between Source ouput and Auxiliary Slot input. Use 0 or EfxFilterType.FilterNull for no filter. + + + (Helper) Reroutes a Source's output into an Auxiliary Effect Slot. + The Source handle who's output is forwarded. + The Auxiliary Effect Slot handle that receives input from the Source. + Every Source has only a limited number of slots it can feed buffer to. The number must stay below AlcContextAttributes.EfxMaxAuxiliarySends + Filter handle to be attached between Source ouput and Auxiliary Slot input. Use 0 or EfxFilterType.FilterNull for no filter. + + + The GenEffects function is used to create one or more Effect objects. An Effect object stores an effect type and a set of parameter values to control that Effect. In order to use an Effect it must be attached to an Auxiliary Effect Slot object + After creation an Effect has no type (EfxEffectType.Null), so before it can be used to store a set of parameters, the application must specify what type of effect should be stored in the object, using Effect() with EfxEffecti. + Number of Effects to be created. + Pointer addressing sufficient memory to store n Effect object identifiers. + + + The GenEffects function is used to create one or more Effect objects. An Effect object stores an effect type and a set of parameter values to control that Effect. In order to use an Effect it must be attached to an Auxiliary Effect Slot object + After creation an Effect has no type (EfxEffectType.Null), so before it can be used to store a set of parameters, the application must specify what type of effect should be stored in the object, using Effect() with EfxEffecti. + Number of Effects to be created. + Pointer addressing sufficient memory to store n Effect object identifiers. + + + Generates one or more effect objects. + Number of Effect object identifiers to generate. + + The GenEffects function is used to create one or more Effect objects. An Effect object stores an effect type and a set of parameter values to control that Effect. In order to use an Effect it must be attached to an Auxiliary Effect Slot object. + After creation an Effect has no type (EfxEffectType.Null), so before it can be used to store a set of parameters, the application must specify what type of effect should be stored in the object, using Effect() with EfxEffecti. + + + + Generates a single effect object. + A handle to the generated effect object. + + The GenEffects function is used to create one or more Effect objects. An Effect object stores an effect type and a set of parameter values to control that Effect. In order to use an Effect it must be attached to an Auxiliary Effect Slot object. + After creation an Effect has no type (EfxEffectType.Null), so before it can be used to store a set of parameters, the application must specify what type of effect should be stored in the object, using Effect() with EfxEffecti. + + + + Generates a single effect object. + A handle to the generated effect object. + + + The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects. + Number of Effects to be deleted. + Pointer to n Effect object identifiers. + + + The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects. + Number of Effects to be deleted. + Pointer to n Effect object identifiers. + + + The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects. + Pointer to n Effect object identifiers. + + + The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects. + Pointer to n Effect object identifiers. + + + This function deletes one Effect only. + Pointer to an effect name/handle identifying the Effect Object to be deleted. + + + This function deletes one Effect only. + Pointer to an effect name/handle identifying the Effect Object to be deleted. + + + The IsEffect function is used to determine if an object identifier is a valid Effect object. + Effect identifier to validate. + True if the identifier is a valid Effect, False otherwise. + + + The IsEffect function is used to determine if an object identifier is a valid Effect object. + Effect identifier to validate. + True if the identifier is a valid Effect, False otherwise. + + + This function is used to set integer properties on Effect objects. + Effect object identifier. + Effect property to set. + Integer value. + + + This function is used to set integer properties on Effect objects. + Effect object identifier. + Effect property to set. + Integer value. + + + This function is used to set floating-point properties on Effect objects. + Effect object identifier. + Effect property to set. + Floating-point value. + + + This function is used to set floating-point properties on Effect objects. + Effect object identifier. + Effect property to set. + Floating-point value. + + + This function is used to set 3 floating-point properties on Effect objects. + Effect object identifier. + Effect property to set. + Pointer to Math.Vector3. + + + This function is used to set 3 floating-point properties on Effect objects. + Effect object identifier. + Effect property to set. + Pointer to Math.Vector3. + + + This function is used to retrieve integer properties from Effect objects. + Effect object identifier. + Effect property to retrieve. + Address where integer value will be stored. + + + This function is used to retrieve integer properties from Effect objects. + Effect object identifier. + Effect property to retrieve. + Address where integer value will be stored. + + + This function is used to retrieve floating-point properties from Effect objects. + Effect object identifier. + Effect property to retrieve. + Address where floating-point value will be stored. + + + This function is used to retrieve floating-point properties from Effect objects. + Effect object identifier. + Effect property to retrieve. + Address where floating-point value will be stored. + + + This function is used to retrieve 3 floating-point properties from Effect objects. + Effect object identifier. + Effect property to retrieve. + A Math.Vector3 to hold the values. + + + This function is used to retrieve 3 floating-point properties from Effect objects. + Effect object identifier. + Effect property to retrieve. + A Math.Vector3 to hold the values. + + + The GenFilters function is used to create one or more Filter objects. A Filter object stores a filter type and a set of parameter values to control that Filter. Filter objects can be attached to Sources as Direct Filters or Auxiliary Send Filters. + After creation a Filter has no type (EfxFilterType.Null), so before it can be used to store a set of parameters, the application must specify what type of filter should be stored in the object, using Filter() with EfxFilteri. + Number of Filters to be created. + Pointer addressing sufficient memory to store n Filter object identifiers. + + + The GenFilters function is used to create one or more Filter objects. A Filter object stores a filter type and a set of parameter values to control that Filter. Filter objects can be attached to Sources as Direct Filters or Auxiliary Send Filters. + After creation a Filter has no type (EfxFilterType.Null), so before it can be used to store a set of parameters, the application must specify what type of filter should be stored in the object, using Filter() with EfxFilteri. + Number of Filters to be created. + Pointer addressing sufficient memory to store n Filter object identifiers. + + + The GenFilters function is used to create one or more Filter objects. A Filter object stores a filter type and a set of parameter values to control that Filter. Filter objects can be attached to Sources as Direct Filters or Auxiliary Send Filters. + After creation a Filter has no type (EfxFilterType.Null), so before it can be used to store a set of parameters, the application must specify what type of filter should be stored in the object, using Filter() with EfxFilteri. + Number of Filters to be created. + Pointer addressing sufficient memory to store n Filter object identifiers. + + + This function generates only one Filter. + Storage Int32 for the new filter name/handle. + + + This function generates only one Filter. + Storage UInt32 for the new filter name/handle. + + + The DeleteFilters function is used to delete and free resources for Filter objects previously created with GenFilters. + Number of Filters to be deleted. + Pointer to n Filter object identifiers. + + + The DeleteFilters function is used to delete and free resources for Filter objects previously created with GenFilters. + Number of Filters to be deleted. + Pointer to n Filter object identifiers. + + + This function deletes one Filter only. + Pointer to an filter name/handle identifying the Filter Object to be deleted. + + + This function deletes one Filter only. + Pointer to an filter name/handle identifying the Filter Object to be deleted. + + + This function deletes one Filter only. + Pointer to an filter name/handle identifying the Filter Object to be deleted. + + + This function deletes one Filter only. + Pointer to an filter name/handle identifying the Filter Object to be deleted. + + + The IsFilter function is used to determine if an object identifier is a valid Filter object. + Effect identifier to validate. + True if the identifier is a valid Filter, False otherwise. + + + The IsFilter function is used to determine if an object identifier is a valid Filter object. + Effect identifier to validate. + True if the identifier is a valid Filter, False otherwise. + + + This function is used to set integer properties on Filter objects. + Filter object identifier. + Effect property to set. + Integer value. + + + This function is used to set integer properties on Filter objects. + Filter object identifier. + Effect property to set. + Integer value. + + + This function is used to set floating-point properties on Filter objects. + Filter object identifier. + Effect property to set. + Floating-point value. + + + This function is used to set floating-point properties on Filter objects. + Filter object identifier. + Effect property to set. + Floating-point value. + + + This function is used to retrieve integer properties from Filter objects. + Filter object identifier. + Effect property to retrieve. + Address where integer value will be stored. + + + This function is used to retrieve integer properties from Filter objects. + Filter object identifier. + Effect property to retrieve. + Address where integer value will be stored. + + + This function is used to retrieve floating-point properties from Filter objects. + Filter object identifier. + Effect property to retrieve. + Address where floating-point value will be stored. + + + This function is used to retrieve floating-point properties from Filter objects. + Filter object identifier. + Effect property to retrieve. + Address where floating-point value will be stored. + + + The GenAuxiliaryEffectSlots function is used to create one or more Auxiliary Effect Slots. The number of slots that can be created will be dependant upon the Open AL device used. + An application should check the OpenAL error state after making this call to determine if the Effect Slot was successfully created. If the function call fails then none of the requested Effect Slots are created. A good strategy for creating any OpenAL object is to use a for-loop and generate one object each loop iteration and then check for an error condition. If an error is set then the loop can be broken and the application can determine if sufficient resources are available. + Number of Auxiliary Effect Slots to be created. + Pointer addressing sufficient memory to store n Effect Slot object identifiers. + + + The GenAuxiliaryEffectSlots function is used to create one or more Auxiliary Effect Slots. The number of slots that can be created will be dependant upon the Open AL device used. + An application should check the OpenAL error state after making this call to determine if the Effect Slot was successfully created. If the function call fails then none of the requested Effect Slots are created. A good strategy for creating any OpenAL object is to use a for-loop and generate one object each loop iteration and then check for an error condition. If an error is set then the loop can be broken and the application can determine if sufficient resources are available. + Number of Auxiliary Effect Slots to be created. + Pointer addressing sufficient memory to store n Effect Slot object identifiers. + + + The GenAuxiliaryEffectSlots function is used to create one or more Auxiliary Effect Slots. The number of slots that can be created will be dependant upon the Open AL device used. + An application should check the OpenAL error state after making this call to determine if the Effect Slot was successfully created. If the function call fails then none of the requested Effect Slots are created. A good strategy for creating any OpenAL object is to use a for-loop and generate one object each loop iteration and then check for an error condition. If an error is set then the loop can be broken and the application can determine if sufficient resources are available. + Number of Auxiliary Effect Slots to be created. + Pointer addressing sufficient memory to store n Effect Slot object identifiers. + + + This function generates only one Auxiliary Effect Slot. + Storage Int32 for the new auxiliary effect slot name/handle. + + + This function generates only one Auxiliary Effect Slot. + Storage UInt32 for the new auxiliary effect slot name/handle. + + + The DeleteAuxiliaryEffectSlots function is used to delete and free resources for Auxiliary Effect Slots previously created with GenAuxiliaryEffectSlots. + Number of Auxiliary Effect Slots to be deleted. + Pointer to n Effect Slot object identifiers. + + + The DeleteAuxiliaryEffectSlots function is used to delete and free resources for Auxiliary Effect Slots previously created with GenAuxiliaryEffectSlots. + Number of Auxiliary Effect Slots to be deleted. + Pointer to n Effect Slot object identifiers. + + + The DeleteAuxiliaryEffectSlots function is used to delete and free resources for Auxiliary Effect Slots previously created with GenAuxiliaryEffectSlots. + Pointer to n Effect Slot object identifiers. + + + This function deletes one AuxiliaryEffectSlot only. + Pointer to an auxiliary effect slot name/handle identifying the Auxiliary Effect Slot Object to be deleted. + + + This function deletes one AuxiliaryEffectSlot only. + Pointer to an auxiliary effect slot name/handle identifying the Auxiliary Effect Slot Object to be deleted. + + + This function deletes one AuxiliaryEffectSlot only. + Pointer to an auxiliary effect slot name/handle identifying the Auxiliary Effect Slot Object to be deleted. + + + The IsAuxiliaryEffectSlot function is used to determine if an object identifier is a valid Auxiliary Effect Slot object. + Effect Slot object identifier to validate. + True if the identifier is a valid Auxiliary Effect Slot, False otherwise. + + + The IsAuxiliaryEffectSlot function is used to determine if an object identifier is a valid Auxiliary Effect Slot object. + Effect Slot object identifier to validate. + True if the identifier is a valid Auxiliary Effect Slot, False otherwise. + + + This function is used to set integer properties on Auxiliary Effect Slot objects. + Auxiliary Effect Slot object identifier. + Auxiliary Effect Slot property to set. + Integer value. + + + This function is used to set integer properties on Auxiliary Effect Slot objects. + Auxiliary Effect Slot object identifier. + Auxiliary Effect Slot property to set. + Integer value. + + + This function is used to set floating-point properties on Auxiliary Effect Slot objects. + Auxiliary Effect Slot object identifier. + Auxiliary Effect Slot property to set. + Floating-point value. + + + This function is used to set floating-point properties on Auxiliary Effect Slot objects. + Auxiliary Effect Slot object identifier. + Auxiliary Effect Slot property to set. + Floating-point value. + + + This function is used to retrieve integer properties on Auxiliary Effect Slot objects. + Auxiliary Effect Slot object identifier. + Auxiliary Effect Slot property to retrieve. + Address where integer value will be stored. + + + This function is used to retrieve integer properties on Auxiliary Effect Slot objects. + Auxiliary Effect Slot object identifier. + Auxiliary Effect Slot property to retrieve. + Address where integer value will be stored. + + + This function is used to retrieve floating properties on Auxiliary Effect Slot objects. + Auxiliary Effect Slot object identifier. + Auxiliary Effect Slot property to retrieve. + Address where floating-point value will be stored. + + + This function is used to retrieve floating properties on Auxiliary Effect Slot objects. + Auxiliary Effect Slot object identifier. + Auxiliary Effect Slot property to retrieve. + Address where floating-point value will be stored. + + + + Constructs a new EffectsExtension instance. + + + + Returns True if the EFX Extension has been found and could be initialized. + + + EAX Reverb Presets in legacy format - use ConvertReverbParameters() to convert to EFX EAX Reverb Presets for use with the OpenAL Effects Extension. + + + + Defines available context attributes. + + + + Followed by System.Int32 Hz + + + Followed by System.Int32 Hz + + + Followed by AlBoolean.True, or AlBoolean.False + + + Followed by System.Int32 Num of requested Mono (3D) Sources + + + Followed by System.Int32 Num of requested Stereo Sources + + + (EFX Extension) This Context property can be passed to OpenAL during Context creation (alcCreateContext) to request a maximum number of Auxiliary Sends desired on each Source. It is not guaranteed that the desired number of sends will be available, so an application should query this property after creating the context using alcGetIntergerv. Default: 2 + + + + Defines OpenAL context errors. + + + + There is no current error. + + + No Device. The device handle or specifier names an inaccessible driver/server. + + + Invalid context ID. The Context argument does not name a valid context. + + + Bad enum. A token used is not valid, or not applicable. + + + Bad value. A value (e.g. Attribute) is not valid, or not applicable. + + + Out of memory. Unable to allocate memory. + + + + Defines available parameters for . + + + + The specifier string for the default device. + + + A list of available context extensions separated by spaces. + + + The name of the default capture device + + + a list of the default devices. + + + Will only return the first Device, not a list. Use AlcGetStringList.CaptureDeviceSpecifier. ALC_EXT_CAPTURE_EXT + + + Will only return the first Device, not a list. Use AlcGetStringList.DeviceSpecifier + + + Will only return the first Device, not a list. Use AlcGetStringList.AllDevicesSpecifier + + + + Defines available parameters for . + + + + The name of the specified capture device, or a list of all available capture devices if no capture device is specified. ALC_EXT_CAPTURE_EXT + + + The specifier strings for all available devices. ALC_ENUMERATION_EXT + + + The specifier strings for all available devices. ALC_ENUMERATE_ALL_EXT + + + + Defines available parameters for . + + + + The specification revision for this implementation (major version). NULL is an acceptable device. + + + The specification revision for this implementation (minor version). NULL is an acceptable device. + + + The size (number of ALCint values) required for a zero-terminated attributes list, for the current context. NULL is an invalid device. + + + Expects a destination of ALC_ATTRIBUTES_SIZE, and provides an attribute list for the current context of the specified device. NULL is an invalid device. + + + The number of capture samples available. NULL is an invalid device. + + + (EFX Extension) This property can be used by the application to retrieve the Major version number of the Effects Extension supported by this OpenAL implementation. As this is a Context property is should be retrieved using alcGetIntegerv. + + + (EFX Extension) This property can be used by the application to retrieve the Minor version number of the Effects Extension supported by this OpenAL implementation. As this is a Context property is should be retrieved using alcGetIntegerv. + + + (EFX Extension) This Context property can be passed to OpenAL during Context creation (alcCreateContext) to request a maximum number of Auxiliary Sends desired on each Source. It is not guaranteed that the desired number of sends will be available, so an application should query this property after creating the context using alcGetIntergerv. Default: 2 + + + + Represents a 3D vector using three double-precision floating-point numbers. + + + + + The X component of the Vector3. + + + + + The Y component of the Vector3. + + + + + The Z component of the Vector3. + + + + + Constructs a new Vector3. + + The x component of the Vector3. + The y component of the Vector3. + The z component of the Vector3. + + + + Constructs a new instance from the given Vector2d. + + The Vector2d to copy components from. + + + + Constructs a new instance from the given Vector3d. + + The Vector3d to copy components from. + + + + Constructs a new instance from the given Vector4d. + + The Vector4d to copy components from. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Multiply this instance by a scalar. + Scalar operand. + + + Divide this instance by a scalar. + Scalar operand. + + + + Scales the Vector3d to unit length. + + + + + Scales the Vector3d to approximately unit length. + + + + + Scales the current Vector3d by the given amounts. + + The scale of the X component. + The scale of the Y component. + The scale of the Z component. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + + Defines a unit-length Vector3d that points towards the X-axis. + + + + + Defines a unit-length Vector3d that points towards the Y-axis. + + + + + /// Defines a unit-length Vector3d that points towards the Z-axis. + + + + + Defines a zero-length Vector3. + + + + + Defines an instance with all components set to 1. + + + + + Defines the size of the Vector3d struct in bytes. + + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Returns the Vector3d with the minimum magnitude + + Left operand + Right operand + The minimum Vector3 + + + + Returns the Vector3d with the minimum magnitude + + Left operand + Right operand + The minimum Vector3 + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Calculate the dot (scalar) product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Calculate the dot (scalar) product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Caclulate the cross (vector) product of two vectors + + First operand + Second operand + The cross product of the two inputs + + + + Caclulate the cross (vector) product of two vectors + + First operand + Second operand + The cross product of the two inputs + The cross product of the two inputs + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Interpolate 3 Vectors using Barycentric coordinates + + First input Vector + Second input Vector + Third input Vector + First Barycentric Coordinate + Second Barycentric Coordinate + a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + Interpolate 3 Vectors using Barycentric coordinates + First input Vector. + Second input Vector. + Third input Vector. + First Barycentric Coordinate. + Second Barycentric Coordinate. + Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + Transform a direction vector by the given Matrix + Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored. + + The vector to transform + The desired transformation + The transformed vector + + + Transform a direction vector by the given Matrix + Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored. + + The vector to transform + The desired transformation + The transformed vector + + + Transform a Normal by the given Matrix + + This calculates the inverse of the given matrix, use TransformNormalInverse if you + already have the inverse to avoid this extra calculation + + The normal to transform + The desired transformation + The transformed normal + + + Transform a Normal by the given Matrix + + This calculates the inverse of the given matrix, use TransformNormalInverse if you + already have the inverse to avoid this extra calculation + + The normal to transform + The desired transformation + The transformed normal + + + Transform a Normal by the (transpose of the) given Matrix + + This version doesn't calculate the inverse matrix. + Use this version if you already have the inverse of the desired transform to hand + + The normal to transform + The inverse of the desired transformation + The transformed normal + + + Transform a Normal by the (transpose of the) given Matrix + + This version doesn't calculate the inverse matrix. + Use this version if you already have the inverse of the desired transform to hand + + The normal to transform + The inverse of the desired transformation + The transformed normal + + + Transform a Position by the given Matrix + The position to transform + The desired transformation + The transformed position + + + Transform a Position by the given Matrix + The position to transform + The desired transformation + The transformed position + + + Transform a Vector by the given Matrix + The vector to transform + The desired transformation + The transformed vector + + + Transform a Vector by the given Matrix + The vector to transform + The desired transformation + The transformed vector + + + + Transform a Vector3d by the given Matrix, and project the resulting Vector4 back to a Vector3 + + The vector to transform + The desired transformation + The transformed vector + + + Transform a Vector3d by the given Matrix, and project the resulting Vector4d back to a Vector3d + The vector to transform + The desired transformation + The transformed vector + + + + Calculates the angle (in radians) between two vectors. + + The first vector. + The second vector. + Angle (in radians) between the vectors. + Note that the returned angle is never bigger than the constant Pi. + + + Calculates the angle (in radians) between two vectors. + The first vector. + The second vector. + Angle (in radians) between the vectors. + Note that the returned angle is never bigger than the constant Pi. + + + Converts OpenTK.Vector3 to OpenTK.Vector3d. + The Vector3 to convert. + The resulting Vector3d. + + + Converts OpenTK.Vector3d to OpenTK.Vector3. + The Vector3d to convert. + The resulting Vector3. + + + + Returns a System.String that represents the current Vector3. + + + + + + Returns the hashcode for this instance. + + A System.Int32 containing the unique hashcode for this instance. + + + + Indicates whether this instance and a specified object are equal. + + The object to compare to. + True if the instances are equal; false otherwise. + + + Indicates whether the current vector is equal to another vector. + A vector to compare with this vector. + true if the current vector is equal to the vector parameter; otherwise, false. + + + + Gets the length (magnitude) of the vector. + + + + + + + Gets an approximation of the vector length (magnitude). + + + This property uses an approximation of the square root function to calculate vector magnitude, with + an upper error bound of 0.001. + + + + + + + Gets the square of the vector length (magnitude). + + + This property avoids the costly square root operation required by the Length property. This makes it more suitable + for comparisons. + + + + + + + Gets or sets an OpenTK.Vector2d with the X and Y components of this instance. + + + + + Represents a Quaternion. + + + + + Construct a new Quaternion from vector and w components + + The vector part + The w part + + + + Construct a new Quaternion + + The x component + The y component + The z component + The w component + + + + Convert the current quaternion to axis angle representation + + The resultant axis + The resultant angle + + + + Convert this instance to an axis-angle representation. + + A Vector4 that is the axis-angle representation of this quaternion. + + + + Scales the Quaternion to unit length. + + + + + Convert this quaternion to its conjugate + + + + + Defines the identity quaternion. + + + + + Add two quaternions + + The first operand + The second operand + The result of the addition + + + + Add two quaternions + + The first operand + The second operand + The result of the addition + + + + Subtracts two instances. + + The left instance. + The right instance. + The result of the operation. + + + + Subtracts two instances. + + The left instance. + The right instance. + The result of the operation. + + + + Get the conjugate of the given quaternion + + The quaternion + The conjugate of the given quaternion + + + + Get the conjugate of the given quaternion + + The quaternion + The conjugate of the given quaternion + + + + Get the inverse of the given quaternion + + The quaternion to invert + The inverse of the given quaternion + + + + Get the inverse of the given quaternion + + The quaternion to invert + The inverse of the given quaternion + + + + Scale the given quaternion to unit length + + The quaternion to normalize + The normalized quaternion + + + + Scale the given quaternion to unit length + + The quaternion to normalize + The normalized quaternion + + + + Build a quaternion from the given axis and angle + + The axis to rotate about + The rotation angle in radians + + + + + Do Spherical linear interpolation between two quaternions + + The first quaternion + The second quaternion + The blend factor + A smooth blend between the given quaternions + + + + Returns a System.String that represents the current Quaternion. + + + + + + Compares this object instance to another object for equality. + + The other object to be used in the comparison. + True if both objects are Quaternions of equal value. Otherwise it returns false. + + + + Provides the hash code for this object. + + A hash code formed from the bitwise XOR of this objects members. + + + + Compares this Quaternion instance to another Quaternion for equality. + + The other Quaternion to be used in the comparison. + True if both instances are equal; false otherwise. + + + + Gets or sets an OpenTK.Vector3 with the X, Y and Z components of this instance. + + + + + Gets or sets an OpenTK.Vector3 with the X, Y and Z components of this instance. + + + + + Gets or sets the X component of this instance. + + + + + Gets or sets the Y component of this instance. + + + + + Gets or sets the Z component of this instance. + + + + + Gets or sets the W component of this instance. + + + + + Gets the length (magnitude) of the quaternion. + + + + + + Gets the square of the quaternion length (magnitude). + + + + + Holds the results of a text measurement. + + + + + Frees the resources consumed by this TextExtents instance. + + + + + Gets the bounding box of the measured text. + + + + + Gets the extents of each glyph in the measured text. + + The index of the glyph. + The extents of the specified glyph. + + + + Gets the extents of each glyph in the measured text. + + + + + Gets the number of the measured glyphs. + + + + + Checks whether the specified stream contains valid WAVE/RIFF buffer. + + The System.IO.Stream to check. + True if the stream is a valid WAVE/RIFF file; false otherwise. + + + + Reads and decodes the specified number of samples from the sound stream. + + The number of samples to read and decode. + An OpenTK.Audio.SoundData object that contains the decoded buffer. + + + + Reads and decodes the sound stream. + + An OpenTK.Audio.SoundData object that contains the decoded buffer. + + + Represents a 4D vector using four double-precision floating-point numbers. + + + + The X component of the Vector4d. + + + + + The Y component of the Vector4d. + + + + + The Z component of the Vector4d. + + + + + The W component of the Vector4d. + + + + + Defines a unit-length Vector4d that points towards the X-axis. + + + + + Defines a unit-length Vector4d that points towards the Y-axis. + + + + + Defines a unit-length Vector4d that points towards the Z-axis. + + + + + Defines a unit-length Vector4d that points towards the W-axis. + + + + + Defines a zero-length Vector4d. + + + + + Defines an instance with all components set to 1. + + + + + Defines the size of the Vector4d struct in bytes. + + + + + Constructs a new Vector4d. + + The x component of the Vector4d. + The y component of the Vector4d. + The z component of the Vector4d. + The w component of the Vector4d. + + + + Constructs a new Vector4d from the given Vector2d. + + The Vector2d to copy components from. + + + + Constructs a new Vector4d from the given Vector3d. + + The Vector3d to copy components from. + + + + Constructs a new Vector4d from the specified Vector3d and w component. + + The Vector3d to copy components from. + The w component of the new Vector4. + + + + Constructs a new Vector4d from the given Vector4d. + + The Vector4d to copy components from. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Multiply this instance by a scalar. + Scalar operand. + + + Divide this instance by a scalar. + Scalar operand. + + + + Scales the Vector4d to unit length. + + + + + Scales the Vector4d to approximately unit length. + + + + + Scales the current Vector4d by the given amounts. + + The scale of the X component. + The scale of the Y component. + The scale of the Z component. + The scale of the Z component. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Calculate the dot product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Calculate the dot product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Interpolate 3 Vectors using Barycentric coordinates + + First input Vector + Second input Vector + Third input Vector + First Barycentric Coordinate + Second Barycentric Coordinate + a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + Interpolate 3 Vectors using Barycentric coordinates + First input Vector. + Second input Vector. + Third input Vector. + First Barycentric Coordinate. + Second Barycentric Coordinate. + Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + Transform a Vector by the given Matrix + The vector to transform + The desired transformation + The transformed vector + + + Transform a Vector by the given Matrix + The vector to transform + The desired transformation + The transformed vector + + + Converts OpenTK.Vector4 to OpenTK.Vector4d. + The Vector4 to convert. + The resulting Vector4d. + + + Converts OpenTK.Vector4d to OpenTK.Vector4. + The Vector4d to convert. + The resulting Vector4. + + + + Returns a System.String that represents the current Vector4d. + + + + + + Returns the hashcode for this instance. + + A System.Int32 containing the unique hashcode for this instance. + + + + Indicates whether this instance and a specified object are equal. + + The object to compare to. + True if the instances are equal; false otherwise. + + + Indicates whether the current vector is equal to another vector. + A vector to compare with this vector. + true if the current vector is equal to the vector parameter; otherwise, false. + + + + Gets the length (magnitude) of the vector. + + + + + + + Gets an approximation of the vector length (magnitude). + + + This property uses an approximation of the square root function to calculate vector magnitude, with + an upper error bound of 0.001. + + + + + + + Gets the square of the vector length (magnitude). + + + This property avoids the costly square root operation required by the Length property. This makes it more suitable + for comparisons. + + + + + + Gets or sets an OpenTK.Vector2d with the X and Y components of this instance. + + + + + Gets or sets an OpenTK.Vector3d with the X, Y and Z components of this instance. + + + + + Represents a 4x4 Matrix with double-precision components. + + + + + Top row of the matrix + + + + + 2nd row of the matrix + + + + + 3rd row of the matrix + + + + + Bottom row of the matrix + + + + + The identity matrix + + + + + Constructs a new instance. + + Top row of the matrix + Second row of the matrix + Third row of the matrix + Bottom row of the matrix + + + + Constructs a new instance. + + First item of the first row. + Second item of the first row. + Third item of the first row. + Fourth item of the first row. + First item of the second row. + Second item of the second row. + Third item of the second row. + Fourth item of the second row. + First item of the third row. + Second item of the third row. + Third item of the third row. + First item of the third row. + Fourth item of the fourth row. + Second item of the fourth row. + Third item of the fourth row. + Fourth item of the fourth row. + + + + Creates a translation matrix. + + X translation. + Y translation. + Z translation. + The resulting Matrix4d instance. + + + + Creates a translation matrix. + + The translation vector. + The resulting Matrix4d instance. + + + + Creates a translation matrix. + + X translation. + Y translation. + Z translation. + The resulting Matrix4d instance. + + + + Creates a translation matrix. + + The translation vector. + The resulting Matrix4d instance. + + + + Creates an orthographic projection matrix. + + The width of the projection volume. + The height of the projection volume. + The near edge of the projection volume. + The far edge of the projection volume. + The resulting Matrix4d instance. + + + + Creates an orthographic projection matrix. + + The width of the projection volume. + The height of the projection volume. + The near edge of the projection volume. + The far edge of the projection volume. + The resulting Matrix4d instance. + + + + Creates an orthographic projection matrix. + + The left edge of the projection volume. + The right edge of the projection volume. + The bottom edge of the projection volume. + The top edge of the projection volume. + The near edge of the projection volume. + The far edge of the projection volume. + The resulting Matrix4d instance. + + + + Creates an orthographic projection matrix. + + The left edge of the projection volume. + The right edge of the projection volume. + The bottom edge of the projection volume. + The top edge of the projection volume. + The near edge of the projection volume. + The far edge of the projection volume. + The resulting Matrix4d instance. + + + + Build a translation matrix with the given translation + + The vector to translate along + A Translation matrix + + + + Build a translation matrix with the given translation + + X translation + Y translation + Z translation + A Translation matrix + + + + Build a scaling matrix + + Single scale factor for x,y and z axes + A scaling matrix + + + + Build a scaling matrix + + Scale factors for x,y and z axes + A scaling matrix + + + + Build a scaling matrix + + Scale factor for x-axis + Scale factor for y-axis + Scale factor for z-axis + A scaling matrix + + + + Build a rotation matrix that rotates about the x-axis + + angle in radians to rotate counter-clockwise around the x-axis + A rotation matrix + + + + Build a rotation matrix that rotates about the y-axis + + angle in radians to rotate counter-clockwise around the y-axis + A rotation matrix + + + + Build a rotation matrix that rotates about the z-axis + + angle in radians to rotate counter-clockwise around the z-axis + A rotation matrix + + + + Build a rotation matrix to rotate about the given axis + + the axis to rotate about + angle in radians to rotate counter-clockwise (looking in the direction of the given axis) + A rotation matrix + + + + Build a rotation matrix from a quaternion + + the quaternion + A rotation matrix + + + + Build a world space to camera space matrix + + Eye (camera) position in world space + Target position in world space + Up vector in world space (should not be parallel to the camera direction, that is target - eye) + A Matrix that transforms world space to camera space + + + + Build a world space to camera space matrix + + Eye (camera) position in world space + Eye (camera) position in world space + Eye (camera) position in world space + Target position in world space + Target position in world space + Target position in world space + Up vector in world space (should not be parallel to the camera direction, that is target - eye) + Up vector in world space (should not be parallel to the camera direction, that is target - eye) + Up vector in world space (should not be parallel to the camera direction, that is target - eye) + A Matrix4 that transforms world space to camera space + + + + Build a projection matrix + + Left edge of the view frustum + Right edge of the view frustum + Bottom edge of the view frustum + Top edge of the view frustum + Distance to the near clip plane + Distance to the far clip plane + A projection matrix that transforms camera space to raster space + + + + Build a projection matrix + + Angle of the field of view in the y direction (in radians) + Aspect ratio of the view (width / height) + Distance to the near clip plane + Distance to the far clip plane + A projection matrix that transforms camera space to raster space + + + + Multiplies two instances. + + The left operand of the multiplication. + The right operand of the multiplication. + A new instance that is the result of the multiplication + + + + Multiplies two instances. + + The left operand of the multiplication. + The right operand of the multiplication. + A new instance that is the result of the multiplication + + + + Calculate the inverse of the given matrix + + The matrix to invert + The inverse of the given matrix if it has one, or the input if it is singular + Thrown if the Matrix4d is singular. + + + + Calculate the transpose of the given matrix + + The matrix to transpose + The transpose of the given matrix + + + + Calculate the transpose of the given matrix + + The matrix to transpose + The result of the calculation + + + + Matrix multiplication + + left-hand operand + right-hand operand + A new Matrix44 which holds the result of the multiplication + + + + Returns a System.String that represents the current Matrix44. + + + + + + Returns the hashcode for this instance. + + A System.Int32 containing the unique hashcode for this instance. + + + + Indicates whether this instance and a specified object are equal. + + The object to compare to. + True if the instances are equal; false otherwise. + + + Indicates whether the current matrix is equal to another matrix. + An matrix to compare with this matrix. + true if the current matrix is equal to the matrix parameter; otherwise, false. + + + + The determinant of this matrix + + + + + The first column of this matrix + + + + + The second column of this matrix + + + + + The third column of this matrix + + + + + The fourth column of this matrix + + + + + Gets or sets the value at row 1, column 1 of this instance. + + + + + Gets or sets the value at row 1, column 2 of this instance. + + + + + Gets or sets the value at row 1, column 3 of this instance. + + + + + Gets or sets the value at row 1, column 4 of this instance. + + + + + Gets or sets the value at row 2, column 1 of this instance. + + + + + Gets or sets the value at row 2, column 2 of this instance. + + + + + Gets or sets the value at row 2, column 3 of this instance. + + + + + Gets or sets the value at row 2, column 4 of this instance. + + + + + Gets or sets the value at row 3, column 1 of this instance. + + + + + Gets or sets the value at row 3, column 2 of this instance. + + + + + Gets or sets the value at row 3, column 3 of this instance. + + + + + Gets or sets the value at row 3, column 4 of this instance. + + + + + Gets or sets the value at row 4, column 1 of this instance. + + + + + Gets or sets the value at row 4, column 3 of this instance. + + + + + Gets or sets the value at row 4, column 3 of this instance. + + + + + Gets or sets the value at row 4, column 4 of this instance. + + + + Represents a 4D vector using four single-precision floating-point numbers. + + The Vector4 structure is suitable for interoperation with unmanaged code requiring four consecutive floats. + + + + + The X component of the Vector4. + + + + + The Y component of the Vector4. + + + + + The Z component of the Vector4. + + + + + The W component of the Vector4. + + + + + Defines a unit-length Vector4 that points towards the X-axis. + + + + + Defines a unit-length Vector4 that points towards the Y-axis. + + + + + Defines a unit-length Vector4 that points towards the Z-axis. + + + + + Defines a unit-length Vector4 that points towards the W-axis. + + + + + Defines a zero-length Vector4. + + + + + Defines an instance with all components set to 1. + + + + + Defines the size of the Vector4 struct in bytes. + + + + + Constructs a new Vector4. + + The x component of the Vector4. + The y component of the Vector4. + The z component of the Vector4. + The w component of the Vector4. + + + + Constructs a new Vector4 from the given Vector2. + + The Vector2 to copy components from. + + + + Constructs a new Vector4 from the given Vector3. + + The Vector3 to copy components from. + + + + Constructs a new Vector4 from the specified Vector3 and w component. + + The Vector3 to copy components from. + The w component of the new Vector4. + + + + Constructs a new Vector4 from the given Vector4. + + The Vector4 to copy components from. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Multiply this instance by a scalar. + Scalar operand. + + + Divide this instance by a scalar. + Scalar operand. + + + + Scales the Vector4 to unit length. + + + + + Scales the Vector4 to approximately unit length. + + + + + Scales the current Vector4 by the given amounts. + + The scale of the X component. + The scale of the Y component. + The scale of the Z component. + The scale of the Z component. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Calculate the dot product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Calculate the dot product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Interpolate 3 Vectors using Barycentric coordinates + + First input Vector + Second input Vector + Third input Vector + First Barycentric Coordinate + Second Barycentric Coordinate + a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + Interpolate 3 Vectors using Barycentric coordinates + First input Vector. + Second input Vector. + Third input Vector. + First Barycentric Coordinate. + Second Barycentric Coordinate. + Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + Transform a Vector by the given Matrix + The vector to transform + The desired transformation + The transformed vector + + + Transform a Vector by the given Matrix + The vector to transform + The desired transformation + The transformed vector + + + + Returns a System.String that represents the current Vector4. + + + + + + Returns the hashcode for this instance. + + A System.Int32 containing the unique hashcode for this instance. + + + + Indicates whether this instance and a specified object are equal. + + The object to compare to. + True if the instances are equal; false otherwise. + + + Indicates whether the current vector is equal to another vector. + A vector to compare with this vector. + true if the current vector is equal to the vector parameter; otherwise, false. + + + + Gets the length (magnitude) of the vector. + + + + + + + Gets an approximation of the vector length (magnitude). + + + This property uses an approximation of the square root function to calculate vector magnitude, with + an upper error bound of 0.001. + + + + + + + Gets the square of the vector length (magnitude). + + + This property avoids the costly square root operation required by the Length property. This makes it more suitable + for comparisons. + + + + + + + Gets or sets an OpenTK.Vector2 with the X and Y components of this instance. + + + + + Gets or sets an OpenTK.Vector3 with the X, Y and Z components of this instance. + + + + + Provides text printing through OpenGL 1.5 vertex buffer objects. + + + + + Contains the necessary information to print text through the VboTextPrinter implementation. + + + + + Represents a handle to cached text. + + + + + Constructs a new TextHandle, + + + + + + Returns a System.String that represents the current TextHandle. + + a System.String that descibes the current TextHandle. + + + + Frees the resource consumed by the TextHandle. + + + + + Gets the handle of the cached text run. Call the OpenTK.Graphics.ITextPrinter.Draw() method + to draw the text represented by this TextHandle. + + + + + Gets the TextureFont used for this text run. + + + + + Defines the version of the Alut library. + + + + Defines the A in OpenAL A.B + + + Defines the B in OpenAL A.B + + + + Defines available alut error codes. + + + + No ALUT error found. + + + ALUT ran out of memory. + + + ALUT was given an invalid enumeration token. + + + ALUT was given an invalid value. + + + The operation is invalid in the current ALUT state. + + + There is no current AL context. + + + There was already an AL error on entry to an ALUT function. + + + There was already an ALC error on entry to an ALUT function. + + + There was an error opening the ALC device. + + + There was an error closing the ALC device. + + + There was an error creating an ALC context. + + + Could not change the current ALC context. + + + There was an error destroying the ALC context. + + + There was an error generating an AL buffer. + + + There was an error passing buffer buffer to AL. + + + I/O error, consult errno for more details. + + + Unsupported file type. + + + Unsupported mode within an otherwise usable file type. + + + The sound buffer was corrupt or truncated. + + + + Defines available alut waveform types. + + + + A sine waveform + + + A square waveform + + + A sawtooth waveform + + + A waveform containing white noise + + + A waveform containing an impusle + + + + Defines parameters for alut loaders. + + + + For the loaders returning sound buffer in an OpenAL buffer, e.g. Alut.CreateBufferFromFile and Alut.CreateBufferFromFileImage + + + For the loaders returning sound buffer in a newly allocated memory region, e.g. Alut.LoadMemoryFromFile and Alut.LoadMemoryFromFileImage. + + + + OpenAL binding for .NET, implementing AL 1.1. + + + Binds functions and definitions in OpenAL32.dll or libAL.so. + + + + + Specifies OpenAl's native library archive. + + + Specifies OpenAl32.dll everywhere; will be mapped via .config for mono. + + + + + Specifies the calling convention. + + + Specifies . + + + + + Bad value. + + + + + Disable value. + + + + + bool false. + + + + + bool true. + + + + + Indicates the type of AL_SOURCE. Sources can be spatialized. + + + + + Indicates source has listener-relative coordinates. + + + + + Directional source, inner cone angle, in degrees. The accepted range is 0 to + 360, the default value is 360. + + + + + Directional source, outer cone angle, in degrees. The accepted range is 0 to + 360, the default value is 360. + + + + + Specifies the pitch to be applied, either at source, or on mixer results, at + listener. The accepted range is 0.5 to 2.0, the default value is 1.0. + + + + + Specifies the current location in three dimensional space. OpenAL, like OpenGL, + uses a right-handed coordinate system, where in a frontal default view X (thumb) + points right, Y points up (index finger), and Z points towards the viewer/camera + (middle finger). To switch to a left-handed coordinate system, flip the sign on + the Z coordinate. Listener position is always in the world coordinate system. + + + + + Specifies the current direction as forward vector. + + + + + Specifies the current velocity in three dimensional space. + + + + + Indicates whether source has to loop infinitely. The accepted values are + or , the default value is + . + + + + + Indicates whether source is meant to be static. The accepted values are + or , the default value is + . + + + + + Indicates whether source is meant to be streaming. The accepted values are + or , the default value is + . + + + + + Indicates whether source is meant to be undetermined. The accepted values are + or , the default value is + . + + + + + Indicates the buffer to provide sound samples. The accepted range is any valid + buffer ID. + + + + + Indicates the gain (volume amplification) applied. The accepted range is 0.0 + or above. A value of 1.0 means unattenuated/unchanged. Each division by 2 equals + an attenuation of -6dB. Each multiplication by 2 equals an amplification of +6dB. + A value of 0.0 is meaningless with respect to a logarithmic scale; it is + interpreted as zero volume, the channel is effectively disabled. + + + + + Indicates minimum source attenuation. The accepted range is 0.0 to 1.0. + + + + + Indicates maximum source attenuation. The accepted range is 0.0 to 1.0. + + #define AL_MAX_GAIN 0x100E + + + + Specifies the current orientation. + + + + + byte offset into source (in canon format). -1 if source is not playing. Do not + set this, only get this value. The accepted range is 0.0 or above. The default + value is 1.0. + + + + + Indicates the rolloff factor for the source. The accepted range is 0.0 or + above. The default value is 1.0. + + + + + Indicates the gain (volume amplification) applied. The accepted range is 0.0 or + above. A value of 1.0 means unattenuated/unchanged. Each division by 2 equals an + attenuation of -6dB. Each multiplication by 2 equals an amplification of +6dB. + A value of 0.0 is meaningless with respect to a logarithmic scale; it is + interpreted as zero volume, the channel is effectively disabled. + + + + + Specifies the maximum distance. The accepted range is 0.0 or above. + + + + + Specifies the channel mask. The accepted range is 0 to 255. + + + + + Source state information. + + + + + Source initialized. + + + + + Source playing. + + + + + Source paused. + + + + + Source stopped. + + + + + Buffers are queued. + + + + + Buffers are processed. + + + + + Source buffer position information. + + + + + Source buffer position information. + + + + + Source buffer position information. + + + + + 8-bit mono buffer. + + + + + 16-bit mono buffer. + + + + + 8-bit stereo buffer. + + + + + 16-bit stereo buffer. + + + + + Buffer frequency, in units of Hertz (Hz). This is the number of samples per + second. Half of the sample frequency marks the maximum significant frequency + component. + + + + + Buffer bit depth. + + + + + Buffer channels. + + + + + Buffer size. + + + + + Buffer data. + + + + + Buffer unused. + + + + + Buffer queued. + + + + + Buffer pending. + + + + + Buffer current. + + + + + Buffer processed. + + + + + No error. + + + + + Illegal name passed as an argument to an AL call. + + + + + Illegal enum passed as an argument to an AL call. + + + + + Illegal enum passed as an argument to an AL call. + + + + + Illegal value passed as an argument to an AL call. Applies to parameter + values, but not to enumerations. + + + + + A function was called at an inappropriate time or in an inappropriate way, + causing an illegal state. This can be an incompatible value, object ID, and/or + function. + + + + + A function was called at an inappropriate time or in an inappropriate way, + causing an illegal state. This can be an incompatible value, object ID, and/or + function. + + + + + A function could not be completed, because there is not enough memory available. + + + + + Vendor name. + + + + + Version. + + + + + Renderer. + + + + + Extensions. + + + + + Doppler scale. The default value is 1.0. + + + + + Doppler velocity. The default value is 1.0. + + + + + Speed of Sound + + + + + Distance scaling. + + + + + Distance model. The default value is . + + + + + Inverse distance model. + + + + + Inverse distance clamped model. + + + + + + + + + + + + + + + + + + + + + + + + + Room. The accepted range is -10000 to 0. The default value is -10000. + + + + + Room high frequency. The accepted range is -10000 to 0. The default value is 0. + + + + + Room rolloff factor. The accepted range is 0.1 to 20.0. The default value is + 0.0. + + + + + Decay time. The accepted range is 0.1 to 20.0. The default value is 1.0. + + + + + Decay high frequency ratio. The accepted range is 0.1 to 2.0. The default value + is 0.5. + + + + + Reflections. The accepted range is -10000 to 1000. The default value is -10000. + + + + + Reflections delay. The accepted range is 0.0 to 0.3. The default value is 0.02. + + + + + Reverb. The accepted range is -10000 to 2000. The default value is -10000. + + + + + Reverb delay. The accepted range is 0.0 to 0.1. The default value is 0.04. + + + + + Diffusion. The accepted range is 0.0 to 100.0. The default value is 100.0. + + + + + Density. The accepted range is 0.0 to 100.0. The default value is 100.0. + + + + + High frequency reference. The accepted range is 20.0 to 20000.0. The default + value is 5000.0. + + + + * Chorus Parameters */ + + + * Distortion Parameters */ + + + * Echo Parameters */ + + + * Flanger Parameters */ + + + * Frequencyshifter Parameters */ + + + * Vocalmorpher Parameters */ + + + * Pitchshifter Parameters */ + + + * Ringmodulator Parameters */ + + + * Autowah Parameters */ + + + * Compressor Parameters */ + + + * Equalizer Parameters */ + + + * Highpass Parameters */ + + + * Bandpass Parameters */ + + + * Filter type */ + + + * Filter type definitions to be used with AL_FILTER_TYPE. */ + + + + Format specifier for 16bit 4-channel audio. + + + Note that if the enumeration value is not supported by the current OpenAl implementation, + an OpenAL error is generated the first, but only the first time this field is accessed. + The field then has a value of zero. + + + + + Format specifier for 16bit 6-channel audio. + + + Note that if the enumeration value is not supported by the current OpenAl implementation, + an OpenAL error is generated the first, but only the first time this field is accessed. + The field then has a value of zero. + + + + + Format specifier for 16bit 7-channel audio. + + + Note that if the enumeration value is not supported by the current OpenAl implementation, + an OpenAL error is generated the first, but only the first time this field is accessed. + The field then has a value of zero. + + + + + Format specifier for 16bit 8-channel audio. + + + Note that if the enumeration value is not supported by the current OpenAl implementation, + an OpenAL error is generated the first, but only the first time this field is accessed. + The field then has a value of zero. + + + + + See 'OpenAL Programmer's Guide' for more information. + + + Note that if the enumeration value is not supported by the current OpenAl implementation, + an OpenAL error is generated the first, but only the first time this field is accessed. + The field then has a value of zero. + + + + + See 'OpenAL Programmer's Guide' for more information. + + + Note that if the enumeration value is not supported by the current OpenAl implementation, + an OpenAL error is generated the first, but only the first time this field is accessed. + The field then has a value of zero. + + + + + See 'OpenAL Programmer's Guide' for more information. + + + Note that if the enumeration value is not supported by the current OpenAl implementation, + an OpenAL error is generated the first, but only the first time this field is accessed. + The field then has a value of zero. + + + + + See 'OpenAL Programmer's Guide' for more information. + + + Note that if the enumeration value is not supported by the current OpenAl implementation, + an OpenAL error is generated the first, but only the first time this field is accessed. + The field then has a value of zero. + + + + + See 'OpenAL Programmer's Guide' for more information. + + + Note that if the enumeration value is not supported by the current OpenAl implementation, + an OpenAL error is generated the first, but only the first time this field is accessed. + The field then has a value of zero. + + + + + Fills a buffer with audio data. + + + Buffer name to be filled with data. + + + + Format type from among the following: + + + + + + + + + + + + Pointer to the audio data. + + + The size of the audio data in bytes. + + + The frequency of the audio data. + + + + + Fills a buffer with audio data. + + + Buffer name to be filled with data. + + + + Format type from among the following: + + + + + + + + + + + + Pointer to the audio data. + + + The size of the audio data in bytes. + + + The frequency of the audio data. + + + + + Fills a buffer with audio data. + + + Buffer name to be filled with data. + + + + Format type from among the following: + + + + + + + + + + + + Pointer to the audio data. + + + The size of the audio data in bytes. + + + The frequency of the audio data. + + + + + Set Buffer parameters. + + + + + Set Buffer parameters. + + + + + Set Buffer parameters. + + + + + Set Buffer parameters. + + + + + Set Buffer parameters. + + + + + Set Buffer parameters. + + + + + Deletes one or more buffers. + + + The number of buffers to be deleted. + + + Pointer to an array of buffer names identifying the buffers to be deleted. + + + If the requested number of buffers cannot be deleted, an error will be + generated which can be detected with . If an error + occurs, no buffers will be deleted. If number equals zero, + alDeleteBuffers does nothing and will not return an error. + + + + + Deletes one or more buffers. + + + The number of buffers to be deleted. + + + Pointer to an array of buffer names identifying the buffers to be deleted. + + + If the requested number of buffers cannot be deleted, an error will be + generated which can be detected with . If an error + occurs, no buffers will be deleted. If number equals zero, + alDeleteBuffers does nothing and will not return an error. + + + + + Deletes one or more buffers. + + + The number of buffers to be deleted. + + + Pointer to an array of buffer names identifying the buffers to be deleted. + + + If the requested number of buffers cannot be deleted, an error will be + generated which can be detected with . If an error + occurs, no buffers will be deleted. If number equals zero, + alDeleteBuffers does nothing and will not return an error. + + + + + Deletes one or more buffers. + + + The number of buffers to be deleted. + + + Pointer to an array of buffer names identifying the buffers to be deleted. + + + If the requested number of buffers cannot be deleted, an error will be + generated which can be detected with . If an error + occurs, no buffers will be deleted. If number equals zero, + alDeleteBuffers does nothing and will not return an error. + + + + + Deletes one or more sources. + + + The number of sources to be deleted. + + + Pointer to an array of source names identifying the sources to be deleted. + + + If the requested number of sources cannot be deleted, an error will be generated + which can be detected with . If an error occurs, no + sources will be deleted. If number equals zero, alDeleteSources + does nothing and will not return an error. + + + + + Deletes one or more sources. + + + The number of sources to be deleted. + + + Pointer to an array of source names identifying the sources to be deleted. + + + If the requested number of sources cannot be deleted, an error will be generated + which can be detected with . If an error occurs, no + sources will be deleted. If number equals zero, alDeleteSources + does nothing and will not return an error. + + + + + Deletes one or more sources. + + + The number of sources to be deleted. + + + Pointer to an array of source names identifying the sources to be deleted. + + + If the requested number of sources cannot be deleted, an error will be generated + which can be detected with . If an error occurs, no + sources will be deleted. If number equals zero, alDeleteSources + does nothing and will not return an error. + + + + + Deletes one or more sources. + + + The number of sources to be deleted. + + + Pointer to an array of source names identifying the sources to be deleted. + + + If the requested number of sources cannot be deleted, an error will be generated + which can be detected with . If an error occurs, no + sources will be deleted. If number equals zero, alDeleteSources + does nothing and will not return an error. + + + + + Disables a feature of the OpenAL driver. + + + The capability to disable. + + + At the time of this writing, there are no features to be disabled using this + function, so if it is called the error will be + generated. + + + + + Selects the OpenAL distance model. + + + + The distance model to be set: + + + + + + + + + + + + The default distance model in OpenAL is . + + + The model works according to the following + formula: + + + + G_dB = AL_GAIN – 20log10(1 + AL_ROLLOFF_FACTOR * (distance – AL_REFERENCE_DISTANCE) / AL_REFERENCE_DISTANCE)); + G_dB = min(G_dB, AL_MAX_GAIN); + G_dB = max(G_dB, AL_MIN_GAIN); + + + + The model works according to the + following formula: + + + + distance = max(distance, AL_REFERENCE_DISTANCE); + distance = min(distance, AL_MAX_DISTANCE); + G_dB = AL_GAIN – 20log10(1 + AL_ROLLOFF_FACTOR * (distance – AL_REFERENCE_DISTANCE) / AL_REFERENCE_DISTANCE)); + G_dB = min(G_dB, AL_MAX_GAIN); + G_dB = max(G_dB, AL_MIN_GAIN); + + + + The model works according to the following formula: + + + + G_db = AL_GAIN; + + + + + + + Selects the OpenAL Doppler factor value. + + + The Doppler scale value to set. + + + The default Doppler factor value is 1.0. + + + + + Selects the OpenAL Doppler velocity value. + + + The Doppler velocity value to set. + + + The default Doppler velocity value is 343.3. + + + + + Selects the OpenAL Speed of Sound value. + + + The Speed of Sound value to set. + + + + + + + + Enables a feature of the OpenAL driver. + + + The capability to enable. + + + At the time of this writing, there are no features to be enabled using this + function, so if it is called the error will be + generated. + + + + + Generates one or more buffers. + + + The number of buffers to be generated. + + + Pointer to an array of integer values which will store the names of the new + buffers. + + + If the requested number of buffers cannot be created, an error will be generated + which can be detected with . If an error occurs, no + buffers will be generated. If number equals zero, alGenBuffers + does nothing and does not return an error. + + + + + Generates one or more buffers. + + + The number of buffers to be generated. + + + Pointer to an array of integer values which will store the names of the new + buffers. + + + If the requested number of buffers cannot be created, an error will be generated + which can be detected with . If an error occurs, no + buffers will be generated. If number equals zero, alGenBuffers + does nothing and does not return an error. + + + + + Generates one or more buffers. + + + The number of buffers to be generated. + + + Pointer to an array of integer values which will store the names of the new + buffers. + + + If the requested number of buffers cannot be created, an error will be generated + which can be detected with . If an error occurs, no + buffers will be generated. If number equals zero, alGenBuffers + does nothing and does not return an error. + + + + + Generates one or more buffers. + + + The number of buffers to be generated. + + + Pointer to an array of integer values which will store the names of the new + buffers. + + + If the requested number of buffers cannot be created, an error will be generated + which can be detected with . If an error occurs, no + buffers will be generated. If number equals zero, alGenBuffers + does nothing and does not return an error. + + + + + Generates one or more sources. + + + The number of sources to be generated. + + + Pointer to an array of integer values which will store the names of the new + sources. + + + If the requested number of sources cannot be created, an error will be generated + which can be detected with . If an error occurs, no + sources will be generated. If number equals zero, alGenSources + does nothing and does not return an error. + + + + + Generates one or more sources. + + + The number of sources to be generated. + + + Pointer to an array of integer values which will store the names of the new + sources. + + + If the requested number of sources cannot be created, an error will be generated + which can be detected with . If an error occurs, no + sources will be generated. If number equals zero, alGenSources + does nothing and does not return an error. + + + + + Generates one or more sources. + + + The number of sources to be generated. + + + Pointer to an array of integer values which will store the names of the new + sources. + + + If the requested number of sources cannot be created, an error will be generated + which can be detected with . If an error occurs, no + sources will be generated. If number equals zero, alGenSources + does nothing and does not return an error. + + + + + Generates one or more sources. + + + The number of sources to be generated. + + + Pointer to an array of integer values which will store the names of the new + sources. + + + If the requested number of sources cannot be created, an error will be generated + which can be detected with . If an error occurs, no + sources will be generated. If number equals zero, alGenSources + does nothing and does not return an error. + + + + + Returns a boolean OpenAL state. + + + The state to be queried. + + + The boolean value ( or ) described + by state will be returned. + + + There aren’t any boolean states defined at the time of this writing, so this + function will always generate the error . + + + + + Retrieves a boolean OpenAL state. + + + The state to be queried. + + + A pointer to the location where the state will be stored. + + + There aren’t any boolean states defined at the time of this writing, so this + function will always generate the error . + + + + + Retrieves a boolean OpenAL state. + + + The state to be queried. + + + A pointer to the location where the state will be stored. + + + There aren’t any boolean states defined at the time of this writing, so this + function will always generate the error . + + + + + Retrieves a boolean OpenAL state. + + + The state to be queried. + + + A pointer to the location where the state will be stored. + + + There aren’t any boolean states defined at the time of this writing, so this + function will always generate the error . + + + + + Retrieves a boolean OpenAL state. + + + The state to be queried. + + + A pointer to the location where the state will be stored. + + + There aren’t any boolean states defined at the time of this writing, so this + function will always generate the error . + + + + + Retrieves a floating-point property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + The name of the attribute to be retrieved. + + + A pointer to an float to hold the retrieved data. + + + There are no float attributes for buffers at this time. + + + + + Retrieves a floating-point property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + The name of the attribute to be retrieved. + + + A pointer to an float to hold the retrieved data. + + + There are no float attributes for buffers at this time. + + + + + Retrieves a floating-point property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + The name of the attribute to be retrieved. + + + A pointer to an float to hold the retrieved data. + + + There are no float attributes for buffers at this time. + + + + + Retrieves a floating-point property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + The name of the attribute to be retrieved. + + + A pointer to an float to hold the retrieved data. + + + There are no float attributes for buffers at this time. + + + + + Retrieves a floating-point property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + The name of the attribute to be retrieved. + + + A pointer to an float to hold the retrieved data. + + + A pointer to an float to hold the retrieved data. + + + A pointer to an float to hold the retrieved data. + + + There are no float attributes for buffers at this time. + + + + + Retrieves a floating-point property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + The name of the attribute to be retrieved. + + + A pointer to an float to hold the retrieved data. + + + There are no float attributes for buffers at this time. + + + + + Retrieves a floating-point property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + The name of the attribute to be retrieved. + + + A pointer to an float to hold the retrieved data. + + + There are no float attributes for buffers at this time. + + + + + Retrieves a floating-point property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + The name of the attribute to be retrieved. + + + A pointer to an float to hold the retrieved data. + + + There are no float attributes for buffers at this time. + + + + + Retrieves a floating-point property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + The name of the attribute to be retrieved. + + + A pointer to an float to hold the retrieved data. + + + There are no float attributes for buffers at this time. + + + + + Retrieves an integer property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + + The name of the attribute to be retrieved: + + + + + + + + + + + + + A pointer to an integer to hold the retrieved data. + + + + + Retrieves an integer property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + + The name of the attribute to be retrieved: + + + + + + + + + + + + + A pointer to an integer to hold the retrieved data. + + + + + Retrieves an integer property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + + The name of the attribute to be retrieved: + + + + + + + + + + + + + A pointer to an integer to hold the retrieved data. + + + + + Retrieves an integer property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + + The name of the attribute to be retrieved: + + + + + + + + + + + + + A pointer to an integer to hold the retrieved data. + + + + + Retrieves an integer property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + The name of the attribute to be retrieved. + + + A pointer to an int to hold the retrieved data. + + + A pointer to an int to hold the retrieved data. + + + A pointer to an int to hold the retrieved data. + + + There are no int attributes for buffers at this time. + + + + + Retrieves an integer property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + + The name of the attribute to be retrieved: + + + + + + + + + + + + + A pointer to an integer to hold the retrieved data. + + + + + Retrieves an integer property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + + The name of the attribute to be retrieved: + + + + + + + + + + + + + A pointer to an integer to hold the retrieved data. + + + + + Retrieves an integer property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + + The name of the attribute to be retrieved: + + + + + + + + + + + + + A pointer to an integer to hold the retrieved data. + + + + + Retrieves an integer property of a buffer. + + + Buffer name whose attribute is being retrieved. + + + + The name of the attribute to be retrieved: + + + + + + + + + + + + + A pointer to an integer to hold the retrieved data. + + + + + Returns a double-precision floating-point OpenAL state. + + + The state to be queried. + + + The double value described by state will be returned. + + + There aren’t any double-precision floating-point states defined at the time of + this writing, so this function will always generate the error + . + + + + + Retrieves a double-precision floating-point OpenAL state. + + + The state to be queried. + + + A pointer to the location where the state will be stored. + + + There aren’t any double-precision floating-point states defined at the time of + this writing, so this function will always generate the error + . + + + + + Retrieves a double-precision floating-point OpenAL state. + + + The state to be queried. + + + A pointer to the location where the state will be stored. + + + There aren’t any double-precision floating-point states defined at the time of + this writing, so this function will always generate the error + . + + + + + Retrieves a double-precision floating-point OpenAL state. + + + The state to be queried. + + + A pointer to the location where the state will be stored. + + + There aren’t any double-precision floating-point states defined at the time of + this writing, so this function will always generate the error + . + + + + + Retrieves a double-precision floating-point OpenAL state. + + + The state to be queried. + + + A pointer to the location where the state will be stored. + + + There aren’t any double-precision floating-point states defined at the time of + this writing, so this function will always generate the error + . + + + + + Returns the enumeration value of an OpenAL enum described by a string. + + + A string describing an OpenAL enum. + + + The actual value for the described enum is returned. + + + + + Returns the current error state and then clears the error state. + + + The error state. + + + When an OpenAL error occurs, the error state is set and will not be changed until + the error state is retrieved using alGetError. Whenever alGetError + is called, the error state is cleared and the last state (the current state when + the call was made) is returned. To isolate error detection to a specific portion + of code, alGetError should be called before the isolated section to clear + the current error state. + + + + + Returns a floating-point OpenAL state. + + + + The state to be queried: + + + + + + + + + + The floating-point value described by state will be returned. + + + + + Retrieves a floating-point OpenAL state. + + + + The state to be queried: + + + + + + + + + + A pointer to the location where the state will be stored. + + + + + Retrieves a floating-point OpenAL state. + + + + The state to be queried: + + + + + + + + + + A pointer to the location where the state will be stored. + + + + + Retrieves a floating-point OpenAL state. + + + + The state to be queried: + + + + + + + + + + A pointer to the location where the state will be stored. + + + + + Retrieves a floating-point OpenAL state. + + + + The state to be queried: + + + + + + + + + + A pointer to the location where the state will be stored. + + + + + Returns an integer OpenAL state. + + + + The state to be queried: + + + + + + + + + The integer value described by state will be returned. + + + + + Retrieves an integer OpenAL state. + + + + The state to be queried: + + + + + + + + + A pointer to the location where the state will be stored. + + + + + Retrieves an integer OpenAL state. + + + + The state to be queried: + + + + + + + + + A pointer to the location where the state will be stored. + + + + + Retrieves an integer OpenAL state. + + + + The state to be queried: + + + + + + + + + A pointer to the location where the state will be stored. + + + + + Retrieves an integer OpenAL state. + + + + The state to be queried: + + + + + + + + + A pointer to the location where the state will be stored. + + + + + Retrieves a set of three floating-point values from a property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + + Pointer to the the floating-point being retrieved. + + + Pointer to the the floating-point being retrieved. + + + Pointer to the the floating-point being retrieved. + + + + + Retrieves a set of three floating-point values from a property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + + Pointer to the the floating-point being retrieved. + + + Pointer to the the floating-point being retrieved. + + + Pointer to the the floating-point being retrieved. + + + + + Retrieves a set of three floating-point values from a property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + + Pointer to the the floating-point being retrieved. + + + Pointer to the the floating-point being retrieved. + + + Pointer to the the floating-point being retrieved. + + + + + Retrieves a set of three floating-point values from a property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + + Pointer to the the floating-point being retrieved. + + + Pointer to the the floating-point being retrieved. + + + Pointer to the the floating-point being retrieved. + + + + + Retrieves a floating-point property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + A pointer to the floating-point value being retrieved. + + + + + Retrieves a floating-point property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + A pointer to the floating-point value being retrieved. + + + + + Retrieves a floating-point property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + A pointer to the floating-point value being retrieved. + + + + + Retrieves a floating-point property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + A pointer to the floating-point value being retrieved. + + + + + Retrieves a floating-point vector property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + + + A pointer to the floating-point vector value being retrieved. + + + + + Retrieves a floating-point vector property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + + + A pointer to the floating-point vector value being retrieved. + + + + + Retrieves a floating-point vector property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + + + A pointer to the floating-point vector value being retrieved. + + + + + Retrieves a floating-point vector property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + + + A pointer to the floating-point vector value being retrieved. + + + + + Retrieves an integer property of the listener. + + + The name of the attribute to be queried. + + + A pointer to the integer value being retrieved. + + + There are no integer listener attributes at this time. + + + + + Retrieves an integer property of the listener. + + + The name of the attribute to be queried. + + + A pointer to the integer value being retrieved. + + + There are no integer listener attributes at this time. + + + + + Retrieves an integer property of the listener. + + + The name of the attribute to be queried. + + + A pointer to the integer value being retrieved. + + + There are no integer listener attributes at this time. + + + + + Retrieves an integer property of the listener. + + + The name of the attribute to be queried. + + + A pointer to the integer value being retrieved. + + + There are no integer listener attributes at this time. + + + + + Retrieves a set of three integer values from a property of the listener. + + + + The name of the attribute to be queried: + + + + + + + + + + Pointer to the integer being retrieved. + + + Pointer to the integer being retrieved. + + + Pointer to the intger being retrieved. + + + + + Retrieves an integer property of the listener. + + + The name of the attribute to be queried. + + + A pointer to the integer value being retrieved. + + + There are no integer listener attributes at this time. + + + + + Retrieves an integer property of the listener. + + + The name of the attribute to be queried. + + + A pointer to the integer value being retrieved. + + + There are no integer listener attributes at this time. + + + + + Retrieves an integer property of the listener. + + + The name of the attribute to be queried. + + + A pointer to the integer value being retrieved. + + + There are no integer listener attributes at this time. + + + + + Retrieves an integer property of the listener. + + + The name of the attribute to be queried. + + + A pointer to the integer value being retrieved. + + + There are no integer listener attributes at this time. + + + + + Returns the address of an OpenAL extension function. + + + A string containing the function name. + + + A pointer to the desired function is returned. + + + The return value will be IntPtr.Zero if the function is not found. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + The float values which the attribute will be set to. + + + The float values which the attribute will be set to. + + + The float values which the attribute will be set to. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + The float values which the attribute will be set to. + + + The float values which the attribute will be set to. + + + The float values which the attribute will be set to. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + The float values which the attribute will be set to. + + + The float values which the attribute will be set to. + + + The float values which the attribute will be set to. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + The float values which the attribute will be set to. + + + The float values which the attribute will be set to. + + + The float values which the attribute will be set to. + + + + + Retrieves a floating-point property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + + + + + + A pointer to the floating-point value being retrieved. + + + + + Retrieves a floating-point property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + + + + + + A pointer to the floating-point value being retrieved. + + + + + Retrieves a floating-point property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + + + + + + A pointer to the floating-point value being retrieved. + + + + + Retrieves a floating-point property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + + + + + + A pointer to the floating-point value being retrieved. + + + + + Retrieves a floating-point vector property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute being retrieved: + + + + + + + + + + + A pointer to the vector to retrieve. + + + + + Retrieves a floating-point vector property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute being retrieved: + + + + + + + + + + + A pointer to the vector to retrieve. + + + + + Retrieves a floating-point vector property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute being retrieved: + + + + + + + + + + + A pointer to the vector to retrieve. + + + + + Retrieves a floating-point vector property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute being retrieved: + + + + + + + + + + + A pointer to the vector to retrieve. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + + + + A pointer to the integer value being retrieved. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + A pointer to the integer value being retrieved. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + A pointer to the integer value being retrieved. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + A pointer to the integer value being retrieved. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + The int values which the attribute will be set to. + + + The int values which the attribute will be set to. + + + The int values which the attribute will be set to. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + + + + A pointer to the integer value being retrieved. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + A pointer to the integer value being retrieved. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + A pointer to the integer value being retrieved. + + + + + Retrieves an integer property of a source. + + + Source name whose attribute is being retrieved. + + + + The name of the attribute to retrieve: + + + + + + + + + + + + + A pointer to the integer value being retrieved. + + + + + Retrieves an OpenAL string property. + + + + The property to be queried: + + + + + + + + + + + + A pointer to a null-terminated string. + + + + + Sets application preferences for driver performance choices. + + + Unknown. + + + Unknown. + + + + + Tests if a buffer name is valid. + + + A buffer name to be tested for validity. + + + bool value if the buffer name is valid or + if the buffer name is not valid. + + + + + Returns a value indicating if a specific feature is enabled in the OpenAL driver. + + + The capability to query. + + + if the capability is enabled, if + the capability is disabled. + + + At the time of this writing, this function always returns , + and since there are no capabilities defined yet, the error + will also be set. + + + + + Tests if a specific extension is available for the OpenAL driver. + + + A string describing the desired extension. + + + if the extension is available, if + the extension is not available. + + + + + Tests if a source name is valid. + + + A source name to be tested for validity. + + + bool value if the source name is valid or + if the source name is not valid. + + + + + Sets a floating-point property for the listener. + + + + The name of the attribute to set: + + + + + + + + + + The value to set the attribute to. + + + The value to set the attribute to. + + + The value to set the attribute to. + + + + + Sets a floating-point property for the listener. + + + The name of the attribute to be set. + + + The float value to set the attribute to. + + + + + Sets a floating-point vector property of the listener. + + + + The name of the attribute to be set: + + + + + + + + + + + Pointer to floating-point vector values. + + + + + Sets a floating-point vector property of the listener. + + + + The name of the attribute to be set: + + + + + + + + + + + Pointer to floating-point vector values. + + + + + Sets a floating-point vector property of the listener. + + + + The name of the attribute to be set: + + + + + + + + + + + Pointer to floating-point vector values. + + + + + Sets a floating-point vector property of the listener. + + + + The name of the attribute to be set: + + + + + + + + + + + Pointer to floating-point vector values. + + + + + Sets an integer property of the listener. + + + The name of the attribute to be set. + + + The integer value to set the attribute to. + + + There are no integer listener attributes at this time. + + + + + Sets an integer property for the listener. + + + + The name of the attribute to set: + + + + + + + + + + The value to set the attribute to. + + + The value to set the attribute to. + + + The value to set the attribute to. + + + + + Sets a integer-vector property of the listener. + + + + The name of the attribute to be set: + + + + + + + + + + + Pointer to integer-vector values. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Sets a source property requiring three floating-point values. + + + Source name whose attribute is being set. + + + + The name of the attribute to set: + + + + + + + + + + + The float values which the attribute will be set to. + + + The float values which the attribute will be set to. + + + The float values which the attribute will be set to. + + + This function is an alternative to . + + + + + Sets a floating-point property of a source. + + + Source name whose attribute is being set. + + + + The name of the attribute to set: + + + + + + + + + + + + + + + + The value to set the attribute to. + + + + + Sets a floating-point vector property of a source. + + + Source name whose attribute is being set. + + + + The name of the attribute being set: + + + + + + + + + + + A pointer to the vector to set the attribute to. + + + + + Sets a floating-point vector property of a source. + + + Source name whose attribute is being set. + + + + The name of the attribute being set: + + + + + + + + + + + A pointer to the vector to set the attribute to. + + + + + Sets a floating-point vector property of a source. + + + Source name whose attribute is being set. + + + + The name of the attribute being set: + + + + + + + + + + + A pointer to the vector to set the attribute to. + + + + + Sets a floating-point vector property of a source. + + + Source name whose attribute is being set. + + + + The name of the attribute being set: + + + + + + + + + + + A pointer to the vector to set the attribute to. + + + + + Sets an integer property of a source. + + + Source name whose attribute is being set. + + + + The name of the attribute to set: + + + + + + + + + + + + + + The value to set the attribute to. + + + The buffer name zero is reserved as a “Null Buffer" and is accepted by + alSourcei(…, Al.AL_BUFFER, …) as a valid buffer of zero length. + + + + + Sets a integer-vector property of a source. + + + Source name whose attribute is being set. + + + + The name of the attribute being set: + + + + + + + + + + + A pointer to the vector to set the attribute to. + + + + + Sets a source property requiring three integer values. + + + Source name whose attribute is being set. + + + + The name of the attribute to set: + + + + + + + + + + + The int values which the attribute will be set to. + + + The int values which the attribute will be set to. + + + The int values which the attribute will be set to. + + + This function is an alternative to . + + + + + Pauses a source. + + + The name of the source to be paused. + + + The paused source will have its state changed to . + + + + + Pauses a set of sources. + + + The number of sources to be paused. + + + A pointer to an array of sources to be paused. + + + The paused sources will have their state changed to . + + + + + Pauses a set of sources. + + + The number of sources to be paused. + + + A pointer to an array of sources to be paused. + + + The paused sources will have their state changed to . + + + + + Pauses a set of sources. + + + The number of sources to be paused. + + + A pointer to an array of sources to be paused. + + + The paused sources will have their state changed to . + + + + + Pauses a set of sources. + + + The number of sources to be paused. + + + A pointer to an array of sources to be paused. + + + The paused sources will have their state changed to . + + + + + Plays a source. + + + The name of the source to be played. + + + The playing source will have its state changed to . + + + + + Plays a set of sources. + + + The number of sources to be played. + + + A pointer to an array of sources to be played. + + + The playing sources will have their state changed to . + + + + + Plays a set of sources. + + + The number of sources to be played. + + + A pointer to an array of sources to be played. + + + The playing sources will have their state changed to . + + + + + Plays a set of sources. + + + The number of sources to be played. + + + A pointer to an array of sources to be played. + + + The playing sources will have their state changed to . + + + + + Plays a set of sources. + + + The number of sources to be played. + + + A pointer to an array of sources to be played. + + + The playing sources will have their state changed to . + + + + + Queues a set of buffers on a source. + + + The name of the source to queue buffers onto. + + + The number of buffers to be queued. + + + A pointer to an array of buffer names to be queued. + + + + + Queues a set of buffers on a source. + + + The name of the source to queue buffers onto. + + + The number of buffers to be queued. + + + A pointer to an array of buffer names to be queued. + + + + + Queues a set of buffers on a source. + + + The name of the source to queue buffers onto. + + + The number of buffers to be queued. + + + A pointer to an array of buffer names to be queued. + + + + + Queues a set of buffers on a source. + + + The name of the source to queue buffers onto. + + + The number of buffers to be queued. + + + A pointer to an array of buffer names to be queued. + + + + + Stops the source and sets its state to . + + + The name of the source to be rewound. + + + + + Stops a set of sources and sets all their states to . + + + The number of sources to be rewound. + + + A pointer to an array of sources to be rewound. + + + + + Stops a set of sources and sets all their states to . + + + The number of sources to be rewound. + + + A pointer to an array of sources to be rewound. + + + + + Stops a set of sources and sets all their states to . + + + The number of sources to be rewound. + + + A pointer to an array of sources to be rewound. + + + + + Stops a set of sources and sets all their states to . + + + The number of sources to be rewound. + + + A pointer to an array of sources to be rewound. + + + + + Stops a source. + + + The name of the source to be stopped. + + + The stopped source will have its state changed to . + + + + + Stops a set of sources. + + + The number of sources to stop. + + + A pointer to an array of sources to be stopped. + + + The stopped sources will have their state changed to . + + + + + Stops a set of sources. + + + The number of sources to stop. + + + A pointer to an array of sources to be stopped. + + + The stopped sources will have their state changed to . + + + + + Stops a set of sources. + + + The number of sources to stop. + + + A pointer to an array of sources to be stopped. + + + The stopped sources will have their state changed to . + + + + + Stops a set of sources. + + + The number of sources to stop. + + + A pointer to an array of sources to be stopped. + + + The stopped sources will have their state changed to . + + + + + Unqueues a set of buffers attached to a source. + + + The name of the source to unqueue buffers from. + + + The number of buffers to be unqueued. + + + A pointer to an array of buffer names that were removed. + + + The unqueue operation will only take place if all number buffers can be + removed from the queue. + + + + + Unqueues a set of buffers attached to a source. + + + The name of the source to unqueue buffers from. + + + The number of buffers to be unqueued. + + + A pointer to an array of buffer names that were removed. + + + The unqueue operation will only take place if all number buffers can be + removed from the queue. + + + + + Unqueues a set of buffers attached to a source. + + + The name of the source to unqueue buffers from. + + + The number of buffers to be unqueued. + + + A pointer to an array of buffer names that were removed. + + + The unqueue operation will only take place if all number buffers can be + removed from the queue. + + + + + Unqueues a set of buffers attached to a source. + + + The name of the source to unqueue buffers from. + + + The number of buffers to be unqueued. + + + A pointer to an array of buffer names that were removed. + + + The unqueue operation will only take place if all number buffers can be + removed from the queue. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Unknown. + + + Unknown. + + + Unknown. + + + Unknown. + + + + + Sets the X-RAM mode for the specified buffers. + + + The number of buffers to set. + + + A pointer to an array of buffers to set. + + + + The X-RAM buffer mode for the specified buffers. + + + + + + + + + + + + + Sets the X-RAM mode for the specified buffers. + + + The number of buffers to set. + + + An array of buffers to set, with minimum n elements. + + + + The X-RAM buffer mode for the specified buffers. + + + + + + + + + + + + + Sets the X-RAM mode for the specified buffers. + + + The number of buffers to set. + + + A pointer to an array of buffers to set. + + + + The X-RAM buffer mode for the specified buffers. + + + + + + + + + + + + + Gets the X-RAM mode for the specified buffer. + + + Buffer to retreive the property for. + + + Not used yet. + + + + One of the following values: + + + + + + + + + + + + + Gets the X-RAM mode for the specified buffer. + + + Buffer to retreive the property for. + + + Not used yet. + + + + One of the following values: + + + + + + + + + + + + + Gets the X-RAM mode for the specified buffer. + + + Buffer to retreive the property for. + + + Not used yet. + + + + One of the following values: + + + + + + + + + + + + + Reloads OpenAL extension functions. + + + + Call this function to reload context-dependent extension OpenAL entry points. This should be done + whenever you change the current OpenAL context, or in the case you cannot (or do not want) + to use the automatic initialisation. + + + Calling this function before the automatic initialisation has taken place will result + in the Al class being initialised twice. This is harmless, but, given the choice, + the automatic initialisation should be preferred. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Represents a 3D vector using three single-precision floating-point numbers. + + + The Vector3 structure is suitable for interoperation with unmanaged code requiring three consecutive floats. + + + + + The X component of the Vector3. + + + + + The Y component of the Vector3. + + + + + The Z component of the Vector3. + + + + + Constructs a new Vector3. + + The x component of the Vector3. + The y component of the Vector3. + The z component of the Vector3. + + + + Constructs a new Vector3 from the given Vector2. + + The Vector2 to copy components from. + + + + Constructs a new Vector3 from the given Vector3. + + The Vector3 to copy components from. + + + + Constructs a new Vector3 from the given Vector4. + + The Vector4 to copy components from. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Multiply this instance by a scalar. + Scalar operand. + + + Divide this instance by a scalar. + Scalar operand. + + + + Scales the Vector3 to unit length. + + + + + Scales the Vector3 to approximately unit length. + + + + + Scales the current Vector3 by the given amounts. + + The scale of the X component. + The scale of the Y component. + The scale of the Z component. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + + Defines a unit-length Vector3 that points towards the X-axis. + + + + + Defines a unit-length Vector3 that points towards the Y-axis. + + + + + /// Defines a unit-length Vector3 that points towards the Z-axis. + + + + + Defines a zero-length Vector3. + + + + + Defines an instance with all components set to 1. + + + + + Defines the size of the Vector3 struct in bytes. + + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Returns the Vector3 with the minimum magnitude + + Left operand + Right operand + The minimum Vector3 + + + + Returns the Vector3 with the minimum magnitude + + Left operand + Right operand + The minimum Vector3 + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Calculate the dot (scalar) product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Calculate the dot (scalar) product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Caclulate the cross (vector) product of two vectors + + First operand + Second operand + The cross product of the two inputs + + + + Caclulate the cross (vector) product of two vectors + + First operand + Second operand + The cross product of the two inputs + The cross product of the two inputs + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Interpolate 3 Vectors using Barycentric coordinates + + First input Vector + Second input Vector + Third input Vector + First Barycentric Coordinate + Second Barycentric Coordinate + a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + Interpolate 3 Vectors using Barycentric coordinates + First input Vector. + Second input Vector. + Third input Vector. + First Barycentric Coordinate. + Second Barycentric Coordinate. + Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + Transform a direction vector by the given Matrix + Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored. + + The vector to transform + The desired transformation + The transformed vector + + + Transform a direction vector by the given Matrix + Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored. + + The vector to transform + The desired transformation + The transformed vector + + + Transform a Normal by the given Matrix + + This calculates the inverse of the given matrix, use TransformNormalInverse if you + already have the inverse to avoid this extra calculation + + The normal to transform + The desired transformation + The transformed normal + + + Transform a Normal by the given Matrix + + This calculates the inverse of the given matrix, use TransformNormalInverse if you + already have the inverse to avoid this extra calculation + + The normal to transform + The desired transformation + The transformed normal + + + Transform a Normal by the (transpose of the) given Matrix + + This version doesn't calculate the inverse matrix. + Use this version if you already have the inverse of the desired transform to hand + + The normal to transform + The inverse of the desired transformation + The transformed normal + + + Transform a Normal by the (transpose of the) given Matrix + + This version doesn't calculate the inverse matrix. + Use this version if you already have the inverse of the desired transform to hand + + The normal to transform + The inverse of the desired transformation + The transformed normal + + + Transform a Position by the given Matrix + The position to transform + The desired transformation + The transformed position + + + Transform a Position by the given Matrix + The position to transform + The desired transformation + The transformed position + + + Transform a Vector by the given Matrix + The vector to transform + The desired transformation + The transformed vector + + + Transform a Vector by the given Matrix + The vector to transform + The desired transformation + The transformed vector + + + Transform a Vector3 by the given Matrix, and project the resulting Vector4 back to a Vector3 + The vector to transform + The desired transformation + The transformed vector + + + Transform a Vector3 by the given Matrix, and project the resulting Vector4 back to a Vector3 + The vector to transform + The desired transformation + The transformed vector + + + + Calculates the angle (in radians) between two vectors. + + The first vector. + The second vector. + Angle (in radians) between the vectors. + Note that the returned angle is never bigger than the constant Pi. + + + Calculates the angle (in radians) between two vectors. + The first vector. + The second vector. + Angle (in radians) between the vectors. + Note that the returned angle is never bigger than the constant Pi. + + + + Returns a System.String that represents the current Vector3. + + + + + + Returns the hashcode for this instance. + + A System.Int32 containing the unique hashcode for this instance. + + + + Indicates whether this instance and a specified object are equal. + + The object to compare to. + True if the instances are equal; false otherwise. + + + Indicates whether the current vector is equal to another vector. + A vector to compare with this vector. + true if the current vector is equal to the vector parameter; otherwise, false. + + + + Gets the length (magnitude) of the vector. + + + + + + + Gets an approximation of the vector length (magnitude). + + + This property uses an approximation of the square root function to calculate vector magnitude, with + an upper error bound of 0.001. + + + + + + + Gets the square of the vector length (magnitude). + + + This property avoids the costly square root operation required by the Length property. This makes it more suitable + for comparisons. + + + + + + + Gets or sets an OpenTK.Vector2 with the X and Y components of this instance. + + + + Describes the format of the SoundData. + + + Constructs a new SoundFormat. + + + Describes the SampleFormat of the SoundData. + + + Describes the sample rate (frequency) of the SoundData. + + + Gets the SampleFormat of the buffer as an OpenTK.Audio.ALFormat enumeration. + + + Defines the available formats for SoundData. + + + 8 bits per sample, 1 channel. + + + 16 bits per sample, 1 channel. + + + 8 bits per sample, 2 channels. + + + 16 bits per sample, 2 channels. + + + Represents a 2D vector using two single-precision floating-point numbers. + + The Vector2 structure is suitable for interoperation with unmanaged code requiring two consecutive floats. + + + + + The X component of the Vector2. + + + + + The Y component of the Vector2. + + + + + Constructs a new Vector2. + + The x coordinate of the net Vector2. + The y coordinate of the net Vector2. + + + + Constructs a new Vector2 from the given Vector2. + + The Vector2 to copy components from. + + + + Constructs a new Vector2 from the given Vector3. + + The Vector3 to copy components from. Z is discarded. + + + + Constructs a new Vector2 from the given Vector4. + + The Vector4 to copy components from. Z and W are discarded. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Add the Vector passed as parameter to this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Subtract the Vector passed as parameter from this instance. + Right operand. This parameter is only read from. + + + Multiply this instance by a scalar. + Scalar operand. + + + Divide this instance by a scalar. + Scalar operand. + + + + Scales the Vector2 to unit length. + + + + + Scales the Vector2 to approximately unit length. + + + + + Scales the current Vector2 by the given amounts. + + The scale of the X component. + The scale of the Y component. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + Scales this instance by the given parameter. + The scaling of the individual components. + + + + Defines a unit-length Vector2 that points towards the X-axis. + + + + + Defines a unit-length Vector2 that points towards the Y-axis. + + + + + Defines a zero-length Vector2. + + + + + Defines an instance with all components set to 1. + + + + + Defines the size of the Vector2 struct in bytes. + + + + + Add the specified instances + + First operand + Second operand + Result of addition + + + + Add two Vectors + + First operand + Second operand + Result of addition + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Subtract one Vector from another + + First operand + Second operand + Result of subtraction + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Multiply a vector and a scalar + + Vector operand + Scalar operand + Result of the multiplication + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Divide a vector by a scalar + + Vector operand + Scalar operand + Result of the division + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise minimum of two vectors + + First operand + Second operand + The component-wise minimum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Calculate the component-wise maximum of two vectors + + First operand + Second operand + The component-wise maximum + + + + Returns the Vector3 with the minimum magnitude + + Left operand + Right operand + The minimum Vector3 + + + + Returns the Vector3 with the minimum magnitude + + Left operand + Right operand + The minimum Vector3 + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Clamp a vector to the given minimum and maximum vectors + + Input vector + Minimum vector + Maximum vector + The clamped vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Scale a vector to approximately unit length + + The input vector + The normalized vector + + + + Calculate the dot (scalar) product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Calculate the dot (scalar) product of two vectors + + First operand + Second operand + The dot product of the two inputs + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Returns a new Vector that is the linear blend of the 2 given Vectors + + First input vector + Second input vector + The blend factor. a when blend=0, b when blend=1. + a when blend=0, b when blend=1, and a linear combination otherwise + + + + Interpolate 3 Vectors using Barycentric coordinates + + First input Vector + Second input Vector + Third input Vector + First Barycentric Coordinate + Second Barycentric Coordinate + a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + Interpolate 3 Vectors using Barycentric coordinates + First input Vector. + Second input Vector. + Third input Vector. + First Barycentric Coordinate. + Second Barycentric Coordinate. + Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise + + + + Adds the specified instances. + + Left operand. + Right operand. + Result of addition. + + + + Subtracts the specified instances. + + Left operand. + Right operand. + Result of subtraction. + + + + Negates the specified instance. + + Operand. + Result of negation. + + + + Multiplies the specified instance by a scalar. + + Left operand. + Right operand. + Result of multiplication. + + + + Multiplies the specified instance by a scalar. + + Left operand. + Right operand. + Result of multiplication. + + + + Divides the specified instance by a scalar. + + Left operand + Right operand + Result of the division. + + + + Compares the specified instances for equality. + + Left operand. + Right operand. + True if both instances are equal; false otherwise. + + + + Compares the specified instances for inequality. + + Left operand. + Right operand. + True if both instances are not equal; false otherwise. + + + + Returns a System.String that represents the current Vector2. + + + + + + Returns the hashcode for this instance. + + A System.Int32 containing the unique hashcode for this instance. + + + + Indicates whether this instance and a specified object are equal. + + The object to compare to. + True if the instances are equal; false otherwise. + + + Indicates whether the current vector is equal to another vector. + A vector to compare with this vector. + true if the current vector is equal to the vector parameter; otherwise, false. + + + + Gets the length (magnitude) of the vector. + + + + + + + Gets an approximation of the vector length (magnitude). + + + This property uses an approximation of the square root function to calculate vector magnitude, with + an upper error bound of 0.001. + + + + + + + Gets the square of the vector length (magnitude). + + + This property avoids the costly square root operation required by the Length property. This makes it more suitable + for comparisons. + + + + + + + Gets the perpendicular vector on the right side of this vector. + + + + + Gets the perpendicular vector on the left side of this vector. + + + + + Defines available directions for text layout. + + + + The text is layed out from left to right. + + + The text is layed out from right to left. + + + The text is layed out vertically. + + + + Represents a quadric bezier curve with two anchor and one control point. + + + + + Start anchor point. + + + + + End anchor point. + + + + + Control point, controls the direction of both endings of the curve. + + + + + The parallel value. + + This value defines whether the curve should be calculated as a + parallel curve to the original bezier curve. A value of 0.0f represents + the original curve, 5.0f i.e. stands for a curve that has always a distance + of 5.f to the orignal curve at any point. + + + + Constructs a new . + + The start anchor. + The end anchor. + The control point. + + + + Constructs a new . + + The parallel value. + The start anchor. + The end anchor. + The control point. + + + + Calculates the point with the specified t. + + The t value, between 0.0f and 1.0f. + Resulting point. + + + + Calculates the point with the specified t of the derivative of this function. + + The t, value between 0.0f and 1.0f. + Resulting point. + + + + Calculates the length of this bezier curve. + + The precision. + Length of curve. + The precision gets better when the + value gets smaller. + + + + The name Half is derived from half-precision floating-point number. + It occupies only 16 bits, which are split into 1 Sign bit, 5 Exponent bits and 10 Mantissa bits. + + + Quote from ARB_half_float_pixel specification: + Any representable 16-bit floating-point value is legal as input to a GL command that accepts 16-bit floating-point data. The + result of providing a value that is not a floating-point number (such as infinity or NaN) to such a command is unspecified, + but must not lead to GL interruption or termination. Providing a denormalized number or negative zero to GL must yield + predictable results. + + + + + The new Half instance will convert the parameter into 16-bit half-precision floating-point. + + 32-bit single-precision floating-point number. + + + + The new Half instance will convert the parameter into 16-bit half-precision floating-point. + + 32-bit single-precision floating-point number. + Enable checks that will throw if the conversion result is not meaningful. + + + + The new Half instance will convert the parameter into 16-bit half-precision floating-point. + + 64-bit double-precision floating-point number. + + + + The new Half instance will convert the parameter into 16-bit half-precision floating-point. + + 64-bit double-precision floating-point number. + Enable checks that will throw if the conversion result is not meaningful. + + + Ported from OpenEXR's IlmBase 1.0.1 + + + Converts the 16-bit half to 32-bit floating-point. + A single-precision floating-point number. + + + Ported from OpenEXR's IlmBase 1.0.1 + + + + Converts a System.Single to a OpenTK.Half. + + The value to convert. + A + + The result of the conversion. + A + + + + + Converts a System.Double to a OpenTK.Half. + + The value to convert. + A + + The result of the conversion. + A + + + + + Converts a OpenTK.Half to a System.Single. + + The value to convert. + A + + The result of the conversion. + A + + + + + Converts a OpenTK.Half to a System.Double. + + The value to convert. + A + + The result of the conversion. + A + + + + The size in bytes for an instance of the Half struct. + + + Smallest positive half + + + Smallest positive normalized half + + + Largest positive half + + + Smallest positive e for which half (1.0 + e) != half (1.0) + + + Constructor used by ISerializable to deserialize the object. + + + + + Used by ISerialize to serialize the object. + + + + + Updates the Half by reading from a Stream. + A BinaryReader instance associated with an open Stream. + + + Writes the Half into a Stream. + A BinaryWriter instance associated with an open Stream. + + + + Returns a value indicating whether this instance is equal to a specified OpenTK.Half value. + + OpenTK.Half object to compare to this instance.. + True, if other is equal to this instance; false otherwise. + + + + Compares this instance to a specified half-precision floating-point number + and returns an integer that indicates whether the value of this instance + is less than, equal to, or greater than the value of the specified half-precision + floating-point number. + + A half-precision floating-point number to compare. + + A signed number indicating the relative values of this instance and value. If the number is: + Less than zero, then this instance is less than other, or this instance is not a number + (OpenTK.Half.NaN) and other is a number. + Zero: this instance is equal to value, or both this instance and other + are not a number (OpenTK.Half.NaN), OpenTK.Half.PositiveInfinity, or + OpenTK.Half.NegativeInfinity. + Greater than zero: this instance is greater than othrs, or this instance is a number + and other is not a number (OpenTK.Half.NaN). + + + + Converts this Half into a human-legible string representation. + The string representation of this instance. + + + Converts this Half into a human-legible string representation. + Formatting for the output string. + Culture-specific formatting information. + The string representation of this instance. + + + Converts the string representation of a number to a half-precision floating-point equivalent. + String representation of the number to convert. + A new Half instance. + + + Converts the string representation of a number to a half-precision floating-point equivalent. + String representation of the number to convert. + Specifies the format of s. + Culture-specific formatting information. + A new Half instance. + + + Converts the string representation of a number to a half-precision floating-point equivalent. Returns success. + String representation of the number to convert. + The Half instance to write to. + Success. + + + Converts the string representation of a number to a half-precision floating-point equivalent. Returns success. + string representation of the number to convert. + specifies the format of s. + Culture-specific formatting information. + The Half instance to write to. + Success. + + + Returns the Half as an array of bytes. + The Half to convert. + The input as byte array. + + + Converts an array of bytes into Half. + A Half in it's byte[] representation. + The starting position within value. + A new Half instance. + + + Returns true if the Half is zero. + + + Returns true if the Half represents Not A Number (NaN) + + + Returns true if the Half represents positive infinity. + + + Returns true if the Half represents negative infinity. + + + + Encapsulates an OpenGL texture. + + + + + Constructs a new Texture. + + + + + Defines available options for the TextPrinter. + + + + The TextPrinter will use default printing options. + + + The TextPrinter will not cache text blocks as they are measured or printed. + + + Encapsulates a pointer to a decoded sound buffer. + + + + Constructs a new SoundData object. + The SoundFormat of these SoundData. + An array of PCM buffer. + + + Gets the raw PCM buffer. + + + Gets the SoundFormat of the SoundData. + + + + Represents a double-precision Quaternion. + + + + + Construct a new Quaterniond from vector and w components + + The vector part + The w part + + + + Construct a new Quaterniond + + The x component + The y component + The z component + The w component + + + + Convert the current quaternion to axis angle representation + + The resultant axis + The resultant angle + + + + Convert this instance to an axis-angle representation. + + A Vector4 that is the axis-angle representation of this quaternion. + + + + Scales the Quaterniond to unit length. + + + + + Convert this Quaterniond to its conjugate + + + + + Defines the identity quaternion. + + + + + Add two quaternions + + The first operand + The second operand + The result of the addition + + + + Add two quaternions + + The first operand + The second operand + The result of the addition + + + + Subtracts two instances. + + The left instance. + The right instance. + The result of the operation. + + + + Subtracts two instances. + + The left instance. + The right instance. + The result of the operation. + + + + Get the conjugate of the given Quaterniond + + The Quaterniond + The conjugate of the given Quaterniond + + + + Get the conjugate of the given Quaterniond + + The Quaterniond + The conjugate of the given Quaterniond + + + + Get the inverse of the given Quaterniond + + The Quaterniond to invert + The inverse of the given Quaterniond + + + + Get the inverse of the given Quaterniond + + The Quaterniond to invert + The inverse of the given Quaterniond + + + + Scale the given Quaterniond to unit length + + The Quaterniond to normalize + The normalized Quaterniond + + + + Scale the given Quaterniond to unit length + + The Quaterniond to normalize + The normalized Quaterniond + + + + Build a Quaterniond from the given axis and angle + + The axis to rotate about + The rotation angle in radians + + + + + Do Spherical linear interpolation between two quaternions + + The first Quaterniond + The second Quaterniond + The blend factor + A smooth blend between the given quaternions + + + + Returns a System.String that represents the current Quaterniond. + + + + + + Compares this object instance to another object for equality. + + The other object to be used in the comparison. + True if both objects are Quaternions of equal value. Otherwise it returns false. + + + + Provides the hash code for this object. + + A hash code formed from the bitwise XOR of this objects members. + + + + Compares this Quaterniond instance to another Quaterniond for equality. + + The other Quaterniond to be used in the comparison. + True if both instances are equal; false otherwise. + + + + Gets or sets an OpenTK.Vector3d with the X, Y and Z components of this instance. + + + + + Gets or sets an OpenTK.Vector3d with the X, Y and Z components of this instance. + + + + + Gets or sets the X component of this instance. + + + + + Gets or sets the Y component of this instance. + + + + + Gets or sets the Z component of this instance. + + + + + Gets or sets the W component of this instance. + + + + + Gets the length (magnitude) of the Quaterniond. + + + + + + Gets the square of the Quaterniond length (magnitude). + + + + + Constructs a new Glyph that represents the given character and Font. + + The character to represent. + The Font of the character. + + + + Checks whether the given object is equal (memberwise) to the current Glyph. + + The obj to check. + True, if the object is identical to the current Glyph. + + + + Describes this Glyph object. + + Returns a System.String describing this Glyph. + + + + Calculates the hashcode for this Glyph. + + A System.Int32 containing a hashcode that uniquely identifies this Glyph. + + + + Gets the character represented by this Glyph. + + + + + Gets the Font of this Glyph. + + + + + OpenAL binding for .NET, implementing ALUT 1.1. + + + ALUT is non-standard. + + + + + Specifies OpenAl's native library archive. + + + Specifies OpenAl32.dll everywhere; will be mapped via .config for mono. + + + + + Specifies the calling convention. + + + Specifies . + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Represents exceptions related to OpenTK.Audio.AudioReader objects. + + + Constructs a new AudioReaderException. + + + Constructs a new AudioReaderException with the specified error message. + The error message of the AudioReaderException. + + + + OpenAL binding for .NET, implementing ALC 1.1. + + + Binds functions and definitions in OpenAL32.dll or libAL.so. + + + + + Specifies OpenAl's native library archive. + + + Specifies OpenAl32.dll everywhere; will be mapped via .config for mono. + + + + + Specifies the calling convention. + + + Specifies . + + + + + Bad value. + + + + + bool false. + + + + + bool true. + + + + + No error. + + + + + Major version. + + + + + Minor version. + + + + + Attributes size. + + + + + All attributes. + + + + + Capture device specifier. + + + + + Capture default device specifier. + + + + + Capture samples. + + + + + Default device specifier. + + + + + Device specifier. + + + + + Extensions. + + + + + Frequency. + + + + + Refresh. + + + + + Sync. + + + + + Num of requested Mono (3D) Sources + + + + + Num of requested Stereo Sources + + + + + The device argument does not name a valid device. + + + + + The context argument does not name a valid context. + + + + + A function was called at inappropriate time, or in an inappropriate way, causing + an illegal state. This can be an incompatible value, object ID, and/or function. + + + + + Illegal value passed as an argument to an AL call. Applies to parameter values, + but not to enumerations. + + + + + A function could not be completed, because there is not enough memory available. + + + + + Closes a device. + + + A pointer to an opened device. + + + + + Creates a context using a specified device. + + + A pointer to a device. + + + + A pointer to a set of attributes: + + + + + + + + + + + Returns a pointer to the new context (IntPtr.Zero on failure). + + + + + Creates a context using a specified device. + + + A pointer to a device. + + + + A pointer to a set of attributes: + + + + + + + + + + + Returns a pointer to the new context (IntPtr.Zero on failure). + + + + + Creates a context using a specified device. + + + A pointer to a device. + + + + A pointer to a set of attributes: + + + + + + + + + + + Returns a pointer to the new context (IntPtr.Zero on failure). + + + + + Creates a context using a specified device. + + + A pointer to a device. + + + + A pointer to a set of attributes: + + + + + + + + + + + Returns a pointer to the new context (IntPtr.Zero on failure). + + + + + Destroys a context. + + + Pointer to the context to be destroyed. + + + + + Gets the device for a context. + + + The context to query. + + + A pointer to a device or IntPtr.Zero on failue. + + + + + Retrieves the current context. + + + Returns a pointer to the current context or IntPtr.Zero on failure. + + + + + Retrieves the enum value for a specified enumeration name. + + + The device to be queried. + + + A null terminated string describing the enum value. + + + Returns the enum value described by the enumName string. + + + + + Retrieves the current context error state. + + + The device to query. + + + The current context error state will be returned. + + + + + Returns integers related to the context. + + + The device to be queried. + + + + An attribute to be retrieved: + + + + + + + + + + + + The size of the destination buffer provided. + + + A pointer to the data to be returned. + + + + + Returns integers related to the context. + + + The device to be queried. + + + + An attribute to be retrieved: + + + + + + + + + + + + The size of the destination buffer provided. + + + A pointer to the data to be returned. + + + + + Returns integers related to the context. + + + The device to be queried. + + + + An attribute to be retrieved: + + + + + + + + + + + + The size of the destination buffer provided. + + + A pointer to the data to be returned. + + + + + Returns integers related to the context. + + + The device to be queried. + + + + An attribute to be retrieved: + + + + + + + + + + + + The size of the destination buffer provided. + + + A pointer to the data to be returned. + + + + + Retrieves the address of a specified context extension function. + + + The device to be queried for the function. + + + A null terminated string describing the function. + + + Returns the address of the function, or IntPtr.Zero if it is not found. + + + + + Returns strings related to the context. + + + The device to be queried. + + + + An attribute to be retrieved: + + + + + + + + + + + Returns a pointer to a string. + + + + + Returns strings related to the context. + + + The device to be queried. + + + + An attribute to be retrieved: + + + + + + + + + + + Returns a pointer to a string. + + + + + Queries if a specified context extension is available. + + + The device to be queried for an extension. + + + A null terminated string describing the extension. + + + Returns if the extension is available, + if the extension is not available. + + + + + Makes a specified context the current context. + + + Pointer to the new context. + + + Returns an error code on failure. + + + + + Opens a device by name. + + + A null-terminated string describing a device. + + + Returns a pointer to the opened device. + + + + + Tells a context to begin processing. + + + Pointer to the new context. + + + + + Suspends processing on a specified context. + + + A pointer to the context to be suspended. + + + + + + + + The Open Device will be captured + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Represents a cubic bezier curve with two anchor and two control points. + + + + + Start anchor point. + + + + + End anchor point. + + + + + First control point, controls the direction of the curve start. + + + + + Second control point, controls the direction of the curve end. + + + + + Gets or sets the parallel value. + + This value defines whether the curve should be calculated as a + parallel curve to the original bezier curve. A value of 0.0f represents + the original curve, 5.0f i.e. stands for a curve that has always a distance + of 5.f to the orignal curve at any point. + + + + Constructs a new . + + The start anchor point. + The end anchor point. + The first control point. + The second control point. + + + + Constructs a new . + + The parallel value. + The start anchor point. + The end anchor point. + The first control point. + The second control point. + + + + Calculates the point with the specified t. + + The t value, between 0.0f and 1.0f. + Resulting point. + + + + Calculates the point with the specified t of the derivative of this function. + + The t, value between 0.0f and 1.0f. + Resulting point. + + + + Calculates the length of this bezier curve. + + The precision. + Length of the curve. + The precision gets better when the + value gets smaller. + + + + Adds boundingBox to the GlyphPacker. + + The bounding box of the item to pack. + The System.Drawing.Rectangle that contains the position of the packed item. + True, if the item was successfully packed; false if the item is too big for this packer.. + Occurs if the item is larger than the available TexturePacker area + Occurs if the item cannot fit in the remaining packer space. + + + + Adds boundingBox to the GlyphPacker. + + The bounding box of the item to pack. + The System.Drawing.RectangleF that contains the position of the packed item. + True, if the item was successfully packed; false if the item is too big for this packer.. + Occurs if the item is larger than the available TexturePacker area + Occurs if the item cannot fit in the remaining packer space. + + + + Adds boundingBox to the GlyphPacker. + + The bounding box of the item to pack. + A System.Drawing.Rectangle containing the coordinates of the packed item. + Occurs if the item is larger than the available TexturePacker area + Occurs if the item cannot fit in the remaining packer space. + + + + Rounds boundingBox to the largest integer and adds the resulting Rectangle to the GlyphPacker. + + The bounding box of the item to pack. + A System.Drawing.Rectangle containing the coordinates of the packed item. + Occurs if the item is larger than the available TexturePacker area + Occurs if the item already exists in the TexturePacker. + + + + Discards all packed items. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + From 20ecd2232db5e5f1ed73dc23a86cd69fd6b74edb Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 08:41:48 +0000 Subject: [PATCH 038/130] Implemented equality operators. --- Source/OpenTK/Input/KeyboardState.cs | 75 ++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/Source/OpenTK/Input/KeyboardState.cs b/Source/OpenTK/Input/KeyboardState.cs index 612dc963..99dea373 100644 --- a/Source/OpenTK/Input/KeyboardState.cs +++ b/Source/OpenTK/Input/KeyboardState.cs @@ -84,6 +84,81 @@ namespace OpenTK.Input return !ReadBit((int)key); } + /// + /// Checks whether two instances are equal. + /// + /// + /// A instance. + /// + /// + /// A instance. + /// + /// + /// True if both left is equal to right; false otherwise. + /// + public static bool operator ==(KeyboardState left, KeyboardState right) + { + return left.Equals(right); + } + + /// + /// Checks whether two instances are not equal. + /// + /// + /// A instance. + /// + /// + /// A instance. + /// + /// + /// True if both left is not equal to right; false otherwise. + /// + public static bool operator !=(KeyboardState left, KeyboardState right) + { + return !left.Equals(right); + } + + /// + /// Compares to an object instance for equality. + /// + /// + /// The to compare to. + /// + /// + /// True if this instance is equal to obj; false otherwise. + /// + public override bool Equals(object obj) + { + if (obj is KeyboardState) + { + return this == (KeyboardState)obj; + } + else + { + return false; + } + } + + /// + /// Generates a hashcode for the current instance. + /// + /// + /// A represting the hashcode for this instance. + /// + public override int GetHashCode() + { + unsafe + { + fixed (int* k = Keys) + { + int hashcode = 0; + for (int i = 0; i < NumInts; i++) + hashcode ^= (k + i)->GetHashCode(); + return hashcode; + } + } + } + #endregion #region Internal Members From 73326138ee24e13ebac1bf31f2954fb4ff6b3853 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 08:42:20 +0000 Subject: [PATCH 039/130] Avoid numeric overflow when printing debug message. --- Source/OpenTK/Platform/Windows/WinGLNative.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index e350ad33..f0bf5633 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -411,7 +411,7 @@ namespace OpenTK.Platform.Windows default: if (!WMInput.KeyMap.ContainsKey((VirtualKeys)wParam)) { - Debug.Print("Virtual key {0} ({1}) not mapped.", (VirtualKeys)wParam, (int)lParam); + Debug.Print("Virtual key {0} ({1}) not mapped.", (VirtualKeys)wParam, (long)lParam); break; } else From 505399ba9facdd8e476103b60ecb90bcc1be9393 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 08:42:38 +0000 Subject: [PATCH 040/130] Implemented WinRawKeyboard input driver. --- .../OpenTK/Platform/Windows/WinRawKeyboard.cs | 112 ++++++++++-------- 1 file changed, 61 insertions(+), 51 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index 995d716e..c5c0b8b2 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -41,7 +41,10 @@ namespace OpenTK.Platform.Windows { internal class WinRawKeyboard : IKeyboardDriver, IDisposable { - private List keyboards = new List(); + readonly List keyboards = new List(); + // ContextHandle instead of IntPtr for fast dictionary access + readonly Dictionary rawids = new Dictionary(); + private List keyboards_old = new List(); private IntPtr window; #region --- Constructors --- @@ -134,8 +137,11 @@ namespace OpenTK.Platform.Windows //if (!keyboards.Contains(kb)) //{ this.RegisterKeyboardDevice(kb); - keyboards.Add(kb); + keyboards_old.Add(kb); //} + + keyboards.Add(new KeyboardState()); + rawids.Add(new ContextHandle(ridl[i].Device), keyboards.Count - 1); } } } @@ -181,58 +187,56 @@ namespace OpenTK.Platform.Windows /// internal bool ProcessKeyboardEvent(RawInput rin) { - //Keyboard key = keyboards[0]; - //rin.Header.Device; - switch (rin.Header.Type) + bool processed = false; + + bool pressed = + rin.Data.Keyboard.Message == (int)WindowMessage.KEYDOWN || + rin.Data.Keyboard.Message == (int)WindowMessage.SYSKEYDOWN; + + ContextHandle handle = new ContextHandle(rin.Header.Device); + KeyboardState keyboard; + if (!rawids.ContainsKey(handle)) { - case RawInputDeviceType.KEYBOARD: - bool pressed = - rin.Data.Keyboard.Message == (int)WindowMessage.KEYDOWN || - rin.Data.Keyboard.Message == (int)WindowMessage.SYSKEYDOWN; - - // Find the device where the button was pressed. It can be that the input notification - // came not from a physical keyboard device but from a code-generated input message - in - // that case, the event goes to the default (first) keyboard. - // TODO: Send the event to all keyboards instead of the default one. - // TODO: Optimize this! The predicate allocates way to much memory. - //int index = keyboards.FindIndex(delegate(KeyboardDevice kb) - //{ - // return kb.DeviceID == rin.Header.Device; - //}); - //if (index == -1) index = 0; - int index; - if (keyboards.Count > 0) index = 0; - else return false; + keyboards.Add(new KeyboardState()); + rawids.Add(handle, keyboards.Count - 1); + } + keyboard = keyboards[rawids[handle]]; - // Generic control, shift, alt keys may be sent instead of left/right. - // It seems you have to explicitly register left/right events. - switch (rin.Data.Keyboard.VKey) - { - case VirtualKeys.SHIFT: - keyboards[index][Input.Key.ShiftLeft] = keyboards[index][Input.Key.ShiftRight] = pressed; - return true; + // Generic control, shift, alt keys may be sent instead of left/right. + // It seems you have to explicitly register left/right events. + switch (rin.Data.Keyboard.VKey) + { + case VirtualKeys.SHIFT: + keyboard[Input.Key.ShiftLeft] = keyboard[Input.Key.ShiftRight] = pressed; + processed = true; + break; - case VirtualKeys.CONTROL: - keyboards[index][Input.Key.ControlLeft] = keyboards[index][Input.Key.ControlRight] = pressed; - return true; + case VirtualKeys.CONTROL: + keyboard[Input.Key.ControlLeft] = keyboard[Input.Key.ControlRight] = pressed; + processed = true; + break; - case VirtualKeys.MENU: - keyboards[index][Input.Key.AltLeft] = keyboards[index][Input.Key.AltRight] = pressed; - return true; - - default: - if (!WMInput.KeyMap.ContainsKey(rin.Data.Keyboard.VKey)) - Debug.Print("Virtual key {0} ({1}) not mapped.", - rin.Data.Keyboard.VKey, (int)rin.Data.Keyboard.VKey); - else - keyboards[index][WMInput.KeyMap[rin.Data.Keyboard.VKey]] = pressed; - - return false; - } + case VirtualKeys.MENU: + keyboard[Input.Key.AltLeft] = keyboard[Input.Key.AltRight] = pressed; + processed = true; + break; default: - throw new ApplicationException("Windows raw keyboard driver received invalid data."); + if (!WMInput.KeyMap.ContainsKey(rin.Data.Keyboard.VKey)) + { + Debug.Print("Virtual key {0} ({1}) not mapped.", + rin.Data.Keyboard.VKey, (int)rin.Data.Keyboard.VKey); + } + else + { + keyboard[WMInput.KeyMap[rin.Data.Keyboard.VKey]] = pressed; + processed = true; + } + break; } + + keyboards[rawids[handle]] = keyboard; + return processed; } #endregion @@ -255,17 +259,23 @@ namespace OpenTK.Platform.Windows public IList Keyboard { - get { return keyboards; } + get { return keyboards_old; } } public KeyboardState GetState() { - throw new NotImplementedException(); + if (keyboards.Count > 0) + return keyboards[0]; + else + return new KeyboardState(); } public KeyboardState GetState(int index) { - throw new NotImplementedException(); + if (keyboards.Count > index) + return keyboards[index]; + else + return new KeyboardState(); } #endregion @@ -286,7 +296,7 @@ namespace OpenTK.Platform.Windows { if (manual) { - keyboards.Clear(); + keyboards_old.Clear(); } disposed = true; } From f0e950817f3844c8df2aeb9b8b7e0044d45478c7 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 08:43:11 +0000 Subject: [PATCH 041/130] Added OpenTK.Compatibility.xml documentation to project. --- Source/Compatibility/OpenTK.Compatibility.csproj | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Source/Compatibility/OpenTK.Compatibility.csproj b/Source/Compatibility/OpenTK.Compatibility.csproj index 3815374e..68becfc3 100644 --- a/Source/Compatibility/OpenTK.Compatibility.csproj +++ b/Source/Compatibility/OpenTK.Compatibility.csproj @@ -478,6 +478,11 @@ Always + + + PreserveNewest + + From 2c57e44ff4233eb5070b4d400706df0abe18df99 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 08:43:36 +0000 Subject: [PATCH 042/130] Minor cosmetic change. --- Source/OpenTK/Platform/Windows/WinFactory.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/Source/OpenTK/Platform/Windows/WinFactory.cs b/Source/OpenTK/Platform/Windows/WinFactory.cs index b4c55db3..e5b02e50 100644 --- a/Source/OpenTK/Platform/Windows/WinFactory.cs +++ b/Source/OpenTK/Platform/Windows/WinFactory.cs @@ -76,7 +76,6 @@ namespace OpenTK.Platform.Windows public virtual OpenTK.Input.IKeyboardDriver CreateKeyboardDriver() { - return InputDriver.KeyboardDriver; } From 19287142d35c904be03f9803bc1a2ea5bd340430 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:00:07 +0000 Subject: [PATCH 043/130] Added missing documentation to OnResize. --- Source/OpenTK/GameWindow.cs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/Source/OpenTK/GameWindow.cs b/Source/OpenTK/GameWindow.cs index 6daa4102..6603b06f 100644 --- a/Source/OpenTK/GameWindow.cs +++ b/Source/OpenTK/GameWindow.cs @@ -1006,6 +1006,15 @@ namespace OpenTK #region OnResize + /// + /// Called when this window is resized. + /// + /// Not used. + /// + /// You will typically wish to update your viewport whenever + /// the window is resized. See the + /// method. + /// protected override void OnResize(EventArgs e) { base.OnResize(e); From 286f6f943930e814e3de8bde85f8d1abc253ec53 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:00:23 +0000 Subject: [PATCH 044/130] Marked int* overloads as non CLS-compliant. --- Source/OpenTK/Audio/OpenAL/AL/AL.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Source/OpenTK/Audio/OpenAL/AL/AL.cs b/Source/OpenTK/Audio/OpenAL/AL/AL.cs index ae180ccc..39191aa8 100644 --- a/Source/OpenTK/Audio/OpenAL/AL/AL.cs +++ b/Source/OpenTK/Audio/OpenAL/AL/AL.cs @@ -1272,6 +1272,7 @@ namespace OpenTK.Audio.OpenAL /// This function generates one or more buffers, which contain audio buffer (see AL.BufferData). References to buffers are uint values, which are used wherever a buffer reference is needed (in calls such as AL.DeleteBuffers, AL.Source with parameter ALSourcei, AL.SourceQueueBuffers, and AL.SourceUnqueueBuffers). /// The number of buffers to be generated. /// Pointer to an array of uint values which will store the names of the new buffers. + [CLSCompliant(false)] [DllImport(AL.Lib, EntryPoint = "alGenBuffers", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity] unsafe public static extern void GenBuffers(int n, [Out] int* buffers); @@ -1346,6 +1347,7 @@ namespace OpenTK.Audio.OpenAL /// This function deletes one or more buffers, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source (ALSourcei) and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source. /// The number of buffers to be deleted. /// Pointer to an array of buffer names identifying the buffers to be deleted. + [CLSCompliant(false)] [DllImport(AL.Lib, EntryPoint = "alDeleteBuffers", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] unsafe public static extern void DeleteBuffers(int n, [In] int* buffers); From 823fd29ce74cc3da47c7f37a2909a402eee186a0 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:00:36 +0000 Subject: [PATCH 045/130] Avoid using deprecated methods. --- Source/OpenTK/Graphics/OpenGL/GLHelper.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/OpenTK/Graphics/OpenGL/GLHelper.cs b/Source/OpenTK/Graphics/OpenGL/GLHelper.cs index 540660fd..8ecf5a19 100644 --- a/Source/OpenTK/Graphics/OpenGL/GLHelper.cs +++ b/Source/OpenTK/Graphics/OpenGL/GLHelper.cs @@ -932,7 +932,7 @@ namespace OpenTK.Graphics.OpenGL public static void TexEnv(TextureEnvTarget target, TextureEnvParameter pname, System.Drawing.Color color) { - Color4 c = new Color4(color); + Color4 c = new Color4(color.R, color.G, color.B, color.A); unsafe { TexEnv(target, pname, &c.R); From 58ba39acceb5edcf945bc343d561468ab83245a0 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:00:53 +0000 Subject: [PATCH 046/130] Fixed malformed documentation comments. --- Source/OpenTK/Input/MouseState.cs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Source/OpenTK/Input/MouseState.cs b/Source/OpenTK/Input/MouseState.cs index a4449aad..19c74451 100644 --- a/Source/OpenTK/Input/MouseState.cs +++ b/Source/OpenTK/Input/MouseState.cs @@ -126,7 +126,7 @@ namespace OpenTK.Input } /// - /// Gets a indicating whether the left mouse button is pressed. /// This property is intended for XNA compatibility. /// public ButtonState LeftButton @@ -135,7 +135,7 @@ namespace OpenTK.Input } /// - /// Gets a indicating whether the middle mouse button is pressed. /// This property is intended for XNA compatibility. /// public ButtonState MiddleButton @@ -144,7 +144,7 @@ namespace OpenTK.Input } /// - /// Gets a indicating whether the right mouse button is pressed. /// This property is intended for XNA compatibility. /// public ButtonState RightButton @@ -153,7 +153,7 @@ namespace OpenTK.Input } /// - /// Gets a indicating whether the first extra mouse button is pressed. /// This property is intended for XNA compatibility. /// public ButtonState XButton1 @@ -162,7 +162,7 @@ namespace OpenTK.Input } /// - /// Gets a indicating whether the second extra mouse button is pressed. /// This property is intended for XNA compatibility. /// public ButtonState XButton2 From 120e38f87a98c5ea19edd74e871ba75c9054a9b9 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:01:25 +0000 Subject: [PATCH 047/130] Suppressed unused field warnings. The fields are necessary for interop, even if not explicitly accessed. --- Source/OpenTK/Platform/X11/Structs.cs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Source/OpenTK/Platform/X11/Structs.cs b/Source/OpenTK/Platform/X11/Structs.cs index 180f455d..ac20cfe4 100644 --- a/Source/OpenTK/Platform/X11/Structs.cs +++ b/Source/OpenTK/Platform/X11/Structs.cs @@ -33,6 +33,9 @@ using System.Drawing; using System.Diagnostics; using System.Runtime.InteropServices; +// Disable unused field warnings. This is interop, we don't use everything +#pragma warning disable 0649 + // X11 Version namespace OpenTK.Platform.X11 { From dc4a55baabd6e32c346ea681cfae4a5a65b66f9d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:01:43 +0000 Subject: [PATCH 048/130] Don't shadow class field. --- Source/OpenTK/Platform/X11/X11DisplayDevice.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/OpenTK/Platform/X11/X11DisplayDevice.cs b/Source/OpenTK/Platform/X11/X11DisplayDevice.cs index 5c2d90b0..76788beb 100644 --- a/Source/OpenTK/Platform/X11/X11DisplayDevice.cs +++ b/Source/OpenTK/Platform/X11/X11DisplayDevice.cs @@ -39,7 +39,7 @@ namespace OpenTK.Platform.X11 using (new XLock(API.DefaultDisplay)) { List devices = new List(); - bool xinerama_supported = false; + xinerama_supported = false; try { xinerama_supported = QueryXinerama(devices); From c99dbc619c33efa32b809041ae11be8fbc0d770d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:01:54 +0000 Subject: [PATCH 049/130] Removed unused field. --- Source/OpenTK/Platform/X11/XI2Mouse.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/Source/OpenTK/Platform/X11/XI2Mouse.cs b/Source/OpenTK/Platform/X11/XI2Mouse.cs index c92984fd..6eb902f4 100644 --- a/Source/OpenTK/Platform/X11/XI2Mouse.cs +++ b/Source/OpenTK/Platform/X11/XI2Mouse.cs @@ -39,7 +39,6 @@ namespace OpenTK.Platform.X11 { List mice = new List(); Dictionary rawids = new Dictionary(); // maps raw ids to mouse ids - int first_mouse; readonly X11WindowInfo window; static int XIOpCode; From c227c36553bc8a699156445b2fcf0eea09760c0d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:31:00 +0000 Subject: [PATCH 050/130] Added code to raise all available events. Removed unused events from old OpenTK versions. Fixed potential race condition when raising events (an event might become null between the null check and the actual raising). --- .../OpenTK/Platform/MacOS/CarbonGLNative.cs | 123 +++++++++--------- Source/OpenTK/Platform/Windows/WinGLNative.cs | 113 ++++++++-------- Source/OpenTK/Platform/X11/X11GLNative.cs | 77 +++++------ 3 files changed, 148 insertions(+), 165 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index ea517095..fcf94717 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -144,6 +144,7 @@ namespace OpenTK.Platform.MacOS DisposeUPP(); + Disposed(this, EventArgs.Empty); } ~CarbonGLNative() @@ -419,11 +420,16 @@ namespace OpenTK.Platform.MacOS case WindowEventKind.WindowBoundsChanged: int thisWidth = Width; int thisHeight = Height; + int thisX = X; + int thisY = Y; LoadSize(); + if (thisX != X || thisY != Y) + Move(this, EventArgs.Empty); + if (thisWidth != Width || thisHeight != Height) - OnResize(); + Resize(this, EventArgs.Empty); return OSStatus.EventNotHandled; @@ -661,15 +667,6 @@ namespace OpenTK.Platform.MacOS API.SizeWindow(window.WindowRef, width, height, true); } - protected void OnResize() - { - LoadSize(); - - if (Resize != null) - { - Resize(this, EventArgs.Empty); - } - } private void LoadSize() { @@ -733,10 +730,16 @@ namespace OpenTK.Platform.MacOS public Icon Icon { - get { return mIcon; } - set { - SetIcon(value); - } + get { return mIcon; } + set + { + if (value != Icon) + { + SetIcon(value); + mIcon = value; + IconChanged(this, EventArgs.Empty); + } + } } private void SetIcon(Icon icon) @@ -798,8 +801,12 @@ namespace OpenTK.Platform.MacOS } set { - API.SetWindowTitle(window.WindowRef, value); - title = value; + if (value != Title) + { + API.SetWindowTitle(window.WindowRef, value); + title = value; + TitleChanged(this, EventArgs.Empty); + } } } @@ -808,10 +815,15 @@ namespace OpenTK.Platform.MacOS get { return API.IsWindowVisible(window.WindowRef); } set { - if (value && Visible == false) - Show(); - else - Hide(); + if (value != Visible) + { + if (value) + Show(); + else + Hide(); + + VisibleChanged(this, EventArgs.Empty); + } } } @@ -917,7 +929,8 @@ namespace OpenTK.Platform.MacOS set { API.SizeWindow(window.WindowRef, (short)value.Width, (short)value.Height, true); - OnResize(); + LoadSize(); + Resize(this, EventArgs.Empty); } } @@ -1019,9 +1032,9 @@ namespace OpenTK.Platform.MacOS } - OnWindowStateChanged(); - - OnResize(); + WindowStateChanged(this, EventArgs.Empty); + LoadSize(); + Resize(this, EventArgs.Empty); } public WindowBorder WindowBorder @@ -1048,8 +1061,7 @@ namespace OpenTK.Platform.MacOS WindowAttributes.Resizable | WindowAttributes.FullZoom); } - if (WindowBorderChanged != null) - WindowBorderChanged(this, EventArgs.Empty); + WindowBorderChanged(this, EventArgs.Empty); } } @@ -1057,76 +1069,65 @@ namespace OpenTK.Platform.MacOS private void OnKeyPress(KeyPressEventArgs keyPressArgs) { - if (KeyPress != null) - KeyPress(this, keyPressArgs); + KeyPress(this, keyPressArgs); } private void OnWindowStateChanged() { - if (WindowStateChanged != null) - WindowStateChanged(this, EventArgs.Empty); + WindowStateChanged(this, EventArgs.Empty); } protected virtual void OnClosing(CancelEventArgs e) { - if (Closing != null) - Closing(this, e); + Closing(this, e); } protected virtual void OnClosed() { - if (Closed != null) - Closed(this, EventArgs.Empty); + Closed(this, EventArgs.Empty); } private void OnMouseLeave() { - if (MouseLeave != null) - MouseLeave(this, EventArgs.Empty); + MouseLeave(this, EventArgs.Empty); } private void OnMouseEnter() { - if (MouseEnter != null) - MouseEnter(this, EventArgs.Empty); + MouseEnter(this, EventArgs.Empty); } private void OnActivate() { mIsActive = true; - if (FocusedChanged != null) - FocusedChanged(this, EventArgs.Empty); + FocusedChanged(this, EventArgs.Empty); } private void OnDeactivate() { mIsActive = false; - if (FocusedChanged != null) - FocusedChanged(this, EventArgs.Empty); + FocusedChanged(this, EventArgs.Empty); } #endregion - public event EventHandler Idle; - public event EventHandler Load; - public event EventHandler Unload; - public event EventHandler Move; - public event EventHandler Resize; - public event EventHandler Closing; - public event EventHandler Closed; - public event EventHandler Disposed; - public event EventHandler IconChanged; - public event EventHandler TitleChanged; - public event EventHandler ClientSizeChanged; - public event EventHandler VisibleChanged; - public event EventHandler WindowInfoChanged; - public event EventHandler FocusedChanged; - public event EventHandler WindowBorderChanged; - public event EventHandler WindowStateChanged; - public event EventHandler KeyPress; - public event EventHandler MouseEnter; - public event EventHandler MouseLeave; + public event EventHandler Load = delegate { }; + public event EventHandler Unload = delegate { }; + public event EventHandler Move = delegate { }; + public event EventHandler Resize = delegate { }; + public event EventHandler Closing = delegate { }; + public event EventHandler Closed = delegate { }; + public event EventHandler Disposed = delegate { }; + public event EventHandler IconChanged = delegate { }; + public event EventHandler TitleChanged = delegate { }; + public event EventHandler VisibleChanged = delegate { }; + public event EventHandler FocusedChanged = delegate { }; + public event EventHandler WindowBorderChanged = delegate { }; + public event EventHandler WindowStateChanged = delegate { }; + public event EventHandler KeyPress = delegate { }; + public event EventHandler MouseEnter = delegate { }; + public event EventHandler MouseLeave = delegate { }; #endregion } diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index f0bf5633..0650a819 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -156,7 +156,7 @@ namespace OpenTK.Platform.Windows else focused = (wParam.ToInt64() & 0xFFFF) != 0; - if (new_focused_state != Focused && FocusedChanged != null) + if (new_focused_state != Focused) FocusedChanged(this, EventArgs.Empty); break; @@ -188,8 +188,7 @@ namespace OpenTK.Platform.Windows if (Location != new_location) { bounds.Location = new_location; - if (Move != null) - Move(this, EventArgs.Empty); + Move(this, EventArgs.Empty); } Size new_size = new Size(pos->cx, pos->cy); @@ -206,7 +205,7 @@ namespace OpenTK.Platform.Windows SetWindowPosFlags.NOZORDER | SetWindowPosFlags.NOOWNERZORDER | SetWindowPosFlags.NOACTIVATE | SetWindowPosFlags.NOSENDCHANGING); - if (suppress_resize <= 0 && Resize != null) + if (suppress_resize <= 0) Resize(this, EventArgs.Empty); } @@ -254,8 +253,7 @@ namespace OpenTK.Platform.Windows if (new_state != windowState) { windowState = new_state; - if (WindowStateChanged != null) - WindowStateChanged(this, EventArgs.Empty); + WindowStateChanged(this, EventArgs.Empty); } // Ensure cursor remains grabbed @@ -274,8 +272,7 @@ namespace OpenTK.Platform.Windows else key_press.KeyChar = (char)wParam.ToInt64(); - if (KeyPress != null) - KeyPress(this, key_press); + KeyPress(this, key_press); break; case WindowMessage.MOUSEMOVE: @@ -291,8 +288,7 @@ namespace OpenTK.Platform.Windows mouse_outside_window = false; EnableMouseTracking(); - if (MouseEnter != null) - MouseEnter(this, EventArgs.Empty); + MouseEnter(this, EventArgs.Empty); } break; @@ -300,8 +296,7 @@ namespace OpenTK.Platform.Windows mouse_outside_window = true; // Mouse tracking is disabled automatically by the OS - if (MouseLeave != null) - MouseLeave(this, EventArgs.Empty); + MouseLeave(this, EventArgs.Empty); break; case WindowMessage.MOUSEWHEEL: @@ -453,13 +448,11 @@ namespace OpenTK.Platform.Windows case WindowMessage.CLOSE: System.ComponentModel.CancelEventArgs e = new System.ComponentModel.CancelEventArgs(); - if (Closing != null) - Closing(this, e); + Closing(this, e); if (!e.Cancel) { - if (Unload != null) - Unload(this, EventArgs.Empty); + Unload(this, EventArgs.Empty); DestroyWindow(); break; @@ -474,8 +467,7 @@ namespace OpenTK.Platform.Windows window.Dispose(); child_window.Dispose(); - if (Closed != null) - Closed(this, EventArgs.Empty); + Closed(this, EventArgs.Empty); break; @@ -795,11 +787,15 @@ namespace OpenTK.Platform.Windows } set { - icon = value; - if (window.WindowHandle != IntPtr.Zero) + if (value != icon) { - Functions.SendMessage(window.WindowHandle, WindowMessage.SETICON, (IntPtr)0, icon == null ? IntPtr.Zero : value.Handle); - Functions.SendMessage(window.WindowHandle, WindowMessage.SETICON, (IntPtr)1, icon == null ? IntPtr.Zero : value.Handle); + icon = value; + if (window.WindowHandle != IntPtr.Zero) + { + Functions.SendMessage(window.WindowHandle, WindowMessage.SETICON, (IntPtr)0, icon == null ? IntPtr.Zero : value.Handle); + Functions.SendMessage(window.WindowHandle, WindowMessage.SETICON, (IntPtr)1, icon == null ? IntPtr.Zero : value.Handle); + } + IconChanged(this, EventArgs.Empty); } } } @@ -829,8 +825,12 @@ namespace OpenTK.Platform.Windows } set { - if (!Functions.SetWindowText(window.WindowHandle, value)) - Debug.Print("Failed to change window title (window:{0}, new title:{1}, reason:{2}).", window.WindowHandle, value, Marshal.GetLastWin32Error()); + if (Title != value) + { + if (!Functions.SetWindowText(window.WindowHandle, value)) + Debug.Print("Failed to change window title (window:{0}, new title:{1}, reason:{2}).", window.WindowHandle, value, Marshal.GetLastWin32Error()); + TitleChanged(this, EventArgs.Empty); + } } } @@ -846,18 +846,23 @@ namespace OpenTK.Platform.Windows } set { - if (value) + if (value != Visible) { - Functions.ShowWindow(window.WindowHandle, ShowWindowCommand.SHOW); - if (invisible_since_creation) + if (value) { - Functions.BringWindowToTop(window.WindowHandle); - Functions.SetForegroundWindow(window.WindowHandle); + Functions.ShowWindow(window.WindowHandle, ShowWindowCommand.SHOW); + if (invisible_since_creation) + { + Functions.BringWindowToTop(window.WindowHandle); + Functions.SetForegroundWindow(window.WindowHandle); + } } - } - else if (!value) - { - Functions.ShowWindow(window.WindowHandle, ShowWindowCommand.HIDE); + else if (!value) + { + Functions.ShowWindow(window.WindowHandle, ShowWindowCommand.HIDE); + } + + VisibleChanged(this, EventArgs.Empty); } } } @@ -1076,8 +1081,7 @@ namespace OpenTK.Platform.Windows WindowState = state; - if (WindowBorderChanged != null) - WindowBorderChanged(this, EventArgs.Empty); + WindowBorderChanged(this, EventArgs.Empty); } } @@ -1113,43 +1117,37 @@ namespace OpenTK.Platform.Windows #region Events - public event EventHandler Idle; + public event EventHandler Load =delegate { }; - public event EventHandler Load; + public event EventHandler Unload = delegate { }; - public event EventHandler Unload; + public event EventHandler Move = delegate { }; - public event EventHandler Move; + public event EventHandler Resize = delegate { }; - public event EventHandler Resize; + public event EventHandler Closing = delegate { }; - public event EventHandler Closing; + public event EventHandler Closed = delegate { }; - public event EventHandler Closed; + public event EventHandler Disposed = delegate { }; - public event EventHandler Disposed; + public event EventHandler IconChanged = delegate { }; - public event EventHandler IconChanged; + public event EventHandler TitleChanged = delegate { }; - public event EventHandler TitleChanged; + public event EventHandler VisibleChanged = delegate { }; - public event EventHandler ClientSizeChanged; + public event EventHandler FocusedChanged = delegate { }; - public event EventHandler VisibleChanged; + public event EventHandler WindowBorderChanged = delegate { }; - public event EventHandler WindowInfoChanged; + public event EventHandler WindowStateChanged = delegate { }; - public event EventHandler FocusedChanged; + public event EventHandler KeyPress = delegate { }; - public event EventHandler WindowBorderChanged; + public event EventHandler MouseEnter = delegate { }; - public event EventHandler WindowStateChanged; - - public event EventHandler KeyPress; - - public event EventHandler MouseEnter; - - public event EventHandler MouseLeave; + public event EventHandler MouseLeave = delegate { }; #endregion @@ -1280,6 +1278,7 @@ namespace OpenTK.Platform.Windows Debug.Print("[Warning] INativeWindow leaked ({0}). Did you forget to call INativeWindow.Dispose()?", this); } + Disposed(this, EventArgs.Empty); disposed = true; } } diff --git a/Source/OpenTK/Platform/X11/X11GLNative.cs b/Source/OpenTK/Platform/X11/X11GLNative.cs index 9ef2de18..92e928bd 100644 --- a/Source/OpenTK/Platform/X11/X11GLNative.cs +++ b/Source/OpenTK/Platform/X11/X11GLNative.cs @@ -659,8 +659,7 @@ namespace OpenTK.Platform.X11 if (Location != new_location) { bounds.Location = new_location; - if (Move != null) - Move(this, EventArgs.Empty); + Move(this, EventArgs.Empty); } // Note: width and height denote the internal (client) size. @@ -673,11 +672,7 @@ namespace OpenTK.Platform.X11 bounds.Size = new_size; client_rectangle.Size = new Size(e.ConfigureEvent.width, e.ConfigureEvent.height); - if (this.Resize != null) - { - //Debug.WriteLine(new System.Diagnostics.StackTrace()); - Resize(this, EventArgs.Empty); - } + Resize(this, EventArgs.Empty); } } @@ -723,8 +718,7 @@ namespace OpenTK.Platform.X11 bool previous_visible = visible; visible = true; if (visible != previous_visible) - if (VisibleChanged != null) - VisibleChanged(this, EventArgs.Empty); + VisibleChanged(this, EventArgs.Empty); } return; @@ -733,8 +727,7 @@ namespace OpenTK.Platform.X11 bool previous_visible = visible; visible = false; if (visible != previous_visible) - if (VisibleChanged != null) - VisibleChanged(this, EventArgs.Empty); + VisibleChanged(this, EventArgs.Empty); } break; @@ -747,8 +740,7 @@ namespace OpenTK.Platform.X11 { Debug.WriteLine("Exit message received."); CancelEventArgs ce = new CancelEventArgs(); - if (Closing != null) - Closing(this, ce); + Closing(this, ce); if (!ce.Cancel) { @@ -769,8 +761,7 @@ namespace OpenTK.Platform.X11 Debug.WriteLine("Window destroyed"); exists = false; - if (Closed != null) - Closed(this, EventArgs.Empty); + Closed(this, EventArgs.Empty); return; @@ -813,8 +804,7 @@ namespace OpenTK.Platform.X11 bool previous_focus = has_focus; has_focus = true; if (has_focus != previous_focus) - if (FocusedChanged != null) - FocusedChanged(this, EventArgs.Empty); + FocusedChanged(this, EventArgs.Empty); } break; @@ -823,19 +813,16 @@ namespace OpenTK.Platform.X11 bool previous_focus = has_focus; has_focus = false; if (has_focus != previous_focus) - if (FocusedChanged != null) - FocusedChanged(this, EventArgs.Empty); + FocusedChanged(this, EventArgs.Empty); } break; case XEventName.LeaveNotify: - if (MouseLeave != null) - MouseLeave(this, EventArgs.Empty); + MouseLeave(this, EventArgs.Empty); break; case XEventName.EnterNotify: - if (MouseEnter != null) - MouseEnter(this, EventArgs.Empty); + MouseEnter(this, EventArgs.Empty); break; case XEventName.MappingNotify: @@ -850,8 +837,7 @@ namespace OpenTK.Platform.X11 case XEventName.PropertyNotify: if (e.PropertyEvent.atom == _atom_net_wm_state) { - if (WindowStateChanged != null) - WindowStateChanged(this, EventArgs.Empty); + WindowStateChanged(this, EventArgs.Empty); } //if (e.PropertyEvent.atom == _atom_net_frame_extents) @@ -1078,8 +1064,7 @@ namespace OpenTK.Platform.X11 } icon = value; - if (IconChanged != null) - IconChanged(this, EventArgs.Empty); + IconChanged(this, EventArgs.Empty); } } @@ -1277,8 +1262,7 @@ namespace OpenTK.Platform.X11 break; } - if (WindowBorderChanged != null) - WindowBorderChanged(this, EventArgs.Empty); + WindowBorderChanged(this, EventArgs.Empty); } } @@ -1286,37 +1270,37 @@ namespace OpenTK.Platform.X11 #region Events - public event EventHandler Load; + public event EventHandler Load = delegate { }; - public event EventHandler Unload; + public event EventHandler Unload = delegate { }; - public event EventHandler Move; + public event EventHandler Move = delegate { }; - public event EventHandler Resize; + public event EventHandler Resize = delegate { }; - public event EventHandler Closing; + public event EventHandler Closing = delegate { }; - public event EventHandler Closed; + public event EventHandler Closed = delegate { }; - public event EventHandler Disposed; + public event EventHandler Disposed = delegate { }; - public event EventHandler IconChanged; + public event EventHandler IconChanged = delegate { }; - public event EventHandler TitleChanged; + public event EventHandler TitleChanged = delegate { }; - public event EventHandler VisibleChanged; + public event EventHandler VisibleChanged = delegate { }; - public event EventHandler FocusedChanged; + public event EventHandler FocusedChanged = delegate { }; - public event EventHandler WindowBorderChanged; + public event EventHandler WindowBorderChanged = delegate { }; - public event EventHandler WindowStateChanged; + public event EventHandler WindowStateChanged = delegate { }; - public event EventHandler KeyPress; + public event EventHandler KeyPress = delegate { }; - public event EventHandler MouseEnter; + public event EventHandler MouseEnter = delegate { }; - public event EventHandler MouseLeave; + public event EventHandler MouseLeave = delegate { }; #endregion @@ -1427,8 +1411,7 @@ namespace OpenTK.Platform.X11 } } - if (TitleChanged != null) - TitleChanged(this, EventArgs.Empty); + TitleChanged(this, EventArgs.Empty); } } From f6bf0c95c65935ace1e9494a207850e58b03cfa8 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:31:20 +0000 Subject: [PATCH 051/130] Fixed ambiguous documentation reference. --- Source/OpenTK/GameWindow.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/OpenTK/GameWindow.cs b/Source/OpenTK/GameWindow.cs index 6603b06f..383f9d9b 100644 --- a/Source/OpenTK/GameWindow.cs +++ b/Source/OpenTK/GameWindow.cs @@ -1013,7 +1013,7 @@ namespace OpenTK /// /// You will typically wish to update your viewport whenever /// the window is resized. See the - /// method. + /// method. /// protected override void OnResize(EventArgs e) { From 0a9d0685a11ffc382a1bb5a0ed175cfa7a47712d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:34:13 +0000 Subject: [PATCH 052/130] Removed events that are not part of the INativeWindow interface. --- Source/OpenTK/Platform/MacOS/CarbonGLNative.cs | 2 -- Source/OpenTK/Platform/Windows/WinGLNative.cs | 6 ------ Source/OpenTK/Platform/X11/X11GLNative.cs | 4 ---- 3 files changed, 12 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index fcf94717..a656a430 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -1112,8 +1112,6 @@ namespace OpenTK.Platform.MacOS #endregion - public event EventHandler Load = delegate { }; - public event EventHandler Unload = delegate { }; public event EventHandler Move = delegate { }; public event EventHandler Resize = delegate { }; public event EventHandler Closing = delegate { }; diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 0650a819..6d12dde6 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -452,8 +452,6 @@ namespace OpenTK.Platform.Windows if (!e.Cancel) { - Unload(this, EventArgs.Empty); - DestroyWindow(); break; } @@ -1117,10 +1115,6 @@ namespace OpenTK.Platform.Windows #region Events - public event EventHandler Load =delegate { }; - - public event EventHandler Unload = delegate { }; - public event EventHandler Move = delegate { }; public event EventHandler Resize = delegate { }; diff --git a/Source/OpenTK/Platform/X11/X11GLNative.cs b/Source/OpenTK/Platform/X11/X11GLNative.cs index 92e928bd..4fc2a91b 100644 --- a/Source/OpenTK/Platform/X11/X11GLNative.cs +++ b/Source/OpenTK/Platform/X11/X11GLNative.cs @@ -1270,10 +1270,6 @@ namespace OpenTK.Platform.X11 #region Events - public event EventHandler Load = delegate { }; - - public event EventHandler Unload = delegate { }; - public event EventHandler Move = delegate { }; public event EventHandler Resize = delegate { }; From 55127769439d225f18dc4a739e214851c1769253 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 09:37:57 +0000 Subject: [PATCH 053/130] Fixed potential race condition when raising events: an event might be modified to null after the null check and before being raised. --- Source/OpenTK/GameWindow.cs | 16 +++++----- Source/OpenTK/NativeWindow.cs | 56 +++++++++++++++++------------------ 2 files changed, 36 insertions(+), 36 deletions(-) diff --git a/Source/OpenTK/GameWindow.cs b/Source/OpenTK/GameWindow.cs index 383f9d9b..b44191bc 100644 --- a/Source/OpenTK/GameWindow.cs +++ b/Source/OpenTK/GameWindow.cs @@ -316,7 +316,7 @@ namespace OpenTK /// Not used. protected virtual void OnLoad(EventArgs e) { - if (Load != null) Load(this, e); + Load(this, e); } #endregion @@ -329,7 +329,7 @@ namespace OpenTK /// Not used. protected virtual void OnUnload(EventArgs e) { - if (Unload != null) Unload(this, e); + Unload(this, e); } #endregion @@ -929,22 +929,22 @@ namespace OpenTK /// /// Occurs before the window is displayed for the first time. /// - public event EventHandler Load; + public event EventHandler Load = delegate { }; /// /// Occurs when it is time to render a frame. /// - public event EventHandler RenderFrame; + public event EventHandler RenderFrame = delegate { }; /// /// Occurs before the window is destroyed. /// - public event EventHandler Unload; + public event EventHandler Unload = delegate { }; /// /// Occurs when it is time to update a frame. /// - public event EventHandler UpdateFrame; + public event EventHandler UpdateFrame = delegate { }; #endregion @@ -973,7 +973,7 @@ namespace OpenTK /// protected virtual void OnRenderFrame(FrameEventArgs e) { - if (RenderFrame != null) RenderFrame(this, e); + RenderFrame(this, e); } #endregion @@ -989,7 +989,7 @@ namespace OpenTK /// protected virtual void OnUpdateFrame(FrameEventArgs e) { - if (UpdateFrame != null) UpdateFrame(this, e); + UpdateFrame(this, e); } #endregion diff --git a/Source/OpenTK/NativeWindow.cs b/Source/OpenTK/NativeWindow.cs index 681eb3ef..dd7467f9 100644 --- a/Source/OpenTK/NativeWindow.cs +++ b/Source/OpenTK/NativeWindow.cs @@ -566,72 +566,72 @@ namespace OpenTK /// /// Occurs after the window has closed. /// - public event EventHandler Closed; + public event EventHandler Closed = delegate { }; /// /// Occurs when the window is about to close. /// - public event EventHandler Closing; + public event EventHandler Closing = delegate { }; /// /// Occurs when the window is disposed. /// - public event EventHandler Disposed; + public event EventHandler Disposed = delegate { }; /// /// Occurs when the property of the window changes. /// - public event EventHandler FocusedChanged; + public event EventHandler FocusedChanged = delegate { }; /// /// Occurs when the property of the window changes. /// - public event EventHandler IconChanged; + public event EventHandler IconChanged = delegate { }; /// /// Occurs whenever a character is typed. /// - public event EventHandler KeyPress; + public event EventHandler KeyPress = delegate { }; /// /// Occurs whenever the window is moved. /// - public event EventHandler Move; + public event EventHandler Move = delegate { }; /// /// Occurs whenever the mouse cursor enters the window . /// - public event EventHandler MouseEnter; + public event EventHandler MouseEnter = delegate { }; /// /// Occurs whenever the mouse cursor leaves the window . /// - public event EventHandler MouseLeave; + public event EventHandler MouseLeave = delegate { }; /// /// Occurs whenever the window is resized. /// - public event EventHandler Resize; + public event EventHandler Resize = delegate { }; /// /// Occurs when the property of the window changes. /// - public event EventHandler TitleChanged; + public event EventHandler TitleChanged = delegate { }; /// /// Occurs when the property of the window changes. /// - public event EventHandler VisibleChanged; + public event EventHandler VisibleChanged = delegate { }; /// /// Occurs when the property of the window changes. /// - public event EventHandler WindowBorderChanged; + public event EventHandler WindowBorderChanged = delegate { }; /// /// Occurs when the property of the window changes. /// - public event EventHandler WindowStateChanged; + public event EventHandler WindowStateChanged = delegate { }; #endregion @@ -705,7 +705,7 @@ namespace OpenTK /// Not used. protected virtual void OnClosed(EventArgs e) { - if (Closed != null) Closed(this, e); + Closed(this, e); } #endregion @@ -720,7 +720,7 @@ namespace OpenTK /// Set e.Cancel to true in order to stop the NativeWindow from closing. protected virtual void OnClosing(CancelEventArgs e) { - if (Closing != null) Closing(this, e); + Closing(this, e); } #endregion @@ -733,7 +733,7 @@ namespace OpenTK /// Not used. protected virtual void OnDisposed(EventArgs e) { - if (Disposed != null) Disposed(this, e); + Disposed(this, e); } #endregion @@ -746,7 +746,7 @@ namespace OpenTK /// Not used. protected virtual void OnFocusedChanged(EventArgs e) { - if (FocusedChanged != null) FocusedChanged(this, e); + FocusedChanged(this, e); } #endregion @@ -759,7 +759,7 @@ namespace OpenTK /// Not used. protected virtual void OnIconChanged(EventArgs e) { - if (IconChanged != null) IconChanged(this, e); + IconChanged(this, e); } #endregion @@ -772,7 +772,7 @@ namespace OpenTK /// The for this event. protected virtual void OnKeyPress(KeyPressEventArgs e) { - if (KeyPress != null) KeyPress(this, e); + KeyPress(this, e); } #endregion @@ -785,7 +785,7 @@ namespace OpenTK /// Not used. protected virtual void OnMove(EventArgs e) { - if (Move != null) Move(this, e); + Move(this, e); } #endregion @@ -798,7 +798,7 @@ namespace OpenTK /// Not used. protected virtual void OnMouseEnter(EventArgs e) { - if (MouseEnter != null) MouseEnter(this, e); + MouseEnter(this, e); } #endregion @@ -811,7 +811,7 @@ namespace OpenTK /// Not used. protected virtual void OnMouseLeave(EventArgs e) { - if (MouseLeave != null) MouseLeave(this, e); + MouseLeave(this, e); } #endregion @@ -824,7 +824,7 @@ namespace OpenTK /// Not used. protected virtual void OnResize(EventArgs e) { - if (Resize != null) Resize(this, e); + Resize(this, e); } #endregion @@ -837,7 +837,7 @@ namespace OpenTK /// Not used. protected virtual void OnTitleChanged(EventArgs e) { - if (TitleChanged != null) TitleChanged(this, e); + TitleChanged(this, e); } #endregion @@ -850,7 +850,7 @@ namespace OpenTK /// Not used. protected virtual void OnVisibleChanged(EventArgs e) { - if (VisibleChanged != null) VisibleChanged(this, e); + VisibleChanged(this, e); } #endregion @@ -863,7 +863,7 @@ namespace OpenTK /// Not used. protected virtual void OnWindowBorderChanged(EventArgs e) { - if (WindowBorderChanged != null) WindowBorderChanged(this, e); + WindowBorderChanged(this, e); } #endregion @@ -876,7 +876,7 @@ namespace OpenTK /// Not used. protected virtual void OnWindowStateChanged(EventArgs e) { - if (WindowStateChanged != null) WindowStateChanged(this, e); + WindowStateChanged(this, e); } #endregion From 3811cf5f460587eccbbafea6d072a49ad569e58a Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 10:30:35 +0000 Subject: [PATCH 054/130] Use SVN or Bazaar version numbers as build revision. If neither is available, use seconds since start of day. --- .../Build.UpdateVersion.csproj | 3 + Source/Build.UpdateVersion/Program.cs | 90 +++++++++++++++++-- 2 files changed, 85 insertions(+), 8 deletions(-) diff --git a/Source/Build.UpdateVersion/Build.UpdateVersion.csproj b/Source/Build.UpdateVersion/Build.UpdateVersion.csproj index 071361e1..ebbeab49 100644 --- a/Source/Build.UpdateVersion/Build.UpdateVersion.csproj +++ b/Source/Build.UpdateVersion/Build.UpdateVersion.csproj @@ -30,6 +30,9 @@ + + + diff --git a/Source/Build.UpdateVersion/Program.cs b/Source/Build.UpdateVersion/Program.cs index 019f6d99..caaac6fa 100644 --- a/Source/Build.UpdateVersion/Program.cs +++ b/Source/Build.UpdateVersion/Program.cs @@ -26,20 +26,38 @@ #endregion using System; +using System.Diagnostics; using System.IO; namespace Build.UpdateVersion { - class Program - { + class Program + { const string Major = "1"; const string Minor = "0"; + static string RootDirectory; + static string SourceDirectory; + public static void Main() { + string wdir = Environment.CurrentDirectory; + if (Directory.GetParent(wdir).Name == "Source") + { + // Running through msbuild inside Source/Build.UpdateVersion/ + RootDirectory = "../.."; + SourceDirectory = ".."; + } + else + { + // Running manually inside Binaries/OpenTK/[Debug|Release]/ + RootDirectory = "../../.."; + SourceDirectory = "../../../Source"; + } + DateTime now = DateTime.UtcNow; - GenerateVersionInfo(now, "../../Version.txt"); - GenerateAssemblyInfo(now, "../GlobalAssemblyInfo.cs"); + GenerateVersionInfo(now, Path.Combine(RootDirectory, "Version.txt")); + GenerateAssemblyInfo(now, Path.Combine(SourceDirectory, "GlobalAssemblyInfo.cs")); } static void GenerateVersionInfo(DateTime now, string file) @@ -54,7 +72,7 @@ namespace Build.UpdateVersion version = lines[0]; } } - + // If the file does not exist, create it. if (version == null) { @@ -69,7 +87,9 @@ namespace Build.UpdateVersion // Revision number is defined as the fraction of the current day, expressed in seconds. double timespan = now.Subtract(new DateTime(2010, 1, 1)).TotalDays; string build = ((int)timespan).ToString(); - string revision = ((int)((timespan - (int)timespan) * UInt16.MaxValue)).ToString(); + + string revision = RetrieveSvnRevision() ?? RetrieveBzrRevision() ?? RetrieveSeconds(timespan); + //string revision = RetrieveSvnRevision() ?? RetrieveSeconds(timespan); File.WriteAllLines(file, new string[] { @@ -90,5 +110,59 @@ namespace Build.UpdateVersion String.Format("[assembly: AssemblyFileVersion(\"{0}.{1}.{2}.{3}\")]", Major, Minor, build, revision), }); } - } -} + + static string RetrieveSeconds(double timespan) + { + string revision = ((int)((timespan - (int)timespan) * UInt16.MaxValue)).ToString(); + return revision; + } + + static string RetrieveSvnRevision() + { + try + { + string output = RunProcess("svn", "info", RootDirectory); + + const string RevisionText = "Revision: "; + int index = output.IndexOf(RevisionText); + if (index > -1) + return output.Substring(index + RevisionText.Length, 5) + .Replace('\r', ' ').Replace('\n', ' ').Trim(); + } + catch (Exception e) + { + Debug.Print("Failed to retrieve svn revision. Error: {0}", e); + } + return null; + } + + static string RetrieveBzrRevision() + { + try + { + string output = RunProcess("bzr", "revno", RootDirectory); + return output != null && !output.StartsWith("bzr") ? output : null; + } + catch (Exception e) + { + Debug.Print("Failed to retrieve svn revision. Error: {0}", e); + } + return null; + } + + static string RunProcess(string cmd, string args, string wdir) + { + ProcessStartInfo info = new ProcessStartInfo(cmd, args); + info.WorkingDirectory = wdir; + info.RedirectStandardOutput = true; + info.RedirectStandardError = true; + info.UseShellExecute = false; + Process p = new Process(); + p.StartInfo = info; + p.Start(); + p.WaitForExit(); + string output = p.StandardOutput.ReadToEnd(); + return output; + } + } +} \ No newline at end of file From f178bebfe6a9140e00ac7cbc8a8a04eca5aeed01 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 10:36:28 +0000 Subject: [PATCH 055/130] Fixed capacity parameter for GetWindowText(). Fixed debug string format that is printed when GetWindowText() fails. --- Source/OpenTK/Platform/Windows/WinGLNative.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 6d12dde6..b6994aa9 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -817,8 +817,8 @@ namespace OpenTK.Platform.Windows get { sb_title.Remove(0, sb_title.Length); - if (Functions.GetWindowText(window.WindowHandle, sb_title, sb_title.MaxCapacity) == 0) - Debug.Print("Failed to retrieve window title (window:{0}, reason:{2}).", window.WindowHandle, Marshal.GetLastWin32Error()); + if (Functions.GetWindowText(window.WindowHandle, sb_title, sb_title.Capacity) == 0) + Debug.Print("Failed to retrieve window title (window:{0}, reason:{1}).", window.WindowHandle, Marshal.GetLastWin32Error()); return sb_title.ToString(); } set From 70518c40a2d8597529bdf4fc1bd092a8a9dd3d85 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 10:37:20 +0000 Subject: [PATCH 056/130] Read OpenTK.Input.Keyboard state. Should gradually replace existing keyboard/mouse events with the new input API. --- Source/Examples/OpenTK/Test/GameWindowStates.cs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Source/Examples/OpenTK/Test/GameWindowStates.cs b/Source/Examples/OpenTK/Test/GameWindowStates.cs index c53a3fa8..4fd419b7 100644 --- a/Source/Examples/OpenTK/Test/GameWindowStates.cs +++ b/Source/Examples/OpenTK/Test/GameWindowStates.cs @@ -24,6 +24,7 @@ namespace Examples.Tests bool viewport_changed = true; bool refresh_text = true; MouseState mouse, mouse_old; + KeyboardState keyboard, keyboard_old; public GameWindowStates() : base(800, 600) @@ -39,6 +40,7 @@ namespace Examples.Tests Resize += delegate { refresh_text = true; }; WindowBorderChanged += delegate { refresh_text = true; }; WindowStateChanged += delegate { refresh_text = true; }; + FocusedChanged += delegate { refresh_text = true; }; Mouse.Move += MouseMoveHandler; Mouse.ButtonDown += MouseButtonHandler; Mouse.ButtonUp += MouseButtonHandler; @@ -108,6 +110,10 @@ namespace Examples.Tests if (mouse != mouse_old) refresh_text = true; mouse_old = mouse; + keyboard = OpenTK.Input.Keyboard.GetState(); + if (keyboard != keyboard_old) + refresh_text = true; + keyboard = keyboard_old; if (refresh_text) { From 5fd0340bb973cd632d4e8d9664acbd7baeb4935c Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 11:10:19 +0000 Subject: [PATCH 057/130] Added argument validation for GetState(index) and serializes access to GetState() implementation. Clarified GetState() documentation to explain that it returns combined device state. --- Source/OpenTK/Input/Keyboard.cs | 20 +++++++++++++++----- Source/OpenTK/Input/Mouse.cs | 20 ++++++++++++++------ 2 files changed, 29 insertions(+), 11 deletions(-) diff --git a/Source/OpenTK/Input/Keyboard.cs b/Source/OpenTK/Input/Keyboard.cs index 104a92fd..f2838c9f 100644 --- a/Source/OpenTK/Input/Keyboard.cs +++ b/Source/OpenTK/Input/Keyboard.cs @@ -40,28 +40,38 @@ namespace OpenTK.Input static readonly IKeyboardDriver driver = Platform.Factory.Default.CreateKeyboardDriver(); + static readonly object SyncRoot = new object(); #endregion #region Public Members /// - /// Retrieves the KeyboardState for the default keyboard device. + /// Retrieves the combined for all keyboard devices. /// - /// A structure containing the state of the keyboard device. + /// A structure containing the combined state for all keyboard devices. public static KeyboardState GetState() { - return driver.GetState(); + lock (SyncRoot) + { + return driver.GetState(); + } } /// - /// Retrieves the KeyboardState for the specified keyboard device. + /// Retrieves the for the specified keyboard device. /// /// The index of the keyboard device. /// A structure containing the state of the keyboard device. public static KeyboardState GetState(int index) { - return driver.GetState(index); + if (index < 0) + throw new ArgumentOutOfRangeException("index"); + + lock (SyncRoot) + { + return driver.GetState(index); + } } #endregion diff --git a/Source/OpenTK/Input/Mouse.cs b/Source/OpenTK/Input/Mouse.cs index e8239e97..0747339f 100644 --- a/Source/OpenTK/Input/Mouse.cs +++ b/Source/OpenTK/Input/Mouse.cs @@ -40,30 +40,38 @@ namespace OpenTK.Input static readonly IMouseDriver driver = Platform.Factory.Default.CreateMouseDriver(); + static readonly object SyncRoot = new object(); #endregion #region Public Members /// - /// Retrieves the MouseState for the specified mouse device. + /// Retrieves the combined for all specified mouse devices. /// - /// A structure containing the state of the mouse device. + /// A structure containing the combined state of all mouse devices. public static MouseState GetState() { - return driver.GetState(); + lock (SyncRoot) + { + return driver.GetState(); + } } /// - /// Retrieves the MouseState for the specified mouse device. + /// Retrieves the for the specified mouse device. /// /// The index of the mouse device. - /// A structure containing the state of the mouse device. + /// A structure containing the state for the specified mouse device. public static MouseState GetState(int index) { if (index < 0) throw new ArgumentOutOfRangeException("index"); - return driver.GetState(index); + + lock (SyncRoot) + { + return driver.GetState(index); + } } #endregion From 415755a257febaf03147cf9b6820cb32daafcc45 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 11:10:57 +0000 Subject: [PATCH 058/130] Modified GetState() to return the combined state for all mouse/keyboard devices. --- Source/OpenTK/Input/KeyboardState.cs | 13 +++++++++++++ Source/OpenTK/Input/MouseState.cs | 17 +++++++++++++++++ .../OpenTK/Platform/Windows/WinRawKeyboard.cs | 12 +++++++----- Source/OpenTK/Platform/Windows/WinRawMouse.cs | 10 ++++++---- Source/OpenTK/Platform/X11/XI2Mouse.cs | 10 ++++++---- 5 files changed, 49 insertions(+), 13 deletions(-) diff --git a/Source/OpenTK/Input/KeyboardState.cs b/Source/OpenTK/Input/KeyboardState.cs index 99dea373..2d5c2e68 100644 --- a/Source/OpenTK/Input/KeyboardState.cs +++ b/Source/OpenTK/Input/KeyboardState.cs @@ -208,6 +208,19 @@ namespace OpenTK.Input } } + internal void MergeBits(KeyboardState other) + { + unsafe + { + int* k2 = other.Keys; + fixed (int* k1 = Keys) + { + for (int i = 0; i < NumInts; i++) + *(k1 + i) |= *(k2 + i); + } + } + } + #endregion #region Private Members diff --git a/Source/OpenTK/Input/MouseState.cs b/Source/OpenTK/Input/MouseState.cs index 19c74451..5338d133 100644 --- a/Source/OpenTK/Input/MouseState.cs +++ b/Source/OpenTK/Input/MouseState.cs @@ -300,6 +300,23 @@ namespace OpenTK.Input } } + internal void MergeBits(MouseState other) + { + unsafe + { + int* b2 = other.Buttons; + fixed (int* b1 = Buttons) + { + for (int i = 0; i < NumInts; i++) + *(b1 + i) |= *(b2 + i); + } + + WheelPrecise += other.WheelPrecise; + X += other.X; + Y += other.Y; + } + } + #endregion #region Private Members diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index c5c0b8b2..01bba01a 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -68,7 +68,7 @@ namespace OpenTK.Platform.Windows #endregion - #region internal static void UpdateKeyboardList() + #region UpdateKeyboardList internal void UpdateKeyboardList() { @@ -264,10 +264,12 @@ namespace OpenTK.Platform.Windows public KeyboardState GetState() { - if (keyboards.Count > 0) - return keyboards[0]; - else - return new KeyboardState(); + KeyboardState master = new KeyboardState(); + foreach (KeyboardState ks in keyboards) + { + master.MergeBits(ks); + } + return master; } public KeyboardState GetState(int index) diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index ed614dfe..9d1676e3 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -65,10 +65,12 @@ namespace OpenTK.Platform.Windows public MouseState GetState() { - if (mice.Count > 0) - return mice[0]; - else - return new MouseState(); + MouseState master = new MouseState(); + foreach (MouseState ms in mice) + { + master.MergeBits(ms); + } + return master; } public MouseState GetState(int index) diff --git a/Source/OpenTK/Platform/X11/XI2Mouse.cs b/Source/OpenTK/Platform/X11/XI2Mouse.cs index 6eb902f4..5290e2de 100644 --- a/Source/OpenTK/Platform/X11/XI2Mouse.cs +++ b/Source/OpenTK/Platform/X11/XI2Mouse.cs @@ -104,10 +104,12 @@ namespace OpenTK.Platform.X11 public MouseState GetState() { ProcessEvents(); - if (mice.Count > 0) - return mice[0]; - else - return new MouseState(); + MouseState master = new MouseState(); + foreach (MouseState ms in mice) + { + master.MergeBits(ms); + } + return master; } public MouseState GetState(int index) From 8c34633faed8de3e68b19fe34cfd283effda8f89 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 11:11:19 +0000 Subject: [PATCH 059/130] Fixed keyboard_old assignment. --- Source/Examples/OpenTK/Test/GameWindowStates.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/Examples/OpenTK/Test/GameWindowStates.cs b/Source/Examples/OpenTK/Test/GameWindowStates.cs index 4fd419b7..144940de 100644 --- a/Source/Examples/OpenTK/Test/GameWindowStates.cs +++ b/Source/Examples/OpenTK/Test/GameWindowStates.cs @@ -113,7 +113,7 @@ namespace Examples.Tests keyboard = OpenTK.Input.Keyboard.GetState(); if (keyboard != keyboard_old) refresh_text = true; - keyboard = keyboard_old; + keyboard_old = keyboard; if (refresh_text) { From de7d38d446df0a35598f2a97c478c6a9a9d90834 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 28 Oct 2010 13:00:21 +0000 Subject: [PATCH 060/130] Do not modify device state during the GetState() call. Fixes intermittent crashes. --- .../OpenTK/Platform/Windows/WinRawKeyboard.cs | 30 ++++++++++++------- Source/OpenTK/Platform/Windows/WinRawMouse.cs | 30 ++++++++++++------- 2 files changed, 40 insertions(+), 20 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index 01bba01a..6c13116d 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -46,6 +46,7 @@ namespace OpenTK.Platform.Windows readonly Dictionary rawids = new Dictionary(); private List keyboards_old = new List(); private IntPtr window; + readonly object UpdateLock = new object(); #region --- Constructors --- @@ -235,8 +236,11 @@ namespace OpenTK.Platform.Windows break; } - keyboards[rawids[handle]] = keyboard; - return processed; + lock (UpdateLock) + { + keyboards[rawids[handle]] = keyboard; + return processed; + } } #endregion @@ -264,20 +268,26 @@ namespace OpenTK.Platform.Windows public KeyboardState GetState() { - KeyboardState master = new KeyboardState(); - foreach (KeyboardState ks in keyboards) + lock (UpdateLock) { - master.MergeBits(ks); + KeyboardState master = new KeyboardState(); + foreach (KeyboardState ks in keyboards) + { + master.MergeBits(ks); + } + return master; } - return master; } public KeyboardState GetState(int index) { - if (keyboards.Count > index) - return keyboards[index]; - else - return new KeyboardState(); + lock (UpdateLock) + { + if (keyboards.Count > index) + return keyboards[index]; + else + return new KeyboardState(); + } } #endregion diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index 9d1676e3..1b98be16 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -44,6 +44,7 @@ namespace OpenTK.Platform.Windows List mice; Dictionary rawids; // ContextHandle instead of IntPtr for fast dictionary access readonly IntPtr Window; + readonly object UpdateLock = new object(); public WinRawMouse(IntPtr window) { @@ -65,20 +66,26 @@ namespace OpenTK.Platform.Windows public MouseState GetState() { - MouseState master = new MouseState(); - foreach (MouseState ms in mice) + lock (UpdateLock) { - master.MergeBits(ms); + MouseState master = new MouseState(); + foreach (MouseState ms in mice) + { + master.MergeBits(ms); + } + return master; } - return master; } public MouseState GetState(int index) { - if (mice.Count > index) - return mice[index]; - else - return new MouseState(); + lock (UpdateLock) + { + if (mice.Count > index) + return mice[index]; + else + return new MouseState(); + } } #endregion @@ -226,8 +233,11 @@ namespace OpenTK.Platform.Windows mouse.Y += raw.LastY; } - mice[rawids[handle]] = mouse; - return true; + lock (UpdateLock) + { + mice[rawids[handle]] = mouse; + return true; + } } } } From a2d53705e762ab7b9e03fab199c8f83f250ea9ed Mon Sep 17 00:00:00 2001 From: chrisbrandtner Date: Thu, 28 Oct 2010 15:58:10 +0000 Subject: [PATCH 061/130] Changed FBO example and documentation to be more useful. --- .../Examples/OpenGL/1.x/FramebufferObject.cs | 62 ++++++++---------- .../Examples/OpenGL/1.x/FramebufferObject.rtf | Bin 938 -> 1404 bytes 2 files changed, 26 insertions(+), 36 deletions(-) diff --git a/Source/Examples/OpenGL/1.x/FramebufferObject.cs b/Source/Examples/OpenGL/1.x/FramebufferObject.cs index 69fd28da..886231cb 100644 --- a/Source/Examples/OpenGL/1.x/FramebufferObject.cs +++ b/Source/Examples/OpenGL/1.x/FramebufferObject.cs @@ -21,7 +21,7 @@ namespace Examples.Tutorial public class SimpleFBO : GameWindow { public SimpleFBO() - : base(800, 600) + : base(800, 400) { } @@ -33,24 +33,7 @@ namespace Examples.Tutorial const int TextureSize = 512; - #region Randoms - - Random rnd = new Random(); - public const float scale = 3f; - - /// Returns a random Float in the range [-0.5*scale..+0.5*scale] - public float GetRandom() - { - return (float)(rnd.NextDouble() - 0.5) * scale; - } - - /// Returns a random Float in the range [0..1] - public float GetRandom0to1() - { - return (float)rnd.NextDouble(); - } - - #endregion Randoms + Examples.Shapes.DrawableShape Object; protected override void OnLoad(EventArgs e) { @@ -63,13 +46,14 @@ namespace Examples.Tutorial Exit(); } + Object = new Shapes.TorusKnot(256, 16, 0.2, 7,8, 1, true); + GL.Enable(EnableCap.DepthTest); GL.ClearDepth(1.0f); GL.DepthFunc(DepthFunction.Lequal); - GL.Disable(EnableCap.CullFace); - GL.PolygonMode(MaterialFace.Back, PolygonMode.Line); - + GL.Enable(EnableCap.CullFace); + // Create Color Tex GL.GenTextures(1, out ColorTexture); GL.BindTexture(TextureTarget.Texture2D, ColorTexture); @@ -176,20 +160,24 @@ namespace Examples.Tutorial GL.ClearColor(1f, 0f, 0f, 0f); GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); - // smack 50 random triangles into the FBO's textures - GL.Begin(BeginMode.Triangles); - { - for (int i = 0; i < 50; i++) - { - GL.Color3(GetRandom0to1(), GetRandom0to1(), GetRandom0to1()); - GL.Vertex3(GetRandom(), GetRandom(), GetRandom()); - GL.Color3(GetRandom0to1(), GetRandom0to1(), GetRandom0to1()); - GL.Vertex3(GetRandom(), GetRandom(), GetRandom()); - GL.Color3(GetRandom0to1(), GetRandom0to1(), GetRandom0to1()); - GL.Vertex3(GetRandom(), GetRandom(), GetRandom()); - } - } - GL.End(); + OpenTK.Matrix4 perspective = OpenTK.Matrix4.CreatePerspectiveFieldOfView( MathHelper.PiOver4, TextureSize / (float)TextureSize, 2.5f, 6f ); + GL.MatrixMode( MatrixMode.Projection ); + GL.LoadMatrix( ref perspective ); + + Matrix4 lookat = Matrix4.LookAt( 0f, 0f, 4.5f, 0f, 0f, 0f, 0f, 1f, 0f ); + GL.MatrixMode( MatrixMode.Modelview ); + GL.LoadMatrix( ref lookat ); + + // draw some complex object into the FBO's textures + GL.Enable( EnableCap.Lighting ); + GL.Enable( EnableCap.Light0 ); + GL.Enable( EnableCap.ColorMaterial ); + GL.Color3( 0f, 1f, 0f ); + Object.Draw(); + GL.Disable( EnableCap.ColorMaterial ); + GL.Disable( EnableCap.Light0 ); + GL.Disable( EnableCap.Lighting ); + } GL.PopAttrib(); GL.Ext.BindFramebuffer(FramebufferTarget.FramebufferExt, 0); // disable rendering into the FBO @@ -203,6 +191,8 @@ namespace Examples.Tutorial protected override void OnUnload(EventArgs e) { + Object.Dispose(); + // Clean up what we allocated before exiting if (ColorTexture != 0) GL.DeleteTextures(1, ref ColorTexture); diff --git a/Source/Examples/OpenGL/1.x/FramebufferObject.rtf b/Source/Examples/OpenGL/1.x/FramebufferObject.rtf index 8d9e74f2b2b3ff9b9b4dbda11530b52ea579048d..75ecb2692fab44592f5cedc97ed2279df914e803 100644 GIT binary patch delta 528 zcmZ9Ju};G<5QYT|NR@a2rW>i$R?v+H0Evl#j#)1DIWaVLdUo0}yNQv}|?-IiPoS&e)#8NT^-W^OVQmP>eW z5K9|?_E^Nej@R&c7 ziXiOaSO?1ekr4nBK1Ng}X^0+d1Pq`Vch(gU8aAjXbo>$ik6ofG`r(|EuSnuh3#wt3 z*dt1$WNs#oYE8&Nl*CxvYGUKL62g^rz@(?0Cc?^d6JDH;;Kv|I%ykEgG(TPReWvuY zbT5du_Pco-UPGh`YW7>Jg>8mnlDk}5p_cLnMJ&+DcxpKz`tH-;pT7I9dI6~@*z{Vk SX;24woOvH;@X6i}XP3VXT)qAP delta 52 zcmeyvwTgYhEk=utx4W5?LyHsBQ)3Dei+H)9WRgKlnqf>@v5}ENbVz Date: Fri, 29 Oct 2010 11:27:40 +0000 Subject: [PATCH 062/130] Decoupled new driver API from old public interface. WinRawMouse can now detect mouse disconnection/connection events. --- Source/OpenTK/INativeWindow.cs | 1 - Source/OpenTK/Input/IInputDriver2.cs | 6 +- Source/OpenTK/Input/IJoystickDriver.cs | 1 + Source/OpenTK/Input/IKeyboardDriver.cs | 14 +- Source/OpenTK/Input/IMouseDriver.cs | 14 +- Source/OpenTK/Input/Keyboard.cs | 24 ++- Source/OpenTK/Input/Mouse.cs | 2 +- Source/OpenTK/Input/MouseState.cs | 8 + Source/OpenTK/OpenTK.csproj | 3 + Source/OpenTK/Platform/Factory.cs | 8 +- Source/OpenTK/Platform/IPlatformFactory.cs | 4 +- Source/OpenTK/Platform/MacOS/CarbonInput.cs | 37 ++-- Source/OpenTK/Platform/MacOS/MacOSFactory.cs | 4 +- Source/OpenTK/Platform/Windows/API.cs | 60 +++++- Source/OpenTK/Platform/Windows/WMInput.cs | 72 +------ Source/OpenTK/Platform/Windows/WinFactory.cs | 4 +- Source/OpenTK/Platform/Windows/WinGLNative.cs | 10 - .../OpenTK/Platform/Windows/WinMMJoystick.cs | 2 +- Source/OpenTK/Platform/Windows/WinRawInput.cs | 154 +++------------ .../OpenTK/Platform/Windows/WinRawKeyboard.cs | 39 +--- Source/OpenTK/Platform/Windows/WinRawMouse.cs | 186 ++++++++++-------- Source/OpenTK/Platform/X11/X11Factory.cs | 4 +- Source/OpenTK/Platform/X11/X11Input.cs | 20 -- Source/OpenTK/Platform/X11/X11Keyboard.cs | 23 ++- Source/OpenTK/Platform/X11/X11Mouse.cs | 2 +- Source/OpenTK/Platform/X11/XI2Mouse.cs | 2 +- 26 files changed, 289 insertions(+), 415 deletions(-) diff --git a/Source/OpenTK/INativeWindow.cs b/Source/OpenTK/INativeWindow.cs index 03927607..106ae60c 100644 --- a/Source/OpenTK/INativeWindow.cs +++ b/Source/OpenTK/INativeWindow.cs @@ -253,7 +253,6 @@ namespace OpenTK //event EventHandler KeyDown; //event EventHandler KeyUp; - //event EventHandler DragDrop; //event EventHandler DragEnter; diff --git a/Source/OpenTK/Input/IInputDriver2.cs b/Source/OpenTK/Input/IInputDriver2.cs index 5cfbcdfd..1ff89748 100644 --- a/Source/OpenTK/Input/IInputDriver2.cs +++ b/Source/OpenTK/Input/IInputDriver2.cs @@ -34,8 +34,8 @@ namespace OpenTK.Input // Defines the interface for a 2nd generation input driver. interface IInputDriver2 { - IMouseDriver MouseDriver { get; } - IKeyboardDriver KeyboardDriver { get; } - IJoystickDriver JoystickDriver { get; } + IMouseDriver2 MouseDriver { get; } + IKeyboardDriver2 KeyboardDriver { get; } + IGamePadDriver GamePadDriver { get; } } } diff --git a/Source/OpenTK/Input/IJoystickDriver.cs b/Source/OpenTK/Input/IJoystickDriver.cs index bb2e030f..0b6f73b9 100644 --- a/Source/OpenTK/Input/IJoystickDriver.cs +++ b/Source/OpenTK/Input/IJoystickDriver.cs @@ -34,6 +34,7 @@ namespace OpenTK.Input /// /// Defines the interface for JoystickDevice drivers. /// + [Obsolete] public interface IJoystickDriver { /// diff --git a/Source/OpenTK/Input/IKeyboardDriver.cs b/Source/OpenTK/Input/IKeyboardDriver.cs index b2806917..20685074 100644 --- a/Source/OpenTK/Input/IKeyboardDriver.cs +++ b/Source/OpenTK/Input/IKeyboardDriver.cs @@ -13,24 +13,12 @@ namespace OpenTK.Input /// /// Defines the interface for KeyboardDevice drivers. /// + [Obsolete] public interface IKeyboardDriver { /// /// Gets the list of available KeyboardDevices. /// IList Keyboard { get; } - - /// - /// Retrieves the KeyboardState for the default keyboard device. - /// - /// A structure containing the state of the keyboard device. - KeyboardState GetState(); - - /// - /// Retrieves the KeyboardState for the specified keyboard device. - /// - /// The index of the keyboard device. - /// A structure containing the state of the keyboard device. - KeyboardState GetState(int index); } } diff --git a/Source/OpenTK/Input/IMouseDriver.cs b/Source/OpenTK/Input/IMouseDriver.cs index 9e60a5db..97713234 100644 --- a/Source/OpenTK/Input/IMouseDriver.cs +++ b/Source/OpenTK/Input/IMouseDriver.cs @@ -13,24 +13,12 @@ namespace OpenTK.Input /// /// Defines the interface for MouseDevice drivers. /// + [Obsolete] public interface IMouseDriver { /// /// Gets the list of available MouseDevices. /// IList Mouse { get; } - - /// - /// Retrieves the MouseState for the default keyboard device. - /// - /// A structure containing the state of the mouse device. - MouseState GetState(); - - /// - /// Retrieves the MouseState for the specified keyboard device. - /// - /// The index of the keyboard device. - /// A structure containing the state of the mouse device. - MouseState GetState(int index); } } diff --git a/Source/OpenTK/Input/Keyboard.cs b/Source/OpenTK/Input/Keyboard.cs index f2838c9f..ea35b050 100644 --- a/Source/OpenTK/Input/Keyboard.cs +++ b/Source/OpenTK/Input/Keyboard.cs @@ -38,7 +38,7 @@ namespace OpenTK.Input { #region Fields - static readonly IKeyboardDriver driver = + static readonly IKeyboardDriver2 driver = Platform.Factory.Default.CreateKeyboardDriver(); static readonly object SyncRoot = new object(); @@ -49,7 +49,7 @@ namespace OpenTK.Input /// /// Retrieves the combined for all keyboard devices. /// - /// A structure containing the combined state for all keyboard devices. + /// An structure containing the combined state for all keyboard devices. public static KeyboardState GetState() { lock (SyncRoot) @@ -62,7 +62,7 @@ namespace OpenTK.Input /// Retrieves the for the specified keyboard device. /// /// The index of the keyboard device. - /// A structure containing the state of the keyboard device. + /// An structure containing the state of the keyboard device. public static KeyboardState GetState(int index) { if (index < 0) @@ -75,5 +75,23 @@ namespace OpenTK.Input } #endregion + + /// + /// Retrieves the device name for the keyboard device. + /// + /// The index of the keyboard device. + /// A with the name of the specified device or . + /// + /// If no device exists at the specified index, the return value is . + public static string GetDeviceName(int index) + { + if (index < 0) + throw new ArgumentOutOfRangeException("index"); + + lock (SyncRoot) + { + return driver.GetDeviceName(index); + } + } } } diff --git a/Source/OpenTK/Input/Mouse.cs b/Source/OpenTK/Input/Mouse.cs index 0747339f..c3f42c17 100644 --- a/Source/OpenTK/Input/Mouse.cs +++ b/Source/OpenTK/Input/Mouse.cs @@ -38,7 +38,7 @@ namespace OpenTK.Input { #region Fields - static readonly IMouseDriver driver = + static readonly IMouseDriver2 driver = Platform.Factory.Default.CreateMouseDriver(); static readonly object SyncRoot = new object(); diff --git a/Source/OpenTK/Input/MouseState.cs b/Source/OpenTK/Input/MouseState.cs index 5338d133..44acc9c3 100644 --- a/Source/OpenTK/Input/MouseState.cs +++ b/Source/OpenTK/Input/MouseState.cs @@ -45,6 +45,7 @@ namespace OpenTK.Input unsafe fixed int Buttons[NumInts]; int x, y; float wheel; + bool is_connected; #endregion @@ -179,6 +180,12 @@ namespace OpenTK.Input get { return Wheel; } } + public bool IsConnected + { + get { return is_connected; } + internal set { is_connected = value; } + } + /// /// Checks whether two instances are equal. /// @@ -314,6 +321,7 @@ namespace OpenTK.Input WheelPrecise += other.WheelPrecise; X += other.X; Y += other.Y; + IsConnected |= other.IsConnected; } } diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index 353f108b..974e460d 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -131,7 +131,10 @@ Code + + + Code diff --git a/Source/OpenTK/Platform/Factory.cs b/Source/OpenTK/Platform/Factory.cs index b352c714..cb9ab3d9 100644 --- a/Source/OpenTK/Platform/Factory.cs +++ b/Source/OpenTK/Platform/Factory.cs @@ -114,12 +114,12 @@ namespace OpenTK.Platform return default_implementation.CreateGraphicsMode(); } - public OpenTK.Input.IKeyboardDriver CreateKeyboardDriver() + public OpenTK.Input.IKeyboardDriver2 CreateKeyboardDriver() { return default_implementation.CreateKeyboardDriver(); } - public OpenTK.Input.IMouseDriver CreateMouseDriver() + public OpenTK.Input.IMouseDriver2 CreateMouseDriver() { return default_implementation.CreateMouseDriver(); } @@ -169,12 +169,12 @@ namespace OpenTK.Platform throw new PlatformNotSupportedException(error_string); } - public OpenTK.Input.IKeyboardDriver CreateKeyboardDriver() + public OpenTK.Input.IKeyboardDriver2 CreateKeyboardDriver() { throw new PlatformNotSupportedException(error_string); } - public OpenTK.Input.IMouseDriver CreateMouseDriver() + public OpenTK.Input.IMouseDriver2 CreateMouseDriver() { throw new PlatformNotSupportedException(error_string); } diff --git a/Source/OpenTK/Platform/IPlatformFactory.cs b/Source/OpenTK/Platform/IPlatformFactory.cs index caae6db1..94761623 100644 --- a/Source/OpenTK/Platform/IPlatformFactory.cs +++ b/Source/OpenTK/Platform/IPlatformFactory.cs @@ -47,8 +47,8 @@ namespace OpenTK.Platform IGraphicsMode CreateGraphicsMode(); - OpenTK.Input.IKeyboardDriver CreateKeyboardDriver(); + OpenTK.Input.IKeyboardDriver2 CreateKeyboardDriver(); - OpenTK.Input.IMouseDriver CreateMouseDriver(); + OpenTK.Input.IMouseDriver2 CreateMouseDriver(); } } diff --git a/Source/OpenTK/Platform/MacOS/CarbonInput.cs b/Source/OpenTK/Platform/MacOS/CarbonInput.cs index 5355a443..615c0899 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonInput.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonInput.cs @@ -7,7 +7,7 @@ namespace OpenTK.Platform.MacOS { using Input; - class CarbonInput : IInputDriver + class CarbonInput : IInputDriver, IInputDriver2 { List dummy_keyboard_list = new List(1); List dummy_mice_list = new List(1); @@ -35,16 +35,6 @@ namespace OpenTK.Platform.MacOS get { return dummy_keyboard_list; } } - public KeyboardState GetState() - { - throw new NotImplementedException(); - } - - public KeyboardState GetState(int index) - { - throw new NotImplementedException(); - } - #endregion #region IMouseDriver Members @@ -54,16 +44,6 @@ namespace OpenTK.Platform.MacOS get { return dummy_mice_list; } } - MouseState IMouseDriver.GetState() - { - throw new NotImplementedException(); - } - - MouseState IMouseDriver.GetState(int index) - { - throw new NotImplementedException(); - } - #endregion #region IJoystickDriver Members @@ -82,5 +62,20 @@ namespace OpenTK.Platform.MacOS } #endregion + + public IMouseDriver2 MouseDriver + { + get { throw new NotImplementedException(); } + } + + public IKeyboardDriver2 KeyboardDriver + { + get { throw new NotImplementedException(); } + } + + public IGamePadDriver GamePadDriver + { + get { throw new NotImplementedException(); } + } } } diff --git a/Source/OpenTK/Platform/MacOS/MacOSFactory.cs b/Source/OpenTK/Platform/MacOS/MacOSFactory.cs index 25619903..e16a58bc 100644 --- a/Source/OpenTK/Platform/MacOS/MacOSFactory.cs +++ b/Source/OpenTK/Platform/MacOS/MacOSFactory.cs @@ -70,12 +70,12 @@ namespace OpenTK.Platform.MacOS return new MacOSGraphicsMode(); } - public virtual OpenTK.Input.IKeyboardDriver CreateKeyboardDriver() + public virtual OpenTK.Input.IKeyboardDriver2 CreateKeyboardDriver() { throw new NotImplementedException(); } - public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() + public virtual OpenTK.Input.IMouseDriver2 CreateMouseDriver() { throw new NotImplementedException(); } diff --git a/Source/OpenTK/Platform/Windows/API.cs b/Source/OpenTK/Platform/Windows/API.cs index 94081054..99dc7dac 100644 --- a/Source/OpenTK/Platform/Windows/API.cs +++ b/Source/OpenTK/Platform/Windows/API.cs @@ -59,6 +59,7 @@ namespace OpenTK.Platform.Windows using RECT = OpenTK.Platform.Windows.Win32Rectangle; using WNDPROC = System.IntPtr; using LPDEVMODE = DeviceMode; + using HDEVNOTIFY = System.IntPtr; using HRESULT = System.IntPtr; using HMONITOR = System.IntPtr; @@ -845,7 +846,7 @@ namespace OpenTK.Platform.Windows #endregion - [DllImport("user32.dll", SetLastError=true)] + [DllImport("user32.dll", SetLastError = true)] public static extern BOOL SetForegroundWindow(HWND hWnd); [DllImport("user32.dll", SetLastError = true)] @@ -854,6 +855,13 @@ namespace OpenTK.Platform.Windows [DllImport("user32.dll", SetLastError = true)] public static extern BOOL SetParent(HWND child, HWND newParent); + [DllImport("user32.dll", SetLastError = true)] + public static extern HDEVNOTIFY RegisterDeviceNotification(HANDLE hRecipient, + LPVOID NotificationFilter, DeviceNotification Flags); + + [DllImport("user32.dll", SetLastError = true)] + public static extern BOOL UnregisterDeviceNotification(HDEVNOTIFY Handle); + #endregion #region Display settings @@ -2794,6 +2802,30 @@ namespace OpenTK.Platform.Windows #endregion + #region BroadcastHeader + + struct BroadcastHeader + { + public DWORD Size; + public DeviceBroadcastType DeviceType; + DWORD dbch_reserved; + } + + #endregion + + #region BroadcastDeviceInterface + + struct BroadcastDeviceInterface + { + public DWORD Size; + public DeviceBroadcastType DeviceType; + DWORD dbcc_reserved; + public Guid ClassGuid; + public char dbcc_name; + } + + #endregion + #endregion #region --- Enums --- @@ -4130,6 +4162,30 @@ namespace OpenTK.Platform.Windows #endregion + #region DeviceNotification + + enum DeviceNotification + { + WINDOW_HANDLE = 0x00000000, + SERVICE_HANDLE = 0x00000001, + ALL_INTERFACE_CLASSES = 0x00000004, + } + + #endregion + + #region DeviceBroadcastType + + enum DeviceBroadcastType + { + OEM = 0, + VOLUME = 2, + PORT = 3, + INTERFACE = 5, + HANDLE = 6, + } + + #endregion + #endregion #region --- Callbacks --- @@ -4190,4 +4246,4 @@ namespace OpenTK.Platform.Windows #pragma warning restore 3019 #pragma warning restore 0649 #pragma warning restore 0169 -#pragma warning restore 0414 \ No newline at end of file +#pragma warning restore 0414 diff --git a/Source/OpenTK/Platform/Windows/WMInput.cs b/Source/OpenTK/Platform/Windows/WMInput.cs index c1b04ef1..1dd3e2dd 100644 --- a/Source/OpenTK/Platform/Windows/WMInput.cs +++ b/Source/OpenTK/Platform/Windows/WMInput.cs @@ -37,11 +37,11 @@ using System.Drawing; namespace OpenTK.Platform.Windows { // Input driver for legacy (pre XP) Windows platforms. - sealed class WMInput : System.Windows.Forms.NativeWindow, IInputDriver, IInputDriver2 + sealed class WMInput : System.Windows.Forms.NativeWindow, IInputDriver2 { #region --- Fields --- - WinMMJoystick joystick_driver = new WinMMJoystick(); + WinMMJoystick gamepad_driver = new WinMMJoystick(); // Driver supports only one keyboard and mouse; KeyboardDevice keyboard = new KeyboardDevice(); MouseDevice mouse = new MouseDevice(); @@ -249,66 +249,6 @@ namespace OpenTK.Platform.Windows #endregion - #region --- IInputDriver Members --- - - #region IInputDriver Members - - public void Poll() - { - joystick_driver.Poll(); - } - - #endregion - - #region IKeyboardDriver Members - - public IList Keyboard - { - get { return keyboards; } - } - - public KeyboardState GetState() - { - throw new NotImplementedException(); - } - - public KeyboardState GetState(int index) - { - throw new NotImplementedException(); - } - - #endregion - - #region IMouseDriver Members - - public IList Mouse - { - get { return mice; } - } - - MouseState IMouseDriver.GetState() - { - throw new NotImplementedException(); - } - - MouseState IMouseDriver.GetState(int index) - { - throw new NotImplementedException(); - } - - #endregion - - #region IJoystickDriver Members - - public IList Joysticks - { - get { return joystick_driver.Joysticks; } - } - - #endregion - - #endregion - #region --- IDisposable Members --- private bool disposed; @@ -337,19 +277,19 @@ namespace OpenTK.Platform.Windows #endregion - public IMouseDriver MouseDriver + public IMouseDriver2 MouseDriver { get { throw new NotImplementedException(); } } - public IKeyboardDriver KeyboardDriver + public IKeyboardDriver2 KeyboardDriver { get { throw new NotImplementedException(); } } - public IJoystickDriver JoystickDriver + public IGamePadDriver GamePadDriver { - get { return joystick_driver; } + get { throw new NotImplementedException(); } } } } diff --git a/Source/OpenTK/Platform/Windows/WinFactory.cs b/Source/OpenTK/Platform/Windows/WinFactory.cs index e5b02e50..796eb7ad 100644 --- a/Source/OpenTK/Platform/Windows/WinFactory.cs +++ b/Source/OpenTK/Platform/Windows/WinFactory.cs @@ -74,12 +74,12 @@ namespace OpenTK.Platform.Windows return new WinGraphicsMode(); } - public virtual OpenTK.Input.IKeyboardDriver CreateKeyboardDriver() + public virtual OpenTK.Input.IKeyboardDriver2 CreateKeyboardDriver() { return InputDriver.KeyboardDriver; } - public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() + public virtual OpenTK.Input.IMouseDriver2 CreateMouseDriver() { return InputDriver.MouseDriver; } diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index b6994aa9..6d409f9b 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -1227,16 +1227,6 @@ namespace OpenTK.Platform.Windows get { return mice; } } - MouseState IMouseDriver.GetState() - { - throw new NotImplementedException(); - } - - MouseState IMouseDriver.GetState(int index) - { - throw new NotImplementedException(); - } - #endregion #region IJoystickDriver Members diff --git a/Source/OpenTK/Platform/Windows/WinMMJoystick.cs b/Source/OpenTK/Platform/Windows/WinMMJoystick.cs index 497ea179..ea3c2a5e 100644 --- a/Source/OpenTK/Platform/Windows/WinMMJoystick.cs +++ b/Source/OpenTK/Platform/Windows/WinMMJoystick.cs @@ -36,7 +36,7 @@ using System.Diagnostics; namespace OpenTK.Platform.Windows { - sealed class WinMMJoystick : IJoystickDriver + sealed class WinMMJoystick : IJoystickDriver, IGamePadDriver { #region Fields diff --git a/Source/OpenTK/Platform/Windows/WinRawInput.cs b/Source/OpenTK/Platform/Windows/WinRawInput.cs index baebfb92..03e2f67b 100644 --- a/Source/OpenTK/Platform/Windows/WinRawInput.cs +++ b/Source/OpenTK/Platform/Windows/WinRawInput.cs @@ -41,7 +41,7 @@ using System.Threading; namespace OpenTK.Platform.Windows { // Not complete. - sealed class WinRawInput : IInputDriver, IInputDriver2 + sealed class WinRawInput : IInputDriver2 { // Input event data. static RawInput data = new RawInput(); @@ -56,6 +56,9 @@ namespace OpenTK.Platform.Windows static WinWindowInfo Parent { get { return Native.WindowInfo as WinWindowInfo; } } static readonly WindowProcedure WndProc = WindowProcedureImplementation; static IntPtr OldWndProc; + + static IntPtr DevNotifyHandle; + static readonly Guid DeviceInterfaceHid = new Guid("4D1E55B2-F16F-11CF-88CB-001111000030"); #region Constructors @@ -102,6 +105,7 @@ namespace OpenTK.Platform.Windows Native.ProcessEvents(); Functions.SetParent(Parent.WindowHandle, Constants.MESSAGE_ONLY); Native.ProcessEvents(); + RegisterForDeviceNotifications(); // Subclass the window to retrieve the events we are interested in. OldWndProc = Functions.SetWindowLong(Parent.WindowHandle, WndProc); @@ -114,6 +118,21 @@ namespace OpenTK.Platform.Windows return Native; } + static void RegisterForDeviceNotifications() + { + BroadcastDeviceInterface bdi = new BroadcastDeviceInterface(); + bdi.Size = BlittableValueType.StrideOf(bdi); + bdi.DeviceType = DeviceBroadcastType.INTERFACE; + bdi.ClassGuid = DeviceInterfaceHid; + unsafe + { + DevNotifyHandle = Functions.RegisterDeviceNotification(Parent.WindowHandle, + new IntPtr((void*)&bdi), DeviceNotification.WINDOW_HANDLE); + } + if (DevNotifyHandle == IntPtr.Zero) + Debug.Print("[Warning] Failed to register for device notifications. Error: {0}", Marshal.GetLastWin32Error()); + } + #endregion #region WindowProcedureImplementation @@ -150,6 +169,10 @@ namespace OpenTK.Platform.Windows } } break; + + case WindowMessage.DEVICECHANGE: + mouseDriver.RefreshDevices(); + break; } return Functions.CallWindowProc(OldWndProc, handle, message, wParam, lParam); } @@ -182,139 +205,19 @@ namespace OpenTK.Platform.Windows #endregion - #region IInputDriver Members - - #region IInputDriver Members - - public void Poll() - { - return; -#if false - // We will do a buffered read for all input devices and route the RawInput structures - // to the correct 'ProcessData' handlers. First, we need to find out the size of the - // buffer to allocate for the structures. Then we allocate the buffer and read the - // structures, calling the correct handler for each one. Last, we free the allocated - // buffer. - int size = 0; - Functions.GetRawInputBuffer(IntPtr.Zero, ref size, API.RawInputHeaderSize); - size *= 256; - IntPtr rin_data = Marshal.AllocHGlobal(size); - - while (true) - { - // Iterate reading all available RawInput structures and routing them to their respective - // handlers. - int num = Functions.GetRawInputBuffer(rin_data, ref size, API.RawInputHeaderSize); - if (num == 0) - break; - else if (num < 0) - { - /*int error = Marshal.GetLastWin32Error(); - if (error == 122) - { - // Enlarge the buffer, it was too small. - AllocateBuffer(); - } - else - { - throw new ApplicationException(String.Format( - "GetRawInputBuffer failed with code: {0}", error)); - }*/ - Debug.Print("GetRawInputBuffer failed with code: {0}", Marshal.GetLastWin32Error()); - //AllocateBuffer(); - break; - } - - RawInput[] rin_structs = new RawInput[num]; - IntPtr next_rin = rin_data; - for (int i = 0; i < num; i++) - { - rin_structs[i] = (RawInput)Marshal.PtrToStructure(next_rin, typeof(RawInput)); - - switch (rin_structs[i].Header.Type) - { - case RawInputDeviceType.KEYBOARD: - keyboardDriver.ProcessKeyboardEvent(rin_structs[i]); - break; - - case RawInputDeviceType.MOUSE: - mouseDriver.ProcessEvent(rin_structs[i]); - break; - } - - next_rin = Functions.NextRawInputStructure(next_rin); - } - Functions.DefRawInputProc(rin_structs, num, (uint)API.RawInputHeaderSize); - } - - Marshal.FreeHGlobal(rin_data); -#endif - } - - #endregion - - #region IKeyboardDriver Members - - public IList Keyboard - { - get { return KeyboardDriver.Keyboard; } - } - - public KeyboardState GetState() - { - throw new NotImplementedException(); - } - - public KeyboardState GetState(int index) - { - throw new NotImplementedException(); - } - - #endregion - - #region IMouseDriver Members - - public IList Mouse - { - get { return MouseDriver.Mouse; } - } - - MouseState IMouseDriver.GetState() - { - throw new NotImplementedException(); - } - - MouseState IMouseDriver.GetState(int index) - { - throw new NotImplementedException(); - } - - #endregion - - #region IJoystickDriver Members - - public IList Joysticks - { - get { throw new NotImplementedException(); } - } - - #endregion - - #endregion - #region IInputDriver2 Members - public IMouseDriver MouseDriver + public IMouseDriver2 MouseDriver { get { return mouseDriver; } } - public IKeyboardDriver KeyboardDriver + public IKeyboardDriver2 KeyboardDriver { get { return keyboardDriver; } } - public IJoystickDriver JoystickDriver + public IGamePadDriver GamePadDriver { get { return joystickDriver; } } @@ -337,10 +240,9 @@ namespace OpenTK.Platform.Windows { if (manual) { - keyboardDriver.Dispose(); - //mouseDriver.Dispose(); } + Functions.UnregisterDeviceNotification(DevNotifyHandle); disposed = true; } } diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index 6c13116d..4747ecb2 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -39,9 +39,10 @@ using OpenTK.Input; namespace OpenTK.Platform.Windows { - internal class WinRawKeyboard : IKeyboardDriver, IDisposable + internal class WinRawKeyboard : IKeyboardDriver2 { readonly List keyboards = new List(); + readonly List names = new List(); // ContextHandle instead of IntPtr for fast dictionary access readonly Dictionary rawids = new Dictionary(); private List keyboards_old = new List(); @@ -142,6 +143,7 @@ namespace OpenTK.Platform.Windows //} keyboards.Add(new KeyboardState()); + names.Add(deviceDesc); rawids.Add(new ContextHandle(ridl[i].Device), keyboards.Count - 1); } } @@ -261,11 +263,6 @@ namespace OpenTK.Platform.Windows #region --- IKeyboardDriver Members --- - public IList Keyboard - { - get { return keyboards_old; } - } - public KeyboardState GetState() { lock (UpdateLock) @@ -290,35 +287,17 @@ namespace OpenTK.Platform.Windows } } - #endregion - - #region --- IDisposable Members --- - - private bool disposed; - - public void Dispose() + public string GetDeviceName(int index) { - Dispose(true); - GC.SuppressFinalize(this); - } - - private void Dispose(bool manual) - { - if (!disposed) + lock (UpdateLock) { - if (manual) - { - keyboards_old.Clear(); - } - disposed = true; + if (names.Count > index) + return names[index]; + else + return String.Empty; } } - ~WinRawKeyboard() - { - Dispose(false); - } - #endregion } } diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index 1b98be16..3c16d48f 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -39,10 +39,11 @@ namespace OpenTK.Platform.Windows /// /// Contains methods to register for and process mouse WM_INPUT messages. /// - internal class WinRawMouse : IMouseDriver + internal class WinRawMouse : IMouseDriver2 { - List mice; - Dictionary rawids; // ContextHandle instead of IntPtr for fast dictionary access + readonly List mice = new List(); + readonly List names = new List(); + readonly Dictionary rawids = new Dictionary(); readonly IntPtr Window; readonly object UpdateLock = new object(); @@ -55,15 +56,13 @@ namespace OpenTK.Platform.Windows throw new ArgumentNullException("window"); Window = window; - RegisterDevices(window, out mice, out rawids); + RefreshDevices(); Debug.Unindent(); } #region IMouseDriver Members - public IList Mouse { get { throw new NotImplementedException(); } } - public MouseState GetState() { lock (UpdateLock) @@ -90,77 +89,114 @@ namespace OpenTK.Platform.Windows #endregion - static int RegisterDevices(IntPtr window, out List mice, out Dictionary rawids) + public void RefreshDevices() { - int count = WinRawInput.DeviceCount; - mice = new List(); - rawids = new Dictionary(); - - RawInputDeviceList[] ridl = new RawInputDeviceList[count]; - for (int i = 0; i < count; i++) - ridl[i] = new RawInputDeviceList(); - Functions.GetRawInputDeviceList(ridl, ref count, API.RawInputDeviceListSize); - - // Discover mouse devices: - for (int i = 0; i < count; i++) + lock (UpdateLock) { - uint size = 0; - Functions.GetRawInputDeviceInfo(ridl[i].Device, RawInputDeviceInfoEnum.DEVICENAME, IntPtr.Zero, ref size); - IntPtr name_ptr = Marshal.AllocHGlobal((IntPtr)size); - Functions.GetRawInputDeviceInfo(ridl[i].Device, RawInputDeviceInfoEnum.DEVICENAME, name_ptr, ref size); - string name = Marshal.PtrToStringAnsi(name_ptr); - Marshal.FreeHGlobal(name_ptr); - - if (name.ToLower().Contains("root")) + // Mark all devices as disconnected. We will check which of those + // are connected later on. + for (int i = 0; i < mice.Count; i++) { - // This is a terminal services device, skip it. - continue; + MouseState state = mice[i]; + state.IsConnected = false; + mice[i] = state; } - else if (ridl[i].Type == RawInputDeviceType.MOUSE || ridl[i].Type == RawInputDeviceType.HID) + + int count = WinRawInput.DeviceCount; + RawInputDeviceList[] ridl = new RawInputDeviceList[count]; + for (int i = 0; i < count; i++) + ridl[i] = new RawInputDeviceList(); + Functions.GetRawInputDeviceList(ridl, ref count, API.RawInputDeviceListSize); + + // Discover mouse devices + foreach (RawInputDeviceList dev in ridl) { - // This is a mouse or a USB mouse device. In the latter case, discover if it really is a - // mouse device by qeurying the registry. - - // remove the \??\ - name = name.Substring(4); - - string[] split = name.Split('#'); - - string id_01 = split[0]; // ACPI (Class code) - string id_02 = split[1]; // PNP0303 (SubClass code) - string id_03 = split[2]; // 3&13c0b0c5&0 (Protocol code) - // The final part is the class GUID and is not needed here - - string findme = string.Format( - @"System\CurrentControlSet\Enum\{0}\{1}\{2}", - id_01, id_02, id_03); - - RegistryKey regkey = Registry.LocalMachine.OpenSubKey(findme); - - string deviceDesc = (string)regkey.GetValue("DeviceDesc"); - deviceDesc = deviceDesc.Substring(deviceDesc.LastIndexOf(';') + 1); - string deviceClass = (string)regkey.GetValue("Class"); - - if (!String.IsNullOrEmpty(deviceClass) && deviceClass.ToLower().Equals("mouse")) + ContextHandle id = new ContextHandle(dev.Device); + if (rawids.ContainsKey(id)) { - // Register the device: - RawInputDeviceInfo info = new RawInputDeviceInfo(); - int devInfoSize = API.RawInputDeviceInfoSize; - Functions.GetRawInputDeviceInfo(ridl[i].Device, RawInputDeviceInfoEnum.DEVICEINFO, - info, ref devInfoSize); + // Device already registered, mark as connected + MouseState state = mice[rawids[id]]; + state.IsConnected = true; + mice[rawids[id]] = state; + continue; + } - mice.Add(RegisterRawDevice(deviceDesc, window)); - rawids.Add(new ContextHandle(ridl[i].Device), mice.Count - 1); + // Unregistered device, find what it is + string name = GetDeviceName(dev); + if (name.ToLower().Contains("root")) + { + // This is a terminal services device, skip it. + continue; + } + else if (dev.Type == RawInputDeviceType.MOUSE || dev.Type == RawInputDeviceType.HID) + { + // This is a mouse or a USB mouse device. In the latter case, discover if it really is a + // mouse device by qeurying the registry. + RegistryKey regkey = FindRegistryKey(name); + string deviceDesc = (string)regkey.GetValue("DeviceDesc"); + deviceDesc = deviceDesc.Substring(deviceDesc.LastIndexOf(';') + 1); + string deviceClass = (string)regkey.GetValue("Class"); + + if (!String.IsNullOrEmpty(deviceClass) && deviceClass.ToLower().Equals("mouse")) + { + if (!rawids.ContainsKey(new ContextHandle(dev.Device))) + { + // Register the device: + RawInputDeviceInfo info = new RawInputDeviceInfo(); + int devInfoSize = API.RawInputDeviceInfoSize; + Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICEINFO, + info, ref devInfoSize); + + RegisterRawDevice(deviceDesc, Window); + MouseState state = new MouseState(); + state.IsConnected = true; + mice.Add(state); + names.Add(deviceDesc); + rawids.Add(new ContextHandle(dev.Device), mice.Count - 1); + } + } } } } - - return count; } - static MouseState RegisterRawDevice(string device, IntPtr window) + static string GetDeviceName(RawInputDeviceList dev) + { + // get name size + uint size = 0; + Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICENAME, IntPtr.Zero, ref size); + + // get actual name + IntPtr name_ptr = Marshal.AllocHGlobal((IntPtr)size); + Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICENAME, name_ptr, ref size); + string name = Marshal.PtrToStringAnsi(name_ptr); + Marshal.FreeHGlobal(name_ptr); + + return name; + } + + static RegistryKey FindRegistryKey(string name) + { + // remove the \??\ + name = name.Substring(4); + + string[] split = name.Split('#'); + + string id_01 = split[0]; // ACPI (Class code) + string id_02 = split[1]; // PNP0303 (SubClass code) + string id_03 = split[2]; // 3&13c0b0c5&0 (Protocol code) + // The final part is the class GUID and is not needed here + + string findme = string.Format( + @"System\CurrentControlSet\Enum\{0}\{1}\{2}", + id_01, id_02, id_03); + + RegistryKey regkey = Registry.LocalMachine.OpenSubKey(findme); + return regkey; + } + + static void RegisterRawDevice(string device, IntPtr window) { - MouseState state = new MouseState(); RawInputDevice[] rid = new RawInputDevice[1]; // Mouse is 1/2 (page/id). See http://www.microsoft.com/whdc/device/input/HID_HWID.mspx rid[0] = new RawInputDevice(); @@ -171,40 +207,24 @@ namespace OpenTK.Platform.Windows if (!Functions.RegisterRawInputDevices(rid, 1, API.RawInputDeviceSize)) { - throw new ApplicationException( - String.Format( - "Raw input registration failed with error: {0}. Device: {1}", - Marshal.GetLastWin32Error(), - rid[0].ToString()) - ); + Debug.Print("[Warning] Raw input registration failed with error: {0}. Device: {1}", + Marshal.GetLastWin32Error(), rid[0].ToString()); } else { Debug.Print("Registered mouse {0}", device); - Point p = new Point(); - if (Functions.GetCursorPos(ref p)) - { - state.X = p.X; - state.Y = p.Y; - } } - - return state; } public bool ProcessMouseEvent(RawInput rin) { - if (mice.Count == 0) - return false; - RawMouse raw = rin.Data.Mouse; ContextHandle handle = new ContextHandle(rin.Header.Device); MouseState mouse; if (!rawids.ContainsKey(handle)) { - mice.Add(new MouseState()); - rawids.Add(handle, mice.Count - 1); + RefreshDevices(); } mouse = mice[rawids[handle]]; diff --git a/Source/OpenTK/Platform/X11/X11Factory.cs b/Source/OpenTK/Platform/X11/X11Factory.cs index a5a82c08..5c46c942 100644 --- a/Source/OpenTK/Platform/X11/X11Factory.cs +++ b/Source/OpenTK/Platform/X11/X11Factory.cs @@ -78,12 +78,12 @@ namespace OpenTK.Platform.X11 return new X11GraphicsMode(); } - public virtual OpenTK.Input.IKeyboardDriver CreateKeyboardDriver() + public virtual OpenTK.Input.IKeyboardDriver2 CreateKeyboardDriver() { return new X11Keyboard(null); } - public virtual OpenTK.Input.IMouseDriver CreateMouseDriver() + public virtual OpenTK.Input.IMouseDriver2 CreateMouseDriver() { if (XI2Mouse.IsSupported(IntPtr.Zero)) return new XI2Mouse(null); // Requires xorg 1.7 or higher. diff --git a/Source/OpenTK/Platform/X11/X11Input.cs b/Source/OpenTK/Platform/X11/X11Input.cs index 3d77cd99..ae4473b1 100644 --- a/Source/OpenTK/Platform/X11/X11Input.cs +++ b/Source/OpenTK/Platform/X11/X11Input.cs @@ -219,16 +219,6 @@ namespace OpenTK.Platform.X11 get { return dummy_keyboard_list; }//return keyboardDriver.Keyboard; } - public KeyboardState GetState() - { - throw new NotImplementedException(); - } - - public KeyboardState GetState(int index) - { - throw new NotImplementedException(); - } - #endregion #region public IList Mouse @@ -238,16 +228,6 @@ namespace OpenTK.Platform.X11 get { return (IList)dummy_mice_list; } //return mouseDriver.Mouse; } - MouseState IMouseDriver.GetState() - { - throw new NotImplementedException(); - } - - MouseState IMouseDriver.GetState(int index) - { - throw new NotImplementedException(); - } - #endregion #region public IList Joysticks diff --git a/Source/OpenTK/Platform/X11/X11Keyboard.cs b/Source/OpenTK/Platform/X11/X11Keyboard.cs index d346e4fd..d67dd56a 100644 --- a/Source/OpenTK/Platform/X11/X11Keyboard.cs +++ b/Source/OpenTK/Platform/X11/X11Keyboard.cs @@ -33,11 +33,13 @@ namespace OpenTK.Platform.X11 { // Standard keyboard driver that relies on xlib input events. // Only one keyboard supported. - sealed class X11Keyboard : IKeyboardDriver + sealed class X11Keyboard : IKeyboardDriver2 { readonly X11WindowInfo window; readonly X11KeyMap keymap = new X11KeyMap(); + readonly static string name = "Core X11 keyboard"; KeyboardState state = new KeyboardState(); + // Can either attach itself to the specified window or can hook the root window. public X11Keyboard(X11WindowInfo win) @@ -64,9 +66,6 @@ namespace OpenTK.Platform.X11 } } - // Todo: remove this - public IList Keyboard { get { throw new NotSupportedException(); } } - public KeyboardState GetState() { ProcessEvents(); @@ -76,11 +75,19 @@ namespace OpenTK.Platform.X11 public KeyboardState GetState(int index) { // X11Keyboard supports a single keyboard only - if (index < 0 || index > 1) - throw new ArgumentOutOfRangeException("index"); - ProcessEvents(); - return state; + if (index == 0) + return state; + else + return new KeyboardState(); + } + + public string GetDeviceName(int index) + { + if (index == 0) + return name; + else + return String.Empty; } void ProcessEvents() diff --git a/Source/OpenTK/Platform/X11/X11Mouse.cs b/Source/OpenTK/Platform/X11/X11Mouse.cs index 5a57364b..881c488e 100644 --- a/Source/OpenTK/Platform/X11/X11Mouse.cs +++ b/Source/OpenTK/Platform/X11/X11Mouse.cs @@ -32,7 +32,7 @@ using OpenTK.Input; namespace OpenTK.Platform.X11 { - sealed class X11Mouse : IMouseDriver + sealed class X11Mouse : IMouseDriver2 { MouseState mouse = new MouseState(); X11WindowInfo window; diff --git a/Source/OpenTK/Platform/X11/XI2Mouse.cs b/Source/OpenTK/Platform/X11/XI2Mouse.cs index 5290e2de..a8f31832 100644 --- a/Source/OpenTK/Platform/X11/XI2Mouse.cs +++ b/Source/OpenTK/Platform/X11/XI2Mouse.cs @@ -35,7 +35,7 @@ namespace OpenTK.Platform.X11 { // Todo: multi-mouse support. Right now we aggregate all data into a single mouse device. // This should be easy: just read the device id and route the data to the correct device. - sealed class XI2Mouse : IMouseDriver + sealed class XI2Mouse : IMouseDriver2 { List mice = new List(); Dictionary rawids = new Dictionary(); // maps raw ids to mouse ids From 72a714126bc53e4a49e23ee81e94ade183e908b9 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 29 Oct 2010 11:46:09 +0000 Subject: [PATCH 063/130] Added missing files to SVN. --- Source/OpenTK/Input/IGamePadDriver.cs | 10 ++++++++ Source/OpenTK/Input/IKeyboardDriver2.cs | 31 +++++++++++++++++++++++++ Source/OpenTK/Input/IMouseDriver2.cs | 22 ++++++++++++++++++ 3 files changed, 63 insertions(+) create mode 100644 Source/OpenTK/Input/IGamePadDriver.cs create mode 100644 Source/OpenTK/Input/IKeyboardDriver2.cs create mode 100644 Source/OpenTK/Input/IMouseDriver2.cs diff --git a/Source/OpenTK/Input/IGamePadDriver.cs b/Source/OpenTK/Input/IGamePadDriver.cs new file mode 100644 index 00000000..0f536dda --- /dev/null +++ b/Source/OpenTK/Input/IGamePadDriver.cs @@ -0,0 +1,10 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.Input +{ + interface IGamePadDriver + { + } +} diff --git a/Source/OpenTK/Input/IKeyboardDriver2.cs b/Source/OpenTK/Input/IKeyboardDriver2.cs new file mode 100644 index 00000000..beeed57b --- /dev/null +++ b/Source/OpenTK/Input/IKeyboardDriver2.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.Input +{ + interface IKeyboardDriver2 + { + /// + /// Retrieves the combined for all keyboard devices. + /// + /// An structure containing the combined state for all keyboard devices. + KeyboardState GetState(); + + /// + /// Retrieves the for the specified keyboard device. + /// + /// The index of the keyboard device. + /// An structure containing the state of the keyboard device. + KeyboardState GetState(int index); + + /// + /// Retrieves the device name for the keyboard device. + /// + /// The index of the keyboard device. + /// A with the name of the specified device or . + /// + /// If no device exists at the specified index, the return value is . + string GetDeviceName(int index); + } +} diff --git a/Source/OpenTK/Input/IMouseDriver2.cs b/Source/OpenTK/Input/IMouseDriver2.cs new file mode 100644 index 00000000..6b560e13 --- /dev/null +++ b/Source/OpenTK/Input/IMouseDriver2.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.Input +{ + interface IMouseDriver2 + { + /// + /// Retrieves the MouseState for the default keyboard device. + /// + /// A structure containing the state of the mouse device. + MouseState GetState(); + + /// + /// Retrieves the MouseState for the specified keyboard device. + /// + /// The index of the keyboard device. + /// A structure containing the state of the mouse device. + MouseState GetState(int index); + } +} From 4a8cb59028957f803abf62302c3761e7938d9c9b Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 29 Oct 2010 11:46:57 +0000 Subject: [PATCH 064/130] Implemented KeyboardState.IsConnected property. Implemented WinRawKeyboard.RefreshDevices(). General code clean-up and beautification. --- Source/OpenTK/Input/KeyboardState.cs | 8 + .../OpenTK/Platform/Windows/WinRawKeyboard.cs | 236 ++++++++---------- Source/OpenTK/Platform/Windows/WinRawMouse.cs | 183 +++++++------- 3 files changed, 210 insertions(+), 217 deletions(-) diff --git a/Source/OpenTK/Input/KeyboardState.cs b/Source/OpenTK/Input/KeyboardState.cs index 2d5c2e68..ee1ddfd7 100644 --- a/Source/OpenTK/Input/KeyboardState.cs +++ b/Source/OpenTK/Input/KeyboardState.cs @@ -43,6 +43,7 @@ namespace OpenTK.Input const int NumInts = ((int)Key.LastKey + IntSize - 1) / IntSize; // The following line triggers bogus CS0214 in gmcs 2.0.1, sigh... unsafe fixed int Keys[NumInts]; + bool is_connected; #endregion @@ -84,6 +85,12 @@ namespace OpenTK.Input return !ReadBit((int)key); } + public bool IsConnected + { + get { return is_connected; } + internal set { is_connected = value; } + } + /// /// Checks whether two instances are equal. /// @@ -219,6 +226,7 @@ namespace OpenTK.Input *(k1 + i) |= *(k2 + i); } } + IsConnected |= other.IsConnected; } #endregion diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index 4747ecb2..e2d39286 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -25,170 +25,103 @@ // #endregion -#region --- Using directives --- - using System; using System.Collections.Generic; -using System.Text; -using System.Runtime.InteropServices; using System.Diagnostics; +using System.Runtime.InteropServices; using Microsoft.Win32; using OpenTK.Input; -#endregion - namespace OpenTK.Platform.Windows { - internal class WinRawKeyboard : IKeyboardDriver2 + sealed class WinRawKeyboard : IKeyboardDriver2 { readonly List keyboards = new List(); readonly List names = new List(); - // ContextHandle instead of IntPtr for fast dictionary access readonly Dictionary rawids = new Dictionary(); - private List keyboards_old = new List(); - private IntPtr window; + readonly IntPtr window; readonly object UpdateLock = new object(); - #region --- Constructors --- + #region Constructors - internal WinRawKeyboard() - : this(IntPtr.Zero) - { - } - - internal WinRawKeyboard(IntPtr windowHandle) + public WinRawKeyboard(IntPtr windowHandle) { Debug.WriteLine("Initializing keyboard driver (WinRawKeyboard)."); Debug.Indent(); this.window = windowHandle; - - UpdateKeyboardList(); + RefreshDevices(); Debug.Unindent(); } #endregion - #region UpdateKeyboardList + #region Public Members - internal void UpdateKeyboardList() + public void RefreshDevices() { - int count = WinRawInput.DeviceCount; - RawInputDeviceList[] ridl = new RawInputDeviceList[count]; - for (int i = 0; i < count; i++) - ridl[i] = new RawInputDeviceList(); - Functions.GetRawInputDeviceList(ridl, ref count, API.RawInputDeviceListSize); - - // Discover keyboard devices: - for (int i = 0; i < count; i++) + lock (UpdateLock) { - uint size = 0; - Functions.GetRawInputDeviceInfo(ridl[i].Device, RawInputDeviceInfoEnum.DEVICENAME, IntPtr.Zero, ref size); - IntPtr name_ptr = Marshal.AllocHGlobal((IntPtr)size); - Functions.GetRawInputDeviceInfo(ridl[i].Device, RawInputDeviceInfoEnum.DEVICENAME, name_ptr, ref size); - string name = Marshal.PtrToStringAnsi(name_ptr); - Marshal.FreeHGlobal(name_ptr); - if (name.ToLower().Contains("root")) + for (int i = 0; i < keyboards.Count; i++) { - // This is a terminal services device, skip it. - continue; + KeyboardState state = keyboards[i]; + state.IsConnected = false; + keyboards[i] = state; } - else if (ridl[i].Type == RawInputDeviceType.KEYBOARD || ridl[i].Type == RawInputDeviceType.HID) + + int count = WinRawInput.DeviceCount; + RawInputDeviceList[] ridl = new RawInputDeviceList[count]; + for (int i = 0; i < count; i++) + ridl[i] = new RawInputDeviceList(); + Functions.GetRawInputDeviceList(ridl, ref count, API.RawInputDeviceListSize); + + // Discover keyboard devices: + foreach (RawInputDeviceList dev in ridl) { - // This is a keyboard or USB keyboard device. In the latter case, discover if it really is a - // keyboard device by qeurying the registry. - - // remove the \??\ - name = name.Substring(4); - - string[] split = name.Split('#'); - - string id_01 = split[0]; // ACPI (Class code) - string id_02 = split[1]; // PNP0303 (SubClass code) - string id_03 = split[2]; // 3&13c0b0c5&0 (Protocol code) - // The final part is the class GUID and is not needed here - - string findme = string.Format( - @"System\CurrentControlSet\Enum\{0}\{1}\{2}", - id_01, id_02, id_03); - - RegistryKey regkey = Registry.LocalMachine.OpenSubKey(findme); - - string deviceDesc = - (string)regkey.GetValue("DeviceDesc"); - string deviceClass = - (string)regkey.GetValue("Class"); - if (!String.IsNullOrEmpty(deviceClass) && deviceClass.ToLower().Equals("keyboard")) + string name = GetDeviceName(dev); + if (name.ToLower().Contains("root")) { - KeyboardDevice kb = new KeyboardDevice(); - kb.Description = deviceDesc; + // This is a terminal services device, skip it. + continue; + } + else if (dev.Type == RawInputDeviceType.KEYBOARD || dev.Type == RawInputDeviceType.HID) + { + // This is a keyboard or USB keyboard device. In the latter case, discover if it really is a + // keyboard device by qeurying the registry. + RegistryKey regkey = GetRegistryKey(name); + string deviceDesc = (string)regkey.GetValue("DeviceDesc"); + string deviceClass = (string)regkey.GetValue("Class"); + deviceDesc = deviceDesc.Substring(deviceDesc.LastIndexOf(';') + 1); - // Register the keyboard: - RawInputDeviceInfo info = new RawInputDeviceInfo(); - int devInfoSize = API.RawInputDeviceInfoSize; - Functions.GetRawInputDeviceInfo(ridl[i].Device, RawInputDeviceInfoEnum.DEVICEINFO, - info, ref devInfoSize); + if (!String.IsNullOrEmpty(deviceClass) && deviceClass.ToLower().Equals("keyboard")) + { + // Register the keyboard: + RawInputDeviceInfo info = new RawInputDeviceInfo(); + int devInfoSize = API.RawInputDeviceInfoSize; + Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICEINFO, + info, ref devInfoSize); - kb.NumberOfLeds = info.Device.Keyboard.NumberOfIndicators; - kb.NumberOfFunctionKeys = info.Device.Keyboard.NumberOfFunctionKeys; - kb.NumberOfKeys = info.Device.Keyboard.NumberOfKeysTotal; - //kb.DeviceID = (info.Device.Keyboard.Type << 32) + info.Device.Keyboard.SubType; - kb.DeviceID = ridl[i].Device; + //KeyboardDevice kb = new KeyboardDevice(); + //kb.Description = deviceDesc; + //kb.NumberOfLeds = info.Device.Keyboard.NumberOfIndicators; + //kb.NumberOfFunctionKeys = info.Device.Keyboard.NumberOfFunctionKeys; + //kb.NumberOfKeys = info.Device.Keyboard.NumberOfKeysTotal; + //kb.DeviceID = dev.Device; - //if (!keyboards.Contains(kb)) - //{ - this.RegisterKeyboardDevice(kb); - keyboards_old.Add(kb); - //} - - keyboards.Add(new KeyboardState()); - names.Add(deviceDesc); - rawids.Add(new ContextHandle(ridl[i].Device), keyboards.Count - 1); + RegisterKeyboardDevice(window, deviceDesc); + KeyboardState state = new KeyboardState(); + state.IsConnected = true; + keyboards.Add(state); + names.Add(deviceDesc); + rawids.Add(new ContextHandle(dev.Device), keyboards.Count - 1); + } } } } } - #endregion - - #region internal void RegisterKeyboardDevice(Keyboard kb) - - internal void RegisterKeyboardDevice(KeyboardDevice kb) - { - RawInputDevice[] rid = new RawInputDevice[1]; - // Keyboard is 1/6 (page/id). See http://www.microsoft.com/whdc/device/input/HID_HWID.mspx - rid[0] = new RawInputDevice(); - rid[0].UsagePage = 1; - rid[0].Usage = 6; - rid[0].Flags = RawInputDeviceFlags.INPUTSINK; - rid[0].Target = window; - - if (!Functions.RegisterRawInputDevices(rid, 1, API.RawInputDeviceSize)) - { - throw new ApplicationException( - String.Format( - "Raw input registration failed with error: {0}. Device: {1}", - Marshal.GetLastWin32Error(), - rid[0].ToString()) - ); - } - else - { - Debug.Print("Registered keyboard {0}", kb.ToString()); - } - } - - #endregion - - #region internal bool ProcessKeyboardEvent(API.RawInput rin) - - /// - /// Processes raw input events. - /// - /// - /// - internal bool ProcessKeyboardEvent(RawInput rin) + public bool ProcessKeyboardEvent(RawInput rin) { bool processed = false; @@ -200,8 +133,7 @@ namespace OpenTK.Platform.Windows KeyboardState keyboard; if (!rawids.ContainsKey(handle)) { - keyboards.Add(new KeyboardState()); - rawids.Add(handle, keyboards.Count - 1); + RefreshDevices(); } keyboard = keyboards[rawids[handle]]; @@ -247,21 +179,63 @@ namespace OpenTK.Platform.Windows #endregion - #region --- IInputDevice Members --- + #region Private Members - public string Description + static RegistryKey GetRegistryKey(string name) { - get { throw new Exception("The method or operation is not implemented."); } + // remove the \??\ + name = name.Substring(4); + + string[] split = name.Split('#'); + + string id_01 = split[0]; // ACPI (Class code) + string id_02 = split[1]; // PNP0303 (SubClass code) + string id_03 = split[2]; // 3&13c0b0c5&0 (Protocol code) + // The final part is the class GUID and is not needed here + + string findme = string.Format( + @"System\CurrentControlSet\Enum\{0}\{1}\{2}", + id_01, id_02, id_03); + + RegistryKey regkey = Registry.LocalMachine.OpenSubKey(findme); + return regkey; } - public Input.InputDeviceType DeviceType + static string GetDeviceName(RawInputDeviceList dev) { - get { return Input.InputDeviceType.Keyboard; } + uint size = 0; + Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICENAME, IntPtr.Zero, ref size); + IntPtr name_ptr = Marshal.AllocHGlobal((IntPtr)size); + Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICENAME, name_ptr, ref size); + string name = Marshal.PtrToStringAnsi(name_ptr); + Marshal.FreeHGlobal(name_ptr); + return name; + } + + static void RegisterKeyboardDevice(IntPtr window, string name) + { + RawInputDevice[] rid = new RawInputDevice[1]; + // Keyboard is 1/6 (page/id). See http://www.microsoft.com/whdc/device/input/HID_HWID.mspx + rid[0] = new RawInputDevice(); + rid[0].UsagePage = 1; + rid[0].Usage = 6; + rid[0].Flags = RawInputDeviceFlags.INPUTSINK; + rid[0].Target = window; + + if (!Functions.RegisterRawInputDevices(rid, 1, API.RawInputDeviceSize)) + { + Debug.Print("[Warning] Raw input registration failed with error: {0}. Device: {1}", + Marshal.GetLastWin32Error(), rid[0].ToString()); + } + else + { + Debug.Print("Registered keyboard {0}", name); + } } #endregion - #region --- IKeyboardDriver Members --- + #region IKeyboardDriver2 Members public KeyboardState GetState() { diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index 3c16d48f..ce3bc374 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -28,7 +28,6 @@ using System; using System.Collections.Generic; using System.Diagnostics; -using System.Drawing; using System.Runtime.InteropServices; using Microsoft.Win32; using OpenTK.Input; @@ -39,7 +38,7 @@ namespace OpenTK.Platform.Windows /// /// Contains methods to register for and process mouse WM_INPUT messages. /// - internal class WinRawMouse : IMouseDriver2 + sealed class WinRawMouse : IMouseDriver2 { readonly List mice = new List(); readonly List names = new List(); @@ -47,6 +46,8 @@ namespace OpenTK.Platform.Windows readonly IntPtr Window; readonly object UpdateLock = new object(); + #region Constructors + public WinRawMouse(IntPtr window) { Debug.WriteLine("Initializing mouse driver (WinRawMouse)."); @@ -61,34 +62,10 @@ namespace OpenTK.Platform.Windows Debug.Unindent(); } - #region IMouseDriver Members - - public MouseState GetState() - { - lock (UpdateLock) - { - MouseState master = new MouseState(); - foreach (MouseState ms in mice) - { - master.MergeBits(ms); - } - return master; - } - } - - public MouseState GetState(int index) - { - lock (UpdateLock) - { - if (mice.Count > index) - return mice[index]; - else - return new MouseState(); - } - } - #endregion + #region Public Members + public void RefreshDevices() { lock (UpdateLock) @@ -134,8 +111,8 @@ namespace OpenTK.Platform.Windows // mouse device by qeurying the registry. RegistryKey regkey = FindRegistryKey(name); string deviceDesc = (string)regkey.GetValue("DeviceDesc"); - deviceDesc = deviceDesc.Substring(deviceDesc.LastIndexOf(';') + 1); string deviceClass = (string)regkey.GetValue("Class"); + deviceDesc = deviceDesc.Substring(deviceDesc.LastIndexOf(';') + 1); if (!String.IsNullOrEmpty(deviceClass) && deviceClass.ToLower().Equals("mouse")) { @@ -147,7 +124,7 @@ namespace OpenTK.Platform.Windows Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICEINFO, info, ref devInfoSize); - RegisterRawDevice(deviceDesc, Window); + RegisterRawDevice(Window, deviceDesc); MouseState state = new MouseState(); state.IsConnected = true; mice.Add(state); @@ -160,62 +137,6 @@ namespace OpenTK.Platform.Windows } } - static string GetDeviceName(RawInputDeviceList dev) - { - // get name size - uint size = 0; - Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICENAME, IntPtr.Zero, ref size); - - // get actual name - IntPtr name_ptr = Marshal.AllocHGlobal((IntPtr)size); - Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICENAME, name_ptr, ref size); - string name = Marshal.PtrToStringAnsi(name_ptr); - Marshal.FreeHGlobal(name_ptr); - - return name; - } - - static RegistryKey FindRegistryKey(string name) - { - // remove the \??\ - name = name.Substring(4); - - string[] split = name.Split('#'); - - string id_01 = split[0]; // ACPI (Class code) - string id_02 = split[1]; // PNP0303 (SubClass code) - string id_03 = split[2]; // 3&13c0b0c5&0 (Protocol code) - // The final part is the class GUID and is not needed here - - string findme = string.Format( - @"System\CurrentControlSet\Enum\{0}\{1}\{2}", - id_01, id_02, id_03); - - RegistryKey regkey = Registry.LocalMachine.OpenSubKey(findme); - return regkey; - } - - static void RegisterRawDevice(string device, IntPtr window) - { - RawInputDevice[] rid = new RawInputDevice[1]; - // Mouse is 1/2 (page/id). See http://www.microsoft.com/whdc/device/input/HID_HWID.mspx - rid[0] = new RawInputDevice(); - rid[0].UsagePage = 1; - rid[0].Usage = 2; - rid[0].Flags = RawInputDeviceFlags.INPUTSINK; - rid[0].Target = window; - - if (!Functions.RegisterRawInputDevices(rid, 1, API.RawInputDeviceSize)) - { - Debug.Print("[Warning] Raw input registration failed with error: {0}. Device: {1}", - Marshal.GetLastWin32Error(), rid[0].ToString()); - } - else - { - Debug.Print("Registered mouse {0}", device); - } - } - public bool ProcessMouseEvent(RawInput rin) { RawMouse raw = rin.Data.Mouse; @@ -259,5 +180,95 @@ namespace OpenTK.Platform.Windows return true; } } + + #endregion + + #region Private Members + + static string GetDeviceName(RawInputDeviceList dev) + { + // get name size + uint size = 0; + Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICENAME, IntPtr.Zero, ref size); + + // get actual name + IntPtr name_ptr = Marshal.AllocHGlobal((IntPtr)size); + Functions.GetRawInputDeviceInfo(dev.Device, RawInputDeviceInfoEnum.DEVICENAME, name_ptr, ref size); + string name = Marshal.PtrToStringAnsi(name_ptr); + Marshal.FreeHGlobal(name_ptr); + + return name; + } + + static RegistryKey FindRegistryKey(string name) + { + // remove the \??\ + name = name.Substring(4); + + string[] split = name.Split('#'); + + string id_01 = split[0]; // ACPI (Class code) + string id_02 = split[1]; // PNP0303 (SubClass code) + string id_03 = split[2]; // 3&13c0b0c5&0 (Protocol code) + // The final part is the class GUID and is not needed here + + string findme = string.Format( + @"System\CurrentControlSet\Enum\{0}\{1}\{2}", + id_01, id_02, id_03); + + RegistryKey regkey = Registry.LocalMachine.OpenSubKey(findme); + return regkey; + } + + static void RegisterRawDevice(IntPtr window, string device) + { + RawInputDevice[] rid = new RawInputDevice[1]; + // Mouse is 1/2 (page/id). See http://www.microsoft.com/whdc/device/input/HID_HWID.mspx + rid[0] = new RawInputDevice(); + rid[0].UsagePage = 1; + rid[0].Usage = 2; + rid[0].Flags = RawInputDeviceFlags.INPUTSINK; + rid[0].Target = window; + + if (!Functions.RegisterRawInputDevices(rid, 1, API.RawInputDeviceSize)) + { + Debug.Print("[Warning] Raw input registration failed with error: {0}. Device: {1}", + Marshal.GetLastWin32Error(), rid[0].ToString()); + } + else + { + Debug.Print("Registered mouse {0}", device); + } + } + + #endregion + + #region IMouseDriver2 Members + + public MouseState GetState() + { + lock (UpdateLock) + { + MouseState master = new MouseState(); + foreach (MouseState ms in mice) + { + master.MergeBits(ms); + } + return master; + } + } + + public MouseState GetState(int index) + { + lock (UpdateLock) + { + if (mice.Count > index) + return mice[index]; + else + return new MouseState(); + } + } + + #endregion } } From 2db6f74ec14385388569364b5e5d3b34d4216fa8 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 1 Nov 2010 07:57:21 +0000 Subject: [PATCH 065/130] * OpenTK/Test/GameWindowStates.cs: Print information on pressed keyboard keys and mouse buttons. --- .../Examples/OpenTK/Test/GameWindowStates.cs | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/Source/Examples/OpenTK/Test/GameWindowStates.cs b/Source/Examples/OpenTK/Test/GameWindowStates.cs index 144940de..33c42000 100644 --- a/Source/Examples/OpenTK/Test/GameWindowStates.cs +++ b/Source/Examples/OpenTK/Test/GameWindowStates.cs @@ -104,6 +104,47 @@ namespace Examples.Tests gfx.DrawString(str, TextFont, Brushes.White, new PointF(0, line * TextFont.Height)); } + static void DrawString(Graphics gfx, string str, int line, float offset) + { + gfx.DrawString(str, TextFont, Brushes.White, new PointF(offset, line * TextFont.Height)); + } + + static void DrawKeyboard(Graphics gfx, KeyboardState keyboard, int line) + { + const string str = "Keys pressed:"; + float space = gfx.MeasureString(" ", TextFont).Width; + float offset = gfx.MeasureString(str, TextFont).Width + space; + DrawString(gfx, str, line); + for (int i = 0; i < (int)Key.LastKey; i++) + { + Key k = (Key)i; + if (keyboard[k]) + { + string key = k.ToString(); + DrawString(gfx, key, line, offset); + offset += gfx.MeasureString(key, TextFont).Width + space; + } + } + } + + static void DrawMouse(Graphics gfx, MouseState mouse, int line) + { + const string str = "Buttons pressed:"; + float space = gfx.MeasureString(" ", TextFont).Width; + float offset = gfx.MeasureString(str, TextFont).Width + space; + DrawString(gfx, str, line); + for (int i = 0; i < (int)MouseButton.LastButton; i++) + { + MouseButton b = (MouseButton)i; + if (mouse[b]) + { + string button = b.ToString(); + DrawString(gfx, button, line, offset); + offset += gfx.MeasureString(button, TextFont).Width + space; + } + } + } + protected override void OnUpdateFrame(FrameEventArgs e) { mouse = OpenTK.Input.Mouse.GetState(); @@ -137,6 +178,8 @@ namespace Examples.Tests DrawString(gfx, String.Format("Window.Location: {0}, Size: {1}", Location, Size), line++); DrawString(gfx, String.Format("Window.{{X={0}, Y={1}, Width={2}, Height={3}}}", X, Y, Width, Height), line++); DrawString(gfx, String.Format("Window.ClientRectangle: {0}", ClientRectangle), line++); + DrawKeyboard(gfx, keyboard, line++); + DrawMouse(gfx, mouse, line++); } } From 151c21f5206bf8e9f66249ecc91d61b14ae62630 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 1 Nov 2010 08:01:44 +0000 Subject: [PATCH 066/130] * X11Keyboard.cs: Use XQueryKeymap to discover key state. * X11Factory.cs: Use new X11Keyboard interface. Temporarily disabled XI2Mouse for testing. * Functions.cs: Fixed type declaration for Time. Added support for XIGrabDevice, XIUngrabDevice, XGrabKey, XUngrabKey, XAllowEvents and XKeycodeToKeysym/XKeysymToKeycode. * API.cs: Enumerate modes for XAllowEvents. --- Source/OpenTK/Platform/X11/API.cs | 13 ++++ Source/OpenTK/Platform/X11/Functions.cs | 29 +++++++- Source/OpenTK/Platform/X11/X11Factory.cs | 8 +-- Source/OpenTK/Platform/X11/X11Keyboard.cs | 82 ++++++----------------- 4 files changed, 63 insertions(+), 69 deletions(-) diff --git a/Source/OpenTK/Platform/X11/API.cs b/Source/OpenTK/Platform/X11/API.cs index eaa80214..1f970123 100644 --- a/Source/OpenTK/Platform/X11/API.cs +++ b/Source/OpenTK/Platform/X11/API.cs @@ -1638,6 +1638,19 @@ XF86VidModeGetGammaRampSize( Functions.XUnlockDisplay(Display); } } + + // XAllowEvent modes + enum EventMode + { + AsyncPointer = 0, + SyncPointer, + ReplayPointer, + AsyncKeyboard, + SyncKeyboard, + ReplayKeyboard, + AsyncBoth, + SyncBoth + } } #pragma warning restore 3019 diff --git a/Source/OpenTK/Platform/X11/Functions.cs b/Source/OpenTK/Platform/X11/Functions.cs index 68a93386..b2bf4947 100644 --- a/Source/OpenTK/Platform/X11/Functions.cs +++ b/Source/OpenTK/Platform/X11/Functions.cs @@ -27,7 +27,7 @@ namespace OpenTK.Platform.X11 using Mask = System.IntPtr; using Atom = System.IntPtr; using VisualID = System.IntPtr; - using Time = System.UInt32; + using Time = System.IntPtr; using KeyCode = System.Byte; // Or maybe ushort? using Display = System.IntPtr; @@ -185,12 +185,24 @@ namespace OpenTK.Platform.X11 [DllImport("libX11", EntryPoint = "XTranslateCoordinates")] public extern static bool XTranslateCoordinates(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return); + + [DllImport("libX11")] + public extern static int XGrabKey(IntPtr display, int keycode, uint modifiers, + Window grab_window, bool owner_events, GrabMode pointer_mode, GrabMode keyboard_mode); + + [DllImport("libX11")] + public extern static int XUngrabKey(IntPtr display, int keycode, uint modifiers, Window grab_window); + [DllImport("libX11", EntryPoint = "XGrabKeyboard")] - public extern static int XGrabKeyboard(IntPtr display, IntPtr window, bool owner_events, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr timestamp); + public extern static int XGrabKeyboard(IntPtr display, IntPtr window, bool owner_events, + GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr timestamp); [DllImport("libX11", EntryPoint = "XUngrabKeyboard")] public extern static int XUngrabKeyboard(IntPtr display, IntPtr timestamp); + [DllImport("libX11")] + public extern static int XAllowEvents(IntPtr display, EventMode event_mode, Time time); + [DllImport("libX11", EntryPoint = "XGetGeometry")] public extern static bool XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth); @@ -468,6 +480,12 @@ namespace OpenTK.Platform.X11 public static extern int XLookupString(ref XKeyEvent event_struct, [Out] byte[] buffer_return, int bytes_buffer, [Out] KeySym[] keysym_return, IntPtr status_in_out); + [DllImport("libX11")] + public static extern KeyCode XKeysymToKeycode(IntPtr display, KeySym keysym); + + [DllImport("libX11")] + public static extern KeySym XKeycodeToKeysym(IntPtr display, KeyCode keycode, int index); + [DllImport("libX11")] public static extern int XRefreshKeyboardMapping(ref XMappingEvent event_map); @@ -492,6 +510,13 @@ namespace OpenTK.Platform.X11 return XISelectEvents(dpy, win, ref mask, 1); } + [DllImport("libXi")] + static extern Status XIGrabDevice(IntPtr display, int deviceid, Window grab_window, Time time, + Cursor cursor, int grab_mode, int paired_device_mode, Bool owner_events, XIEventMask[] mask); + + [DllImport("libXi")] + static extern Status XIUngrabDevice(IntPtr display, int deviceid, Time time); + static readonly IntPtr CopyFromParent = IntPtr.Zero; public static void SendNetWMMessage(X11WindowInfo window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) diff --git a/Source/OpenTK/Platform/X11/X11Factory.cs b/Source/OpenTK/Platform/X11/X11Factory.cs index 5c46c942..f2459183 100644 --- a/Source/OpenTK/Platform/X11/X11Factory.cs +++ b/Source/OpenTK/Platform/X11/X11Factory.cs @@ -80,14 +80,14 @@ namespace OpenTK.Platform.X11 public virtual OpenTK.Input.IKeyboardDriver2 CreateKeyboardDriver() { - return new X11Keyboard(null); + return new X11Keyboard(); } public virtual OpenTK.Input.IMouseDriver2 CreateMouseDriver() { - if (XI2Mouse.IsSupported(IntPtr.Zero)) - return new XI2Mouse(null); // Requires xorg 1.7 or higher. - else + //if (XI2Mouse.IsSupported(IntPtr.Zero)) + // return new XI2Mouse(null); // Requires xorg 1.7 or higher. + //else return new X11Mouse(null); // Always supported. } diff --git a/Source/OpenTK/Platform/X11/X11Keyboard.cs b/Source/OpenTK/Platform/X11/X11Keyboard.cs index d67dd56a..81534264 100644 --- a/Source/OpenTK/Platform/X11/X11Keyboard.cs +++ b/Source/OpenTK/Platform/X11/X11Keyboard.cs @@ -27,6 +27,7 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using OpenTK.Input; namespace OpenTK.Platform.X11 @@ -35,35 +36,14 @@ namespace OpenTK.Platform.X11 // Only one keyboard supported. sealed class X11Keyboard : IKeyboardDriver2 { - readonly X11WindowInfo window; - readonly X11KeyMap keymap = new X11KeyMap(); + readonly static X11KeyMap keymap = new X11KeyMap(); readonly static string name = "Core X11 keyboard"; KeyboardState state = new KeyboardState(); - + readonly byte[] keys = new byte[32]; - // Can either attach itself to the specified window or can hook the root window. - public X11Keyboard(X11WindowInfo win) + public X11Keyboard() { - if (win != null) - { - window = win; - } - else - { - using (new XLock(API.DefaultDisplay)) - { - window = new X11WindowInfo(); - window.Display = API.DefaultDisplay; - window.Screen = Functions.XDefaultScreen(window.Display); - window.RootWindow = Functions.XRootWindow(window.Display, window.Screen); - window.WindowHandle = window.RootWindow; - window.EventMask =EventMask.KeyPressMask | EventMask.KeyReleaseMask | EventMask.KeymapStateMask; - - Functions.XGrabKeyboard(window.Display, window.RootWindow, true, - GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, IntPtr.Zero); - Functions.XSelectInput(window.Display, window.RootWindow, new IntPtr((int)window.EventMask)); - } - } + Debug.WriteLine("Using X11Keyboard."); } public KeyboardState GetState() @@ -92,48 +72,24 @@ namespace OpenTK.Platform.X11 void ProcessEvents() { - XEvent e = new XEvent(); - - while (true) + IntPtr display = API.DefaultDisplay; + using (new XLock(display)) { - using (new XLock(window.Display)) + Functions.XQueryKeymap(display, keys); + for (int keycode = 8; keycode < 256; keycode++) { - if (!Functions.XCheckWindowEvent(window.Display, window.WindowHandle, window.EventMask, ref e)) - break; + IntPtr keysym = Functions.XKeycodeToKeysym(display, (byte)keycode, 0); + IntPtr keysym2 = Functions.XKeycodeToKeysym(display, (byte)keycode, 1); + bool pressed = (keys[keycode >> 3] >> (keycode & 0x07) & 0x01) != 0; - switch (e.type) + Key key; + if (keymap.TryGetValue((XKey)keysym, out key) || + keymap.TryGetValue((XKey)keysym2, out key)) { - case XEventName.KeyPress: - case XEventName.KeyRelease: - bool pressed = e.type == XEventName.KeyPress; - - IntPtr keysym = API.LookupKeysym(ref e.KeyEvent, 0); - IntPtr keysym2 = API.LookupKeysym(ref e.KeyEvent, 1); - - if (keymap.ContainsKey((XKey)keysym)) - { - if (pressed) - state.EnableBit((int)keymap[(XKey)keysym]); - else - state.DisableBit((int)keymap[(XKey)keysym]); - } - else if (keymap.ContainsKey((XKey)keysym2)) - { - if (pressed) - state.EnableBit((int)keymap[(XKey)keysym2]); - else - state.DisableBit((int)keymap[(XKey)keysym2]); - } - else - { - System.Diagnostics.Debug.Print("KeyCode {0} (Keysym: {1}, {2}) not mapped.", - e.KeyEvent.keycode, (XKey)keysym, (XKey)keysym2); - } - break; - - case XEventName.KeymapNotify: - System.Diagnostics.Debug.Print("Keymap event: {0}", e.KeymapEvent.key_vector0); - break; + if (pressed) + state.EnableBit((int)key); + else + state.DisableBit((int)key); } } } From 061f7a60145e3eb6db63c45643e6a1b81105745e Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 2 Nov 2010 17:38:41 +0000 Subject: [PATCH 067/130] * OpenTK.Compatibility.csproj: Suppressed deprecation warnings when compiling this project. --- Source/Compatibility/OpenTK.Compatibility.csproj | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/Source/Compatibility/OpenTK.Compatibility.csproj b/Source/Compatibility/OpenTK.Compatibility.csproj index 68becfc3..e2a8225b 100644 --- a/Source/Compatibility/OpenTK.Compatibility.csproj +++ b/Source/Compatibility/OpenTK.Compatibility.csproj @@ -1,4 +1,4 @@ - + Local @@ -56,7 +56,7 @@ False False 4 - 1591 + 0612, 0618, 1591 AllRules.ruleset full @@ -74,12 +74,17 @@ False False 4 - 1591 + 0612, 0618, 1591 AllRules.ruleset none ..\..\Binaries\OpenTK\Release\ + none + 4 + 0612, 0618, 1591 + true + TRACE; true @@ -95,7 +100,7 @@ False False 4 - 1591 + 0612, 0618, 1591 AllRules.ruleset none From 68bf778718464e7d6058a46613a92da7912c687d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 2 Nov 2010 17:39:43 +0000 Subject: [PATCH 068/130] * Source/OpenTK/OpenTK.csproj: * Source/Bind/Generator.Bind.csproj: * Source/Examples/OpenTK.Examples.csproj: * Source/GLControl/OpenTK.GLControl.csproj: * Source/Converter/Generator.Convert.csproj: * Source/Build.UpdateVersion/Build.UpdateVersion.csproj: Normalized "Documentation" configuration with "Release" configuration. --- Source/Bind/Generator.Bind.csproj | 42 ++++++------------- .../Build.UpdateVersion.csproj | 27 +++++++++++- Source/Converter/Generator.Convert.csproj | 42 ++++++------------- Source/Examples/OpenTK.Examples.csproj | 6 ++- Source/GLControl/OpenTK.GLControl.csproj | 6 ++- Source/OpenTK/OpenTK.csproj | 3 +- 6 files changed, 64 insertions(+), 62 deletions(-) diff --git a/Source/Bind/Generator.Bind.csproj b/Source/Bind/Generator.Bind.csproj index d41f86a6..290f430f 100644 --- a/Source/Bind/Generator.Bind.csproj +++ b/Source/Bind/Generator.Bind.csproj @@ -1,4 +1,4 @@ - + Local @@ -7,8 +7,6 @@ {31D19132-0000-0000-0000-000000000000} Debug AnyCPU - - Bind @@ -21,8 +19,6 @@ Bind - - @@ -47,73 +43,60 @@ true - False 285212672 - False DEBUG;TRACE; - True + true 4096 - False + false ..\..\Binaries\OpenTK\Debug\ False False - False 4 - False - - AllRules.ruleset + full - False 285212672 - False TRACE; - False 4096 - True + true ..\..\Binaries\OpenTK\Release\ False False - False 4 - False - - AllRules.ruleset + none - False 285212672 - False TRACE; - False 4096 - True + true ..\..\Binaries\OpenTK\Release\ False False - False 4 - False - - AllRules.ruleset + none ..\..\Binaries\OpenTK\Release\ + none + 4 + true + TRACE; true @@ -944,6 +927,7 @@ + diff --git a/Source/Build.UpdateVersion/Build.UpdateVersion.csproj b/Source/Build.UpdateVersion/Build.UpdateVersion.csproj index ebbeab49..34d60ecf 100644 --- a/Source/Build.UpdateVersion/Build.UpdateVersion.csproj +++ b/Source/Build.UpdateVersion/Build.UpdateVersion.csproj @@ -1,4 +1,4 @@ - + ..\..\Binaries\OpenTK\Release @@ -26,6 +26,10 @@ Build.UpdateVersion Exe v2.0 + Debug + AnyCPU + 10.0.0 + 2.0 @@ -34,12 +38,33 @@ + + + none + TRACE; + 4 + + + true + full + 4 + + + none + TRACE; + 4 + + + none + TRACE; + 4 + diff --git a/Source/Converter/Generator.Convert.csproj b/Source/Converter/Generator.Convert.csproj index dc64a57c..622149f2 100644 --- a/Source/Converter/Generator.Convert.csproj +++ b/Source/Converter/Generator.Convert.csproj @@ -1,4 +1,4 @@ - + Local @@ -7,8 +7,6 @@ {5FDFF4B6-0000-0000-0000-000000000000} Debug AnyCPU - - Convert @@ -21,8 +19,6 @@ Convert - - @@ -45,73 +41,60 @@ true - False 285212672 - False DEBUG;TRACE; - True + true 4096 - False + false ..\..\Binaries\OpenTK\Debug\ False False - False 4 - False - - AllRules.ruleset + full - False 285212672 - False TRACE; - False 4096 - True + true ..\..\Binaries\OpenTK\Release\ False False - False 4 - False - - AllRules.ruleset + none ..\..\Binaries\OpenTK\Release\ + none + 4 + true + TRACE; - False 285212672 - False TRACE; - False 4096 - True + true ..\..\Binaries\OpenTK\Release\ False False - False 4 - False - - AllRules.ruleset + none true @@ -183,6 +166,7 @@ + diff --git a/Source/Examples/OpenTK.Examples.csproj b/Source/Examples/OpenTK.Examples.csproj index 20ca3931..789042bb 100644 --- a/Source/Examples/OpenTK.Examples.csproj +++ b/Source/Examples/OpenTK.Examples.csproj @@ -1,4 +1,4 @@ - + Local @@ -80,6 +80,10 @@ ..\..\Binaries\OpenTK\Release\ + none + 4 + true + TRACE; true diff --git a/Source/GLControl/OpenTK.GLControl.csproj b/Source/GLControl/OpenTK.GLControl.csproj index f2e53c94..1c41c469 100644 --- a/Source/GLControl/OpenTK.GLControl.csproj +++ b/Source/GLControl/OpenTK.GLControl.csproj @@ -1,4 +1,4 @@ - + Local @@ -76,6 +76,10 @@ ..\..\Binaries\OpenTK\Release\ + none + 4 + true + TRACE; true diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index 974e460d..b008f827 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -1,4 +1,4 @@ - + Local @@ -79,6 +79,7 @@ none 4 true + TRACE; true From b30ec151676fb824e022ff1c687d298779f262fa Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 2 Nov 2010 17:45:53 +0000 Subject: [PATCH 069/130] * Graphics/GL/GLHelper.cs: * OpenTK.Compatibility.csproj: * Audio/OpenAL/AL/EffectsExtensionPresets.cs: Fixed/suppressed all build warnings. --- .../Audio/OpenAL/AL/EffectsExtensionPresets.cs | 2 -- Source/Compatibility/Graphics/GL/GLHelper.cs | 5 ----- Source/Compatibility/OpenTK.Compatibility.csproj | 8 ++++---- 3 files changed, 4 insertions(+), 11 deletions(-) diff --git a/Source/Compatibility/Audio/OpenAL/AL/EffectsExtensionPresets.cs b/Source/Compatibility/Audio/OpenAL/AL/EffectsExtensionPresets.cs index 71b08db5..3cc16afc 100644 --- a/Source/Compatibility/Audio/OpenAL/AL/EffectsExtensionPresets.cs +++ b/Source/Compatibility/Audio/OpenAL/AL/EffectsExtensionPresets.cs @@ -363,7 +363,5 @@ namespace OpenTK.Audio public static EaxReverb Chapel = new EaxReverb(26, 19.6f, 0.840f, -1000, -500, 0, 4.62f, 0.64f, 1.23f, -700, 0.032f, 0f, 0f, 0f, -200, 0.049f, 0f, 0f, 0f, 0.250f, 0f, 0.250f, 0.110f, -5f, 5000f, 250f, 0f, 0x3f); public static EaxReverb Smallwaterroom = new EaxReverb(26, 36.2f, 0.700f, -1000, -698, 0, 1.51f, 1.25f, 1.14f, -100, 0.020f, 0f, 0f, 0f, 300, 0.030f, 0f, 0f, 0f, 0.179f, 0.150f, 0.895f, 0.190f, -7f, 5000f, 250f, 0f, 0x0); } - -#pragma warning restore 1591 } } diff --git a/Source/Compatibility/Graphics/GL/GLHelper.cs b/Source/Compatibility/Graphics/GL/GLHelper.cs index 3a293fce..0a1d954a 100644 --- a/Source/Compatibility/Graphics/GL/GLHelper.cs +++ b/Source/Compatibility/Graphics/GL/GLHelper.cs @@ -1312,11 +1312,6 @@ namespace OpenTK.Graphics #endregion -#pragma warning restore 3019 -#pragma warning restore 1591 -#pragma warning restore 1572 -#pragma warning restore 1573 - #endregion } } diff --git a/Source/Compatibility/OpenTK.Compatibility.csproj b/Source/Compatibility/OpenTK.Compatibility.csproj index e2a8225b..cd359462 100644 --- a/Source/Compatibility/OpenTK.Compatibility.csproj +++ b/Source/Compatibility/OpenTK.Compatibility.csproj @@ -56,7 +56,7 @@ False False 4 - 0612, 0618, 1591 + 0219, 0414, 0612, 0618, 1591, 3005, 3006 AllRules.ruleset full @@ -74,7 +74,7 @@ False False 4 - 0612, 0618, 1591 + 0219, 0414, 0612, 0618, 1591, 3005, 3006 AllRules.ruleset none @@ -82,7 +82,7 @@ ..\..\Binaries\OpenTK\Release\ none 4 - 0612, 0618, 1591 + 0219, 0414, 0612, 0618, 1591, 3005, 3006 true TRACE; @@ -100,7 +100,7 @@ False False 4 - 0612, 0618, 1591 + 0219, 0414, 0612, 0618, 1591, 3005, 3006 AllRules.ruleset none From 64210383de16cdb40df77283ad2e14e7c0cf87d7 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 2 Nov 2010 19:49:24 +0000 Subject: [PATCH 070/130] * EventInfo.cs: * AglContext.cs: * MacOSKeyMap.cs: * CarbonInput.cs: * Application.cs: * MacOSFactory.cs: * CarbonGLNative.cs: * CarbonWindowInfo.cs: * MacOSGraphicsMode.cs: * QuartzDisplayDeviceDriver.cs: Normalized code formatting. --- Source/OpenTK/Platform/MacOS/AglContext.cs | 393 +++--- Source/OpenTK/Platform/MacOS/Application.cs | 116 +- .../OpenTK/Platform/MacOS/CarbonGLNative.cs | 1093 ++++++++--------- Source/OpenTK/Platform/MacOS/CarbonInput.cs | 15 +- .../OpenTK/Platform/MacOS/CarbonWindowInfo.cs | 39 +- Source/OpenTK/Platform/MacOS/EventInfo.cs | 35 +- Source/OpenTK/Platform/MacOS/MacOSFactory.cs | 4 +- .../Platform/MacOS/MacOSGraphicsMode.cs | 11 +- Source/OpenTK/Platform/MacOS/MacOSKeyMap.cs | 4 +- .../MacOS/QuartzDisplayDeviceDriver.cs | 121 +- 10 files changed, 882 insertions(+), 949 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/AglContext.cs b/Source/OpenTK/Platform/MacOS/AglContext.cs index 50ab9144..341d8fe9 100644 --- a/Source/OpenTK/Platform/MacOS/AglContext.cs +++ b/Source/OpenTK/Platform/MacOS/AglContext.cs @@ -23,41 +23,40 @@ namespace OpenTK.Platform.MacOS using AGLContext = IntPtr; using AGLPbuffer = IntPtr; - class AglContext : DesktopGraphicsContext + class AglContext : DesktopGraphicsContext { bool mVSync = false; // Todo: keep track of which display adapter was specified when the context was created. // IntPtr displayID; - + GraphicsMode graphics_mode; CarbonWindowInfo carbonWindow; IntPtr shareContextRef; - DisplayDevice device; - bool mIsFullscreen = false; + DisplayDevice device; + bool mIsFullscreen = false; public AglContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext) { Debug.Print("Context Type: {0}", shareContext); Debug.Print("Window info: {0}", window); - + this.graphics_mode = mode; this.carbonWindow = (CarbonWindowInfo)window; - + if (shareContext is AglContext) shareContextRef = ((AglContext)shareContext).Handle.Handle; - if (shareContext is GraphicsContext) - { - ContextHandle shareHandle = shareContext != null ? - (shareContext as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero; - - shareContextRef = shareHandle.Handle; - } - - if (shareContextRef == IntPtr.Zero) - { - Debug.Print("No context sharing will take place."); - } - + if (shareContext is GraphicsContext) + { + ContextHandle shareHandle = shareContext != null ? (shareContext as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero; + + shareContextRef = shareHandle.Handle; + } + + if (shareContextRef == IntPtr.Zero) + { + Debug.Print("No context sharing will take place."); + } + CreateContext(mode, carbonWindow, shareContextRef, true); } @@ -67,7 +66,7 @@ namespace OpenTK.Platform.MacOS throw new ArgumentException("handle"); if (window == null) throw new ArgumentNullException("window"); - + Handle = handle; carbonWindow = (CarbonWindowInfo)window; } @@ -76,37 +75,36 @@ namespace OpenTK.Platform.MacOS private void AddPixelAttrib(List aglAttributes, Agl.PixelFormatAttribute pixelFormatAttribute) { Debug.Print(pixelFormatAttribute.ToString()); - + aglAttributes.Add((int)pixelFormatAttribute); } private void AddPixelAttrib(List aglAttributes, Agl.PixelFormatAttribute pixelFormatAttribute, int value) { Debug.Print("{0} : {1}", pixelFormatAttribute, value); - + aglAttributes.Add((int)pixelFormatAttribute); aglAttributes.Add(value); } - void CreateContext(GraphicsMode mode, CarbonWindowInfo carbonWindow, - IntPtr shareContextRef, bool fullscreen) + void CreateContext(GraphicsMode mode, CarbonWindowInfo carbonWindow, IntPtr shareContextRef, bool fullscreen) { - List aglAttributes = new List(); - + List aglAttributes = new List(); + Debug.Print("AGL pixel format attributes:"); Debug.Indent(); - + AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_RGBA); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_DOUBLEBUFFER); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_RED_SIZE, mode.ColorFormat.Red); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_GREEN_SIZE, mode.ColorFormat.Green); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_BLUE_SIZE, mode.ColorFormat.Blue); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ALPHA_SIZE, mode.ColorFormat.Alpha); - + if (mode.Depth > 0) AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_DEPTH_SIZE, mode.Depth); - + if (mode.Stencil > 0) AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_STENCIL_SIZE, mode.Stencil); - + if (mode.AccumulatorFormat.BitsPerPixel > 0) { AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_RED_SIZE, mode.AccumulatorFormat.Red); @@ -120,72 +118,68 @@ namespace OpenTK.Platform.MacOS AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_SAMPLE_BUFFERS_ARB, 1); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_SAMPLES_ARB, mode.Samples); } - + if (fullscreen) { AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_FULLSCREEN); } AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_NONE); - + Debug.Unindent(); - + Debug.Write("Attribute array: "); for (int i = 0; i < aglAttributes.Count; i++) Debug.Write(aglAttributes[i].ToString() + " "); Debug.WriteLine(""); - + AGLPixelFormat myAGLPixelFormat; - + // Choose a pixel format with the attributes we specified. if (fullscreen) { - IntPtr gdevice; - IntPtr cgdevice = GetQuartzDevice(carbonWindow); - - if (cgdevice == IntPtr.Zero) - cgdevice = QuartzDisplayDeviceDriver.MainDisplay; - - OSStatus status = Carbon.API.DMGetGDeviceByDisplayID( - cgdevice, out gdevice, false); + IntPtr gdevice; + IntPtr cgdevice = GetQuartzDevice(carbonWindow); + + if (cgdevice == IntPtr.Zero) + cgdevice = QuartzDisplayDeviceDriver.MainDisplay; + + OSStatus status = Carbon.API.DMGetGDeviceByDisplayID(cgdevice, out gdevice, false); if (status != OSStatus.NoError) throw new MacOSException(status, "DMGetGDeviceByDisplayID failed."); - - myAGLPixelFormat = Agl.aglChoosePixelFormat( - ref gdevice, 1, - aglAttributes.ToArray()); - + + myAGLPixelFormat = Agl.aglChoosePixelFormat(ref gdevice, 1, aglAttributes.ToArray()); + Agl.AglError err = Agl.GetError(); - + if (err == Agl.AglError.BadPixelFormat) { Debug.Print("Failed to create full screen pixel format."); Debug.Print("Trying again to create a non-fullscreen pixel format."); - + CreateContext(mode, carbonWindow, shareContextRef, false); return; } } + else { - myAGLPixelFormat = Agl.aglChoosePixelFormat( - IntPtr.Zero, 0, - aglAttributes.ToArray()); - + myAGLPixelFormat = Agl.aglChoosePixelFormat(IntPtr.Zero, 0, aglAttributes.ToArray()); + MyAGLReportError("aglChoosePixelFormat"); } - - - Debug.Print("Creating AGL context. Sharing with {0}", shareContextRef); - + + + Debug.Print("Creating AGL context. Sharing with {0}", shareContextRef); + // create the context and share it with the share reference. - Handle = new ContextHandle( Agl.aglCreateContext(myAGLPixelFormat, shareContextRef)); + Handle = new ContextHandle(Agl.aglCreateContext(myAGLPixelFormat, shareContextRef)); MyAGLReportError("aglCreateContext"); - + // Free the pixel format from memory. Agl.aglDestroyPixelFormat(myAGLPixelFormat); MyAGLReportError("aglDestroyPixelFormat"); - + Debug.Print("IsControl: {0}", carbonWindow.IsControl); SetDrawable(carbonWindow); @@ -193,29 +187,29 @@ namespace OpenTK.Platform.MacOS Update(carbonWindow); MakeCurrent(carbonWindow); - + Debug.Print("context: {0}", Handle.Handle); } - private IntPtr GetQuartzDevice(CarbonWindowInfo carbonWindow) - { - IntPtr windowRef = carbonWindow.WindowRef; - - if (CarbonGLNative.WindowRefMap.ContainsKey(windowRef) == false) - return IntPtr.Zero; - - WeakReference nativeRef = CarbonGLNative.WindowRefMap[windowRef]; - if (nativeRef.IsAlive == false) - return IntPtr.Zero; - - CarbonGLNative window = nativeRef.Target as CarbonGLNative; - - if (window == null) - return IntPtr.Zero; - - return QuartzDisplayDeviceDriver.HandleTo(window.TargetDisplayDevice); - - } + private IntPtr GetQuartzDevice(CarbonWindowInfo carbonWindow) + { + IntPtr windowRef = carbonWindow.WindowRef; + + if (CarbonGLNative.WindowRefMap.ContainsKey(windowRef) == false) + return IntPtr.Zero; + + WeakReference nativeRef = CarbonGLNative.WindowRefMap[windowRef]; + if (nativeRef.IsAlive == false) + return IntPtr.Zero; + + CarbonGLNative window = nativeRef.Target as CarbonGLNative; + + if (window == null) + return IntPtr.Zero; + + return QuartzDisplayDeviceDriver.HandleTo(window.TargetDisplayDevice); + + } void SetBufferRect(CarbonWindowInfo carbonWindow) { @@ -223,16 +217,15 @@ namespace OpenTK.Platform.MacOS return; System.Windows.Forms.Control ctrl = Control.FromHandle(carbonWindow.WindowRef); - + if (ctrl.TopLevelControl == null) return; - + Rect rect = API.GetControlBounds(carbonWindow.WindowRef); - System.Windows.Forms.Form frm = (System.Windows.Forms.Form) ctrl.TopLevelControl; - - System.Drawing.Point loc = - frm.PointToClient(ctrl.PointToScreen(System.Drawing.Point.Empty)); - + System.Windows.Forms.Form frm = (System.Windows.Forms.Form)ctrl.TopLevelControl; + + System.Drawing.Point loc = frm.PointToClient(ctrl.PointToScreen(System.Drawing.Point.Empty)); + rect.X = (short)loc.X; rect.Y = (short)loc.Y; @@ -243,28 +236,28 @@ namespace OpenTK.Platform.MacOS Debug.Print(" AGL Coordinate Rect: {0}", rect); int[] glrect = new int[4]; - + glrect[0] = rect.X; glrect[1] = rect.Y; glrect[2] = rect.Width; glrect[3] = rect.Height; - + Agl.aglSetInteger(Handle.Handle, Agl.ParameterNames.AGL_BUFFER_RECT, glrect); MyAGLReportError("aglSetInteger"); - + Agl.aglEnable(Handle.Handle, Agl.ParameterNames.AGL_BUFFER_RECT); MyAGLReportError("aglEnable"); - + } void SetDrawable(CarbonWindowInfo carbonWindow) { IntPtr windowPort = GetWindowPortForWindowInfo(carbonWindow); - //Debug.Print("Setting drawable for context {0} to window port: {1}", Handle.Handle, windowPort); - + //Debug.Print("Setting drawable for context {0} to window port: {1}", Handle.Handle, windowPort); + Agl.aglSetDrawable(Handle.Handle, windowPort); - + MyAGLReportError("aglSetDrawable"); - + } private static IntPtr GetWindowPortForWindowInfo(CarbonWindowInfo carbonWindow) @@ -276,109 +269,109 @@ namespace OpenTK.Platform.MacOS windowPort = API.GetWindowPort(controlOwner); } + else windowPort = API.GetWindowPort(carbonWindow.WindowRef); - + return windowPort; } - public override void Update(IWindowInfo window) + public override void Update(IWindowInfo window) { CarbonWindowInfo carbonWindow = (CarbonWindowInfo)window; + + if (carbonWindow.GoFullScreenHack) + { + carbonWindow.GoFullScreenHack = false; + CarbonGLNative wind = GetCarbonWindow(carbonWindow); + + if (wind != null) + wind.SetFullscreen(this); + else + Debug.Print("Could not find window!"); + + return; + } - if (carbonWindow.GoFullScreenHack) - { - carbonWindow.GoFullScreenHack = false; - CarbonGLNative wind = GetCarbonWindow(carbonWindow); - - if (wind != null) - wind.SetFullscreen(this); - else - Debug.Print("Could not find window!"); - - return; - } - else if (carbonWindow.GoWindowedHack) - { - carbonWindow.GoWindowedHack = false; - CarbonGLNative wind = GetCarbonWindow(carbonWindow); - - if (wind != null) - wind.UnsetFullscreen(this); - else - Debug.Print("Could not find window!"); - - } - - if (mIsFullscreen) - return; - + else if (carbonWindow.GoWindowedHack) + { + carbonWindow.GoWindowedHack = false; + CarbonGLNative wind = GetCarbonWindow(carbonWindow); + + if (wind != null) + wind.UnsetFullscreen(this); + else + Debug.Print("Could not find window!"); + + } + + if (mIsFullscreen) + return; + SetDrawable(carbonWindow); SetBufferRect(carbonWindow); - + Agl.aglUpdateContext(Handle.Handle); } - private CarbonGLNative GetCarbonWindow(CarbonWindowInfo carbonWindow) - { - WeakReference r = CarbonGLNative.WindowRefMap[carbonWindow.WindowRef]; + private CarbonGLNative GetCarbonWindow(CarbonWindowInfo carbonWindow) + { + WeakReference r = CarbonGLNative.WindowRefMap[carbonWindow.WindowRef]; + + if (r.IsAlive) + { + return (CarbonGLNative)r.Target; + } - if (r.IsAlive) - { - return (CarbonGLNative) r.Target; - } - else - return null; - } + else + return null; + } void MyAGLReportError(string function) { Agl.AglError err = Agl.GetError(); - + if (err != Agl.AglError.NoError) - throw new MacOSException((OSStatus)err, string.Format( - "AGL Error from function {0}: {1} {2}", - function, err, Agl.ErrorString(err))); + throw new MacOSException((OSStatus)err, string.Format("AGL Error from function {0}: {1} {2}", function, err, Agl.ErrorString(err))); } bool firstFullScreen = false; internal void SetFullScreen(CarbonWindowInfo info, out int width, out int height) { - CarbonGLNative wind = GetCarbonWindow(info); - - Debug.Print("Switching to full screen {0}x{1} on context {2}", - wind.TargetDisplayDevice.Width, wind.TargetDisplayDevice.Height, Handle.Handle); - - CG.DisplayCapture(GetQuartzDevice(info)); - Agl.aglSetFullScreen(Handle.Handle, wind.TargetDisplayDevice.Width, wind.TargetDisplayDevice.Height, 0, 0); - MakeCurrent(info); - - width = wind.TargetDisplayDevice.Width; - height = wind.TargetDisplayDevice.Height; - + CarbonGLNative wind = GetCarbonWindow(info); + + Debug.Print("Switching to full screen {0}x{1} on context {2}", wind.TargetDisplayDevice.Width, wind.TargetDisplayDevice.Height, Handle.Handle); + + CG.DisplayCapture(GetQuartzDevice(info)); + Agl.aglSetFullScreen(Handle.Handle, wind.TargetDisplayDevice.Width, wind.TargetDisplayDevice.Height, 0, 0); + MakeCurrent(info); + + width = wind.TargetDisplayDevice.Width; + height = wind.TargetDisplayDevice.Height; + // This is a weird hack to workaround a bug where the first time a context // is made fullscreen, we just end up with a blank screen. So we undo it as fullscreen // and redo it as fullscreen. - if (firstFullScreen == false) - { - firstFullScreen = true; - UnsetFullScreen(info); - SetFullScreen(info, out width, out height); - } - - mIsFullscreen = true; + if (firstFullScreen == false) + { + firstFullScreen = true; + UnsetFullScreen(info); + SetFullScreen(info, out width, out height); + } + + mIsFullscreen = true; } internal void UnsetFullScreen(CarbonWindowInfo windowInfo) { - Debug.Print("Unsetting AGL fullscreen."); + Debug.Print("Unsetting AGL fullscreen."); Agl.aglSetDrawable(Handle.Handle, IntPtr.Zero); - Agl.aglUpdateContext(Handle.Handle); - - CG.DisplayRelease(GetQuartzDevice(windowInfo)); - Debug.Print("Resetting drawable."); - SetDrawable(windowInfo); - - mIsFullscreen = false; + Agl.aglUpdateContext(Handle.Handle); + + CG.DisplayRelease(GetQuartzDevice(windowInfo)); + Debug.Print("Resetting drawable."); + SetDrawable(windowInfo); + + mIsFullscreen = false; } @@ -393,14 +386,14 @@ namespace OpenTK.Platform.MacOS { Debug.WriteLine("--> Resetting drawable. <--"); firstSwap = true; - SetDrawable(carbonWindow); - Update(carbonWindow); + SetDrawable(carbonWindow); + Update(carbonWindow); } - - Agl.aglSwapBuffers(Handle.Handle); - MyAGLReportError("aglSwapBuffers"); + + Agl.aglSwapBuffers(Handle.Handle); + MyAGLReportError("aglSwapBuffers"); } - + public override void MakeCurrent(IWindowInfo window) { if (Agl.aglSetCurrentContext(Handle.Handle) == false) @@ -409,24 +402,18 @@ namespace OpenTK.Platform.MacOS public override bool IsCurrent { - get - { - return (Handle.Handle == Agl.aglGetCurrentContext()); - } + get { return (Handle.Handle == Agl.aglGetCurrentContext()); } } public override bool VSync { - get - { - return mVSync; - } + get { return mVSync; } set { int intVal = value ? 1 : 0; - + Agl.aglSetInteger(Handle.Handle, Agl.ParameterNames.AGL_SWAP_INTERVAL, ref intVal); - + mVSync = value; } } @@ -449,34 +436,34 @@ namespace OpenTK.Platform.MacOS { if (IsDisposed || Handle.Handle == IntPtr.Zero) return; - + Debug.Print("Disposing of AGL context."); Agl.aglSetCurrentContext(IntPtr.Zero); - - //Debug.Print("Setting drawable to null for context {0}.", Handle.Handle); - //Agl.aglSetDrawable(Handle.Handle, IntPtr.Zero); - - // I do not know MacOS allows us to destroy a context from a separate thread, - // like the finalizer thread. It's untested, but worst case is probably - // an exception on application exit, which would be logged to the console. - Debug.Print("Destroying context"); + + //Debug.Print("Setting drawable to null for context {0}.", Handle.Handle); + //Agl.aglSetDrawable(Handle.Handle, IntPtr.Zero); + + // I do not know MacOS allows us to destroy a context from a separate thread, + // like the finalizer thread. It's untested, but worst case is probably + // an exception on application exit, which would be logged to the console. + Debug.Print("Destroying context"); if (Agl.aglDestroyContext(Handle.Handle) == true) { - Debug.Print("Context destruction completed successfully."); - Handle = ContextHandle.Zero; - return; + Debug.Print("Context destruction completed successfully."); + Handle = ContextHandle.Zero; + return; } - + // failed to destroy context. Debug.WriteLine("Failed to destroy context."); Debug.WriteLine(Agl.ErrorString(Agl.GetError())); - + // don't throw an exception from the finalizer thread. if (disposing) { throw new MacOSException((OSStatus)Agl.GetError(), Agl.ErrorString(Agl.GetError())); } - + IsDisposed = true; } @@ -484,7 +471,7 @@ namespace OpenTK.Platform.MacOS #region IGraphicsContextInternal Members - private const string Library = "libdl.dylib"; + private const string Library = "libdl.dylib"; [DllImport(Library, EntryPoint = "NSIsSymbolNameDefined")] private static extern bool NSIsSymbolNameDefined(string s); @@ -498,14 +485,14 @@ namespace OpenTK.Platform.MacOS string fname = "_" + function; if (!NSIsSymbolNameDefined(fname)) return IntPtr.Zero; - + IntPtr symbol = NSLookupAndBindSymbol(fname); if (symbol != IntPtr.Zero) symbol = NSAddressOfSymbol(symbol); - + return symbol; } - + #endregion } } diff --git a/Source/OpenTK/Platform/MacOS/Application.cs b/Source/OpenTK/Platform/MacOS/Application.cs index 5c649787..a4d83b54 100644 --- a/Source/OpenTK/Platform/MacOS/Application.cs +++ b/Source/OpenTK/Platform/MacOS/Application.cs @@ -27,35 +27,36 @@ namespace OpenTK.Platform.MacOS.Carbon Initialize(); } - internal static void Initialize() + static internal void Initialize() { - if (mInitialized) return; + if (mInitialized) + return; API.AcquireRootMenu(); - + ConnectEvents(); - + API.Gestalt(GestaltSelector.SystemVersionMajor, out osMajor); API.Gestalt(GestaltSelector.SystemVersionMinor, out osMinor); API.Gestalt(GestaltSelector.SystemVersionBugFix, out osBugfix); - + Debug.Print("Running on Mac OS X {0}.{1}.{2}.", osMajor, osMinor, osBugfix); - - TransformProcessToForeground(); + + TransformProcessToForeground(); } - private static void TransformProcessToForeground() - { - Carbon.ProcessSerialNumber psn = new ProcessSerialNumber(); + private static void TransformProcessToForeground() + { + Carbon.ProcessSerialNumber psn = new ProcessSerialNumber(); + + Debug.Print("Setting process to be foreground application."); + + API.GetCurrentProcess(ref psn); + API.TransformProcessType(ref psn, ProcessApplicationTransformState.kProcessTransformToForegroundApplication); + API.SetFrontProcess(ref psn); + } - Debug.Print("Setting process to be foreground application."); - - API.GetCurrentProcess(ref psn); - API.TransformProcessType(ref psn, ProcessApplicationTransformState.kProcessTransformToForegroundApplication); - API.SetFrontProcess(ref psn); - } - - internal static CarbonGLNative WindowEventHandler + static internal CarbonGLNative WindowEventHandler { get { return eventHandler; } set { eventHandler = value; } @@ -63,33 +64,16 @@ namespace OpenTK.Platform.MacOS.Carbon static void ConnectEvents() { - EventTypeSpec[] eventTypes = new EventTypeSpec[] - { - new EventTypeSpec(EventClass.Application, AppEventKind.AppActivated), - new EventTypeSpec(EventClass.Application, AppEventKind.AppDeactivated), - new EventTypeSpec(EventClass.Application, AppEventKind.AppQuit), - - new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseDown), - new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseUp), - new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseMoved), - new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseDragged), - new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseEntered), - new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseExited), - new EventTypeSpec(EventClass.Mouse, MouseEventKind.WheelMoved), - - new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyDown), - new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyRepeat), - new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyUp), - new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyModifiersChanged), - - new EventTypeSpec(EventClass.AppleEvent, AppleEventKind.AppleEvent), - }; - + + EventTypeSpec[] eventTypes = new EventTypeSpec[] { new EventTypeSpec(EventClass.Application, AppEventKind.AppActivated), new EventTypeSpec(EventClass.Application, AppEventKind.AppDeactivated), new EventTypeSpec(EventClass.Application, AppEventKind.AppQuit), new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseDown), new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseUp), new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseMoved), new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseDragged), new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseEntered), new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseExited), new EventTypeSpec(EventClass.Mouse, MouseEventKind.WheelMoved), + + + new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyDown), new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyRepeat), new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyUp), new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyModifiersChanged), new EventTypeSpec(EventClass.AppleEvent, AppleEventKind.AppleEvent) }; + MacOSEventHandler handler = EventHandler; uppHandler = API.NewEventHandlerUPP(handler); - - API.InstallApplicationEventHandler( - uppHandler, eventTypes, IntPtr.Zero, IntPtr.Zero); + + API.InstallApplicationEventHandler(uppHandler, eventTypes, IntPtr.Zero, IntPtr.Zero); mInitialized = true; } @@ -100,28 +84,30 @@ namespace OpenTK.Platform.MacOS.Carbon switch (evt.EventClass) { - case EventClass.Application: - switch (evt.AppEventKind) - { - default: - return OSStatus.EventNotHandled; - } + case EventClass.Application: + switch (evt.AppEventKind) + { + default: + return OSStatus.EventNotHandled; + } - case EventClass.AppleEvent: - // only event here is the apple event. - Debug.Print("Processing apple event."); - API.ProcessAppleEvent(inEvent); - break; + + case EventClass.AppleEvent: + // only event here is the apple event. + Debug.Print("Processing apple event."); + API.ProcessAppleEvent(inEvent); + break; + + case EventClass.Keyboard: + case EventClass.Mouse: + if (WindowEventHandler != null) + { + return WindowEventHandler.DispatchEvent(inCaller, inEvent, evt, userData); + } - case EventClass.Keyboard: - case EventClass.Mouse: - if (WindowEventHandler != null) - { - return WindowEventHandler.DispatchEvent(inCaller, inEvent, evt, userData); - } - break; + break; } - + return OSStatus.EventNotHandled; } @@ -129,9 +115,9 @@ namespace OpenTK.Platform.MacOS.Carbon { window.Closed += MainWindowClosed; window.Visible = true; - + API.RunApplicationEventLoop(); - + window.Closed -= MainWindowClosed; } @@ -142,7 +128,7 @@ namespace OpenTK.Platform.MacOS.Carbon } - internal static void ProcessEvents() + static internal void ProcessEvents() { API.ProcessEvents(); } diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index a656a430..57d7b13d 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -50,10 +50,10 @@ namespace OpenTK.Platform.MacOS string title = "OpenTK Window"; Rectangle bounds, clientRectangle; - Rectangle windowedBounds; + Rectangle windowedBounds; bool mIsDisposed = false; - bool mExists = true; - DisplayDevice mDisplayDevice; + bool mExists = true; + DisplayDevice mDisplayDevice; WindowAttributes mWindowAttrib; WindowClass mWindowClass; @@ -64,36 +64,38 @@ namespace OpenTK.Platform.MacOS static Dictionary mWindows = new Dictionary(); - KeyPressEventArgs mKeyPressArgs = new KeyPressEventArgs((char)0); + KeyPressEventArgs mKeyPressArgs = new KeyPressEventArgs((char)0); - bool mMouseIn = false; - bool mIsActive = false; + bool mMouseIn = false; + bool mIsActive = false; - Icon mIcon; + Icon mIcon; #endregion - #region AGL Device Hack + #region AGL Device Hack - static internal Dictionary WindowRefMap { get { return mWindows; } } - internal DisplayDevice TargetDisplayDevice { get { return mDisplayDevice; } } + static internal Dictionary WindowRefMap + { + get { return mWindows; } + } + internal DisplayDevice TargetDisplayDevice + { + get { return mDisplayDevice; } + } - #endregion + #endregion - #region Constructors + #region Constructors - static CarbonGLNative() + static CarbonGLNative() { Application.Initialize(); } - CarbonGLNative() - : this(WindowClass.Document, - WindowAttributes.StandardDocument | - WindowAttributes.StandardHandler | - WindowAttributes.InWindowMenu | - WindowAttributes.LiveResize) - { } + CarbonGLNative() : this(WindowClass.Document, WindowAttributes.StandardDocument | WindowAttributes.StandardHandler | WindowAttributes.InWindowMenu | WindowAttributes.LiveResize) + { + } CarbonGLNative(WindowClass @class, WindowAttributes attrib) @@ -104,12 +106,9 @@ namespace OpenTK.Platform.MacOS public CarbonGLNative(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) { - CreateNativeWindow(WindowClass.Document, - WindowAttributes.StandardDocument | WindowAttributes.StandardHandler | - WindowAttributes.InWindowMenu | WindowAttributes.LiveResize, - new Rect((short)x, (short)y, (short)width, (short)height)); - - mDisplayDevice = device; + CreateNativeWindow(WindowClass.Document, WindowAttributes.StandardDocument | WindowAttributes.StandardHandler | WindowAttributes.InWindowMenu | WindowAttributes.LiveResize, new Rect((short)x, (short)y, (short)width, (short)height)); + + mDisplayDevice = device; } #endregion @@ -126,24 +125,24 @@ namespace OpenTK.Platform.MacOS { if (mIsDisposed) return; - + Debug.Print("Disposing of CarbonGLNative window."); - - API.DisposeWindow(window.WindowRef); - + + API.DisposeWindow(window.WindowRef); + mIsDisposed = true; - mExists = false; - + mExists = false; + if (disposing) { mWindows.Remove(window.WindowRef); - + window.Dispose(); window = null; } - + DisposeUPP(); - + Disposed(this, EventArgs.Empty); } @@ -163,7 +162,7 @@ namespace OpenTK.Platform.MacOS //API.RemoveEventHandler(uppHandler); //API.DisposeEventHandlerUPP(uppHandler); } - + uppHandler = IntPtr.Zero; } @@ -171,44 +170,37 @@ namespace OpenTK.Platform.MacOS { Debug.Print("Creating window..."); Debug.Indent(); - + IntPtr windowRef = API.CreateNewWindow(@class, attrib, r); API.SetWindowTitle(windowRef, title); - + window = new CarbonWindowInfo(windowRef, true, false); - + SetLocation(r.X, r.Y); SetSize(r.Width, r.Height); - + Debug.Unindent(); Debug.Print("Created window."); - + mWindows.Add(windowRef, new WeakReference(this)); - + LoadSize(); - + Rect titleSize = API.GetWindowBounds(window.WindowRef, WindowRegionCode.TitleBarRegion); mTitlebarHeight = titleSize.Height; - + Debug.Print("Titlebar size: {0}", titleSize); - + ConnectEvents(); - + System.Diagnostics.Debug.Print("Attached window events."); } void ConnectEvents() { mInputDriver = new CarbonInput(); - - EventTypeSpec[] eventTypes = new EventTypeSpec[] - { - new EventTypeSpec(EventClass.Window, WindowEventKind.WindowClose), - new EventTypeSpec(EventClass.Window, WindowEventKind.WindowClosed), - new EventTypeSpec(EventClass.Window, WindowEventKind.WindowBoundsChanged), - new EventTypeSpec(EventClass.Window, WindowEventKind.WindowActivate), - new EventTypeSpec(EventClass.Window, WindowEventKind.WindowDeactivate), - + + //new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseDown), //new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseUp), //new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseMoved), @@ -216,18 +208,18 @@ namespace OpenTK.Platform.MacOS //new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseEntered), //new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseExited), //new EventTypeSpec(EventClass.Mouse, MouseEventKind.WheelMoved), - + //new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyDown), //new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyRepeat), //new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyUp), //new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyModifiersChanged), - }; - + EventTypeSpec[] eventTypes = new EventTypeSpec[] { new EventTypeSpec(EventClass.Window, WindowEventKind.WindowClose), new EventTypeSpec(EventClass.Window, WindowEventKind.WindowClosed), new EventTypeSpec(EventClass.Window, WindowEventKind.WindowBoundsChanged), new EventTypeSpec(EventClass.Window, WindowEventKind.WindowActivate), new EventTypeSpec(EventClass.Window, WindowEventKind.WindowDeactivate) }; + MacOSEventHandler handler = EventHandler; uppHandler = API.NewEventHandlerUPP(handler); - + API.InstallWindowEventHandler(window.WindowRef, uppHandler, eventTypes, window.WindowRef, IntPtr.Zero); - + Application.WindowEventHandler = this; } @@ -239,7 +231,7 @@ namespace OpenTK.Platform.MacOS void Show() { IntPtr parent = IntPtr.Zero; - + API.ShowWindow(window.WindowRef); API.RepositionWindow(window.WindowRef, parent, WindowPositionMethod); API.SelectWindow(window.WindowRef); @@ -253,29 +245,29 @@ namespace OpenTK.Platform.MacOS internal void SetFullscreen(AglContext context) { windowedBounds = bounds; - - int width, height; - - context.SetFullScreen(window, out width, out height); - - Debug.Print("Prev Size: {0}, {1}", Width, Height); - clientRectangle.Size = new Size(width, height); - Debug.Print("New Size: {0}, {1}", Width, Height); - - // TODO: if we go full screen we need to make this use the device specified. - bounds = mDisplayDevice.Bounds; - - windowState = WindowState.Fullscreen; + int width, height; + + context.SetFullScreen(window, out width, out height); + + Debug.Print("Prev Size: {0}, {1}", Width, Height); + clientRectangle.Size = new Size(width, height); + Debug.Print("New Size: {0}, {1}", Width, Height); + + // TODO: if we go full screen we need to make this use the device specified. + bounds = mDisplayDevice.Bounds; + + + windowState = WindowState.Fullscreen; } internal void UnsetFullscreen(AglContext context) { context.UnsetFullScreen(window); - - Debug.Print("Telling Carbon to reset window state to " + windowState.ToString()); - SetCarbonWindowState(); - + + Debug.Print("Telling Carbon to reset window state to " + windowState.ToString()); + SetCarbonWindowState(); + SetSize((short)windowedBounds.Width, (short)windowedBounds.Height); } @@ -294,17 +286,17 @@ namespace OpenTK.Platform.MacOS { switch (evt.EventClass) { - case EventClass.Window: - return ProcessWindowEvent(inCaller, inEvent, evt, userData); - - case EventClass.Mouse: - return ProcessMouseEvent(inCaller, inEvent, evt, userData); - - case EventClass.Keyboard: - return ProcessKeyboardEvent(inCaller, inEvent, evt, userData); - - default: - return OSStatus.EventNotHandled; + case EventClass.Window: + return ProcessWindowEvent(inCaller, inEvent, evt, userData); + + case EventClass.Mouse: + return ProcessMouseEvent(inCaller, inEvent, evt, userData); + + case EventClass.Keyboard: + return ProcessKeyboardEvent(inCaller, inEvent, evt, userData); + default: + + return OSStatus.EventNotHandled; } } @@ -314,40 +306,40 @@ namespace OpenTK.Platform.MacOS // I think this happens if using winforms with a GameWindow sometimes. if (mWindows.ContainsKey(userData) == false) return OSStatus.EventNotHandled; - + WeakReference reference = mWindows[userData]; - + // bail out if the CarbonGLNative window has been garbage collected. if (reference.IsAlive == false) { mWindows.Remove(userData); return OSStatus.EventNotHandled; } - - CarbonGLNative window = (CarbonGLNative)reference.Target; - EventInfo evt = new EventInfo(inEvent); - + + CarbonGLNative window = (CarbonGLNative)reference.Target; + EventInfo evt = new EventInfo(inEvent); + //Debug.Print("Processing {0} event for {1}.", evt, window.window); - + if (window == null) { Debug.WriteLine("Window for event not found."); return OSStatus.EventNotHandled; } - + switch (evt.EventClass) { - case EventClass.Window: - return window.ProcessWindowEvent(inCaller, inEvent, evt, userData); - - case EventClass.Mouse: - return window.ProcessMouseEvent(inCaller, inEvent, evt, userData); - - case EventClass.Keyboard: - return window.ProcessKeyboardEvent(inCaller, inEvent, evt, userData); - - default: - return OSStatus.EventNotHandled; + case EventClass.Window: + return window.ProcessWindowEvent(inCaller, inEvent, evt, userData); + + case EventClass.Mouse: + return window.ProcessMouseEvent(inCaller, inEvent, evt, userData); + + case EventClass.Keyboard: + return window.ProcessKeyboardEvent(inCaller, inEvent, evt, userData); + default: + + return OSStatus.EventNotHandled; } } @@ -356,95 +348,95 @@ namespace OpenTK.Platform.MacOS System.Diagnostics.Debug.Assert(evt.EventClass == EventClass.Keyboard); MacOSKeyCode code = (MacOSKeyCode)0; char charCode = '\0'; - - //Debug.Print("Processing keyboard event {0}", evt.KeyboardEventKind); - - switch (evt.KeyboardEventKind) - { - case KeyboardEventKind.RawKeyDown: - case KeyboardEventKind.RawKeyRepeat: - case KeyboardEventKind.RawKeyUp: - GetCharCodes(inEvent, out code, out charCode); - mKeyPressArgs.KeyChar = charCode; - break; - } - + + //Debug.Print("Processing keyboard event {0}", evt.KeyboardEventKind); + switch (evt.KeyboardEventKind) { - case KeyboardEventKind.RawKeyRepeat: - InputDriver.Keyboard[0].KeyRepeat = true; - goto case KeyboardEventKind.RawKeyDown; - - case KeyboardEventKind.RawKeyDown: - OnKeyPress(mKeyPressArgs); - InputDriver.Keyboard[0][Keymap[code]] = true; - return OSStatus.NoError; - - case KeyboardEventKind.RawKeyUp: - InputDriver.Keyboard[0][Keymap[code]] = false; - - return OSStatus.NoError; - - case KeyboardEventKind.RawKeyModifiersChanged: - ProcessModifierKey(inEvent); - return OSStatus.NoError; - - default: - return OSStatus.EventNotHandled; + case KeyboardEventKind.RawKeyDown: + case KeyboardEventKind.RawKeyRepeat: + case KeyboardEventKind.RawKeyUp: + GetCharCodes(inEvent, out code, out charCode); + mKeyPressArgs.KeyChar = charCode; + break; } - - + + switch (evt.KeyboardEventKind) + { + case KeyboardEventKind.RawKeyRepeat: + InputDriver.Keyboard[0].KeyRepeat = true; + goto case KeyboardEventKind.RawKeyDown; + + case KeyboardEventKind.RawKeyDown: + OnKeyPress(mKeyPressArgs); + InputDriver.Keyboard[0][Keymap[code]] = true; + return OSStatus.NoError; + + case KeyboardEventKind.RawKeyUp: + InputDriver.Keyboard[0][Keymap[code]] = false; + + return OSStatus.NoError; + + case KeyboardEventKind.RawKeyModifiersChanged: + ProcessModifierKey(inEvent); + return OSStatus.NoError; + default: + + return OSStatus.EventNotHandled; + } + + } private OSStatus ProcessWindowEvent(IntPtr inCaller, IntPtr inEvent, EventInfo evt, IntPtr userData) { System.Diagnostics.Debug.Assert(evt.EventClass == EventClass.Window); - + switch (evt.WindowEventKind) { - case WindowEventKind.WindowClose: - CancelEventArgs cancel = new CancelEventArgs(); - OnClosing(cancel); - - if (cancel.Cancel) - return OSStatus.NoError; - else - return OSStatus.EventNotHandled; - - case WindowEventKind.WindowClosed: - mExists = false; - OnClosed(); - + case WindowEventKind.WindowClose: + CancelEventArgs cancel = new CancelEventArgs(); + OnClosing(cancel); + + if (cancel.Cancel) return OSStatus.NoError; - - case WindowEventKind.WindowBoundsChanged: - int thisWidth = Width; - int thisHeight = Height; - int thisX = X; - int thisY = Y; - - LoadSize(); - - if (thisX != X || thisY != Y) - Move(this, EventArgs.Empty); - - if (thisWidth != Width || thisHeight != Height) - Resize(this, EventArgs.Empty); - - return OSStatus.EventNotHandled; - - case WindowEventKind.WindowActivate: - OnActivate(); - return OSStatus.EventNotHandled; - - case WindowEventKind.WindowDeactivate: - OnDeactivate(); - return OSStatus.EventNotHandled; - - default: - Debug.Print("{0}", evt); - + else return OSStatus.EventNotHandled; + + case WindowEventKind.WindowClosed: + mExists = false; + OnClosed(); + + return OSStatus.NoError; + + case WindowEventKind.WindowBoundsChanged: + int thisWidth = Width; + int thisHeight = Height; + int thisX = X; + int thisY = Y; + + LoadSize(); + + if (thisX != X || thisY != Y) + Move(this, EventArgs.Empty); + + if (thisWidth != Width || thisHeight != Height) + Resize(this, EventArgs.Empty); + + return OSStatus.EventNotHandled; + + case WindowEventKind.WindowActivate: + OnActivate(); + return OSStatus.EventNotHandled; + + case WindowEventKind.WindowDeactivate: + OnDeactivate(); + return OSStatus.EventNotHandled; + default: + + Debug.Print("{0}", evt); + + return OSStatus.EventNotHandled; } } protected OSStatus ProcessMouseEvent(IntPtr inCaller, IntPtr inEvent, EventInfo evt, IntPtr userData) @@ -452,19 +444,20 @@ namespace OpenTK.Platform.MacOS System.Diagnostics.Debug.Assert(evt.EventClass == EventClass.Mouse); MouseButton button = MouseButton.Primary; HIPoint pt = new HIPoint(); - HIPoint screenLoc = new HIPoint(); - - OSStatus err = API.GetEventMouseLocation(inEvent, out screenLoc); - + HIPoint screenLoc = new HIPoint(); + + OSStatus err = API.GetEventMouseLocation(inEvent, out screenLoc); + if (this.windowState == WindowState.Fullscreen) { - pt = screenLoc; + pt = screenLoc; } + else { err = API.GetEventWindowMouseLocation(inEvent, out pt); } - + if (err != OSStatus.NoError) { // this error comes up from the application event handler. @@ -473,126 +466,128 @@ namespace OpenTK.Platform.MacOS throw new MacOSException(err); } } - - Point mousePosInClient = new Point((int)pt.X, (int)pt.Y); - if (this.windowState != WindowState.Fullscreen) - { - mousePosInClient.Y -= mTitlebarHeight; - } - - // check for enter/leave events - IntPtr thisEventWindow; - API.GetEventWindowRef(inEvent, out thisEventWindow); - CheckEnterLeaveEvents(thisEventWindow, mousePosInClient); - + + Point mousePosInClient = new Point((int)pt.X, (int)pt.Y); + if (this.windowState != WindowState.Fullscreen) + { + mousePosInClient.Y -= mTitlebarHeight; + } + + // check for enter/leave events + IntPtr thisEventWindow; + API.GetEventWindowRef(inEvent, out thisEventWindow); + CheckEnterLeaveEvents(thisEventWindow, mousePosInClient); + switch (evt.MouseEventKind) { - case MouseEventKind.MouseDown: - button = API.GetEventMouseButton(inEvent); + case MouseEventKind.MouseDown: + button = API.GetEventMouseButton(inEvent); + + switch (button) + { + case MouseButton.Primary: + InputDriver.Mouse[0][OpenTK.Input.MouseButton.Left] = true; + break; + + case MouseButton.Secondary: + InputDriver.Mouse[0][OpenTK.Input.MouseButton.Right] = true; + break; + + case MouseButton.Tertiary: + InputDriver.Mouse[0][OpenTK.Input.MouseButton.Middle] = true; + break; + } - switch (button) + + + return OSStatus.NoError; + + case MouseEventKind.MouseUp: + button = API.GetEventMouseButton(inEvent); + + switch (button) + { + case MouseButton.Primary: + InputDriver.Mouse[0][OpenTK.Input.MouseButton.Left] = false; + break; + + case MouseButton.Secondary: + InputDriver.Mouse[0][OpenTK.Input.MouseButton.Right] = false; + break; + + case MouseButton.Tertiary: + InputDriver.Mouse[0][OpenTK.Input.MouseButton.Middle] = false; + break; + } + + + button = API.GetEventMouseButton(inEvent); + + return OSStatus.NoError; + + case MouseEventKind.WheelMoved: + + int delta = API.GetEventMouseWheelDelta(inEvent) / 3; + + InputDriver.Mouse[0].Wheel += delta; + + return OSStatus.NoError; + + case MouseEventKind.MouseMoved: + case MouseEventKind.MouseDragged: + + //Debug.Print("Mouse Location: {0}, {1}", pt.X, pt.Y); + + if (this.windowState == WindowState.Fullscreen) + { + if (mousePosInClient.X != InputDriver.Mouse[0].X || mousePosInClient.Y != InputDriver.Mouse[0].Y) { - case MouseButton.Primary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Left] = true; - break; - - case MouseButton.Secondary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Right] = true; - break; - - case MouseButton.Tertiary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Middle] = true; - break; + InputDriver.Mouse[0].Position = mousePosInClient; } + } - - return OSStatus.NoError; - - case MouseEventKind.MouseUp: - button = API.GetEventMouseButton(inEvent); - - switch (button) + else + { + // ignore clicks in the title bar + if (pt.Y < 0) + return OSStatus.EventNotHandled; + + if (mousePosInClient.X != InputDriver.Mouse[0].X || mousePosInClient.Y != InputDriver.Mouse[0].Y) { - case MouseButton.Primary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Left] = false; - break; - - case MouseButton.Secondary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Right] = false; - break; - - case MouseButton.Tertiary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Middle] = false; - break; + InputDriver.Mouse[0].Position = mousePosInClient; } + } - button = API.GetEventMouseButton(inEvent); - - return OSStatus.NoError; - - case MouseEventKind.WheelMoved: - - int delta = API.GetEventMouseWheelDelta(inEvent) / 3; - - InputDriver.Mouse[0].Wheel += delta; - - return OSStatus.NoError; - - case MouseEventKind.MouseMoved: - case MouseEventKind.MouseDragged: - - //Debug.Print("Mouse Location: {0}, {1}", pt.X, pt.Y); - - if (this.windowState == WindowState.Fullscreen) - { - if (mousePosInClient.X != InputDriver.Mouse[0].X || - mousePosInClient.Y != InputDriver.Mouse[0].Y) - { - InputDriver.Mouse[0].Position = mousePosInClient; - } - } - else - { - // ignore clicks in the title bar - if (pt.Y < 0) - return OSStatus.EventNotHandled; - - if (mousePosInClient.X != InputDriver.Mouse[0].X || - mousePosInClient.Y != InputDriver.Mouse[0].Y) - { - InputDriver.Mouse[0].Position = mousePosInClient; - } - } - - return OSStatus.EventNotHandled; - - default: - Debug.Print("{0}", evt); - - return OSStatus.EventNotHandled; + + return OSStatus.EventNotHandled; + default: + + Debug.Print("{0}", evt); + + return OSStatus.EventNotHandled; } } - private void CheckEnterLeaveEvents(IntPtr eventWindowRef, Point pt) - { - if (window == null) - return; - - bool thisIn = eventWindowRef == window.WindowRef; - - if (pt.Y < 0) - thisIn = false; - - if (thisIn != mMouseIn) - { - mMouseIn = thisIn; - - if (mMouseIn) - OnMouseEnter(); - else - OnMouseLeave(); - } - } + private void CheckEnterLeaveEvents(IntPtr eventWindowRef, Point pt) + { + if (window == null) + return; + + bool thisIn = eventWindowRef == window.WindowRef; + + if (pt.Y < 0) + thisIn = false; + + if (thisIn != mMouseIn) + { + mMouseIn = thisIn; + + if (mMouseIn) + OnMouseEnter(); + else + OnMouseLeave(); + } + } private static void GetCharCodes(IntPtr inEvent, out MacOSKeyCode code, out char charCode) { @@ -602,38 +597,38 @@ namespace OpenTK.Platform.MacOS private void ProcessModifierKey(IntPtr inEvent) { MacOSKeyModifiers modifiers = API.GetEventKeyModifiers(inEvent); - + bool caps = (modifiers & MacOSKeyModifiers.CapsLock) != 0 ? true : false; bool control = (modifiers & MacOSKeyModifiers.Control) != 0 ? true : false; bool command = (modifiers & MacOSKeyModifiers.Command) != 0 ? true : false; bool option = (modifiers & MacOSKeyModifiers.Option) != 0 ? true : false; bool shift = (modifiers & MacOSKeyModifiers.Shift) != 0 ? true : false; - + Debug.Print("Modifiers Changed: {0}", modifiers); - + Input.KeyboardDevice keyboard = InputDriver.Keyboard[0]; - + if (keyboard[OpenTK.Input.Key.AltLeft] ^ option) keyboard[OpenTK.Input.Key.AltLeft] = option; - + if (keyboard[OpenTK.Input.Key.ShiftLeft] ^ shift) keyboard[OpenTK.Input.Key.ShiftLeft] = shift; - + if (keyboard[OpenTK.Input.Key.WinLeft] ^ command) keyboard[OpenTK.Input.Key.WinLeft] = command; - + if (keyboard[OpenTK.Input.Key.ControlLeft] ^ control) keyboard[OpenTK.Input.Key.ControlLeft] = control; - + if (keyboard[OpenTK.Input.Key.CapsLock] ^ caps) keyboard[OpenTK.Input.Key.CapsLock] = caps; - + } Rect GetRegion() { Rect retval = API.GetWindowBounds(window.WindowRef, WindowRegionCode.ContentRegion); - + return retval; } @@ -641,7 +636,7 @@ namespace OpenTK.Platform.MacOS { if (windowState == WindowState.Fullscreen) return; - + API.MoveWindow(window.WindowRef, x, y, false); } @@ -649,42 +644,42 @@ namespace OpenTK.Platform.MacOS { if (WindowState == WindowState.Fullscreen) return; - - // The bounds of the window should be the size specified, but - // API.SizeWindow sets the content region size. So - // we reduce the size to get the correct bounds. - width -= (short)(bounds.Width - clientRectangle.Width); - height -= (short)(bounds.Height - clientRectangle.Height); + + // The bounds of the window should be the size specified, but + // API.SizeWindow sets the content region size. So + // we reduce the size to get the correct bounds. + width -= (short)(bounds.Width - clientRectangle.Width); + height -= (short)(bounds.Height - clientRectangle.Height); + + API.SizeWindow(window.WindowRef, width, height, true); + } + + void SetClientSize(short width, short height) + { + if (WindowState == WindowState.Fullscreen) + return; API.SizeWindow(window.WindowRef, width, height, true); } - void SetClientSize(short width, short height) - { - if (WindowState == WindowState.Fullscreen) - return; - - API.SizeWindow(window.WindowRef, width, height, true); - } - private void LoadSize() { if (WindowState == WindowState.Fullscreen) return; - - Rect r = API.GetWindowBounds(window.WindowRef, WindowRegionCode.StructureRegion); - bounds = new Rectangle(r.X, r.Y, r.Width, r.Height); - - r = API.GetWindowBounds(window.WindowRef, WindowRegionCode.GlobalPortRegion); - clientRectangle = new Rectangle(0, 0, r.Width, r.Height); + + Rect r = API.GetWindowBounds(window.WindowRef, WindowRegionCode.StructureRegion); + bounds = new Rectangle(r.X, r.Y, r.Width, r.Height); + + r = API.GetWindowBounds(window.WindowRef, WindowRegionCode.GlobalPortRegion); + clientRectangle = new Rectangle(0, 0, r.Width, r.Height); } #endregion - #region INativeWindow Members + #region INativeWindow Members - public void ProcessEvents() + public void ProcessEvents() { Application.ProcessEvents(); } @@ -693,15 +688,15 @@ namespace OpenTK.Platform.MacOS { Rect r = Carbon.API.GetWindowBounds(window.WindowRef, WindowRegionCode.ContentRegion); Debug.Print("Rect: {0}", r); - + return new Point(point.X - r.X, point.Y - r.Y); } public Point PointToScreen(Point point) { - Rect r = Carbon.API.GetWindowBounds(window.WindowRef, WindowRegionCode.ContentRegion); - Debug.Print("Rect: {0}", r); - - return new Point(point.X + r.X, point.Y + r.Y); + Rect r = Carbon.API.GetWindowBounds(window.WindowRef, WindowRegionCode.ContentRegion); + Debug.Print("Rect: {0}", r); + + return new Point(point.X + r.X, point.Y + r.Y); } public bool Exists @@ -721,10 +716,7 @@ namespace OpenTK.Platform.MacOS public OpenTK.Input.IInputDriver InputDriver { - get - { - return mInputDriver; - } + get { return mInputDriver; } } @@ -742,63 +734,63 @@ namespace OpenTK.Platform.MacOS } } - private void SetIcon(Icon icon) - { - // The code for this function was adapted from Mono's - // XplatUICarbon implementation, written by Geoff Norton - // http://anonsvn.mono-project.com/viewvc/trunk/mcs/class/Managed.Windows.Forms/System.Windows.Forms/XplatUICarbon.cs?view=markup&pathrev=136932 - if (icon == null) - { - API.RestoreApplicationDockTileImage(); - } - else - { - Bitmap bitmap; - int size; - IntPtr[] data; - int index; + private void SetIcon(Icon icon) + { + // The code for this function was adapted from Mono's + // XplatUICarbon implementation, written by Geoff Norton + // http://anonsvn.mono-project.com/viewvc/trunk/mcs/class/Managed.Windows.Forms/System.Windows.Forms/XplatUICarbon.cs?view=markup&pathrev=136932 + if (icon == null) + { + API.RestoreApplicationDockTileImage(); + } - bitmap = new Bitmap(128, 128); - using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(bitmap)) - { - g.DrawImage(icon.ToBitmap(), 0, 0, 128, 128); - } - index = 0; - size = bitmap.Width * bitmap.Height; - data = new IntPtr[size]; + else + { + Bitmap bitmap; + int size; + IntPtr[] data; + int index; + + bitmap = new Bitmap(128, 128); + using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(bitmap)) + { + g.DrawImage(icon.ToBitmap(), 0, 0, 128, 128); + } + index = 0; + size = bitmap.Width * bitmap.Height; + data = new IntPtr[size]; + + for (int y = 0; y < bitmap.Height; y++) + { + for (int x = 0; x < bitmap.Width; x++) + { + int pixel = bitmap.GetPixel(x, y).ToArgb(); + if (BitConverter.IsLittleEndian) + { + byte a = (byte)((pixel >> 24) & 0xFF); + byte r = (byte)((pixel >> 16) & 0xFF); + byte g = (byte)((pixel >> 8) & 0xFF); + byte b = (byte)(pixel & 0xFF); + data[index++] = (IntPtr)(a + (r << 8) + (g << 16) + (b << 24)); + } - for (int y = 0; y < bitmap.Height; y++) - { - for (int x = 0; x < bitmap.Width; x++) - { - int pixel = bitmap.GetPixel(x, y).ToArgb(); - if (BitConverter.IsLittleEndian) - { - byte a = (byte)((pixel >> 24) & 0xFF); - byte r = (byte)((pixel >> 16) & 0xFF); - byte g = (byte)((pixel >> 8) & 0xFF); - byte b = (byte)(pixel & 0xFF); - data[index++] = (IntPtr)(a + (r << 8) + (g << 16) + (b << 24)); - } - else - { - data[index++] = (IntPtr)pixel; - } - } - } - - IntPtr provider = API.CGDataProviderCreateWithData(IntPtr.Zero, data, size * 4, IntPtr.Zero); - IntPtr image = API.CGImageCreate(128, 128, 8, 32, 4 * 128, API.CGColorSpaceCreateDeviceRGB(), 4, provider, IntPtr.Zero, 0, 0); - API.SetApplicationDockTileImage(image); - } - } + else + { + data[index++] = (IntPtr)pixel; + } + } + } + + IntPtr provider = API.CGDataProviderCreateWithData(IntPtr.Zero, data, size * 4, IntPtr.Zero); + IntPtr image = API.CGImageCreate(128, 128, 8, 32, 4 * 128, API.CGColorSpaceCreateDeviceRGB(), 4, provider, IntPtr.Zero, 0, + 0); + API.SetApplicationDockTileImage(image); + } + } public string Title { - get - { - return title; - } + get { return title; } set { if (value != Title) @@ -821,7 +813,7 @@ namespace OpenTK.Platform.MacOS Show(); else Hide(); - + VisibleChanged(this, EventArgs.Empty); } } @@ -829,16 +821,13 @@ namespace OpenTK.Platform.MacOS public bool Focused { - get { return this.mIsActive; } + get { return this.mIsActive; } } public Rectangle Bounds { - get - { - - return bounds; - } + + get { return bounds; } set { Location = value.Location; @@ -848,26 +837,14 @@ namespace OpenTK.Platform.MacOS public Point Location { - get - { - return Bounds.Location; - } - set - { - SetLocation((short)value.X, (short)value.Y); - } + get { return Bounds.Location; } + set { SetLocation((short)value.X, (short)value.Y); } } public Size Size { - get - { - return bounds.Size; - } - set - { - SetSize((short)value.Width, (short)value.Height); - } + get { return bounds.Size; } + set { SetSize((short)value.Width, (short)value.Height); } } public int Width @@ -884,51 +861,30 @@ namespace OpenTK.Platform.MacOS public int X { - get - { - return ClientRectangle.X; - } - set - { - Location = new Point(value, Y); - } + get { return ClientRectangle.X; } + set { Location = new Point(value, Y); } } public int Y { - get - { - return ClientRectangle.Y; - } - set - { - Location = new Point(X, value); - } + get { return ClientRectangle.Y; } + set { Location = new Point(X, value); } } public Rectangle ClientRectangle { - get - { - return clientRectangle; - } - set - { - // just set the size, and ignore the location value. - // this is the behavior of the Windows WinGLNative. - ClientSize = value.Size; - } + get { return clientRectangle; } +// just set the size, and ignore the location value. +// this is the behavior of the Windows WinGLNative. + set { ClientSize = value.Size; } } public Size ClientSize { - get - { - return clientRectangle.Size; - } + get { return clientRectangle.Size; } set { - API.SizeWindow(window.WindowRef, (short)value.Width, (short)value.Height, true); + API.SizeWindow(window.WindowRef, (short)value.Width, (short)value.Height, true); LoadSize(); Resize(this, EventArgs.Empty); } @@ -942,15 +898,15 @@ namespace OpenTK.Platform.MacOS public void Close() { - CancelEventArgs e = new CancelEventArgs(); - OnClosing(e); - - if (e.Cancel) - return; - - OnClosed(); - - Dispose(); + CancelEventArgs e = new CancelEventArgs(); + OnClosing(e); + + if (e.Cancel) + return; + + OnClosed(); + + Dispose(); } public WindowState WindowState @@ -959,158 +915,155 @@ namespace OpenTK.Platform.MacOS { if (windowState == WindowState.Fullscreen) return WindowState.Fullscreen; - + if (Carbon.API.IsWindowCollapsed(window.WindowRef)) return WindowState.Minimized; - + if (Carbon.API.IsWindowInStandardState(window.WindowRef)) { return WindowState.Maximized; } - + return WindowState.Normal; } set { if (value == WindowState) return; - + Debug.Print("Switching window state from {0} to {1}", WindowState, value); - WindowState oldState = WindowState; - - windowState = value; - - if (oldState == WindowState.Fullscreen) + WindowState oldState = WindowState; + + windowState = value; + + if (oldState == WindowState.Fullscreen) { - window.GoWindowedHack = true; - - // when returning from full screen, wait until the context is updated - // to actually do the work. - return; + window.GoWindowedHack = true; + + // when returning from full screen, wait until the context is updated + // to actually do the work. + return; } - + if (oldState == WindowState.Minimized) { API.CollapseWindow(window.WindowRef, false); } - - SetCarbonWindowState(); + + SetCarbonWindowState(); } } - private void SetCarbonWindowState() - { - CarbonPoint idealSize; - - switch (windowState) - { - case WindowState.Fullscreen: - window.GoFullScreenHack = true; - - break; - - case WindowState.Maximized: - // hack because mac os has no concept of maximized. Instead windows are "zoomed" - // meaning they are maximized up to their reported ideal size. So we report a - // large ideal size. - idealSize = new CarbonPoint(9000, 9000); - API.ZoomWindowIdeal(window.WindowRef, WindowPartCode.inZoomOut, ref idealSize); - break; - - case WindowState.Normal: - if (WindowState == WindowState.Maximized) - { - idealSize = new CarbonPoint(); - API.ZoomWindowIdeal(window.WindowRef, WindowPartCode.inZoomIn, ref idealSize); - } - break; - - case WindowState.Minimized: - API.CollapseWindow(window.WindowRef, true); - - break; - } - + private void SetCarbonWindowState() + { + CarbonPoint idealSize; + + switch (windowState) + { + case WindowState.Fullscreen: + window.GoFullScreenHack = true; + + break; + + case WindowState.Maximized: + // hack because mac os has no concept of maximized. Instead windows are "zoomed" + // meaning they are maximized up to their reported ideal size. So we report a + // large ideal size. + idealSize = new CarbonPoint(9000, 9000); + API.ZoomWindowIdeal(window.WindowRef, WindowPartCode.inZoomOut, ref idealSize); + break; + + case WindowState.Normal: + if (WindowState == WindowState.Maximized) + { + idealSize = new CarbonPoint(); + API.ZoomWindowIdeal(window.WindowRef, WindowPartCode.inZoomIn, ref idealSize); + } + break; + + case WindowState.Minimized: + API.CollapseWindow(window.WindowRef, true); + + break; + } + + WindowStateChanged(this, EventArgs.Empty); LoadSize(); Resize(this, EventArgs.Empty); - } + } - public WindowBorder WindowBorder - { - get - { - return windowBorder; - } - set - { - if (windowBorder == value) - return; + public WindowBorder WindowBorder + { + get { return windowBorder; } + set + { + if (windowBorder == value) + return; + + windowBorder = value; + + if (windowBorder == WindowBorder.Resizable) + { + API.ChangeWindowAttributes(window.WindowRef, WindowAttributes.Resizable | WindowAttributes.FullZoom, WindowAttributes.NoAttributes); + } - windowBorder = value; + else if (windowBorder == WindowBorder.Fixed) + { + API.ChangeWindowAttributes(window.WindowRef, WindowAttributes.NoAttributes, WindowAttributes.Resizable | WindowAttributes.FullZoom); + } + + WindowBorderChanged(this, EventArgs.Empty); + } + } - if (windowBorder == WindowBorder.Resizable) - { - API.ChangeWindowAttributes(window.WindowRef, WindowAttributes.Resizable | WindowAttributes.FullZoom, - WindowAttributes.NoAttributes); - } - else if (windowBorder == WindowBorder.Fixed) - { - API.ChangeWindowAttributes(window.WindowRef, WindowAttributes.NoAttributes, - WindowAttributes.Resizable | WindowAttributes.FullZoom); - } + #region --- Event wrappers --- - WindowBorderChanged(this, EventArgs.Empty); - } - } - - #region --- Event wrappers --- - - private void OnKeyPress(KeyPressEventArgs keyPressArgs) - { - KeyPress(this, keyPressArgs); - } + private void OnKeyPress(KeyPressEventArgs keyPressArgs) + { + KeyPress(this, keyPressArgs); + } - private void OnWindowStateChanged() - { - WindowStateChanged(this, EventArgs.Empty); - } + private void OnWindowStateChanged() + { + WindowStateChanged(this, EventArgs.Empty); + } - protected virtual void OnClosing(CancelEventArgs e) - { - Closing(this, e); - } + protected virtual void OnClosing(CancelEventArgs e) + { + Closing(this, e); + } - protected virtual void OnClosed() - { - Closed(this, EventArgs.Empty); - } + protected virtual void OnClosed() + { + Closed(this, EventArgs.Empty); + } - private void OnMouseLeave() - { - MouseLeave(this, EventArgs.Empty); - } + private void OnMouseLeave() + { + MouseLeave(this, EventArgs.Empty); + } - private void OnMouseEnter() - { - MouseEnter(this, EventArgs.Empty); - } + private void OnMouseEnter() + { + MouseEnter(this, EventArgs.Empty); + } - private void OnActivate() - { - mIsActive = true; - FocusedChanged(this, EventArgs.Empty); - } - private void OnDeactivate() - { - mIsActive = false; - FocusedChanged(this, EventArgs.Empty); - } + private void OnActivate() + { + mIsActive = true; + FocusedChanged(this, EventArgs.Empty); + } + private void OnDeactivate() + { + mIsActive = false; + FocusedChanged(this, EventArgs.Empty); + } - #endregion + #endregion public event EventHandler Move = delegate { }; public event EventHandler Resize = delegate { }; @@ -1126,7 +1079,7 @@ namespace OpenTK.Platform.MacOS public event EventHandler KeyPress = delegate { }; public event EventHandler MouseEnter = delegate { }; public event EventHandler MouseLeave = delegate { }; - + #endregion } } diff --git a/Source/OpenTK/Platform/MacOS/CarbonInput.cs b/Source/OpenTK/Platform/MacOS/CarbonInput.cs index 615c0899..654e8321 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonInput.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonInput.cs @@ -65,17 +65,26 @@ namespace OpenTK.Platform.MacOS public IMouseDriver2 MouseDriver { - get { throw new NotImplementedException(); } + get + { + throw new NotImplementedException(); + } } public IKeyboardDriver2 KeyboardDriver { - get { throw new NotImplementedException(); } + get + { + throw new NotImplementedException(); + } } public IGamePadDriver GamePadDriver { - get { throw new NotImplementedException(); } + get + { + throw new NotImplementedException(); + } } } } diff --git a/Source/OpenTK/Platform/MacOS/CarbonWindowInfo.cs b/Source/OpenTK/Platform/MacOS/CarbonWindowInfo.cs index 7f3eabdf..cd594a49 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonWindowInfo.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonWindowInfo.cs @@ -36,14 +36,14 @@ namespace OpenTK.Platform.MacOS /// /// Describes a Carbon window. /// - sealed class CarbonWindowInfo : IWindowInfo + sealed class CarbonWindowInfo : IWindowInfo { IntPtr windowRef; bool ownHandle = false; bool disposed = false; bool isControl = false; - bool goFullScreenHack = false; - bool goWindowedHack = false; + bool goFullScreenHack = false; + bool goWindowedHack = false; #region Constructors @@ -72,16 +72,16 @@ namespace OpenTK.Platform.MacOS get { return this.windowRef; } } - internal bool GoFullScreenHack - { - get { return goFullScreenHack; } - set { goFullScreenHack = value; } - } - internal bool GoWindowedHack - { - get { return goWindowedHack; } - set { goWindowedHack = value; } - } + internal bool GoFullScreenHack + { + get { return goFullScreenHack; } + set { goFullScreenHack = value; } + } + internal bool GoWindowedHack + { + get { return goWindowedHack; } + set { goWindowedHack = value; } + } /// @@ -96,8 +96,7 @@ namespace OpenTK.Platform.MacOS /// A System.String that represents the current window. public override string ToString() { - return String.Format("MacOS.CarbonWindowInfo: Handle {0}", - this.WindowRef); + return String.Format("MacOS.CarbonWindowInfo: Handle {0}", this.WindowRef); } #endregion @@ -113,19 +112,19 @@ namespace OpenTK.Platform.MacOS { if (disposed) return; - + if (disposing) { - + } - + if (ownHandle) { Debug.Print("Disposing window {0}.", windowRef); Carbon.API.DisposeWindow(this.windowRef); windowRef = IntPtr.Zero; } - + disposed = true; } @@ -133,7 +132,7 @@ namespace OpenTK.Platform.MacOS { Dispose(false); } - + #endregion } } diff --git a/Source/OpenTK/Platform/MacOS/EventInfo.cs b/Source/OpenTK/Platform/MacOS/EventInfo.cs index 87ea61dc..c5400001 100644 --- a/Source/OpenTK/Platform/MacOS/EventInfo.cs +++ b/Source/OpenTK/Platform/MacOS/EventInfo.cs @@ -25,14 +25,17 @@ namespace OpenTK.Platform.MacOS.Carbon uint _eventKind; EventClass _eventClass; - public EventClass EventClass { get { return _eventClass; }} - + public EventClass EventClass + { + get { return _eventClass; } + } + public WindowEventKind WindowEventKind { get { if (EventClass == EventClass.Window) - return (WindowEventKind) _eventKind; + return (WindowEventKind)_eventKind; else throw new InvalidCastException("Event is not a Window event."); } @@ -42,7 +45,7 @@ namespace OpenTK.Platform.MacOS.Carbon get { if (EventClass == EventClass.Keyboard) - return (KeyboardEventKind) _eventKind; + return (KeyboardEventKind)_eventKind; else throw new InvalidCastException("Event is not a Keyboard event."); } @@ -52,7 +55,7 @@ namespace OpenTK.Platform.MacOS.Carbon get { if (EventClass == EventClass.Mouse) - return (MouseEventKind) _eventKind; + return (MouseEventKind)_eventKind; else throw new InvalidCastException("Event is not an Mouse event."); } @@ -62,7 +65,7 @@ namespace OpenTK.Platform.MacOS.Carbon get { if (EventClass == EventClass.Application) - return (AppEventKind) _eventKind; + return (AppEventKind)_eventKind; else throw new InvalidCastException("Event is not an Application event."); } @@ -71,18 +74,18 @@ namespace OpenTK.Platform.MacOS.Carbon public override string ToString() { - switch(EventClass) + switch (EventClass) { - case EventClass.Application: - return "Event: App " + AppEventKind.ToString(); - case EventClass.Keyboard: - return "Event: Keyboard " + KeyboardEventKind.ToString(); - case EventClass.Mouse: - return "Event: Mouse " + MouseEventKind.ToString(); - case EventClass.Window: - return "Event: Window " + WindowEventKind.ToString(); + case EventClass.Application: + return "Event: App " + AppEventKind.ToString(); + case EventClass.Keyboard: + return "Event: Keyboard " + KeyboardEventKind.ToString(); + case EventClass.Mouse: + return "Event: Mouse " + MouseEventKind.ToString(); + case EventClass.Window: + return "Event: Window " + WindowEventKind.ToString(); } - + return "Event: Unknown Class " + EventClass.ToString() + " kind: " + _eventKind.ToString(); } } diff --git a/Source/OpenTK/Platform/MacOS/MacOSFactory.cs b/Source/OpenTK/Platform/MacOS/MacOSFactory.cs index e16a58bc..c83163db 100644 --- a/Source/OpenTK/Platform/MacOS/MacOSFactory.cs +++ b/Source/OpenTK/Platform/MacOS/MacOSFactory.cs @@ -55,7 +55,7 @@ namespace OpenTK.Platform.MacOS public virtual IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return new AglContext(handle, window, shareContext); - } + } public virtual GraphicsContext.GetCurrentContextDelegate CreateGetCurrentGraphicsContext() { @@ -79,7 +79,7 @@ namespace OpenTK.Platform.MacOS { throw new NotImplementedException(); } - + #endregion } } diff --git a/Source/OpenTK/Platform/MacOS/MacOSGraphicsMode.cs b/Source/OpenTK/Platform/MacOS/MacOSGraphicsMode.cs index ef3590ce..c49d3401 100644 --- a/Source/OpenTK/Platform/MacOS/MacOSGraphicsMode.cs +++ b/Source/OpenTK/Platform/MacOS/MacOSGraphicsMode.cs @@ -6,20 +6,19 @@ namespace OpenTK.Platform.MacOS { using Graphics; - class MacOSGraphicsMode : IGraphicsMode + class MacOSGraphicsMode : IGraphicsMode { #region IGraphicsMode Members public GraphicsMode SelectGraphicsMode(ColorFormat color, int depth, int stencil, int samples, ColorFormat accum, int buffers, bool stereo) { - GraphicsMode gfx = new GraphicsMode((IntPtr)1, color, depth, stencil, samples, - accum, buffers, stereo); - + GraphicsMode gfx = new GraphicsMode((IntPtr)1, color, depth, stencil, samples, accum, buffers, stereo); + System.Diagnostics.Debug.Print("Created dummy graphics mode."); - + return gfx; } - + #endregion } } diff --git a/Source/OpenTK/Platform/MacOS/MacOSKeyMap.cs b/Source/OpenTK/Platform/MacOS/MacOSKeyMap.cs index a92f160f..e5ffc834 100644 --- a/Source/OpenTK/Platform/MacOS/MacOSKeyMap.cs +++ b/Source/OpenTK/Platform/MacOS/MacOSKeyMap.cs @@ -12,7 +12,7 @@ namespace OpenTK.Platform.MacOS public MacOSKeyMap() { // comments indicate members of the Key enum that are missing - + Add(MacOSKeyCode.A, Key.A); // AltLeft // AltRight @@ -127,7 +127,7 @@ namespace OpenTK.Platform.MacOS Add(MacOSKeyCode.X, Key.X); Add(MacOSKeyCode.Y, Key.Y); Add(MacOSKeyCode.Z, Key.Z); - + } } } diff --git a/Source/OpenTK/Platform/MacOS/QuartzDisplayDeviceDriver.cs b/Source/OpenTK/Platform/MacOS/QuartzDisplayDeviceDriver.cs index 3f3e65af..999b1d45 100644 --- a/Source/OpenTK/Platform/MacOS/QuartzDisplayDeviceDriver.cs +++ b/Source/OpenTK/Platform/MacOS/QuartzDisplayDeviceDriver.cs @@ -11,11 +11,13 @@ namespace OpenTK.Platform.MacOS { static object display_lock = new object(); - static Dictionary displayMap = - new Dictionary(); + static Dictionary displayMap = new Dictionary(); static IntPtr mainDisplay; - internal static IntPtr MainDisplay { get { return mainDisplay; } } + static internal IntPtr MainDisplay + { + get { return mainDisplay; } + } static QuartzDisplayDeviceDriver() { @@ -30,135 +32,130 @@ namespace OpenTK.Platform.MacOS const int maxDisplayCount = 20; IntPtr[] displays = new IntPtr[maxDisplayCount]; int displayCount; - + unsafe { - fixed(IntPtr* displayPtr = displays) + fixed (IntPtr* displayPtr = displays) { CG.GetActiveDisplayList(maxDisplayCount, displayPtr, out displayCount); } } - + Debug.Print("CoreGraphics reported {0} display(s).", displayCount); Debug.Indent(); - + for (int i = 0; i < displayCount; i++) { IntPtr currentDisplay = displays[i]; - + // according to docs, first element in the array is always the // main display. bool primary = (i == 0); - + if (primary) mainDisplay = currentDisplay; - + // gets current settings int currentWidth = CG.DisplayPixelsWide(currentDisplay); int currentHeight = CG.DisplayPixelsHigh(currentDisplay); Debug.Print("Display {0} is at {1}x{2}", i, currentWidth, currentHeight); - - IntPtr displayModesPtr = CG.DisplayAvailableModes(currentDisplay); + + IntPtr displayModesPtr = CG.DisplayAvailableModes(currentDisplay); CFArray displayModes = new CFArray(displayModesPtr); Debug.Print("Supports {0} display modes.", displayModes.Count); - + DisplayResolution opentk_dev_current_res = null; List opentk_dev_available_res = new List(); IntPtr currentModePtr = CG.DisplayCurrentMode(currentDisplay); CFDictionary currentMode = new CFDictionary(currentModePtr); - + for (int j = 0; j < displayModes.Count; j++) { CFDictionary dict = new CFDictionary(displayModes[j]); - int width = (int) dict.GetNumberValue("Width"); - int height = (int) dict.GetNumberValue("Height"); - int bpp = (int) dict.GetNumberValue("BitsPerPixel"); + int width = (int)dict.GetNumberValue("Width"); + int height = (int)dict.GetNumberValue("Height"); + int bpp = (int)dict.GetNumberValue("BitsPerPixel"); double freq = dict.GetNumberValue("RefreshRate"); bool current = currentMode.Ref == dict.Ref; - + //if (current) Debug.Write(" * "); //else Debug.Write(" "); - + //Debug.Print("Mode {0} is {1}x{2}x{3} @ {4}.", j, width, height, bpp, freq); - + DisplayResolution thisRes = new DisplayResolution(0, 0, width, height, bpp, (float)freq); opentk_dev_available_res.Add(thisRes); - + if (current) opentk_dev_current_res = thisRes; - + } - - HIRect bounds = CG.DisplayBounds(currentDisplay); - Rectangle newRect = new Rectangle( - (int)bounds.Origin.X, (int)bounds.Origin.Y, (int)bounds.Size.Width, (int)bounds.Size.Height); - - Debug.Print("Display {0} bounds: {1}", i, newRect); - - DisplayDevice opentk_dev = - new DisplayDevice(opentk_dev_current_res, primary, opentk_dev_available_res, newRect); - + + HIRect bounds = CG.DisplayBounds(currentDisplay); + Rectangle newRect = new Rectangle((int)bounds.Origin.X, (int)bounds.Origin.Y, (int)bounds.Size.Width, (int)bounds.Size.Height); + + Debug.Print("Display {0} bounds: {1}", i, newRect); + + DisplayDevice opentk_dev = new DisplayDevice(opentk_dev_current_res, primary, opentk_dev_available_res, newRect); + displayMap.Add(opentk_dev, currentDisplay); } - + Debug.Unindent(); } } - internal static IntPtr HandleTo(DisplayDevice displayDevice) - { - if (displayMap.ContainsKey(displayDevice)) - return displayMap[displayDevice]; - else - return IntPtr.Zero; - } + static internal IntPtr HandleTo(DisplayDevice displayDevice) + { + if (displayMap.ContainsKey(displayDevice)) + return displayMap[displayDevice]; + else + return IntPtr.Zero; + } #region IDisplayDeviceDriver Members Dictionary storedModes = new Dictionary(); List displaysCaptured = new List(); - + public bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution) { IntPtr display = displayMap[device]; IntPtr currentModePtr = CG.DisplayCurrentMode(display); - + if (storedModes.ContainsKey(display) == false) { - storedModes.Add(display, currentModePtr); + storedModes.Add(display, currentModePtr); } - + IntPtr displayModesPtr = CG.DisplayAvailableModes(display); CFArray displayModes = new CFArray(displayModesPtr); - + for (int j = 0; j < displayModes.Count; j++) { CFDictionary dict = new CFDictionary(displayModes[j]); - + int width = (int)dict.GetNumberValue("Width"); int height = (int)dict.GetNumberValue("Height"); int bpp = (int)dict.GetNumberValue("BitsPerPixel"); double freq = dict.GetNumberValue("RefreshRate"); - - if (width == resolution.Width && - height == resolution.Height && - bpp == resolution.BitsPerPixel && - System.Math.Abs(freq - resolution.RefreshRate) < 1e-6) + + if (width == resolution.Width && height == resolution.Height && bpp == resolution.BitsPerPixel && System.Math.Abs(freq - resolution.RefreshRate) < 1e-6) { if (displaysCaptured.Contains(display) == false) { CG.DisplayCapture(display); } - + Debug.Print("Changing resolution to {0}x{1}x{2}@{3}.", width, height, bpp, freq); - + CG.DisplaySwitchToMode(display, displayModes[j]); - + return true; } - + } return false; } @@ -166,22 +163,22 @@ namespace OpenTK.Platform.MacOS public bool TryRestoreResolution(DisplayDevice device) { IntPtr display = displayMap[device]; - + if (storedModes.ContainsKey(display)) { Debug.Print("Restoring resolution."); - + CG.DisplaySwitchToMode(display, storedModes[display]); CG.DisplayRelease(display); displaysCaptured.Remove(display); - + return true; } - + return false; } - + #endregion - - } + + } } From 574909c426b1be64f83dadaac12bbbd8694ebc24 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 4 Nov 2010 17:57:09 +0000 Subject: [PATCH 071/130] * X11KeyMap.cs: Added AltGr keycode. * X11Mouse.cs: Use XQueryPointer instead of trying to hook events. * X11Keyboard.cs: Improved handling of key modifiers. * X11Factory.cs: Use new X11Mouse API. * Functions.cs: Added XButtonGrab/XButtonUngrab. * API.cs: Added missing XF86 keysyms. --- Source/OpenTK/Platform/X11/API.cs | 75 +++++++++++++ Source/OpenTK/Platform/X11/Functions.cs | 14 ++- Source/OpenTK/Platform/X11/X11Factory.cs | 2 +- Source/OpenTK/Platform/X11/X11KeyMap.cs | 1 + Source/OpenTK/Platform/X11/X11Keyboard.cs | 46 ++++++-- Source/OpenTK/Platform/X11/X11Mouse.cs | 128 +++++----------------- 6 files changed, 154 insertions(+), 112 deletions(-) diff --git a/Source/OpenTK/Platform/X11/API.cs b/Source/OpenTK/Platform/X11/API.cs index 1f970123..43581b2b 100644 --- a/Source/OpenTK/Platform/X11/API.cs +++ b/Source/OpenTK/Platform/X11/API.cs @@ -1142,6 +1142,8 @@ XF86VidModeGetGammaRampSize( Hyper_L = 0xffed, /* Left hyper */ Hyper_R = 0xffee, /* Right hyper */ + ISO_Level3_Shift = 0xfe03, + /* * Latin 1 * (ISO/IEC 8859-1 = Unicode U+0020..U+00FF) @@ -1245,6 +1247,79 @@ XF86VidModeGetGammaRampSize( bar = 0x007c, /* U+007C VERTICAL LINE */ braceright = 0x007d, /* U+007D RIGHT CURLY BRACKET */ asciitilde = 0x007e, /* U+007E TILDE */ + + // Extra keys + + XF86AudioMute = 0x1008ff12, + XF86AudioLowerVolume = 0x1008ff11, + XF86AudioRaiseVolume = 0x1008ff13, + XF86PowerOff = 0x1008ff2a, + XF86Suspend = 0x1008ffa7, + XF86Copy = 0x1008ff57, + XF86Paste = 0x1008ff6d, + XF86Cut = 0x1008ff58, + XF86MenuKB = 0x1008ff65, + XF86Calculator = 0x1008ff1d, + XF86Sleep = 0x1008ff2f, + XF86WakeUp = 0x1008ff2b , + XF86Explorer = 0x1008ff5d, + XF86Send = 0x1008ff7b, + XF86Xfer = 0x1008ff8a, + XF86Launch1 = 0x1008ff41, + XF86Launch2 = 0x1008ff42, + XF86Launch3 = 0x1008ff43, + XF86Launch4 = 0x1008ff44, + XF86Launch5 = 0x1008ff45, + XF86LaunchA = 0x1008ff4a, + XF86LaunchB = 0x1008ff4b, + XF86WWW = 0x1008ff2e, + XF86DOS = 0x1008ff5a, + XF86ScreenSaver = 0x1008ff2d, + XF86RotateWindows = 0x1008ff74, + XF86Mail = 0x1008ff19, + XF86Favorites = 0x1008ff30, + XF86MyComputer = 0x1008ff33, + XF86Back = 0x1008ff26, + XF86Forward = 0x1008ff27 , + XF86Eject = 0x1008ff2c, + XF86AudioPlay = 0x1008ff14, + XF86AudioStop = 0x1008ff15, + XF86AudioPrev = 0x1008ff16, + XF86AudioNext = 0x1008ff17, + XF86AudioRecord = 0x1008ff1c, + XF86AudioPause =0x1008ff31, + XF86AudioRewind = 0x1008ff3e, + XF86AudioForward = 0x1008ff97, + XF86Phone = 0x1008ff6e, + XF86Tools = 0x1008ff81, + XF86HomePage = 0x1008ff18, + XF86Close = 0x1008ff56, + XF86Reload = 0x1008ff73, + XF86ScrollUp = 0x1008ff78, + XF86ScrollDown = 0x1008ff79, + XF86New = 0x1008ff68, + XF86TouchpadToggle = 0x1008ffa9, + XF86WebCam = 0x1008ff8f, + XF86Search = 0x1008ff1b, + XF86Finance = 0x1008ff3c, + XF86Shop = 0x1008ff36, + XF86MonBrightnessDown = 0x1008ff03, + XF86MonBrightnessUp = 0x1008ff02, + XF86AudioMedia = 0x1008ff32, + XF86Display = 0x1008ff59, + XF86KbdLightOnOff = 0x1008ff04, + XF86KbdBrightnessDown = 0x1008ff06, + XF86KbdBrightnessUp = 0x1008ff05, + XF86Reply = 0x1008ff72, + XF86MailForward = 0x1008ff90, + XF86Save = 0x1008ff77, + XF86Documents = 0x1008ff5b, + XF86Battery = 0x1008ff93, + XF86Bluetooth = 0x1008ff94, + XF86WLAN = 0x1008ff95, + + SunProps = 0x1005ff70, + SunOpen = 0x1005ff73, } #endregion diff --git a/Source/OpenTK/Platform/X11/Functions.cs b/Source/OpenTK/Platform/X11/Functions.cs index b2bf4947..69e1e362 100644 --- a/Source/OpenTK/Platform/X11/Functions.cs +++ b/Source/OpenTK/Platform/X11/Functions.cs @@ -108,8 +108,9 @@ namespace OpenTK.Platform.X11 public extern static int XConnectionNumber(IntPtr diplay); [DllImport("libX11")] public extern static int XPending(IntPtr diplay); + [DllImport("libX11", EntryPoint = "XSelectInput")] - public extern static IntPtr XSelectInput(IntPtr display, IntPtr window, IntPtr mask); + public extern static int XSelectInput(IntPtr display, IntPtr window, IntPtr mask); [DllImport("libX11", EntryPoint = "XDestroyWindow")] public extern static int XDestroyWindow(IntPtr display, IntPtr window); @@ -179,6 +180,17 @@ namespace OpenTK.Platform.X11 [DllImport("libX11", EntryPoint = "XUngrabPointer")] public extern static int XUngrabPointer(IntPtr display, IntPtr timestamp); + [DllImport("libX11", EntryPoint = "XGrabButton")] + public extern static int XGrabButton(IntPtr display, + int button, uint modifiers, Window grab_window, + Bool owner_events, EventMask event_mask, + GrabMode pointer_mode, GrabMode keyboard_mode, + Window confine_to, Cursor cursor); + + [DllImport("libX11", EntryPoint = "XUngrabButton")] + public extern static int XUngrabButton(IntPtr display, uint button, uint + modifiers, Window grab_window); + [DllImport("libX11", EntryPoint = "XQueryPointer")] public extern static bool XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons); diff --git a/Source/OpenTK/Platform/X11/X11Factory.cs b/Source/OpenTK/Platform/X11/X11Factory.cs index f2459183..c3292637 100644 --- a/Source/OpenTK/Platform/X11/X11Factory.cs +++ b/Source/OpenTK/Platform/X11/X11Factory.cs @@ -88,7 +88,7 @@ namespace OpenTK.Platform.X11 //if (XI2Mouse.IsSupported(IntPtr.Zero)) // return new XI2Mouse(null); // Requires xorg 1.7 or higher. //else - return new X11Mouse(null); // Always supported. + return new X11Mouse(); // Always supported. } #endregion diff --git a/Source/OpenTK/Platform/X11/X11KeyMap.cs b/Source/OpenTK/Platform/X11/X11KeyMap.cs index 9fba864c..0e2c7e80 100644 --- a/Source/OpenTK/Platform/X11/X11KeyMap.cs +++ b/Source/OpenTK/Platform/X11/X11KeyMap.cs @@ -36,6 +36,7 @@ namespace OpenTK.Platform.X11 this.Add(XKey.Super_R, Key.WinRight); this.Add(XKey.Meta_L, Key.WinLeft); this.Add(XKey.Meta_R, Key.WinRight); + this.Add(XKey.ISO_Level3_Shift, Key.AltRight); // Normally AltGr this.Add(XKey.Menu, Key.Menu); this.Add(XKey.Tab, Key.Tab); diff --git a/Source/OpenTK/Platform/X11/X11Keyboard.cs b/Source/OpenTK/Platform/X11/X11Keyboard.cs index 81534264..ef1f0a0b 100644 --- a/Source/OpenTK/Platform/X11/X11Keyboard.cs +++ b/Source/OpenTK/Platform/X11/X11Keyboard.cs @@ -38,12 +38,36 @@ namespace OpenTK.Platform.X11 { readonly static X11KeyMap keymap = new X11KeyMap(); readonly static string name = "Core X11 keyboard"; - KeyboardState state = new KeyboardState(); readonly byte[] keys = new byte[32]; + readonly int KeysymsPerKeycode; + KeyboardState state = new KeyboardState(); public X11Keyboard() { Debug.WriteLine("Using X11Keyboard."); + state.IsConnected = true; + + IntPtr display = API.DefaultDisplay; + using (new XLock(display)) + { + // Find the number of keysyms per keycode. + int first = 0, last = 0; + API.DisplayKeycodes(display, ref first, ref last); + IntPtr keysym_ptr = API.GetKeyboardMapping(display, (byte)first, last - first + 1, + ref KeysymsPerKeycode); + Functions.XFree(keysym_ptr); + + try + { + // Request that auto-repeat is only set on devices that support it physically. + // This typically means that it's turned off for keyboards what we want). + // We prefer this method over XAutoRepeatOff/On, because the latter needs to + // be reset before the program exits. + bool supported; + Functions.XkbSetDetectableAutoRepeat(display, true, out supported); + } + catch { } + } } public KeyboardState GetState() @@ -78,18 +102,20 @@ namespace OpenTK.Platform.X11 Functions.XQueryKeymap(display, keys); for (int keycode = 8; keycode < 256; keycode++) { - IntPtr keysym = Functions.XKeycodeToKeysym(display, (byte)keycode, 0); - IntPtr keysym2 = Functions.XKeycodeToKeysym(display, (byte)keycode, 1); bool pressed = (keys[keycode >> 3] >> (keycode & 0x07) & 0x01) != 0; - Key key; - if (keymap.TryGetValue((XKey)keysym, out key) || - keymap.TryGetValue((XKey)keysym2, out key)) + + for (int mod = 0; mod < KeysymsPerKeycode; mod++) { - if (pressed) - state.EnableBit((int)key); - else - state.DisableBit((int)key); + IntPtr keysym = Functions.XKeycodeToKeysym(display, (byte)keycode, mod); + if (keysym != IntPtr.Zero && keymap.TryGetValue((XKey)keysym, out key)) + { + if (pressed) + state.EnableBit((int)key); + else + state.DisableBit((int)key); + break; + } } } } diff --git a/Source/OpenTK/Platform/X11/X11Mouse.cs b/Source/OpenTK/Platform/X11/X11Mouse.cs index 881c488e..9dd523c6 100644 --- a/Source/OpenTK/Platform/X11/X11Mouse.cs +++ b/Source/OpenTK/Platform/X11/X11Mouse.cs @@ -34,41 +34,17 @@ namespace OpenTK.Platform.X11 { sealed class X11Mouse : IMouseDriver2 { + readonly IntPtr display; MouseState mouse = new MouseState(); - X11WindowInfo window; - // Can either attach itself to the specified window or can hook the root window. - public X11Mouse(X11WindowInfo win) + // Can either attach itself to the specified window or can hook the root window. + public X11Mouse() { - if (win != null) - { - window = win; - } - else - { - using (new XLock(API.DefaultDisplay)) - { - window = new X11WindowInfo(); - window.Display = API.DefaultDisplay; - window.Screen = Functions.XDefaultScreen(window.Display); - window.RootWindow = Functions.XRootWindow(window.Display, window.Screen); - window.WindowHandle = window.RootWindow; - window.EventMask = EventMask.ButtonMotionMask | - EventMask.ButtonPressMask | EventMask.ButtonReleaseMask; - - //Functions.XGrabPointer(window.Display, window.RootWindow, true, - // window.EventMask, GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, IntPtr.Zero, - // IntPtr.Zero, IntPtr.Zero); - //Functions.XSelectInput(window.Display, window.RootWindow, new IntPtr((int)window.EventMask)); - } - - Debug.WriteLine("Using X11Mouse."); - } + Debug.WriteLine("Using X11Mouse."); + mouse.IsConnected = true; + display = API.DefaultDisplay; } - // Todo: remove this - public IList Mouse { get { throw new NotSupportedException(); } } - public MouseState GetState() { ProcessEvents(); @@ -98,77 +74,29 @@ namespace OpenTK.Platform.X11 IntPtr root, child; int root_x, root_y, win_x, win_y; int buttons; - Functions.XQueryPointer(window.Display, window.WindowHandle, out root, out child, - out root_x, out root_y, out win_x, out win_y, out buttons); - mouse.X = root_x; - mouse.Y = root_y; - WriteBit(MouseButton.Left, buttons & (int)MouseMask.Button1Mask); - WriteBit(MouseButton.Middle, buttons & (int)MouseMask.Button2Mask); - WriteBit(MouseButton.Right, buttons & (int)MouseMask.Button3Mask); - if ((buttons & (int)MouseMask.Button4Mask) != 0) - mouse.WheelPrecise++; - if ((buttons & (int)MouseMask.Button5Mask) != 0) - mouse.WheelPrecise--; - WriteBit(MouseButton.Button1, buttons & (int)MouseMask.Button6Mask); - WriteBit(MouseButton.Button2, buttons & (int)MouseMask.Button7Mask); - WriteBit(MouseButton.Button3, buttons & (int)MouseMask.Button8Mask); -// XEvent e = new XEvent(); -// -// while (true) -// { -// using (new XLock(window.Display)) -// { -// if (!Functions.XCheckWindowEvent(window.Display, window.WindowHandle, window.EventMask, ref e)) -// break; -// -// switch (e.type) -// { -// case XEventName.ButtonPress: -// switch (e.ButtonEvent.button) -// { -// case 1: mouse.EnableBit((int)MouseButton.Left); break; -// case 2: mouse.EnableBit((int)MouseButton.Middle); break; -// case 3: mouse.EnableBit((int)MouseButton.Right); break; -// case 4: mouse.WheelPrecise++; break; -// case 5: mouse.WheelPrecise--; break; -// case 6: mouse.EnableBit((int)MouseButton.Button1); break; -// case 7: mouse.EnableBit((int)MouseButton.Button2); break; -// case 8: mouse.EnableBit((int)MouseButton.Button3); break; -// case 9: mouse.EnableBit((int)MouseButton.Button4); break; -// case 10: mouse.EnableBit((int)MouseButton.Button5); break; -// case 11: mouse.EnableBit((int)MouseButton.Button6); break; -// case 12: mouse.EnableBit((int)MouseButton.Button7); break; -// case 13: mouse.EnableBit((int)MouseButton.Button8); break; -// case 15: mouse.EnableBit((int)MouseButton.Button9); break; -// } -// break; -// -// case XEventName.ButtonRelease: -// switch (e.ButtonEvent.button) -// { -// case 1: mouse.DisableBit((int)MouseButton.Left); break; -// case 2: mouse.DisableBit((int)MouseButton.Middle); break; -// case 3: mouse.DisableBit((int)MouseButton.Right); break; -// case 6: mouse.DisableBit((int)MouseButton.Button1); break; -// case 7: mouse.DisableBit((int)MouseButton.Button2); break; -// case 8: mouse.DisableBit((int)MouseButton.Button3); break; -// case 9: mouse.DisableBit((int)MouseButton.Button4); break; -// case 10: mouse.DisableBit((int)MouseButton.Button5); break; -// case 11: mouse.DisableBit((int)MouseButton.Button6); break; -// case 12: mouse.DisableBit((int)MouseButton.Button7); break; -// case 13: mouse.DisableBit((int)MouseButton.Button8); break; -// case 15: mouse.DisableBit((int)MouseButton.Button9); break; -// } -// break; -// -// case XEventName.MotionNotify: -// mouse.X = e.MotionEvent.x; -// mouse.Y = e.MotionEvent.y; -// break; -// } -// } -// } + using (new XLock(display)) + { + IntPtr window = Functions.XRootWindow(display, Functions.XDefaultScreen(display)); + Functions.XQueryPointer(display, window, out root, out child, + out root_x, out root_y, out win_x, out win_y, out buttons); + + mouse.X = root_x; + mouse.Y = root_y; + WriteBit(MouseButton.Left, buttons & (int)MouseMask.Button1Mask); + WriteBit(MouseButton.Middle, buttons & (int)MouseMask.Button2Mask); + WriteBit(MouseButton.Right, buttons & (int)MouseMask.Button3Mask); + // Note: this will never work right. After spending a week on this, I simply don't care + // anymore. If someone can fix it, please do. + // Note 2: I have tried passively grabbing those buttons - no go (BadAccess). + if ((buttons & (int)MouseMask.Button4Mask) != 0) + mouse.WheelPrecise++; + if ((buttons & (int)MouseMask.Button5Mask) != 0) + mouse.WheelPrecise--; + WriteBit(MouseButton.Button1, buttons & (int)MouseMask.Button6Mask); + WriteBit(MouseButton.Button2, buttons & (int)MouseMask.Button7Mask); + WriteBit(MouseButton.Button3, buttons & (int)MouseMask.Button8Mask); + } } } } From 52d38059f4b98784f3ef7f4c517bba3be79ddabc Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 4 Nov 2010 18:01:07 +0000 Subject: [PATCH 072/130] * XI2Mouse.cs: * X11Factory.cs: Removed window hooking, as it complicates code unnecessarily. --- Source/OpenTK/Platform/X11/X11Factory.cs | 6 ++--- Source/OpenTK/Platform/X11/XI2Mouse.cs | 31 ++++++++---------------- 2 files changed, 13 insertions(+), 24 deletions(-) diff --git a/Source/OpenTK/Platform/X11/X11Factory.cs b/Source/OpenTK/Platform/X11/X11Factory.cs index c3292637..6fd9c5eb 100644 --- a/Source/OpenTK/Platform/X11/X11Factory.cs +++ b/Source/OpenTK/Platform/X11/X11Factory.cs @@ -85,9 +85,9 @@ namespace OpenTK.Platform.X11 public virtual OpenTK.Input.IMouseDriver2 CreateMouseDriver() { - //if (XI2Mouse.IsSupported(IntPtr.Zero)) - // return new XI2Mouse(null); // Requires xorg 1.7 or higher. - //else + if (XI2Mouse.IsSupported(IntPtr.Zero)) + return new XI2Mouse(); // Requires xorg 1.7 or higher. + else return new X11Mouse(); // Always supported. } diff --git a/Source/OpenTK/Platform/X11/XI2Mouse.cs b/Source/OpenTK/Platform/X11/XI2Mouse.cs index a8f31832..69825805 100644 --- a/Source/OpenTK/Platform/X11/XI2Mouse.cs +++ b/Source/OpenTK/Platform/X11/XI2Mouse.cs @@ -45,23 +45,17 @@ namespace OpenTK.Platform.X11 static readonly Functions.EventPredicate PredicateImpl = IsEventValid; readonly IntPtr Predicate = Marshal.GetFunctionPointerForDelegate(PredicateImpl); - // Can either attach itself to the specified window or can hook the root window. - public XI2Mouse(X11WindowInfo win) + public XI2Mouse() { - if (win != null) + Debug.WriteLine("Using XI2Mouse."); + + using (new XLock(API.DefaultDisplay)) { - window = win; - } - else - { - using (new XLock(API.DefaultDisplay)) - { - window = new X11WindowInfo(); - window.Display = API.DefaultDisplay; - window.Screen = Functions.XDefaultScreen(window.Display); - window.RootWindow = Functions.XRootWindow(window.Display, window.Screen); - window.WindowHandle = window.RootWindow; - } + window = new X11WindowInfo(); + window.Display = API.DefaultDisplay; + window.Screen = Functions.XDefaultScreen(window.Display); + window.RootWindow = Functions.XRootWindow(window.Display, window.Screen); + window.WindowHandle = window.RootWindow; } if (!IsSupported(window.Display)) @@ -72,8 +66,6 @@ namespace OpenTK.Platform.X11 { Functions.XISelectEvents(window.Display, window.WindowHandle, mask); } - - Debug.WriteLine("Using XI2Mouse."); } // Checks whether XInput2 is supported on the specified display. @@ -96,10 +88,7 @@ namespace OpenTK.Platform.X11 return true; } - #region IMouseDriver Members - - // Todo: remove this - public IList Mouse { get { throw new NotSupportedException(); } } + #region IMouseDriver2 Members public MouseState GetState() { From 16feb28ccaa79c45a21ab3d96992f0d1a82e25f9 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 08:59:32 +0000 Subject: [PATCH 073/130] Release both shift keys when one is released. Otherwise, we end up with stuck keys. --- Source/OpenTK/Platform/Windows/WinGLNative.cs | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 6d409f9b..51249726 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -361,11 +361,12 @@ namespace OpenTK.Platform.Windows // The behavior of this key is very strange. Unlike Control and Alt, there is no extended bit // to distinguish between left and right keys. Moreover, pressing both keys and releasing one // may result in both keys being held down (but not always). - // The only reliably way to solve this was reported by BlueMonkMN at the forums: we should + // The only reliable way to solve this was reported by BlueMonkMN at the forums: we should // check the scancodes. It looks like GLFW does the same thing, so it should be reliable. - // TODO: Not 100% reliable, when both keys are pressed at once. - if (ShiftRightScanCode != 0) + // Note: we release both keys when either shift is released. + // Otherwise, the state of one key might be stuck to pressed. + if (ShiftRightScanCode != 0 && pressed) { unchecked { @@ -377,8 +378,8 @@ namespace OpenTK.Platform.Windows } else { - // Should only fall here on Windows 9x and NT4.0- - keyboard[Input.Key.ShiftLeft] = pressed; + // Windows 9x and NT4.0 or key release event. + keyboard[Input.Key.ShiftLeft] = keyboard[Input.Key.ShiftRight] = pressed; } return IntPtr.Zero; From b8b32c4f9c614cbdaf09d52cfef622a1ecd7e742 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 15:58:42 +0000 Subject: [PATCH 074/130] Removed duplicate success message. --- Source/OpenTK/Platform/Windows/WinGLContext.cs | 2 -- 1 file changed, 2 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGLContext.cs b/Source/OpenTK/Platform/Windows/WinGLContext.cs index 74396a52..9ffc28c4 100644 --- a/Source/OpenTK/Platform/Windows/WinGLContext.cs +++ b/Source/OpenTK/Platform/Windows/WinGLContext.cs @@ -117,8 +117,6 @@ namespace OpenTK.Platform.Windows attributes.ToArray())); if (Handle == ContextHandle.Zero) Debug.Print("failed. (Error: {0})", Marshal.GetLastWin32Error()); - else - Debug.Print("success!"); } catch (EntryPointNotFoundException e) { Debug.Print(e.ToString()); } catch (NullReferenceException e) { Debug.Print(e.ToString()); } From 2aa1dcef1d81ef2b57044a77835f7e679ba85eb9 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 16:01:50 +0000 Subject: [PATCH 075/130] Avoid reference to System.Windows.Forms. Pass a concrete GraphicsMode to the context constructor in SelectPixelFormatARB to avoid NRE. --- .../Platform/Windows/WinGraphicsMode.cs | 40 +++++++++++-------- 1 file changed, 23 insertions(+), 17 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs b/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs index 5881b5a4..ec526fa1 100644 --- a/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs +++ b/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs @@ -45,6 +45,7 @@ namespace OpenTK.Platform.Windows // To avoid recursion when calling GraphicsMode.Default bool creating; + static readonly object SyncRoot = new object(); #endregion @@ -61,22 +62,26 @@ namespace OpenTK.Platform.Windows public GraphicsMode SelectGraphicsMode(ColorDepth color, int depth, int stencil, int samples, ColorDepth accum, int buffers, bool stereo) { - GraphicsMode mode = null; - if (!creating) + lock (SyncRoot) { - try + GraphicsMode mode = null; + if (!creating) { creating = true; - mode = SelectGraphicsModeARB(color, depth, stencil, samples, accum, buffers, stereo); - } - finally - { - creating = false; + try + { + mode = SelectGraphicsModeARB(color, depth, stencil, samples, accum, buffers, stereo); + } + finally + { + if (mode == null) + mode = SelectGraphicsModePFD(color, depth, stencil, samples, accum, buffers, stereo); + } } + + creating = false; + return mode; } - if (mode == null) - mode = SelectGraphicsModePFD(color, depth, stencil, samples, accum, buffers, stereo); - return mode; } #endregion @@ -88,13 +93,13 @@ namespace OpenTK.Platform.Windows GraphicsMode SelectGraphicsModePFD(ColorDepth color, int depth, int stencil, int samples, ColorDepth accum, int buffers, bool stereo) { - using (Control native_window = new Control()) - using (WinWindowInfo window = new WinWindowInfo(native_window.Handle, null)) + using (INativeWindow native_window = new NativeWindow()) { + WinWindowInfo window = native_window.WindowInfo as WinWindowInfo; IntPtr deviceContext = ((WinWindowInfo)window).DeviceContext; Debug.WriteLine(String.Format("Device context: {0}", deviceContext)); - Debug.Write("Selecting pixel format... "); + Debug.Write("Selecting pixel format (PFD)... "); PixelFormatDescriptor pixelFormat = new PixelFormatDescriptor(); pixelFormat.Size = API.PixelFormatDescriptorSize; pixelFormat.Version = API.PixelFormatDescriptorVersion; @@ -155,7 +160,9 @@ namespace OpenTK.Platform.Windows int buffers, bool stereo) { using (INativeWindow native_window = new NativeWindow()) - using (IGraphicsContext context = new GraphicsContext(new GraphicsMode(new ColorFormat(), 0, 0, 0, new ColorFormat(), 2, false), native_window.WindowInfo, 1, 0, GraphicsContextFlags.Default)) + using (IGraphicsContext context = new WinGLContext( + new GraphicsMode(new IntPtr(2), new ColorFormat(), 0, 0, 0, new ColorFormat(), 2, false), + (WinWindowInfo)native_window.WindowInfo, null, 1, 0, GraphicsContextFlags.Default)) { WinWindowInfo window = (WinWindowInfo)native_window.WindowInfo; @@ -249,7 +256,7 @@ namespace OpenTK.Platform.Windows Debug.WriteLine("failed (pixel format attributes could not be determined)."); return null; } - + GraphicsMode mode = new GraphicsMode(new IntPtr(pixel[0]), new ColorDepth(values[1], values[2], values[3], values[4]), values[6], @@ -269,4 +276,3 @@ namespace OpenTK.Platform.Windows #endregion } } - From cff4ab2d3c6c4a1de2a046835b53658cbacb9872 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 19:41:24 +0000 Subject: [PATCH 076/130] Retrieve all pixel formats at once and select the correct one through a custom selection predicate. Simplifies the code significantly and reduces the chance of race conditions. --- .../Platform/Windows/WinGraphicsMode.cs | 281 +++++++++--------- 1 file changed, 137 insertions(+), 144 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs b/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs index ec526fa1..05200297 100644 --- a/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs +++ b/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs @@ -2,7 +2,7 @@ // // The Open Toolkit Library License // -// Copyright (c) 2006 - 2009 the Open Toolkit library. +// Copyright (c) 2006 - 2010 the Open Toolkit library. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal @@ -28,23 +28,20 @@ using System; using System.Collections.Generic; using System.Text; -using System.Windows.Forms; using System.Diagnostics; using System.Runtime.InteropServices; using OpenTK.Graphics; -using ColorDepth = OpenTK.Graphics.ColorFormat; namespace OpenTK.Platform.Windows { internal class WinGraphicsMode : IGraphicsMode { - // Todo: Get rid of the System.Windows.Forms.Control dependency. - - #region --- Fields --- + #region Fields // To avoid recursion when calling GraphicsMode.Default bool creating; + readonly List modes = new List(); static readonly object SyncRoot = new object(); #endregion @@ -52,127 +49,135 @@ namespace OpenTK.Platform.Windows #region --- Constructors --- public WinGraphicsMode() - { - } - - #endregion - - #region --- IGraphicsMode Members --- - - public GraphicsMode SelectGraphicsMode(ColorDepth color, int depth, int stencil, int samples, ColorDepth accum, - int buffers, bool stereo) { lock (SyncRoot) { - GraphicsMode mode = null; - if (!creating) + using (INativeWindow native = new NativeWindow()) { - creating = true; - try - { - mode = SelectGraphicsModeARB(color, depth, stencil, samples, accum, buffers, stereo); - } - finally - { - if (mode == null) - mode = SelectGraphicsModePFD(color, depth, stencil, samples, accum, buffers, stereo); - } + modes.AddRange(GetModesARB(native)); + if (modes.Count == 0) + modes.AddRange(GetModesPFD(native)); } - - creating = false; - return mode; + modes.Sort(new GraphicsModeComparer()); } } #endregion - #region --- Private Methods --- + #region IGraphicsMode Members - #region SelectGraphicsModePFD - - GraphicsMode SelectGraphicsModePFD(ColorDepth color, int depth, int stencil, int samples, ColorDepth accum, - int buffers, bool stereo) + public GraphicsMode SelectGraphicsMode(ColorFormat color, int depth, int stencil, int samples, + ColorFormat accum, int buffers, bool stereo) { - using (INativeWindow native_window = new NativeWindow()) + GraphicsMode mode = null; + do { - WinWindowInfo window = native_window.WindowInfo as WinWindowInfo; - IntPtr deviceContext = ((WinWindowInfo)window).DeviceContext; - Debug.WriteLine(String.Format("Device context: {0}", deviceContext)); - - Debug.Write("Selecting pixel format (PFD)... "); - PixelFormatDescriptor pixelFormat = new PixelFormatDescriptor(); - pixelFormat.Size = API.PixelFormatDescriptorSize; - pixelFormat.Version = API.PixelFormatDescriptorVersion; - pixelFormat.Flags = - PixelFormatDescriptorFlags.SUPPORT_OPENGL | - PixelFormatDescriptorFlags.DRAW_TO_WINDOW; - pixelFormat.ColorBits = (byte)(color.Red + color.Green + color.Blue); - - pixelFormat.PixelType = color.IsIndexed ? PixelType.INDEXED : PixelType.RGBA; - pixelFormat.RedBits = (byte)color.Red; - pixelFormat.GreenBits = (byte)color.Green; - pixelFormat.BlueBits = (byte)color.Blue; - pixelFormat.AlphaBits = (byte)color.Alpha; - - if (accum.BitsPerPixel > 0) + mode = modes.Find(delegate(GraphicsMode current) { - pixelFormat.AccumBits = (byte)(accum.Red + accum.Green + accum.Blue); - pixelFormat.AccumRedBits = (byte)accum.Red; - pixelFormat.AccumGreenBits = (byte)accum.Green; - pixelFormat.AccumBlueBits = (byte)accum.Blue; - pixelFormat.AccumAlphaBits = (byte)accum.Alpha; + return ModeSelector(current, color, depth, stencil, samples, accum, buffers, stereo); + }); + } while (mode == null && RelaxParameters( + ref color, ref depth, ref stencil, ref samples, ref accum, ref buffers, ref stereo)); + + return mode; + } + + bool RelaxParameters(ref ColorFormat color, ref int depth, ref int stencil, ref int samples, + ref ColorFormat accum, ref int buffers, ref bool stereo) + { + if (stereo) { stereo = false; return true; } + if (buffers != 2) { buffers = 2; return true; } + if (accum != 0) { accum = 0; return true; } + if (samples != 0) { samples = 0; return true; } + if (color == 32 && depth == 24 && stencil != 8) { color = 32; depth = 24; stencil = 8; return true; } + if (color == 32 && depth == 24 && stencil == 8) { color = 32; depth = 24; stencil = 0; return true; } + if (color == 32 && depth != 16) { color = 32; depth = 16; stencil = 0; return true; } + if (color == 24 && depth == 24 && stencil != 8) { color = 24; depth = 24; stencil = 8; return true; } + if (color == 24 && depth == 24 && stencil == 8) { color = 24; depth = 24; stencil = 0; return true; } + if (color == 24 && depth != 16) { color = 24; depth = 16; stencil = 0; return true; } + if (color == 16 && depth == 24 && stencil != 8) { color = 16; depth = 24; stencil = 8; return true; } + if (color == 16 && depth == 24 && stencil == 8) { color = 16; depth = 24; stencil = 0; return true; } + if (color == 16 && depth != 16) { color = 16; depth = 16; stencil = 0; return true; } + if (color < 16) { color = 16; return true; } + return false; + } + + #endregion + + #region Private Methods + + #region DescribePixelFormat + + static int DescribePixelFormat(IntPtr hdc, int ipfd, int cjpfd, ref PixelFormatDescriptor pfd) + { + unsafe + { + fixed (PixelFormatDescriptor* ppfd = &pfd) + { + // Note: DescribePixelFormat found in gdi32 is extremely slow + // on nvidia, for some reason. + return Wgl.Imports.DescribePixelFormat(hdc, ipfd, (uint)cjpfd, ppfd); } + } + } - pixelFormat.DepthBits = (byte)depth; - pixelFormat.StencilBits = (byte)stencil; + #endregion - if (depth <= 0) pixelFormat.Flags |= PixelFormatDescriptorFlags.DEPTH_DONTCARE; - if (stereo) pixelFormat.Flags |= PixelFormatDescriptorFlags.STEREO; - if (buffers > 1) pixelFormat.Flags |= PixelFormatDescriptorFlags.DOUBLEBUFFER; + #region GetModesPFD - int pixel = Functions.ChoosePixelFormat(deviceContext, ref pixelFormat); - if (pixel == 0) - throw new GraphicsModeException("The requested GraphicsMode is not available."); + IEnumerable GetModesPFD(INativeWindow native) + { + WinWindowInfo window = native.WindowInfo as WinWindowInfo; + IntPtr deviceContext = ((WinWindowInfo)window).DeviceContext; + Debug.WriteLine(String.Format("Device context: {0}", deviceContext)); + + Debug.WriteLine("Retrieving PFD pixel formats... "); + PixelFormatDescriptor pfd = new PixelFormatDescriptor(); + pfd.Size = API.PixelFormatDescriptorSize; + pfd.Version = API.PixelFormatDescriptorVersion; + pfd.Flags = + PixelFormatDescriptorFlags.SUPPORT_OPENGL | + PixelFormatDescriptorFlags.DRAW_TO_WINDOW; + + int pixel = 0; + while (DescribePixelFormat(deviceContext, ++pixel, API.PixelFormatDescriptorSize, ref pfd) != 0) + { + // Ignore non-accelerated formats. + if ((pfd.Flags & PixelFormatDescriptorFlags.GENERIC_FORMAT) != 0) + continue; - // Find out what we really got as a format: - PixelFormatDescriptor pfd = new PixelFormatDescriptor(); - pixelFormat.Size = API.PixelFormatDescriptorSize; - pixelFormat.Version = API.PixelFormatDescriptorVersion; - Functions.DescribePixelFormat(deviceContext, pixel, API.PixelFormatDescriptorSize, ref pfd); GraphicsMode fmt = new GraphicsMode((IntPtr)pixel, - new ColorDepth(pfd.RedBits, pfd.GreenBits, pfd.BlueBits, pfd.AlphaBits), + new ColorFormat(pfd.RedBits, pfd.GreenBits, pfd.BlueBits, pfd.AlphaBits), pfd.DepthBits, pfd.StencilBits, 0, - new ColorDepth(pfd.AccumBits), + new ColorFormat(pfd.AccumBits), (pfd.Flags & PixelFormatDescriptorFlags.DOUBLEBUFFER) != 0 ? 2 : 1, (pfd.Flags & PixelFormatDescriptorFlags.STEREO) != 0); - return fmt; + yield return fmt; } } #endregion - #region SelectGraphicsModeARB + #region GetModesARB - GraphicsMode SelectGraphicsModeARB(ColorDepth color, int depth, int stencil, int samples, ColorDepth accum, - int buffers, bool stereo) + IEnumerable GetModesARB(INativeWindow native) { - using (INativeWindow native_window = new NativeWindow()) - using (IGraphicsContext context = new WinGLContext( + using (IGraphicsContext context = new GraphicsContext( new GraphicsMode(new IntPtr(2), new ColorFormat(), 0, 0, 0, new ColorFormat(), 2, false), - (WinWindowInfo)native_window.WindowInfo, null, 1, 0, GraphicsContextFlags.Default)) + (WinWindowInfo)native.WindowInfo, 1, 0, GraphicsContextFlags.Default)) { - WinWindowInfo window = (WinWindowInfo)native_window.WindowInfo; + WinWindowInfo window = (WinWindowInfo)native.WindowInfo; - // See http://www.opengl.org/registry/specs/ARB/wgl_pixel_format.txt + // See http://www.opengl.org/registry/specs/ARB/wgl_pixel_format.txt // for more details - Debug.Write("Selecting pixel format (ARB)... "); + Debug.Write("Retrieving ARB pixel formats.... "); if (Wgl.Delegates.wglChoosePixelFormatARB == null || Wgl.Delegates.wglGetPixelFormatAttribivARB == null) { - Debug.WriteLine("failed"); - return null; + Debug.WriteLine("failed."); + yield break; } int[] attribs = new int[] @@ -206,73 +211,61 @@ namespace OpenTK.Platform.Windows int[] attribs_values = new int[] { - (int)WGL_ARB_pixel_format.AccelerationArb, (int)WGL_ARB_pixel_format.FullAccelerationArb, - (int)WGL_ARB_pixel_format.DrawToWindowArb, 1, - - (int)WGL_ARB_pixel_format.RedBitsArb, color.Red, - (int)WGL_ARB_pixel_format.GreenBitsArb, color.Green, - (int)WGL_ARB_pixel_format.BlueBitsArb, color.Blue, - (int)WGL_ARB_pixel_format.AlphaBitsArb, color.Alpha, - (int)WGL_ARB_pixel_format.ColorBitsArb, color.BitsPerPixel - color.Alpha, // Should not contain alpha bpp (see spec) - - (int)WGL_ARB_pixel_format.DepthBitsArb, depth, - (int)WGL_ARB_pixel_format.StencilBitsArb, stencil, - - (int)WGL_ARB_multisample.SampleBuffersArb, samples > 0 ? 1 : 0, - (int)WGL_ARB_multisample.SamplesArb, samples, - - (int)WGL_ARB_pixel_format.AccumRedBitsArb, accum.Red, - (int)WGL_ARB_pixel_format.AccumGreenBitsArb, accum.Green, - (int)WGL_ARB_pixel_format.AccumBlueBitsArb, accum.Blue, - (int)WGL_ARB_pixel_format.AccumAlphaBitsArb, accum.Alpha, - (int)WGL_ARB_pixel_format.AccumBitsArb, accum.BitsPerPixel, // Spec doesn't mention wether alpha bpp should be included... - - (int)WGL_ARB_pixel_format.DoubleBufferArb, buffers > 1 ? 1 : 0, - (int)WGL_ARB_pixel_format.StereoArb, stereo ? 1 : 0, + (int)WGL_ARB_pixel_format.AccelerationArb, + (int)WGL_ARB_pixel_format.FullAccelerationArb, 0, 0 }; - int[] pixel = new int[1], num_formats = new int[1]; - bool success = Wgl.Arb.ChoosePixelFormat(window.DeviceContext, attribs_values, null, 1, pixel, num_formats); - if (!success || num_formats[0] == 0 || pixel[0] == 0) - { - // Try again without an accumulator. Many modern cards cannot accelerate multisampled formats with accumulator buffers. - int index_of_accum = Array.IndexOf(attribs_values, (int)WGL_ARB_pixel_format.AccumRedBitsArb); - attribs_values[index_of_accum + 1] = attribs_values[index_of_accum + 3] = - attribs_values[index_of_accum + 5] = attribs_values[index_of_accum + 7] = - attribs_values[index_of_accum + 9] = 0; - Wgl.Arb.ChoosePixelFormat(window.DeviceContext, attribs_values, null, 1, pixel, num_formats); - } - if (!success || num_formats[0] == 0 || pixel[0] == 0) - { - Debug.WriteLine("failed (no suitable pixel format)."); - return null; - } + int[] num_formats = new int[1]; + Wgl.Arb.ChoosePixelFormat(window.DeviceContext, attribs_values, null, 0, null, num_formats); + int[] pixel = new int[num_formats[0]]; - // Find out what we really got as a format: - success = Wgl.Arb.GetPixelFormatAttrib(window.DeviceContext, pixel[0], 0, attribs.Length - 1, attribs, values); - if (!success) + if (Wgl.Arb.ChoosePixelFormat(window.DeviceContext, attribs_values, null, pixel.Length, pixel, num_formats)) { - Debug.WriteLine("failed (pixel format attributes could not be determined)."); - return null; + foreach (int p in pixel) + { + // Find out what we really got as a format: + if (!Wgl.Arb.GetPixelFormatAttrib(window.DeviceContext, p, 0, attribs.Length - 1, attribs, values)) + { + Debug.Print("[Warning] Failed to detect attributes for PixelFormat:{0}.", p); + continue; + } + + GraphicsMode mode = new GraphicsMode(new IntPtr(p), + new ColorFormat(values[1], values[2], values[3], values[4]), + values[6], + values[7], + values[8] != 0 ? values[9] : 0, + new ColorFormat(values[10], values[11], values[12], values[13]), + values[15] == 1 ? 2 : 1, + values[16] == 1 ? true : false); + + yield return mode; + } } - - GraphicsMode mode = new GraphicsMode(new IntPtr(pixel[0]), - new ColorDepth(values[1], values[2], values[3], values[4]), - values[6], - values[7], - values[8] != 0 ? values[9] : 0, - new ColorDepth(values[10], values[11], values[12], values[13]), - values[15] == 1 ? 2 : 1, - values[16] == 1 ? true : false); - - Debug.WriteLine("success!"); - return mode; } } #endregion + #region ModeSelector + + bool ModeSelector(GraphicsMode current, ColorFormat color, int depth, int stencil, int samples, + ColorFormat accum, int buffers, bool stereo) + { + bool result = + (color != ColorFormat.Empty ? current.ColorFormat >= color : true) && + (depth != 0 ? current.Depth >= depth : true) && + (stencil != 0 ? current.Stencil >= stencil : true) && + (samples != 0 ? current.Samples >= samples : true) && + (accum != ColorFormat.Empty ? current.AccumulatorFormat >= accum : true) && + (buffers != 0 ? current.Buffers >= buffers : true) && + current.Stereo == stereo; + return result; + } + + #endregion + #endregion } } From 3e0f5e045ebbdaf4fa38587a2a09259c952cf7f4 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 19:42:53 +0000 Subject: [PATCH 077/130] Added >, >=, < and <= operators. --- Source/OpenTK/Graphics/ColorFormat.cs | 112 +++++++++++++++++++++++--- 1 file changed, 101 insertions(+), 11 deletions(-) diff --git a/Source/OpenTK/Graphics/ColorFormat.cs b/Source/OpenTK/Graphics/ColorFormat.cs index 583109e3..48516503 100644 --- a/Source/OpenTK/Graphics/ColorFormat.cs +++ b/Source/OpenTK/Graphics/ColorFormat.cs @@ -1,9 +1,28 @@ -#region --- License --- -/* Licensed under the MIT/X11 license. - * Copyright (c) 2006-2008 the OpenTK Team. - * This notice may not be removed from any source distribution. - * See license.txt for licensing detailed licensing details. - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion using System; @@ -17,13 +36,13 @@ namespace OpenTK.Graphics /// A ColorFormat contains Red, Green, Blue and Alpha components that descibe /// the allocated bits per pixel for the corresponding color. /// - public struct ColorFormat + public struct ColorFormat : IComparable { byte red, green, blue, alpha; bool isIndexed; int bitsPerPixel; - #region --- Constructors --- + #region Constructors /// /// Constructs a new ColorFormat with the specified aggregate bits per pixel. @@ -96,7 +115,7 @@ namespace OpenTK.Graphics #endregion - #region --- Public Methods --- + #region Public Members /// Gets the bits per pixel for the Red channel. public int Red { get { return red; } private set { red = (byte)value; } } @@ -111,9 +130,11 @@ namespace OpenTK.Graphics /// Gets the sum of Red, Green, Blue and Alpha bits per pixel. public int BitsPerPixel { get { return bitsPerPixel; } private set { bitsPerPixel = value; } } + public static readonly ColorFormat Empty = new ColorFormat(0); + #endregion - #region --- Operator Overloads --- + #region Operator Overloads /// /// Converts the specified bpp into a new ColorFormat. @@ -132,7 +153,32 @@ namespace OpenTK.Graphics #endregion - #region --- Overrides --- + #region IComparable Members + + /// + /// Compares two instances. + /// + /// The other instance. + /// + /// Zero if this instance is equal to other; + /// a positive value if this instance is greater than other; + /// a negative value otherwise. + /// + public int CompareTo(ColorFormat other) + { + int result = BitsPerPixel.CompareTo(other.BitsPerPixel); + if (result != 0) + return result; + result = IsIndexed.CompareTo(other.IsIndexed); + if (result != 0) + return result; + result = Alpha.CompareTo(other.Alpha); + return result; + } + + #endregion + + #region Overrides /// /// Indicates whether this instance and a specified object are equal. @@ -176,6 +222,50 @@ namespace OpenTK.Graphics return !(left == right); } + /// + /// Compares two instances for inequality. + /// + /// The left operand. + /// The right operand. + /// True if left is greater than right; false otherwise. + public static bool operator >(ColorFormat left, ColorFormat right) + { + return left.CompareTo(right) > 0; + } + + /// + /// Compares two instances for inequality. + /// + /// The left operand. + /// The right operand. + /// True if left is greater than or equal to right; false otherwise. + public static bool operator >=(ColorFormat left, ColorFormat right) + { + return left.CompareTo(right) >= 0; + } + + /// + /// Compares two instances for inequality. + /// + /// The left operand. + /// The right operand. + /// True if left is less than right; false otherwise. + public static bool operator <(ColorFormat left, ColorFormat right) + { + return left.CompareTo(right) < 0; + } + + /// + /// Compares two instances for inequality. + /// + /// The left operand. + /// The right operand. + /// True if left is less than or equal to right; false otherwise. + public static bool operator <=(ColorFormat left, ColorFormat right) + { + return left.CompareTo(right) <= 0; + } + /// /// Returns the hash code for this instance. /// From 3a967fcfb7d39d8e401a977101e72282a0181b42 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 19:45:58 +0000 Subject: [PATCH 078/130] Added GraphicsModeComparer for GraphicsMode comparisons. Added WinInputBase as a base abstraction for all win32 input class. --- .../OpenTK/Graphics/GraphicsModeComparer.cs | 63 ++++++ Source/OpenTK/OpenTK.csproj | 15 +- .../OpenTK/Platform/Windows/WinInputBase.cs | 204 ++++++++++++++++++ 3 files changed, 274 insertions(+), 8 deletions(-) create mode 100644 Source/OpenTK/Graphics/GraphicsModeComparer.cs create mode 100644 Source/OpenTK/Platform/Windows/WinInputBase.cs diff --git a/Source/OpenTK/Graphics/GraphicsModeComparer.cs b/Source/OpenTK/Graphics/GraphicsModeComparer.cs new file mode 100644 index 00000000..ca2e77ff --- /dev/null +++ b/Source/OpenTK/Graphics/GraphicsModeComparer.cs @@ -0,0 +1,63 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.Graphics +{ + sealed class GraphicsModeComparer : IComparer + { + #region IComparer Members + + public int Compare(GraphicsMode x, GraphicsMode y) + { + int result = x.ColorFormat.CompareTo(y.ColorFormat); + if (result != 0) + return result; + result = x.Depth.CompareTo(y.Depth); + if (result != 0) + return result; + result = x.Stencil.CompareTo(y.Stencil); + if (result != 0) + return result; + result = x.Samples.CompareTo(y.Samples); + if (result != 0) + return result; + result = x.Stereo.CompareTo(y.Stereo); + if (result != 0) + return result; + result = x.Buffers.CompareTo(y.Buffers); + if (result != 0) + return result; + return x.AccumulatorFormat.CompareTo(y.AccumulatorFormat); + } + + #endregion + } +} diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index b008f827..431e983d 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -1,4 +1,4 @@ - + Local @@ -116,10 +116,7 @@ System.Drawing False - - System.Windows.Forms - False - + System.Xml False @@ -132,10 +129,12 @@ Code + + Code @@ -758,13 +757,13 @@ OpenTK.snk - - Always - + + Always + diff --git a/Source/OpenTK/Platform/Windows/WinInputBase.cs b/Source/OpenTK/Platform/Windows/WinInputBase.cs new file mode 100644 index 00000000..91079757 --- /dev/null +++ b/Source/OpenTK/Platform/Windows/WinInputBase.cs @@ -0,0 +1,204 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +using System; +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Threading; +using OpenTK.Input; + +namespace OpenTK.Platform.Windows +{ + abstract class WinInputBase : IInputDriver2 + { + #region Fields + + readonly WindowProcedure WndProc; + readonly Thread InputThread; + readonly AutoResetEvent InputReady = new AutoResetEvent(false); + + IntPtr OldWndProc; + INativeWindow native; + + protected INativeWindow Native { get { return native; } private set { native = value; } } + protected WinWindowInfo Parent { get { return (WinWindowInfo)Native.WindowInfo; } } + + static readonly IntPtr Unhandled = new IntPtr(-1); + + #endregion + + #region Constructors + + public WinInputBase() + { + WndProc = WindowProcedure; + + InputThread = new Thread(ProcessEvents); + InputThread.IsBackground = true; + InputThread.Start(); + + InputReady.WaitOne(); + } + + #endregion + + #region Private Members + + #region ConstructMessageWindow + + INativeWindow ConstructMessageWindow() + { + Debug.WriteLine("Initializing input driver."); + Debug.Indent(); + + // Create a new message-only window to retrieve WM_INPUT messages. + INativeWindow native = new NativeWindow(); + native.ProcessEvents(); + WinWindowInfo parent = native.WindowInfo as WinWindowInfo; + Functions.SetParent(parent.WindowHandle, Constants.MESSAGE_ONLY); + native.ProcessEvents(); + + Debug.Unindent(); + return native; + } + + + #endregion + + #region ProcessEvents + + void ProcessEvents() + { + Native = ConstructMessageWindow(); + CreateDrivers(); + + // Subclass the window to retrieve the events we are interested in. + OldWndProc = Functions.SetWindowLong(Parent.WindowHandle, WndProc); + Debug.Print("Input window attached to {0}", Parent); + + InputReady.Set(); + + MSG msg = new MSG(); + while (Native.Exists) + { + Native.ProcessEvents(); + //int ret = Functions.GetMessage(ref msg, Parent.WindowHandle, 0, 0); + //if (ret == -1) + //{ + // throw new PlatformException(String.Format( + // "An error happened while processing the message queue. Windows error: {0}", + // Marshal.GetLastWin32Error())); + //} + + //Functions.TranslateMessage(ref msg); + //Functions.DispatchMessage(ref msg); + } + } + + #endregion + + #region WndProcHandler + + IntPtr WndProcHandler( + IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam) + { + IntPtr ret = WindowProcedure(handle, message, wParam, lParam); + if (ret == Unhandled) + return Functions.CallWindowProc(OldWndProc, handle, message, wParam, lParam); + else + return ret; + } + + #endregion + + #endregion + + #region Protected Members + + #region WindowProcedure + + protected virtual IntPtr WindowProcedure( + IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam) + { + return Unhandled; + } + + #endregion + + #region CreateDrivers + + // Note: this method is called through the input thread. + protected abstract void CreateDrivers(); + + #endregion + + #endregion + + #region IInputDriver2 Members + + public abstract IMouseDriver2 MouseDriver { get; } + public abstract IKeyboardDriver2 KeyboardDriver { get; } + public abstract IGamePadDriver GamePadDriver { get; } + + #endregion + + #region IDisposable Members + + protected bool Disposed; + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool manual) + { + if (!Disposed) + { + if (manual) + { + if (Native != null) + { + Native.Close(); + Native.Dispose(); + } + } + + Disposed = true; + } + } + + ~WinInputBase() + { + Debug.Print("[Warning] Resource leaked: {0}.", this); + Dispose(false); + } + + #endregion + } +} From 3a57aa777a4a22cb66a381837fb0468d00774f36 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 19:48:01 +0000 Subject: [PATCH 079/130] Removed WinForms dependency and performed general code cleanup. --- Source/OpenTK/Platform/Windows/WinKeyMap.cs | 195 ++++++++++---------- 1 file changed, 102 insertions(+), 93 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinKeyMap.cs b/Source/OpenTK/Platform/Windows/WinKeyMap.cs index 359a305a..93ab2bcf 100644 --- a/Source/OpenTK/Platform/Windows/WinKeyMap.cs +++ b/Source/OpenTK/Platform/Windows/WinKeyMap.cs @@ -1,113 +1,122 @@ -#region --- License --- -/* Copyright (c) 2007 Stefanos Apostolopoulos - * See license.txt for license information - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion using System; using System.Collections.Generic; -using System.Text; -using OpenTK.Platform.Windows; using OpenTK.Input; -using System.Diagnostics; namespace OpenTK.Platform.Windows { - internal class WinKeyMap : Dictionary + class WinKeyMap : Dictionary { /// /// Initializes the map between VirtualKeys and OpenTK.Key /// - internal WinKeyMap() + public WinKeyMap() { - try + this.Add(VirtualKeys.ESCAPE, Key.Escape); + + // Function keys + for (int i = 0; i < 24; i++) { - this.Add(VirtualKeys.ESCAPE, Key.Escape); - - // Function keys - for (int i = 0; i < 24; i++) - { - this.Add((VirtualKeys)((int)VirtualKeys.F1 + i), Key.F1 + i); - } - - // Number keys (0-9) - for (int i = 0; i <= 9; i++) - { - this.Add((VirtualKeys)(0x30 + i), Key.Number0 + i); - } - - // Letters (A-Z) - for (int i = 0; i < 26; i++) - { - this.Add((VirtualKeys)(0x41 + i), Key.A + i); - } - - this.Add(VirtualKeys.TAB, Key.Tab); - this.Add(VirtualKeys.CAPITAL, Key.CapsLock); - this.Add(VirtualKeys.LCONTROL, Key.ControlLeft); - this.Add(VirtualKeys.LSHIFT, Key.ShiftLeft); - this.Add(VirtualKeys.LWIN, Key.WinLeft); - this.Add(VirtualKeys.LMENU, Key.AltLeft); - this.Add(VirtualKeys.SPACE, Key.Space); - this.Add(VirtualKeys.RMENU, Key.AltRight); - this.Add(VirtualKeys.RWIN, Key.WinRight); - this.Add(VirtualKeys.APPS, Key.Menu); - this.Add(VirtualKeys.RCONTROL, Key.ControlRight); - this.Add(VirtualKeys.RSHIFT, Key.ShiftRight); - this.Add(VirtualKeys.RETURN, Key.Enter); - this.Add(VirtualKeys.BACK, Key.BackSpace); - - this.Add(VirtualKeys.OEM_1, Key.Semicolon); // Varies by keyboard, ;: on Win2K/US - this.Add(VirtualKeys.OEM_2, Key.Slash); // Varies by keyboard, /? on Win2K/US - this.Add(VirtualKeys.OEM_3, Key.Tilde); // Varies by keyboard, `~ on Win2K/US - this.Add(VirtualKeys.OEM_4, Key.BracketLeft); // Varies by keyboard, [{ on Win2K/US - this.Add(VirtualKeys.OEM_5, Key.BackSlash); // Varies by keyboard, \| on Win2K/US - this.Add(VirtualKeys.OEM_6, Key.BracketRight); // Varies by keyboard, ]} on Win2K/US - this.Add(VirtualKeys.OEM_7, Key.Quote); // Varies by keyboard, '" on Win2K/US - this.Add(VirtualKeys.OEM_PLUS, Key.Plus); // Invariant: + - this.Add(VirtualKeys.OEM_COMMA, Key.Comma); // Invariant: , - this.Add(VirtualKeys.OEM_MINUS, Key.Minus); // Invariant: - - this.Add(VirtualKeys.OEM_PERIOD, Key.Period); // Invariant: . - - this.Add(VirtualKeys.HOME, Key.Home); - this.Add(VirtualKeys.END, Key.End); - this.Add(VirtualKeys.DELETE, Key.Delete); - this.Add(VirtualKeys.PRIOR, Key.PageUp); - this.Add(VirtualKeys.NEXT, Key.PageDown); - this.Add(VirtualKeys.PRINT, Key.PrintScreen); - this.Add(VirtualKeys.PAUSE, Key.Pause); - this.Add(VirtualKeys.NUMLOCK, Key.NumLock); - - this.Add(VirtualKeys.SCROLL, Key.ScrollLock); - this.Add(VirtualKeys.SNAPSHOT, Key.PrintScreen); - this.Add(VirtualKeys.CLEAR, Key.Clear); - this.Add(VirtualKeys.INSERT, Key.Insert); - - this.Add(VirtualKeys.SLEEP, Key.Sleep); - - // Keypad - for (int i = 0; i <= 9; i++) - { - this.Add((VirtualKeys)((int)VirtualKeys.NUMPAD0 + i), Key.Keypad0 + i); - } - this.Add(VirtualKeys.DECIMAL, Key.KeypadDecimal); - this.Add(VirtualKeys.ADD, Key.KeypadAdd); - this.Add(VirtualKeys.SUBTRACT, Key.KeypadSubtract); - this.Add(VirtualKeys.DIVIDE, Key.KeypadDivide); - this.Add(VirtualKeys.MULTIPLY, Key.KeypadMultiply); - - // Navigation - this.Add(VirtualKeys.UP, Key.Up); - this.Add(VirtualKeys.DOWN, Key.Down); - this.Add(VirtualKeys.LEFT, Key.Left); - this.Add(VirtualKeys.RIGHT, Key.Right); + this.Add((VirtualKeys)((int)VirtualKeys.F1 + i), Key.F1 + i); } - catch (ArgumentException e) + + // Number keys (0-9) + for (int i = 0; i <= 9; i++) { - Debug.Print("Exception while creating keymap: '{0}'.", e.ToString()); - System.Windows.Forms.MessageBox.Show( - String.Format("Exception while creating keymap: '{0}'.", e.ToString())); + this.Add((VirtualKeys)(0x30 + i), Key.Number0 + i); } + + // Letters (A-Z) + for (int i = 0; i < 26; i++) + { + this.Add((VirtualKeys)(0x41 + i), Key.A + i); + } + + this.Add(VirtualKeys.TAB, Key.Tab); + this.Add(VirtualKeys.CAPITAL, Key.CapsLock); + this.Add(VirtualKeys.LCONTROL, Key.ControlLeft); + this.Add(VirtualKeys.LSHIFT, Key.ShiftLeft); + this.Add(VirtualKeys.LWIN, Key.WinLeft); + this.Add(VirtualKeys.LMENU, Key.AltLeft); + this.Add(VirtualKeys.SPACE, Key.Space); + this.Add(VirtualKeys.RMENU, Key.AltRight); + this.Add(VirtualKeys.RWIN, Key.WinRight); + this.Add(VirtualKeys.APPS, Key.Menu); + this.Add(VirtualKeys.RCONTROL, Key.ControlRight); + this.Add(VirtualKeys.RSHIFT, Key.ShiftRight); + this.Add(VirtualKeys.RETURN, Key.Enter); + this.Add(VirtualKeys.BACK, Key.BackSpace); + + this.Add(VirtualKeys.OEM_1, Key.Semicolon); // Varies by keyboard, ;: on Win2K/US + this.Add(VirtualKeys.OEM_2, Key.Slash); // Varies by keyboard, /? on Win2K/US + this.Add(VirtualKeys.OEM_3, Key.Tilde); // Varies by keyboard, `~ on Win2K/US + this.Add(VirtualKeys.OEM_4, Key.BracketLeft); // Varies by keyboard, [{ on Win2K/US + this.Add(VirtualKeys.OEM_5, Key.BackSlash); // Varies by keyboard, \| on Win2K/US + this.Add(VirtualKeys.OEM_6, Key.BracketRight); // Varies by keyboard, ]} on Win2K/US + this.Add(VirtualKeys.OEM_7, Key.Quote); // Varies by keyboard, '" on Win2K/US + this.Add(VirtualKeys.OEM_PLUS, Key.Plus); // Invariant: + + this.Add(VirtualKeys.OEM_COMMA, Key.Comma); // Invariant: , + this.Add(VirtualKeys.OEM_MINUS, Key.Minus); // Invariant: - + this.Add(VirtualKeys.OEM_PERIOD, Key.Period); // Invariant: . + + this.Add(VirtualKeys.HOME, Key.Home); + this.Add(VirtualKeys.END, Key.End); + this.Add(VirtualKeys.DELETE, Key.Delete); + this.Add(VirtualKeys.PRIOR, Key.PageUp); + this.Add(VirtualKeys.NEXT, Key.PageDown); + this.Add(VirtualKeys.PRINT, Key.PrintScreen); + this.Add(VirtualKeys.PAUSE, Key.Pause); + this.Add(VirtualKeys.NUMLOCK, Key.NumLock); + + this.Add(VirtualKeys.SCROLL, Key.ScrollLock); + this.Add(VirtualKeys.SNAPSHOT, Key.PrintScreen); + this.Add(VirtualKeys.CLEAR, Key.Clear); + this.Add(VirtualKeys.INSERT, Key.Insert); + + this.Add(VirtualKeys.SLEEP, Key.Sleep); + + // Keypad + for (int i = 0; i <= 9; i++) + { + this.Add((VirtualKeys)((int)VirtualKeys.NUMPAD0 + i), Key.Keypad0 + i); + } + this.Add(VirtualKeys.DECIMAL, Key.KeypadDecimal); + this.Add(VirtualKeys.ADD, Key.KeypadAdd); + this.Add(VirtualKeys.SUBTRACT, Key.KeypadSubtract); + this.Add(VirtualKeys.DIVIDE, Key.KeypadDivide); + this.Add(VirtualKeys.MULTIPLY, Key.KeypadMultiply); + + // Navigation + this.Add(VirtualKeys.UP, Key.Up); + this.Add(VirtualKeys.DOWN, Key.Down); + this.Add(VirtualKeys.LEFT, Key.Left); + this.Add(VirtualKeys.RIGHT, Key.Right); } } } From 9150a9925263c04e00e6a940ed3dac90941d39f9 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:36:10 +0000 Subject: [PATCH 080/130] Minor cosmetic fixes. Removed unused code. --- Source/OpenTK/Platform/Windows/WinGLNative.cs | 84 +++++++++---------- 1 file changed, 38 insertions(+), 46 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 51249726..5b90892f 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -49,9 +49,11 @@ namespace OpenTK.Platform.Windows const ExtendedWindowStyle ParentStyleEx = ExtendedWindowStyle.WindowEdge | ExtendedWindowStyle.ApplicationWindow; const ExtendedWindowStyle ChildStyleEx = 0; + static readonly WinKeyMap KeyMap = new WinKeyMap(); readonly IntPtr Instance = Marshal.GetHINSTANCE(typeof(WinGLNative).Module); readonly IntPtr ClassName = Marshal.StringToHGlobalAuto(Guid.NewGuid().ToString()); readonly WindowProcedure WindowProcedureDelegate; + readonly uint ModalLoopTimerPeriod = 1; UIntPtr timer_handle; readonly Functions.TimerProc ModalLoopCallback; @@ -78,16 +80,12 @@ namespace OpenTK.Platform.Windows const ClassStyle DefaultClassStyle = ClassStyle.OwnDC; - readonly IntPtr DefaultWindowProcedure = - Marshal.GetFunctionPointerForDelegate(new WindowProcedure(Functions.DefWindowProc)); - // Used for IInputDriver implementation WinMMJoystick joystick_driver = new WinMMJoystick(); KeyboardDevice keyboard = new KeyboardDevice(); MouseDevice mouse = new MouseDevice(); IList keyboards = new List(1); IList mice = new List(1); - internal static readonly WinKeyMap KeyMap = new WinKeyMap(); const long ExtendedBit = 1 << 24; // Used to distinguish left and right control, alt and enter keys. static readonly uint ShiftRightScanCode = Functions.MapVirtualKey(VirtualKeys.RSHIFT, 0); // Used to distinguish left and right shift keys. @@ -95,44 +93,49 @@ namespace OpenTK.Platform.Windows int cursor_visible_count = 0; + static readonly object SyncRoot = new object(); + #endregion #region Contructors public WinGLNative(int x, int y, int width, int height, string title, GameWindowFlags options, DisplayDevice device) { - // This is the main window procedure callback. We need the callback in order to create the window, so - // don't move it below the CreateWindow calls. - WindowProcedureDelegate = WindowProcedure; + lock (SyncRoot) + { + // This is the main window procedure callback. We need the callback in order to create the window, so + // don't move it below the CreateWindow calls. + WindowProcedureDelegate = WindowProcedure; - //// This timer callback is called periodically when the window enters a sizing / moving modal loop. - //ModalLoopCallback = delegate(IntPtr handle, WindowMessage msg, UIntPtr eventId, int time) - //{ - // // Todo: find a way to notify the frontend that it should process queued up UpdateFrame/RenderFrame events. - // if (Move != null) - // Move(this, EventArgs.Empty); - //}; + //// This timer callback is called periodically when the window enters a sizing / moving modal loop. + //ModalLoopCallback = delegate(IntPtr handle, WindowMessage msg, UIntPtr eventId, int time) + //{ + // // Todo: find a way to notify the frontend that it should process queued up UpdateFrame/RenderFrame events. + // if (Move != null) + // Move(this, EventArgs.Empty); + //}; - // To avoid issues with Ati drivers on Windows 6+ with compositing enabled, the context will not be - // bound to the top-level window, but rather to a child window docked in the parent. - window = new WinWindowInfo( - CreateWindow(x, y, width, height, title, options, device, IntPtr.Zero), null); - child_window = new WinWindowInfo( - CreateWindow(0, 0, ClientSize.Width, ClientSize.Height, title, options, device, window.WindowHandle), window); + // To avoid issues with Ati drivers on Windows 6+ with compositing enabled, the context will not be + // bound to the top-level window, but rather to a child window docked in the parent. + window = new WinWindowInfo( + CreateWindow(x, y, width, height, title, options, device, IntPtr.Zero), null); + child_window = new WinWindowInfo( + CreateWindow(0, 0, ClientSize.Width, ClientSize.Height, title, options, device, window.WindowHandle), window); - exists = true; + exists = true; - keyboard.Description = "Standard Windows keyboard"; - keyboard.NumberOfFunctionKeys = 12; - keyboard.NumberOfKeys = 101; - keyboard.NumberOfLeds = 3; + keyboard.Description = "Standard Windows keyboard"; + keyboard.NumberOfFunctionKeys = 12; + keyboard.NumberOfKeys = 101; + keyboard.NumberOfLeds = 3; - mouse.Description = "Standard Windows mouse"; - mouse.NumberOfButtons = 3; - mouse.NumberOfWheels = 1; + mouse.Description = "Standard Windows mouse"; + mouse.NumberOfButtons = 3; + mouse.NumberOfWheels = 1; - keyboards.Add(keyboard); - mice.Add(mouse); + keyboards.Add(keyboard); + mice.Add(mouse); + } } #endregion @@ -405,14 +408,14 @@ namespace OpenTK.Platform.Windows return IntPtr.Zero; default: - if (!WMInput.KeyMap.ContainsKey((VirtualKeys)wParam)) + if (!KeyMap.ContainsKey((VirtualKeys)wParam)) { Debug.Print("Virtual key {0} ({1}) not mapped.", (VirtualKeys)wParam, (long)lParam); break; } else { - keyboard[WMInput.KeyMap[(VirtualKeys)wParam]] = pressed; + keyboard[KeyMap[(VirtualKeys)wParam]] = pressed; } return IntPtr.Zero; } @@ -644,7 +647,7 @@ namespace OpenTK.Platform.Windows Marshal.GetLastWin32Error())); } - static void UngrabCursor() + void UngrabCursor() { if (!Functions.ClipCursor(IntPtr.Zero)) Debug.WriteLine(String.Format("Failed to ungrab cursor. Error: {0}", @@ -1117,31 +1120,20 @@ namespace OpenTK.Platform.Windows #region Events public event EventHandler Move = delegate { }; - public event EventHandler Resize = delegate { }; - public event EventHandler Closing = delegate { }; - public event EventHandler Closed = delegate { }; - public event EventHandler Disposed = delegate { }; - public event EventHandler IconChanged = delegate { }; - public event EventHandler TitleChanged = delegate { }; - public event EventHandler VisibleChanged = delegate { }; - public event EventHandler FocusedChanged = delegate { }; - public event EventHandler WindowBorderChanged = delegate { }; - public event EventHandler WindowStateChanged = delegate { }; - + public event EventHandler KeyDown = delegate { }; public event EventHandler KeyPress = delegate { }; - + public event EventHandler KeyUp = delegate { }; public event EventHandler MouseEnter = delegate { }; - public event EventHandler MouseLeave = delegate { }; #endregion From 045d3d73f67e715ec984847de2700e23b789ad96 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:38:32 +0000 Subject: [PATCH 081/130] Removed unimplement SetPixelFormatARB - no such function exists. Added aggressive locking during context creation and delegate loading in order to avoid potential race conditions. Now uses Wgl.Imports directly wherever possible in order to improve performance and avoid race conditions. Slightly improved debugging messages. --- .../OpenTK/Platform/Windows/WinGLContext.cs | 214 ++++++++++-------- 1 file changed, 116 insertions(+), 98 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGLContext.cs b/Source/OpenTK/Platform/Windows/WinGLContext.cs index 9ffc28c4..6dcf9d06 100644 --- a/Source/OpenTK/Platform/Windows/WinGLContext.cs +++ b/Source/OpenTK/Platform/Windows/WinGLContext.cs @@ -27,7 +27,8 @@ namespace OpenTK.Platform.Windows /// internal sealed class WinGLContext : DesktopGraphicsContext { - static object SyncRoot = new object(); + static readonly object LoadLock = new object(); + static readonly object SyncRoot = new object(); static IntPtr opengl32Handle; static bool wgl_loaded; @@ -39,18 +40,7 @@ namespace OpenTK.Platform.Windows static WinGLContext() { - lock (SyncRoot) - { - // Dynamically load the OpenGL32.dll in order to use the extension loading capabilities of Wgl. - if (opengl32Handle == IntPtr.Zero) - { - opengl32Handle = Functions.LoadLibrary(opengl32Name); - if (opengl32Handle == IntPtr.Zero) - throw new ApplicationException(String.Format("LoadLibrary(\"{0}\") call failed with code {1}", - opengl32Name, Marshal.GetLastWin32Error())); - Debug.WriteLine(String.Format("Loaded opengl32.dll: {0}", opengl32Handle)); - } - } + Init(); } public WinGLContext(GraphicsMode format, WinWindowInfo window, IGraphicsContext sharedContext, @@ -68,58 +58,60 @@ namespace OpenTK.Platform.Windows Mode = format; - Debug.Print("OpenGL will be bound to handle: {0}", window.WindowHandle); - Debug.Write("Setting pixel format... "); + Debug.Print("OpenGL will be bound to window:{0} on thread:{1}", window.WindowHandle, + System.Threading.Thread.CurrentThread.ManagedThreadId); this.SetGraphicsModePFD(format, (WinWindowInfo)window); - if (!wgl_loaded) + lock (LoadLock) { - // We need to create a temp context in order to load wgl extensions (e.g. for multisampling or GL3). - // We cannot rely on OpenTK.Platform.Wgl until we create the context and call Wgl.LoadAll(). - Debug.Print("Creating temporary context for wgl extensions."); - - ContextHandle temp_context = new ContextHandle(Wgl.Imports.CreateContext(window.DeviceContext)); - Wgl.Imports.MakeCurrent(window.DeviceContext, temp_context.Handle); - Wgl.LoadAll(); - Wgl.MakeCurrent(IntPtr.Zero, IntPtr.Zero); - Wgl.DeleteContext(temp_context.Handle); - wgl_loaded = true; - } - - if (Wgl.Delegates.wglCreateContextAttribsARB != null) - { - try + if (!wgl_loaded) { - Debug.Write("Using WGL_ARB_create_context... "); - - List attributes = new List(); - attributes.Add((int)ArbCreateContext.MajorVersion); - attributes.Add(major); - attributes.Add((int)ArbCreateContext.MinorVersion); - attributes.Add(minor); - if (flags != 0) - { - attributes.Add((int)ArbCreateContext.Flags); -#warning "This is not entirely correct: Embedded is not a valid flag! We need to add a GetARBContextFlags(GraphicsContextFlags) method." - attributes.Add((int)flags); - } - // According to the docs, " specifies a list of attributes for the context. - // The list consists of a sequence of pairs terminated by the - // value 0. [...]" - // Is this a single 0, or a <0, 0> pair? (Defensive coding: add two zeroes just in case). - attributes.Add(0); - attributes.Add(0); - - Handle = new ContextHandle( - Wgl.Arb.CreateContextAttribs( - window.DeviceContext, - sharedContext != null ? (sharedContext as IGraphicsContextInternal).Context.Handle : IntPtr.Zero, - attributes.ToArray())); - if (Handle == ContextHandle.Zero) - Debug.Print("failed. (Error: {0})", Marshal.GetLastWin32Error()); + // We need to create a temp context in order to load wgl extensions (e.g. for multisampling or GL3). + // We cannot rely on OpenTK.Platform.Wgl until we create the context and call Wgl.LoadAll(). + Debug.Print("Creating temporary context for wgl extensions."); + ContextHandle temp_context = new ContextHandle(Wgl.Imports.CreateContext(window.DeviceContext)); + Wgl.Imports.MakeCurrent(window.DeviceContext, temp_context.Handle); + Wgl.LoadAll(); + Wgl.Imports.MakeCurrent(IntPtr.Zero, IntPtr.Zero); + Wgl.Imports.DeleteContext(temp_context.Handle); + wgl_loaded = true; + } + + if (Wgl.Delegates.wglCreateContextAttribsARB != null) + { + try + { + Debug.Write("Using WGL_ARB_create_context... "); + + List attributes = new List(); + attributes.Add((int)ArbCreateContext.MajorVersion); + attributes.Add(major); + attributes.Add((int)ArbCreateContext.MinorVersion); + attributes.Add(minor); + if (flags != 0) + { + attributes.Add((int)ArbCreateContext.Flags); +#warning "This is not entirely correct: Embedded is not a valid flag! We need to add a GetARBContextFlags(GraphicsContextFlags) method." + attributes.Add((int)flags); + } + // According to the docs, " specifies a list of attributes for the context. + // The list consists of a sequence of pairs terminated by the + // value 0. [...]" + // Is this a single 0, or a <0, 0> pair? (Defensive coding: add two zeroes just in case). + attributes.Add(0); + attributes.Add(0); + + Handle = new ContextHandle( + Wgl.Arb.CreateContextAttribs( + window.DeviceContext, + sharedContext != null ? (sharedContext as IGraphicsContextInternal).Context.Handle : IntPtr.Zero, + attributes.ToArray())); + if (Handle == ContextHandle.Zero) + Debug.Print("failed. (Error: {0})", Marshal.GetLastWin32Error()); + } + catch (EntryPointNotFoundException e) { Debug.Print(e.ToString()); } + catch (NullReferenceException e) { Debug.Print(e.ToString()); } } - catch (EntryPointNotFoundException e) { Debug.Print(e.ToString()); } - catch (NullReferenceException e) { Debug.Print(e.ToString()); } } if (Handle == ContextHandle.Zero) @@ -140,7 +132,7 @@ namespace OpenTK.Platform.Windows if (sharedContext != null) { Marshal.GetLastWin32Error(); - Debug.Write("Sharing state with context {0}: ", sharedContext.ToString()); + Debug.Write(String.Format("Sharing state with context {0}: ", sharedContext)); bool result = Wgl.Imports.ShareLists((sharedContext as IGraphicsContextInternal).Context.Handle, Handle.Handle); Debug.WriteLine(result ? "success!" : "failed with win32 error " + Marshal.GetLastWin32Error()); } @@ -160,13 +152,13 @@ namespace OpenTK.Platform.Windows #endregion - #region --- IGraphicsContext Members --- + #region IGraphicsContext Members #region SwapBuffers public override void SwapBuffers() { - if (!Functions.SwapBuffers(Wgl.GetCurrentDC())) + if (!Functions.SwapBuffers(DeviceContext)) throw new GraphicsContextException(String.Format( "Failed to swap buffers for context {0} current. Error: {1}", this, Marshal.GetLastWin32Error())); } @@ -177,30 +169,36 @@ namespace OpenTK.Platform.Windows public override void MakeCurrent(IWindowInfo window) { - bool success; - - if (window != null) + lock (SyncRoot) + lock (LoadLock) { - if (((WinWindowInfo)window).WindowHandle == IntPtr.Zero) - throw new ArgumentException("window", "Must point to a valid window."); + bool success; - success = Wgl.Imports.MakeCurrent(((WinWindowInfo)window).DeviceContext, Handle.Handle); + if (window != null) + { + if (((WinWindowInfo)window).WindowHandle == IntPtr.Zero) + throw new ArgumentException("window", "Must point to a valid window."); + + success = Wgl.Imports.MakeCurrent(((WinWindowInfo)window).DeviceContext, Handle.Handle); + } + else + { + success = Wgl.Imports.MakeCurrent(IntPtr.Zero, IntPtr.Zero); + } + + if (!success) + throw new GraphicsContextException(String.Format( + "Failed to make context {0} current. Error: {1}", this, Marshal.GetLastWin32Error())); } - else - success = Wgl.Imports.MakeCurrent(IntPtr.Zero, IntPtr.Zero); - - if (!success) - throw new GraphicsContextException(String.Format( - "Failed to make context {0} current. Error: {1}", this, Marshal.GetLastWin32Error())); - } + #endregion #region IsCurrent public override bool IsCurrent { - get { return Wgl.GetCurrentContext() == Handle.Handle; } + get { return Wgl.Imports.GetCurrentContext() == Handle.Handle; } } #endregion @@ -214,12 +212,18 @@ namespace OpenTK.Platform.Windows { get { - return vsync_supported && Wgl.Ext.GetSwapInterval() != 0; + lock (LoadLock) + { + return vsync_supported && Wgl.Ext.GetSwapInterval() != 0; + } } set { - if (vsync_supported) - Wgl.Ext.SwapInterval(value ? 1 : 0); + lock (LoadLock) + { + if (vsync_supported) + Wgl.Ext.SwapInterval(value ? 1 : 0); + } } } @@ -229,9 +233,12 @@ namespace OpenTK.Platform.Windows public override void LoadAll() { - Wgl.LoadAll(); - vsync_supported = Wgl.Arb.SupportsExtension(this, "WGL_EXT_swap_control") && - Wgl.Load("wglGetSwapIntervalEXT") && Wgl.Load("wglSwapIntervalEXT"); + lock (LoadLock) + { + Wgl.LoadAll(); + vsync_supported = Wgl.Arb.SupportsExtension(this, "WGL_EXT_swap_control") && + Wgl.Load("wglGetSwapIntervalEXT") && Wgl.Load("wglSwapIntervalEXT"); + } base.LoadAll(); } @@ -240,7 +247,7 @@ namespace OpenTK.Platform.Windows #endregion - #region --- IGLContextInternal Members --- + #region IGLContextInternal Members #region IWindowInfo IGLContextInternal.Info /* @@ -262,12 +269,15 @@ namespace OpenTK.Platform.Windows #endregion - #region --- Private Methods --- + #region Private Methods - #region void SetGraphicsModePFD(GraphicsMode format, WinWindowInfo window) + #region SetGraphicsModePFD + // Note: there is no relevant ARB function. void SetGraphicsModePFD(GraphicsMode mode, WinWindowInfo window) { + Debug.Write("Setting pixel format... "); + if (!mode.Index.HasValue) throw new GraphicsModeException("Invalid or unsupported GraphicsMode."); @@ -281,20 +291,12 @@ namespace OpenTK.Platform.Windows throw new GraphicsContextException(String.Format( "Requested GraphicsMode not available. SetPixelFormat error: {0}", Marshal.GetLastWin32Error())); } - #endregion - - #region void SetGraphicsModeARB(GraphicsMode format, IWindowInfo window) - - void SetGraphicsModeARB(GraphicsMode format, IWindowInfo window) - { - throw new NotImplementedException(); - } #endregion #endregion - #region --- Internal Methods --- + #region Internal Methods #region internal IntPtr DeviceContext @@ -302,16 +304,32 @@ namespace OpenTK.Platform.Windows { get { - return Wgl.GetCurrentDC(); + return Wgl.Imports.GetCurrentDC(); } } #endregion + static internal void Init() + { + lock (SyncRoot) + { + // Dynamically load the OpenGL32.dll in order to use the extension loading capabilities of Wgl. + if (opengl32Handle == IntPtr.Zero) + { + opengl32Handle = Functions.LoadLibrary(opengl32Name); + if (opengl32Handle == IntPtr.Zero) + throw new ApplicationException(String.Format("LoadLibrary(\"{0}\") call failed with code {1}", + opengl32Name, Marshal.GetLastWin32Error())); + Debug.WriteLine(String.Format("Loaded opengl32.dll: {0}", opengl32Handle)); + } + } + } + #endregion - #region --- Overrides --- + #region Overrides /// Returns a System.String describing this OpenGL context. /// A System.String describing this OpenGL context. @@ -322,7 +340,7 @@ namespace OpenTK.Platform.Windows #endregion - #region --- IDisposable Members --- + #region IDisposable Members public override void Dispose() { From 1bacea077903e459fa9b0212d2fc76d1383f33d4 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:40:43 +0000 Subject: [PATCH 082/130] WinRawInput requires Windows 5.1 (XP) or higher. --- Source/OpenTK/Platform/Windows/WinFactory.cs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinFactory.cs b/Source/OpenTK/Platform/Windows/WinFactory.cs index 796eb7ad..aa802fdf 100644 --- a/Source/OpenTK/Platform/Windows/WinFactory.cs +++ b/Source/OpenTK/Platform/Windows/WinFactory.cs @@ -95,10 +95,12 @@ namespace OpenTK.Platform.Windows if (inputDriver == null) { // If Windows version is NT5 or higher, we are able to use raw input. - if (System.Environment.OSVersion.Version.Major >= 5) + if (System.Environment.OSVersion.Version.Major > 5 || + (System.Environment.OSVersion.Version.Major == 5 && + System.Environment.OSVersion.Version.Minor > 0)) inputDriver = new WinRawInput(); else - inputDriver = new WMInput(null); + inputDriver = new WMInput(); } return inputDriver; } From 6e00ecefa1c94eaa47ba0b6e6b69476d7bebaf61 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:41:44 +0000 Subject: [PATCH 083/130] Minor spelling fix. Use POINT structure instead of System.Drawing.Point. --- Source/OpenTK/Platform/Windows/API.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/API.cs b/Source/OpenTK/Platform/Windows/API.cs index 99dc7dac..96c3de9f 100644 --- a/Source/OpenTK/Platform/Windows/API.cs +++ b/Source/OpenTK/Platform/Windows/API.cs @@ -350,7 +350,7 @@ namespace OpenTK.Platform.Windows #region GetMessage /// - /// Low-level WINAPI function that retriives the next message in the queue. + /// Low-level WINAPI function that retrieves the next message in the queue. /// /// The pending message (if any) is stored here. /// Not used @@ -986,7 +986,7 @@ namespace OpenTK.Platform.Windows /// The input desktop must be the current desktop when you call GetCursorPos. Call OpenInputDesktop to determine whether the current desktop is the input desktop. If it is not, call SetThreadDesktop with the HDESK returned by OpenInputDesktop to switch to that desktop. /// [DllImport("user32.dll", SetLastError = true), SuppressUnmanagedCodeSecurity] - internal static extern BOOL GetCursorPos(ref Point point); + internal static extern BOOL GetCursorPos(ref POINT point); #endregion From 9eeac5d40bc1509999de5ac16ce5e4e43af68b73 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:43:29 +0000 Subject: [PATCH 084/130] Refactored input drivers in terms of WinInputBase to reduce code duplication. --- Source/OpenTK/Platform/Windows/WMInput.cs | 349 ++++++------------ Source/OpenTK/Platform/Windows/WinRawInput.cs | 289 ++++++--------- .../OpenTK/Platform/Windows/WinRawKeyboard.cs | 7 +- Source/OpenTK/Platform/Windows/WinRawMouse.cs | 2 +- 4 files changed, 238 insertions(+), 409 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WMInput.cs b/Source/OpenTK/Platform/Windows/WMInput.cs index 1dd3e2dd..5f14efa8 100644 --- a/Source/OpenTK/Platform/Windows/WMInput.cs +++ b/Source/OpenTK/Platform/Windows/WMInput.cs @@ -27,269 +27,160 @@ using System; using System.Collections.Generic; -using System.Text; -using System.Windows.Forms; - -using OpenTK.Input; using System.Diagnostics; using System.Drawing; +using System.Threading; +using System.Text; + +using OpenTK.Input; + namespace OpenTK.Platform.Windows { // Input driver for legacy (pre XP) Windows platforms. - sealed class WMInput : System.Windows.Forms.NativeWindow, IInputDriver2 + // Supports a single mouse and keyboard through WM_MOUSE* and WM_KEY* events. + // Supports multiple joysticks through WinMM. + sealed class WMInput : +#if !ASYNC_INPUT + WinInputBase, +#else + IInputDriver2, +#endif + IMouseDriver2, IKeyboardDriver2, IGamePadDriver { - #region --- Fields --- + #region Fields - WinMMJoystick gamepad_driver = new WinMMJoystick(); - // Driver supports only one keyboard and mouse; - KeyboardDevice keyboard = new KeyboardDevice(); - MouseDevice mouse = new MouseDevice(); - IList keyboards = new List(1); - IList mice = new List(1); - internal static readonly WinKeyMap KeyMap = new WinKeyMap(); - // Used to distinguish left and right control, alt and enter keys. - const long ExtendedBit = 1 << 24; - // Used to distinguish left and right shift keys. - static readonly uint ShiftRightScanCode = Functions.MapVirtualKey(VirtualKeys.RSHIFT, 0); + readonly WinMMJoystick gamepad_driver = new WinMMJoystick(); + KeyboardState keyboard = new KeyboardState(); + MouseState mouse = new MouseState(); + + readonly WinKeyMap KeyMap = new WinKeyMap(); #endregion - #region --- Constructor --- + #region Constructor - public WMInput(WinWindowInfo parent) + public WMInput() + : base() { - Debug.WriteLine("Initalizing WMInput driver."); - Debug.Indent(); - - AssignHandle(parent.WindowHandle); - Debug.Print("Input window attached to parent {0}", parent); - - Debug.Unindent(); - - keyboard.Description = "Standard Windows keyboard"; - keyboard.NumberOfFunctionKeys = 12; - keyboard.NumberOfKeys = 101; - keyboard.NumberOfLeds = 3; - - mouse.Description = "Standard Windows mouse"; - mouse.NumberOfButtons = 3; - mouse.NumberOfWheels = 1; - - keyboards.Add(keyboard); - mice.Add(mouse); + Debug.WriteLine("Using WMInput."); } #endregion - #region protected override void WndProc(ref Message msg) - - bool mouse_about_to_enter = false; - protected override void WndProc(ref Message msg) + #region Private Members +#if ASYNC_INPUT + void UpdateKeyboard() { - UIntPtr lparam, wparam; - unsafe + for (int i = 0; i < 256; i++) { - lparam = (UIntPtr)(void*)msg.LParam; - wparam = (UIntPtr)(void*)msg.WParam; - } - - switch ((WindowMessage)msg.Msg) - { - // Mouse events: - case WindowMessage.NCMOUSEMOVE: - mouse_about_to_enter = true; // Used to simulate a mouse enter event. - break; - - case WindowMessage.MOUSEMOVE: - mouse.Position = new Point( - (int)(lparam.ToUInt32() & 0x0000FFFF), - (int)(lparam.ToUInt32() & 0xFFFF0000) >> 16); - if (mouse_about_to_enter) - { - Cursor.Current = Cursors.Default; - mouse_about_to_enter = false; - } - return; - - case WindowMessage.MOUSEWHEEL: - // This is due to inconsistent behavior of the WParam value on 64bit arch, whese - // wparam = 0xffffffffff880000 or wparam = 0x00000000ff100000 - mouse.Wheel += (int)((long)msg.WParam << 32 >> 48) / 120; - return; - - case WindowMessage.LBUTTONDOWN: - mouse[MouseButton.Left] = true; - return; - - case WindowMessage.MBUTTONDOWN: - mouse[MouseButton.Middle] = true; - return; - - case WindowMessage.RBUTTONDOWN: - mouse[MouseButton.Right] = true; - return; - - case WindowMessage.XBUTTONDOWN: - mouse[((wparam.ToUInt32() & 0xFFFF0000) >> 16) != (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = true; - return; - - case WindowMessage.LBUTTONUP: - mouse[MouseButton.Left] = false; - return; - - case WindowMessage.MBUTTONUP: - mouse[MouseButton.Middle] = false; - return; - - case WindowMessage.RBUTTONUP: - mouse[MouseButton.Right] = false; - return; - - case WindowMessage.XBUTTONUP: - // TODO: Is this correct? - mouse[((wparam.ToUInt32() & 0xFFFF0000) >> 16) != (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = false; - return; - - // Keyboard events: - case WindowMessage.KEYDOWN: - case WindowMessage.KEYUP: - case WindowMessage.SYSKEYDOWN: - case WindowMessage.SYSKEYUP: - bool pressed = (WindowMessage)msg.Msg == WindowMessage.KEYDOWN || - (WindowMessage)msg.Msg == WindowMessage.SYSKEYDOWN; - - // Shift/Control/Alt behave strangely when e.g. ShiftRight is held down and ShiftLeft is pressed - // and released. It looks like neither key is released in this case, or that the wrong key is - // released in the case of Control and Alt. - // To combat this, we are going to release both keys when either is released. Hacky, but should work. - // Win95 does not distinguish left/right key constants (GetAsyncKeyState returns 0). - // In this case, both keys will be reported as pressed. - - bool extended = (msg.LParam.ToInt64() & ExtendedBit) != 0; - switch ((VirtualKeys)wparam) - { - case VirtualKeys.SHIFT: - // The behavior of this key is very strange. Unlike Control and Alt, there is no extended bit - // to distinguish between left and right keys. Moreover, pressing both keys and releasing one - // may result in both keys being held down (but not always). - // The only reliably way to solve this was reported by BlueMonkMN at the forums: we should - // check the scancodes. It looks like GLFW does the same thing, so it should be reliable. - - // TODO: Not 100% reliable, when both keys are pressed at once. - if (ShiftRightScanCode != 0) - { - unchecked - { - if (((lparam.ToUInt32() >> 16) & 0xFF) == ShiftRightScanCode) - keyboard[Input.Key.ShiftRight] = pressed; - else - keyboard[Input.Key.ShiftLeft] = pressed; - } - } - else - { - // Should only fall here on Windows 9x and NT4.0- - keyboard[Input.Key.ShiftLeft] = pressed; - } - return; - - case VirtualKeys.CONTROL: - if (extended) - keyboard[Input.Key.ControlRight] = pressed; - else - keyboard[Input.Key.ControlLeft] = pressed; - return; - - case VirtualKeys.MENU: - if (extended) - keyboard[Input.Key.AltRight] = pressed; - else - keyboard[Input.Key.AltLeft] = pressed; - return; - - case VirtualKeys.RETURN: - if (extended) - keyboard[Key.KeypadEnter] = pressed; - else - keyboard[Key.Enter] = pressed; - return; - - default: - if (!WMInput.KeyMap.ContainsKey((VirtualKeys)msg.WParam)) - { - Debug.Print("Virtual key {0} ({1}) not mapped.", (VirtualKeys)msg.WParam, (int)msg.WParam); - break; - } - else - { - keyboard[WMInput.KeyMap[(VirtualKeys)msg.WParam]] = pressed; - return; - } - } - break; - - case WindowMessage.KILLFOCUS: - keyboard.ClearKeys(); - break; - - case WindowMessage.DESTROY: - Debug.Print("Input window detached from parent {0}.", Handle); - ReleaseHandle(); - break; - - case WindowMessage.QUIT: - Debug.WriteLine("Input window quit."); - this.Dispose(); - break; - } - - base.WndProc(ref msg); - } - - #endregion - - #region --- IDisposable Members --- - - private bool disposed; - - public void Dispose() - { - Dispose(true); - GC.SuppressFinalize(this); - } - - private void Dispose(bool manual) - { - if (!disposed) - { - if (manual) - this.ReleaseHandle(); - - disposed = true; + VirtualKeys key = (VirtualKeys)i; + bool pressed = (Functions.GetAsyncKeyState(key) >> 8) != 0; + if (KeyMap.ContainsKey(key)) + { + keyboard[KeyMap[key]] = pressed; + } } } - ~WMInput() + void UpdateMouse() { - Dispose(false); + POINT p = new POINT(); + Functions.GetCursorPos(ref p); + // Note: we cannot poll the mouse wheel + mouse[MouseButton.Left] = (Functions.GetAsyncKeyState(VirtualKeys.LBUTTON) >> 8) != 0; + mouse[MouseButton.Middle] = (Functions.GetAsyncKeyState(VirtualKeys.RBUTTON) >> 8) != 0; + mouse[MouseButton.Right] = (Functions.GetAsyncKeyState(VirtualKeys.MBUTTON) >> 8) != 0; + mouse[MouseButton.Button1] = (Functions.GetAsyncKeyState(VirtualKeys.XBUTTON1) >> 8) != 0; + mouse[MouseButton.Button2] = (Functions.GetAsyncKeyState(VirtualKeys.XBUTTON2) >> 8) != 0; + } +#endif + #endregion + + #region Protected Members + + protected override IntPtr WindowProcedure(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam) + { + return base.WindowProcedure(handle, message, wParam, lParam); + } + + protected override void CreateDrivers() + { + //keyboard.IsConnected = true; + //Native.KeyDown += delegate(object sender, KeyboardKeyEventArgs e) + //{ + // keyboard.EnableBit((int)e.Key); + //}; + //Native.KeyUp += delegate(object sender, KeyboardKeyEventArgs e) + //{ + // keyboard.DisableBit((int)e.Key); + //}; + + //mouse.IsConnected = false; + // Todo: implement and hook INativeWindow.Mouse* events. + //Native.MouseMove += delegate(object sender, MouseMoveEventArgs e) + //{ + //}; } #endregion - public IMouseDriver2 MouseDriver + #region IInputDriver2 Members + + public override IKeyboardDriver2 KeyboardDriver { - get { throw new NotImplementedException(); } + get { return this; } } - public IKeyboardDriver2 KeyboardDriver + public override IMouseDriver2 MouseDriver { - get { throw new NotImplementedException(); } + get { return this; } } - public IGamePadDriver GamePadDriver + public override IGamePadDriver GamePadDriver { - get { throw new NotImplementedException(); } + get { return this; } } + + #endregion + + #region IMouseDriver2 Members + + public MouseState GetState() + { + return mouse; + } + + public MouseState GetState(int index) + { + if (index == 0) + return mouse; + else + return new MouseState(); + } + + #endregion + + #region IKeyboardDriver2 Members + + KeyboardState IKeyboardDriver2.GetState() + { + return keyboard; + } + + KeyboardState IKeyboardDriver2.GetState(int index) + { + if (index == 0) + return keyboard; + else + return new KeyboardState(); + } + + string IKeyboardDriver2.GetDeviceName(int index) + { + return "Default Windows Keyboard"; + } + + #endregion } } diff --git a/Source/OpenTK/Platform/Windows/WinRawInput.cs b/Source/OpenTK/Platform/Windows/WinRawInput.cs index 03e2f67b..54425ded 100644 --- a/Source/OpenTK/Platform/Windows/WinRawInput.cs +++ b/Source/OpenTK/Platform/Windows/WinRawInput.cs @@ -25,50 +25,132 @@ // #endregion -#region --- Using directives --- - using System; -using System.Collections.Generic; -using System.Text; -using System.Runtime.InteropServices; using System.Diagnostics; -using System.Windows.Forms; -using OpenTK.Input; +using System.Runtime.InteropServices; using System.Threading; - -#endregion +using OpenTK.Input; namespace OpenTK.Platform.Windows { - // Not complete. - sealed class WinRawInput : IInputDriver2 + sealed class WinRawInput : WinInputBase { + #region Fields + // Input event data. static RawInput data = new RawInput(); static readonly int rawInputStructSize = API.RawInputSize; - static readonly Thread InputThread = new Thread(ProcessEvents); - static WinRawKeyboard keyboardDriver; - static WinRawMouse mouseDriver; - static readonly WinMMJoystick joystickDriver = new WinMMJoystick(); + WinRawKeyboard keyboard_driver; + WinRawMouse mouse_driver; + WinMMJoystick joystick_driver; - static INativeWindow Native; - static WinWindowInfo Parent { get { return Native.WindowInfo as WinWindowInfo; } } - static readonly WindowProcedure WndProc = WindowProcedureImplementation; - static IntPtr OldWndProc; - - static IntPtr DevNotifyHandle; + IntPtr DevNotifyHandle; static readonly Guid DeviceInterfaceHid = new Guid("4D1E55B2-F16F-11CF-88CB-001111000030"); + #endregion + #region Constructors public WinRawInput() + : base() { - InputThread.IsBackground = true; - InputThread.Start(); + Debug.WriteLine("Using WinRawInput."); + } - while (mouseDriver == null || keyboardDriver == null) - Thread.Sleep(0); + #endregion + + #region Private Members + + static IntPtr RegisterForDeviceNotifications(WinWindowInfo parent) + { + IntPtr dev_notify_handle; + BroadcastDeviceInterface bdi = new BroadcastDeviceInterface(); + bdi.Size = BlittableValueType.StrideOf(bdi); + bdi.DeviceType = DeviceBroadcastType.INTERFACE; + bdi.ClassGuid = DeviceInterfaceHid; + unsafe + { + dev_notify_handle = Functions.RegisterDeviceNotification(parent.WindowHandle, + new IntPtr((void*)&bdi), DeviceNotification.WINDOW_HANDLE); + } + if (dev_notify_handle == IntPtr.Zero) + Debug.Print("[Warning] Failed to register for device notifications. Error: {0}", Marshal.GetLastWin32Error()); + + return dev_notify_handle; + } + + + #endregion + + #region Protected Members + + #region WindowProcedure + + // Processes the input Windows Message, routing the buffer to the correct Keyboard, Mouse or HID. + protected override IntPtr WindowProcedure( + IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam) + { + switch (message) + { + case WindowMessage.INPUT: + int size = 0; + // Get the size of the input buffer + Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, + IntPtr.Zero, ref size, API.RawInputHeaderSize); + + // Read the actual raw input structure + if (size == Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, + out data, ref size, API.RawInputHeaderSize)) + { + switch (data.Header.Type) + { + case RawInputDeviceType.KEYBOARD: + if (((WinRawKeyboard)KeyboardDriver).ProcessKeyboardEvent(data)) + return IntPtr.Zero; + break; + + case RawInputDeviceType.MOUSE: + if (((WinRawMouse)MouseDriver).ProcessMouseEvent(data)) + return IntPtr.Zero; + break; + + case RawInputDeviceType.HID: + break; + } + } + break; + + case WindowMessage.DEVICECHANGE: + ((WinRawKeyboard)KeyboardDriver).RefreshDevices(); + ((WinRawMouse)MouseDriver).RefreshDevices(); + break; + } + return base.WindowProcedure(handle, message, wParam, lParam); + } + + #endregion + + #region CreateDrivers + + protected override void CreateDrivers() + { + keyboard_driver = new WinRawKeyboard(Parent.WindowHandle); + mouse_driver = new WinRawMouse(Parent.WindowHandle); + joystick_driver = new WinMMJoystick(); + + DevNotifyHandle = RegisterForDeviceNotifications(Parent); + } + + #endregion + + protected override void Dispose(bool manual) + { + if (!Disposed) + { + Functions.UnregisterDeviceNotification(DevNotifyHandle); + base.Dispose(manual); + } } #endregion @@ -91,166 +173,21 @@ namespace OpenTK.Platform.Windows #endregion - #region Private Members - - #region ConstructMessageWindow - - static INativeWindow ConstructMessageWindow() - { - Debug.WriteLine("Initializing windows raw input driver."); - Debug.Indent(); - - // Create a new message-only window to retrieve WM_INPUT messages. - Native = new NativeWindow(); - Native.ProcessEvents(); - Functions.SetParent(Parent.WindowHandle, Constants.MESSAGE_ONLY); - Native.ProcessEvents(); - RegisterForDeviceNotifications(); - - // Subclass the window to retrieve the events we are interested in. - OldWndProc = Functions.SetWindowLong(Parent.WindowHandle, WndProc); - - Debug.Print("Input window attached to parent {0}", Parent); - keyboardDriver = new WinRawKeyboard(Parent.WindowHandle); - mouseDriver = new WinRawMouse(Parent.WindowHandle); - - Debug.Unindent(); - return Native; - } - - static void RegisterForDeviceNotifications() - { - BroadcastDeviceInterface bdi = new BroadcastDeviceInterface(); - bdi.Size = BlittableValueType.StrideOf(bdi); - bdi.DeviceType = DeviceBroadcastType.INTERFACE; - bdi.ClassGuid = DeviceInterfaceHid; - unsafe - { - DevNotifyHandle = Functions.RegisterDeviceNotification(Parent.WindowHandle, - new IntPtr((void*)&bdi), DeviceNotification.WINDOW_HANDLE); - } - if (DevNotifyHandle == IntPtr.Zero) - Debug.Print("[Warning] Failed to register for device notifications. Error: {0}", Marshal.GetLastWin32Error()); - } - - #endregion - - #region WindowProcedureImplementation - - // Processes the input Windows Message, routing the buffer to the correct Keyboard, Mouse or HID. - static IntPtr WindowProcedureImplementation(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam) - { - switch (message) - { - case WindowMessage.INPUT: - int size = 0; - // Get the size of the input buffer - Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, - IntPtr.Zero, ref size, API.RawInputHeaderSize); - - // Read the actual raw input structure - if (size == Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, - out data, ref size, API.RawInputHeaderSize)) - { - switch (data.Header.Type) - { - case RawInputDeviceType.KEYBOARD: - if (keyboardDriver.ProcessKeyboardEvent(data)) - return IntPtr.Zero; - break; - - case RawInputDeviceType.MOUSE: - if (mouseDriver.ProcessMouseEvent(data)) - return IntPtr.Zero; - break; - - case RawInputDeviceType.HID: - break; - } - } - break; - - case WindowMessage.DEVICECHANGE: - mouseDriver.RefreshDevices(); - break; - } - return Functions.CallWindowProc(OldWndProc, handle, message, wParam, lParam); - } - - #endregion - - #region ProcessEvents - - static void ProcessEvents() - { - INativeWindow native = ConstructMessageWindow(); - - MSG msg = new MSG(); - while (native.Exists) - { - int ret = Functions.GetMessage(ref msg, Parent.WindowHandle, 0, 0); - if (ret == -1) - { - throw new PlatformException(String.Format( - "An error happened while processing the message queue. Windows error: {0}", - Marshal.GetLastWin32Error())); - } - - Functions.TranslateMessage(ref msg); - Functions.DispatchMessage(ref msg); - } - } - - #endregion - - #endregion - #region IInputDriver2 Members - public IMouseDriver2 MouseDriver + public override IKeyboardDriver2 KeyboardDriver { - get { return mouseDriver; } + get { return keyboard_driver; } } - public IKeyboardDriver2 KeyboardDriver + public override IMouseDriver2 MouseDriver { - get { return keyboardDriver; } + get { return mouse_driver; } } - public IGamePadDriver GamePadDriver + public override IGamePadDriver GamePadDriver { - get { return joystickDriver; } - } - - #endregion - - #region IDisposable Members - - private bool disposed; - - public void Dispose() - { - Dispose(true); - GC.SuppressFinalize(this); - } - - private void Dispose(bool manual) - { - if (!disposed) - { - if (manual) - { - } - - Functions.UnregisterDeviceNotification(DevNotifyHandle); - disposed = true; - } - } - - ~WinRawInput() - { - Debug.Print("[Warning] Resource leaked: {0}.", this); - Dispose(false); + get { return joystick_driver; } } #endregion diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index e2d39286..a1388e11 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -36,6 +36,7 @@ namespace OpenTK.Platform.Windows { sealed class WinRawKeyboard : IKeyboardDriver2 { + static readonly WinKeyMap KeyMap = new WinKeyMap(); readonly List keyboards = new List(); readonly List names = new List(); readonly Dictionary rawids = new Dictionary(); @@ -46,7 +47,7 @@ namespace OpenTK.Platform.Windows public WinRawKeyboard(IntPtr windowHandle) { - Debug.WriteLine("Initializing keyboard driver (WinRawKeyboard)."); + Debug.WriteLine("Using WinRawKeyboard."); Debug.Indent(); this.window = windowHandle; @@ -157,14 +158,14 @@ namespace OpenTK.Platform.Windows break; default: - if (!WMInput.KeyMap.ContainsKey(rin.Data.Keyboard.VKey)) + if (!KeyMap.ContainsKey(rin.Data.Keyboard.VKey)) { Debug.Print("Virtual key {0} ({1}) not mapped.", rin.Data.Keyboard.VKey, (int)rin.Data.Keyboard.VKey); } else { - keyboard[WMInput.KeyMap[rin.Data.Keyboard.VKey]] = pressed; + keyboard[KeyMap[rin.Data.Keyboard.VKey]] = pressed; processed = true; } break; diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index ce3bc374..637b1cba 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -50,7 +50,7 @@ namespace OpenTK.Platform.Windows public WinRawMouse(IntPtr window) { - Debug.WriteLine("Initializing mouse driver (WinRawMouse)."); + Debug.WriteLine("Using WinRawMouse."); Debug.Indent(); if (window == IntPtr.Zero) From 0a9912469a32034744f38f526927c1820b4d1bc4 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:44:56 +0000 Subject: [PATCH 085/130] Removed dependency on System.Windows.Forms. --- Source/OpenTK/Platform/MacOS/AglContext.cs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/AglContext.cs b/Source/OpenTK/Platform/MacOS/AglContext.cs index 341d8fe9..4d52d337 100644 --- a/Source/OpenTK/Platform/MacOS/AglContext.cs +++ b/Source/OpenTK/Platform/MacOS/AglContext.cs @@ -11,7 +11,6 @@ using System; using System.Collections.Generic; using System.Diagnostics; using System.Runtime.InteropServices; -using Control = System.Windows.Forms.Control; namespace OpenTK.Platform.MacOS { @@ -215,7 +214,10 @@ namespace OpenTK.Platform.MacOS { if (carbonWindow.IsControl == false) return; - + + // Todo: See if there is a way around using WinForms. + throw new NotImplementedException(); +#if false System.Windows.Forms.Control ctrl = Control.FromHandle(carbonWindow.WindowRef); if (ctrl.TopLevelControl == null) @@ -247,7 +249,7 @@ namespace OpenTK.Platform.MacOS Agl.aglEnable(Handle.Handle, Agl.ParameterNames.AGL_BUFFER_RECT); MyAGLReportError("aglEnable"); - +#endif } void SetDrawable(CarbonWindowInfo carbonWindow) { From e601852547269ba91d588e6f8fc12b32d5ffadc1 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:45:15 +0000 Subject: [PATCH 086/130] Added new KeyDown and KeyUp events. --- Source/OpenTK/Platform/MacOS/CarbonGLNative.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index 57d7b13d..edf48c7e 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -1076,7 +1076,9 @@ namespace OpenTK.Platform.MacOS public event EventHandler FocusedChanged = delegate { }; public event EventHandler WindowBorderChanged = delegate { }; public event EventHandler WindowStateChanged = delegate { }; + public event EventHandler KeyDown = delegate { }; public event EventHandler KeyPress = delegate { }; + public event EventHandler KeyUp = delegate { }; public event EventHandler MouseEnter = delegate { }; public event EventHandler MouseLeave = delegate { }; From 896a2b0739a8db2de79bf3ea08e51784b2dea281 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:46:36 +0000 Subject: [PATCH 087/130] Print useful information in ToString() method. Updated license text. --- Source/OpenTK/Graphics/GraphicsContext.cs | 64 ++++++++++++++++++++--- 1 file changed, 58 insertions(+), 6 deletions(-) diff --git a/Source/OpenTK/Graphics/GraphicsContext.cs b/Source/OpenTK/Graphics/GraphicsContext.cs index 54b859d5..38817755 100644 --- a/Source/OpenTK/Graphics/GraphicsContext.cs +++ b/Source/OpenTK/Graphics/GraphicsContext.cs @@ -1,9 +1,28 @@ -#region --- License --- -/* Licensed under the MIT/X11 license. - * Copyright (c) 2006-2008 the OpenTK Team. - * This notice may not be removed from any source distribution. - * See license.txt for licensing detailed licensing details. - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion using System; @@ -190,6 +209,39 @@ namespace OpenTK.Graphics #endregion + #region Public Members + + /// + /// Returns a representing this instance. + /// + /// A that contains a string representation of this instance. + public override string ToString() + { + return (this as IGraphicsContextInternal).Context.ToString(); + } + + /// + /// Returns the hash code for this instance. + /// + /// A System.Int32 with the hash code of this instance. + public override int GetHashCode() + { + return (this as IGraphicsContextInternal).Context.GetHashCode(); + } + + /// + /// Compares two instances. + /// + /// The instance to compare to. + /// True, if obj is equal to this instance; false otherwise. + public override bool Equals(object obj) + { + return (obj is GraphicsContext) && + (this as IGraphicsContextInternal).Context == (obj as IGraphicsContextInternal).Context; + } + + #endregion + #region Private Members static IGraphicsContext FindSharedContext() From 6a35048a042ecd4331ef260696103de735179d10 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:46:55 +0000 Subject: [PATCH 088/130] Trivial cosmetic fix. --- Source/OpenTK/Input/Keyboard.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/OpenTK/Input/Keyboard.cs b/Source/OpenTK/Input/Keyboard.cs index ea35b050..d923f3be 100644 --- a/Source/OpenTK/Input/Keyboard.cs +++ b/Source/OpenTK/Input/Keyboard.cs @@ -74,8 +74,6 @@ namespace OpenTK.Input } } - #endregion - /// /// Retrieves the device name for the keyboard device. /// @@ -93,5 +91,7 @@ namespace OpenTK.Input return driver.GetDeviceName(index); } } + + #endregion } } From f99d6a2c1c0cf6042d02040a00dc080cf76d357d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:47:24 +0000 Subject: [PATCH 089/130] Removed obsolete System.Windows.Forms reference. --- Source/OpenTK/Platform/Utilities.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/Source/OpenTK/Platform/Utilities.cs b/Source/OpenTK/Platform/Utilities.cs index ae44a2f4..4dd5aeb7 100644 --- a/Source/OpenTK/Platform/Utilities.cs +++ b/Source/OpenTK/Platform/Utilities.cs @@ -9,7 +9,6 @@ using System; using System.Collections.Generic; using System.Text; -using System.Windows.Forms; using System.Runtime.InteropServices; using System.Reflection; using System.Diagnostics; From c96a632bab72d5c05fd9dc341180aba529ef0398 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:48:00 +0000 Subject: [PATCH 090/130] Added KeyDown and KeyUp events. --- Source/OpenTK/INativeWindow.cs | 13 +++++++-- Source/OpenTK/NativeWindow.cs | 50 ++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+), 3 deletions(-) diff --git a/Source/OpenTK/INativeWindow.cs b/Source/OpenTK/INativeWindow.cs index 106ae60c..137a4a8d 100644 --- a/Source/OpenTK/INativeWindow.cs +++ b/Source/OpenTK/INativeWindow.cs @@ -229,10 +229,20 @@ namespace OpenTK /// event EventHandler WindowStateChanged; + /// + /// Occurs whenever a keybord key is pressed. + /// + event EventHandler KeyDown; + /// /// Occurs whenever a character is typed. /// event EventHandler KeyPress; + + /// + /// Occurs whenever a keyboard key is released. + /// + event EventHandler KeyUp; /// /// Occurs whenever the mouse cursor leaves the window . @@ -251,9 +261,6 @@ namespace OpenTK //event EventHandler MouseClick; //event EventHandler MouseDoubleClick; - //event EventHandler KeyDown; - //event EventHandler KeyUp; - //event EventHandler DragDrop; //event EventHandler DragEnter; //event EventHandler DragOver; diff --git a/Source/OpenTK/NativeWindow.cs b/Source/OpenTK/NativeWindow.cs index dd7467f9..5fc2f418 100644 --- a/Source/OpenTK/NativeWindow.cs +++ b/Source/OpenTK/NativeWindow.cs @@ -50,6 +50,7 @@ namespace OpenTK private bool disposed, events; private bool cursor_visible = true; + private bool previous_cursor_visible = true; #endregion @@ -588,11 +589,21 @@ namespace OpenTK /// public event EventHandler IconChanged = delegate { }; + /// + /// Occurs whenever a keybord key is pressed. + /// + public event EventHandler KeyDown = delegate { }; + /// /// Occurs whenever a character is typed. /// public event EventHandler KeyPress = delegate { }; + /// + /// Occurs whenever a keyboard key is released. + /// + public event EventHandler KeyUp = delegate { }; + /// /// Occurs whenever the window is moved. /// @@ -746,6 +757,20 @@ namespace OpenTK /// Not used. protected virtual void OnFocusedChanged(EventArgs e) { + if (!Focused) + { + // Release cursor when losing focus, to ensure + // IDEs continue working as expected. + previous_cursor_visible = CursorVisible; + CursorVisible = true; + } + else if (!previous_cursor_visible) + { + // Make cursor invisible when focus is regained + // if cursor was invisible on previous focus loss. + previous_cursor_visible = true; + CursorVisible = false; + } FocusedChanged(this, e); } @@ -764,6 +789,18 @@ namespace OpenTK #endregion + #region OnKeyDown + + /// + /// Occurs whenever a keybord key is pressed. + /// + protected virtual void OnKeyDown(KeyboardKeyEventArgs e) + { + KeyDown(this, e); + } + + #endregion + #region OnKeyPress /// @@ -777,6 +814,19 @@ namespace OpenTK #endregion + #region OnKeyUp + + /// + /// Called when a keybord key is released. + /// + /// The for this event. + protected virtual void OnKeyUp(KeyboardKeyEventArgs e) + { + KeyUp(this, e); + } + + #endregion + #region OnMove /// From e695429db17c60ce9610d11a751bf2803489fef4 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 21:49:02 +0000 Subject: [PATCH 091/130] Removed obsolete System.Windows.Forms reference. --- Source/OpenTK/OpenTK.csproj | 1 - 1 file changed, 1 deletion(-) diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index 431e983d..803dd745 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -116,7 +116,6 @@ System.Drawing False - System.Xml False From 1f037d077c328cf2b7d4c3cbe80ac1037a02562e Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 22:19:19 +0000 Subject: [PATCH 092/130] Reverted to wait for messages. --- .../OpenTK/Platform/Windows/WinInputBase.cs | 209 +++++++++--------- 1 file changed, 104 insertions(+), 105 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinInputBase.cs b/Source/OpenTK/Platform/Windows/WinInputBase.cs index 91079757..408906b5 100644 --- a/Source/OpenTK/Platform/Windows/WinInputBase.cs +++ b/Source/OpenTK/Platform/Windows/WinInputBase.cs @@ -1,28 +1,28 @@ -#region License -// -// The Open Toolkit Library License -// -// Copyright (c) 2006 - 2010 the Open Toolkit library. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights to -// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -// the Software, and to permit persons to whom the Software is furnished to do -// so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES -// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT -// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR -// OTHER DEALINGS IN THE SOFTWARE. -// +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion using System; @@ -44,51 +44,51 @@ namespace OpenTK.Platform.Windows IntPtr OldWndProc; INativeWindow native; - protected INativeWindow Native { get { return native; } private set { native = value; } } - protected WinWindowInfo Parent { get { return (WinWindowInfo)Native.WindowInfo; } } - + protected INativeWindow Native { get { return native; } private set { native = value; } } + protected WinWindowInfo Parent { get { return (WinWindowInfo)Native.WindowInfo; } } + static readonly IntPtr Unhandled = new IntPtr(-1); #endregion #region Constructors - public WinInputBase() + public WinInputBase() { - WndProc = WindowProcedure; - - InputThread = new Thread(ProcessEvents); - InputThread.IsBackground = true; + WndProc = WindowProcedure; + + InputThread = new Thread(ProcessEvents); + InputThread.IsBackground = true; InputThread.Start(); InputReady.WaitOne(); - } - - #endregion - - #region Private Members - - #region ConstructMessageWindow - - INativeWindow ConstructMessageWindow() - { - Debug.WriteLine("Initializing input driver."); - Debug.Indent(); - - // Create a new message-only window to retrieve WM_INPUT messages. + } + + #endregion + + #region Private Members + + #region ConstructMessageWindow + + INativeWindow ConstructMessageWindow() + { + Debug.WriteLine("Initializing input driver."); + Debug.Indent(); + + // Create a new message-only window to retrieve WM_INPUT messages. INativeWindow native = new NativeWindow(); native.ProcessEvents(); WinWindowInfo parent = native.WindowInfo as WinWindowInfo; Functions.SetParent(parent.WindowHandle, Constants.MESSAGE_ONLY); - native.ProcessEvents(); - + native.ProcessEvents(); + Debug.Unindent(); - return native; - } - - - #endregion - + return native; + } + + + #endregion + #region ProcessEvents void ProcessEvents() @@ -105,20 +105,19 @@ namespace OpenTK.Platform.Windows MSG msg = new MSG(); while (Native.Exists) { - Native.ProcessEvents(); - //int ret = Functions.GetMessage(ref msg, Parent.WindowHandle, 0, 0); - //if (ret == -1) - //{ - // throw new PlatformException(String.Format( - // "An error happened while processing the message queue. Windows error: {0}", - // Marshal.GetLastWin32Error())); - //} + int ret = Functions.GetMessage(ref msg, Parent.WindowHandle, 0, 0); + if (ret == -1) + { + throw new PlatformException(String.Format( + "An error happened while processing the message queue. Windows error: {0}", + Marshal.GetLastWin32Error())); + } - //Functions.TranslateMessage(ref msg); - //Functions.DispatchMessage(ref msg); + Functions.TranslateMessage(ref msg); + Functions.DispatchMessage(ref msg); } - } - + } + #endregion #region WndProcHandler @@ -160,45 +159,45 @@ namespace OpenTK.Platform.Windows #region IInputDriver2 Members - public abstract IMouseDriver2 MouseDriver { get; } + public abstract IMouseDriver2 MouseDriver { get; } public abstract IKeyboardDriver2 KeyboardDriver { get; } - public abstract IGamePadDriver GamePadDriver { get; } - - #endregion - - #region IDisposable Members - - protected bool Disposed; - - public void Dispose() - { - Dispose(true); - GC.SuppressFinalize(this); - } - - protected virtual void Dispose(bool manual) - { - if (!Disposed) - { - if (manual) - { - if (Native != null) - { - Native.Close(); - Native.Dispose(); - } - } - - Disposed = true; - } - } - - ~WinInputBase() - { - Debug.Print("[Warning] Resource leaked: {0}.", this); - Dispose(false); - } - + public abstract IGamePadDriver GamePadDriver { get; } + + #endregion + + #region IDisposable Members + + protected bool Disposed; + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool manual) + { + if (!Disposed) + { + if (manual) + { + if (Native != null) + { + Native.Close(); + Native.Dispose(); + } + } + + Disposed = true; + } + } + + ~WinInputBase() + { + Debug.Print("[Warning] Resource leaked: {0}.", this); + Dispose(false); + } + #endregion } } From 0c45d7c169f0e27a23e1caaa191290e750a3f5b0 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 8 Nov 2010 22:19:44 +0000 Subject: [PATCH 093/130] Use async input to poll the keyboard/mouse. --- Source/OpenTK/Platform/Windows/WMInput.cs | 86 ++++++++++------------- 1 file changed, 36 insertions(+), 50 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WMInput.cs b/Source/OpenTK/Platform/Windows/WMInput.cs index 5f14efa8..8f42d3a7 100644 --- a/Source/OpenTK/Platform/Windows/WMInput.cs +++ b/Source/OpenTK/Platform/Windows/WMInput.cs @@ -38,18 +38,14 @@ using OpenTK.Input; namespace OpenTK.Platform.Windows { // Input driver for legacy (pre XP) Windows platforms. - // Supports a single mouse and keyboard through WM_MOUSE* and WM_KEY* events. + // Supports a single mouse and keyboard through async input. // Supports multiple joysticks through WinMM. - sealed class WMInput : -#if !ASYNC_INPUT - WinInputBase, -#else - IInputDriver2, -#endif - IMouseDriver2, IKeyboardDriver2, IGamePadDriver + sealed class WMInput : IInputDriver2, IMouseDriver2, IKeyboardDriver2, IGamePadDriver { #region Fields + readonly object MouseLock = new object(); + readonly object KeyboardLock = new object(); readonly WinMMJoystick gamepad_driver = new WinMMJoystick(); KeyboardState keyboard = new KeyboardState(); MouseState mouse = new MouseState(); @@ -69,7 +65,7 @@ namespace OpenTK.Platform.Windows #endregion #region Private Members -#if ASYNC_INPUT + void UpdateKeyboard() { for (int i = 0; i < 256; i++) @@ -87,6 +83,8 @@ namespace OpenTK.Platform.Windows { POINT p = new POINT(); Functions.GetCursorPos(ref p); + mouse.X = p.X; + mouse.Y = p.Y; // Note: we cannot poll the mouse wheel mouse[MouseButton.Left] = (Functions.GetAsyncKeyState(VirtualKeys.LBUTTON) >> 8) != 0; mouse[MouseButton.Middle] = (Functions.GetAsyncKeyState(VirtualKeys.RBUTTON) >> 8) != 0; @@ -94,50 +92,22 @@ namespace OpenTK.Platform.Windows mouse[MouseButton.Button1] = (Functions.GetAsyncKeyState(VirtualKeys.XBUTTON1) >> 8) != 0; mouse[MouseButton.Button2] = (Functions.GetAsyncKeyState(VirtualKeys.XBUTTON2) >> 8) != 0; } -#endif - #endregion - - #region Protected Members - - protected override IntPtr WindowProcedure(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam) - { - return base.WindowProcedure(handle, message, wParam, lParam); - } - - protected override void CreateDrivers() - { - //keyboard.IsConnected = true; - //Native.KeyDown += delegate(object sender, KeyboardKeyEventArgs e) - //{ - // keyboard.EnableBit((int)e.Key); - //}; - //Native.KeyUp += delegate(object sender, KeyboardKeyEventArgs e) - //{ - // keyboard.DisableBit((int)e.Key); - //}; - - //mouse.IsConnected = false; - // Todo: implement and hook INativeWindow.Mouse* events. - //Native.MouseMove += delegate(object sender, MouseMoveEventArgs e) - //{ - //}; - } #endregion #region IInputDriver2 Members - public override IKeyboardDriver2 KeyboardDriver + public IKeyboardDriver2 KeyboardDriver { get { return this; } } - public override IMouseDriver2 MouseDriver + public IMouseDriver2 MouseDriver { get { return this; } } - public override IGamePadDriver GamePadDriver + public IGamePadDriver GamePadDriver { get { return this; } } @@ -148,15 +118,23 @@ namespace OpenTK.Platform.Windows public MouseState GetState() { - return mouse; + lock (MouseLock) + { + UpdateMouse(); + return mouse; + } } public MouseState GetState(int index) { - if (index == 0) - return mouse; - else - return new MouseState(); + lock (MouseLock) + { + UpdateMouse(); + if (index == 0) + return mouse; + else + return new MouseState(); + } } #endregion @@ -165,15 +143,23 @@ namespace OpenTK.Platform.Windows KeyboardState IKeyboardDriver2.GetState() { - return keyboard; + lock (KeyboardLock) + { + UpdateKeyboard(); + return keyboard; + } } KeyboardState IKeyboardDriver2.GetState(int index) { - if (index == 0) - return keyboard; - else - return new KeyboardState(); + lock (KeyboardLock) + { + UpdateKeyboard(); + if (index == 0) + return keyboard; + else + return new KeyboardState(); + } } string IKeyboardDriver2.GetDeviceName(int index) From 3d40ef377bd319d58ba15ecb20a98b250fddcd14 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 9 Nov 2010 08:55:55 +0000 Subject: [PATCH 094/130] Capture ButtonUp events after ButtonDown even if the mouse leaves the window. --- Source/OpenTK/Platform/Windows/WinGLNative.cs | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 5b90892f..61814c14 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -309,36 +309,45 @@ namespace OpenTK.Platform.Windows break; case WindowMessage.LBUTTONDOWN: + Functions.SetCapture(window.WindowHandle); mouse[MouseButton.Left] = true; break; case WindowMessage.MBUTTONDOWN: + Functions.SetCapture(window.WindowHandle); mouse[MouseButton.Middle] = true; break; case WindowMessage.RBUTTONDOWN: + Functions.SetCapture(window.WindowHandle); mouse[MouseButton.Right] = true; break; case WindowMessage.XBUTTONDOWN: - mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) != (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = true; + Functions.SetCapture(window.WindowHandle); + mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) != + (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = true; break; case WindowMessage.LBUTTONUP: + Functions.ReleaseCapture(); mouse[MouseButton.Left] = false; break; case WindowMessage.MBUTTONUP: + Functions.ReleaseCapture(); mouse[MouseButton.Middle] = false; break; case WindowMessage.RBUTTONUP: + Functions.ReleaseCapture(); mouse[MouseButton.Right] = false; break; case WindowMessage.XBUTTONUP: - // TODO: Is this correct? - mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) != (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = false; + Functions.ReleaseCapture(); + mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) != + (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = false; break; // Keyboard events: From 68d35f7d69a2c126cf6ac07cf50d08bf70985de0 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 9 Nov 2010 11:52:14 +0000 Subject: [PATCH 095/130] * X11GLNative.cs: Added missing KeyDown/KeyUp events. --- Source/OpenTK/Platform/X11/X11GLNative.cs | 17 +++-------------- 1 file changed, 3 insertions(+), 14 deletions(-) diff --git a/Source/OpenTK/Platform/X11/X11GLNative.cs b/Source/OpenTK/Platform/X11/X11GLNative.cs index 4fc2a91b..4688ebd7 100644 --- a/Source/OpenTK/Platform/X11/X11GLNative.cs +++ b/Source/OpenTK/Platform/X11/X11GLNative.cs @@ -1271,31 +1271,20 @@ namespace OpenTK.Platform.X11 #region Events public event EventHandler Move = delegate { }; - public event EventHandler Resize = delegate { }; - public event EventHandler Closing = delegate { }; - public event EventHandler Closed = delegate { }; - public event EventHandler Disposed = delegate { }; - public event EventHandler IconChanged = delegate { }; - public event EventHandler TitleChanged = delegate { }; - public event EventHandler VisibleChanged = delegate { }; - public event EventHandler FocusedChanged = delegate { }; - public event EventHandler WindowBorderChanged = delegate { }; - public event EventHandler WindowStateChanged = delegate { }; - - public event EventHandler KeyPress = delegate { }; - + public event EventHandler KeyDown = delegate { }; + public event EventHandler KeyPress = delegate { }; + public event EventHandler KeyUp = delegate { }; public event EventHandler MouseEnter = delegate { }; - public event EventHandler MouseLeave = delegate { }; #endregion From 1f715a0c1aeb7b092ba2a7a6cd0d72687b3a29fb Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 9 Nov 2010 15:19:58 +0000 Subject: [PATCH 096/130] Added workaround for zoom-in/zoom-out keys on Microsoft Digital 3000 keyboard. These keys report 0 as a device id, but no such device exists. --- .../OpenTK/Platform/Windows/WinRawKeyboard.cs | 23 +++++++++++++++++-- Source/OpenTK/Platform/Windows/WinRawMouse.cs | 13 +++++++++-- 2 files changed, 32 insertions(+), 4 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index a1388e11..ecf3e0df 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -80,6 +80,16 @@ namespace OpenTK.Platform.Windows // Discover keyboard devices: foreach (RawInputDeviceList dev in ridl) { + ContextHandle id = new ContextHandle(dev.Device); + if (rawids.ContainsKey(id)) + { + // Device already registered, mark as connected + KeyboardState state = keyboards[rawids[id]]; + state.IsConnected = true; + keyboards[rawids[id]] = state; + continue; + } + string name = GetDeviceName(dev); if (name.ToLower().Contains("root")) { @@ -136,7 +146,16 @@ namespace OpenTK.Platform.Windows { RefreshDevices(); } - keyboard = keyboards[rawids[handle]]; + + if (keyboards.Count == 0) + return false; + + // Note:For some reason, my Microsoft Digital 3000 keyboard reports 0 + // as rin.Header.Device for the "zoom-in/zoom-out" buttons. + // That's problematic, because no device has a "0" id. + // As a workaround, we'll add those buttons to the first device (if any). + int keyboard_handle = rawids.ContainsKey(handle) ? rawids[handle] : 0; + keyboard = keyboards[keyboard_handle]; // Generic control, shift, alt keys may be sent instead of left/right. // It seems you have to explicitly register left/right events. @@ -173,7 +192,7 @@ namespace OpenTK.Platform.Windows lock (UpdateLock) { - keyboards[rawids[handle]] = keyboard; + keyboards[keyboard_handle] = keyboard; return processed; } } diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index 637b1cba..3f028bc6 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -147,7 +147,16 @@ namespace OpenTK.Platform.Windows { RefreshDevices(); } - mouse = mice[rawids[handle]]; + + if (mice.Count == 0) + return false; + + // Note:For some reason, my Microsoft Digital 3000 keyboard reports 0 + // as rin.Header.Device for the "zoom-in/zoom-out" buttons. + // That's problematic, because no device has a "0" id. + // As a workaround, we'll add those buttons to the first device (if any). + int mouse_handle = rawids.ContainsKey(handle) ? rawids[handle] : 0; + mouse = mice[mouse_handle]; if ((raw.ButtonFlags & RawInputMouseState.LEFT_BUTTON_DOWN) != 0) mouse.EnableBit((int)MouseButton.Left); if ((raw.ButtonFlags & RawInputMouseState.LEFT_BUTTON_UP) != 0) mouse.DisableBit((int)MouseButton.Left); @@ -176,7 +185,7 @@ namespace OpenTK.Platform.Windows lock (UpdateLock) { - mice[rawids[handle]] = mouse; + mice[mouse_handle] = mouse; return true; } } From 294f23f34a3cd30ea3efc9e1572b35382599a228 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 11 Nov 2010 19:32:22 +0000 Subject: [PATCH 097/130] Improved and simplified behavior of RelaxParameters. Removed unused code. --- .../Platform/Windows/WinGraphicsMode.cs | 28 ++++++++++--------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs b/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs index 05200297..c93ae4e1 100644 --- a/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs +++ b/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs @@ -35,12 +35,10 @@ using OpenTK.Graphics; namespace OpenTK.Platform.Windows { - internal class WinGraphicsMode : IGraphicsMode + class WinGraphicsMode : IGraphicsMode { #region Fields - // To avoid recursion when calling GraphicsMode.Default - bool creating; readonly List modes = new List(); static readonly object SyncRoot = new object(); @@ -57,6 +55,9 @@ namespace OpenTK.Platform.Windows modes.AddRange(GetModesARB(native)); if (modes.Count == 0) modes.AddRange(GetModesPFD(native)); + if (modes.Count == 0) + throw new GraphicsModeException( + "No GraphicsMode available. This should never happen, please report a bug at http://www.opentk.com"); } modes.Sort(new GraphicsModeComparer()); } @@ -79,6 +80,9 @@ namespace OpenTK.Platform.Windows } while (mode == null && RelaxParameters( ref color, ref depth, ref stencil, ref samples, ref accum, ref buffers, ref stereo)); + if (mode == null) + mode = modes[0]; + return mode; } @@ -89,17 +93,15 @@ namespace OpenTK.Platform.Windows if (buffers != 2) { buffers = 2; return true; } if (accum != 0) { accum = 0; return true; } if (samples != 0) { samples = 0; return true; } - if (color == 32 && depth == 24 && stencil != 8) { color = 32; depth = 24; stencil = 8; return true; } - if (color == 32 && depth == 24 && stencil == 8) { color = 32; depth = 24; stencil = 0; return true; } - if (color == 32 && depth != 16) { color = 32; depth = 16; stencil = 0; return true; } - if (color == 24 && depth == 24 && stencil != 8) { color = 24; depth = 24; stencil = 8; return true; } - if (color == 24 && depth == 24 && stencil == 8) { color = 24; depth = 24; stencil = 0; return true; } - if (color == 24 && depth != 16) { color = 24; depth = 16; stencil = 0; return true; } - if (color == 16 && depth == 24 && stencil != 8) { color = 16; depth = 24; stencil = 8; return true; } - if (color == 16 && depth == 24 && stencil == 8) { color = 16; depth = 24; stencil = 0; return true; } - if (color == 16 && depth != 16) { color = 16; depth = 16; stencil = 0; return true; } + if (depth < 16) { depth = 16; return true; } + if (depth != 24) { depth = 24; return true; } + if (stencil > 0 && stencil != 8) { stencil = 8; return true; } + if (stencil == 8) { stencil = 0; return true; } + if (color < 8) { color = 8; return true; } if (color < 16) { color = 16; return true; } - return false; + if (color < 24) { color = 24; return true; } + if (color < 32 || color > 32) { color = 32; return true; } + return false; // We tried everything we could, no match found. } #endregion From a49c995bdf2c146029fdcd07bfca8c830fa002d6 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 15 Nov 2010 21:10:36 +0000 Subject: [PATCH 098/130] Trim whitespace from revision number, which may cause build issues. --- Source/Build.UpdateVersion/Program.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/Build.UpdateVersion/Program.cs b/Source/Build.UpdateVersion/Program.cs index caaac6fa..71b59caf 100644 --- a/Source/Build.UpdateVersion/Program.cs +++ b/Source/Build.UpdateVersion/Program.cs @@ -89,7 +89,7 @@ namespace Build.UpdateVersion string build = ((int)timespan).ToString(); string revision = RetrieveSvnRevision() ?? RetrieveBzrRevision() ?? RetrieveSeconds(timespan); - //string revision = RetrieveSvnRevision() ?? RetrieveSeconds(timespan); + revision = revision.Trim(); File.WriteAllLines(file, new string[] { From c89f8e375eb9248df726e3d9638c4d2766ee5813 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 15 Nov 2010 22:34:52 +0000 Subject: [PATCH 099/130] Added 1-parameter constructors. --- Source/OpenTK/Math/Vector2.cs | 10 ++++++++++ Source/OpenTK/Math/Vector2d.cs | 10 ++++++++++ Source/OpenTK/Math/Vector2h.cs | 20 ++++++++++++++++++++ Source/OpenTK/Math/Vector3.cs | 11 +++++++++++ Source/OpenTK/Math/Vector3d.cs | 11 +++++++++++ Source/OpenTK/Math/Vector3h.cs | 22 ++++++++++++++++++++++ Source/OpenTK/Math/Vector4.cs | 12 ++++++++++++ Source/OpenTK/Math/Vector4d.cs | 12 ++++++++++++ Source/OpenTK/Math/Vector4h.cs | 24 ++++++++++++++++++++++++ 9 files changed, 132 insertions(+) diff --git a/Source/OpenTK/Math/Vector2.cs b/Source/OpenTK/Math/Vector2.cs index 5946fdd3..7c8dabf8 100644 --- a/Source/OpenTK/Math/Vector2.cs +++ b/Source/OpenTK/Math/Vector2.cs @@ -50,6 +50,16 @@ namespace OpenTK #region Constructors + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector2(float value) + { + X = value; + Y = value; + } + /// /// Constructs a new Vector2. /// diff --git a/Source/OpenTK/Math/Vector2d.cs b/Source/OpenTK/Math/Vector2d.cs index e0aae38e..5305a185 100644 --- a/Source/OpenTK/Math/Vector2d.cs +++ b/Source/OpenTK/Math/Vector2d.cs @@ -69,6 +69,16 @@ namespace OpenTK #region Constructors + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector2d(double value) + { + X = value; + Y = value; + } + /// Constructs left vector with the given coordinates. /// The X coordinate. /// The Y coordinate. diff --git a/Source/OpenTK/Math/Vector2h.cs b/Source/OpenTK/Math/Vector2h.cs index 28bc8e40..0ac6d509 100644 --- a/Source/OpenTK/Math/Vector2h.cs +++ b/Source/OpenTK/Math/Vector2h.cs @@ -46,6 +46,26 @@ namespace OpenTK #region Constructors + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector2h(Half value) + { + X = value; + Y = value; + } + + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector2h(Single value) + { + X = new Half(value); + Y = new Half(value); + } + /// /// The new Half2 instance will avoid conversion and copy directly from the Half parameters. /// diff --git a/Source/OpenTK/Math/Vector3.cs b/Source/OpenTK/Math/Vector3.cs index 9baa652e..f48d745b 100644 --- a/Source/OpenTK/Math/Vector3.cs +++ b/Source/OpenTK/Math/Vector3.cs @@ -58,6 +58,17 @@ namespace OpenTK #region Constructors + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector3(float value) + { + X = value; + Y = value; + Z = value; + } + /// /// Constructs a new Vector3. /// diff --git a/Source/OpenTK/Math/Vector3d.cs b/Source/OpenTK/Math/Vector3d.cs index bf2d60b9..cec1cbc8 100644 --- a/Source/OpenTK/Math/Vector3d.cs +++ b/Source/OpenTK/Math/Vector3d.cs @@ -56,6 +56,17 @@ namespace OpenTK #region Constructors + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector3d(double value) + { + X = value; + Y = value; + Z = value; + } + /// /// Constructs a new Vector3. /// diff --git a/Source/OpenTK/Math/Vector3h.cs b/Source/OpenTK/Math/Vector3h.cs index 973bbad8..7f417808 100644 --- a/Source/OpenTK/Math/Vector3h.cs +++ b/Source/OpenTK/Math/Vector3h.cs @@ -51,6 +51,28 @@ namespace OpenTK #region Constructors + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector3h(Half value) + { + X = value; + Y = value; + Z = value; + } + + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector3h(Single value) + { + X = new Half(value); + Y = new Half(value); + Z = new Half(value); + } + /// /// The new Half3 instance will avoid conversion and copy directly from the Half parameters. /// diff --git a/Source/OpenTK/Math/Vector4.cs b/Source/OpenTK/Math/Vector4.cs index f13a6fe0..29d771bd 100644 --- a/Source/OpenTK/Math/Vector4.cs +++ b/Source/OpenTK/Math/Vector4.cs @@ -96,6 +96,18 @@ namespace OpenTK #region Constructors + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector4(float value) + { + X = value; + Y = value; + Z = value; + W = value; + } + /// /// Constructs a new Vector4. /// diff --git a/Source/OpenTK/Math/Vector4d.cs b/Source/OpenTK/Math/Vector4d.cs index 246191d0..14bd402a 100644 --- a/Source/OpenTK/Math/Vector4d.cs +++ b/Source/OpenTK/Math/Vector4d.cs @@ -94,6 +94,18 @@ namespace OpenTK #region Constructors + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector4d(double value) + { + X = value; + Y = value; + Z = value; + W = value; + } + /// /// Constructs a new Vector4d. /// diff --git a/Source/OpenTK/Math/Vector4h.cs b/Source/OpenTK/Math/Vector4h.cs index 744c1436..4a7f83a6 100644 --- a/Source/OpenTK/Math/Vector4h.cs +++ b/Source/OpenTK/Math/Vector4h.cs @@ -54,6 +54,30 @@ namespace OpenTK #region Constructors + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector4h(Half value) + { + X = value; + Y = value; + Z = value; + W = value; + } + + /// + /// Constructs a new instance. + /// + /// The value that will initialize this instance. + public Vector4h(Single value) + { + X = new Half(value); + Y = new Half(value); + Z = new Half(value); + W = new Half(value); + } + /// /// The new Half4 instance will avoid conversion and copy directly from the Half parameters. /// From 4be74af5d43e5834e5036209eb43393585217e24 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Sun, 21 Nov 2010 00:09:50 +0000 Subject: [PATCH 100/130] Modified TransformPerspective to work correctly with orthographic projection matrices. Fixes issue [#1827]: "OpenTK.Vector3.TransformPerspective code is wrong". --- Source/OpenTK/Math/Vector3.cs | 2 +- Source/OpenTK/Math/Vector3d.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/OpenTK/Math/Vector3.cs b/Source/OpenTK/Math/Vector3.cs index f48d745b..5ce13d85 100644 --- a/Source/OpenTK/Math/Vector3.cs +++ b/Source/OpenTK/Math/Vector3.cs @@ -1154,7 +1154,7 @@ namespace OpenTK /// The transformed vector public static void TransformPerspective(ref Vector3 vec, ref Matrix4 mat, out Vector3 result) { - Vector4 v = new Vector4(vec); + Vector4 v = new Vector4(vec, 1); Vector4.Transform(ref v, ref mat, out v); result.X = v.X / v.W; result.Y = v.Y / v.W; diff --git a/Source/OpenTK/Math/Vector3d.cs b/Source/OpenTK/Math/Vector3d.cs index cec1cbc8..f61c3ec8 100644 --- a/Source/OpenTK/Math/Vector3d.cs +++ b/Source/OpenTK/Math/Vector3d.cs @@ -1152,7 +1152,7 @@ namespace OpenTK /// The transformed vector public static void TransformPerspective(ref Vector3d vec, ref Matrix4d mat, out Vector3d result) { - Vector4d v = new Vector4d(vec); + Vector4d v = new Vector4d(vec, 1); Vector4d.Transform(ref v, ref mat, out v); result.X = v.X / v.W; result.Y = v.Y / v.W; From d8612f4df64eea3f9ae952f6ed361c25ec16d383 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Sun, 21 Nov 2010 00:15:18 +0000 Subject: [PATCH 101/130] Relaxed parameter checks for CreatePerspectiveFieldOfView. Fixes issue [#1693]: "CreatePerspectiveFieldOfView throws in valid cases". --- Source/OpenTK/Math/Matrix4.cs | 2 -- Source/OpenTK/Math/Matrix4d.cs | 2 -- 2 files changed, 4 deletions(-) diff --git a/Source/OpenTK/Math/Matrix4.cs b/Source/OpenTK/Math/Matrix4.cs index 8eb5a484..009b658f 100644 --- a/Source/OpenTK/Math/Matrix4.cs +++ b/Source/OpenTK/Math/Matrix4.cs @@ -565,8 +565,6 @@ namespace OpenTK throw new ArgumentOutOfRangeException("zNear"); if (zFar <= 0) throw new ArgumentOutOfRangeException("zFar"); - if (zNear >= zFar) - throw new ArgumentOutOfRangeException("zNear"); float yMax = zNear * (float)System.Math.Tan(0.5f * fovy); float yMin = -yMax; diff --git a/Source/OpenTK/Math/Matrix4d.cs b/Source/OpenTK/Math/Matrix4d.cs index 95a7408f..1a1f810b 100644 --- a/Source/OpenTK/Math/Matrix4d.cs +++ b/Source/OpenTK/Math/Matrix4d.cs @@ -565,8 +565,6 @@ namespace OpenTK throw new ArgumentOutOfRangeException("zNear"); if (zFar <= 0) throw new ArgumentOutOfRangeException("zFar"); - if (zNear >= zFar) - throw new ArgumentOutOfRangeException("zNear"); double yMax = zNear * System.Math.Tan(0.5 * fovy); double yMin = -yMax; From e986af3b6eb10965b37198721793bcc897613704 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Sun, 21 Nov 2010 10:54:11 +0000 Subject: [PATCH 102/130] Fixed issue [#1895]: "Vector3d.Equals(object obj) defined in terms of Vector3, not Vector3d". --- Source/OpenTK/Math/Vector3d.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/OpenTK/Math/Vector3d.cs b/Source/OpenTK/Math/Vector3d.cs index f61c3ec8..5af1aeb5 100644 --- a/Source/OpenTK/Math/Vector3d.cs +++ b/Source/OpenTK/Math/Vector3d.cs @@ -1364,10 +1364,10 @@ namespace OpenTK /// True if the instances are equal; false otherwise. public override bool Equals(object obj) { - if (!(obj is Vector3)) + if (!(obj is Vector3d)) return false; - return this.Equals((Vector3)obj); + return this.Equals((Vector3d)obj); } #endregion From 569c4c86c79f351ec9116047041af80e48e8d4b6 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Sun, 21 Nov 2010 20:16:18 +0000 Subject: [PATCH 103/130] Refactored and simplified DisplayDevice detection (devices are now stored in the platform-specific drivers instead of the frontend). Made XRR resolution changes more robust. Resolution changes now refresh the DisplayDevices on Windows. --- Source/OpenTK/DisplayDevice.cs | 96 +++++++---- Source/OpenTK/DisplayIndex.cs | 72 ++++++++ Source/OpenTK/Graphics/GraphicsMode.cs | 4 +- Source/OpenTK/OpenTK.csproj | 2 + Source/OpenTK/Platform/DisplayDeviceBase.cs | 53 ++++++ .../OpenTK/Platform/IDisplayDeviceDriver.cs | 32 +++- Source/OpenTK/Platform/MacOS/AglContext.cs | 2 +- .../MacOS/QuartzDisplayDeviceDriver.cs | 74 ++++---- .../Platform/Windows/WinDisplayDevice.cs | 159 +++++++++++------- .../Platform/Windows/WinGraphicsMode.cs | 2 +- Source/OpenTK/Platform/X11/API.cs | 2 +- .../OpenTK/Platform/X11/X11DisplayDevice.cs | 113 +++++++++---- 12 files changed, 453 insertions(+), 158 deletions(-) create mode 100644 Source/OpenTK/DisplayIndex.cs create mode 100644 Source/OpenTK/Platform/DisplayDeviceBase.cs diff --git a/Source/OpenTK/DisplayDevice.cs b/Source/OpenTK/DisplayDevice.cs index 5a20ba35..a95cb19a 100644 --- a/Source/OpenTK/DisplayDevice.cs +++ b/Source/OpenTK/DisplayDevice.cs @@ -1,16 +1,33 @@ -#region --- License --- -/* Licensed under the MIT/X11 license. - * Copyright (c) 2006-2008 the OpenTK team. - * This notice may not be removed. - * See license.txt for licensing detailed licensing details. - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion using System; using System.Collections.Generic; -using System.Text; using System.Diagnostics; -using System.Threading; using System.Drawing; namespace OpenTK @@ -21,23 +38,19 @@ namespace OpenTK /// public class DisplayDevice { - // TODO: Add support for refresh rate queries and switches. - // TODO: Check whether bits_per_pixel works correctly under Mono/X11. // TODO: Add properties that describe the 'usable' size of the Display, i.e. the maximized size without the taskbar etc. // TODO: Does not detect changes to primary device. - // TODO: Mono does not support System.Windows.Forms.Screen.BitsPerPixel -- find workaround! - #region --- Fields --- + #region Fields + bool primary; + Rectangle bounds; DisplayResolution current_resolution = new DisplayResolution(), original_resolution; List available_resolutions = new List(); IList available_resolutions_readonly; - bool primary; + + internal object Id; // A platform-specific id for this monitor - Rectangle bounds; - - static readonly List available_displays = new List(); - static readonly IList available_displays_readonly; static readonly object display_lock = new object(); static DisplayDevice primary_display; @@ -45,26 +58,21 @@ namespace OpenTK #endregion - #region --- Constructors --- + #region Constructors static DisplayDevice() { implementation = Platform.Factory.Default.CreateDisplayDeviceDriver(); - available_displays_readonly = available_displays.AsReadOnly(); } internal DisplayDevice() { - lock (display_lock) - { - available_displays.Add(this); - } - available_resolutions_readonly = available_resolutions.AsReadOnly(); } internal DisplayDevice(DisplayResolution currentResolution, bool primary, - IEnumerable availableResolutions, Rectangle bounds) + IEnumerable availableResolutions, Rectangle bounds, + object id) : this() { #warning "Consolidate current resolution with bounds? Can they fall out of sync right now?" @@ -72,9 +80,7 @@ namespace OpenTK IsPrimary = primary; this.available_resolutions.AddRange(availableResolutions); this.bounds = bounds == Rectangle.Empty ? currentResolution.Bounds : bounds; - - Debug.Print("DisplayDevice {0} ({1}) supports {2} resolutions.", - available_displays.Count, primary ? "primary" : "secondary", available_resolutions.Count); + this.Id = id; } #endregion @@ -280,10 +286,23 @@ namespace OpenTK /// /// Gets the list of available objects. + /// This function allocates memory. /// + [Obsolete("Use GetDisplay(DisplayIndex) instead.")] public static IList AvailableDisplays { - get { return available_displays_readonly; } + get + { + List displays = new List(); + for (int i = 0; i < 6; i++) + { + DisplayDevice dev = GetDisplay(DisplayIndex.First + i); + if (dev != null) + displays.Add(dev); + } + + return displays.AsReadOnly(); + } } #endregion @@ -291,7 +310,24 @@ namespace OpenTK #region public static DisplayDevice Default /// Gets the default (primary) display of this system. - public static DisplayDevice Default { get { return primary_display; } } + public static DisplayDevice Default + { + get { return implementation.GetDisplay(DisplayIndex.Primary); } + } + + #endregion + + #region GetDisplay + + /// + /// Gets the for the specified . + /// + /// The that defines the desired display. + /// A or null, if no device corresponds to the specified index. + public static DisplayDevice GetDisplay(DisplayIndex index) + { + return implementation.GetDisplay(index); + } #endregion diff --git a/Source/OpenTK/DisplayIndex.cs b/Source/OpenTK/DisplayIndex.cs new file mode 100644 index 00000000..14ff6cff --- /dev/null +++ b/Source/OpenTK/DisplayIndex.cs @@ -0,0 +1,72 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK +{ + /// + /// Defines indices. + /// + public enum DisplayIndex + { + /// + /// The first DisplayDevice. + /// + First = 0, + /// + /// The second DisplayDevice. + /// + Second, + /// + /// The third DisplayDevice. + /// + Third, + /// + /// The fourth DisplayDevice. + /// + Fourth, + /// + /// The fifth DisplayDevice. + /// + Fifth, + /// + /// The sixth DisplayDevice. + /// + Sixth, + /// + /// The default (primary) DisplayDevice. + /// + Primary = -1, + /// + /// The default (primary) DisplayDevice. + /// + Default = Primary, + } +} diff --git a/Source/OpenTK/Graphics/GraphicsMode.cs b/Source/OpenTK/Graphics/GraphicsMode.cs index 6854beb0..89379131 100644 --- a/Source/OpenTK/Graphics/GraphicsMode.cs +++ b/Source/OpenTK/Graphics/GraphicsMode.cs @@ -321,8 +321,8 @@ namespace OpenTK.Graphics { if (defaultMode == null) { - Debug.Print("Creating default GraphicsMode ({0}, {1}, {2}, {3}, {4}, {5}, {6}).", DisplayDevice.Default.BitsPerPixel, - 16, 0, 0, 0, 2, false); + Debug.Print("Creating default GraphicsMode ({0}, {1}, {2}, {3}, {4}, {5}, {6}).", + DisplayDevice.Default.BitsPerPixel, 16, 0, 0, 0, 2, false); defaultMode = new GraphicsMode(DisplayDevice.Default.BitsPerPixel, 16, 0, 0, 0, 2, false); } return defaultMode; diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index 803dd745..4dbe1bf0 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -128,11 +128,13 @@ Code + + Code diff --git a/Source/OpenTK/Platform/DisplayDeviceBase.cs b/Source/OpenTK/Platform/DisplayDeviceBase.cs new file mode 100644 index 00000000..723d8221 --- /dev/null +++ b/Source/OpenTK/Platform/DisplayDeviceBase.cs @@ -0,0 +1,53 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.Platform +{ + abstract class DisplayDeviceBase : IDisplayDeviceDriver + { + protected readonly List AvailableDevices = new List(); + protected DisplayDevice Primary; + + public abstract bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution); + public abstract bool TryRestoreResolution(DisplayDevice device); + + // Gets the DisplayDevice that corresponds to the specified index. + public virtual DisplayDevice GetDisplay(DisplayIndex index) + { + if (index == DisplayIndex.Primary) + return Primary; + else if ((int)index >= 0 && (int)index < AvailableDevices.Count) + return AvailableDevices[(int)index]; + else + return null; + } + } +} diff --git a/Source/OpenTK/Platform/IDisplayDeviceDriver.cs b/Source/OpenTK/Platform/IDisplayDeviceDriver.cs index f66bca4e..cc3e67da 100644 --- a/Source/OpenTK/Platform/IDisplayDeviceDriver.cs +++ b/Source/OpenTK/Platform/IDisplayDeviceDriver.cs @@ -1,9 +1,28 @@ -#region --- License --- -/* Licensed under the MIT/X11 license. - * Copyright (c) 2006-2008 the OpenTK team. - * This notice may not be removed. - * See license.txt for licensing detailed licensing details. - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion using System; @@ -16,5 +35,6 @@ namespace OpenTK.Platform { bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution); bool TryRestoreResolution(DisplayDevice device); + DisplayDevice GetDisplay(DisplayIndex displayIndex); } } diff --git a/Source/OpenTK/Platform/MacOS/AglContext.cs b/Source/OpenTK/Platform/MacOS/AglContext.cs index 4d52d337..960d4abf 100644 --- a/Source/OpenTK/Platform/MacOS/AglContext.cs +++ b/Source/OpenTK/Platform/MacOS/AglContext.cs @@ -140,7 +140,7 @@ namespace OpenTK.Platform.MacOS IntPtr cgdevice = GetQuartzDevice(carbonWindow); if (cgdevice == IntPtr.Zero) - cgdevice = QuartzDisplayDeviceDriver.MainDisplay; + cgdevice = (IntPtr)DisplayDevice.Default.Id; OSStatus status = Carbon.API.DMGetGDeviceByDisplayID(cgdevice, out gdevice, false); diff --git a/Source/OpenTK/Platform/MacOS/QuartzDisplayDeviceDriver.cs b/Source/OpenTK/Platform/MacOS/QuartzDisplayDeviceDriver.cs index 999b1d45..b7da1bc1 100644 --- a/Source/OpenTK/Platform/MacOS/QuartzDisplayDeviceDriver.cs +++ b/Source/OpenTK/Platform/MacOS/QuartzDisplayDeviceDriver.cs @@ -1,25 +1,43 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + using System; using System.Collections.Generic; using System.Diagnostics; +using System.Drawing; +using OpenTK.Platform.MacOS.Carbon; namespace OpenTK.Platform.MacOS { - using System.Drawing; - using Carbon; - - class QuartzDisplayDeviceDriver : IDisplayDeviceDriver + sealed class QuartzDisplayDeviceDriver : DisplayDeviceBase { static object display_lock = new object(); - static Dictionary displayMap = new Dictionary(); - - static IntPtr mainDisplay; - static internal IntPtr MainDisplay - { - get { return mainDisplay; } - } - - static QuartzDisplayDeviceDriver() + public QuartzDisplayDeviceDriver() { lock (display_lock) { @@ -52,9 +70,6 @@ namespace OpenTK.Platform.MacOS // main display. bool primary = (i == 0); - if (primary) - mainDisplay = currentDisplay; - // gets current settings int currentWidth = CG.DisplayPixelsWide(currentDisplay); int currentHeight = CG.DisplayPixelsHigh(currentDisplay); @@ -97,22 +112,22 @@ namespace OpenTK.Platform.MacOS Debug.Print("Display {0} bounds: {1}", i, newRect); - DisplayDevice opentk_dev = new DisplayDevice(opentk_dev_current_res, primary, opentk_dev_available_res, newRect); - - displayMap.Add(opentk_dev, currentDisplay); + DisplayDevice opentk_dev = new DisplayDevice(opentk_dev_current_res, + primary, opentk_dev_available_res, newRect, currentDisplay); + + AvailableDevices.Add(opentk_dev); + + if (primary) + Primary = opentk_dev; } Debug.Unindent(); } } - static internal IntPtr HandleTo(DisplayDevice displayDevice) { - if (displayMap.ContainsKey(displayDevice)) - return displayMap[displayDevice]; - else - return IntPtr.Zero; + return (IntPtr)displayDevice.Id; } #region IDisplayDeviceDriver Members @@ -120,9 +135,9 @@ namespace OpenTK.Platform.MacOS Dictionary storedModes = new Dictionary(); List displaysCaptured = new List(); - public bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution) + public sealed override bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution) { - IntPtr display = displayMap[device]; + IntPtr display = HandleTo(device); IntPtr currentModePtr = CG.DisplayCurrentMode(display); if (storedModes.ContainsKey(display) == false) @@ -160,9 +175,9 @@ namespace OpenTK.Platform.MacOS return false; } - public bool TryRestoreResolution(DisplayDevice device) + public sealed override bool TryRestoreResolution(DisplayDevice device) { - IntPtr display = displayMap[device]; + IntPtr display = HandleTo(device); if (storedModes.ContainsKey(display)) { @@ -177,8 +192,7 @@ namespace OpenTK.Platform.MacOS return false; } - + #endregion - } } diff --git a/Source/OpenTK/Platform/Windows/WinDisplayDevice.cs b/Source/OpenTK/Platform/Windows/WinDisplayDevice.cs index ec0025a8..195c119b 100644 --- a/Source/OpenTK/Platform/Windows/WinDisplayDevice.cs +++ b/Source/OpenTK/Platform/Windows/WinDisplayDevice.cs @@ -1,37 +1,101 @@ -#region --- License --- -/* Licensed under the MIT/X11 license. - * Copyright (c) 2006-2008 the OpenTK team. - * This notice may not be removed. - * See license.txt for licensing detailed licensing details. - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion using System; using System.Collections.Generic; -using System.Text; - -using OpenTK.Graphics; -using System.Runtime.InteropServices; using System.Diagnostics; namespace OpenTK.Platform.Windows { - internal class WinDisplayDeviceDriver : IDisplayDeviceDriver + sealed class WinDisplayDeviceDriver : DisplayDeviceBase { - static object display_lock = new object(); - static Dictionary available_device_names = - new Dictionary(); // Needed for ChangeDisplaySettingsEx + readonly object display_lock = new object(); - #region --- Constructors --- + #region Constructors - /// Queries available display devices and display resolutions. - static WinDisplayDeviceDriver() + public WinDisplayDeviceDriver() + { + RefreshDisplayDevices(); + Microsoft.Win32.SystemEvents.DisplaySettingsChanged += + HandleDisplaySettingsChanged; + } + + #endregion + + #region IDisplayDeviceDriver Members + + #region TryChangeResolution + + public sealed override bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution) + { + DeviceMode mode = null; + + if (resolution != null) + { + mode = new DeviceMode(); + mode.PelsWidth = resolution.Width; + mode.PelsHeight = resolution.Height; + mode.BitsPerPel = resolution.BitsPerPixel; + mode.DisplayFrequency = (int)resolution.RefreshRate; + mode.Fields = Constants.DM_BITSPERPEL + | Constants.DM_PELSWIDTH + | Constants.DM_PELSHEIGHT + | Constants.DM_DISPLAYFREQUENCY; + } + + return Constants.DISP_CHANGE_SUCCESSFUL == + Functions.ChangeDisplaySettingsEx((string)device.Id, mode, IntPtr.Zero, + ChangeDisplaySettingsEnum.Fullscreen, IntPtr.Zero); + } + + #endregion + + #region TryRestoreResolution + + public sealed override bool TryRestoreResolution(DisplayDevice device) + { + return TryChangeResolution(device, null); + } + + #endregion + + #endregion + + #region Private Members + + #region RefreshDisplayDevices + + public void RefreshDisplayDevices() { lock (display_lock) { - // To minimize the need to add static methods to OpenTK.Graphics.DisplayDevice - // we only allow settings to be set through its constructor. - // Thus, we save all necessary parameters in temporary variables + AvailableDevices.Clear(); + + // We save all necessary parameters in temporary variables // and construct the device when every needed detail is available. // The main DisplayDevice constructor adds the newly constructed device // to the list of available devices. @@ -82,56 +146,37 @@ namespace OpenTK.Platform.Windows opentk_dev_current_res, opentk_dev_primary, opentk_dev_available_res, - opentk_dev_current_res.Bounds); + opentk_dev_current_res.Bounds, + dev1.DeviceName); - available_device_names.Add(opentk_dev, dev1.DeviceName); + AvailableDevices.Add(opentk_dev); + + if (opentk_dev_primary) + Primary = opentk_dev; + + Debug.Print("DisplayDevice {0} ({1}) supports {2} resolutions.", + device_count, opentk_dev.IsPrimary ? "primary" : "secondary", opentk_dev.AvailableResolutions.Count); } } } - public WinDisplayDeviceDriver() + #endregion + + #region HandleDisplaySettingsChanged + + void HandleDisplaySettingsChanged(object sender, EventArgs e) { + RefreshDisplayDevices(); } #endregion - #region --- IDisplayDeviceDriver Members --- - - #region public bool TryChangeResolution(OpenTK.Graphics.DisplayDevice device, DisplayResolution resolution) - - public bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution) + ~WinDisplayDeviceDriver() { - DeviceMode mode = null; - - if (resolution != null) - { - mode = new DeviceMode(); - mode.PelsWidth = resolution.Width; - mode.PelsHeight = resolution.Height; - mode.BitsPerPel = resolution.BitsPerPixel; - mode.DisplayFrequency = (int)resolution.RefreshRate; - mode.Fields = Constants.DM_BITSPERPEL - | Constants.DM_PELSWIDTH - | Constants.DM_PELSHEIGHT - | Constants.DM_DISPLAYFREQUENCY; - } - - return Constants.DISP_CHANGE_SUCCESSFUL == - Functions.ChangeDisplaySettingsEx(available_device_names[device], mode, IntPtr.Zero, - ChangeDisplaySettingsEnum.Fullscreen, IntPtr.Zero); + Microsoft.Win32.SystemEvents.DisplaySettingsChanged -= + HandleDisplaySettingsChanged; } #endregion - - #region public TryRestoreResolution TryRestoreResolution(OpenTK.Graphics.DisplayDevice device) - - public bool TryRestoreResolution(DisplayDevice device) - { - return TryChangeResolution(device, null); - } - - #endregion - - #endregion } } diff --git a/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs b/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs index c93ae4e1..69d0be95 100644 --- a/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs +++ b/Source/OpenTK/Platform/Windows/WinGraphicsMode.cs @@ -44,7 +44,7 @@ namespace OpenTK.Platform.Windows #endregion - #region --- Constructors --- + #region Constructors public WinGraphicsMode() { diff --git a/Source/OpenTK/Platform/X11/API.cs b/Source/OpenTK/Platform/X11/API.cs index 43581b2b..dd7a5d25 100644 --- a/Source/OpenTK/Platform/X11/API.cs +++ b/Source/OpenTK/Platform/X11/API.cs @@ -1501,7 +1501,7 @@ XF86VidModeGetGammaRampSize( [DllImport(XrandrLibrary)] public static extern Status XRRSetScreenConfig(Display dpy, XRRScreenConfiguration config, - Drawable draw, int size_index, ref Rotation rotation, Time timestamp); + Drawable draw, int size_index, Rotation rotation, Time timestamp); [DllImport(XrandrLibrary)] public static extern Status XRRSetScreenConfigAndRate(Display dpy, XRRScreenConfiguration config, diff --git a/Source/OpenTK/Platform/X11/X11DisplayDevice.cs b/Source/OpenTK/Platform/X11/X11DisplayDevice.cs index 76788beb..3262ce1b 100644 --- a/Source/OpenTK/Platform/X11/X11DisplayDevice.cs +++ b/Source/OpenTK/Platform/X11/X11DisplayDevice.cs @@ -1,9 +1,28 @@ -#region --- License --- -/* Licensed under the MIT/X11 license. - * Copyright (c) 2006-2008 the OpenTK Team. - * This notice may not be removed from any source distribution. - * See license.txt for licensing detailed licensing details. - */ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// #endregion using System; @@ -14,27 +33,35 @@ using System.Runtime.InteropServices; namespace OpenTK.Platform.X11 { - internal class X11DisplayDevice : IDisplayDeviceDriver + sealed class X11DisplayDevice : DisplayDeviceBase { - static object display_lock = new object(); // Store a mapping between resolutions and their respective // size_index (needed for XRRSetScreenConfig). The size_index // is simply the sequence number of the resolution as returned by // XRRSizes. This is done per available screen. - static List> screenResolutionToIndex = + readonly List> screenResolutionToIndex = new List>(); // Store a mapping between DisplayDevices and their default resolutions. - static Dictionary deviceToDefaultResolution = new Dictionary(); + readonly Dictionary deviceToDefaultResolution = new Dictionary(); // Store a mapping between DisplayDevices and X11 screens. - static Dictionary deviceToScreen = new Dictionary(); + readonly Dictionary deviceToScreen = new Dictionary(); // Keep the time when the config of each screen was last updated. - static List lastConfigUpdate = new List(); + readonly List lastConfigUpdate = new List(); - static bool xinerama_supported, xrandr_supported, xf86_supported; + bool xinerama_supported, xrandr_supported, xf86_supported; - #region --- Constructors --- + #region Constructors - static X11DisplayDevice() + public X11DisplayDevice() + { + RefreshDisplayDevices(); + } + + #endregion + + #region Private Methods + + void RefreshDisplayDevices() { using (new XLock(API.DefaultDisplay)) { @@ -82,16 +109,23 @@ namespace OpenTK.Platform.X11 Debug.Print("XF86 query failed, no DisplayDevice support available."); } } + + AvailableDevices.Clear(); + AvailableDevices.AddRange(devices); + Primary = FindDefaultDevice(devices); } } - internal X11DisplayDevice() { } + static DisplayDevice FindDefaultDevice(IEnumerable devices) + { + foreach (DisplayDevice dev in devices) + if (dev.IsPrimary) + return dev; - #endregion + throw new InvalidOperationException("No primary display found. Please file a bug at http://www.opentk.com"); + } - #region --- Private Methods --- - - static bool QueryXinerama(List devices) + bool QueryXinerama(List devices) { // Try to use Xinerama to obtain the geometry of all output devices. int event_base, error_base; @@ -119,7 +153,7 @@ namespace OpenTK.Platform.X11 return (devices.Count>0); } - static bool QueryXRandR(List devices) + bool QueryXRandR(List devices) { // Get available resolutions. Then, for each resolution get all available rates. foreach (DisplayDevice dev in devices) @@ -196,7 +230,7 @@ namespace OpenTK.Platform.X11 return true; } - static bool QueryXF86(List devices) + bool QueryXF86(List devices) { int major; int minor; @@ -286,14 +320,14 @@ namespace OpenTK.Platform.X11 #region private static int FindCurrentDepth(int screen) - private static int FindCurrentDepth(int screen) + static int FindCurrentDepth(int screen) { return (int)Functions.XDefaultDepth(API.DefaultDisplay, screen); } #endregion - static bool ChangeResolutionXRandR(DisplayDevice device, DisplayResolution resolution) + bool ChangeResolutionXRandR(DisplayDevice device, DisplayResolution resolution) { using (new XLock(API.DefaultDisplay)) { @@ -313,8 +347,28 @@ namespace OpenTK.Platform.X11 Debug.Print("Changing size of screen {0} from {1} to {2}", screen, current_resolution_index, new_resolution_index); - return 0 == Functions.XRRSetScreenConfigAndRate(API.DefaultDisplay, screen_config, root, new_resolution_index, - current_rotation, (short)(resolution != null ? resolution.RefreshRate : 0), lastConfigUpdate[screen]); + int ret = 0; + short refresh_rate =(short)(resolution != null ? resolution.RefreshRate : 0); + if (refresh_rate > 0) + { + ret = Functions.XRRSetScreenConfigAndRate(API.DefaultDisplay, + screen_config, root, new_resolution_index, current_rotation, + refresh_rate, IntPtr.Zero); + } + else + { + ret = Functions.XRRSetScreenConfig(API.DefaultDisplay, + screen_config, root, new_resolution_index, current_rotation, + IntPtr.Zero); + } + + if (ret != 0) + { + Debug.Print("[Error] Change to resolution {0} failed with error {1}.", + resolution, (ErrorCode)ret); + } + + return ret == 0; } } @@ -325,9 +379,9 @@ namespace OpenTK.Platform.X11 #endregion - #region --- IDisplayDeviceDriver Members --- + #region IDisplayDeviceDriver Members - public bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution) + public sealed override bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution) { // If resolution is null, restore the default resolution (new_resolution_index = 0). @@ -345,8 +399,7 @@ namespace OpenTK.Platform.X11 } } - - public bool TryRestoreResolution(DisplayDevice device) + public sealed override bool TryRestoreResolution(DisplayDevice device) { return TryChangeResolution(device, null); } From 82e540177932b28c7608b9b12b3e03617b20e16d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 22 Nov 2010 15:57:26 +0000 Subject: [PATCH 104/130] * OpenTK.csproj: * Platform/MacOS/HIDInput.cs: * Platform/MacOS/MacOSFactory.cs: * Platform/MacOS/CarbonBindings/CoreFoundation.cs: Initial work on HID input manager. --- Source/OpenTK/OpenTK.csproj | 3 +- .../MacOS/CarbonBindings/CoreFoundation.cs | 5 + Source/OpenTK/Platform/MacOS/HIDInput.cs | 161 ++++++++++++++++++ Source/OpenTK/Platform/MacOS/MacOSFactory.cs | 2 +- 4 files changed, 169 insertions(+), 2 deletions(-) create mode 100755 Source/OpenTK/Platform/MacOS/HIDInput.cs diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index 4dbe1bf0..1db398dc 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -1,4 +1,4 @@ - + Local @@ -765,6 +765,7 @@ Always + diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs index 10a607f1..a2c9ba93 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs @@ -5,6 +5,8 @@ using System.Text; namespace OpenTK.Platform.MacOS.Carbon { + using CFRunLoop = System.IntPtr; + struct CFArray { IntPtr arrayRef; @@ -112,5 +114,8 @@ namespace OpenTK.Platform.MacOS.Carbon kCFNumberCGFloatType = 16, kCFNumberMaxType = 16 }; + + [DllImport(appServices)] + internal static extern CFRunLoop CFRunLoopGetCurrent(); } } diff --git a/Source/OpenTK/Platform/MacOS/HIDInput.cs b/Source/OpenTK/Platform/MacOS/HIDInput.cs new file mode 100755 index 00000000..6e8a6038 --- /dev/null +++ b/Source/OpenTK/Platform/MacOS/HIDInput.cs @@ -0,0 +1,161 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Runtime.InteropServices; +using OpenTK.Input; + +namespace OpenTK.Platform.MacOS +{ + using Carbon; + using CFAllocatorRef = System.IntPtr; + using CFDictionaryRef = System.IntPtr; + using CFRunLoop = System.IntPtr; + using CFString = System.IntPtr; + using IOHIDDeviceRef = System.IntPtr; + using IOHIDManagerRef = System.IntPtr; + using IOOptionBits = System.IntPtr; + using IOReturn = System.IntPtr; + + class HIDInput : IMouseDriver2 + { + #region Fields + + readonly IOHIDManagerRef hidmanager; + readonly static NativeMethods.IOHIDDeviceCallback HandleDeviceAdded = delegate + { + Debug.WriteLine("Device added"); + }; + readonly static NativeMethods.IOHIDDeviceCallback HandleDeviceRemoved = delegate + { + Debug.WriteLine("Device Removed"); + }; + readonly static CFString RunLoopMode = CF.CFSTR("OPENTK_INPUT"); + readonly static CFDictionary DeviceTypes = new CFDictionary(); + + #endregion + + #region Constructors + + public HIDInput() + { + Debug.Print("Using {0}.", typeof(HIDInput).Name); + + hidmanager = CreateHIDManager(); + RegisterHIDCallbacks(hidmanager); + } + + #endregion + + #region Private Members + + static IOHIDManagerRef CreateHIDManager() + { + return NativeMethods.IOHIDManagerCreate(IntPtr.Zero, IntPtr.Zero); + } + + static void RegisterHIDCallbacks(IOHIDManagerRef hidmanager) + { + CFRunLoop runloop = Carbon.CF.CFRunLoopGetCurrent(); + + NativeMethods.IOHIDManagerRegisterDeviceMatchingCallback( + hidmanager, HandleDeviceAdded, IntPtr.Zero); + NativeMethods.IOHIDManagerRegisterDeviceRemovalCallback( + hidmanager, HandleDeviceRemoved, IntPtr.Zero); + NativeMethods.IOHIDManagerScheduleWithRunLoop(hidmanager, + runloop, RunLoopMode); + + NativeMethods.IOHIDManagerSetDeviceMatching(hidmanager, DeviceTypes.Ref); + NativeMethods.IOHIDManagerOpen(hidmanager, IOOptionBits.Zero); + } + + #endregion + + #region IMouseDriver2 Members + + public MouseState GetState() + { + return new MouseState(); + } + + public MouseState GetState(int index) + { + return new MouseState(); + } + + #endregion + + #region NativeMethods + + class NativeMethods + { + const string hid = "/System/Library/Frameworks/IOKit.framework/Versions/Current/IOKit"; + + [DllImport(hid)] + public static extern IOHIDManagerRef IOHIDManagerCreate( + CFAllocatorRef allocator, IOOptionBits options) ; + + // This routine will be called when a new (matching) device is connected. + [DllImport(hid)] + public static extern void IOHIDManagerRegisterDeviceMatchingCallback( + IOHIDManagerRef inIOHIDManagerRef, + IOHIDDeviceCallback inIOHIDDeviceCallback, + IntPtr inContext); + + // This routine will be called when a (matching) device is disconnected. + [DllImport(hid)] + public static extern void IOHIDManagerRegisterDeviceRemovalCallback( + IOHIDManagerRef inIOHIDManagerRef, + IOHIDDeviceCallback inIOHIDDeviceCallback, + IntPtr inContext); + + [DllImport(hid)] + public static extern void IOHIDManagerScheduleWithRunLoop( + IOHIDManagerRef inIOHIDManagerRef, + CFRunLoop inCFRunLoop, + CFString inCFRunLoopMode); + + [DllImport(hid)] + public static extern void IOHIDManagerSetDeviceMatching( + IOHIDManagerRef manager, + CFDictionaryRef matching) ; + + [DllImport(hid)] + public static extern IOReturn IOHIDManagerOpen( + IOHIDManagerRef manager, + IOOptionBits options) ; + + + public delegate void IOHIDDeviceCallback(IntPtr ctx, IOReturn res, IntPtr sender, IOHIDDeviceRef device); + } + + #endregion + } +} + diff --git a/Source/OpenTK/Platform/MacOS/MacOSFactory.cs b/Source/OpenTK/Platform/MacOS/MacOSFactory.cs index c83163db..07c3a968 100644 --- a/Source/OpenTK/Platform/MacOS/MacOSFactory.cs +++ b/Source/OpenTK/Platform/MacOS/MacOSFactory.cs @@ -77,7 +77,7 @@ namespace OpenTK.Platform.MacOS public virtual OpenTK.Input.IMouseDriver2 CreateMouseDriver() { - throw new NotImplementedException(); + return new HIDInput(); } #endregion From 76e1d4064bb324b91b5a802e00d384bbde6445b7 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 23 Nov 2010 17:17:13 +0000 Subject: [PATCH 105/130] * Input/Mouse.cs: * Input/IMouseDriver2.cs: * Platform/X11/X11Mouse.cs: * Platform/X11/XI2Mouse.cs: * Platform/X11/Functions.cs: * Platform/Windows/WMInput.cs: * Platform/X11/X11GLNative.cs: * Platform/Windows/WinRawMouse.cs: Added ability to set the position of the mouse cursor. [X11] Avoid grabbing the pointer, as this causes unexpected side-effects (XInput2 stops working, debugging becomes difficult). We now use XWarpPointer and try to discard the spurious MouseMove events it generates. [X11] Make cursor visible when window loses focus, to make debugging easier. Restore previous state when it regains focus. --- Source/OpenTK/Input/IMouseDriver2.cs | 40 +++++++--- Source/OpenTK/Input/Mouse.cs | 17 +++++ Source/OpenTK/Platform/Windows/WMInput.cs | 5 ++ Source/OpenTK/Platform/Windows/WinRawMouse.cs | 5 ++ Source/OpenTK/Platform/X11/Functions.cs | 6 ++ Source/OpenTK/Platform/X11/X11GLNative.cs | 73 +++++++++++++++++-- Source/OpenTK/Platform/X11/X11Mouse.cs | 5 ++ Source/OpenTK/Platform/X11/XI2Mouse.cs | 60 ++++++++++++++- 8 files changed, 189 insertions(+), 22 deletions(-) diff --git a/Source/OpenTK/Input/IMouseDriver2.cs b/Source/OpenTK/Input/IMouseDriver2.cs index 6b560e13..0d0335e7 100644 --- a/Source/OpenTK/Input/IMouseDriver2.cs +++ b/Source/OpenTK/Input/IMouseDriver2.cs @@ -1,4 +1,31 @@ -using System; + #region License + // + // The Open Toolkit Library License + // + // Copyright (c) 2006 - 2010 the Open Toolkit library. + // + // Permission is hereby granted, free of charge, to any person obtaining a copy + // of this software and associated documentation files (the "Software"), to deal + // in the Software without restriction, including without limitation the rights to + // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + // the Software, and to permit persons to whom the Software is furnished to do + // so, subject to the following conditions: + // + // The above copyright notice and this permission notice shall be included in all + // copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + // OTHER DEALINGS IN THE SOFTWARE. + // + #endregion + +using System; using System.Collections.Generic; using System.Text; @@ -6,17 +33,8 @@ namespace OpenTK.Input { interface IMouseDriver2 { - /// - /// Retrieves the MouseState for the default keyboard device. - /// - /// A structure containing the state of the mouse device. MouseState GetState(); - - /// - /// Retrieves the MouseState for the specified keyboard device. - /// - /// The index of the keyboard device. - /// A structure containing the state of the mouse device. MouseState GetState(int index); + void SetPosition(double x, double y); } } diff --git a/Source/OpenTK/Input/Mouse.cs b/Source/OpenTK/Input/Mouse.cs index c3f42c17..f68d5ff2 100644 --- a/Source/OpenTK/Input/Mouse.cs +++ b/Source/OpenTK/Input/Mouse.cs @@ -74,6 +74,23 @@ namespace OpenTK.Input } } + /// + ///Moves the mouse cursor to the specified screen position. + /// + /// + /// A that represents the absolute x position of the cursor in screen coordinates. + /// + /// + /// A that represents the absolute y position of the cursor in screen coordinates. + /// + public static void SetPosition(double x, double y) + { + lock (SyncRoot) + { + driver.SetPosition(x, y); + } + } + #endregion } } diff --git a/Source/OpenTK/Platform/Windows/WMInput.cs b/Source/OpenTK/Platform/Windows/WMInput.cs index 8f42d3a7..692ef491 100644 --- a/Source/OpenTK/Platform/Windows/WMInput.cs +++ b/Source/OpenTK/Platform/Windows/WMInput.cs @@ -137,6 +137,11 @@ namespace OpenTK.Platform.Windows } } + public void SetPosition(double x, double y) + { + throw new NotImplementedException(); + } + #endregion #region IKeyboardDriver2 Members diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index 3f028bc6..4d6ade4f 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -278,6 +278,11 @@ namespace OpenTK.Platform.Windows } } + public void SetPosition(double x, double y) + { + throw new NotImplementedException(); + } + #endregion } } diff --git a/Source/OpenTK/Platform/X11/Functions.cs b/Source/OpenTK/Platform/X11/Functions.cs index 69e1e362..7d138d92 100644 --- a/Source/OpenTK/Platform/X11/Functions.cs +++ b/Source/OpenTK/Platform/X11/Functions.cs @@ -529,6 +529,12 @@ namespace OpenTK.Platform.X11 [DllImport("libXi")] static extern Status XIUngrabDevice(IntPtr display, int deviceid, Time time); + [DllImport("libXi")] + public static extern Bool XIWarpPointer(Display display, + int deviceid, Window src_w, Window dest_w, + double src_x, double src_y, int src_width, int src_height, + double dest_x, double dest_y); + static readonly IntPtr CopyFromParent = IntPtr.Zero; public static void SendNetWMMessage(X11WindowInfo window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) diff --git a/Source/OpenTK/Platform/X11/X11GLNative.cs b/Source/OpenTK/Platform/X11/X11GLNative.cs index 4688ebd7..4be53acd 100644 --- a/Source/OpenTK/Platform/X11/X11GLNative.cs +++ b/Source/OpenTK/Platform/X11/X11GLNative.cs @@ -54,7 +54,10 @@ namespace OpenTK.Platform.X11 const int _min_width = 30, _min_height = 30; X11WindowInfo window = new X11WindowInfo(); + + // Legacy input support X11Input driver; + MouseDevice mouse; // Window manager hints for fullscreen windows. // Not used right now (the code is written, but is not 64bit-correct), but could be useful for older WMs which @@ -107,6 +110,8 @@ namespace OpenTK.Platform.X11 bool isExiting; bool _decorations_hidden = false; + bool cursor_visible = true; + int mouse_rel_x, mouse_rel_y; // Keyboard input readonly byte[] ascii = new byte[16]; @@ -115,6 +120,8 @@ namespace OpenTK.Platform.X11 readonly IntPtr EmptyCursor; + public static bool MouseWarpActive = false; + #endregion #region Constructors @@ -196,6 +203,7 @@ namespace OpenTK.Platform.X11 RefreshWindowBounds(ref e); driver = new X11Input(window); + mouse = driver.Mouse[0]; EmptyCursor = CreateEmptyCursor(window); @@ -692,6 +700,17 @@ namespace OpenTK.Platform.X11 return cursor; } + static void SetMouseClamped(MouseDevice mouse, int x, int y, + int left, int top, int width, int height) + { + // Clamp mouse to the specified rectangle. + x = Math.Max(x, left); + x = Math.Min(x, width); + y = Math.Max(y, top); + y = Math.Min(y, height); + mouse.Position = new Point(x, y); + } + #endregion #region INativeWindow Members @@ -794,6 +813,45 @@ namespace OpenTK.Platform.X11 break; case XEventName.MotionNotify: + { + // Try to detect and ignore events from XWarpPointer, below. + // This heuristic will fail if the user actually moves the pointer + // to the dead center of the window. Fortunately, this situation + // is very very uncommon. Todo: Can this be remedied? + int x = e.MotionEvent.x; + int y =e.MotionEvent.y; + int middle_x = (Bounds.Left + Bounds.Right) / 2; + int middle_y = (Bounds.Top + Bounds.Bottom) / 2; + Point screen_xy = PointToScreen(new Point(x, y)); + if (!CursorVisible && MouseWarpActive && + screen_xy.X == middle_x && screen_xy.Y == middle_y) + { + MouseWarpActive = false; + mouse_rel_x = x; + mouse_rel_y = y; + } + else if (!CursorVisible) + { + SetMouseClamped(mouse, + mouse.X + x - mouse_rel_x, + mouse.Y + y - mouse_rel_y, + 0, 0, Width, Height); + mouse_rel_x = x; + mouse_rel_y = y; + + // Warp cursor to center of window. + MouseWarpActive = true; + Mouse.SetPosition(middle_x, middle_y); + } + else + { + SetMouseClamped(mouse, x, y, 0, 0, Width, Height); + mouse_rel_x = x; + mouse_rel_y = y; + } + break; + } + case XEventName.ButtonPress: case XEventName.ButtonRelease: driver.ProcessEvent(ref e); @@ -818,7 +876,10 @@ namespace OpenTK.Platform.X11 break; case XEventName.LeaveNotify: - MouseLeave(this, EventArgs.Empty); + if (CursorVisible) + { + MouseLeave(this, EventArgs.Empty); + } break; case XEventName.EnterNotify: @@ -1291,15 +1352,15 @@ namespace OpenTK.Platform.X11 public bool CursorVisible { - get { return true; } // Not used + get { return cursor_visible; } set { if (value) { using (new XLock(window.Display)) { - Functions.XUngrabPointer(window.Display, IntPtr.Zero); Functions.XUndefineCursor(window.Display, window.WindowHandle); + cursor_visible = true; } } else @@ -1307,11 +1368,7 @@ namespace OpenTK.Platform.X11 using (new XLock(window.Display)) { Functions.XDefineCursor(window.Display, window.WindowHandle, EmptyCursor); - Functions.XGrabPointer(window.Display, window.WindowHandle, true, - EventMask.PointerMotionMask | EventMask.ButtonPressMask | EventMask.ButtonReleaseMask, - GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, window.WindowHandle, IntPtr.Zero, - IntPtr.Zero); - + cursor_visible = false; } } } diff --git a/Source/OpenTK/Platform/X11/X11Mouse.cs b/Source/OpenTK/Platform/X11/X11Mouse.cs index 9dd523c6..0dc3f169 100644 --- a/Source/OpenTK/Platform/X11/X11Mouse.cs +++ b/Source/OpenTK/Platform/X11/X11Mouse.cs @@ -61,6 +61,11 @@ namespace OpenTK.Platform.X11 return new MouseState(); } + public void SetPosition(double x, double y) + { + throw new NotImplementedException(); + } + void WriteBit(MouseButton offset, int enabled) { if (enabled != 0) diff --git a/Source/OpenTK/Platform/X11/XI2Mouse.cs b/Source/OpenTK/Platform/X11/XI2Mouse.cs index 69825805..e1162ecd 100644 --- a/Source/OpenTK/Platform/X11/XI2Mouse.cs +++ b/Source/OpenTK/Platform/X11/XI2Mouse.cs @@ -39,12 +39,22 @@ namespace OpenTK.Platform.X11 { List mice = new List(); Dictionary rawids = new Dictionary(); // maps raw ids to mouse ids - readonly X11WindowInfo window; + internal readonly X11WindowInfo window; static int XIOpCode; static readonly Functions.EventPredicate PredicateImpl = IsEventValid; readonly IntPtr Predicate = Marshal.GetFunctionPointerForDelegate(PredicateImpl); + // Store information on a mouse warp event, so it can be ignored. + struct MouseWarp : IEquatable + { + public MouseWarp(double x, double y) { X = x; Y = y; } + double X, Y; + public bool Equals(MouseWarp warp) { return X == warp.X && Y == warp.Y; } + } + MouseWarp? mouse_warp_event; + int mouse_warp_event_count; + public XI2Mouse() { Debug.WriteLine("Using XI2Mouse."); @@ -65,6 +75,7 @@ namespace OpenTK.Platform.X11 XIEventMasks.RawButtonReleaseMask | XIEventMasks.RawMotionMask)) { Functions.XISelectEvents(window.Display, window.WindowHandle, mask); + Functions.XISelectEvents(window.Display, window.RootWindow, mask); } } @@ -110,8 +121,40 @@ namespace OpenTK.Platform.X11 return new MouseState(); } + public void SetPosition(double x, double y) + { + using (new XLock(window.Display)) + { +// Functions.XIWarpPointer(window.Display, 0, +// IntPtr.Zero, window.RootWindow, 0, 0, 0, 0, x, y); + Functions.XWarpPointer(window.Display, + IntPtr.Zero, window.RootWindow, 0, 0, 0, 0, (int)x, (int)y); + + // Mark the expected warp-event so it can be ignored. + if (mouse_warp_event == null) + mouse_warp_event_count = 0; + mouse_warp_event_count++; + mouse_warp_event = new MouseWarp((int)x, (int)y); + } + + ProcessEvents(); + } + #endregion + bool CheckMouseWarp(double x, double y) + { + // Check if a mouse warp with the specified destination exists. + bool is_warp = + mouse_warp_event.HasValue && + mouse_warp_event.Value.Equals(new MouseWarp((int)x, (int)y)); + + if (is_warp && --mouse_warp_event_count <= 0) + mouse_warp_event = null; + + return is_warp; + } + void ProcessEvents() { while (true) @@ -140,10 +183,21 @@ namespace OpenTK.Platform.X11 switch (raw.evtype) { case XIEventType.RawMotion: + double x = 0, y = 0; if (IsBitSet(raw.valuators.mask, 0)) - state.X += (int)BitConverter.Int64BitsToDouble(Marshal.ReadInt64(raw.raw_values, 0)); + { + x = BitConverter.Int64BitsToDouble(Marshal.ReadInt64(raw.raw_values, 0)); + } if (IsBitSet(raw.valuators.mask, 1)) - state.Y += (int)BitConverter.Int64BitsToDouble(Marshal.ReadInt64(raw.raw_values, 8)); + { + y = BitConverter.Int64BitsToDouble(Marshal.ReadInt64(raw.raw_values, 8)); + } + + if (!CheckMouseWarp(x, y)) + { + state.X += (int)x; + state.Y += (int)y; + } break; case XIEventType.RawButtonPress: From 6d00a1cce34e118db232954b8ed16ed1aa5ccb8d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 23 Nov 2010 19:21:17 +0000 Subject: [PATCH 106/130] * X11Mouse.cs: Added SetPosition() implementation. Added detection of pointer warping and used it to fake relative motion. --- Source/OpenTK/Platform/X11/X11Mouse.cs | 62 +++++++++++++++++++++----- 1 file changed, 51 insertions(+), 11 deletions(-) diff --git a/Source/OpenTK/Platform/X11/X11Mouse.cs b/Source/OpenTK/Platform/X11/X11Mouse.cs index 0dc3f169..ca421449 100644 --- a/Source/OpenTK/Platform/X11/X11Mouse.cs +++ b/Source/OpenTK/Platform/X11/X11Mouse.cs @@ -32,17 +32,31 @@ using OpenTK.Input; namespace OpenTK.Platform.X11 { + // Note: we cannot create a background window to retrieve events, + // because X11 doesn't deliver core pointer events to background + // windows (unless we grab, which will break *everything*). + // The only solution is to poll. + // Note 2: this driver only supports absolute positions. + // Note 3: polling means we cannot ignore move events generated + // through SetPosition. In short, this won't work as expected (we + // simply cannot deliver relative movement through this driver). sealed class X11Mouse : IMouseDriver2 { readonly IntPtr display; + readonly IntPtr root_window; MouseState mouse = new MouseState(); - // Can either attach itself to the specified window or can hook the root window. + // When the mouse warps, "detach" the current location + // from the pointer. + bool mouse_detached; + int mouse_detached_x, mouse_detached_y; + public X11Mouse() { Debug.WriteLine("Using X11Mouse."); mouse.IsConnected = true; display = API.DefaultDisplay; + root_window = Functions.XRootWindow(display, Functions.XDefaultScreen(display)); } public MouseState GetState() @@ -63,7 +77,21 @@ namespace OpenTK.Platform.X11 public void SetPosition(double x, double y) { - throw new NotImplementedException(); + // Update the current location, otherwise the pointer + // may become locked (for instance, if we call + // SetPosition too often, like X11GLNative does). + ProcessEvents(); + + using (new XLock(display)) + { + // Mark the expected warp-event so it can be ignored. + mouse_detached = true; + mouse_detached_x = (int)x; + mouse_detached_y = (int)y; + + Functions.XWarpPointer(display, + IntPtr.Zero, root_window, 0, 0, 0, 0, (int)x, (int)y); + } } void WriteBit(MouseButton offset, int enabled) @@ -82,22 +110,34 @@ namespace OpenTK.Platform.X11 using (new XLock(display)) { - IntPtr window = Functions.XRootWindow(display, Functions.XDefaultScreen(display)); + IntPtr window = root_window; Functions.XQueryPointer(display, window, out root, out child, out root_x, out root_y, out win_x, out win_y, out buttons); - mouse.X = root_x; - mouse.Y = root_y; + if (!mouse_detached) + { + mouse.X = root_x; + mouse.Y = root_y; + } + else + { + mouse.X += (int)root_x - mouse_detached_x; + mouse.Y += (int)root_y - mouse_detached_y; + mouse_detached_x = root_x; + mouse_detached_y = root_y; + } WriteBit(MouseButton.Left, buttons & (int)MouseMask.Button1Mask); WriteBit(MouseButton.Middle, buttons & (int)MouseMask.Button2Mask); WriteBit(MouseButton.Right, buttons & (int)MouseMask.Button3Mask); - // Note: this will never work right. After spending a week on this, I simply don't care - // anymore. If someone can fix it, please do. + // Note: this will never work right, wheel events have a duration of 0 + // (yes, zero). They are impposible to catch via polling. + // After spending a week on this, I simply don't care anymore. + // If someone can fix it, please do. // Note 2: I have tried passively grabbing those buttons - no go (BadAccess). - if ((buttons & (int)MouseMask.Button4Mask) != 0) - mouse.WheelPrecise++; - if ((buttons & (int)MouseMask.Button5Mask) != 0) - mouse.WheelPrecise--; + //if ((buttons & (int)MouseMask.Button4Mask) != 0) + // mouse.WheelPrecise++; + //if ((buttons & (int)MouseMask.Button5Mask) != 0) + // mouse.WheelPrecise--; WriteBit(MouseButton.Button1, buttons & (int)MouseMask.Button6Mask); WriteBit(MouseButton.Button2, buttons & (int)MouseMask.Button7Mask); WriteBit(MouseButton.Button3, buttons & (int)MouseMask.Button8Mask); From ff8e42c77ac8fbac0d7fc9f26c60ef07b34ee236 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 23 Nov 2010 19:21:28 +0000 Subject: [PATCH 107/130] * XI2Mouse.cs: Removed unused code. --- Source/OpenTK/Platform/X11/XI2Mouse.cs | 2 -- 1 file changed, 2 deletions(-) diff --git a/Source/OpenTK/Platform/X11/XI2Mouse.cs b/Source/OpenTK/Platform/X11/XI2Mouse.cs index e1162ecd..1ccf2997 100644 --- a/Source/OpenTK/Platform/X11/XI2Mouse.cs +++ b/Source/OpenTK/Platform/X11/XI2Mouse.cs @@ -125,8 +125,6 @@ namespace OpenTK.Platform.X11 { using (new XLock(window.Display)) { -// Functions.XIWarpPointer(window.Display, 0, -// IntPtr.Zero, window.RootWindow, 0, 0, 0, 0, x, y); Functions.XWarpPointer(window.Display, IntPtr.Zero, window.RootWindow, 0, 0, 0, 0, (int)x, (int)y); From 227c0dc12e8d3c8713cfaf28c2a8ee84d5c2580a Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 23 Nov 2010 19:26:35 +0000 Subject: [PATCH 108/130] * X11Mouse.cs: Updated comments to clarify the capabilities of the driver. --- Source/OpenTK/Platform/X11/X11Mouse.cs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/Source/OpenTK/Platform/X11/X11Mouse.cs b/Source/OpenTK/Platform/X11/X11Mouse.cs index ca421449..7c96545d 100644 --- a/Source/OpenTK/Platform/X11/X11Mouse.cs +++ b/Source/OpenTK/Platform/X11/X11Mouse.cs @@ -36,10 +36,13 @@ namespace OpenTK.Platform.X11 // because X11 doesn't deliver core pointer events to background // windows (unless we grab, which will break *everything*). // The only solution is to poll. - // Note 2: this driver only supports absolute positions. - // Note 3: polling means we cannot ignore move events generated - // through SetPosition. In short, this won't work as expected (we - // simply cannot deliver relative movement through this driver). + // Note 2: this driver only supports absolute positions. Relative motion + // is faked through SetPosition. This is called automatically when + // NativeWindow.CursorVisible = false, otherwise it must be called + // by the user. + // Note 3: this driver cannot drive the mouse wheel reliably. + // See comments in ProcessEvents() for more information. + // (If someone knows of a solution, please tell!) sealed class X11Mouse : IMouseDriver2 { readonly IntPtr display; @@ -134,6 +137,7 @@ namespace OpenTK.Platform.X11 // After spending a week on this, I simply don't care anymore. // If someone can fix it, please do. // Note 2: I have tried passively grabbing those buttons - no go (BadAccess). + // Maybe I am doing something wrong with the grab. //if ((buttons & (int)MouseMask.Button4Mask) != 0) // mouse.WheelPrecise++; //if ((buttons & (int)MouseMask.Button5Mask) != 0) From d408fd54ce97ae9cc27a4e306a517f6e8aef3139 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 23 Nov 2010 22:08:53 +0000 Subject: [PATCH 109/130] Avoid loading Wgl entry points automatically. This is now explicitly done through WinGLContext. --- Source/OpenTK/Platform/Windows/WglHelper.cs | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/WglHelper.cs b/Source/OpenTK/Platform/Windows/WglHelper.cs index dbdd4dfb..46231aca 100644 --- a/Source/OpenTK/Platform/Windows/WglHelper.cs +++ b/Source/OpenTK/Platform/Windows/WglHelper.cs @@ -24,9 +24,9 @@ namespace OpenTK.Platform.Windows delegatesClass = wglClass.GetNestedType("Delegates", BindingFlags.Static | BindingFlags.NonPublic); importsClass = wglClass.GetNestedType("Imports", BindingFlags.Static | BindingFlags.NonPublic); - // Ensure core entry points are ready prior to accessing any method. - // Resolves bug [#993]: "Possible bug in GraphicsContext.CreateDummyContext()" - LoadAll(); + //// Ensure core entry points are ready prior to accessing any method. + //// Resolves bug [#993]: "Possible bug in GraphicsContext.CreateDummyContext()" + //LoadAll(); } #endregion @@ -42,6 +42,8 @@ namespace OpenTK.Platform.Windows private static bool rebuildExtensionList = true; + static readonly object SyncRoot = new object(); + #endregion #region static Delegate LoadDelegate(string name, Type signature) @@ -108,7 +110,10 @@ namespace OpenTK.Platform.Windows /// public static void LoadAll() { - OpenTK.Platform.Utilities.LoadExtensions(typeof(Wgl)); + lock (SyncRoot) + { + OpenTK.Platform.Utilities.LoadExtensions(typeof(Wgl)); + } } #endregion From 4f041bca92ef4581b8ce1707721d1b2d967f1d73 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 23 Nov 2010 22:10:49 +0000 Subject: [PATCH 110/130] [Win32] Implemented Mouse.SetPosition via SetCursorPos. This was refreshingly simple, the function works exactly as expected! (unlike XWarpPointer on X11) --- Source/OpenTK/Platform/Windows/API.cs | 3 +++ Source/OpenTK/Platform/Windows/WMInput.cs | 2 +- Source/OpenTK/Platform/Windows/WinRawMouse.cs | 2 +- 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/Source/OpenTK/Platform/Windows/API.cs b/Source/OpenTK/Platform/Windows/API.cs index 96c3de9f..97b4115b 100644 --- a/Source/OpenTK/Platform/Windows/API.cs +++ b/Source/OpenTK/Platform/Windows/API.cs @@ -971,6 +971,9 @@ namespace OpenTK.Platform.Windows [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)] public static extern bool ClipCursor(IntPtr rcClip); + [DllImport("user32.dll")] + public static extern bool SetCursorPos(int X, int Y); + #region Async input #region GetCursorPos diff --git a/Source/OpenTK/Platform/Windows/WMInput.cs b/Source/OpenTK/Platform/Windows/WMInput.cs index 692ef491..e512204f 100644 --- a/Source/OpenTK/Platform/Windows/WMInput.cs +++ b/Source/OpenTK/Platform/Windows/WMInput.cs @@ -139,7 +139,7 @@ namespace OpenTK.Platform.Windows public void SetPosition(double x, double y) { - throw new NotImplementedException(); + Functions.SetCursorPos((int)x, (int)y); } #endregion diff --git a/Source/OpenTK/Platform/Windows/WinRawMouse.cs b/Source/OpenTK/Platform/Windows/WinRawMouse.cs index 4d6ade4f..38e8a371 100644 --- a/Source/OpenTK/Platform/Windows/WinRawMouse.cs +++ b/Source/OpenTK/Platform/Windows/WinRawMouse.cs @@ -280,7 +280,7 @@ namespace OpenTK.Platform.Windows public void SetPosition(double x, double y) { - throw new NotImplementedException(); + Functions.SetCursorPos((int)x, (int)y); } #endregion From 7a83b5decbbf736985949a258dca2a97e60c25ae Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 24 Nov 2010 00:55:19 +0000 Subject: [PATCH 111/130] * MacOSGraphicsMode.cs: * CarbonBindings/Agl.cs: Added AGL-based GraphicsMode detection on Mac OS X. Fixes issue [#1679]: "GraphicsMode returns hardcoded mode on Mac OS X". --- .../Platform/MacOS/CarbonBindings/Agl.cs | 2 +- .../Platform/MacOS/MacOSGraphicsMode.cs | 149 +++++++++++++++++- 2 files changed, 142 insertions(+), 9 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/Agl.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/Agl.cs index 22b819df..ad837571 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/Agl.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/Agl.cs @@ -297,7 +297,7 @@ namespace OpenTK.Platform.MacOS [DllImport(agl)] internal static extern AGLPixelFormat aglChoosePixelFormat(IntPtr gdevs, int ndev, int []attribs); [DllImport(agl)] internal static extern void aglDestroyPixelFormat(AGLPixelFormat pix); [DllImport(agl)] internal static extern AGLPixelFormat aglNextPixelFormat(AGLPixelFormat pix); - [DllImport(agl)] static extern byte aglDescribePixelFormat(AGLPixelFormat pix, int attrib, out int value); + [DllImport(agl)] internal static extern bool aglDescribePixelFormat(AGLPixelFormat pix, PixelFormatAttribute attrib, out int value); [Obsolete("Use aglDisplaysOfPixelFormat instead.")] [DllImport(agl)] static extern AGLDevice *aglDevicesOfPixelFormat(AGLPixelFormat pix, int *ndevs); diff --git a/Source/OpenTK/Platform/MacOS/MacOSGraphicsMode.cs b/Source/OpenTK/Platform/MacOS/MacOSGraphicsMode.cs index c49d3401..28d49f2b 100644 --- a/Source/OpenTK/Platform/MacOS/MacOSGraphicsMode.cs +++ b/Source/OpenTK/Platform/MacOS/MacOSGraphicsMode.cs @@ -1,24 +1,157 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + using System; using System.Collections.Generic; +using System.Diagnostics; using System.Text; +using OpenTK.Graphics; namespace OpenTK.Platform.MacOS { - using Graphics; + using Carbon; class MacOSGraphicsMode : IGraphicsMode { #region IGraphicsMode Members - public GraphicsMode SelectGraphicsMode(ColorFormat color, int depth, int stencil, int samples, ColorFormat accum, int buffers, bool stereo) + public GraphicsMode SelectGraphicsMode(ColorFormat color, int depth, int stencil, + int samples, ColorFormat accum, int buffers, bool stereo) { - GraphicsMode gfx = new GraphicsMode((IntPtr)1, color, depth, stencil, samples, accum, buffers, stereo); - - System.Diagnostics.Debug.Print("Created dummy graphics mode."); - - return gfx; + IntPtr pixelformat = SelectPixelFormat(color, depth, stencil, samples, accum, buffers, stereo); + return GetGraphicsModeFromPixelFormat(pixelformat); } - + + #endregion + + #region Private Members + + GraphicsMode GetGraphicsModeFromPixelFormat(IntPtr pixelformat) + { + int r, g, b, a; + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_RED_SIZE, out r); + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_GREEN_SIZE, out g); + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_BLUE_SIZE, out b); + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_ALPHA_SIZE, out a); + int ar, ag, ab, aa; + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_ACCUM_ALPHA_SIZE, out aa); + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_ACCUM_RED_SIZE, out ar); + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_ACCUM_GREEN_SIZE, out ag); + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_ACCUM_BLUE_SIZE, out ab); + int depth, stencil, samples, buffers, stereo; + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_DEPTH_SIZE, out depth); + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_STENCIL_SIZE, out stencil); + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_SAMPLES_ARB, out samples); + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_DOUBLEBUFFER, out buffers); + Agl.aglDescribePixelFormat(pixelformat, Agl.PixelFormatAttribute.AGL_STEREO, out stereo); + + return new GraphicsMode(pixelformat, new ColorFormat(r, g, b, a), + depth, stencil, samples, new ColorFormat(ar, ag, ab, aa), buffers + 1, stereo != 0); + } + + IntPtr SelectPixelFormat(ColorFormat color, int depth, int stencil, int samples, + ColorFormat accum, int buffers, bool stereo) + { + List attribs = new List(); + + Debug.Print("Bits per pixel: {0}", color.BitsPerPixel); + + if (color.BitsPerPixel > 0) + { + if (!color.IsIndexed) + { + attribs.Add((int)Agl.PixelFormatAttribute.AGL_RGBA); + } + attribs.Add((int)Agl.PixelFormatAttribute.AGL_RED_SIZE); + attribs.Add(color.Red); + attribs.Add((int)Agl.PixelFormatAttribute.AGL_GREEN_SIZE); + attribs.Add(color.Green); + attribs.Add((int)Agl.PixelFormatAttribute.AGL_BLUE_SIZE); + attribs.Add(color.Blue); + attribs.Add((int)Agl.PixelFormatAttribute.AGL_ALPHA_SIZE); + attribs.Add(color.Alpha); + } + + Debug.Print("Depth: {0}", depth); + + if (depth > 0) + { + attribs.Add((int)Agl.PixelFormatAttribute.AGL_DEPTH_SIZE); + attribs.Add(depth); + } + + if (buffers > 1) + { + attribs.Add((int)Agl.PixelFormatAttribute.AGL_DOUBLEBUFFER); + } + + if (stencil > 1) + { + attribs.Add((int)Agl.PixelFormatAttribute.AGL_STENCIL_SIZE); + attribs.Add(stencil); + } + + if (accum.BitsPerPixel > 0) + { + attribs.Add((int)Agl.PixelFormatAttribute.AGL_ACCUM_ALPHA_SIZE); + attribs.Add(accum.Alpha); + attribs.Add((int)Agl.PixelFormatAttribute.AGL_ACCUM_BLUE_SIZE); + attribs.Add(accum.Blue); + attribs.Add((int)Agl.PixelFormatAttribute.AGL_ACCUM_GREEN_SIZE); + attribs.Add(accum.Green); + attribs.Add((int)Agl.PixelFormatAttribute.AGL_ACCUM_RED_SIZE); + attribs.Add(accum.Red); + } + + if (samples > 0) + { + attribs.Add((int)Agl.PixelFormatAttribute.AGL_SAMPLE_BUFFERS_ARB); + attribs.Add(1); + attribs.Add((int)Agl.PixelFormatAttribute.AGL_SAMPLES_ARB); + attribs.Add(samples); + } + + if (stereo) + { + attribs.Add((int)Agl.PixelFormatAttribute.AGL_STEREO); + } + + attribs.Add(0); + attribs.Add(0); + + IntPtr pixelformat = Agl.aglChoosePixelFormat(IntPtr.Zero, 0, attribs.ToArray()); + if (pixelformat == IntPtr.Zero) + { + throw new GraphicsModeException(String.Format( + "[Error] Failed to select GraphicsMode, error {0}.", Agl.GetError())); + } + return pixelformat; + } + #endregion } } From 6a4b41d9758e29c435686e60621efca505537e26 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 24 Nov 2010 12:50:08 +0000 Subject: [PATCH 112/130] Device discovery now works correctly. Added support for input value callbacks. --- .../MacOS/CarbonBindings/CoreFoundation.cs | 14 ++++ Source/OpenTK/Platform/MacOS/HIDInput.cs | 72 ++++++++++++++++--- 2 files changed, 75 insertions(+), 11 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs index a2c9ba93..08ea695f 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs @@ -115,7 +115,21 @@ namespace OpenTK.Platform.MacOS.Carbon kCFNumberMaxType = 16 }; + public enum CFRunLoopExitReason + { + Finished = 1, + Stopped = 2, + TimedOut = 3, + HandledSource = 4 + } + + public static readonly IntPtr RunLoopModeDefault = CF.CFSTR("kCFRunLoopDefaultMode"); + [DllImport(appServices)] internal static extern CFRunLoop CFRunLoopGetCurrent(); + + [DllImport(appServices)] + internal static extern CFRunLoopExitReason CFRunLoopRunInMode( + IntPtr cfstrMode, double interval, bool returnAfterSourceHandled); } } diff --git a/Source/OpenTK/Platform/MacOS/HIDInput.cs b/Source/OpenTK/Platform/MacOS/HIDInput.cs index 6e8a6038..9c33ea53 100755 --- a/Source/OpenTK/Platform/MacOS/HIDInput.cs +++ b/Source/OpenTK/Platform/MacOS/HIDInput.cs @@ -40,6 +40,7 @@ namespace OpenTK.Platform.MacOS using CFString = System.IntPtr; using IOHIDDeviceRef = System.IntPtr; using IOHIDManagerRef = System.IntPtr; + using IOHIDValueRef = System.IntPtr; using IOOptionBits = System.IntPtr; using IOReturn = System.IntPtr; @@ -48,17 +49,36 @@ namespace OpenTK.Platform.MacOS #region Fields readonly IOHIDManagerRef hidmanager; - readonly static NativeMethods.IOHIDDeviceCallback HandleDeviceAdded = delegate - { - Debug.WriteLine("Device added"); - }; - readonly static NativeMethods.IOHIDDeviceCallback HandleDeviceRemoved = delegate - { - Debug.WriteLine("Device Removed"); - }; - readonly static CFString RunLoopMode = CF.CFSTR("OPENTK_INPUT"); + readonly static CFString InputLoopMode = CF.CFSTR("opentkRunLoopCheckDevicesMode"); readonly static CFDictionary DeviceTypes = new CFDictionary(); + readonly static NativeMethods.IOHIDDeviceCallback HandleDeviceAdded = delegate( + IntPtr context, IOReturn res, IntPtr sender, IOHIDDeviceRef device) + { + Debug.Print("Device {0} discovered", device); + + // IOReturn.Zero is kIOReturnSuccess + if (NativeMethods.IOHIDDeviceOpen(device, IOOptionBits.Zero) == IOReturn.Zero) + { + Debug.Print("Device {0} connected", device); + + NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, HandleValue, IntPtr.Zero); + NativeMethods.IOHIDDeviceScheduleWithRunLoop(device, CF.CFRunLoopGetCurrent(), InputLoopMode); + } + }; + readonly static NativeMethods.IOHIDDeviceCallback HandleDeviceRemoved = delegate( + IntPtr context, IOReturn res, IntPtr sender, IOHIDDeviceRef device) + { + Debug.Print("Device {0} disconnected", device); + NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, null, IntPtr.Zero); + NativeMethods.IOHIDDeviceScheduleWithRunLoop(device, IntPtr.Zero, IntPtr.Zero); + }; + readonly static NativeMethods.IOHIDValueCallback HandleValue = delegate( + IntPtr context, IOReturn res, IntPtr sender, IOHIDValueRef device) + { + + }; + #endregion #region Constructors @@ -80,19 +100,27 @@ namespace OpenTK.Platform.MacOS return NativeMethods.IOHIDManagerCreate(IntPtr.Zero, IntPtr.Zero); } + // Registers callbacks for device addition and removal. These callbacks + // are called when we run the loop in CheckDevicesMode static void RegisterHIDCallbacks(IOHIDManagerRef hidmanager) { - CFRunLoop runloop = Carbon.CF.CFRunLoopGetCurrent(); + CFRunLoop runloop = CF.CFRunLoopGetCurrent(); NativeMethods.IOHIDManagerRegisterDeviceMatchingCallback( hidmanager, HandleDeviceAdded, IntPtr.Zero); NativeMethods.IOHIDManagerRegisterDeviceRemovalCallback( hidmanager, HandleDeviceRemoved, IntPtr.Zero); NativeMethods.IOHIDManagerScheduleWithRunLoop(hidmanager, - runloop, RunLoopMode); + runloop, InputLoopMode); NativeMethods.IOHIDManagerSetDeviceMatching(hidmanager, DeviceTypes.Ref); NativeMethods.IOHIDManagerOpen(hidmanager, IOOptionBits.Zero); + + while (CF.CFRunLoopRunInMode(InputLoopMode, 0, true) == + CF.CFRunLoopExitReason.HandledSource) + { + // Do nothing. The real work is done in the Handle* callbacks above. + } } #endregion @@ -109,6 +137,10 @@ namespace OpenTK.Platform.MacOS return new MouseState(); } + public void SetPosition(double x, double y) + { + } + #endregion #region NativeMethods @@ -151,8 +183,26 @@ namespace OpenTK.Platform.MacOS IOHIDManagerRef manager, IOOptionBits options) ; + [DllImport(hid)] + public static extern IOReturn IOHIDDeviceOpen( + IOHIDDeviceRef manager, + IOOptionBits opts); + + [DllImport(hid)] + public static extern void IOHIDDeviceRegisterInputValueCallback( + IOHIDDeviceRef device, + IOHIDValueCallback callback, + IntPtr context); + + [DllImport(hid)] + public static extern void IOHIDDeviceScheduleWithRunLoop( + IOHIDDeviceRef device, + CFRunLoop inCFRunLoop, + CFString inCFRunLoopMode); + public delegate void IOHIDDeviceCallback(IntPtr ctx, IOReturn res, IntPtr sender, IOHIDDeviceRef device); + public delegate void IOHIDValueCallback(IntPtr ctx, IOReturn res, IntPtr sender, IOHIDValueRef val); } #endregion From 898315a58fac8e9258f6a10b4e7f1f8eb3434fb2 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 24 Nov 2010 13:13:14 +0000 Subject: [PATCH 113/130] Use main run loop for input callbacks. This way we don't have to run the loop ourselves. Unregister callbacks for removed devices. --- .../MacOS/CarbonBindings/CoreFoundation.cs | 3 +++ Source/OpenTK/Platform/MacOS/HIDInput.cs | 25 ++++++++----------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs index 08ea695f..451103ff 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs @@ -128,6 +128,9 @@ namespace OpenTK.Platform.MacOS.Carbon [DllImport(appServices)] internal static extern CFRunLoop CFRunLoopGetCurrent(); + [DllImport(appServices)] + internal static extern CFRunLoop CFRunLoopGetMain(); + [DllImport(appServices)] internal static extern CFRunLoopExitReason CFRunLoopRunInMode( IntPtr cfstrMode, double interval, bool returnAfterSourceHandled); diff --git a/Source/OpenTK/Platform/MacOS/HIDInput.cs b/Source/OpenTK/Platform/MacOS/HIDInput.cs index 9c33ea53..292ac438 100755 --- a/Source/OpenTK/Platform/MacOS/HIDInput.cs +++ b/Source/OpenTK/Platform/MacOS/HIDInput.cs @@ -49,7 +49,11 @@ namespace OpenTK.Platform.MacOS #region Fields readonly IOHIDManagerRef hidmanager; - readonly static CFString InputLoopMode = CF.CFSTR("opentkRunLoopCheckDevicesMode"); + //readonly static CFRunLoop RunLoop = CF.CFRunLoopGetCurrent(); + //readonly static CFString InputLoopMode = CF.CFSTR("opentkInputMode"); + + readonly static CFRunLoop RunLoop = CF.CFRunLoopGetMain(); + readonly static CFString InputLoopMode = CF.RunLoopModeDefault; readonly static CFDictionary DeviceTypes = new CFDictionary(); readonly static NativeMethods.IOHIDDeviceCallback HandleDeviceAdded = delegate( @@ -63,7 +67,8 @@ namespace OpenTK.Platform.MacOS Debug.Print("Device {0} connected", device); NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, HandleValue, IntPtr.Zero); - NativeMethods.IOHIDDeviceScheduleWithRunLoop(device, CF.CFRunLoopGetCurrent(), InputLoopMode); + NativeMethods.IOHIDDeviceScheduleWithRunLoop(device, + RunLoop, InputLoopMode); } }; readonly static NativeMethods.IOHIDDeviceCallback HandleDeviceRemoved = delegate( @@ -71,12 +76,12 @@ namespace OpenTK.Platform.MacOS { Debug.Print("Device {0} disconnected", device); NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, null, IntPtr.Zero); - NativeMethods.IOHIDDeviceScheduleWithRunLoop(device, IntPtr.Zero, IntPtr.Zero); + //NativeMethods.IOHIDDeviceScheduleWithRunLoop(device, IntPtr.Zero, IntPtr.Zero); }; readonly static NativeMethods.IOHIDValueCallback HandleValue = delegate( - IntPtr context, IOReturn res, IntPtr sender, IOHIDValueRef device) + IntPtr context, IOReturn res, IntPtr sender, IOHIDValueRef val) { - + Debug.Print("Value {0}:{1} received", sender, val); }; #endregion @@ -104,23 +109,15 @@ namespace OpenTK.Platform.MacOS // are called when we run the loop in CheckDevicesMode static void RegisterHIDCallbacks(IOHIDManagerRef hidmanager) { - CFRunLoop runloop = CF.CFRunLoopGetCurrent(); - NativeMethods.IOHIDManagerRegisterDeviceMatchingCallback( hidmanager, HandleDeviceAdded, IntPtr.Zero); NativeMethods.IOHIDManagerRegisterDeviceRemovalCallback( hidmanager, HandleDeviceRemoved, IntPtr.Zero); NativeMethods.IOHIDManagerScheduleWithRunLoop(hidmanager, - runloop, InputLoopMode); + RunLoop, InputLoopMode); NativeMethods.IOHIDManagerSetDeviceMatching(hidmanager, DeviceTypes.Ref); NativeMethods.IOHIDManagerOpen(hidmanager, IOOptionBits.Zero); - - while (CF.CFRunLoopRunInMode(InputLoopMode, 0, true) == - CF.CFRunLoopExitReason.HandledSource) - { - // Do nothing. The real work is done in the Handle* callbacks above. - } } #endregion From 3ec54fce34ab569b1c9c7560a5a2409bb98af5de Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 24 Nov 2010 18:08:20 +0000 Subject: [PATCH 114/130] * ExampleBrowser.cs: Do not crash if Source directory is not found. --- Source/Examples/ExampleBrowser.cs | 99 +++++++++++++++++++------------ 1 file changed, 61 insertions(+), 38 deletions(-) diff --git a/Source/Examples/ExampleBrowser.cs b/Source/Examples/ExampleBrowser.cs index 7d4bf59c..97ef206b 100644 --- a/Source/Examples/ExampleBrowser.cs +++ b/Source/Examples/ExampleBrowser.cs @@ -42,10 +42,8 @@ namespace Examples #region Fields //PrivateFontCollection font_collection = new PrivateFontCollection(); - bool show_warning = true; - - static readonly string SourcePath = FindSourcePath(); + readonly string SourcePath; #endregion @@ -53,6 +51,10 @@ namespace Examples public ExampleBrowser() { + SourcePath = + FindSourcePath(Directory.GetCurrentDirectory()) ?? + FindSourcePath(Assembly.GetExecutingAssembly().Location); + Font = SystemFonts.DialogFont; InitializeComponent(); @@ -121,7 +123,8 @@ namespace Examples const string no_docs = "Documentation has not been entered."; const string no_source = "Source code has not been entered."; - if (e.Node.Tag != null && !String.IsNullOrEmpty(((ExampleInfo)e.Node.Tag).Attribute.Documentation)) + if (SourcePath != null && e.Node.Tag != null && + !String.IsNullOrEmpty(((ExampleInfo)e.Node.Tag).Attribute.Documentation)) { string docs = null; string source = null; @@ -358,7 +361,10 @@ namespace Examples MethodInfo main = e.Example.GetMethod("Main", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) ?? - e.Example.GetMethod("Main", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(object), typeof(object) }, null); + e.Example.GetMethod("Main", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { + typeof(object), + typeof(object) + }, null); if (main != null) { try @@ -371,31 +377,13 @@ namespace Examples Trace.WriteLine(String.Format("Launching sample: \"{0}\"", e.Attribute.Title)); Trace.WriteLine(String.Empty); - Thread thread = new Thread((ThreadStart)delegate - { - try - { - main.Invoke(null, null); - } - catch (TargetInvocationException expt) - { - string ex_info; - if (expt.InnerException != null) - ex_info = expt.InnerException.ToString(); - else - ex_info = expt.ToString(); - MessageBox.Show(ex_info, "An OpenTK example encountered an error.", MessageBoxButtons.OK, MessageBoxIcon.Warning); + AppDomain sandbox = AppDomain.CreateDomain("Sandbox"); + sandbox.DomainUnload += HandleSandboxDomainUnload; - Debug.Print(expt.ToString()); - } - catch (NullReferenceException expt) - { - MessageBox.Show(expt.ToString(), "The Example launcher failed to load the example.", MessageBoxButtons.OK, MessageBoxIcon.Warning); - } - }); - thread.IsBackground = true; - thread.Start(); - thread.Join(); + SampleRunner runner = new SampleRunner(main); + CrossAppDomainDelegate cross = new CrossAppDomainDelegate(runner.Invoke); + sandbox.DoCallBack(cross); + AppDomain.Unload(sandbox); } finally { @@ -412,31 +400,66 @@ namespace Examples } } - // Tries to detect the path that contains the source for the examples. - static string FindSourcePath() + static void HandleSandboxDomainUnload(object sender, EventArgs e) { - string current_dir = Directory.GetCurrentDirectory(); + AppDomain sandbox = (AppDomain)sender; + sandbox.DomainUnload -= HandleSandboxDomainUnload; + } + [Serializable] + class SampleRunner + { + MethodInfo _main; + + public SampleRunner(MethodInfo main) + { + _main = main; + } + + public void Invoke() + { + try + { + _main.Invoke(null, null); + } + catch (TargetInvocationException expt) + { + string ex_info; + if (expt.InnerException != null) + ex_info = expt.InnerException.ToString(); + else + ex_info = expt.ToString(); + //MessageBox.Show(ex_info, "An OpenTK example encountered an error.", MessageBoxButtons.OK, MessageBoxIcon.Warning); + + Trace.WriteLine(ex_info.ToString()); + } + catch (Exception expt) + { + Trace.WriteLine(expt.ToString()); + } + } + } + + // Tries to detect the path that contains the source for the examples. + static string FindSourcePath(string guess) + { // Typically, our working directory is either "[opentk]/Binaries/OpenTK/[config]" or "[opentk]". // The desired source path is "[opentk]/Source/Examples/[ExampleCategory]" - - string guess = current_dir; if (CheckPath(ref guess)) return guess; // We were in [opentk] after all - guess = current_dir; for (int i = 0; i < 3; i++) { DirectoryInfo dir = Directory.GetParent(guess); - if (!dir.Exists) + if (dir == null || !dir.Exists) break; guess = dir.FullName; } - + if (CheckPath(ref guess)) return guess; // We were in [opentk]/Binaries/OpenTK/[config] after all - throw new DirectoryNotFoundException(); + return null; } static bool CheckPath(ref string path) From 28a66006191c9e56e07c26e5d8155f553252fec4 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 24 Nov 2010 18:11:01 +0000 Subject: [PATCH 115/130] * ExampleBrowser.cs: Correctly use the assembly location to locate the Source directory. --- Source/Examples/ExampleBrowser.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Source/Examples/ExampleBrowser.cs b/Source/Examples/ExampleBrowser.cs index 97ef206b..4e82d33e 100644 --- a/Source/Examples/ExampleBrowser.cs +++ b/Source/Examples/ExampleBrowser.cs @@ -443,6 +443,8 @@ namespace Examples // Tries to detect the path that contains the source for the examples. static string FindSourcePath(string guess) { + guess = Path.GetDirectoryName(guess); + // Typically, our working directory is either "[opentk]/Binaries/OpenTK/[config]" or "[opentk]". // The desired source path is "[opentk]/Source/Examples/[ExampleCategory]" if (CheckPath(ref guess)) From 4bc0db1d10be8cfcda675b61191eb76eb123dbca Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 24 Nov 2010 20:50:47 +0000 Subject: [PATCH 116/130] Updated documentation on Vector4(Vector3) constructor to state that the w component is initialized to 0. --- Source/OpenTK/Math/Vector4.cs | 2 ++ Source/OpenTK/Math/Vector4d.cs | 2 ++ 2 files changed, 4 insertions(+) diff --git a/Source/OpenTK/Math/Vector4.cs b/Source/OpenTK/Math/Vector4.cs index 29d771bd..fb850172 100644 --- a/Source/OpenTK/Math/Vector4.cs +++ b/Source/OpenTK/Math/Vector4.cs @@ -137,8 +137,10 @@ namespace OpenTK /// /// Constructs a new Vector4 from the given Vector3. + /// The w component is initialized to 0. /// /// The Vector3 to copy components from. + /// public Vector4(Vector3 v) { X = v.X; diff --git a/Source/OpenTK/Math/Vector4d.cs b/Source/OpenTK/Math/Vector4d.cs index 14bd402a..95eec840 100644 --- a/Source/OpenTK/Math/Vector4d.cs +++ b/Source/OpenTK/Math/Vector4d.cs @@ -135,8 +135,10 @@ namespace OpenTK /// /// Constructs a new Vector4d from the given Vector3d. + /// The w component is initialized to 0. /// /// The Vector3d to copy components from. + /// public Vector4d(Vector3d v) { X = v.X; From 9c8247c13a93dad5515e8504097aa12256f8d7e9 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 24 Nov 2010 21:15:38 +0000 Subject: [PATCH 117/130] * Vector4.cs: Fixed doc comment to refer to the single-precision version of the structure, rather than the double-precision one. --- Source/OpenTK/Math/Vector4.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/OpenTK/Math/Vector4.cs b/Source/OpenTK/Math/Vector4.cs index fb850172..384fdf74 100644 --- a/Source/OpenTK/Math/Vector4.cs +++ b/Source/OpenTK/Math/Vector4.cs @@ -140,7 +140,7 @@ namespace OpenTK /// The w component is initialized to 0. /// /// The Vector3 to copy components from. - /// + /// public Vector4(Vector3 v) { X = v.X; From 5caf6204de2033135e65b774cec44e9f66ebd72e Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Wed, 24 Nov 2010 23:49:40 +0000 Subject: [PATCH 118/130] Implemented new multi-mouse API on Mac OS X. --- Source/OpenTK/IntPtrEqualityComparer.cs | 49 ++++ Source/OpenTK/OpenTK.csproj | 3 + Source/OpenTK/Platform/MacOS/HIDInput.cs | 301 ++++++++++++++++++++--- 3 files changed, 319 insertions(+), 34 deletions(-) create mode 100755 Source/OpenTK/IntPtrEqualityComparer.cs diff --git a/Source/OpenTK/IntPtrEqualityComparer.cs b/Source/OpenTK/IntPtrEqualityComparer.cs new file mode 100755 index 00000000..6ddb2472 --- /dev/null +++ b/Source/OpenTK/IntPtrEqualityComparer.cs @@ -0,0 +1,49 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +using System; +using System.Collections.Generic; + +namespace OpenTK +{ + // Simple equality comparer to allow IntPtrs as keys in dictionaries + // without causing boxing/garbage generation. + // Seriously, Microsoft, shouldn't this have been in the BCL out of the box? + class IntPtrEqualityComparer : IEqualityComparer + { + public bool Equals(IntPtr x, IntPtr y) + { + return x == y; + } + + public int GetHashCode(IntPtr obj) + { + return obj.GetHashCode(); + } + } +} + diff --git a/Source/OpenTK/OpenTK.csproj b/Source/OpenTK/OpenTK.csproj index 1db398dc..9cd3f603 100644 --- a/Source/OpenTK/OpenTK.csproj +++ b/Source/OpenTK/OpenTK.csproj @@ -57,6 +57,7 @@ 4 AllRules.ruleset full + true true @@ -80,6 +81,7 @@ 4 true TRACE; + true true @@ -766,6 +768,7 @@ Always + diff --git a/Source/OpenTK/Platform/MacOS/HIDInput.cs b/Source/OpenTK/Platform/MacOS/HIDInput.cs index 292ac438..dabcc218 100755 --- a/Source/OpenTK/Platform/MacOS/HIDInput.cs +++ b/Source/OpenTK/Platform/MacOS/HIDInput.cs @@ -36,9 +36,13 @@ namespace OpenTK.Platform.MacOS using Carbon; using CFAllocatorRef = System.IntPtr; using CFDictionaryRef = System.IntPtr; + using CFIndex = System.IntPtr; using CFRunLoop = System.IntPtr; using CFString = System.IntPtr; + using CFStringRef = System.IntPtr; // Here used interchangeably with the CFString + using CFTypeRef = System.IntPtr; using IOHIDDeviceRef = System.IntPtr; + using IOHIDElementRef = System.IntPtr; using IOHIDManagerRef = System.IntPtr; using IOHIDValueRef = System.IntPtr; using IOOptionBits = System.IntPtr; @@ -49,40 +53,19 @@ namespace OpenTK.Platform.MacOS #region Fields readonly IOHIDManagerRef hidmanager; - //readonly static CFRunLoop RunLoop = CF.CFRunLoopGetCurrent(); - //readonly static CFString InputLoopMode = CF.CFSTR("opentkInputMode"); - readonly static CFRunLoop RunLoop = CF.CFRunLoopGetMain(); - readonly static CFString InputLoopMode = CF.RunLoopModeDefault; - readonly static CFDictionary DeviceTypes = new CFDictionary(); + readonly Dictionary MouseDevices = + new Dictionary(new IntPtrEqualityComparer()); + readonly Dictionary MouseIndexToDevice = + new Dictionary(); - readonly static NativeMethods.IOHIDDeviceCallback HandleDeviceAdded = delegate( - IntPtr context, IOReturn res, IntPtr sender, IOHIDDeviceRef device) - { - Debug.Print("Device {0} discovered", device); + readonly CFRunLoop RunLoop = CF.CFRunLoopGetMain(); + readonly CFString InputLoopMode = CF.RunLoopModeDefault; + readonly CFDictionary DeviceTypes = new CFDictionary(); - // IOReturn.Zero is kIOReturnSuccess - if (NativeMethods.IOHIDDeviceOpen(device, IOOptionBits.Zero) == IOReturn.Zero) - { - Debug.Print("Device {0} connected", device); - - NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, HandleValue, IntPtr.Zero); - NativeMethods.IOHIDDeviceScheduleWithRunLoop(device, - RunLoop, InputLoopMode); - } - }; - readonly static NativeMethods.IOHIDDeviceCallback HandleDeviceRemoved = delegate( - IntPtr context, IOReturn res, IntPtr sender, IOHIDDeviceRef device) - { - Debug.Print("Device {0} disconnected", device); - NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, null, IntPtr.Zero); - //NativeMethods.IOHIDDeviceScheduleWithRunLoop(device, IntPtr.Zero, IntPtr.Zero); - }; - readonly static NativeMethods.IOHIDValueCallback HandleValue = delegate( - IntPtr context, IOReturn res, IntPtr sender, IOHIDValueRef val) - { - Debug.Print("Value {0}:{1} received", sender, val); - }; + readonly NativeMethods.IOHIDDeviceCallback HandleDeviceAdded; + readonly NativeMethods.IOHIDDeviceCallback HandleDeviceRemoved; + readonly NativeMethods.IOHIDValueCallback HandleDeviceValueReceived; #endregion @@ -92,6 +75,10 @@ namespace OpenTK.Platform.MacOS { Debug.Print("Using {0}.", typeof(HIDInput).Name); + HandleDeviceAdded = DeviceAdded; + HandleDeviceRemoved = DeviceRemoved; + HandleDeviceValueReceived = DeviceValueReceived; + hidmanager = CreateHIDManager(); RegisterHIDCallbacks(hidmanager); } @@ -100,14 +87,14 @@ namespace OpenTK.Platform.MacOS #region Private Members - static IOHIDManagerRef CreateHIDManager() + IOHIDManagerRef CreateHIDManager() { return NativeMethods.IOHIDManagerCreate(IntPtr.Zero, IntPtr.Zero); } // Registers callbacks for device addition and removal. These callbacks // are called when we run the loop in CheckDevicesMode - static void RegisterHIDCallbacks(IOHIDManagerRef hidmanager) + void RegisterHIDCallbacks(IOHIDManagerRef hidmanager) { NativeMethods.IOHIDManagerRegisterDeviceMatchingCallback( hidmanager, HandleDeviceAdded, IntPtr.Zero); @@ -120,17 +107,113 @@ namespace OpenTK.Platform.MacOS NativeMethods.IOHIDManagerOpen(hidmanager, IOOptionBits.Zero); } + void DeviceAdded(IntPtr context, IOReturn res, IntPtr sender, IOHIDDeviceRef device) + { + Debug.Print("Device {0} discovered", device); + + if (NativeMethods.IOHIDDeviceOpen(device, IOOptionBits.Zero) == IOReturn.Zero) + { + Debug.Print("Device {0} connected", device); + + if (NativeMethods.IOHIDDeviceConformsTo(device, HIDPage.GenericDesktop, (int)HIDUsageGD.Mouse)) + { + MouseState state = new MouseState(); + state.IsConnected = true; + MouseIndexToDevice.Add(MouseDevices.Count, device); + MouseDevices.Add(device, state); + } + + NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, + HandleDeviceValueReceived, IntPtr.Zero); + NativeMethods.IOHIDDeviceScheduleWithRunLoop(device, RunLoop, InputLoopMode); + } + } + + void DeviceRemoved(IntPtr context, IOReturn res, IntPtr sender, IOHIDDeviceRef device) + { + Debug.Print("Device {0} disconnected", device); + + if (NativeMethods.IOHIDDeviceConformsTo(device, HIDPage.GenericDesktop, (int)HIDUsageGD.Mouse) && + MouseDevices.ContainsKey(device)) + { + // Keep the device in case it comes back later on + MouseState state = MouseDevices[device]; + state.IsConnected = false; + MouseDevices[device] = state; + } + + NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, null, IntPtr.Zero); + NativeMethods.IOHIDDeviceUnscheduleWithRunLoop(device, RunLoop, InputLoopMode); + } + + void DeviceValueReceived(IntPtr context, IOReturn res, IntPtr sender, IOHIDValueRef val) + { + MouseState mouse; + if (MouseDevices.TryGetValue(sender, out mouse)) + { + MouseDevices[sender] = UpdateMouse(mouse, val); + } + } + + static MouseState UpdateMouse(MouseState state, IOHIDValueRef val) + { + IOHIDElementRef elem = NativeMethods.IOHIDValueGetElement(val); + int v_int = NativeMethods.IOHIDValueGetIntegerValue(val).ToInt32(); + //double v_physical = NativeMethods.IOHIDValueGetScaledValue(val, IOHIDValueScaleType.Physical); + //double v_calbrated = NativeMethods.IOHIDValueGetScaledValue(val, IOHIDValueScaleType.Calibrated); + HIDPage page = NativeMethods.IOHIDElementGetUsagePage(elem); + int usage = NativeMethods.IOHIDElementGetUsage(elem); + + switch (page) + { + case HIDPage.GenericDesktop: + switch ((HIDUsageGD)usage) + { + case HIDUsageGD.X: + state.X += v_int; + break; + + case HIDUsageGD.Y: + state.Y += v_int; + break; + + case HIDUsageGD.Wheel: + state.WheelPrecise += v_int; + break; + } + break; + + case HIDPage.Button: + state[OpenTK.Input.MouseButton.Left + usage - 1] = v_int == 1; + break; + } + + return state; + } + #endregion #region IMouseDriver2 Members public MouseState GetState() { - return new MouseState(); + MouseState master = new MouseState(); + foreach (KeyValuePair item in MouseDevices) + { + master.MergeBits(item.Value); + } + + return master; } public MouseState GetState(int index) { + IntPtr device; + if (MouseIndexToDevice.TryGetValue(index, out device)) + { + return MouseDevices[device]; + } + return new MouseState(); } @@ -145,6 +228,9 @@ namespace OpenTK.Platform.MacOS class NativeMethods { const string hid = "/System/Library/Frameworks/IOKit.framework/Versions/Current/IOKit"; + public static readonly CFString IOHIDDeviceUsageKey = CF.CFSTR("DeviceUsage"); + public static readonly CFString IOHIDDeviceUsagePageKey = CF.CFSTR("DeviceUsagePage"); + public static readonly CFString IOHIDDeviceUsagePairsKey = CF.CFSTR("DeviceUsagePairs"); [DllImport(hid)] public static extern IOHIDManagerRef IOHIDManagerCreate( @@ -185,6 +271,17 @@ namespace OpenTK.Platform.MacOS IOHIDDeviceRef manager, IOOptionBits opts); + [DllImport(hid)] + public static extern CFTypeRef IOHIDDeviceGetProperty( + IOHIDDeviceRef device, + CFStringRef key); + + [DllImport(hid)] + public static extern bool IOHIDDeviceConformsTo( + IOHIDDeviceRef inIOHIDDeviceRef, // IOHIDDeviceRef for the HID device + HIDPage inUsagePage, // the usage page to test conformance with + int inUsage); // the usage to test conformance with + [DllImport(hid)] public static extern void IOHIDDeviceRegisterInputValueCallback( IOHIDDeviceRef device, @@ -197,11 +294,147 @@ namespace OpenTK.Platform.MacOS CFRunLoop inCFRunLoop, CFString inCFRunLoopMode); + [DllImport(hid)] + public static extern void IOHIDDeviceUnscheduleWithRunLoop( + IOHIDDeviceRef device, + CFRunLoop inCFRunLoop, + CFString inCFRunLoopMode); + + [DllImport(hid)] + public static extern IOHIDElementRef IOHIDValueGetElement(IOHIDValueRef @value); + + [DllImport(hid)] + public static extern CFIndex IOHIDValueGetIntegerValue(IOHIDValueRef @value); + + [DllImport(hid)] + public static extern double IOHIDValueGetScaledValue( + IOHIDValueRef @value, + IOHIDValueScaleType type) ; + + [DllImport(hid)] + public static extern int IOHIDElementGetUsage(IOHIDElementRef elem); + + [DllImport(hid)] + public static extern HIDPage IOHIDElementGetUsagePage(IOHIDElementRef elem); public delegate void IOHIDDeviceCallback(IntPtr ctx, IOReturn res, IntPtr sender, IOHIDDeviceRef device); public delegate void IOHIDValueCallback(IntPtr ctx, IOReturn res, IntPtr sender, IOHIDValueRef val); } + enum IOHIDValueScaleType + { + Physical, // [device min, device max] + Calibrated // [-1, +1] + } + + enum HIDPage + { + Undefined = 0x00, + GenericDesktop = 0x01, + Simulation = 0x02, + VR = 0x03, + Sport = 0x04, + Game = 0x05, + /* Reserved 0x06 */ + KeyboardOrKeypad = 0x07, /* USB Device Class Definition for Human Interface Devices (HID). Note: the usage type for all key codes is Selector (Sel). */ + LEDs = 0x08, + Button = 0x09, + Ordinal = 0x0A, + Telephony = 0x0B, + Consumer = 0x0C, + Digitizer = 0x0D, + /* Reserved 0x0E */ + PID = 0x0F, /* USB Physical Interface Device definitions for force feedback and related devices. */ + Unicode = 0x10, + /* Reserved 0x11 - 0x13 */ + AlphanumericDisplay = 0x14, + /* Reserved 0x15 - 0x7F */ + /* Monitor 0x80 - 0x83 USB Device Class Definition for Monitor Devices */ + /* Power 0x84 - 0x87 USB Device Class Definition for Power Devices */ + PowerDevice = 0x84, /* Power Device Page */ + BatterySystem = 0x85, /* Battery System Page */ + /* Reserved 0x88 - 0x8B */ + BarCodeScanner = 0x8C, /* (Point of Sale) USB Device Class Definition for Bar Code Scanner Devices */ + WeighingDevice = 0x8D, /* (Point of Sale) USB Device Class Definition for Weighing Devices */ + Scale = 0x8D, /* (Point of Sale) USB Device Class Definition for Scale Devices */ + MagneticStripeReader = 0x8E, + /* ReservedPointofSalepages 0x8F */ + CameraControl = 0x90, /* USB Device Class Definition for Image Class Devices */ + Arcade = 0x91, /* OAAF Definitions for arcade and coinop related Devices */ + /* Reserved 0x92 - 0xFEFF */ + /* VendorDefined 0xFF00 - 0xFFFF */ + VendorDefinedStart = 0xFF00 + } + + // Generic desktop usage + enum HIDUsageGD + { + Pointer = 0x01, /* Physical Collection */ + Mouse = 0x02, /* Application Collection */ + /* 0x03 Reserved */ + Joystick = 0x04, /* Application Collection */ + GamePad = 0x05, /* Application Collection */ + Keyboard = 0x06, /* Application Collection */ + Keypad = 0x07, /* Application Collection */ + MultiAxisController = 0x08, /* Application Collection */ + /* 0x09 - 0x2F Reserved */ + X = 0x30, /* Dynamic Value */ + Y = 0x31, /* Dynamic Value */ + Z = 0x32, /* Dynamic Value */ + Rx = 0x33, /* Dynamic Value */ + Ry = 0x34, /* Dynamic Value */ + Rz = 0x35, /* Dynamic Value */ + Slider = 0x36, /* Dynamic Value */ + Dial = 0x37, /* Dynamic Value */ + Wheel = 0x38, /* Dynamic Value */ + Hatswitch = 0x39, /* Dynamic Value */ + CountedBuffer = 0x3A, /* Logical Collection */ + ByteCount = 0x3B, /* Dynamic Value */ + MotionWakeup = 0x3C, /* One-Shot Control */ + Start = 0x3D, /* On/Off Control */ + Select = 0x3E, /* On/Off Control */ + /* 0x3F Reserved */ + Vx = 0x40, /* Dynamic Value */ + Vy = 0x41, /* Dynamic Value */ + Vz = 0x42, /* Dynamic Value */ + Vbrx = 0x43, /* Dynamic Value */ + Vbry = 0x44, /* Dynamic Value */ + Vbrz = 0x45, /* Dynamic Value */ + Vno = 0x46, /* Dynamic Value */ + /* 0x47 - 0x7F Reserved */ + SystemControl = 0x80, /* Application Collection */ + SystemPowerDown = 0x81, /* One-Shot Control */ + SystemSleep = 0x82, /* One-Shot Control */ + SystemWakeUp = 0x83, /* One-Shot Control */ + SystemContextMenu = 0x84, /* One-Shot Control */ + SystemMainMenu = 0x85, /* One-Shot Control */ + SystemAppMenu = 0x86, /* One-Shot Control */ + SystemMenuHelp = 0x87, /* One-Shot Control */ + SystemMenuExit = 0x88, /* One-Shot Control */ + SystemMenu = 0x89, /* Selector */ + SystemMenuRight = 0x8A, /* Re-Trigger Control */ + SystemMenuLeft = 0x8B, /* Re-Trigger Control */ + SystemMenuUp = 0x8C, /* Re-Trigger Control */ + SystemMenuDown = 0x8D, /* Re-Trigger Control */ + /* 0x8E - 0x8F Reserved */ + DPadUp = 0x90, /* On/Off Control */ + DPadDown = 0x91, /* On/Off Control */ + DPadRight = 0x92, /* On/Off Control */ + DPadLeft = 0x93, /* On/Off Control */ + /* 0x94 - 0xFFFF Reserved */ + Reserved = 0xFFFF + } + + enum HIDButton + { + Button_1 = 0x01, /* (primary/trigger) */ + Button_2 = 0x02, /* (secondary) */ + Button_3 = 0x03, /* (tertiary) */ + Button_4 = 0x04, /* 4th button */ + /* ... */ + Button_65535 = 0xFFFF + } + #endregion } } From 1a3df17dff62de5972b4f5a56d00524f76a11176 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Thu, 25 Nov 2010 00:30:16 +0000 Subject: [PATCH 119/130] Implemented SetPosition in terms of CGWarpMouseCursorPosition. Added constructors to HIPoint. --- .../Platform/MacOS/CarbonBindings/CarbonAPI.cs | 8 ++++++++ .../CarbonBindings/QuartzDisplayServicesAPI.cs | 17 +++++++++++++++++ Source/OpenTK/Platform/MacOS/HIDInput.cs | 9 ++++++--- 3 files changed, 31 insertions(+), 3 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs index 4ae61ca9..45975680 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs @@ -99,6 +99,14 @@ namespace OpenTK.Platform.MacOS.Carbon { public float X; public float Y; + public HIPoint(float x, float y) + { + X = x; + Y = y; + } + public HIPoint(double x, double y) + : this((float)x, (float)y) + { } } [StructLayout(LayoutKind.Sequential)] internal struct HISize diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs index d241a3d6..f15d1a20 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs @@ -12,6 +12,21 @@ namespace OpenTK.Platform.MacOS.Carbon } + enum CGError + { + Success = 0, + Failure = 1000, + IllegalArgument = 1001, + InvalidConnection = 1002, + InvalidContext = 1003, + CannotComplete = 1004, + NotImplemented = 1006, + RangeCheck = 1007, + TypeCheck = 1008, + InvalidOperation = 1010, + NoneAvailable = 1011, + } + internal static class CG { const string appServices = "/System/Library/Frameworks/ApplicationServices.framework/Versions/Current/ApplicationServices"; @@ -50,5 +65,7 @@ namespace OpenTK.Platform.MacOS.Carbon [DllImport(appServices, EntryPoint = "CGDisplaySwitchToMode")] internal static extern IntPtr DisplaySwitchToMode(IntPtr display, IntPtr displayMode); + [DllImport(appServices, EntryPoint = "CGWarpMouseCursorPosition")] + internal static extern CGError WarpMouseCursorPosition(HIPoint newCursorPosition); } } diff --git a/Source/OpenTK/Platform/MacOS/HIDInput.cs b/Source/OpenTK/Platform/MacOS/HIDInput.cs index dabcc218..af160203 100755 --- a/Source/OpenTK/Platform/MacOS/HIDInput.cs +++ b/Source/OpenTK/Platform/MacOS/HIDInput.cs @@ -48,6 +48,8 @@ namespace OpenTK.Platform.MacOS using IOOptionBits = System.IntPtr; using IOReturn = System.IntPtr; + // Requires Mac OS X 10.5 or higher. + // Todo: create a driver for older installations. Maybe use CGGetLastMouseDelta for that? class HIDInput : IMouseDriver2 { #region Fields @@ -195,7 +197,7 @@ namespace OpenTK.Platform.MacOS #region IMouseDriver2 Members - public MouseState GetState() + MouseState IMouseDriver2.GetState() { MouseState master = new MouseState(); foreach (KeyValuePair item in MouseDevices) @@ -206,7 +208,7 @@ namespace OpenTK.Platform.MacOS return master; } - public MouseState GetState(int index) + MouseState IMouseDriver2.GetState(int index) { IntPtr device; if (MouseIndexToDevice.TryGetValue(index, out device)) @@ -217,8 +219,9 @@ namespace OpenTK.Platform.MacOS return new MouseState(); } - public void SetPosition(double x, double y) + void IMouseDriver2.SetPosition(double x, double y) { + CG.WarpMouseCursorPosition(new Carbon.HIPoint(x, y)); } #endregion From 7f0212a5fe46ac6a8c4928fb0a6fa4f887312a0d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 26 Nov 2010 10:59:08 +0000 Subject: [PATCH 120/130] Disabled event suppression after cursor movements. --- Source/OpenTK/Platform/MacOS/HIDInput.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/Source/OpenTK/Platform/MacOS/HIDInput.cs b/Source/OpenTK/Platform/MacOS/HIDInput.cs index af160203..6a123d28 100755 --- a/Source/OpenTK/Platform/MacOS/HIDInput.cs +++ b/Source/OpenTK/Platform/MacOS/HIDInput.cs @@ -221,6 +221,7 @@ namespace OpenTK.Platform.MacOS void IMouseDriver2.SetPosition(double x, double y) { + CG.SetLocalEventsSuppressionInterval(0.0); CG.WarpMouseCursorPosition(new Carbon.HIPoint(x, y)); } From 96791683d0326c6c8f8d7ec9b92673681637856f Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 26 Nov 2010 11:00:27 +0000 Subject: [PATCH 121/130] * Platform/MacOS/CarbonBindings/CarbonAPI.cs: Added support for mouse delta events. --- .../Platform/MacOS/CarbonBindings/CarbonAPI.cs | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs index 45975680..593612d0 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs @@ -714,17 +714,31 @@ namespace OpenTK.Platform.MacOS.Carbon unsafe { HIPoint* parm = &point; - OSStatus result = API.GetEventParameter(inEvent, EventParamName.WindowMouseLocation, EventParamType.typeHIPoint, IntPtr.Zero, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(HIPoint)), IntPtr.Zero, (IntPtr)parm); - pt = point; return result; } + } + static internal OSStatus GetEventMouseDelta(IntPtr inEvent, out HIPoint pt) + { + HIPoint point; + + unsafe + { + HIPoint* parm = &point; + OSStatus result = API.GetEventParameter(inEvent, + EventParamName.MouseDelta, EventParamType.typeHIPoint, IntPtr.Zero, + (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(HIPoint)), IntPtr.Zero, + (IntPtr)parm); + pt = point; + + return result; + } } static internal OSStatus GetEventWindowRef(IntPtr inEvent, out IntPtr windowRef) From 37a744acb33906c0ff47a6e4cf803c338a9cceb9 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 26 Nov 2010 11:00:57 +0000 Subject: [PATCH 122/130] * Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs: Added support for mouse control. --- .../CarbonBindings/QuartzDisplayServicesAPI.cs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs index f15d1a20..c30c8399 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs @@ -5,6 +5,8 @@ using System.Diagnostics; namespace OpenTK.Platform.MacOS.Carbon { + using CGDirectDisplayID = System.IntPtr; + // Quartz Display services used here are available in MacOS X 10.3 and later. enum CGDisplayErr @@ -67,5 +69,20 @@ namespace OpenTK.Platform.MacOS.Carbon [DllImport(appServices, EntryPoint = "CGWarpMouseCursorPosition")] internal static extern CGError WarpMouseCursorPosition(HIPoint newCursorPosition); + + [DllImport(appServices, EntryPoint = "CGCursorIsVisible")] + internal static extern bool CursorIsVisible(); + + [DllImport(appServices, EntryPoint = "CGDisplayShowCursor")] + internal static extern CGError DisplayShowCursor(CGDirectDisplayID display); + + [DllImport(appServices, EntryPoint = "CGDisplayHideCursor")] + internal static extern CGError DisplayHideCursor(CGDirectDisplayID display); + + [DllImport(appServices, EntryPoint = "CGAssociateMouseAndMouseCursorPosition")] + internal static extern CGError AssociateMouseAndMouseCursorPosition(bool connected); + + [DllImport(appServices, EntryPoint="CGSetLocalEventsSuppressionInterval")] + internal static extern CGError SetLocalEventsSuppressionInterval(double seconds); } } From db6cc338f573636aef21d6a83063aed9cc072f43 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 26 Nov 2010 11:01:51 +0000 Subject: [PATCH 123/130] * Platform/MacOS/CarbonGLNative.cs: Implemented CursorVisible property. Aligned mouse behavior to win32 & x11. General code cleanup. --- .../OpenTK/Platform/MacOS/CarbonGLNative.cs | 270 ++++++++++-------- 1 file changed, 145 insertions(+), 125 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index edf48c7e..ce1f0a84 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -62,7 +62,8 @@ namespace OpenTK.Platform.MacOS private WindowBorder windowBorder = WindowBorder.Resizable; private WindowState windowState = WindowState.Normal; - static Dictionary mWindows = new Dictionary(); + static Dictionary mWindows = + new Dictionary(new IntPtrEqualityComparer()); KeyPressEventArgs mKeyPressArgs = new KeyPressEventArgs((char)0); @@ -71,6 +72,10 @@ namespace OpenTK.Platform.MacOS Icon mIcon; + // Used to accumulate mouse motion when the cursor is hidden. + float mouse_rel_x; + float mouse_rel_y; + #endregion #region AGL Device Hack @@ -93,21 +98,26 @@ namespace OpenTK.Platform.MacOS Application.Initialize(); } - CarbonGLNative() : this(WindowClass.Document, WindowAttributes.StandardDocument | WindowAttributes.StandardHandler | WindowAttributes.InWindowMenu | WindowAttributes.LiveResize) + CarbonGLNative() : this(WindowClass.Document, + WindowAttributes.StandardDocument | WindowAttributes.StandardHandler | + WindowAttributes.InWindowMenu | WindowAttributes.LiveResize) { } - CarbonGLNative(WindowClass @class, WindowAttributes attrib) { mWindowClass = @class; mWindowAttrib = attrib; } - public CarbonGLNative(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) + public CarbonGLNative(int x, int y, int width, int height, string title, + GraphicsMode mode, GameWindowFlags options, DisplayDevice device) { - CreateNativeWindow(WindowClass.Document, WindowAttributes.StandardDocument | WindowAttributes.StandardHandler | WindowAttributes.InWindowMenu | WindowAttributes.LiveResize, new Rect((short)x, (short)y, (short)width, (short)height)); - + CreateNativeWindow(WindowClass.Document, + WindowAttributes.StandardDocument | WindowAttributes.StandardHandler | + WindowAttributes.InWindowMenu | WindowAttributes.LiveResize, + new Rect((short)x, (short)y, (short)width, (short)height)); + mDisplayDevice = device; } @@ -125,14 +135,16 @@ namespace OpenTK.Platform.MacOS { if (mIsDisposed) return; - + Debug.Print("Disposing of CarbonGLNative window."); - + + CursorVisible = true; API.DisposeWindow(window.WindowRef); - mIsDisposed = true; mExists = false; - + + CG.SetLocalEventsSuppressionInterval(0.25); + if (disposing) { mWindows.Remove(window.WindowRef); @@ -140,9 +152,9 @@ namespace OpenTK.Platform.MacOS window.Dispose(); window = null; } - + DisposeUPP(); - + Disposed(this, EventArgs.Empty); } @@ -199,8 +211,15 @@ namespace OpenTK.Platform.MacOS void ConnectEvents() { mInputDriver = new CarbonInput(); - - + + EventTypeSpec[] eventTypes = new EventTypeSpec[] + { + new EventTypeSpec(EventClass.Window, WindowEventKind.WindowClose), + new EventTypeSpec(EventClass.Window, WindowEventKind.WindowClosed), + new EventTypeSpec(EventClass.Window, WindowEventKind.WindowBoundsChanged), + new EventTypeSpec(EventClass.Window, WindowEventKind.WindowActivate), + new EventTypeSpec(EventClass.Window, WindowEventKind.WindowDeactivate), + //new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseDown), //new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseUp), //new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseMoved), @@ -208,17 +227,18 @@ namespace OpenTK.Platform.MacOS //new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseEntered), //new EventTypeSpec(EventClass.Mouse, MouseEventKind.MouseExited), //new EventTypeSpec(EventClass.Mouse, MouseEventKind.WheelMoved), - + //new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyDown), //new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyRepeat), //new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyUp), //new EventTypeSpec(EventClass.Keyboard, KeyboardEventKind.RawKeyModifiersChanged), - EventTypeSpec[] eventTypes = new EventTypeSpec[] { new EventTypeSpec(EventClass.Window, WindowEventKind.WindowClose), new EventTypeSpec(EventClass.Window, WindowEventKind.WindowClosed), new EventTypeSpec(EventClass.Window, WindowEventKind.WindowBoundsChanged), new EventTypeSpec(EventClass.Window, WindowEventKind.WindowActivate), new EventTypeSpec(EventClass.Window, WindowEventKind.WindowDeactivate) }; + }; MacOSEventHandler handler = EventHandler; uppHandler = API.NewEventHandlerUPP(handler); - API.InstallWindowEventHandler(window.WindowRef, uppHandler, eventTypes, window.WindowRef, IntPtr.Zero); + API.InstallWindowEventHandler(window.WindowRef, uppHandler, eventTypes, + window.WindowRef, IntPtr.Zero); Application.WindowEventHandler = this; } @@ -439,149 +459,124 @@ namespace OpenTK.Platform.MacOS return OSStatus.EventNotHandled; } } + protected OSStatus ProcessMouseEvent(IntPtr inCaller, IntPtr inEvent, EventInfo evt, IntPtr userData) { System.Diagnostics.Debug.Assert(evt.EventClass == EventClass.Mouse); MouseButton button = MouseButton.Primary; HIPoint pt = new HIPoint(); HIPoint screenLoc = new HIPoint(); - + + IntPtr thisEventWindow; + API.GetEventWindowRef(inEvent, out thisEventWindow); + OSStatus err = API.GetEventMouseLocation(inEvent, out screenLoc); - if (this.windowState == WindowState.Fullscreen) { pt = screenLoc; } - - else + else if (CursorVisible) { err = API.GetEventWindowMouseLocation(inEvent, out pt); + pt.Y -= mTitlebarHeight; + } + else + { + err = API.GetEventMouseDelta(inEvent, out pt); + pt.X += mouse_rel_x; + pt.Y += mouse_rel_y; + pt = ConfineMouseToWindow(thisEventWindow, pt); + ResetMouseToWindowCenter(); + mouse_rel_x = pt.X; + mouse_rel_y = pt.Y; } - if (err != OSStatus.NoError) + if (err != OSStatus.NoError && err != OSStatus.EventParameterNotFound) { // this error comes up from the application event handler. - if (err != OSStatus.EventParameterNotFound) - { - throw new MacOSException(err); - } + throw new MacOSException(err); } Point mousePosInClient = new Point((int)pt.X, (int)pt.Y); - if (this.windowState != WindowState.Fullscreen) - { - mousePosInClient.Y -= mTitlebarHeight; - } - - // check for enter/leave events - IntPtr thisEventWindow; - API.GetEventWindowRef(inEvent, out thisEventWindow); CheckEnterLeaveEvents(thisEventWindow, mousePosInClient); switch (evt.MouseEventKind) { - case MouseEventKind.MouseDown: - button = API.GetEventMouseButton(inEvent); - - switch (button) - { - case MouseButton.Primary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Left] = true; - break; - - case MouseButton.Secondary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Right] = true; - break; - - case MouseButton.Tertiary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Middle] = true; - break; - } + case MouseEventKind.MouseDown: + case MouseEventKind.MouseUp: + button = API.GetEventMouseButton(inEvent); + bool pressed = evt.MouseEventKind == MouseEventKind.MouseDown; - - - return OSStatus.NoError; - - case MouseEventKind.MouseUp: - button = API.GetEventMouseButton(inEvent); - - switch (button) - { - case MouseButton.Primary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Left] = false; - break; - - case MouseButton.Secondary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Right] = false; - break; - - case MouseButton.Tertiary: - InputDriver.Mouse[0][OpenTK.Input.MouseButton.Middle] = false; - break; - } - - - button = API.GetEventMouseButton(inEvent); - - return OSStatus.NoError; - - case MouseEventKind.WheelMoved: - - int delta = API.GetEventMouseWheelDelta(inEvent) / 3; - - InputDriver.Mouse[0].Wheel += delta; - - return OSStatus.NoError; - - case MouseEventKind.MouseMoved: - case MouseEventKind.MouseDragged: - - //Debug.Print("Mouse Location: {0}, {1}", pt.X, pt.Y); - - if (this.windowState == WindowState.Fullscreen) - { - if (mousePosInClient.X != InputDriver.Mouse[0].X || mousePosInClient.Y != InputDriver.Mouse[0].Y) + switch (button) { - InputDriver.Mouse[0].Position = mousePosInClient; - } - } + case MouseButton.Primary: + InputDriver.Mouse[0][OpenTK.Input.MouseButton.Left] = pressed; + break; - else - { - // ignore clicks in the title bar - if (pt.Y < 0) - return OSStatus.EventNotHandled; - - if (mousePosInClient.X != InputDriver.Mouse[0].X || mousePosInClient.Y != InputDriver.Mouse[0].Y) + case MouseButton.Secondary: + InputDriver.Mouse[0][OpenTK.Input.MouseButton.Right] = pressed; + break; + + case MouseButton.Tertiary: + InputDriver.Mouse[0][OpenTK.Input.MouseButton.Middle] = pressed; + break; + } + return OSStatus.NoError; + + case MouseEventKind.WheelMoved: + float delta = API.GetEventMouseWheelDelta(inEvent); + InputDriver.Mouse[0].WheelPrecise += delta; + return OSStatus.NoError; + + case MouseEventKind.MouseMoved: + case MouseEventKind.MouseDragged: + if (this.windowState == WindowState.Fullscreen) { - InputDriver.Mouse[0].Position = mousePosInClient; + if (mousePosInClient.X != InputDriver.Mouse[0].X || mousePosInClient.Y != InputDriver.Mouse[0].Y) + { + InputDriver.Mouse[0].Position = mousePosInClient; + } } - } + else + { + // ignore clicks in the title bar + if (pt.Y < 0) + return OSStatus.EventNotHandled; - - return OSStatus.EventNotHandled; - default: - - Debug.Print("{0}", evt); - - return OSStatus.EventNotHandled; + if (mousePosInClient.X != InputDriver.Mouse[0].X || mousePosInClient.Y != InputDriver.Mouse[0].Y) + { + InputDriver.Mouse[0].Position = mousePosInClient; + } + } + return OSStatus.EventNotHandled; + + default: + Debug.Print("{0}", evt); + return OSStatus.EventNotHandled; } } + void ResetMouseToWindowCenter() + { + OpenTK.Input.Mouse.SetPosition( + (Bounds.Left + Bounds.Right) / 2, + (Bounds.Top + Bounds.Bottom) / 2); + } + private void CheckEnterLeaveEvents(IntPtr eventWindowRef, Point pt) { if (window == null) return; - + bool thisIn = eventWindowRef == window.WindowRef; - + if (pt.Y < 0) thisIn = false; - + if (thisIn != mMouseIn) { mMouseIn = thisIn; - + if (mMouseIn) OnMouseEnter(); else @@ -589,11 +584,28 @@ namespace OpenTK.Platform.MacOS } } + // Point in client (window) coordinates + private HIPoint ConfineMouseToWindow(IntPtr window, HIPoint client) + { + if (client.X < 0) + client.X = 0; + if (client.X >= Width) + client.X = Width - 1; + if (client.Y < 0) + client.Y = 0; + if (client.Y >= Height) + client.Y = Height - 1; + + Debug.Print("[{0}:{1}]", client.X, client.Y); + return client; + } + private static void GetCharCodes(IntPtr inEvent, out MacOSKeyCode code, out char charCode) { code = API.GetEventKeyboardKeyCode(inEvent); charCode = API.GetEventKeyboardChar(inEvent); } + private void ProcessModifierKey(IntPtr inEvent) { MacOSKeyModifiers modifiers = API.GetEventKeyModifiers(inEvent); @@ -662,7 +674,6 @@ namespace OpenTK.Platform.MacOS API.SizeWindow(window.WindowRef, width, height, true); } - private void LoadSize() { if (WindowState == WindowState.Fullscreen) @@ -687,15 +698,12 @@ namespace OpenTK.Platform.MacOS public Point PointToClient(Point point) { Rect r = Carbon.API.GetWindowBounds(window.WindowRef, WindowRegionCode.ContentRegion); - Debug.Print("Rect: {0}", r); - return new Point(point.X - r.X, point.Y - r.Y); } + public Point PointToScreen(Point point) { Rect r = Carbon.API.GetWindowBounds(window.WindowRef, WindowRegionCode.ContentRegion); - Debug.Print("Rect: {0}", r); - return new Point(point.X + r.X, point.Y + r.Y); } @@ -719,7 +727,6 @@ namespace OpenTK.Platform.MacOS get { return mInputDriver; } } - public Icon Icon { get { return mIcon; } @@ -892,8 +899,21 @@ namespace OpenTK.Platform.MacOS public bool CursorVisible { - get { return true; } - set { } + get { return CG.CursorIsVisible(); } + set + { + if (value) + { + CG.DisplayShowCursor(IntPtr.Zero); + CG.AssociateMouseAndMouseCursorPosition(true); + } + else + { + CG.DisplayHideCursor(IntPtr.Zero); + ResetMouseToWindowCenter(); + CG.AssociateMouseAndMouseCursorPosition(false); + } + } } public void Close() From 6078b4530a20a1ea2a3833e3da8e4361ce20e29e Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 26 Nov 2010 11:41:45 +0000 Subject: [PATCH 124/130] * EventInfo.cs, AglContext.cs, MacOSKeyMap.cs, Application.cs, CarbonInput.cs, CarbonGLNative.cs, MacOSException.cs, CarbonBindings/Agl.cs, CarbonBindings/CarbonAPI.cs, CarbonBindings/MacOSKeys.cs, CarbonBindings/SpeechChannel.cs, CarbonBindings/CoreFoundation.cs, CarbonBindings/QuartzDisplayServicesAPI.cs: Normalized licensing information. --- Source/OpenTK/Platform/MacOS/AglContext.cs | 28 +++- Source/OpenTK/Platform/MacOS/Application.cs | 28 +++- .../Platform/MacOS/CarbonBindings/Agl.cs | 31 ++++- .../MacOS/CarbonBindings/CarbonAPI.cs | 31 ++++- .../MacOS/CarbonBindings/CoreFoundation.cs | 27 ++++ .../MacOS/CarbonBindings/MacOSKeys.cs | 27 ++++ .../QuartzDisplayServicesAPI.cs | 28 +++- .../MacOS/CarbonBindings/SpeechChannel.cs | 27 ++++ .../OpenTK/Platform/MacOS/CarbonGLNative.cs | 120 ++++++++---------- Source/OpenTK/Platform/MacOS/CarbonInput.cs | 27 ++++ Source/OpenTK/Platform/MacOS/EventInfo.cs | 30 ++++- .../OpenTK/Platform/MacOS/MacOSException.cs | 28 ++++ Source/OpenTK/Platform/MacOS/MacOSKeyMap.cs | 29 +++++ 13 files changed, 368 insertions(+), 93 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/AglContext.cs b/Source/OpenTK/Platform/MacOS/AglContext.cs index 960d4abf..4d2ca42e 100644 --- a/Source/OpenTK/Platform/MacOS/AglContext.cs +++ b/Source/OpenTK/Platform/MacOS/AglContext.cs @@ -1,11 +1,31 @@ +#region License // -// -// AglContext.cs +// The Open Toolkit Library License // -// Created by Erik Ylvisaker on 3/17/08. -// Copyright 2008. All rights reserved. +// Copyright (c) 2006 - 2010 the Open Toolkit library. // +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: // +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +// Created by Erik Ylvisaker on 3/17/08. using System; using System.Collections.Generic; diff --git a/Source/OpenTK/Platform/MacOS/Application.cs b/Source/OpenTK/Platform/MacOS/Application.cs index a4d83b54..c419a079 100644 --- a/Source/OpenTK/Platform/MacOS/Application.cs +++ b/Source/OpenTK/Platform/MacOS/Application.cs @@ -1,11 +1,31 @@ +#region License // -// -// xCSCarbon +// The Open Toolkit Library License // -// Created by Erik Ylvisaker on 3/17/08. -// Copyright 2008 __MyCompanyName__. All rights reserved. +// Copyright (c) 2006 - 2010 the Open Toolkit library. // +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: // +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +// Created by Erik Ylvisaker on 3/17/08. using System; using System.Collections.Generic; diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/Agl.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/Agl.cs index ad837571..03f4cb4a 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/Agl.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/Agl.cs @@ -1,11 +1,32 @@ +#region License // -// -// Agl.cs +// The Open Toolkit Library License // +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + // Created by Erik Ylvisaker on 3/17/08. -// Copyright 2008. All rights reserved. -// -// + using System; using System.Diagnostics; diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs index 593612d0..0cf7847e 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/CarbonAPI.cs @@ -1,11 +1,32 @@ +#region License // -// -// Carbon.cs +// The Open Toolkit Library License // +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + // Created by Erik Ylvisaker on 3/17/08. -// Copyright 2008. All rights reserved. -// -// + using System; using System.Runtime.InteropServices; diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs index 451103ff..f6c9b156 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/CoreFoundation.cs @@ -1,3 +1,30 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + using System; using System.Collections.Generic; using System.Runtime.InteropServices; diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/MacOSKeys.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/MacOSKeys.cs index 90868408..b7fab61b 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/MacOSKeys.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/MacOSKeys.cs @@ -1,3 +1,30 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + using System; using System.Collections.Generic; using System.Text; diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs index c30c8399..c21d4159 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/QuartzDisplayServicesAPI.cs @@ -1,8 +1,34 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + using System; using System.Runtime.InteropServices; using System.Diagnostics; - namespace OpenTK.Platform.MacOS.Carbon { using CGDirectDisplayID = System.IntPtr; diff --git a/Source/OpenTK/Platform/MacOS/CarbonBindings/SpeechChannel.cs b/Source/OpenTK/Platform/MacOS/CarbonBindings/SpeechChannel.cs index cc84f25c..d96fce72 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonBindings/SpeechChannel.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonBindings/SpeechChannel.cs @@ -1,3 +1,30 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + using System; using System.Collections.Generic; using System.Diagnostics; diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index ce1f0a84..99b61c88 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -2,7 +2,7 @@ // // The Open Toolkit Library License // -// Copyright (c) 2006 - 2009 the Open Toolkit library. +// Copyright (c) 2006 - 2010 the Open Toolkit library. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal @@ -25,6 +25,8 @@ // #endregion +// Created by Erik Ylvisaker on 3/17/08. + using System; using System.Collections.Generic; using System.ComponentModel; @@ -306,61 +308,46 @@ namespace OpenTK.Platform.MacOS { switch (evt.EventClass) { - case EventClass.Window: - return ProcessWindowEvent(inCaller, inEvent, evt, userData); - - case EventClass.Mouse: - return ProcessMouseEvent(inCaller, inEvent, evt, userData); - - case EventClass.Keyboard: - return ProcessKeyboardEvent(inCaller, inEvent, evt, userData); - default: - - return OSStatus.EventNotHandled; + case EventClass.Window: + return ProcessWindowEvent(inCaller, inEvent, evt, userData); + + case EventClass.Mouse: + return ProcessMouseEvent(inCaller, inEvent, evt, userData); + + case EventClass.Keyboard: + return ProcessKeyboardEvent(inCaller, inEvent, evt, userData); + + default: + return OSStatus.EventNotHandled; } } protected static OSStatus EventHandler(IntPtr inCaller, IntPtr inEvent, IntPtr userData) { - // bail out if the window passed in is not actually our window. - // I think this happens if using winforms with a GameWindow sometimes. if (mWindows.ContainsKey(userData) == false) + { + // Bail out if the window passed in is not actually our window. + // I think this happens if using winforms with a GameWindow sometimes. return OSStatus.EventNotHandled; - + } + WeakReference reference = mWindows[userData]; - - // bail out if the CarbonGLNative window has been garbage collected. if (reference.IsAlive == false) { + // Bail out if the CarbonGLNative window has been garbage collected. mWindows.Remove(userData); return OSStatus.EventNotHandled; } - + CarbonGLNative window = (CarbonGLNative)reference.Target; - EventInfo evt = new EventInfo(inEvent); - - //Debug.Print("Processing {0} event for {1}.", evt, window.window); - if (window == null) { Debug.WriteLine("Window for event not found."); return OSStatus.EventNotHandled; } - - switch (evt.EventClass) - { - case EventClass.Window: - return window.ProcessWindowEvent(inCaller, inEvent, evt, userData); - - case EventClass.Mouse: - return window.ProcessMouseEvent(inCaller, inEvent, evt, userData); - - case EventClass.Keyboard: - return window.ProcessKeyboardEvent(inCaller, inEvent, evt, userData); - default: - - return OSStatus.EventNotHandled; - } + + EventInfo evt = new EventInfo(inEvent); + return window.DispatchEvent(inCaller, inEvent, evt, userData); } private OSStatus ProcessKeyboardEvent(IntPtr inCaller, IntPtr inEvent, EventInfo evt, IntPtr userData) @@ -368,44 +355,39 @@ namespace OpenTK.Platform.MacOS System.Diagnostics.Debug.Assert(evt.EventClass == EventClass.Keyboard); MacOSKeyCode code = (MacOSKeyCode)0; char charCode = '\0'; - - //Debug.Print("Processing keyboard event {0}", evt.KeyboardEventKind); - + switch (evt.KeyboardEventKind) { - case KeyboardEventKind.RawKeyDown: - case KeyboardEventKind.RawKeyRepeat: - case KeyboardEventKind.RawKeyUp: - GetCharCodes(inEvent, out code, out charCode); - mKeyPressArgs.KeyChar = charCode; - break; + case KeyboardEventKind.RawKeyDown: + case KeyboardEventKind.RawKeyRepeat: + case KeyboardEventKind.RawKeyUp: + GetCharCodes(inEvent, out code, out charCode); + mKeyPressArgs.KeyChar = charCode; + break; } - + switch (evt.KeyboardEventKind) { - case KeyboardEventKind.RawKeyRepeat: - InputDriver.Keyboard[0].KeyRepeat = true; - goto case KeyboardEventKind.RawKeyDown; - - case KeyboardEventKind.RawKeyDown: - OnKeyPress(mKeyPressArgs); - InputDriver.Keyboard[0][Keymap[code]] = true; - return OSStatus.NoError; - - case KeyboardEventKind.RawKeyUp: - InputDriver.Keyboard[0][Keymap[code]] = false; - - return OSStatus.NoError; - - case KeyboardEventKind.RawKeyModifiersChanged: - ProcessModifierKey(inEvent); - return OSStatus.NoError; - default: - - return OSStatus.EventNotHandled; + case KeyboardEventKind.RawKeyRepeat: + InputDriver.Keyboard[0].KeyRepeat = true; + goto case KeyboardEventKind.RawKeyDown; + + case KeyboardEventKind.RawKeyDown: + OnKeyPress(mKeyPressArgs); + InputDriver.Keyboard[0][Keymap[code]] = true; + return OSStatus.NoError; + + case KeyboardEventKind.RawKeyUp: + InputDriver.Keyboard[0][Keymap[code]] = false; + return OSStatus.NoError; + + case KeyboardEventKind.RawKeyModifiersChanged: + ProcessModifierKey(inEvent); + return OSStatus.NoError; + + default: + return OSStatus.EventNotHandled; } - - } private OSStatus ProcessWindowEvent(IntPtr inCaller, IntPtr inEvent, EventInfo evt, IntPtr userData) diff --git a/Source/OpenTK/Platform/MacOS/CarbonInput.cs b/Source/OpenTK/Platform/MacOS/CarbonInput.cs index 654e8321..1fd65a2c 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonInput.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonInput.cs @@ -1,3 +1,30 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + using System; using System.Collections.Generic; using System.Diagnostics; diff --git a/Source/OpenTK/Platform/MacOS/EventInfo.cs b/Source/OpenTK/Platform/MacOS/EventInfo.cs index c5400001..32c9d689 100644 --- a/Source/OpenTK/Platform/MacOS/EventInfo.cs +++ b/Source/OpenTK/Platform/MacOS/EventInfo.cs @@ -1,11 +1,31 @@ +#region License // -// -// xCSCarbon +// The Open Toolkit Library License // +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + // Created by Erik Ylvisaker on 3/17/08. -// Copyright 2008 __MyCompanyName__. All rights reserved. -// -// using System; using System.Collections.Generic; diff --git a/Source/OpenTK/Platform/MacOS/MacOSException.cs b/Source/OpenTK/Platform/MacOS/MacOSException.cs index a8082347..47489398 100644 --- a/Source/OpenTK/Platform/MacOS/MacOSException.cs +++ b/Source/OpenTK/Platform/MacOS/MacOSException.cs @@ -1,3 +1,31 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +// Created by Erik Ylvisaker on 3/17/08. using System; diff --git a/Source/OpenTK/Platform/MacOS/MacOSKeyMap.cs b/Source/OpenTK/Platform/MacOS/MacOSKeyMap.cs index e5ffc834..49e86033 100644 --- a/Source/OpenTK/Platform/MacOS/MacOSKeyMap.cs +++ b/Source/OpenTK/Platform/MacOS/MacOSKeyMap.cs @@ -1,3 +1,32 @@ +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2010 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +// Created by Erik Ylvisaker on 3/17/08. + using System; using System.Collections.Generic; using System.Text; From 24af8471c9c01a8c395530c42d90f9ac92f1512f Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 26 Nov 2010 13:32:52 +0000 Subject: [PATCH 125/130] * MacOS/CarbonGLNative.cs: Removed unnecessary debug information. --- Source/OpenTK/Platform/MacOS/CarbonGLNative.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index 99b61c88..7c85b7c8 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -578,7 +578,6 @@ namespace OpenTK.Platform.MacOS if (client.Y >= Height) client.Y = Height - 1; - Debug.Print("[{0}:{1}]", client.X, client.Y); return client; } From e75e4a64b8eca11a1e721b8fa6eddd25e657ac5a Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 30 Nov 2010 23:22:56 +0000 Subject: [PATCH 126/130] * Platform/MacOS/CarbonGLNative.cs: Fixed handling of key repeat. Fixed crash when unknown key is pressed. --- .../OpenTK/Platform/MacOS/CarbonGLNative.cs | 28 +++++++++++++------ 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index 7c85b7c8..c1c8eaa5 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -369,25 +369,37 @@ namespace OpenTK.Platform.MacOS switch (evt.KeyboardEventKind) { case KeyboardEventKind.RawKeyRepeat: - InputDriver.Keyboard[0].KeyRepeat = true; - goto case KeyboardEventKind.RawKeyDown; + if (InputDriver.Keyboard[0].KeyRepeat) + goto case KeyboardEventKind.RawKeyDown; + break; case KeyboardEventKind.RawKeyDown: - OnKeyPress(mKeyPressArgs); - InputDriver.Keyboard[0][Keymap[code]] = true; + { + OpenTK.Input.Key key; + if (Keymap.TryGetValue(code, out key)) + { + InputDriver.Keyboard[0][key] = true; + OnKeyPress(mKeyPressArgs); + } return OSStatus.NoError; + } case KeyboardEventKind.RawKeyUp: - InputDriver.Keyboard[0][Keymap[code]] = false; + { + OpenTK.Input.Key key; + if (Keymap.TryGetValue(code, out key)) + { + InputDriver.Keyboard[0][key] = false; + } return OSStatus.NoError; + } case KeyboardEventKind.RawKeyModifiersChanged: ProcessModifierKey(inEvent); return OSStatus.NoError; - - default: - return OSStatus.EventNotHandled; } + + return OSStatus.EventNotHandled; } private OSStatus ProcessWindowEvent(IntPtr inCaller, IntPtr inEvent, EventInfo evt, IntPtr userData) From 223c911bf90443fccae5cbd5162083227b1b50d9 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Tue, 30 Nov 2010 23:23:42 +0000 Subject: [PATCH 127/130] * Platform/MacOS/HIDInput.cs, Platform/MacOS/MacOSFactory.cs: Added support for raw keyboard input. --- Source/OpenTK/Platform/MacOS/HIDInput.cs | 518 ++++++++++++++++++- Source/OpenTK/Platform/MacOS/MacOSFactory.cs | 11 +- 2 files changed, 514 insertions(+), 15 deletions(-) diff --git a/Source/OpenTK/Platform/MacOS/HIDInput.cs b/Source/OpenTK/Platform/MacOS/HIDInput.cs index 6a123d28..1a5759a7 100755 --- a/Source/OpenTK/Platform/MacOS/HIDInput.cs +++ b/Source/OpenTK/Platform/MacOS/HIDInput.cs @@ -50,7 +50,7 @@ namespace OpenTK.Platform.MacOS // Requires Mac OS X 10.5 or higher. // Todo: create a driver for older installations. Maybe use CGGetLastMouseDelta for that? - class HIDInput : IMouseDriver2 + class HIDInput : IInputDriver2, IMouseDriver2, IKeyboardDriver2 { #region Fields @@ -60,6 +60,10 @@ namespace OpenTK.Platform.MacOS new Dictionary(new IntPtrEqualityComparer()); readonly Dictionary MouseIndexToDevice = new Dictionary(); + readonly Dictionary KeyboardDevices = + new Dictionary(new IntPtrEqualityComparer()); + readonly Dictionary KeyboardIndexToDevice = + new Dictionary(); readonly CFRunLoop RunLoop = CF.CFRunLoopGetMain(); readonly CFString InputLoopMode = CF.RunLoopModeDefault; @@ -75,7 +79,7 @@ namespace OpenTK.Platform.MacOS public HIDInput() { - Debug.Print("Using {0}.", typeof(HIDInput).Name); + Debug.Print("Using HIDInput."); HandleDeviceAdded = DeviceAdded; HandleDeviceRemoved = DeviceRemoved; @@ -107,22 +111,52 @@ namespace OpenTK.Platform.MacOS NativeMethods.IOHIDManagerSetDeviceMatching(hidmanager, DeviceTypes.Ref); NativeMethods.IOHIDManagerOpen(hidmanager, IOOptionBits.Zero); + + OpenTK.Platform.MacOS.Carbon.CF.CFRunLoopRunInMode(InputLoopMode, 0.0, true); } void DeviceAdded(IntPtr context, IOReturn res, IntPtr sender, IOHIDDeviceRef device) { - Debug.Print("Device {0} discovered", device); - if (NativeMethods.IOHIDDeviceOpen(device, IOOptionBits.Zero) == IOReturn.Zero) { - Debug.Print("Device {0} connected", device); - - if (NativeMethods.IOHIDDeviceConformsTo(device, HIDPage.GenericDesktop, (int)HIDUsageGD.Mouse)) + if (NativeMethods.IOHIDDeviceConformsTo(device, + HIDPage.GenericDesktop, (int)HIDUsageGD.Mouse)) { - MouseState state = new MouseState(); - state.IsConnected = true; - MouseIndexToDevice.Add(MouseDevices.Count, device); - MouseDevices.Add(device, state); + if (!MouseDevices.ContainsKey(device)) + { + Debug.Print("Mouse device {0} discovered", device); + MouseState state = new MouseState(); + state.IsConnected = true; + MouseIndexToDevice.Add(MouseDevices.Count, device); + MouseDevices.Add(device, state); + } + else + { + Debug.Print("Mouse device {0} reconnected", device); + MouseState state = MouseDevices[device]; + state.IsConnected = true; + MouseDevices[device] = state; + } + } + + if (NativeMethods.IOHIDDeviceConformsTo(device, + HIDPage.GenericDesktop, (int)HIDUsageGD.Keyboard)) + { + if (!KeyboardDevices.ContainsKey(device)) + { + Debug.Print("Keyboard device {0} discovered", device); + KeyboardState state = new KeyboardState(); + state.IsConnected = true; + KeyboardIndexToDevice.Add(KeyboardDevices.Count, device); + KeyboardDevices.Add(device, state); + } + else + { + Debug.Print("Keyboard device {0} reconnected", device); + KeyboardState state = KeyboardDevices[device]; + state.IsConnected = true; + KeyboardDevices[device] = state; + } } NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, @@ -133,17 +167,28 @@ namespace OpenTK.Platform.MacOS void DeviceRemoved(IntPtr context, IOReturn res, IntPtr sender, IOHIDDeviceRef device) { - Debug.Print("Device {0} disconnected", device); - if (NativeMethods.IOHIDDeviceConformsTo(device, HIDPage.GenericDesktop, (int)HIDUsageGD.Mouse) && MouseDevices.ContainsKey(device)) { + Debug.Print("Mouse device {0} disconnected", device); + // Keep the device in case it comes back later on MouseState state = MouseDevices[device]; state.IsConnected = false; MouseDevices[device] = state; } + if (NativeMethods.IOHIDDeviceConformsTo(device, HIDPage.GenericDesktop, (int)HIDUsageGD.Keyboard) && + KeyboardDevices.ContainsKey(device)) + { + Debug.Print("Keyboard device {0} disconnected", device); + + // Keep the device in case it comes back later on + KeyboardState state = KeyboardDevices[device]; + state.IsConnected = false; + KeyboardDevices[device] = state; + } + NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, null, IntPtr.Zero); NativeMethods.IOHIDDeviceUnscheduleWithRunLoop(device, RunLoop, InputLoopMode); } @@ -151,10 +196,15 @@ namespace OpenTK.Platform.MacOS void DeviceValueReceived(IntPtr context, IOReturn res, IntPtr sender, IOHIDValueRef val) { MouseState mouse; + KeyboardState keyboard; if (MouseDevices.TryGetValue(sender, out mouse)) { MouseDevices[sender] = UpdateMouse(mouse, val); } + else if (KeyboardDevices.TryGetValue(sender, out keyboard)) + { + KeyboardDevices[sender] = UpdateKeyboard(keyboard, val); + } } static MouseState UpdateMouse(MouseState state, IOHIDValueRef val) @@ -193,6 +243,39 @@ namespace OpenTK.Platform.MacOS return state; } + static KeyboardState UpdateKeyboard(KeyboardState state, IOHIDValueRef val) + { + IOHIDElementRef elem = NativeMethods.IOHIDValueGetElement(val); + int v_int = NativeMethods.IOHIDValueGetIntegerValue(val).ToInt32(); + HIDPage page = NativeMethods.IOHIDElementGetUsagePage(elem); + int usage = NativeMethods.IOHIDElementGetUsage(elem); + + switch (page) + { + case HIDPage.GenericDesktop: + case HIDPage.KeyboardOrKeypad: + int raw = (int)usage; + if (raw >= RawKeyMap.Length || raw < 0) + { + Debug.Print("[Warning] Key {0} not mapped.", raw); + return state; + } + Key key = RawKeyMap[raw]; + state[key] = v_int != 0; + break; + } + + return state; + } + + #endregion + + #region IInputDriver2 Members + + public IMouseDriver2 MouseDriver { get { return this; } } + public IKeyboardDriver2 KeyboardDriver { get { return this; } } + public IGamePadDriver GamePadDriver { get { throw new NotImplementedException(); } } + #endregion #region IMouseDriver2 Members @@ -227,11 +310,57 @@ namespace OpenTK.Platform.MacOS #endregion + #region IKeyboardDriver2 + + KeyboardState IKeyboardDriver2.GetState() + { + KeyboardState master = new KeyboardState(); + foreach (KeyValuePair item in KeyboardDevices) + { + master.MergeBits(item.Value); + } + + return master; + } + + KeyboardState IKeyboardDriver2.GetState(int index) + { + IntPtr device; + if (KeyboardIndexToDevice.TryGetValue(index, out device)) + { + return KeyboardDevices[device]; + } + + return new KeyboardState(); + } + + string IKeyboardDriver2.GetDeviceName(int index) + { + IntPtr device; + if (KeyboardIndexToDevice.TryGetValue(index, out device)) + { + IntPtr vendor_id = NativeMethods.IOHIDDeviceGetProperty(device, NativeMethods.IOHIDVendorIDKey); + IntPtr product_id = NativeMethods.IOHIDDeviceGetProperty(device, NativeMethods.IOHIDProductIDKey); + // Todo: find out the real vendor/product name from the relevant ids. + return String.Format("{0}:{1}", vendor_id, product_id); + } + return String.Empty; + } + + #endregion + #region NativeMethods class NativeMethods { const string hid = "/System/Library/Frameworks/IOKit.framework/Versions/Current/IOKit"; + + public static readonly CFString IOHIDVendorIDKey = CF.CFSTR("VendorID"); + public static readonly CFString IOHIDVendorIDSourceKey = CF.CFSTR("VendorIDSource"); + public static readonly CFString IOHIDProductIDKey = CF.CFSTR("ProductID"); + public static readonly CFString IOHIDVersionNumberKey = CF.CFSTR("VersionNumber"); + public static readonly CFString IOHIDManufacturerKey = CF.CFSTR("Manufacturer"); + public static readonly CFString IOHIDProductKey = CF.CFSTR("Product"); public static readonly CFString IOHIDDeviceUsageKey = CF.CFSTR("DeviceUsage"); public static readonly CFString IOHIDDeviceUsagePageKey = CF.CFSTR("DeviceUsagePage"); public static readonly CFString IOHIDDeviceUsagePairsKey = CF.CFSTR("DeviceUsagePairs"); @@ -439,6 +568,369 @@ namespace OpenTK.Platform.MacOS Button_65535 = 0xFFFF } + enum HIDKey + { + ErrorRollOver = 0x01, /* ErrorRollOver */ + POSTFail = 0x02, /* POSTFail */ + ErrorUndefined = 0x03, /* ErrorUndefined */ + A = 0x04, /* a or A */ + B = 0x05, /* b or B */ + C = 0x06, /* c or C */ + D = 0x07, /* d or D */ + E = 0x08, /* e or E */ + F = 0x09, /* f or F */ + G = 0x0A, /* g or G */ + H = 0x0B, /* h or H */ + I = 0x0C, /* i or I */ + J = 0x0D, /* j or J */ + K = 0x0E, /* k or K */ + L = 0x0F, /* l or L */ + M = 0x10, /* m or M */ + N = 0x11, /* n or N */ + O = 0x12, /* o or O */ + P = 0x13, /* p or P */ + Q = 0x14, /* q or Q */ + R = 0x15, /* r or R */ + S = 0x16, /* s or S */ + T = 0x17, /* t or T */ + U = 0x18, /* u or U */ + V = 0x19, /* v or V */ + W = 0x1A, /* w or W */ + X = 0x1B, /* x or X */ + Y = 0x1C, /* y or Y */ + Z = 0x1D, /* z or Z */ + Number1 = 0x1E, /* 1 or ! */ + Number2 = 0x1F, /* 2 or @ */ + Number3 = 0x20, /* 3 or # */ + Number4 = 0x21, /* 4 or $ */ + Number5 = 0x22, /* 5 or % */ + Number6 = 0x23, /* 6 or ^ */ + Number7 = 0x24, /* 7 or & */ + Number8 = 0x25, /* 8 or * */ + Number9 = 0x26, /* 9 or ( */ + Number0 = 0x27, /* 0 or ) */ + ReturnOrEnter = 0x28, /* Return (Enter) */ + Escape = 0x29, /* Escape */ + DeleteOrBackspace = 0x2A, /* Delete (Backspace) */ + Tab = 0x2B, /* Tab */ + Spacebar = 0x2C, /* Spacebar */ + Hyphen = 0x2D, /* - or _ */ + EqualSign = 0x2E, /* = or + */ + OpenBracket = 0x2F, /* [ or { */ + CloseBracket = 0x30, /* ] or } */ + Backslash = 0x31, /* \ or | */ + NonUSPound = 0x32, /* Non-US # or _ */ + Semicolon = 0x33, /* ; or : */ + Quote = 0x34, /* ' or " */ + GraveAccentAndTilde = 0x35, /* Grave Accent and Tilde */ + Comma = 0x36, /* , or < */ + Period = 0x37, /* . or > */ + Slash = 0x38, /* / or ? */ + CapsLock = 0x39, /* Caps Lock */ + F1 = 0x3A, /* F1 */ + F2 = 0x3B, /* F2 */ + F3 = 0x3C, /* F3 */ + F4 = 0x3D, /* F4 */ + F5 = 0x3E, /* F5 */ + F6 = 0x3F, /* F6 */ + F7 = 0x40, /* F7 */ + F8 = 0x41, /* F8 */ + F9 = 0x42, /* F9 */ + F10 = 0x43, /* F10 */ + F11 = 0x44, /* F11 */ + F12 = 0x45, /* F12 */ + PrintScreen = 0x46, /* Print Screen */ + ScrollLock = 0x47, /* Scroll Lock */ + Pause = 0x48, /* Pause */ + Insert = 0x49, /* Insert */ + Home = 0x4A, /* Home */ + PageUp = 0x4B, /* Page Up */ + DeleteForward = 0x4C, /* Delete Forward */ + End = 0x4D, /* End */ + PageDown = 0x4E, /* Page Down */ + RightArrow = 0x4F, /* Right Arrow */ + LeftArrow = 0x50, /* Left Arrow */ + DownArrow = 0x51, /* Down Arrow */ + UpArrow = 0x52, /* Up Arrow */ + KeypadNumLock = 0x53, /* Keypad NumLock or Clear */ + KeypadSlash = 0x54, /* Keypad / */ + KeypadAsterisk = 0x55, /* Keypad * */ + KeypadHyphen = 0x56, /* Keypad - */ + KeypadPlus = 0x57, /* Keypad + */ + KeypadEnter = 0x58, /* Keypad Enter */ + Keypad1 = 0x59, /* Keypad 1 or End */ + Keypad2 = 0x5A, /* Keypad 2 or Down Arrow */ + Keypad3 = 0x5B, /* Keypad 3 or Page Down */ + Keypad4 = 0x5C, /* Keypad 4 or Left Arrow */ + Keypad5 = 0x5D, /* Keypad 5 */ + Keypad6 = 0x5E, /* Keypad 6 or Right Arrow */ + Keypad7 = 0x5F, /* Keypad 7 or Home */ + Keypad8 = 0x60, /* Keypad 8 or Up Arrow */ + Keypad9 = 0x61, /* Keypad 9 or Page Up */ + Keypad0 = 0x62, /* Keypad 0 or Insert */ + KeypadPeriod = 0x63, /* Keypad . or Delete */ + NonUSBackslash = 0x64, /* Non-US \ or | */ + Application = 0x65, /* Application */ + Power = 0x66, /* Power */ + KeypadEqualSign = 0x67, /* Keypad = */ + F13 = 0x68, /* F13 */ + F14 = 0x69, /* F14 */ + F15 = 0x6A, /* F15 */ + F16 = 0x6B, /* F16 */ + F17 = 0x6C, /* F17 */ + F18 = 0x6D, /* F18 */ + F19 = 0x6E, /* F19 */ + F20 = 0x6F, /* F20 */ + F21 = 0x70, /* F21 */ + F22 = 0x71, /* F22 */ + F23 = 0x72, /* F23 */ + F24 = 0x73, /* F24 */ + Execute = 0x74, /* Execute */ + Help = 0x75, /* Help */ + Menu = 0x76, /* Menu */ + Select = 0x77, /* Select */ + Stop = 0x78, /* Stop */ + Again = 0x79, /* Again */ + Undo = 0x7A, /* Undo */ + Cut = 0x7B, /* Cut */ + Copy = 0x7C, /* Copy */ + Paste = 0x7D, /* Paste */ + Find = 0x7E, /* Find */ + Mute = 0x7F, /* Mute */ + VolumeUp = 0x80, /* Volume Up */ + VolumeDown = 0x81, /* Volume Down */ + LockingCapsLock = 0x82, /* Locking Caps Lock */ + LockingNumLock = 0x83, /* Locking Num Lock */ + LockingScrollLock = 0x84, /* Locking Scroll Lock */ + KeypadComma = 0x85, /* Keypad Comma */ + KeypadEqualSignAS400 = 0x86, /* Keypad Equal Sign for AS/400 */ + International1 = 0x87, /* International1 */ + International2 = 0x88, /* International2 */ + International3 = 0x89, /* International3 */ + International4 = 0x8A, /* International4 */ + International5 = 0x8B, /* International5 */ + International6 = 0x8C, /* International6 */ + International7 = 0x8D, /* International7 */ + International8 = 0x8E, /* International8 */ + International9 = 0x8F, /* International9 */ + LANG1 = 0x90, /* LANG1 */ + LANG2 = 0x91, /* LANG2 */ + LANG3 = 0x92, /* LANG3 */ + LANG4 = 0x93, /* LANG4 */ + LANG5 = 0x94, /* LANG5 */ + LANG6 = 0x95, /* LANG6 */ + LANG7 = 0x96, /* LANG7 */ + LANG8 = 0x97, /* LANG8 */ + LANG9 = 0x98, /* LANG9 */ + AlternateErase = 0x99, /* AlternateErase */ + SysReqOrAttention = 0x9A, /* SysReq/Attention */ + Cancel = 0x9B, /* Cancel */ + Clear = 0x9C, /* Clear */ + Prior = 0x9D, /* Prior */ + Return = 0x9E, /* Return */ + Separator = 0x9F, /* Separator */ + Out = 0xA0, /* Out */ + Oper = 0xA1, /* Oper */ + ClearOrAgain = 0xA2, /* Clear/Again */ + CrSelOrProps = 0xA3, /* CrSel/Props */ + ExSel = 0xA4, /* ExSel */ + /* 0xA5-0xDF Reserved */ + LeftControl = 0xE0, /* Left Control */ + LeftShift = 0xE1, /* Left Shift */ + LeftAlt = 0xE2, /* Left Alt */ + LeftGUI = 0xE3, /* Left GUI */ + RightControl = 0xE4, /* Right Control */ + RightShift = 0xE5, /* Right Shift */ + RightAlt = 0xE6, /* Right Alt */ + RightGUI = 0xE7, /* Right GUI */ + /* 0xE8-0xFFFF Reserved */ + //_Reserved = 0xFFFF + } + + // Maps HIDKey to OpenTK.Input.Key. + static readonly Key[] RawKeyMap = new Key[] + { + Key.Unknown, + Key.Unknown, /* ErrorRollOver */ + Key.Unknown, /* POSTFail */ + Key.Unknown, /* ErrorUndefined */ + Key.A, /* a or A */ + Key.B, /* b or B */ + Key.C, /* c or C */ + Key.D, /* d or D */ + Key.E, /* e or E */ + Key.F, /* f or F */ + Key.G, /* g or G */ + Key.H, /* h or H */ + Key.I, /* i or I */ + Key.J, /* j or J */ + Key.K, /* k or K */ + Key.L, /* l or L */ + Key.M, /* m or M */ + Key.N, /* n or N */ + Key.O, /* o or O */ + Key.P, /* p or P */ + Key.Q, /* q or Q */ + Key.R, /* r or R */ + Key.S, /* s or S */ + Key.T, /* t or T */ + Key.U, /* u or U */ + Key.V, /* v or V */ + Key.W, /* w or W */ + Key.X, /* x or X */ + Key.Y, /* y or Y */ + Key.Z, /* z or Z */ + Key.Number1, /* 1 or ! */ + Key.Number2, /* 2 or @ */ + Key.Number3, /* 3 or # */ + Key.Number4, /* 4 or $ */ + Key.Number5, /* 5 or % */ + Key.Number6, /* 6 or ^ */ + Key.Number7, /* 7 or & */ + Key.Number8, /* 8 or * */ + Key.Number9, /* 9 or ( */ + Key.Number0, /* 0 or ) */ + Key.Enter, /* Return (Enter) */ + Key.Escape, /* Escape */ + Key.BackSpace, /* Delete (Backspace) */ + Key.Tab, /* Tab */ + Key.Space, /* Spacebar */ + Key.Minus, /* - or _ */ + Key.Plus, /* = or + */ + Key.BracketLeft, /* [ or { */ + Key.BracketRight, /* ] or } */ + Key.BackSlash, /* \ or | */ + Key.Minus, /* Non-US # or _ */ + Key.Semicolon, /* ; or : */ + Key.Quote, /* ' or " */ + Key.Tilde, /* Grave Accent and Tilde */ + Key.Comma, /* , or < */ + Key.Period, /* . or > */ + Key.Slash, /* / or ? */ + Key.CapsLock, /* Caps Lock */ + Key.F1, /* F1 */ + Key.F2, /* F2 */ + Key.F3, /* F3 */ + Key.F4, /* F4 */ + Key.F5, /* F5 */ + Key.F6, /* F6 */ + Key.F7, /* F7 */ + Key.F8, /* F8 */ + Key.F9, /* F9 */ + Key.F10, /* F10 */ + Key.F11, /* F11 */ + Key.F12, /* F12 */ + Key.PrintScreen, /* Print Screen */ + Key.ScrollLock, /* Scroll Lock */ + Key.Pause, /* Pause */ + Key.Insert, /* Insert */ + Key.Home, /* Home */ + Key.PageUp, /* Page Up */ + Key.Delete, /* Delete Forward */ + Key.End, /* End */ + Key.PageDown, /* Page Down */ + Key.Right, /* Right Arrow */ + Key.Left, /* Left Arrow */ + Key.Down, /* Down Arrow */ + Key.Up, /* Up Arrow */ + Key.NumLock, /* Keypad NumLock or Clear */ + Key.KeypadDivide, /* Keypad / */ + Key.KeypadMultiply, /* Keypad * */ + Key.KeypadMinus, /* Keypad - */ + Key.KeypadPlus, /* Keypad + */ + Key.KeypadEnter, /* Keypad Enter */ + Key.Keypad1, /* Keypad 1 or End */ + Key.Keypad2, /* Keypad 2 or Down Arrow */ + Key.Keypad3, /* Keypad 3 or Page Down */ + Key.Keypad4, /* Keypad 4 or Left Arrow */ + Key.Keypad5, /* Keypad 5 */ + Key.Keypad6, /* Keypad 6 or Right Arrow */ + Key.Keypad7, /* Keypad 7 or Home */ + Key.Keypad8, /* Keypad 8 or Up Arrow */ + Key.Keypad9, /* Keypad 9 or Page Up */ + Key.Keypad0, /* Keypad 0 or Insert */ + Key.KeypadDecimal, /* Keypad . or Delete */ + Key.BackSlash, /* Non-US \ or | */ + Key.Unknown, /* Application */ + Key.Unknown, /* Power */ + Key.Unknown, /* Keypad = */ + Key.F13, /* F13 */ + Key.F14, /* F14 */ + Key.F15, /* F15 */ + Key.F16, /* F16 */ + Key.F17, /* F17 */ + Key.F18, /* F18 */ + Key.F19, /* F19 */ + Key.F20, /* F20 */ + Key.F21, /* F21 */ + Key.F22, /* F22 */ + Key.F23, /* F23 */ + Key.F24, /* F24 */ + Key.Unknown, /* Execute */ + Key.Unknown, /* Help */ + Key.Menu, /* Menu */ + Key.Unknown, /* Select */ + Key.Unknown, /* Stop */ + Key.Unknown, /* Again */ + Key.Unknown, /* Undo */ + Key.Unknown, /* Cut */ + Key.Unknown, /* Copy */ + Key.Unknown, /* Paste */ + Key.Unknown, /* Find */ + Key.Unknown, /* Mute */ + Key.Unknown, /* Volume Up */ + Key.Unknown, /* Volume Down */ + Key.CapsLock, /* Locking Caps Lock */ + Key.NumLock , /* Locking Num Lock */ + Key.ScrollLock, /* Locking Scroll Lock */ + Key.KeypadDecimal, /* Keypad Comma */ + Key.Unknown, /* Keypad Equal Sign for AS/400 */ + Key.Unknown, /* International1 */ + Key.Unknown, /* International2 */ + Key.Unknown, /* International3 */ + Key.Unknown, /* International4 */ + Key.Unknown, /* International5 */ + Key.Unknown, /* International6 */ + Key.Unknown, /* International7 */ + Key.Unknown, /* International8 */ + Key.Unknown, /* International9 */ + Key.Unknown, /* LANG1 */ + Key.Unknown, /* LANG2 */ + Key.Unknown, /* LANG3 */ + Key.Unknown, /* LANG4 */ + Key.Unknown, /* LANG5 */ + Key.Unknown, /* LANG6 */ + Key.Unknown, /* LANG7 */ + Key.Unknown, /* LANG8 */ + Key.Unknown, /* LANG9 */ + Key.Unknown, /* AlternateErase */ + Key.Unknown, /* SysReq/Attention */ + Key.Unknown, /* Cancel */ + Key.Unknown, /* Clear */ + Key.Unknown, /* Prior */ + Key.Enter, /* Return */ + Key.Unknown, /* Separator */ + Key.Unknown, /* Out */ + Key.Unknown, /* Oper */ + Key.Unknown, /* Clear/Again */ + Key.Unknown, /* CrSel/Props */ + Key.Unknown, /* ExSel */ + /* 0xA5-0xDF Reserved */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + Key.LControl, /* Left Control */ + Key.LShift, /* Left Shift */ + Key.LAlt, /* Left Alt */ + Key.LWin, /* Left GUI */ + Key.RControl, /* Right Control */ + Key.RShift, /* Right Shift */ + Key.RAlt, /* Right Alt */ + Key.RWin, /* Right GUI */ + /* 0xE8-0xFFFF Reserved */ + }; + #endregion } } diff --git a/Source/OpenTK/Platform/MacOS/MacOSFactory.cs b/Source/OpenTK/Platform/MacOS/MacOSFactory.cs index 07c3a968..066e2879 100644 --- a/Source/OpenTK/Platform/MacOS/MacOSFactory.cs +++ b/Source/OpenTK/Platform/MacOS/MacOSFactory.cs @@ -28,6 +28,7 @@ using System; using System.Collections.Generic; using System.Text; +using OpenTK.Input; namespace OpenTK.Platform.MacOS { @@ -35,6 +36,12 @@ namespace OpenTK.Platform.MacOS class MacOSFactory : IPlatformFactory { + #region Fields + + readonly IInputDriver2 InputDriver = new HIDInput(); + + #endregion + #region IPlatformFactory Members public virtual INativeWindow CreateNativeWindow(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) @@ -72,12 +79,12 @@ namespace OpenTK.Platform.MacOS public virtual OpenTK.Input.IKeyboardDriver2 CreateKeyboardDriver() { - throw new NotImplementedException(); + return InputDriver.KeyboardDriver; } public virtual OpenTK.Input.IMouseDriver2 CreateMouseDriver() { - return new HIDInput(); + return InputDriver.MouseDriver; } #endregion From 140a278b3eee917a1fcac0efa930d4f3c5bfbc80 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 3 Dec 2010 12:29:01 +0000 Subject: [PATCH 128/130] Do not try to register device when device description is empty. --- Source/OpenTK/Platform/Windows/WinRawKeyboard.cs | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index ecf3e0df..9b2a1989 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -103,7 +103,16 @@ namespace OpenTK.Platform.Windows RegistryKey regkey = GetRegistryKey(name); string deviceDesc = (string)regkey.GetValue("DeviceDesc"); string deviceClass = (string)regkey.GetValue("Class"); - deviceDesc = deviceDesc.Substring(deviceDesc.LastIndexOf(';') + 1); + + if (String.IsNullOrEmpty(deviceDesc)) + { + Debug.Print("[Warning] Failed to retrieve device description, skipping this device."); + continue; + } + else + { + deviceDesc = deviceDesc.Substring(deviceDesc.LastIndexOf(';') + 1); + } if (!String.IsNullOrEmpty(deviceClass) && deviceClass.ToLower().Equals("keyboard")) { From 6470f1da3af74ddbeb999f880bdfc646d4dfbb96 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 3 Dec 2010 12:39:42 +0000 Subject: [PATCH 129/130] Disabled GetDeviceName until the correct cross-platform API can be determined. --- Source/OpenTK/Input/Keyboard.cs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Source/OpenTK/Input/Keyboard.cs b/Source/OpenTK/Input/Keyboard.cs index d923f3be..09116aa1 100644 --- a/Source/OpenTK/Input/Keyboard.cs +++ b/Source/OpenTK/Input/Keyboard.cs @@ -74,6 +74,9 @@ namespace OpenTK.Input } } +#if false + // Disabled until a correct, cross-platform API can be defined. + /// /// Retrieves the device name for the keyboard device. /// @@ -91,6 +94,7 @@ namespace OpenTK.Input return driver.GetDeviceName(index); } } +#endif #endregion } From 2412757397319c97c76aede84b8a1fb2f552e98d Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Fri, 3 Dec 2010 12:40:10 +0000 Subject: [PATCH 130/130] Added documentation for IsConnected and added (disabled) IsLedOn/IsLedOff methods. --- Source/OpenTK/Input/KeyboardState.cs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/Source/OpenTK/Input/KeyboardState.cs b/Source/OpenTK/Input/KeyboardState.cs index ee1ddfd7..d37c60da 100644 --- a/Source/OpenTK/Input/KeyboardState.cs +++ b/Source/OpenTK/Input/KeyboardState.cs @@ -85,12 +85,29 @@ namespace OpenTK.Input return !ReadBit((int)key); } + /// + /// Gets a indicating whether this keyboard + /// is connected. + /// public bool IsConnected { get { return is_connected; } internal set { is_connected = value; } } +#if false + // Disabled until the correct cross-platform API can be determined. + public bool IsLedOn(KeyboardLeds led) + { + return false; + } + + public bool IsLedOff(KeyboardLeds led) + { + return false; + } +#endif + /// /// Checks whether two instances are equal. ///