Tutorial: A cross-platform graphical application using Java, OpenGL, and Eclipse

Update on 6/24/2017: I updated the GitHub project to launch correctly on Eclipse Neon 3. Many times when they update Eclipse, it changes the dependencies a project like this needs, which means we have to regenerate the Tutorial.product file to make it launch properly again.

To run the tutorial:

• Check out https://github.com/WadeWalker/com.jogamp.jogl and
  https://github.com/WadeWalker/name.wadewalker.tutorial from GitHub
• Import both projects into an empty Eclipse workspace
• Double-click the Tutorial.product file in the name.wadewalker.tutorial project, and click the “Launch an Eclipse application” or “Launch an Eclipse application in Debug mode” link at the bottom of the Overview pane.

This runs the fully-developed tutorial, not just the simple donut below, but you can always paste the donut code into it if you like 🙂 Enjoy!

Update on 6/6/2015: This tutorial’s gotten a bit out of date with changes to JOGL and Eclipse in the last couple of years. The quickest way to get set up now is to just get my two projects from GitHub and import them into an empty Eclipse workspace:

https://github.com/WadeWalker/com.jogamp.jogl
https://github.com/WadeWalker/name.wadewalker.tutorial

This will give you a working RCP app without creating fragment projects like I describe below. Then you can hack on the tutorial app or create your own by following the latter half of the tutorial 🙂

=================================================================

Hi! My name’s Wade Walker. I’m an engineer and wanna-be scientist.

And you may call me “Interstitius”. I am something of a Renaissance-being, but my current occupation is penning the headings between these paragraphs.

Yeah, that doesn’t come across weird at all! But this guy comes highly recommended, so I figured I’d give him a try. What’s with the name, anyway?

It is a Latinate nom de plume, of course. I thought it dashing and flamboyant, much like myself.

Um, OK sure. Don’t ask questions you don’t want answered, et cetera. Anyway moving on!

At my day job, I write engineering apps that help chip designers make the chips that go into all your iStuff. But by night, and also on weekends, I write scientific apps as a hobby. And before anyone asks: no, I don’t live in my mom’s basement. Trust me, I’m perfectly normal. Except for writing science apps.

I’m gonna write a set of tutorials that walk you through creating a cross-platform graphical app using Java, OpenGL, and the Eclipse Rich Client Platform (“Eclipse RCP” for short). There are lots of other ways to do this, like with C++ and Qt, but I’m lazy and I figured I’d stick with what I know.

What do I get out of this? Glad you asked!

No one has asked anything as yet.

Dude, that’s just for color. Not supposed to be literal. Anyway, what I get out of tutorializing is this: I’m in the process of translating my hobby science app from C# and DirectX to Java and OpenGL. So I figured I might as well write up how I do it, and maybe help out some other folks in the process.

In this first tutorial, I’ll make a bare-bones app that draws a rotating 3-D demo object in a window using Java OpenGL (JOGL).

A brief description of the intended audience of this tutorial

Nice heading, I-dog! Just keep ‘em punchy like that and you’ll do great.

I’m aiming these tutorials at people who want to write cross-platform graphical “workbench” apps, the kind where users create some kind of project and edit it interactively using 3D hardware-accelerated graphics. Apps like this are common in the sciences, in engineering, and in the graphic arts.

You should be able to do these tutorials if you’ve got a bit of software dev experience, but you don’t need any prior exposure to Java, Eclipse, or OpenGL. I’ll give you working code for each tutorial that you can adapt and use for whatever you want. Then you can gradually figure out how it works as you customize it.

Java, Eclipse, and OpenGL are all super-deep neck-beard topics that take years of study to master, so don’t feel like you need to totally comprehend every bit of these tutorials the first time you see them. My main point in putting them up here is to give you working starting points for your own stuff and to get you past some common roadblocks, not to instantly transmute you into a super-genius like me.

Quick pro tip for any eager beavers out there: If you already know how to set up an Eclipse workspace and just want to see the money shot, here’s a zip file of the JOGL projects, and here’s another zip file for the tutorial project. Just change the file names to end in “.zip” instead of “-zip-not-a.doc”, unzip them, import them into Eclipse, and go nuts!

Now, let’s do this!

Put “Java” and the “Eclipse development environment” in order

