glLoadIdentity();

// <-- do your camera positioning / rotation stuff here

glPushMatrix();
glTranslatef(newX, newY, newZ);   // move to the point projected in front of the camera

glDisable(GL_TEXTURE_2D);   // turn this off to make sure the un-textured sphere surface will draw correctly

Sphere s = new Sphere();    // not optimal to declare here, but this is just an example!
s.draw(2, 12, 12);              // draw the sphere with a radius of 2, with 12 segments and sections

glEnable(GL_TEXTURE_2D);  // re-enable texturing
glPopMatrix();

double cameraPitchInRadians = Math.toRadians(camera.getCameraPitch());
double cameraYawInRadians = Math.toRadians(camera.getCameraYaw());
float f = (float)Math.cos(cameraPitchInRadians);
         
float newX = distanceFromCameraYouWantToMeasure * f * (float)Math.sin(cameraYawInRadians);
float newZ = distanceFromCameraYouWantToMeasure * f * (float)Math.cos(cameraYawInRadians);
float newY = distanceFromCameraYouWantToMeasure * (float)Math.sin(cameraPitchInRadians);

// one byte
byte value = 10;    

// 10 bytes maximum? Would this be zero-bytes until an element is initialised with a value?
byte[] values = new byte[10];    

// 10,000 bytes maximum? (9.7kb). Again, do the rules with the above array apply re: initialisation?
byte[][] valuesMany = new byte[100][100];    

float addX = 5  * (float)Math.sin(Math.toRadians(camera.yaw));
float addZ = 5  * (float)Math.cos(Math.toRadians(camera.yaw));
float addY = 5  * (float)Math.sin(Math.toRadians(camera.pitch));

float newX = camera.x + addX;
float newZ = camera.z + addZ;
float newY = camera.y + addY;

// Index arrays for each unique type of texture
boolean[] texIndex1 = new boolean[16*16];
boolean[] texIndex2 = new boolean[16*16];

protected void resetIndices()
{
    for (int i = 0; i < (16*16); i++) { texIndex1[i] = false; texIndex2[i] = false; }
}

protected void setupIndices()
{
    // N.B. These values will be set during the initial terrain load
    // Obviously there would be 'true' values for all 256 quads, but for now
    // I'm just using 8 as an example!
    texIndex1[14] = true;
    texIndex1[18] = true;
    texIndex1[25] = true;
    texIndex1[29] = true;

    texIndex2[6] = true;
    texIndex2[8] = true;
    texIndex2[11] = true;
    texIndex2[21] = true;
}

protected void renderPatch()
{
    // bind the first texture
    texture1.bind();
    for (int i = 0; i < (16*16); i++)
    {
        if (texIndex1[i])
        {
            // render the quad VBO object
        }
    }

    texture2.bind();
    for (int i = 0; i < (16*16); i++)
    {
        if (texIndex2[i])
        {
            // render the quad VBO object
        }
    }
}

for (int i = 0; i < (16*16); i++)
{
    // do we need to use texture 1, but are currently using texture 2?
    if (texIndex1[i] && texActive2)
    {
        texActive2 = false;
        texActive1 = true;
        texture1.bind();
    }

    // do we need to use texture 2, but are currently using texture 1?
    if (texIndex2[i] && texActive1)
    {
        texActive1 = false;
        texActive2 = true;
        texture2.bind();
    }

    // render the quad VBO object
}

newHeight[x][z] = (float)Math.abs(noise1[x][z] - noise2[x][z]);

protected void moveForward(float distance)
   {
      // track value (for debugging)
      lastMoveForward = distance;
      
      speedX -= (distance * (float)Math.sin(Math.toRadians(yaw)));
      speedZ += (distance * (float)Math.cos(Math.toRadians(yaw)));
       
       if (flyMode) { speedY += distance * (float) Math.tan(Math.toRadians(pitch)); }
   }

speed = (forwardSpeed * GameLoop.delta) / 1000f;
position.x += speed;

public void start()
   {
      lastFrame = getTime();
      lastFPS = getTime();
      delta = 0;
      gameState = startupState;
            
      // while the game is running we loop round updating and rendering
      while (!Display.isCloseRequested() && !AppWin.ref.isClosedRequested())
      {
         // calculate the frame delta (time elapsed since the last loop iteration)
         int _delta = (int) (getTime() - lastFrame);
         lastFrame = getTime();
         
         delta = _delta;
         
         // clear the display
         GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT | GL11.GL_STENCIL_BUFFER_BIT);
         
         // ensure a constant update speed
         int remainder = delta % 10;
         int step = delta / 10;
         
         // run as many update cycles as we need to catch up to our render timing
         for (int i=0;i<step;i++) 
         {
            update(10);
         }
         if (remainder != 0)
         {
            update(remainder);
         }
         
         // render the game
         render(delta);
         
         // refresh the display
         Display.update();
         Display.sync(60);

         // update the current FPS value
         updateFPS();
      }
      
      Display.destroy();
      System.exit(0);
   }

private long getTime() 
   {
      return (Sys.getTime() * 1000) / Sys.getTimerResolution();
   }

// what speed are we moving at, based on the current delta?
// 'forwardSpeed' will be a fixed value, such as 10
speed = (forwardSpeed * GameLoop.delta) / 1000f;