texSphere.setTexParameteri(GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT);
            texSphere.setTexParameteri(GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT);
            gl.glTexGeni(GL.GL_S, GL.GL_TEXTURE_GEN_MODE, GL.GL_REFLECTION_MAP);
            gl.glTexGeni(GL.GL_T, GL.GL_TEXTURE_GEN_MODE, GL.GL_REFLECTION_MAP);
            gl.glTexGeni(GL.GL_R, GL.GL_TEXTURE_GEN_MODE, GL.GL_REFLECTION_MAP);
            gl.glEnable(GL.GL_TEXTURE_GEN_S);
            gl.glEnable(GL.GL_TEXTURE_GEN_T);
            gl.glEnable(GL.GL_TEXTURE_GEN_R);

package glsl1;

import com.sun.opengl.util.Animator;
import com.sun.opengl.util.texture.Texture;
import com.sun.opengl.util.texture.TextureIO;
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;
import static javax.media.opengl.GL.*;

/**
 * SimpleShaderTemplate.java
 * @author Mathias 'cylab' Henze
 */
public class glsl1 implements GLEventListener
{
   private GLU glu = new GLU();

   // Hold the shader program for later use
   private int program;
   // Holds the texture object for later use
   private int textureID;

   public static void main(String[] args)
   {
      Frame frame = new Frame("Simple JOGL GLSL Application");
      GLCanvas canvas = new GLCanvas();

      canvas.addGLEventListener(new glsl1());
      frame.add(canvas);
      frame.setSize(640, 480);
      final Animator animator = new Animator(canvas);
      frame.addWindowListener(new WindowAdapter()
      {
         @Override
         public void windowClosing(WindowEvent e)
         {
            // Run this on another thread than the AWT event queue
            // so that Animator.stop() completes before exiting
            new Thread(new Runnable()
            {
               public void run()
               {
                  animator.stop();
                  System.exit(0);
               }
            }).start();
         }
      });
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
      animator.start();
   }

   public void init(GLAutoDrawable drawable)
   {
      // drawable.setGL(new DebugGL(drawable.getGL()));
      GL gl = drawable.getGL();

      // You won't get far without error checking ;)
      String errors = null;

      try
      {
         // Load some texture
         Texture texture = TextureIO.newTexture(glsl1.class.getResource("moon.png"), false, "png");

         // Store the OpenGL texture object ID for later use
         textureID = texture.getTextureObject();
      }
      catch (Exception ex)
      {
         Logger.getLogger(glsl1.class.getName()).log(Level.SEVERE, null, ex);
      }

      // This is the shader source. For simplicity just use a single concatenated string
      String[] shader =
      {
         // This variable specifies the texture unit to use, called "sampler" in GLSL
         "uniform sampler2D texUnit;\n" +
         // main() is called for every pixel on screen (called "fragment" in GLSL) while rasterizing
         "void main(void)\n" +
         "{\n" +
             // The gl_TexCoord array is a build in GLSL variable that holds the glTexCoordXX() values
         "   vec2 texCoord = gl_TexCoord[0].xy;\n" +
             // texture2D() gets a texel from the texture unit at the given location
         "   vec4 texel = texture2D(texUnit, texCoord);\n" +
             // Now assign the texel to be the current pixels output color.
             // Mask out green, to see that the shader is indeed used (vec4 is r,g,b,a)
         "   gl_FragColor = texel * vec4(1.0, 0.0, 1.0, 1.0);\n" +
         "}\n"
      };

      // Since java Strings aren't 0-terminated, store the length for submission to glShaderSource
      // (maybe this unnecessary and JOGL implicitly 0-terminates the Strings, but you never know)
      int[] lengths = { shader[0].length() };

      // Create and store a shader program
      program = gl.glCreateProgramObjectARB();

      // Create the fragment shader object
      int frag = gl.glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

      // Tell the shader program to use the fragment shader
      gl.glAttachObjectARB(program, frag);

      // Copy the shader source to GL implementation.
      // You need the amount of Strings, the String[] and an array of the Strings lenghts
      gl.glShaderSourceARB(frag, shader.length, shader, lengths, 0);

      // Compile the shader
      gl.glCompileShaderARB(frag);

      // Check for compile errors
      if ((errors = getGLErrorLog(gl, frag)) != null)
         throw new RuntimeException("Compile error\n" + errors);

      // Link the program
      gl.glLinkProgramARB(program);

      // Check for link errors
      if ((errors = getGLErrorLog(gl, program)) != null)
         throw new RuntimeException("Link error\n" + errors);

      // Use the program, to be able to assign values to the uniforms
      gl.glUseProgramObjectARB(program);

      // Get the location of the texUnit uniform, so we can assign a value to it
      int texUnit = gl.glGetUniformLocationARB(program, "texUnit");

      // Assign the GL_TEXTURE0 unit to the uniform variable
      // CAUTION: you need to set the plain texture _unit_ _number_,
      // not the GL constant nor the textur object here!!!
      gl.glUniform1iARB(texUnit, 0);

      // Enable VSync
      gl.setSwapInterval(1);

      // Setup the clear color
      gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

   }

