/* * Copyright (c) 2002-2004 LWJGL Project * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * * Redistributions 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 'LWJGL' nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package org.lwjgl.opengl; import org.lwjgl.LWJGLException; import org.lwjgl.Sys; import java.lang.reflect.Method; import java.util.*; /** * $Id$ *
* Manages GL contexts. Before any rendering is done by a LWJGL system, a call should be made to GLContext.useContext() with a * context. This will ensure that GLContext has an accurate reflection of the current context's capabilities and function * pointers. * * This class is thread-safe in the sense that multiple threads can safely call all public methods. The class is also * thread-aware in the sense that it tracks a per-thread current context (including capabilities and function pointers). * That way, multiple threads can have multiple contexts current and render to them concurrently. * * @author elias_naurIf the context is the same as last time, then this is * a no-op.
If the context has not been encountered before it will be fully initialized from scratch. Otherwise a cached set * of caps and function pointers will be used.
The reference to the context is held in a weak reference; therefore if no * strong reference exists to the GL context it will automatically be forgotten by the VM at an indeterminate point in the * future, freeing up a little RAM. * * @param context The context object, which uniquely identifies a GL context. If context is null, the native stubs are * unloaded. * * @throws LWJGLException if context non-null, and the gl library can't be loaded or the basic GL11 functions can't be loaded */ public static synchronized void useContext(Object context) throws LWJGLException { if (context == null) { ContextCapabilities.unloadAllStubs(); setCapabilities(null); if (did_auto_load) unloadOpenGLLibrary(); return; } if (gl_ref_count == 0) { loadOpenGLLibrary(); did_auto_load = true; } try { ContextCapabilities capabilities = (ContextCapabilities)capability_cache.get(context); if (capabilities == null) { /* * The capabilities object registers itself as current. This behaviour is caused * by a chicken-and-egg situation where the constructor needs to call GL functions * as part of its capability discovery, but GL functions cannot be called before * a capabilities object has been set. */ new ContextCapabilities(); capability_cache.put(context, getCapabilities()); } else setCapabilities(capabilities); } catch (LWJGLException e) { if (did_auto_load) unloadOpenGLLibrary(); throw e; } } /** If the OpenGL reference count is 0, the library is loaded. The reference count is then incremented. */ public static synchronized void loadOpenGLLibrary() throws LWJGLException { if (gl_ref_count == 0) nLoadOpenGLLibrary(); gl_ref_count++; } private static native void nLoadOpenGLLibrary() throws LWJGLException; /** The OpenGL library reference count is decremented, and if it reaches 0, the library is unloaded. */ public static synchronized void unloadOpenGLLibrary() { gl_ref_count--; if ( gl_ref_count == 0 ) nUnloadOpenGLLibrary(); } private static native void nUnloadOpenGLLibrary(); /** Native method to clear native stub bindings */ static native void resetNativeStubs(Class clazz); }