OpenGL: Modello che non visualizza in modo corretto. (Necessità di distanza correzione pareggio?)

Question

Sono nuovo di OpenGL. Sto giocando intorno con JOGL.

Ho un modello di obj che sto disegnando come poligoni. Sembra ok, solo che la maggior parte di esso viene ritagliato. Quindi penso che ho bisogno di aumentare la distanza pareggio.

Non sono davvero sicuro di come farlo. Ecco il mio codice di rendering:

private void render(GLAutoDrawable drawable) {
        GL2 gl = drawable.getGL().getGL2();
        GLUgl2 glu = new GLUgl2();

        gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);

        gl.glMatrixMode(GL2.GL_MODELVIEW);
        gl.glLoadIdentity();

        // Position the camera
        glu.gluLookAt(cameraPos.x, cameraPos.y, cameraPos.z, cameraPos.x
                + cameraForward.x, cameraPos.y + cameraForward.y, cameraPos.z
                + cameraForward.z, cameraUp.x, cameraUp.y, cameraUp.z);

            // uncommenting out this line will make everything disappear.
        // glu.gluPerspective(2, 1, 10, 1000);

        // ****** Start of example code ******
        gl.glCallList(axes); // Show X, Y, Z axes

        gl.glCallList(secondLines);

        gl.glCallList(triangle);

        gazebo.render(gl);

                // ...

E 'possibile che il mio problema è qualcosa di completamente diverso. gazebo è di tipo ObjModel, una classe che legge e rappresenta i file .obj. Ecco le sue render e metodi delle liste di compilazione pareggio:

private int drawID = 0;

public ObjModel(String fn, GL2 gl) {

            // ...

    readFile(fn);

    drawID = buildDrawList(gl);
}

public void render(GL2 gl) {
    gl.glCallList(drawID);
}

private int buildDrawList(GL2 gl) {
    int result = gl.glGenLists(1);

    gl.glNewList(result, GL2.GL_COMPILE);
    gl.glPushMatrix();
    gl.glBegin(GL2.GL_POLYGON);

    for (Point3f vert : vertices) {
        gl.glVertex3f(vert.x, vert.y, vert.z);
    }

    gl.glEnd();
    gl.glPopMatrix();
    gl.glEndList();

    return result;
}

private void readFile(String filename) {
    try {
        BufferedReader input = new BufferedReader(new FileReader(fileName));
        try {
            String newLine = null;
            while ((newLine = input.readLine()) != null) {

                int indVn = newLine.indexOf("vn ");
                if (indVn != -1) {
                    readNormal(newLine);
                    continue;
                }

                int indV = newLine.indexOf("v ");
                if (indV != -1) {
                    readVertex(newLine);
                    continue;
                }

                int indF = newLine.indexOf("f ");
                if (indF != -1) {
                    readPolygon(newLine);
                    continue;
                }

                int indVt = newLine.indexOf("vt ");
                if (indVt != -1) {
                    readTexture(newLine);
                    continue;
                }
            }
        } finally {
            input.close();
        }
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

posso postare le immagini se sono necessarie ulteriori informazioni.

Qualche consiglio? Grazie.

Answer 1

Sembra che il modello dispone di vertici al di fuori del piano di ritaglio. Ci sono alcune soluzioni per questo.

1) in scala il vostro modello in modo che tutti i vertici si inseriscono all'interno delle coordinate della clip (uso glScale())

2) Uso gluPerspective per impostare un 'telecamera' che ha un piano di taglio più profondo. Anche se hai provato questo, ho il sospetto che i risultati indesiderati sono perché non si sta modificando la matrice di proiezione quando si usa questa chiamata. Prova:

glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( 60, 1, 0.1, 1000.0 );

3) Uso glFrustrum() per modificare i piani di ritaglio. Questo è simile al gluPerspective ma fornisce una maggiore flessibilità nella costoso di una certa complessità.

FYI è comunque possibile utilizzare gluPerspective o glFrustrum in modalità matrice modelview, ma tenere presente che l'ordine con cui effettuare tali chiamate e altre chiamate matrice di trasformazione (es. GlScale, glTranslate, glRotate) è importante.

Answer 2

Prova a: gluPerspective (60, 1, 0,1, 1000);