@Test public void test01_DefaultNorm() throws AWTException, InterruptedException, InvocationTargetException { final GLProfile glp; if (forceGL3) { glp = GLProfile.get(GLProfile.GL3); } else if (forceES3) { glp = GLProfile.get(GLProfile.GLES3); } else if (forceES2) { glp = GLProfile.get(GLProfile.GLES2); } else if (forceGLFFP) { glp = GLProfile.getMaxFixedFunc(true); } else { glp = GLProfile.getDefault(); } final GLCapabilities caps = new GLCapabilities(glp); if (useMSAA) { caps.setNumSamples(msaaNumSamples); caps.setSampleBuffers(true); } if (shallUsePBuffer) { caps.setPBuffer(true); } if (shallUseBitmap) { caps.setBitmap(true); } runTestGL(caps); }
static GLCapabilities getCaps(final String profile) { if (!GLProfile.isAvailable(profile)) { System.err.println("Profile " + profile + " n/a"); return null; } return new GLCapabilities(GLProfile.get(profile)); }
@BeforeClass public static void initClass() { if (GLProfile.isAvailable(GLProfile.GL2ES2)) { glp = GLProfile.get(GLProfile.GL2ES2); Assert.assertNotNull(glp); caps = new GLCapabilities(glp); Assert.assertNotNull(caps); width = 256; height = 256; } else { setTestSupported(false); } }
@Test public void test40_GL3() throws AWTException, InterruptedException, InvocationTargetException { if (manualTest) { return; } if (!GLProfile.isAvailable(GLProfile.GL3)) { System.err.println("GL3 n/a"); return; } final GLProfile glp = GLProfile.get(GLProfile.GL3); final GLCapabilities caps = new GLCapabilities(glp); runTestGL(caps); }
/** Default constructor for the window */ public ExampleJOGL() { super("JOGL Example"); // setup the JFrame this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // create the size of the window Dimension size = new Dimension(800, 600); // setup OpenGL capabilities GLCapabilities caps = new GLCapabilities(GLProfile.get(GLProfile.GL2)); caps.setDoubleBuffered(true); caps.setHardwareAccelerated(true); // create a canvas to paint to this.canvas = new GLCanvas(caps); this.canvas.setPreferredSize(size); this.canvas.setMinimumSize(size); this.canvas.setMaximumSize(size); this.canvas.setIgnoreRepaint(true); this.canvas.addGLEventListener(this); // add the canvas to the JFrame this.add(this.canvas); // make the JFrame not resizable // (this way I dont have to worry about resize events) this.setResizable(false); // size everything this.pack(); // setup the world this.initializeWorld(); }
public static void main(String[] args) { Display display = NewtFactory.createDisplay(null); Screen screen = NewtFactory.createScreen(display, 0); GLProfile glProfile = GLProfile.get(GLProfile.GL3); GLCapabilities glCapabilities = new GLCapabilities(glProfile); glWindow = GLWindow.create(screen, glCapabilities); glWindow.setSize(1024, 768); glWindow.setPosition(50, 50); glWindow.setUndecorated(false); glWindow.setAlwaysOnTop(false); glWindow.setFullscreen(false); glWindow.setPointerVisible(true); glWindow.confinePointer(false); glWindow.setTitle("Hello Triangle"); glWindow.setVisible(true); HelloTriangle helloTriangle = new HelloTriangle(); glWindow.addGLEventListener(helloTriangle); glWindow.addKeyListener(helloTriangle); animator = new Animator(glWindow); animator.start(); }
protected void loadTexture() { try { BufferedImage image = ImageIO.read(new File("images/raindrop.png")); texture = AWTTextureIO.newTexture(GLProfile.getDefault(), image, true); } catch (IOException e) { e.printStackTrace(); } }
public static void main(String[] args) { GLProfile.initSingleton(); EventQueue.invokeLater( () -> { MyFrame f = new MyFrame(); f.setVisible(true); }); }
@Test public void test05_BitmapNorm() throws AWTException, InterruptedException, InvocationTargetException { if (manualTest) { return; } final GLCapabilities caps = new GLCapabilities(GLProfile.getDefault()); caps.setBitmap(true); runTestGL(caps); }
@Test public void test02_DefaultMsaa() throws AWTException, InterruptedException, InvocationTargetException { if (manualTest) { return; } final GLCapabilities caps = new GLCapabilities(GLProfile.getDefault()); caps.setNumSamples(4); caps.setSampleBuffers(true); runTestGL(caps); }
@Test public void test99_PixelScale1_DefaultNorm() throws AWTException, InterruptedException, InvocationTargetException { if (manualTest) { return; } reqSurfacePixelScale[0] = ScalableSurface.IDENTITY_PIXELSCALE; reqSurfacePixelScale[1] = ScalableSurface.IDENTITY_PIXELSCALE; final GLCapabilities caps = new GLCapabilities(GLProfile.getDefault()); runTestGL(caps); }
/** Returns the default, desired OpenGL capabilities needed for this component. */ public static GLCapabilities getDefaultCapabalities() { GLCapabilities caps = new GLCapabilities(GLProfile.getGL2ES1()); caps.setRedBits(8); caps.setGreenBits(8); caps.setBlueBits(8); caps.setAlphaBits(8); caps.setDoubleBuffered(true); caps.setHardwareAccelerated(true); caps.setNumSamples(4); caps.setBackgroundOpaque(false); caps.setSampleBuffers(true); return caps; }
public MyFrame() { glprof_ = GLProfile.getDefault(); glcap_ = new GLCapabilities(glprof_); camera_ = new Camera(); light_ = new Light(); terrain_ = new Terrain(); input_ = new Input(); initUI(); }
/** * Main program. * * @param args Command line arguments * @throws Exception On errors */ public static void main(final String[] args) throws Exception { if (args.length != 3 && args.length != 4) { Main.LOG.info("usage: root file.vert [file.geom] file.frag"); System.exit(1); } final File root = new File(args[0]); final R2ShaderPreprocessorType p = R2ShaderPreprocessor.newPreprocessor(root); List<String> vs = null; Optional<List<String>> gs = null; List<String> fs = null; try { if (args.length == 4) { vs = p.preprocessFile(args[1]); gs = Optional.of(p.preprocessFile(args[2])); fs = p.preprocessFile(args[3]); } else { vs = p.preprocessFile(args[1]); gs = Optional.empty(); fs = p.preprocessFile(args[2]); } } catch (final Exception e) { Main.LOG.error("Preprocessing failure: ", e); System.exit(1); } final GLProfile pro = GLProfile.get(GLProfile.GL3); final GLCapabilities caps = new GLCapabilities(pro); final GLDrawableFactory f = GLDrawableFactory.getFactory(pro); final GLOffscreenAutoDrawable drawable = f.createOffscreenAutoDrawable(null, caps, null, 32, 32); drawable.display(); final GLContext ctx = drawable.getContext(); ctx.makeCurrent(); try { final JCGLImplementationJOGLType i = JCGLImplementationJOGL.getInstance(); final JCGLContextType jc = i.newContextFrom(ctx, "offscreen"); final JCGLInterfaceGL33Type gi = jc.contextGetGL33(); final R2ShaderCheckerType ch = R2ShaderChecker.newChecker(gi.getShaders()); ch.check(vs, gs, fs); } finally { ctx.release(); drawable.destroy(); } }
@Override public void run() { // // Necessary to load the native libraries correctly (see // // // http://forum.jogamp.org/Return-of-the-quot-java-lang-UnsatisfiedLinkError-Can-t-load-library-System-Library-Frameworks-glueg-td4034549.html) JarUtil.setResolver( new JarUtil.Resolver() { @Override public URL resolve(final URL url) { try { final URL urlUnescaped = FileLocator.resolve(url); final URL urlEscaped = new URI(urlUnescaped.getProtocol(), urlUnescaped.getPath(), null).toURL(); return urlEscaped; } catch (final IOException ioexception) { return url; } catch (final URISyntaxException urisyntaxexception) { return url; } } }); // Necessary to initialize very early because initializing it // while opening a Java2D view before leads to a deadlock GLProfile.initSingleton(); while (!GLProfile.isInitialized()) { try { Thread.sleep(100); } catch (final InterruptedException e) { e.printStackTrace(); } } isInitialized = true; }
void test01GLDebug01EnableDisable(final boolean enable) throws InterruptedException { final GLProfile glp = GLProfile.getDefault(); final WindowContext winctx = createWindow(glp, enable); final String glDebugExt = winctx.context.getGLDebugMessageExtension(); System.err.println("glDebug extension: " + glDebugExt); System.err.println("glDebug enabled: " + winctx.context.isGLDebugMessageEnabled()); System.err.println("glDebug sync: " + winctx.context.isGLDebugSynchronous()); System.err.println("context version: " + winctx.context.getGLVersion()); Assert.assertEquals( (null == glDebugExt) ? false : enable, winctx.context.isGLDebugMessageEnabled()); destroyWindow(winctx); }
protected void initGL() { // System.out.println("*******************************"); if (profile == null) { if (PJOGL.profile == 2) { try { profile = GLProfile.getGL2ES2(); } catch (GLException ex) { profile = GLProfile.getMaxProgrammable(true); } } else if (PJOGL.profile == 3) { try { profile = GLProfile.getGL2GL3(); } catch (GLException ex) { profile = GLProfile.getMaxProgrammable(true); } if (!profile.isGL3()) { PGraphics.showWarning("Requested profile GL3 but is not available, got: " + profile); } } else if (PJOGL.profile == 4) { try { profile = GLProfile.getGL4ES3(); } catch (GLException ex) { profile = GLProfile.getMaxProgrammable(true); } if (!profile.isGL4()) { PGraphics.showWarning("Requested profile GL4 but is not available, got: " + profile); } } else throw new RuntimeException(PGL.UNSUPPORTED_GLPROF_ERROR); } // Setting up the desired capabilities; GLCapabilities caps = new GLCapabilities(profile); caps.setAlphaBits(PGL.REQUESTED_ALPHA_BITS); caps.setDepthBits(PGL.REQUESTED_DEPTH_BITS); caps.setStencilBits(PGL.REQUESTED_STENCIL_BITS); // caps.setPBuffer(false); // caps.setFBO(false); pgl.reqNumSamples = PGL.smoothToSamples(graphics.smooth); caps.setSampleBuffers(true); caps.setNumSamples(pgl.reqNumSamples); caps.setBackgroundOpaque(true); caps.setOnscreen(true); pgl.capabilities = caps; }
public FirstStepNewtLast() { GLCapabilities caps = new GLCapabilities(GLProfile.get(GLProfile.GL2)); GLWindow glWindow = GLWindow.create(caps); glWindow.setTitle("First demo (Newt)"); glWindow.setSize(300, 300); glWindow.addWindowListener( new WindowAdapter() { @Override public void windowDestroyed(WindowEvent arg0) { System.exit(0); } }); glWindow.addGLEventListener(this); FPSAnimator animator = new FPSAnimator(10); // (2) animator.add(glWindow); animator.start(); glWindow.setVisible(true); }
public static void main(String[] args) { GLProfile glp = GLProfile.getDefault(); GLCapabilities caps = new GLCapabilities(glp); GLCanvas canvas = new GLCanvas(caps); cube unCube = new cube(); canvas.addGLEventListener(unCube); Frame frame = new Frame("AWT Window Test"); FPSAnimator anim = new FPSAnimator(canvas, 60); anim.start(); frame.setSize(400, 400); frame.add(canvas); frame.setVisible(true); frame.addKeyListener( new KeyListener() { @Override public void keyPressed(KeyEvent e) { // TODO Auto-generated method stub int keyCode = e.getKeyCode(); unCube.handleKeyPress(keyCode); // Here is the handleKeyPress function's call frame.add(canvas); } @Override public void keyReleased(KeyEvent e) { // TODO Auto-generated method stub } @Override public void keyTyped(KeyEvent e) { // TODO Auto-generated method stub } }); frame.addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); }
public static void main(String[] args) { GLProfile glprofile = GLProfile.getDefault(); GLCapabilities glcapabilities = new GLCapabilities(glprofile); final GLCanvas glcanvas = new GLCanvas(glcapabilities); glcanvas.addGLEventListener( new GLEventListener() { @Override public void reshape(GLAutoDrawable glautodrawable, int x, int y, int width, int height) { OneTriangle.setup(glautodrawable.getGL().getGL2(), width, height); } @Override public void init(GLAutoDrawable glautodrawable) {} @Override public void dispose(GLAutoDrawable glautodrawable) {} @Override public void display(GLAutoDrawable glautodrawable) { OneTriangle.render( glautodrawable.getGL().getGL2(), glautodrawable.getSurfaceWidth(), glautodrawable.getSurfaceHeight()); } }); // "One Triangle Swing GLCanvas JWindow" final JWindow jwindow = new JWindow(); jwindow.addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent windowevent) { jwindow.dispose(); System.exit(0); } }); jwindow.getContentPane().add(glcanvas, BorderLayout.CENTER); jwindow.setSize(640, 480); jwindow.setVisible(true); }
public CubeSample6InvalidNormal() { GLCapabilities caps = new GLCapabilities(GLProfile.get(GLProfile.GL2)); glu = new GLU(); GLWindow glWindow = GLWindow.create(caps); glWindow.setTitle("Cube demo (Newt)"); glWindow.setSize(300, 300); glWindow.addWindowListener( new WindowAdapter() { @Override public void windowDestroyed(WindowEvent arg0) { System.exit(0); } }); glWindow.addGLEventListener(this); glWindow.addMouseListener(this); animator = new FPSAnimator(30); animator.add(glWindow); animator.start(); animator.pause(); glWindow.setVisible(true); }
@Test public void test02GLDebugError() throws InterruptedException { final GLProfile glp = GLProfile.getDefault(); final WindowContext winctx = createWindow(glp, true); final MyGLDebugListener myGLDebugListener = new MyGLDebugListener( GL2ES2.GL_DEBUG_SOURCE_API, GL2ES2.GL_DEBUG_TYPE_ERROR, GL2ES2.GL_DEBUG_SEVERITY_HIGH); winctx.context.addGLDebugListener(myGLDebugListener); final GL gl = winctx.context.getGL(); gl.glBindFramebuffer(-1, -1); // ERROR ! if (winctx.context.isGLDebugMessageEnabled()) { Assert.assertEquals(true, myGLDebugListener.received()); } destroyWindow(winctx); }
@Test public void test03GLDebugInsert() throws InterruptedException { final GLProfile glp = GLProfile.getDefault(); final WindowContext winctx = createWindow(glp, true); final MyGLDebugListener myGLDebugListener = new MyGLDebugListener(dbgTstMsg0, dbgTstId0); winctx.context.addGLDebugListener(myGLDebugListener); final String glDebugExt = winctx.context.getGLDebugMessageExtension(); Assert.assertEquals( (null == glDebugExt) ? false : true, winctx.context.isGLDebugMessageEnabled()); if (winctx.context.isGLDebugMessageEnabled()) { winctx.context.glDebugMessageInsert( GL2ES2.GL_DEBUG_SOURCE_APPLICATION, GL2ES2.GL_DEBUG_TYPE_OTHER, dbgTstId0, GL2ES2.GL_DEBUG_SEVERITY_MEDIUM, dbgTstMsg0); Assert.assertEquals(true, myGLDebugListener.received()); } destroyWindow(winctx); }
@Override public SharedResourceRunner.Resource createSharedResource( final AbstractGraphicsDevice adevice) { final X11GraphicsDevice device = new X11GraphicsDevice( X11Util.openDisplay(adevice.getConnection()), adevice.getUnitID(), true /* owner */); GLContextImpl context = null; boolean contextIsCurrent = false; device.lock(); try { final X11GraphicsScreen screen = new X11GraphicsScreen(device, device.getDefaultScreen()); GLXUtil.initGLXClientDataSingleton(device); final String glXServerVendorName = GLX.glXQueryServerString(device.getHandle(), 0, GLX.GLX_VENDOR); final boolean glXServerMultisampleAvailable = GLXUtil.isMultisampleAvailable( GLX.glXQueryServerString(device.getHandle(), 0, GLX.GLX_EXTENSIONS)); final GLProfile glp = GLProfile.get(device, GLProfile.GL_PROFILE_LIST_MIN_DESKTOP, false); if (null == glp) { throw new GLException("Couldn't get default GLProfile for device: " + device); } final GLCapabilitiesImmutable caps = new GLCapabilities(glp); final GLDrawableImpl drawable = createOnscreenDrawableImpl( createDummySurfaceImpl(device, false, caps, caps, null, 64, 64)); drawable.setRealized(true); final X11GLCapabilities chosenCaps = (X11GLCapabilities) drawable.getChosenGLCapabilities(); final boolean glxForcedOneOne = !chosenCaps.hasFBConfig(); final VersionNumber glXServerVersion; if (glxForcedOneOne) { glXServerVersion = versionOneOne; } else { glXServerVersion = GLXUtil.getGLXServerVersionNumber(device); } context = (GLContextImpl) drawable.createContext(null); if (null == context) { throw new GLException("Couldn't create shared context for drawable: " + drawable); } contextIsCurrent = GLContext.CONTEXT_NOT_CURRENT != context.makeCurrent(); final boolean allowsSurfacelessCtx; if (contextIsCurrent && context.getGLVersionNumber().compareTo(GLContext.Version3_0) >= 0) { allowsSurfacelessCtx = probeSurfacelessCtx(context, true /* restoreDrawable */); } else { setNoSurfacelessCtxQuirk(context); allowsSurfacelessCtx = false; } if (context.hasRendererQuirk(GLRendererQuirks.DontCloseX11Display)) { X11Util.markAllDisplaysUnclosable(); } if (DEBUG_SHAREDCTX) { System.err.println("SharedDevice: " + device); System.err.println("SharedScreen: " + screen); System.err.println("SharedContext: " + context + ", madeCurrent " + contextIsCurrent); System.err.println(" allowsSurfacelessCtx " + allowsSurfacelessCtx); System.err.println("GLX Server Vendor: " + glXServerVendorName); System.err.println( "GLX Server Version: " + glXServerVersion + ", forced " + glxForcedOneOne); System.err.println("GLX Server Multisample: " + glXServerMultisampleAvailable); System.err.println("GLX Client Vendor: " + GLXUtil.getClientVendorName()); System.err.println("GLX Client Version: " + GLXUtil.getClientVersionNumber()); System.err.println("GLX Client Multisample: " + GLXUtil.isClientMultisampleAvailable()); } return new SharedResource( device, screen, drawable, context, glXServerVersion, glXServerVendorName, glXServerMultisampleAvailable && GLXUtil.isClientMultisampleAvailable()); } catch (final Throwable t) { throw new GLException( "X11GLXDrawableFactory - Could not initialize shared resources for " + adevice, t); } finally { if (contextIsCurrent) { context.release(); } device.unlock(); } }
protected void runJOGLTasks( final int animThreadCount, final int frameCount, final int reszThreadCount, final int resizeCount) throws InterruptedException { final GLWindow glWindow = GLWindow.create(new GLCapabilities(GLProfile.getDefault())); final MyEventCounter myEventCounter = new MyEventCounter(); glWindow.addGLEventListener(new GearsES2(0)); glWindow.addGLEventListener(myEventCounter); glWindow.setSize(demoSize, demoSize); glWindow.setVisible(true); final String currentThreadName = Thread.currentThread().getName(); final Object sync = new Object(); final MyRunnable[] animTasks = new MyRunnable[animThreadCount]; final MyRunnable[] resizeTasks = new MyRunnable[animThreadCount]; final Thread[] animThreads = new Thread[reszThreadCount]; final Thread[] resizeThreads = new Thread[reszThreadCount]; System.err.println("animThreadCount " + animThreadCount + ", frameCount " + frameCount); System.err.println("reszThreadCount " + reszThreadCount + ", resizeCount " + resizeCount); System.err.println( "tasks " + (animTasks.length + resizeTasks.length) + ", threads " + (animThreads.length + resizeThreads.length)); for (int i = 0; i < animThreadCount; i++) { System.err.println("create anim task/thread " + i); animTasks[i] = new RudeAnimator(glWindow, frameCount, sync, i); animThreads[i] = new Thread(animTasks[i], currentThreadName + "-anim" + i); } for (int i = 0; i < reszThreadCount; i++) { System.err.println("create resz task/thread " + i); resizeTasks[i] = new RudeResizer(glWindow, resizeCount, sync, i); resizeThreads[i] = new Thread(resizeTasks[i], currentThreadName + "-resz" + i); } myEventCounter.reset(); int j = 0, k = 0; for (int i = 0; i < reszThreadCount + animThreadCount; i++) { if (0 == i % 2) { System.err.println("start resize thread " + j); resizeThreads[j++].start(); } else { System.err.println("start anim thread " + k); animThreads[k++].start(); } } synchronized (sync) { while (!done(resizeTasks) || !done(animTasks)) { try { sync.wait(); } catch (final InterruptedException e) { throw new RuntimeException(e); } } } int i = 0; while (i < 30 && !isDead(animThreads) && !isDead(resizeThreads)) { Thread.sleep(100); i++; } glWindow.destroy(); }
@BeforeClass public static void initClass() { if (!GLProfile.isAvailable(GLProfile.GL2ES2)) { setTestSupported(false); } }
public Triangle() { super(new GLCapabilities(GLProfile.get("GL3"))); setSize(800, 800); addGLEventListener(this); }
public void testImpl() throws InterruptedException { final JFrame frame = new JFrame(this.getSimpleTestName(".")); // // GLDrawableFactory factory = GLDrawableFactory.getFactory(GLProfile.get(GLProfile.GL2)); // GLContext sharedContext = factory.getOrCreateSharedContext(factory.getDefaultDevice()); // final GLCapabilities glCapabilities = new GLCapabilities(GLProfile.get(GLProfile.GL2)); glCapabilities.setSampleBuffers(true); glCapabilities.setNumSamples(4); final GearsES2 eventListener1 = new GearsES2(0); final GearsES2 eventListener2 = new GearsES2(1); final Component openGLComponent1; final Component openGLComponent2; final GLAutoDrawable openGLAutoDrawable1; final GLAutoDrawable openGLAutoDrawable2; final GLWindow glWindow1 = GLWindow.create(glCapabilities); final NewtCanvasAWT newtCanvasAWT1 = new NewtCanvasAWT(glWindow1); newtCanvasAWT1.setPreferredSize(new Dimension(640, 480)); glWindow1.addGLEventListener(eventListener1); // final GLWindow glWindow2 = GLWindow.create(glCapabilities); final NewtCanvasAWT newtCanvasAWT2 = new NewtCanvasAWT(glWindow2); newtCanvasAWT2.setPreferredSize(new Dimension(640, 480)); glWindow2.addGLEventListener(eventListener2); openGLComponent1 = newtCanvasAWT1; openGLComponent2 = newtCanvasAWT2; openGLAutoDrawable1 = glWindow1; openGLAutoDrawable2 = glWindow2; // group both OpenGL canvases / windows into a horizontal panel final JPanel openGLPanel = new JPanel(); openGLPanel.setLayout(new BoxLayout(openGLPanel, BoxLayout.LINE_AXIS)); openGLPanel.add(openGLComponent1); openGLPanel.add(Box.createHorizontalStrut(5)); openGLPanel.add(openGLComponent2); final JPanel mainPanel = (JPanel) frame.getContentPane(); mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.LINE_AXIS)); mainPanel.add(Box.createHorizontalGlue()); mainPanel.add(openGLPanel); mainPanel.add(Box.createHorizontalGlue()); final Animator animator = new Animator(Thread.currentThread().getThreadGroup()); animator.setUpdateFPSFrames(1, null); animator.add(openGLAutoDrawable1); animator.add(openGLAutoDrawable2); // make the window visible using the EDT SwingUtilities.invokeLater( new Runnable() { public void run() { frame.pack(); frame.setVisible(true); } }); Assert.assertEquals(true, AWTRobotUtil.waitForVisible(frame, true)); Assert.assertEquals(true, AWTRobotUtil.waitForRealized(openGLComponent1, true)); Assert.assertEquals(true, AWTRobotUtil.waitForRealized(openGLComponent2, true)); animator.start(); // sleep for test duration, then request the window to close, wait for the window to close,s and // stop the animation while (animator.isAnimating() && animator.getTotalFPSDuration() < durationPerTest) { Thread.sleep(100); } animator.stop(); // ask the EDT to dispose of the frame; // if using newt, explicitly dispose of the canvases because otherwise it seems our destroy // methods are not called SwingUtilities.invokeLater( new Runnable() { public void run() { newtCanvasAWT1.destroy(); // removeNotify does not destroy GLWindow newtCanvasAWT2.destroy(); // removeNotify does not destroy GLWindow frame.dispose(); } }); Assert.assertEquals(true, AWTRobotUtil.waitForVisible(frame, false)); Assert.assertEquals(true, AWTRobotUtil.waitForRealized(openGLComponent1, false)); Assert.assertEquals(true, AWTRobotUtil.waitForRealized(openGLComponent2, false)); }
static { // setting this true causes window events not to get sent on Linux if you run from inside // Eclipse GLProfile.initSingleton(); }
protected void initGLCanvas() { loadNatives(); device = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); // FIXME use the settings to know whether to use the max programmable profile // then call GLProfile.getMaxProgrammable(true); GLCapabilities caps = new GLCapabilities(GLProfile.getMaxFixedFunc(true)); caps.setHardwareAccelerated(true); caps.setDoubleBuffered(true); caps.setStencilBits(settings.getStencilBits()); caps.setDepthBits(settings.getDepthBits()); if (settings.getSamples() > 1) { caps.setSampleBuffers(true); caps.setNumSamples(settings.getSamples()); } canvas = new GLCanvas(caps) { @Override public void addNotify() { super.addNotify(); onCanvasAdded(); } @Override public void removeNotify() { onCanvasRemoved(); super.removeNotify(); } }; canvas.invoke( false, new GLRunnable() { public boolean run(GLAutoDrawable glad) { canvas.getGL().setSwapInterval(settings.isVSync() ? 1 : 0); return true; } }); canvas.setFocusable(true); canvas.requestFocus(); canvas.setSize(settings.getWidth(), settings.getHeight()); canvas.setIgnoreRepaint(true); canvas.addGLEventListener(this); // FIXME not sure it is the best place to do that renderable.set(true); // TODO remove this block once for all when the unified renderer is stable /*if (settings.getBoolean("GraphicsDebug")) { canvas.invoke(false, new GLRunnable() { public boolean run(GLAutoDrawable glad) { GL gl = glad.getGL(); if (gl.isGLES()) { if (gl.isGLES1()) { glad.setGL(new DebugGLES1(gl.getGLES1())); } else { if (gl.isGLES2()) { glad.setGL(new DebugGLES2(gl.getGLES2())); } else { if (gl.isGLES3()) { glad.setGL(new DebugGLES3(gl.getGLES3())); } } } } else { if (gl.isGL4bc()) { glad.setGL(new DebugGL4bc(gl.getGL4bc())); } else { if (gl.isGL4()) { glad.setGL(new DebugGL4(gl.getGL4())); } else { if (gl.isGL3bc()) { glad.setGL(new DebugGL3bc(gl.getGL3bc())); } else { if (gl.isGL3()) { glad.setGL(new DebugGL3(gl.getGL3())); } else { if (gl.isGL2()) { glad.setGL(new DebugGL2(gl.getGL2())); } } } } } } return true; } }); } renderer = new JoglRenderer(); canvas.invoke(false, new GLRunnable() { public boolean run(GLAutoDrawable glad) { renderer.setMainFrameBufferSrgb(settings.getGammaCorrection()); return true; } });*/ }