Slick und LWJGL Texture lag

[CookieSoft]

Hey,
ich habe mal eine Frage, ich lade meine Texturen mit Slick und nutze sie dann in opengl. Jetzt ist es aber so ich habe eine kleine Textur da klappt alles gut. Aber jetzt lade ich eine große Textur jetzt laggt das ganze Spiel... Was kann man da machen und woran liegt das?

 

[Network]

Wie groß ist die Textur und wie groß ist die eigentliche Darstellung?
Unterscheiden sich die beiden zu sehr, wird sehr viel Berechnungszeit benötigt das Bild zu skalieren.

Gruß
Net

 

[Guest2]

Moin,

zur Skalierung gibt es Mipmaps. Grundsätzlich sind große Texturen mit OpenGL kein Problem (natürlich bis zu gewissen Grenzen, eine 100GB Textur wird eine mobile GPU nur schwer bewältigen können).

Lässt sich das Problem vielleicht in ein KSKB gießen?

Viele Grüße,
Fancy

 

[CookieSoft]

Also meine Texturen-Datei hat eine Abmessung von 880x740 und eine Größe von 1,18MB. Diese wird als "Hintergrund" für mein Spiel verwendet daher wird diese auf die Größe meines Displays skaliert, dieser hat eine Abmessung von 800x600. Ich denke nämlich nicht das es an der Dateigröße liegt...

 

[CookieSoft]

Also ich habe ein Beispiel auf cookiesoft.org hochgeladen (.RAR 38.0MB). (ACHTUNG::: ICH lade die Datei grade hoch ihr müsst kurz warten bis es fertig hochgeladen hat...).

 

[Evil-Devil]

Zunächst einmal sollte deine Texture PoT (n^2) kompatibel sein, dann brauch SLICK die nicht mehr angleichen. Kann es vielleicht sein das du die Texture im eigentlichen Render Vorgang jedes Mal neu lädst? Denn selbst bei einer 2048x2048 Textur sollte noch nichts ruckeln...

Wieso ist das Beispiel 38! MB klein?

 

[CookieSoft]

Klein? Es ist halt ne rar datei... Und 2. wenn ich die Texture beim initialisieren lade habe ich das selbe Problem...

 

[CookieSoft]

Ok die Datei ist jetzt hochgeladen.

 

[Evil-Devil]

So...RAR geladen...und so viele Ohrfeigen kann man gar nicht mehr austeilen. Wieso zur Hölle packst du erstens das 28! MB PSD mit ins RAR und zweitens wieso packst du es ebenfalls in JAR rein? Also 56MB an Daten die niemanden interessieren!

Die Libs und Natives interessieren auch niemanden. Es wurde nach Source gefragt und alles was du lieferst ist ein überfrachtetes Archive das keinen Source enthält.


Grml!

 

[CookieSoft]

Ok, ich wollte halt schnell ein Beispiel hochladen und hab jetzt halt vergessen die PSD und alles rauszuhauen srry...

 

[Evil-Devil]

Ein Ausschnitt aus deinem Programm an dem du die Textur lädst und anzeigst würde doch schon vollkommen genügen...

 

[CookieSoft]

Also:
So lade ich den Hintergrund:

GL11.glEnable(GL11.GL_TEXTURE_2D);
        Texture texture = Textures.getTexture("blatt");
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
        texture.bind();
        BufferObject bo = new BufferObject();
        bo.setDrawMode(GL11.GL_QUADS);
        bo.setTextureMax(texture.getWidth(), texture.getHeight());
        bo.putCoord(0.0f, 0.0f);
        bo.putCoord(Display.getWidth(), 0.0f);
        bo.putCoord(Display.getWidth(), Display.getHeight());
        bo.putCoord(0.0f, Display.getHeight());
        bo.drawObject();
        texture.release();

Meine Textures class:

