OpenGL with JOGL in Java

Overview

JOGL (Java Binding for OpenGL) provides Java developers with access to the OpenGL graphics API. It allows creating high-performance 2D and 3D graphics applications in Java.

Setup and Dependencies

Maven Dependency

<dependencies> <dependency> <groupId>org.jogamp.jogl</groupId> <artifactId>jogl-all-main</artifactId> <version>2.4.0</version> </dependency> <dependency> <groupId>org.jogamp.gluegen</groupId> <artifactId>gluegen-rt-main</artifactId> <version>2.4.0</version> </dependency> </dependencies>

Manual Setup

Download JOGL from: https://jogamp.org

Basic JOGL Application Structure

1. Basic JOGL Frame

import com.jogamp.opengl.*; import com.jogamp.opengl.awt.GLCanvas; import com.jogamp.opengl.util.FPSAnimator; import javax.swing.*; public class BasicJOGLApp extends JFrame { private GLCanvas canvas; private FPSAnimator animator; public BasicJOGLApp() { super("Basic JOGL Application"); initialize(); } private void initialize() { setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setSize(800, 600); setLocationRelativeTo(null); // Create OpenGL profile GLProfile profile = GLProfile.get(GLProfile.GL4); GLCapabilities capabilities = new GLCapabilities(profile); // Create canvas canvas = new GLCanvas(capabilities); canvas.addGLEventListener(new BasicRenderer()); getContentPane().add(canvas); // Create animator animator = new FPSAnimator(canvas, 60); animator.start(); } public static void main(String[] args) { SwingUtilities.invokeLater(() -> { new BasicJOGLApp().setVisible(true); }); } }

2. Basic Renderer Class

import com.jogamp.opengl.*; import com.jogamp.opengl.glu.GLU; public class BasicRenderer implements GLEventListener { private GLU glu; private float rotation = 0.0f; @Override public void init(GLAutoDrawable drawable) { GL4 gl = drawable.getGL().getGL4(); glu = new GLU(); // Set clear color (dark blue) gl.glClearColor(0.1f, 0.1f, 0.3f, 1.0f); // Enable depth testing gl.glEnable(GL2.GL_DEPTH_TEST); System.out.println("OpenGL Version: " + gl.glGetString(GL2.GL_VERSION)); } @Override public void display(GLAutoDrawable drawable) { GL4 gl = drawable.getGL().getGL4(); // Clear color and depth buffers gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT); // Set up model-view matrix gl.glLoadIdentity(); glu.gluLookAt(0, 0, 5, 0, 0, 0, 0, 1, 0); // Rotate the triangle gl.glRotatef(rotation, 0.0f, 1.0f, 0.0f); rotation += 1.0f; // Draw a colored triangle drawTriangle(gl); } @Override public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) { GL4 gl = drawable.getGL().getGL4(); // Set viewport to cover entire window gl.glViewport(0, 0, width, height); // Set up projection matrix gl.glMatrixMode(GL2.GL_PROJECTION); gl.glLoadIdentity(); glu.gluPerspective(45.0, (double) width / height, 1.0, 100.0); // Switch back to model-view matrix gl.glMatrixMode(GL2.GL_MODELVIEW); } @Override public void dispose(GLAutoDrawable drawable) { // Clean up resources } private void drawTriangle(GL4 gl) { gl.glBegin(GL2.GL_TRIANGLES); // Red vertex gl.glColor3f(1.0f, 0.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, 0.0f); // Green vertex gl.glColor3f(0.0f, 1.0f, 0.0f); gl.glVertex3f(1.0f, -1.0f, 0.0f); // Blue vertex gl.glColor3f(0.0f, 0.0f, 1.0f); gl.glVertex3f(0.0f, 1.0f, 0.0f); gl.glEnd(); } }

Modern OpenGL with Shaders

3. Shader-Based Renderer

import com.jogamp.opengl.*; import com.jogamp.opengl.util.glsl.ShaderCode; import com.jogamp.opengl.util.glsl.ShaderProgram; import java.nio.FloatBuffer; import java.nio.IntBuffer; import com.jogamp.common.nio.Buffers; public class ModernRenderer implements GLEventListener { private int vao; private int vbo; private int ebo; private int shaderProgram; private float rotation = 0.0f; // Vertex data for a cube private final float[] vertices = { -0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, // Red 0.5f, -0.5f, -0.5f, 0.0f, 1.0f, 0.0f, // Green 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, // Blue -0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.0f, // Yellow -0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 1.0f, // Magenta 0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, // Cyan 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, // Gray -0.5f, 0.5f, 0.5f, 1.0f, 0.5f, 0.0f // Orange }; private final int[] indices = { 0, 1, 2, 2, 3, 0, // Front face 1, 5, 6, 6, 2, 1, // Right face 5, 4, 7, 7, 6, 5, // Back face 4, 0, 3, 3, 7, 4, // Left face 3, 2, 6, 6, 7, 3, // Top face 4, 5, 1, 1, 0, 4 // Bottom face }; @Override public void init(GLAutoDrawable drawable) { GL4 gl = drawable.getGL().getGL4(); // Set clear color gl.glClearColor(0.1f, 0.1f, 0.1f, 1.0f); gl.glEnable(GL2.GL_DEPTH_TEST); // Initialize shaders setupShaders(gl); // Initialize buffers setupBuffers(gl); } private void setupShaders(GL4 gl) { // Vertex shader source String vertexShaderSource = "#version 330 core\n" + "layout (location = 0) in vec3 aPos;\n" + "layout (location = 1) in vec3 aColor;\n" + "out vec3 ourColor;\n" + "uniform mat4 model;\n" + "uniform mat4 view;\n" + "uniform mat4 projection;\n" + "void main() {\n" + " gl_Position = projection * view * model * vec4(aPos, 1.0);\n" + " ourColor = aColor;\n" + "}"; // Fragment shader source String fragmentShaderSource = "#version 330 core\n" + "in vec3 ourColor;\n" + "out vec4 FragColor;\n" + "void main() {\n" + " FragColor = vec4(ourColor, 1.0);\n" + "}"; // Compile shaders int vertexShader = gl.glCreateShader(GL2.GL_VERTEX_SHADER); gl.glShaderSource(vertexShader, 1, new String[]{vertexShaderSource}, null); gl.glCompileShader(vertexShader); checkShaderCompileErrors(gl, vertexShader); int fragmentShader = gl.glCreateShader(GL2.GL_FRAGMENT_SHADER); gl.glShaderSource(fragmentShader, 1, new String[]{fragmentShaderSource}, null); gl.glCompileShader(fragmentShader); checkShaderCompileErrors(gl, fragmentShader); // Create shader program shaderProgram = gl.glCreateProgram(); gl.glAttachShader(shaderProgram, vertexShader); gl.glAttachShader(shaderProgram, fragmentShader); gl.glLinkProgram(shaderProgram); checkProgramLinkErrors(gl, shaderProgram); // Delete shaders gl.glDeleteShader(vertexShader); gl.glDeleteShader(fragmentShader); } private void setupBuffers(GL4 gl) { // Generate VAO, VBO, EBO IntBuffer vaoBuffer = Buffers.newDirectIntBuffer(1); IntBuffer vboBuffer = Buffers.newDirectIntBuffer(1); IntBuffer eboBuffer = Buffers.newDirectIntBuffer(1); gl.glGenVertexArrays(1, vaoBuffer); gl.glGenBuffers(1, vboBuffer); gl.glGenBuffers(1, eboBuffer); vao = vaoBuffer.get(0); vbo = vboBuffer.get(0); ebo = eboBuffer.get(0); // Bind VAO gl.glBindVertexArray(vao); // Bind and fill VBO gl.glBindBuffer(GL2.GL_ARRAY_BUFFER, vbo); FloatBuffer vertexBuffer = Buffers.newDirectFloatBuffer(vertices); gl.glBufferData(GL2.GL_ARRAY_BUFFER, vertices.length * Buffers.SIZEOF_FLOAT, vertexBuffer, GL2.GL_STATIC_DRAW); // Bind and fill EBO gl.glBindBuffer(GL2.GL_ELEMENT_ARRAY_BUFFER, ebo); IntBuffer indexBuffer = Buffers.newDirectIntBuffer(indices); gl.glBufferData(GL2.GL_ELEMENT_ARRAY_BUFFER, indices.length * Buffers.SIZEOF_INT, indexBuffer, GL2.GL_STATIC_DRAW); // Position attribute gl.glVertexAttribPointer(0, 3, GL2.GL_FLOAT, false, 6 * Buffers.SIZEOF_FLOAT, 0); gl.glEnableVertexAttribArray(0); // Color attribute gl.glVertexAttribPointer(1, 3, GL2.GL_FLOAT, false, 6 * Buffers.SIZEOF_FLOAT, 3 * Buffers.SIZEOF_FLOAT); gl.glEnableVertexAttribArray(1); // Unbind gl.glBindBuffer(GL2.GL_ARRAY_BUFFER, 0); gl.glBindVertexArray(0); } @Override public void display(GLAutoDrawable drawable) { GL4 gl = drawable.getGL().getGL4(); // Clear buffers gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT); // Use shader program gl.glUseProgram(shaderProgram); // Create transformation matrices float[] model = createModelMatrix(); float[] view = createViewMatrix(); float[] projection = createProjectionMatrix(); // Set uniform matrices int modelLoc = gl.glGetUniformLocation(shaderProgram, "model"); int viewLoc = gl.glGetUniformLocation(shaderProgram, "view"); int projectionLoc = gl.glGetUniformLocation(shaderProgram, "projection"); gl.glUniformMatrix4fv(modelLoc, 1, false, model, 0); gl.glUniformMatrix4fv(viewLoc, 1, false, view, 0); gl.glUniformMatrix4fv(projectionLoc, 1, false, projection, 0); // Draw cube gl.glBindVertexArray(vao); gl.glDrawElements(GL2.GL_TRIANGLES, indices.length, GL2.GL_UNSIGNED_INT, 0); gl.glBindVertexArray(0); // Update rotation rotation += 1.0f; if (rotation > 360.0f) rotation = 0.0f; } @Override public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) { GL4 gl = drawable.getGL().getGL4(); gl.glViewport(0, 0, width, height); } @Override public void dispose(GLAutoDrawable drawable) { GL4 gl = drawable.getGL().getGL4(); gl.glDeleteVertexArrays(1, new int[]{vao}, 0); gl.glDeleteBuffers(1, new int[]{vbo}, 0); gl.glDeleteBuffers(1, new int[]{ebo}, 0); gl.glDeleteProgram(shaderProgram); } private float[] createModelMatrix() { // Create rotation matrix float angle = (float) Math.toRadians(rotation); float cos = (float) Math.cos(angle); float sin = (float) Math.sin(angle); return new float[] { cos, 0.0f, sin, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -sin, 0.0f, cos, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; } private float[] createViewMatrix() { // Camera at (0, 0, 3), looking at origin, up vector (0, 1, 0) return new float[] { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, -3.0f, 0.0f, 0.0f, 0.0f, 1.0f }; } private float[] createProjectionMatrix() { float fov = (float) Math.toRadians(45.0f); float aspect = 800.0f / 600.0f; // Assuming 800x600 window float near = 0.1f; float far = 100.0f; float f = (float) (1.0 / Math.tan(fov / 2.0)); return new float[] { f / aspect, 0.0f, 0.0f, 0.0f, 0.0f, f, 0.0f, 0.0f, 0.0f, 0.0f, (far + near) / (near - far), (2 * far * near) / (near - far), 0.0f, 0.0f, -1.0f, 0.0f }; } private void checkShaderCompileErrors(GL4 gl, int shader) { IntBuffer success = Buffers.newDirectIntBuffer(1); gl.glGetShaderiv(shader, GL2.GL_COMPILE_STATUS, success); if (success.get(0) == 0) { IntBuffer infoLogLength = Buffers.newDirectIntBuffer(1); gl.glGetShaderiv(shader, GL2.GL_INFO_LOG_LENGTH, infoLogLength); byte[] infoLog = new byte[infoLogLength.get(0)]; gl.glGetShaderInfoLog(shader, infoLogLength.get(0), null, infoLog, 0); System.err.println("Shader compilation error: " + new String(infoLog)); } } private void checkProgramLinkErrors(GL4 gl, int program) { IntBuffer success = Buffers.newDirectIntBuffer(1); gl.glGetProgramiv(program, GL2.GL_LINK_STATUS, success); if (success.get(0) == 0) { IntBuffer infoLogLength = Buffers.newDirectIntBuffer(1); gl.glGetProgramiv(program, GL2.GL_INFO_LOG_LENGTH, infoLogLength); byte[] infoLog = new byte[infoLogLength.get(0)]; gl.glGetProgramInfoLog(program, infoLogLength.get(0), null, infoLog, 0); System.err.println("Program linking error: " + new String(infoLog)); } } }

Texture Mapping

4. Texture Loading and Application

import com.jogamp.opengl.util.texture.Texture; import com.jogamp.opengl.util.texture.TextureIO; import java.io.File; import java.io.IOException; public class TexturedRenderer implements GLEventListener { private int vao, vbo, ebo, shaderProgram; private Texture texture; private float rotation = 0.0f; // Quad vertices with texture coordinates private final float[] vertices = { // positions // colors // texture coords 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top right 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom right -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom left -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f // top left }; private final int[] indices = { 0, 1, 3, // first triangle 1, 2, 3 // second triangle }; @Override public void init(GLAutoDrawable drawable) { GL4 gl = drawable.getGL().getGL4(); gl.glClearColor(0.2f, 0.3f, 0.3f, 1.0f); setupShaders(gl); setupBuffers(gl); loadTexture(gl); } private void loadTexture(GL4 gl) { try { // Load texture from file texture = TextureIO.newTexture(new File("texture.jpg"), false); texture.setTexParameteri(gl, GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_LINEAR); texture.setTexParameteri(gl, GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_LINEAR); texture.setTexParameteri(gl, GL2.GL_TEXTURE_WRAP_S, GL2.GL_REPEAT); texture.setTexParameteri(gl, GL2.GL_TEXTURE_WRAP_T, GL2.GL_REPEAT); } catch (IOException e) { System.err.println("Could not load texture: " + e.getMessage()); } } private void setupShaders(GL4 gl) { String vertexShaderSource = "#version 330 core\n" + "layout (location = 0) in vec3 aPos;\n" + "layout (location = 1) in vec3 aColor;\n" + "layout (location = 2) in vec2 aTexCoord;\n" + "out vec3 ourColor;\n" + "out vec2 TexCoord;\n" + "uniform mat4 transform;\n" + "void main() {\n" + " gl_Position = transform * vec4(aPos, 1.0);\n" + " ourColor = aColor;\n" + " TexCoord = aTexCoord;\n" + "}"; String fragmentShaderSource = "#version 330 core\n" + "in vec3 ourColor;\n" + "in vec2 TexCoord;\n" + "out vec4 FragColor;\n" + "uniform sampler2D ourTexture;\n" + "void main() {\n" + " FragColor = texture(ourTexture, TexCoord) * vec4(ourColor, 1.0);\n" + "}"; // Compile and link shaders (similar to previous example) // ... shader compilation code ... } @Override public void display(GLAutoDrawable drawable) { GL4 gl = drawable.getGL().getGL4(); gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT); gl.glUseProgram(shaderProgram); // Create transformation matrix float[] transform = createTransformMatrix(); int transformLoc = gl.glGetUniformLocation(shaderProgram, "transform"); gl.glUniformMatrix4fv(transformLoc, 1, false, transform, 0); // Bind texture texture.bind(gl); // Render quad gl.glBindVertexArray(vao); gl.glDrawElements(GL2.GL_TRIANGLES, indices.length, GL2.GL_UNSIGNED_INT, 0); rotation += 1.0f; } private float[] createTransformMatrix() { float angle = (float) Math.toRadians(rotation); float cos = (float) Math.cos(angle); float sin = (float) Math.sin(angle); return new float[] { cos, -sin, 0.0f, 0.0f, sin, cos, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; } // Implement other required methods... }

3D Camera System

5. First-Person Camera

public class Camera { private float[] position = {0.0f, 0.0f, 3.0f}; private float[] front = {0.0f, 0.0f, -1.0f}; private float[] up = {0.0f, 1.0f, 0.0f}; private float[] right = {1.0f, 0.0f, 0.0f}; private float[] worldUp = {0.0f, 1.0f, 0.0f}; private float yaw = -90.0f; private float pitch = 0.0f; private float movementSpeed = 2.5f; private float mouseSensitivity = 0.1f; private float zoom = 45.0f; public float[] getViewMatrix() { return lookAt(position, new float[]{ position[0] + front[0], position[1] + front[1], position[2] + front[2] }, up); } public void processKeyboard(CameraMovement direction, float deltaTime) { float velocity = movementSpeed * deltaTime; switch (direction) { case FORWARD: position[0] += front[0] * velocity; position[1] += front[1] * velocity; position[2] += front[2] * velocity; break; case BACKWARD: position[0] -= front[0] * velocity; position[1] -= front[1] * velocity; position[2] -= front[2] * velocity; break; case LEFT: position[0] -= right[0] * velocity; position[1] -= right[1] * velocity; position[2] -= right[2] * velocity; break; case RIGHT: position[0] += right[0] * velocity; position[1] += right[1] * velocity; position[2] += right[2] * velocity; break; } } public void processMouseMovement(float xoffset, float yoffset, boolean constrainPitch) { xoffset *= mouseSensitivity; yoffset *= mouseSensitivity; yaw += xoffset; pitch += yoffset; if (constrainPitch) { if (pitch > 89.0f) pitch = 89.0f; if (pitch < -89.0f) pitch = -89.0f; } updateCameraVectors(); } public void processMouseScroll(float yoffset) { zoom -= yoffset; if (zoom < 1.0f) zoom = 1.0f; if (zoom > 45.0f) zoom = 45.0f; } private void updateCameraVectors() { float[] newFront = new float[3]; newFront[0] = (float) (Math.cos(Math.toRadians(yaw)) * Math.cos(Math.toRadians(pitch))); newFront[1] = (float) Math.sin(Math.toRadians(pitch)); newFront[2] = (float) (Math.sin(Math.toRadians(yaw)) * Math.cos(Math.toRadians(pitch))); front = normalize(newFront); right = normalize(crossProduct(front, worldUp)); up = normalize(crossProduct(right, front)); } private float[] lookAt(float[] eye, float[] center, float[] up) { float[] f = normalize(new float[]{ center[0] - eye[0], center[1] - eye[1], center[2] - eye[2] }); float[] s = normalize(crossProduct(f, up)); float[] u = crossProduct(s, f); return new float[]{ s[0], u[0], -f[0], 0.0f, s[1], u[1], -f[1], 0.0f, s[2], u[2], -f[2], 0.0f, -dotProduct(s, eye), -dotProduct(u, eye), dotProduct(f, eye), 1.0f }; } private float[] normalize(float[] v) { float length = (float) Math.sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]); return new float[]{v[0]/length, v[1]/length, v[2]/length}; } private float[] crossProduct(float[] a, float[] b) { return new float[]{ a[1]*b[2] - a[2]*b[1], a[2]*b[0] - a[0]*b[2], a[0]*b[1] - a[1]*b[0] }; } private float dotProduct(float[] a, float[] b) { return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]; } // Getters public float getZoom() { return zoom; } public float[] getPosition() { return position.clone(); } public enum CameraMovement { FORWARD, BACKWARD, LEFT, RIGHT } }

Advanced Example: 3D Model Viewer

6. Complete 3D Application

import com.jogamp.opengl.*; import com.jogamp.opengl.awt.GLCanvas; import com.jogamp.opengl.util.FPSAnimator; import javax.swing.*; import java.awt.event.*; public class ModelViewer3D extends JFrame { private GLCanvas canvas; private FPSAnimator animator; private Camera camera; private long lastFrameTime; private boolean[] keysPressed; public ModelViewer3D() { super("3D Model Viewer"); initialize(); } private void initialize() { setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setSize(1200, 800); setLocationRelativeTo(null); GLProfile profile = GLProfile.get(GLProfile.GL4); GLCapabilities capabilities = new GLCapabilities(profile); canvas = new GLCanvas(capabilities); camera = new Camera(); keysPressed = new boolean[512]; lastFrameTime = System.currentTimeMillis(); ModernRenderer renderer = new ModernRenderer(); renderer.setCamera(camera); canvas.addGLEventListener(renderer); setupInputHandling(); getContentPane().add(canvas); animator = new FPSAnimator(canvas, 60); animator.start(); } private void setupInputHandling() { canvas.addKeyListener(new KeyAdapter() { @Override public void keyPressed(KeyEvent e) { keysPressed[e.getKeyCode()] = true; } @Override public void keyReleased(KeyEvent e) { keysPressed[e.getKeyCode()] = false; } }); canvas.addMouseMotionListener(new MouseMotionAdapter() { private int lastX = -1, lastY = -1; @Override public void mouseDragged(MouseEvent e) { if (lastX == -1 || lastY == -1) { lastX = e.getX(); lastY = e.getY(); return; } int xOffset = e.getX() - lastX; int yOffset = lastY - e.getY(); // Reversed for natural movement camera.processMouseMovement(xOffset, yOffset, true); lastX = e.getX(); lastY = e.getY(); } @Override public void mouseMoved(MouseEvent e) { lastX = e.getX(); lastY = e.getY(); } }); canvas.addMouseWheelListener(e -> { camera.processMouseScroll(e.getPreciseWheelRotation()); }); // Process keyboard input in a separate thread new Thread(() -> { while (true) { processInput(); try { Thread.sleep(16); // ~60 FPS } catch (InterruptedException e) { break; } } }).start(); } private void processInput() { long currentTime = System.currentTimeMillis(); float deltaTime = (currentTime - lastFrameTime) / 1000.0f; lastFrameTime = currentTime; if (keysPressed[KeyEvent.VK_W]) { camera.processKeyboard(Camera.CameraMovement.FORWARD, deltaTime); } if (keysPressed[KeyEvent.VK_S]) { camera.processKeyboard(Camera.CameraMovement.BACKWARD, deltaTime); } if (keysPressed[KeyEvent.VK_A]) { camera.processKeyboard(Camera.CameraMovement.LEFT, deltaTime); } if (keysPressed[KeyEvent.VK_D]) { camera.processKeyboard(Camera.CameraMovement.RIGHT, deltaTime); } canvas.display(); // Trigger redraw } public static void main(String[] args) { SwingUtilities.invokeLater(() -> { new ModelViewer3D().setVisible(true); }); } }

Key Features Covered

Basic JOGL Setup: Creating windows and OpenGL contexts
Modern OpenGL: Shader-based rendering with VAOs, VBOs, and EBOs
3D Transformations: Model, view, and projection matrices
Texture Mapping: Loading and applying textures
Camera System: First-person camera with mouse and keyboard controls
Error Handling: Shader compilation and linking error checking
Performance: Efficient buffer management and rendering

Best Practices

Always check for OpenGL errors in development
Use vertex array objects for better performance
Implement proper resource cleanup
Use uniform buffers for frequently updated data
Implement level-of-detail (LOD) for complex scenes
Use frustum culling to avoid rendering off-screen objects

This comprehensive JOGL tutorial provides a solid foundation for creating sophisticated 3D graphics applications in Java.