If you don’t already have it, download and install the Standard Edition of the latest Java Development Kit (the Java SE JDK) from here. When I downloaded it, the latest version was JDK 7 update 4. You’ll have to pick the platform you’re running on, too. I’m running Windows 7 64-bit, so I picked the “Windows x64” platform.

Note! A JDK isn’t the same as a Java Runtime Environment (JRE) or Java browser plug-in that you may already have installed. If you’re not sure, check your installed programs to make sure you really have the JDK and not something else.

Further note! If you’re running on Mac OS X, you may already have a Java JDK installed at /System/Library/Java/JavaVirtualMachines/1.6.0.jdk, since it used to ship with the operating system. If not, you can install Oracle’s JDK 7 from here. Or if you don’t want to try JDK 7 on OS X yet, you can install Apple’s JDK 6 as documented here. Just be aware that if you want this tutorial to build on more than one platform without changing any Eclipse settings, it’s best to have the same version of the JDK installed on all your platforms.

After your JDK is set, download and install “Eclipse for RCP and RAP Developers” from here. When I downloaded it, the latest version was 3.7.2, nicknamed “Indigo” because of the obvious similarity between “a dye-producing plant” and “a software development environment”. I downloaded the Windows 64-bit version of this too. To run Eclipse, you just unzip it into any directory and double-click on “eclipse.exe”.

The first time you run Eclipse, it’ll show you the world’s most unhelpful welcome page. Click the “Workbench” button on the right to go past it.

Then Eclipse will ask you what “workspace” to open. Set this to a directory where you want to create your new projects for this tutorial, then click “OK”. You can switch between workspaces or create new ones later on by selecting “File > Switch Workspace” from the main menu.

Here’s what your new empty workspace should look like now.

Eclipse is a great sprawling beast, baroque but hyper-useful, and I can’t even try to explain everything about it here. I’ll just keep to the minimum that we need to make this tutorial work, and you can pick up the rest as you need it.

Obtain “Java OpenGL”, or “JOGL” as it is commonly known

Um, I-man? You don’t have to scare-quote all the tech words. I think our audience can figure it out.

My apologies.

No biggie, just trying to keep it casual up in here. Java OpenGL, or yes, “JOGL” as it’s known to those of us in the know, such as myself, is maintained by the super-programmers at JogAmp. So grab the latest gluegen and JOGL archive files from here. I got five .7z files from gluegen-b547-2012-04-19_20-39-21 and five from jogl-b736-2012-04-19_20-43-43, which were the latest builds at the time of this writing.

• gluegen-2.0-b547-20120419-linux-amd64.7z
• gluegen-2.0-b547-20120419-linux-i586.7z
• gluegen-2.0-b547-20120419-macosx-universal.7z
• gluegen-2.0-b547-20120419-windows-amd64.7z
• gluegen-2.0-b547-20120419-windows-i586.7z

 

 

• jogl-2.0-b736-20120419-linux-amd64.7z
• jogl-2.0-b736-20120419-linux-i586.7z
• jogl-2.0-b736-20120419-macosx-universal.7z
• jogl-2.0-b736-20120419-windows-amd64.7z
• jogl-2.0-b736-20120419-windows-i586.7z

 

Since I develop on 64-bit Windows 7, I only need gluegen-2.0-b547-20120419-windows-amd64.7z and jogl-2.0-b736-20120419-windows-amd64.7z to run on my main computer, but I got all ten so I can make this project multi-platform. Unzip these files somewhere convenient. To unzip .7z files, I recommend 7-Zip on Windows and Linux, and Keka on Mac OS X.

Create JOGL projects within Eclipse

To use JOGL from an Eclipse RCP project, we have to repackage it a bit. JOGL is made of two types of files: JAR files that are common to all platforms, and library files (.dll files on Windows, .so files on Linux, and .jnilib or .dylib files on Mac OS X) that are specific to each platform you want your program to run on. We’ll put the JOGL JARs in an Eclipse plug-in project, and the JOGL library files in separate Eclipse plug-in fragment projects. If you’re not familiar with Eclipse don’t worry about what the different Eclipse project types mean right now. This setup is just a good way for all the platforms’ libraries to live together without anything blowing up.

