String os = System.getProperty("os.name").toLowerCase();
return (os.indexOf("win") >= 0);

System.out.println("user.home: " + System.getProperty("user.home"));

user.home: C:\Users\Scott

System.getProperty("user.home") + /.dtp/gamename 

public void render() {
      
      glPushMatrix();
      
      
      
      glTranslatef(_position.getX(), _position.getY(), _position.getZ());
      
      glRotatef(_rotation.getX(), 1.0f, 0.0f, 0.0f);
      glRotatef(_rotation.getY(), 0.0f, 1.0f, 0.0f);
      glRotatef(_rotation.getZ(), 0.0f, 0.0f, 1.0f);
      
      glScalef(_scale, _scale, _scale);
      
      _texture.bind();
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
      glCallList(_listID);
      
      for(Object3D model : _children)
      {
         model.render();
      }
      
      glPopMatrix();
}

public class Sprite {
    Texture _texture;
    Vector2 _position;
    Point2 _size;
    
    public void load(String path)
    {
        _position = new Vector2(0);
        
        try {
         _texture = TextureLoader.getTexture("PNG", ResourceLoader.getResourceAsStream(path + ".png"));

      } catch (IOException e) {
      }
        
        _size = new Point2(_texture.getImageWidth(), _texture.getImageHeight());
    }
    
    public void draw()
    {
        Camera.enterOrtho(GameSettings.SCREEN_WIDTH, GameSettings.SCREEN_HEIGHT);
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        _texture.bind();
        GL11.glBegin(GL11.GL_QUADS);
            // Top Face
            GL11.glTexCoord2f(0.0f, 1.0f); GL11.glVertex3f(getX() - getWidth(), getY() + getHeight(), 0);  // Top Left Of The Texture and Quad
            GL11.glTexCoord2f(0.0f, 0.0f); GL11.glVertex3f(getX() - getWidth(), getY() - getHeight(), 0);  // Bottom Left Of The Texture and Quad
            GL11.glTexCoord2f(1.0f, 0.0f); GL11.glVertex3f(getX() + getWidth(), getY() + getHeight(), 0);  // Bottom Right Of The Texture and Quad
            GL11.glTexCoord2f(1.0f, 1.0f); GL11.glVertex3f(getX() + getWidth(), getY() - getHeight(), 0);  // Top Right Of The Texture and Quad
        GL11.glEnd();
        Camera.leaveOrtho();
    }
    
    public void setTexture(Texture texture)
    {
        _texture = texture;
    }
    
    public void setPosition(Vector2 position)
    {
        _position = position;
    }
    
    public void setX(float x)
    {
        _position.setX(x);
    }
    
    public void setY(float y)
    {
        _position.setY(y);
    }
    
    public float getX()
    {
        return _position.getX();
    }
    
    public float getY()
    {
        return _position.getY();
    }
    
    public Vector2 getPosition()
    {
        return _position;
    }
    
    public int getWidth()
    {
        return _size.getX();
    }
    
    public int getHeight()
    {
        return _size.getY();
    }
    
    public Point2 getSize()
    {
        return _size;
    }
}

public static void enterOrtho(int sizeX, int sizeY) 
    {
        // store the current state of the renderer
        GL11.glPushAttrib(GL11.GL_DEPTH_BUFFER_BIT | GL11.GL_ENABLE_BIT);
        GL11.glPushMatrix();
        GL11.glLoadIdentity();
        GL11.glMatrixMode(GL11.GL_PROJECTION); 
        GL11.glPushMatrix();   

        // now enter orthographic projection
        GL11.glLoadIdentity();      
        GL11.glOrtho(0, sizeX, sizeY, 0, -1, 1);
        GL11.glDisable(GL11.GL_DEPTH_TEST);
        GL11.glDisable(GL11.GL_LIGHTING);  
    }

    public static void leaveOrtho() 
    {
        // restore the state of the renderer
        GL11.glPopMatrix();
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glPopMatrix();
        GL11.glPopAttrib();
    }

glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_NEAREST);

