Provides a virtual machine- and operating system-independent mechanism for creating {@link GLDrawable}s.
The {@link javax.media.opengl.GLCapabilities} objects passed in to the various factory methods are used as a hint for the properties of the returned drawable. The default capabilities selection algorithm (equivalent to passing in a null {@link GLCapabilitiesChooser}) is described in {@link DefaultGLCapabilitiesChooser}. Sophisticated applications needing to change the selection algorithm may pass in their own {@link GLCapabilitiesChooser} which can select from the available pixel formats.
Because of the multithreaded nature of the Java platform's
window system toolkit, it is typically not possible to immediately
reject a given {@link GLCapabilities} as being unsupportable by
either returning null from the creation routines or
raising a {@link GLException}. The semantics of the rejection
process are (unfortunately) left unspecified for now. The current
implementation will cause a {@link GLException} to be raised
during the first repaint of the {@link GLCanvas} or {@link
GLJPanel} if the capabilities can not be met. Pbuffers are always
created immediately and their creation will fail with a {@link
GLException} if errors occur.
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(). */
public GLCanvas createGLCanvas(GLCapabilities capabilities,
GLCapabilitiesChooser chooser,
GLContext shareWith,
GraphicsDevice device) {
return new GLCanvas(capabilities,
chooser,
shareWith,
device);
}
/** Creates a {@link GLJPanel} with the specified capabilities using
the default capabilities selection algorithm. */
public GLJPanel createGLJPanel(GLCapabilities capabilities) {
return createGLJPanel(capabilities, null, null);
}
/** Creates a {@link GLJPanel} with the specified capabilities using
the supplied capabilities selection algorithm. A null chooser is
equivalent to using the {@link DefaultGLCapabilitiesChooser}.
The panel will share textures and display lists with the
specified {@link GLContext}; the context must either be null or
have been fabricated by classes in this package. A null context
indicates no sharing. */
public GLJPanel createGLJPanel(GLCapabilities capabilities,
GLCapabilitiesChooser chooser,
GLContext shareWith) {
return new GLJPanel(capabilities, chooser, shareWith);
}
/**
* Returns true if it is possible to create a GLPbuffer. Some older
* graphics cards do not have this capability.
*/
public abstract boolean canCreateGLPbuffer();
/**
* Creates a GLPbuffer with the given capabilites and dimensions.
*/
public abstract GLPbuffer createGLPbuffer(GLCapabilities capabilities,
int initialWidth,
int initialHeight,
GLContext shareWith);
//----------------------------------------------------------------------
// Methods for interacting with third-party OpenGL libraries
/**
* Creates a GLContext object representing an existing OpenGL * context in an external (third-party) OpenGL-based library. This * GLContext object may be used to draw into this preexisting * context using its {@link GL} and {@link * javax.media.opengl.glu.GLU} objects. New contexts created through * {@link GLDrawable}s may share textures and display lists with * this external context.
* * The underlying OpenGL context must be current on the current
* thread at the time this method is called. The user is responsible
* for the maintenance of the underlying OpenGL context; calls to
* makeCurrent and release on the returned
* GLContext object have no effect. If the underlying OpenGL context
* is destroyed, the destroy method should be called on
* the GLContext. A new GLContext object
* should be created for each newly-created underlying OpenGL
* context.
*/
public abstract GLContext createExternalGLContext();
/**
* Returns true if it is possible to create an external GLDrawable
* object via {@link #createExternalGLDrawable}.
*/
public abstract boolean canCreateExternalGLDrawable();
/**
*
Creates a {@link GLDrawable} object representing an existing * OpenGL drawable in an external (third-party) OpenGL-based * library. This GLDrawable object may be used to create new, * fully-functional {@link GLContext}s on the OpenGL drawable. This * is useful when interoperating with a third-party OpenGL-based * library and it is essential to not perturb the state of the * library's existing context, even to the point of not sharing * textures or display lists with that context.
* *An underlying OpenGL context must be current on the desired * drawable and the current thread at the time this method is * called. The user is responsible for the maintenance of the * underlying drawable. If one or more contexts are created on the * drawable using {@link GLDrawable#createContext}, and the drawable * is deleted by the third-party library, the user is responsible * for calling {@link GLContext#destroy} on these contexts.
* * Calls to setSize, getWidth and
* getHeight are illegal on the returned GLDrawable. If
* these operations are required by the user, they must be performed
* by the third-party library.
It is legal to create both an external GLContext and * GLDrawable representing the same third-party OpenGL entities. * This can be used, for example, to query current state information * using the external GLContext and then create and set up new * GLContexts using the external GLDrawable.
* *This functionality may not be available on all platforms and * {@link #canCreateExternalGLDrawable} should be called first to * see if it is present. For example, on X11 platforms, this API * requires the presence of GLX 1.3 or later. */ public abstract GLDrawable createExternalGLDrawable(); }