First we create a project to hold the JAR files. Select “File > New > Project…” from the Eclipse main menu to bring up the “New Project” wizard. Open “Plug-in Development”, select “Plug-in from Existing JAR Archives”, and click “Next”.

Click “Add External…”, and in the “Open” dialog that pops up, navigate to the “jar” directory inside an unzipped gluegen archive, select “gluegen-rt.jar” and click “Open”. Then do the same thing for the “jogl.all.jar” file in the “jar” directory of an unzipped JOGL archive. It doesn’t matter which platform’s archive you get these JARs from, since they’re all the same. Click “Next” when you’re done.

Enter “com.jogamp.jogl” as the project name. Set the plug-in version to “2.0.0”. Set the plug-in name to “JOGL” and the plug-in provider to “jogamp.org”. Uncheck “Unzip the JAR archives into the project”. Then click “Finish”, and Eclipse will magically create the project especially just for you.

Your finished project should look like this. The new “com.jogamp.jogl” directory is inside your workspace directory. The settings you typed in are stored in the “META-INF/MANIFEST.MF” and “build.properties” files that the wizard just created for you. The wizard also copied the gluegen and JOGL JAR files into your new project.

Next we create projects to hold the platform-specific libraries. Eclipse calls this type of project a “fragment” because it’s an “extra bit” of the earlier JAR project, and it holds stuff we only need on some platforms. Select “File > New > Project…” to bring up the “New Project” wizard again. Then open “Plug-in Development”, select “Fragment Project”, and click “Next”.

Enter “com.jogamp.jogl-windows-amd64” as the project name, then click “Next”.

Set the plug-in version to “2.0.0”, the name to “jogl-windows-amd64”, and the plug-in provider to “jogamp.org”. Set the host plug-in ID to “com.jogamp.jogl” (that’s the project this one is a fragment of). Set the minimum version to “2.0.0”. Then click “Finish” to create the project.

When the overview of this fragment comes up, set the platform filter to the incantation “(& (osgi.os=win32) (osgi.arch=x86_64))”. This makes sure the fragment project is only loaded when your program is run on a 64-bit Windows system.

In Windows, manually copy all the DLLs from the “lib” directories inside the unzipped “*-windows-amd64” gluegen and JOGL archives into the new “com.jogamp.jogl-windows-amd64” directory in your workspace. Then back in Eclipse, right-click the “com.jogamp.jogl-windows-amd64” project and select “Refresh”. You should see the DLLs in your project like this:

To finish setting up this fragment, click the “Build” tab at the bottom of the main window and check all the DLLs under “Binary Build” list. It should look like this:

Create one’s other fragments, mutatis mutandis

I guess what Stish means by that is, we can create fragments for the rest of the platforms that we want to support by redoing what we just did for the 64-bit Windows fragment, but making the necessary changes for each one. Here are the fragment names and platform filters for all five:

• com.jogamp.jogl-linux-amd64: (& (osgi.os=linux) (osgi.arch=x86_64))
• com.jogamp.jogl-linux-i586: (& (osgi.os=linux) (osgi.arch=x86))
• com.jogamp.jogl-macosx-universal: (& (osgi.os=macosx) (osgi.arch=x86_64))
• com.jogamp.jogl-windows-amd64: (& (osgi.os=win32) (osgi.arch=x86_64))
• com.jogamp.jogl-windows-i586: (& (osgi.os=win32) (osgi.arch=x86))

And there is a complete table of the names of the native library files on the JogAmp wiki for reference here. When you’ve created all five fragments, your workspace will look like this:

Note for JDK 7 users on Mac OS X! Due to an incompatibility between JDK 6 and JDK 7 documented here and here, you need to either rename your .jnilib files to .dylib (if you only need to run under Java 7), or create copies of the .jnilib files as .dylib files (if you want to run under both Java 6 and Java 7).

You can see there’s a “Platform filter does not match the current environment” warning at the bottom for each of the platforms other than the one Eclipse is running on now. You could ignore those, but if you’re as compulsive as I am, that’s just not an option. So right-click the first fragment project in the Package Explorer on the left, click Properties, then expand “Plug-in Development” on the left and select “Plug-in Manifest Compiler”. Check “Enable project specific settings”, then change “General > Incompatible environment” to “Ignore”. The properties dialog should look like this when you’re done.