public void draw() {
      GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
      ARBVertexBufferObject.glBindBufferARB(ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, _verticesID);
      GL11.glVertexPointer(3, GL11.GL_FLOAT, 0, 0);
      
//      GL11.glEnableClientState(GL11.GL_COLOR_ARRAY);
//      ARBVertexBufferObject.glBindBufferARB(ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, _coloursID);
//      GL11.glColorPointer(4, GL11.GL_FLOAT, 0, 0);

      _texture.bind();
      GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
      ARBVertexBufferObject.glBindBufferARB(ARBVertexBufferObject.GL_ELEMENT_ARRAY_BUFFER_ARB, _texcoordsID);
      GL11.glTexCoordPointer(2, GL11.GL_FLOAT, 0, 0);
      
      ARBVertexBufferObject.glBindBufferARB(ARBVertexBufferObject.GL_ELEMENT_ARRAY_BUFFER_ARB, _indicesID);
      GL12.glDrawRangeElements(GL11.GL_QUADS, 0, _indices.limit(), _indices.limit(),
                        GL11.GL_UNSIGNED_INT, 0);
      
    }
   
   // This adds indices for faces that are exposed (visible)
   public void buildIndices(Block[][][] in)
    {
        int sy = _size.getY() + 1;
        int sx = _size.getX() + 1;
        int sz = _size.getZ() + 1;
        
        // create indices
        _indices = BufferUtils.createIntBuffer(sy * sz * sx * 24);
        _texcoords = BufferUtils.createFloatBuffer(sy * sz * sx * 24);
        for(int y = 0; y < _size.getY(); y++)
        {
            for(int z = 0; z < _size.getZ(); z++)
            {
                for(int x = 0; x < _size.getX(); x++)
                {
                    if(in[x][y][z].getMaterial() != Material.Air)
                    {
                        int w = sx;
                        int d = sz;
                        int h = sy;

                        int zw = z * w;
                        int ywd = y * w * d;
                        int wd = w * d;


                        int v0 = x + zw + ywd;
                        int v1 = v0 + 1;
                        int v2 = x + w + zw + ywd;
                        int v3 = v2 + 1;
                        int v4 = x + wd + zw + ywd;
                        int v5 = v4 + 1;
                        int v6 = x + w + wd + zw + ywd;
                        int v7 = v6 + 1;

                        float[] tl = new float[] {0.0f, 0.0f}; // Top left of the texture
                        float[] tr = new float[] {1.0f, 0.0f}; // top right
                        float[] bl = new float[] {0.0f, 1.0f}; // bottom left
                        float[] br = new float[] {1.0f, 1.0f}; // bottom right

                  // "connectivity" is a construct of bools that refer to whether or 
                  // not another block is connected to the face in question.
                  
                  // true when there is a block next door, which tells us that the 
                  // face is not visible, so don't add its indices to the buffer.
                  
                        if(!in[x][y][z].getConnectivity().getFaceState(Face.Front))
                        {
                            addIndices(new int[] { v0, v1, v5, v4});
                            addTexcoords(new float[][] {tl, tr, bl, br});
                        }

                        if(!in[x][y][z].getConnectivity().getFaceState(Face.Right))
                        {
                            addIndices(new int[] { v1, v3, v7, v5});
                            addTexcoords(new float[][] {tl, tr, bl, br});
                        }

                        if(!in[x][y][z].getConnectivity().getFaceState(Face.Back))
                        {
                            addIndices(new int[] { v3, v2, v6, v7});
                            addTexcoords(new float[][] {tl, tr, bl, br});
                        }

                        if(!in[x][y][z].getConnectivity().getFaceState(Face.Left))
                        {
                            addIndices(new int[] { v2, v0, v4, v6});
                            addTexcoords(new float[][] {tl, tr, bl, br});
                        }

                        if(!in[x][y][z].getConnectivity().getFaceState(Face.Bottom))
                        {
                            addIndices(new int[] { v2, v3, v1, v0});
                            addTexcoords(new float[][] {tl, tr, bl, br});
                        }

                        if(!in[x][y][z].getConnectivity().getFaceState(Face.Top))
                        {
                            addIndices(new int[] { v4, v5, v7, v6});
                            addTexcoords(new float[][] {tl, tr, bl, br});
                        }
                    }
                }
            }
        }
        
        _indices.flip();
        _texcoords.flip();
        VBOHandler.bufferElementData(_indicesID, _indices);
        VBOHandler.bufferData(_texcoordsID, _texcoords);
    }
   
   
   // I've been using this to debug. It just populates the colour buffer with a random 
   // intensity of green... Per vertex.
   public void buildColours()
    {
        // create colours
        int vl = _vertices.limit() / 3;
        _colours = BufferUtils.createFloatBuffer(vl * 4);
        Random rand = new Random(System.currentTimeMillis());
        for(int x = 0; x < vl; x++)
        {
            
            addColour(new float[] {0.0f, 0.8f + (rand.nextFloat() / 5), 0.0f, 0.0f} );
        }
        
        _colours.flip();
    }