java.io.IOException Difficulty when adding "player" texture into screen

Question

I get this strange error from loading "Player.png" file from the Player Class.

I understand that my organization of the code is very sloppy and the methods I use are terrible. half of the code is borrowed from tutorials.

What 2 classes are supposed to do is create a screen with green colored tiles filling up the screen with a "player" sprite that can move right, left, up, and down with the W,A,S,D keys.

error:

java.io.IOException: Attempt to allocate a texture to big for the current hardware at org.newdawn.slick.opengl.InternalTextureLoader.getTexture(InternalTextureLoader.java:293) at org.newdawn.slick.opengl.InternalTextureLoader.getTexture(InternalTextureLoader.java:231) at org.newdawn.slick.opengl.InternalTextureLoader.getTexture(InternalTextureLoader.java:184) at org.newdawn.slick.opengl.TextureLoader.getTexture(TextureLoader.java:64) at org.newdawn.slick.opengl.TextureLoader.getTexture(TextureLoader.java:24) at test.PlayerClass.render(PlayerClass.java:69) at test.Main.render(Main.java:110) at test.Main.run(Main.java:82) at test.Main.main(Main.java:27)

Main Class

public class Main{

    private static boolean running = true;
    public static final int WIDTH = 1024;
    public static final int HEIGHT = 768;
    private static Texture tile;

static PlayerClass playerClass = new PlayerClass(100, 100, 32, 32);


public static void main(String[] args){

    Main main = new Main();
    main.run(); 
}

//Initialize Method
public static void init(int width, int height ) throws LWJGLException
{
    DisplayMode[] m = Display.getAvailableDisplayModes();
    for(DisplayMode mode : m)
    {
        if(mode.getWidth() == 1024 && mode.getHeight() == 768   && mode.getBitsPerPixel() == 32)
        {
            Display.setDisplayMode(mode);
        }

    }
    Display.setTitle("Game");
    Display.setVSyncEnabled(true);
    Display.sync(100);
    Display.create();

    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glLoadIdentity();

    GL11.glOrtho(0, Display.getDisplayMode().getWidth(), Display.getDisplayMode().getHeight(), 0, -1, 1 );
    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glLoadIdentity();

    GL11.glEnable(GL11.GL_ALPHA_TEST);
    GL11.glAlphaFunc(GL11.GL_GREATER, 0.2f);
    GL11.glEnable(GL11.GL_TEXTURE_2D);



    try {
        tile = TextureLoader.getTexture("PNG", ResourceLoader.getResourceAsStream("RPG/tile.png"));
    } 
    catch (IOException e) 
    {
        e.printStackTrace();
    }
}

public void run()
{
    try {
        init(1024, 768);
    } catch (LWJGLException e) {
        e.printStackTrace();
    }
    while(running)
    {
        Display.update();
        drawTiled(WIDTH, HEIGHT);
        input();
        update();
        render();

    }
    cleanup();
}

public static void input()
{
    if(Keyboard.isKeyDown(Keyboard.KEY_ESCAPE))
    {
        running = false;
    }

    playerClass.input();

}

public static void update()
{


}
public static void render()
{
    GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
    GL11.glLoadIdentity();

    try {
        playerClass.render();
    } catch (IOException e) {
        e.printStackTrace();
    }

    Display.update();


}

public static void cleanup()
{
    Display.destroy();
}

public void drawTiled(int screenWidth, int screenHeight) {
    Color.white.bind();
    tile.bind();
    int numberPerRow = screenWidth / tile.getTextureWidth();
    int numberOfRows = screenHeight / tile.getTextureHeight();
    GL11.glBegin(GL11.GL_QUADS);
    for (int j = 0; j < numberOfRows; j++) {
        //System.out.print("{");
        for (int i = 0; i < numberPerRow; i++) 
        {

            //top left
            GL11.glTexCoord2f(0, 0);
            GL11.glVertex2f(tile.getTextureWidth() * i, tile.getTextureHeight() * j);

            //top right
            GL11.glTexCoord2f(1, 0);
            GL11.glVertex2f(tile.getTextureWidth() * (i + 1), tile.getTextureHeight() * j);

            //bottom right
            GL11.glTexCoord2f(1, 1);
            GL11.glVertex2f(tile.getTextureWidth() * (i + 1), tile.getTextureHeight() * (j + 1));

            //bottom left
            GL11.glTexCoord2f(0, 1);
            GL11.glVertex2f(tile.getTextureWidth() * i, tile.getTextureHeight() * (j + 1));    
       }

    }
  }
}

Player Class

public class PlayerClass {
  private float x, y;
  private int w, h;
  private Texture player;
  private FloatBuffer verts = BufferUtils.createFloatBuffer(2 * 4);
  private FloatBuffer tex = BufferUtils.createFloatBuffer(2 * 4);

public PlayerClass(float X, float Y, int W, int H)
{
    x = X;
    y = Y;
    w = W;
    h = H;

    verts.put(new float[]{
        0.0f, 0.0f,
        32.0f, 0.0f,
        32.0f, 32.0f,
        0.0f, 32.0f

    });

    tex.put(new float[]{
        0.0f, 0.0f,
        1.0f, 0.0f,
        1.0f, 1.0f,
        0.0f, 1.0f
    });     
}

public void input()
{
    if(Keyboard.isKeyDown(Keyboard.KEY_W))
    {
        y -= 10;
    }

    else if(Keyboard.isKeyDown(Keyboard.KEY_S))
    {
        y += 10;
    }

    if(Keyboard.isKeyDown(Keyboard.KEY_A))
    {
        x -= 10;
    }

    else if(Keyboard.isKeyDown(Keyboard.KEY_D))
    {
        x += 10;
    }

}

public void render() throws IOException
{
    player = TextureLoader.getTexture("PNG", ResourceLoader.getResourceAsStream("RPG/player.png"));

    player.bind();
    verts.rewind();
    tex.rewind();

    GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
    GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);

    GL11.glTranslatef(x, y, 0.0f);

    GL11.glVertexPointer(2, 0, verts);
    GL11.glTexCoordPointer(2, 0, tex);

    GL11.glDrawArrays(GL11.GL_QUADS, 0, 4);

    GL11.glTranslatef(-x, -y, 0.0f);

    GL11.glDisableClientState(GL11.GL_VERTEX_ARRAY);
    GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
   }
 }

Answer 1

How large is tile.png - the maximum texture size can vary depending your card, and I think, some other factors. Your file is probably outside this dimension.

Cody's answer gives you the way to get the max texture size for your card. If you're writing a game for use by many other people, you'll probably want to integrate that code into your game code in such a way that it loads different resolution textures based on the capabilities of the card it's running on, or simply find a default that works on any card that you want to support, and use that for all installations.

Here's some additional reading that will explain more about this issue, some history about it, and more technical info that you might find useful:

• Official OpenGL wiki on 'Texture'
• List of maximum texture size by video card (from 2006, but you'll get the idea)
• An FAQ of texture mapping

Answer 2

Run this:

System.out.println(GL11.glGetInteger(GL11.GL_MAX_TEXTURE_SIZE));

It'll tell you the max texture size allowed by your Graphics card. Make sure that your graphics card can handle a texture of the size that you are trying to use. According to the error, it can't.