Click “OK”, then click “Yes” when it asks you if it can rebuild the project. Do this for all five fragment projects, and your warnings list will be gloriously empty.

With these five fragment projects included, our app will be able to run with no modification on five different platforms. When we run the app, the Eclipse RCP framework will load the com.jogamp.jogl plugin first, then it will load the correct fragment for the platform the app is running on, without you having to write any custom code or wrapper scripts to try to change the Java library path.

Create one’s principal project

Now that JOGL is ready for use, we can create the main project. Select “File > New > Project…” to bring up the “New Project” wizard. Open “Plug-in Development”, select “Plug-in Project”, and click “Next”.

Enter your project’s name. Mine is “name.wadewalker.tutorial”. Then click “Next”.

Then set your project version number (mine is “1.0.0”), your provider (mine is “Wade Walker”), click “Yes” beside “Would you like to create a rich client application?”, and click “Next”.

Select the “Hello RCP” template under “Available Templates”. This will make a minimal RCP app that we can stuff our own JOGL code into. Then click “Next” (not “Finish”).

Fill in your window title (mine’s “Tutorial”), and check the “Add branding” box (this lets you customize your splash screen later). Then click “Finish” to create the project.

Your project overview should look like this:

Now click the “Dependencies” tab at the bottom of the main window. Click “Add…” beside “Required Plug-ins”, and type “com.jo” in the “Select a Plug-in” box. Select “com.jogamp.jogl (2.0.0)” in the list of matching items, then click “OK”.

Your dependencies should look like this:

At this point, if you right-click this project in the list, then select “Run As > Eclipse Application”, you’ll see the most minimal app you can imagine. OK, I guess it could technically be more minimal, but this is pretty bare. But at least it runs! The empty frame inside our window is where the editors go in an RCP app. We’ll get rid of that in a moment, since we don’t want an editor yet.

Add a “view” to one’s principal application

Eclipse calls the kind of window we’re creating for JOGL a “view”. To create it, click the “Extensions” tab, then click the “Add…” button, type “org.eclipse.ui.v” in the “Extension Point filter” box, select “org.eclipse.ui.views”, and click “Finish”.

Right-click “org.eclipse.ui.views” under “All Extensions” and select “New > view”. Then under “Extension Element Details”, fill in the ID (“name.wadewalker.tutorial.joglview”), the name (“JOGLView”), and the class (“name.wadewalker.tutorial.JOGLView”).

Click the “class” hyperlink under “Extension Element Details”, then click “Finish” to create the Java file that implements the JOGL view.

Now we have to tell our program to open this view at startup so we can see it. Open the “Perspective.java” file by double-clicking it in the package explorer:

And change the contents of “Perspective.java” in the text editor to this:

package name.wadewalker.tutorial;

import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;

public class Perspective implements IPerspectiveFactory {

	public void createInitialLayout(IPageLayout layout) {
		// editor area invisible to avoid empty editor frame below our view
		layout.setEditorAreaVisible( false );
		layout.addView( "name.wadewalker.tutorial.joglview", IPageLayout.TOP,
						IPageLayout.RATIO_MAX, IPageLayout.ID_EDITOR_AREA);
		}
}

Now if you right-click your project in the list, then select “Run As > Eclipse Application”, you’ll see that our app has an empty JOGL view now. Still bare, but getting closer! The empty editor frame’s gone too, since we turned it off in the code above.

Now we put in some demo JOGL code. This snippet was originally used to demonstrate the old JOGL 1.1.1 (pre-JogAmp) in SWT (the windowing toolkit that Eclipse uses). Sven Göthel at JogAmp adapted it for JOGL 2.0, then I adapted that to make it an Eclipse ViewPart. Double-click the “JOGLView.java” file on the left, then replace its contents with this:

/*******************************************************************************
 * Copyright (c) 2000, 2005, 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sven Gothel     - conversion to JOGL 2.0 (original at http://github.com/sgothel/jogl-demos/blob/master/src/demos/swt/Snippet209.java)
 *     Wade Walker     - conversion to an Eclipse ViewPart
 *
 *******************************************************************************/

package name.wadewalker.tutorial;

