Collaboration diagram for Deleted API Features:
|
As gleandev is a new, experimental project, and has not yet had any releases, the only "lost" features listed will be those that relate to OpenGLEAN device suport yet which are not part of gleandev. These never-included features may in time not even be listed.
void glutJoystickFunc (
void (*callback)
(unsigned int buttons, int xaxis, int yaxis, int zaxis),
int pollInterval
)
The old GLUT API defined a joystick callback mechanism, via glutJoystickFunc(). This supported up to 4 buttons and up to 3 axes on a single joystick. The buttons were reported as a bitmask, while the axes were reported as integer values in the range [-1000,1000]. The callback was structured as an event, but worked by polling the joystick interface at regular intervals. When you registered a joystick callback, you specified the time interval for polling in milliseconds.
GLUT made the joystick pseudo-events tied to windows, allowing up to 1 joystick event callback to be attached to each GLUT window.
Portability notes
It is not clear when or if GLUT ever has a proper release with joystick support. GLUT ceased development during a phase when game-oriented features were being added.
gleandev offers a gleandevGet*() interface that allows you to explicitly poll the joystick buttons and axes on demand. You can either wrap a standard GLUT timer around this, or simply do a direct poll of the hardware when you want to know its status.
The old interface used fixed-point axes, and had a more limited support for buttons and numbers of axes. Consequently, while it worked, it was less flexible than the new form.
void glutForceJoystickFunc (void)
Although GLUT lacked any way to poll joysticks directly, there was some support (believed to be a freeglut innovation) to let the client force the library to poll the joystick on-demand, short-circuting the timer mechanism.
The callbacks implied by the joystick poll would be issued and returned before glutForceJoystickFunc() returned.
Portability notes
This feature is believed to go back no further than freeglut.
Because this function would force a second layer of callbacks, and would normally itself be invoked from within a callback, there is a tiny risk that a careless client could get into a recursion loop that would cause the application to crash when stack space was exhausted.
Instead of forcing a poll-and-callback, you are encouraged to simply use gleandevGet*() to query the current status of the joystick. Aside from removing the remote danger of blowing your stack, the interface is more in keeping with the OpenGL glGet*(), et al, approach to state management.
glutButtonBoxFunc (void (*callback) (int button, int state));
Button boxes, dials boxes, and dials-and-buttons boxes provided an array of scalar/boolean input devices to give mutlidimensional input to applications, without requiring or tying up a mouse.
Provides a callback to handle button-presses as received from a "button box" or "dials-and-buttons box". button would indicate which button had changed state and state would be one of GLUT_UP or GLUT_DOWN. A glutGet() call could tell you how many buttons you might expect.
Note the absence of an timer interval in the function prototype. However, these devices do not appear to have operated under a window system, and may or may not have been capable of asynchronous events, so there is no obvious reason to retain the API entry in OpenGLEAN's core.
Portability notes
These devices are rare, but not quite extinct.
There is no way to support more than one button box, except by having the library transparently combine the button sets to create a single, large, logical button box.
This feature was not originally implemented in freeglut; it was only in stub-form. Hence its removal here does not mean any loss of functionality. Code has recently come to light that may provide UNIX-like and/or MS-Windows support, and which may be suitably licensed for inclusion in gleandev. Presumably it is based on polling support.
At this time, there is no replacement support in either OpenGLEAN or gleandev.
glutDialsFunc (void (*callback) (int dial, int value));
Similar to glutButtonBoxFunc(), with similar limitations. The dial indicated which dial was being reported, while value was an absolute measurement in degrees (so sub-degree resolution was impossible.
glutSpaceballButtonFunc (void (*callback) (int button, int state));
The spaceball provided a mechanical input device allowing you to provide both position or directional information in three dimensions while also allowing you to apply torque to the ball to give rotational information.
Similar to glutButtonBoxFunc(), with similar limitations.
glutSpaceballMotionFunc (void (*callback) (int x, int y, int z));
Similar to glutButtonBoxFunc(). See also glutSpaceballButtonFunc() for brief overview of the spaceball.
The x, y, and z values were integer values in the range [-1000,1000].
glutSpaceballRotateFunc (void (*callback) (int x, int y, int z));
Similar to glutButtonBoxFunc(). See also glutSpaceballButtonFunc() for brief overview of the spaceball.
the x, y, and z values were integer values in the range [-1800,1800], specifying rotation about the respective axes. Presumably to recreate the actual rotation, one would apply each axis in the order listed here via a glRotated(), or equivalent. The range suggests that the ball could rotate up to 180 degrees from at-rest in any direction, but the actual rotation limits may have been smaller.
glutTabletButtonFunc (
void (*callback) (int button, int state, int x, int y)
);
Similar to glutButtonBoxFunc() with similar limitations.
A tablet is a planar surface with some kind of input locus (a puck or stylus). The position of the locus is intended to have an absolute position on your display, just as it is absolute on the planar surface. I.e., the planar surface corresponds to your display, window, or some rectangular portion thereof.
Portability notes
In addition to the general issues common to many of these (see glutButtonBoxFunc() ), the tablet as GLUT defined the interface has a resolution limit of 1000x1000, which means that it is not capable of per-pixel resolution on modern displays.
The aspect ratio of the planar surface may not match that of your display (much less window).
The GLUT API also does not recognize pressure-sensitive nibs, which are more commonplace on modern tablets.
For these reasons, the GLUT tablet interface is deemed to be particularly deficient for modern devices.
glutTabletMotionFunc (void (*callback) (int x, int y));
Similar to glutButtonBoxFunc() with similar limitations. See also glutTabletButtonFunc() for an overview of tablets and some specific portability notes for tablet hardware.
Supported in part by SourceForge.net.
Generated on Fri Sep 9 18:01:36 2005 for gleandev by
doxygen 1.4.3
The OpenGLEAN project is hosted in part by
SourceForge.