   public void display(GLAutoDrawable drawable)
   {
      GL gl = drawable.getGL();

      // Clear the drawing area
      gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

      // Reset the current matrix to the "identity"
      gl.glLoadIdentity();

      // Move the "drawing cursor" around
      gl.glTranslatef(0.0f, 0.0f, -3.0f);

      // Choose the current texture unit
      gl.glActiveTexture(GL_TEXTURE0);

      // Bind a texture to the current texture unit
      gl.glBindTexture(GL_TEXTURE_2D, textureID);

      // Enable the shader program
      gl.glUseProgramObjectARB(program);

      // Draw a quad to be textured
      gl.glBegin(GL_QUADS);
      {
         gl.glTexCoord2f(0, 0);
         gl.glVertex3f(-1, -1, 0);
         gl.glTexCoord2f(1, 0);
         gl.glVertex3f(1, -1, 0);
         gl.glTexCoord2f(1, 1);
         gl.glVertex3f(1, 1, 0);
         gl.glTexCoord2f(0, 1);
         gl.glVertex3f(-1, 1, 0);
      }
      gl.glEnd();

      // Disable all shaders
      gl.glUseProgramObjectARB(0);

      // Flush all drawing operations to the graphics card
      gl.glFlush();
   }

   public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height)
   {
      GL gl = drawable.getGL();

      if (height <= 0)
      { // avoid a divide by zero error!

         height = 1;
      }
      final float h = (float) width / (float) height;
      gl.glViewport(0, 0, width, height);
      gl.glMatrixMode(GL_PROJECTION);
      gl.glLoadIdentity();
      glu.gluPerspective(45.0f, h, 1.0, 20.0);
      gl.glMatrixMode(GL_MODELVIEW);
      gl.glLoadIdentity();
   }

   public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged)
   {
   }

   // Checks for arbitrary GL errors. Could also be accomplished by enabling the DebugGL pipeline
   private String getGLError(GL gl)
   {
      boolean hasError = false;
      String message = "";
      for (int glErr = gl.glGetError(); glErr != GL.GL_NO_ERROR; glErr = gl.glGetError())
      {
         message += (hasError ? "\n" : "") + glu.gluErrorString(glErr);
         hasError = true;
      }
      return hasError ? message : null;
   }

   // Checks the info log for compile/link errors
   private String getGLErrorLog(GL gl, int obj)
   {
      boolean hasError = false;
      int[] infologLength = {0};
      int[] charsWritten = {0};
      byte[] infoLog;

      String message = "";
      String error = getGLError(gl);
      if (error != null)
      {
         message += error;
         hasError = true;
      }

      gl.glGetObjectParameterivARB(obj, GL_OBJECT_INFO_LOG_LENGTH_ARB, infologLength, 0);
      error = getGLError(gl);
      if (error != null)
      {
         message += (hasError ? "\n" : "") + error;
         hasError = true;
      }

      if (infologLength[0] > 1)
      {
         infoLog = new byte[infologLength[0]];
         gl.glGetInfoLogARB(obj, infologLength[0], charsWritten, 0, infoLog, 0);
         message += (hasError ? "\n" : "") + "InfoLog:\n" + new String(infoLog);
         hasError = true;
      }
      error = getGLError(gl);
      if (error != null)
      {
         message += (hasError ? "\n" : "") + error;
         hasError = true;
      }
      return hasError ? message : null;
   }
}

SCHWERWIEGEND: null
java.io.IOException: URL was null
at com.sun.opengl.util.texture.TextureIO.newTextureDataImpl(TextureIO.java:818)
   at com.sun.opengl.util.texture.TextureIO.newTextureData(TextureIO.java:236)
   at com.sun.opengl.util.texture.TextureIO.newTexture(TextureIO.java:521)
   at glsl1.glsl1.init(glsl1.java:73)