public static Texture getTexture(String file){
        try {
            Texture tex = TextureLoader.getTexture("PNG", new FileInputStream(new File("res/" + file + ".png")));
            return tex;
        } catch (IOException ex) {
            Logger.getLogger(Textures.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }

Meine BufferObjectClass (Nicht wunder ist noch ein wenig ein Chaos ;D):

public class BufferObject {
    private final int dimension = 2;
    private int drawMode; 
    private ArrayList<float[]> floatArray;
    private ArrayList<float[]> floatTexture;
    
    private boolean hasTexture;
    private boolean hasColor;
    
    public BufferObject(){
        floatArray = new ArrayList<float[]>();
        floatTexture = new ArrayList<float[]>();
        hasTexture = false;
        hasColor = false;
    }
    public void setDrawMode(int mode){
        drawMode = mode;
    }
    public void setTexturePart(float texWidth, float texHeight, int nPartsX, int nPartsY, int partX, int partY){
        hasTexture = true;
        floatTexture.add(new float[]{texWidth/nPartsX*partX, (texHeight/nPartsY*partY)+(texHeight/nPartsY)});
        floatTexture.add(new float[]{texWidth/nPartsX*partX, texHeight/nPartsY*partY});
        floatTexture.add(new float[]{(texWidth/nPartsX*partX)+(texWidth/nPartsX), texHeight/nPartsY*partY});
        floatTexture.add(new float[]{(texWidth/nPartsX*partX)+(texWidth/nPartsX), (texHeight/nPartsY*partY)+(texHeight/nPartsY)});
    }
    public void setTextureMax(float texWidth, float texHeight){
        hasTexture = true;
        floatTexture.add(new float[]{0.0f, 0.0f});
        floatTexture.add(new float[]{texWidth, 0.0f});
        floatTexture.add(new float[]{texWidth, texHeight});
        floatTexture.add(new float[]{0.0f, texHeight});
    }
    public void putTexCoord(float x, float y){
        hasTexture = true;
        floatTexture.add(new float[]{x, y});
    }
    public void putCoord(float[] coord){
        floatArray.add(coord);
    }
    public void putCoord(float x, float y){
        floatArray.add(new float[]{x, y});
    }
    public void drawObject(){
        FloatBuffer buffer = BufferUtils.createFloatBuffer((floatArray.size()*dimension));
        FloatBuffer textureBuffer = BufferUtils.createFloatBuffer((floatTexture.size()*2));
        
        for(int i=0;i<=floatArray.size()-1;i++){
            buffer.put(floatArray.get(i));
        }
        buffer.flip();
        for(int i=0;i<=floatTexture.size()-1;i++){
            textureBuffer.put(floatTexture.get(i));
        }
        textureBuffer.flip();
        
        int texId = glGenBuffers();
        int bufferId = glGenBuffers();
        
        if(hasTexture){
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
            glBindBuffer(GL_ARRAY_BUFFER, texId);
            glBufferData(GL_ARRAY_BUFFER, textureBuffer, GL_STATIC_DRAW);
            glTexCoordPointer(2, GL_FLOAT, 0, 0L);
        }
        glBindBuffer(GL_ARRAY_BUFFER, bufferId);
        glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glEnableClientState(GL_VERTEX_ARRAY);
        glBindBuffer(GL_ARRAY_BUFFER, bufferId);
        glVertexPointer(dimension, GL_FLOAT, 0, 0L);
        glDrawArrays(drawMode, 0, floatArray.size());
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glDisableClientState(GL_VERTEX_ARRAY);
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        glDeleteBuffers(bufferId);
        glDeleteBuffers(texId);
    }
}

Ich hoffe das reicht an Source 🙂 ...

 

[Evil-Devil]

Ok...wenn ich das richtig lese, wird bei jedem neu zeichnen deines Bildschirms die Textur erneut geladen. Wieso erzeugst du nicht einfach nur einmal den Buffer und übergibst den dann zum zeichnen? Das würde viel Arbeitsaufwand reduzieren.

 

[CookieSoft]

Ok super danke werde es gleich mal probieren...