/*
 * SWT OpenGL snippet: use JOGL to draw to an SWT GLCanvas
 *
 * For a list of all SWT example snippets see
 * http://www.eclipse.org/swt/snippets/
 *
 * @since 3.2
 */
import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import javax.media.opengl.GL2ES1;
import javax.media.opengl.GL2GL3;
import javax.media.opengl.GLContext;
import javax.media.opengl.GLDrawableFactory;
import javax.media.opengl.GLProfile;
import javax.media.opengl.fixedfunc.GLMatrixFunc;
import javax.media.opengl.glu.GLU;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.opengl.GLCanvas;
import org.eclipse.swt.opengl.GLData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;

public class JOGLView extends ViewPart {

    /** Holds the OpenGL canvas. */
    private Composite composite;

    /** Widget that displays OpenGL content. */
    private GLCanvas glcanvas;

    /** Used to get OpenGL object that we need to access OpenGL functions. */
    private GLContext glcontext;

    /** Master rotation angle of the torus, in degrees. */
    private int rot = 0;

    public JOGLView() {
    }

    @Override
    public void createPartControl( Composite compositeParent ) {
        GLProfile glprofile = GLProfile.get(GLProfile.GL2);

        composite = new Composite( compositeParent, SWT.NONE );
        composite.setLayout( new FillLayout() );

        GLData gldata = new GLData();
        gldata.doubleBuffer = true;
        glcanvas = new GLCanvas( composite, SWT.NO_BACKGROUND, gldata );
        glcanvas.setCurrent();
        glcontext = GLDrawableFactory.getFactory( glprofile ).createExternalGLContext();

        glcanvas.addListener(SWT.Resize, new Listener() {
            public void handleEvent(Event event) {
                Rectangle bounds = glcanvas.getBounds();
                float fAspect = (float) bounds.width / (float) bounds.height;
                glcanvas.setCurrent();
                glcontext.makeCurrent();
                GL2 gl = glcontext.getGL().getGL2();
                gl.glViewport(0, 0, bounds.width, bounds.height);
                gl.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
                gl.glLoadIdentity();
                GLU glu = new GLU();
                glu.gluPerspective(45.0f, fAspect, 0.5f, 400.0f);
                gl.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
                gl.glLoadIdentity();
                glcontext.release();
                }
        });

        glcontext.makeCurrent();
        GL2 gl = glcontext.getGL().getGL2();
        gl.setSwapInterval(1);
        gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        gl.glColor3f(1.0f, 0.0f, 0.0f);
        gl.glHint(GL2ES1.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
        gl.glClearDepth(1.0);
        gl.glLineWidth(2);
        gl.glEnable(GL.GL_DEPTH_TEST);
        glcontext.release();

        (new Thread() {
            public void run() {
                while( (glcanvas != null) && !glcanvas.isDisposed() ) {
                    render();
                    try {
                        // don't make loop too tight, or not enough time
                        // to process window messages properly
                        sleep( 1 );
                    } catch( InterruptedException interruptedexception ) {
                        // we just quit on interrupt, so nothing required here
                    }
                }
            }
        }).start();
    }

    protected void render() {
        PlatformUI.getWorkbench().getDisplay().syncExec( new Runnable() {
            public void run() {
                if( (glcanvas != null) && !glcanvas.isDisposed()) {
                    glcanvas.setCurrent();
                    glcontext.makeCurrent();
                    GL2 gl = glcontext.getGL().getGL2();
                    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
                    gl.glClearColor(.3f, .5f, .8f, 1.0f);
                    gl.glLoadIdentity();
                    gl.glTranslatef(0.0f, 0.0f, -10.0f);
                    gl.glRotatef(0.15f * rot, 2.0f * rot, 10.0f * rot, 1.0f);
                    gl.glRotatef(0.3f * rot, 3.0f * rot, 1.0f * rot, 1.0f);
                    rot++;
                    gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL2GL3.GL_LINE);
                    gl.glColor3f(0.9f, 0.9f, 0.9f);
                    drawTorus(gl, 1, 1.9f + ((float) Math.sin((0.004f * rot))), 15, 15);
                    glcanvas.swapBuffers();
                    glcontext.release();
                }
            }
        });
    }

