/* * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * - Redistribution of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistribution in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of Sun Microsystems, Inc. or the names of * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * This software is provided "AS IS," without a warranty of any kind. ALL * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. * * You acknowledge that this software is not designed or intended for use * in the design, construction, operation or maintenance of any nuclear * facility. * * Sun gratefully acknowledges that this software was originally authored * and developed by Kenneth Bradley Russell and Christopher John Kline. */ package com.sun.opengl.impl; import java.awt.Component; import java.nio.*; import javax.media.opengl.*; import com.sun.gluegen.runtime.*; public abstract class GLContextImpl extends GLContext { protected GLContextLock lock = new GLContextLock(); protected static final boolean DEBUG = Debug.debug("GLContextImpl"); protected static final boolean VERBOSE = Debug.verbose(); protected static final boolean NO_FREE = Debug.isPropertyDefined("jogl.GLContext.nofree"); // Cache of the functions that are available to be called at the current // moment in time protected FunctionAvailabilityCache functionAvailability; // Table that holds the addresses of the native C-language entry points for // OpenGL functions. private GLProcAddressTable glProcAddressTable; // Tracks creation and deletion of server-side OpenGL objects when // the Java2D/OpenGL pipeline is active and using FBOs to render private GLObjectTracker tracker; protected GL gl; public GLContextImpl(GLContext shareWith) { this(shareWith, false); } public GLContextImpl(GLContext shareWith, boolean dontShareWithJava2D) { setGL(createGL()); functionAvailability = new FunctionAvailabilityCache(this); GLContext shareContext = shareWith; if (!dontShareWithJava2D) { shareContext = Java2D.filterShareContext(shareWith); } if (shareContext != null) { GLContextShareSet.registerSharing(this, shareContext); } GLContextShareSet.registerForObjectTracking(shareWith, this); } public int makeCurrent() throws GLException { // Support calls to makeCurrent() over and over again with // different contexts without releasing them // Could implement this more efficiently without explicit // releasing of the underlying context; would require more error // checking during the makeCurrentImpl phase GLContext current = getCurrent(); if (current != null) { if (current == this) { // Assume we don't need to make this context current again return CONTEXT_CURRENT; } else { current.release(); } } lock.lock(); int res = 0; try { res = makeCurrentImpl(); if ((tracker != null) && (res == CONTEXT_CURRENT_NEW)) { // Increase reference count of GLObjectTracker tracker.ref(); } } catch (GLException e) { lock.unlock(); throw(e); } if (res == CONTEXT_NOT_CURRENT) { lock.unlock(); } else { setCurrent(this); } return res; } protected abstract int makeCurrentImpl() throws GLException; public void release() throws GLException { if (!lock.isHeld()) { throw new GLException("Context not current on current thread"); } setCurrent(null); try { releaseImpl(); } finally { lock.unlock(); } } protected abstract void releaseImpl() throws GLException; public void destroy() { if (lock.isHeld()) { throw new GLException("Can not destroy context while it is current"); } if (tracker != null) { // Don't need to do anything for contexts that haven't been // created yet if (isCreated()) { // If we are tracking creation and destruction of server-side // OpenGL objects, we must decrement the reference count of the // GLObjectTracker upon context destruction. try { int res = makeCurrent(); if (res != CONTEXT_CURRENT) { // FIXME: we really need to behave better than this throw new GLException("Unable to make context current to destroy tracked server-side OpenGL objects"); } try { tracker.unref(getGL()); } finally { release(); } } catch (GLException e) { // FIXME: should probably do something more intelligent here if (DEBUG) { e.printStackTrace(); } } } } // Must hold the lock around the destroy operation to make sure we // don't destroy the context out from under another thread rendering to it lock.lock(); try { destroyImpl(); } finally { lock.unlock(); } } protected abstract void destroyImpl() throws GLException; public boolean isSynchronized() { return !lock.getFailFastMode(); } public void setSynchronized(boolean isSynchronized) { lock.setFailFastMode(!isSynchronized); } public GL getGL() { return gl; } public void setGL(GL gl) { this.gl = gl; } public abstract Object getPlatformGLExtensions(); //---------------------------------------------------------------------- // Helpers for various context implementations // /** Create the GL for this context. */ protected GL createGL() { GLImpl gl = new GLImpl(this); if (tracker != null) { gl.setObjectTracker(tracker); } return gl; } public GLProcAddressTable getGLProcAddressTable() { if (glProcAddressTable == null) { // FIXME: cache ProcAddressTables by capability bits so we can // share them among contexts with the same capabilities glProcAddressTable = new GLProcAddressTable(); } return glProcAddressTable; } /** * Pbuffer support; given that this is a GLContext associated with a * pbuffer, binds this pbuffer to its texture target. */ public abstract void bindPbufferToTexture(); /** * Pbuffer support; given that this is a GLContext associated with a * pbuffer, releases this pbuffer from its texture target. */ public abstract void releasePbufferFromTexture(); public abstract ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3); /* * Sets the swap interval for onscreen OpenGL contexts. Has no * effect for offscreen contexts. */ public void setSwapInterval(final int interval) { } /** Maps the given "platform-independent" function name to a real function name. Currently this is only used to map "glAllocateMemoryNV" and associated routines to wglAllocateMemoryNV / glXAllocateMemoryNV. */ protected abstract String mapToRealGLFunctionName(String glFunctionName); /** Maps the given "platform-independent" extension name to a real function name. Currently this is only used to map "GL_ARB_pbuffer" and "GL_ARB_pixel_format" to "WGL_ARB_pbuffer" and "WGL_ARB_pixel_format" (not yet mapped to X11). */ protected abstract String mapToRealGLExtensionName(String glExtensionName); /** Returns a non-null (but possibly empty) string containing the space-separated list of available platform-dependent (e.g., WGL, GLX) extensions. Can only be called while this context is current. */ public abstract String getPlatformExtensionsString(); /** Helper routine which resets a ProcAddressTable generated by the GLEmitter by looking up anew all of its function pointers. */ protected void resetProcAddressTable(Object table) { ProcAddressHelper.resetProcAddressTable(table, GLDrawableFactoryImpl.getFactoryImpl()); } /** Indicates whether the underlying OpenGL context has been created. This is used to manage sharing of display lists and textures between contexts. */ public abstract boolean isCreated(); /** * Resets the cache of which GL functions are available for calling through this * context. See {@link #isFunctionAvailable(String)} for more information on * the definition of "available". */ protected void resetGLFunctionAvailability() { // In order to be able to allow the user to uniformly install the // debug and trace pipelines in their GLEventListener.init() // method (for both GLCanvas and GLJPanel), we need to reset the // actual GL object in the GLDrawable as well setGL(createGL()); functionAvailability.flush(); if (DEBUG) { System.err.println(getThreadName() + ": !!! Initializing OpenGL extension address table for " + this); } resetProcAddressTable(getGLProcAddressTable()); } /** * Returns true if the specified OpenGL core- or extension-function can be * successfully called using this GL context given the current host (OpenGL * <i>client</i>) and display (OpenGL <i>server</i>) configuration. * * See {@link GL#isFunctionAvailable(String)} for more details. * * @param glFunctionName the name of the OpenGL function (e.g., use * "glPolygonOffsetEXT" to check if the {@link * javax.media.opengl.GL#glPolygonOffsetEXT(float,float)} is available). */ protected boolean isFunctionAvailable(String glFunctionName) { return functionAvailability.isFunctionAvailable(mapToRealGLFunctionName(glFunctionName)); } /** * Returns true if the specified OpenGL extension can be * successfully called using this GL context given the current host (OpenGL * <i>client</i>) and display (OpenGL <i>server</i>) configuration. * * See {@link GL#isExtensionAvailable(String)} for more details. * * @param glExtensionName the name of the OpenGL extension (e.g., * "GL_VERTEX_PROGRAM_ARB"). */ public boolean isExtensionAvailable(String glExtensionName) { return functionAvailability.isExtensionAvailable(mapToRealGLExtensionName(glExtensionName)); } /** Indicates which floating-point pbuffer implementation is in use. Returns one of GLPbuffer.APPLE_FLOAT, GLPbuffer.ATI_FLOAT, or GLPbuffer.NV_FLOAT. */ public int getFloatingPointMode() throws GLException { throw new GLException("Not supported on non-pbuffer contexts"); } /** On some platforms the mismatch between OpenGL's coordinate system (origin at bottom left) and the window system's coordinate system (origin at top left) necessitates a vertical flip of pixels read from offscreen contexts. */ public abstract boolean offscreenImageNeedsVerticalFlip(); /** Only called for offscreen contexts; needed by glReadPixels */ public abstract int getOffscreenContextPixelDataType(); protected static String getThreadName() { return Thread.currentThread().getName(); } public static String toHexString(long hex) { return "0x" + Long.toHexString(hex); } public void setObjectTracker(GLObjectTracker tracker) { this.tracker = tracker; } public GLObjectTracker getObjectTracker() { return tracker; } }