[Java&OpenGL] texturing probleem

[Verwijderd]

Ik moet voor de les een 3D renderer schrijven. Nu is dat redelijk goed gelukt, alleen krijg ik geen textures op mijn objecten geplakt. Ik zit hier nu al een week op te zoeken, en ik weet echt niet waar de fout zou kunnen zitten. Ik gebruik de volgende methode om de texture te tekenen:

code:

public void draw(Texture texture, GL gl, Matrix4f matrix) {
        int[] texname = new int[1];
        
        gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1);

        gl.glGenTextures(1, texname);
        gl.glBindTexture(GL.GL_TEXTURE_2D, texname[0]);

        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT);
        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT);
        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
        gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA, texture.getWidth(), 
                            texture.getHeight(), 0, GL.GL_RGBA, GL.GL_INT, 
                            texture.getImageArray());
        
        gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_DECAL);
        
        Point3f[] coordinates = getCoordinates();
        int[] coordinateIndices = getCoordIndices();
        TexCoord2f[] textureCoordinates = getTexCoord();
        int[] textureCoordinateIndices = getTexCoordIndices();
        int size = coordinateIndices.length;
        
        float[] coord1={0,0,0},coord2={0,0,0},coord3={0,0,0};
        float[] texCoord1={0,0},texCoord2={0,0},texCoord3={0,0};
        
        gl.glEnable(GL.GL_TEXTURE_2D);
        gl.glPushMatrix();
        if(matrix != null) {
            gl.glMultMatrixf(matrix.getMatrixArray());
        }
        gl.glBindTexture(GL.GL_TEXTURE_2D, texname[0]);
        gl.glBegin(GL.GL_TRIANGLES);
        for (int i=0; i<size; i+=3) {
            coordinates[coordinateIndices[i]].get(coord1);
            coordinates[coordinateIndices[i+1]].get(coord2);
            coordinates[coordinateIndices[i+2]].get(coord3);
            textureCoordinates[textureCoordinateIndices[i]].get(texCoord1);
            textureCoordinates[textureCoordinateIndices[i+1]].get(texCoord2);
            textureCoordinates[textureCoordinateIndices[i+2]].get(texCoord3);
            
            gl.glTexCoord2f(texCoord1[0],texCoord1[1]); gl.glVertex3f(coord1[0],coord1[1],coord1[2]);
            gl.glTexCoord2f(texCoord2[0],texCoord2[1]); gl.glVertex3f(coord2[0],coord2[1],coord2[2]);
            gl.glTexCoord2f(texCoord3[0],texCoord3[1]); gl.glVertex3f(coord3[0],coord3[1],coord3[2]);
        }
        gl.glEnd();
        gl.glPopMatrix();
        gl.glDisable(GL.GL_TEXTURE_2D);

Waarbij die texture.getImageArray() gedefinieerd is als:

code:

public void getImage() {
        int w = getWidth();
        int h = getHeight();
        int[] returnArray;
        int[] temp;
        Object buffer;
        ColorModel model;
        
        PixelGrabber grabber = new PixelGrabber($src, 0, 0, w, h, false);
        try {
            grabber.grabPixels();
        }
        catch (InterruptedException e) {
            System.out.println("PixelGrabber Exception");
        }
        
        model = grabber.getColorModel();
        buffer = grabber.getPixels();
        temp = (int[])buffer;
        int size = temp.length;
        returnArray = new int[size];
        
        for (int i=0; i<size; i++) {
            returnArray[i] = model.getRGB(temp[i]);
        }
        image = returnArray;
    }

Maar dat geeft dus alleen zwarte vlakken. Iemand die de fout ziet?

[hobbit_be]

heb je light enabled?

[.oisyn]

Verwijderd schreef op 28 april 2004 @ 18:56:
Ik moet voor de les een 3D renderer schrijven.

Waarom maak je dan gebruik van opengl?

Maar wat zie je dan wel? Gewoon witte polygonen? Of helemaal niets? Zijn je mapping coordinaten wel goed? Wordt je texture wel goed geupload? Zijn je vertexcoordinaten wel goed?

[ Voor 18% gewijzigd door .oisyn op 29-04-2004 12:59 ]

[EfBe]

wilde gok:
gl.glEnable(GL.GL_TEXTURE_2D);
veel eerder aanroepen, bv VOORDAT je iets met textures gaat doen.

[.oisyn]

Die render state is alleen van invloed op het daadwerkelijke renderen, niet op het wel of niet kunnen binden van textures

[EfBe]

Heb je inderdaad gelijk in, was ook wilde gok . Wat me wel verbaasd is de 'zwarte vlakken'. Hij gebruikt wel GL_DECAL, dus de polycolor mag geen invloed hebben, maar toch. (hij zet ook geen polycolor, is wellicht ook een idee dat wel te doen)

[.oisyn]

Oh dat laatste zinnetje had ik even gemist
Zwarte vlakken dus, dan lijkt het me idd of verkeerde texturecoordinaten, of gewoon een verkeerd geuploadde texture. Check de returnwaardes van all die opengl calls eens? Met name de glTexImage2D call

Zijn je texture dimensies wel machten van 2? Oh, je pixel data type moet GL_UNSIGNED_BYTE zijn, niet GL_INT (eennalaatste parameter van glTexImage2D)

[Verwijderd]

mmm, ik krijg toch echt een array van ints terug uit die Pixelgrabber. Nu ja, ik heb het al geprobeerd, en het gaf geen beterschap. Gewoon een groot zwart vlak ipv een mooie texture

[Verwijderd]

Ok, ik heb de fout gevonden. JPEG file was 680*600 hetgeen dus GEEN macht van twee is. Nu weet ik het zeker, proffen zijn eikels. Alle andere textures mooi de juiste afmetingen.
Nu ja, bedankt voor de hulp iig.

[.oisyn]

Verwijderd schreef op 29 april 2004 @ 20:14:
mmm, ik krijg toch echt een array van ints terug uit die Pixelgrabber. Nu ja, ik heb het al geprobeerd, en het gaf geen beterschap. Gewoon een groot zwart vlak ipv een mooie texture

ja, maar de individuele componenten van de pixels zijn unsigned bytes, geen ints. Hoe denk je anders dat het werkt met floats? Je kunt niet 1 pixelkleur met een float weergeven, dan zul je 4 floats per pixel moeten gebruiken. Nu gebruik je 4 losse bytes per pixel

[.oisyn]

code:

void glTexImage2D(
  GLenum target,
  GLint level,
  GLint internalformat,
  GLsizei width,
  GLsizei height,
  GLint border,
  GLenum format,
  GLenum type,
  const GLvoid *pixels
);

[..]

Data is read from pixels as a sequence of signed or unsigned bytes, shorts or longs, or single-precision floating-point values, depending on type. These values are grouped into sets of one, two, three, or four values, depending on format, to form elements. If type is GL_BITMAP, the data is considered as a string of unsigned bytes (and format must be GL_COLOR_INDEX). Each data byte is treated as eight 1-bit elements, with bit ordering determined by GL_UNPACK_LSB_FIRST (see glPixelStore). Please see glDrawPixels for a description of the acceptable values for the type parameter

[ Voor 16% gewijzigd door .oisyn op 29-04-2004 20:54 ]