    protected void drawTorus(GL2 gl, float r, float R, int nsides, int rings) {
        float ringDelta = 2.0f * (float) Math.PI / rings;
        float sideDelta = 2.0f * (float) Math.PI / nsides;
        float theta = 0.0f, cosTheta = 1.0f, sinTheta = 0.0f;
        for (int i = rings - 1; i >= 0; i--) {
            float theta1 = theta + ringDelta;
            float cosTheta1 = (float) Math.cos(theta1);
            float sinTheta1 = (float) Math.sin(theta1);
            gl.glBegin(GL2.GL_QUAD_STRIP);
            float phi = 0.0f;
            for (int j = nsides; j >= 0; j--) {
                phi += sideDelta;
                float cosPhi = (float) Math.cos(phi);
                float sinPhi = (float) Math.sin(phi);
                float dist = R + r * cosPhi;
                gl.glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi);
                gl.glVertex3f(cosTheta1 * dist, -sinTheta1 * dist, r * sinPhi);
                gl.glNormal3f(cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi);
                gl.glVertex3f(cosTheta * dist, -sinTheta * dist, r * sinPhi);
            }
            gl.glEnd();
            theta = theta1;
            cosTheta = cosTheta1;
            sinTheta = sinTheta1;
        }
    }

    @Override
    public void setFocus() {
    }

    @Override
    public void dispose() {
        glcanvas.dispose();
        super.dispose();
    }
}

Then run the main project again, and finally our JOGL view shows an animated wireframe doughnut – what we super-geniuses call a “torus”. Success!

Here’s what it looks like in Linux:

And last but not least et cetera, here’s the Mac OS X version:

Now that we’ve got this skeleton up and walking, we’ll start putting some meat on it in the next tutorial.

Final touches — solutions to two potential problems

For some versions of JOGL, you may see an error saying there’s something wrong with the JAR cache. If so, simply right-click the project and select “Run As > Run Configurations…”. Make sure “Eclipse Application > name.wadewalker.tutorial.product” is selected in the left pane. Then click the “Arguments” tab on the right and add “ -Djogamp.gluegen.UseTempJarCache=false” to the end of the list of arguments in the “VM Arguments” box. This insures that JOGL won’t attempt to use its JAR caching mechanism, which fails in certain situations.

On Mac OS X, this application may freeze on startup or log an error saying “Can’t start the AWT because Java was started on the first thread”. If it does, simply right-click the project and select “Run As > Run Configurations…”. Make sure “Eclipse Application > name.wadewalker.tutorial.product” is selected in the left pane. Then click the “Arguments” tab on the right and add “ -Djava.awt.headless=true” to the end of the list of arguments in the “VM Arguments” box. This insures that AWT will not be loaded, which can cause problems with SWT applications on Mac OS X.

Resources upon which you may draw for more information

JOGL: Sven Göthel and the guys at http://jogamp.org have the source code for JOGL, zipped builds, and discussion forums. This is the main home for JOGL now, even though it still shows up a few other places on the web. Huge props to these guys for taking on such a large project that’s helpful to so many people around the world!

Eclipse RCP programming: Lars Vogel has a great article about creating Eclipse RCP programs at http://www.vogella.de/articles/EclipseRCP/article.html. The other articles on his site are also awesome.

SWT: The snippets at http://www.eclipse.org/swt/snippets/ are very helpful when putting other controls into RCP apps.

A concise history of the changes which we have made to this document

• 10/09/2010: Wrote this post.
• 10/17/2010: Punched up the language, added zip files.
• 10/23/2010: Added fragments for all platforms; split the zip into two parts; fixed the location of GLProfile.initSingleton() after testing on Linux.
• 10/26/2010: Fixed the links to full-sized images.
• 3/23/2011: Fixed quote marks in code snipped from Perspective.java.
• 4/10/2011: Updated code to work with the latest JOGL across all three major platforms. Updated zip file to JOGL b365. Put in new Linux and Mac OS X screenshots.
• 10/14/2011: Fixed typo in Mac OS X platform filter.
• 04/20/2012: Updated text for JOGL b736, Eclipse 3.7.2, and Java 1.7.0_03.
• 04/21/2012: Uploaded new images.
• 05/1/2012: Updated with .dylib vs. .jnilib information after I got JDK 7 working on Mac OS X.
• 05/30/2013: Updated with info on how to turn JOGL’s JAR cache off.