DGL • Thema anzeigen - Was fehlt, was ist falsch ???

Was fehlt, was ist falsch ???

Moderator: DGL-Team

Seite 1 von 1

[ 1 Beitrag ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

paddy

Betreff des Beitrags: Was fehlt, was ist falsch ???

Verfasst: Mi Jun 14, 2006 10:26

DGL Member

Registriert: Mo Mai 22, 2006 16:33
Beiträge: 9

Hallo,

die Funktion computeVisabilityMatrix() soll mir alle vertices liefern, die aus Lichtquellensicht sichtbar sind (im orthogr. Prtojektionsmodus).
Danach will ich nur noch die sichtbaren anzeigen lassen.
Lass ich alle Vertices rendern, ohne vorher computeVisabilityMatrix() aufzurufen, dann werden alle vertices korrekt angezeigt. Lasse ich die Visabilitymatrix berechnen und dann nur die sichtbaren vertices rendern, erhalte ich einen schwarzen Bildschirm.

Irgendwas in computeVisabilityMatrix() scheint mir die Anzeige kaputt zu machen, bzw. stelle ich sie danach nicht korerekt ein.
Kann mir jemand sagen wo der Fehler liegt?

Code:

 
void computeVisabilityMatrix() {
 
    int i,j;
    int Pixel;
    int counter;
    GLuint queries[3494];
    GLint available;
 
    glPushMatrix();
    // enable orthographic projection
    glOrtho(0, width, height, 0, NEAR_CLIPPING_PLANE, FAR_CLIPPING_PLANE);
 
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); // disable Colorbuffer
    glEnable(GL_STENCIL_TEST);
    glEnable(GL_DEPTH_TEST);
 
    // Query erzeugen
    glGenQueriesARB(3494, queries);
    counter = 0;
    // for all light directions j do
    for (j=0; j<nLights; j++) {
        // set camera at light direction lj
        gluLookAt(LightPositions[j][0], LightPositions[j][1], LightPositions[j][2], model->BBox->Center.x, model->BBox->Center.y, model->BBox->Center.z, 0.0f,1.0f,0.0f);
        // render object into depth buffer with polygon offset
        glEnable(GL_POLYGON_OFFSET_POINT);
        drawFirstPass();
        // for all vertices i do
        for (i=0; i<model->nVertex; i++) {
            // begin query i
            glBeginQueryARB(GL_SAMPLES_PASSED_ARB,queries[i]);
 
            // render vertex i
            glBegin(GL_POINTS);         
                glVertex3f(model->VertexArray[i].x, model->VertexArray[i].y, model->VertexArray[i].z);
            glEnd();
 
            //end query i
            glEndQueryARB(GL_SAMPLES_PASSED_ARB);
        }
        // end for
        glFlush();
        // Do other work until "most" of the queries are back, to avoid
        // wasting time spinning
        i = 3494 * 3/4; // N * 3/4 instead of N-1, to prevent the GPU from going idle
        do {
            //DoSomeStuff();
            glGetQueryObjectivARB(queries[i],
                                  GL_QUERY_RESULT_AVAILABLE_ARB,
                                  &available);
        } while (!available);
        
        // for all vertices i do
        for (i=0; i<model->nVertex; i++) { 
            // retrieve result from query i
            glGetQueryObjectivARB(queries[i],GL_QUERY_RESULT_ARB,&Pixel);
            //if result is "visible" then
            if (Pixel > 0) {   
                // Mij = ni(vertex normal) ·(dot product) lj(light direction) ;lj ist wohl gleich lightposition
                VisMatrix[j][i] = model->NormalArray[i].x * LightPositions[j][0] + model->NormalArray[i].y * LightPositions[j][1] + model->NormalArray[i].z * LightPositions[j][2];
                counter++;
            } else {
                VisMatrix[j][i] = 0;
            }
            //end if
        }
        // end for
    }
    // end for
 
    // Query wieder freigeben
    glDeleteQueriesARB(3494, queries);
    GLErrorHandler();
    glPopMatrix();
}
 

Code:

 
void drawFirstPass() {
 
    int i;
    ObjNormal vNormal;
    ObjVertex v1, v2, v3;
 
    // schalte depth testing ein
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);     // The Type Of Depth Testing To Do
 
    glBegin(GL_TRIANGLES);
        for (i=0; i<model->nPolygon; i++) {
            if (model->nNormal > 0) {
                glVertex3f(model->VertexArray[model->PolygonArray[i].Vertex[0] - 1].x, model->VertexArray[model->PolygonArray[i].Vertex[0] - 1].y, model->VertexArray[model->PolygonArray[i].Vertex[0] - 1].z);
                glNormal3f(model->NormalArray[model->PolygonArray[i].Normal[0] - 1].x, model->NormalArray[model->PolygonArray[i].Normal[0] - 1].y, model->NormalArray[model->PolygonArray[i].Normal[0] - 1].z);
                glVertex3f(model->VertexArray[model->PolygonArray[i].Vertex[1] - 1].x, model->VertexArray[model->PolygonArray[i].Vertex[1] - 1].y, model->VertexArray[model->PolygonArray[i].Vertex[1] - 1].z);
                glNormal3f(model->NormalArray[model->PolygonArray[i].Normal[1] - 1].x, model->NormalArray[model->PolygonArray[i].Normal[1] - 1].y, model->NormalArray[model->PolygonArray[i].Normal[1] - 1].z);
                glVertex3f(model->VertexArray[model->PolygonArray[i].Vertex[2] - 1].x, model->VertexArray[model->PolygonArray[i].Vertex[2] - 1].y, model->VertexArray[model->PolygonArray[i].Vertex[2] - 1].z);
                glNormal3f(model->NormalArray[model->PolygonArray[i].Normal[2] - 1].x, model->NormalArray[model->PolygonArray[i].Normal[2] - 1].y, model->NormalArray[model->PolygonArray[i].Normal[2] - 1].z);
            } else {
                v1 = model->VertexArray[model->PolygonArray[i].Vertex[0] - 1];
                v2 = model->VertexArray[model->PolygonArray[i].Vertex[1] - 1];
                v3 = model->VertexArray[model->PolygonArray[i].Vertex[2] - 1];
                vNormal = CalcNormal(v1, v2, v3);
                glNormal3f(vNormal.x, vNormal.y, vNormal.z);
                glVertex3f(v1.x, v1.y, v1.z);
                glVertex3f(v2.x, v2.y, v2.z);
                glVertex3f(v3.x, v3.y, v3.z);
            }
        }
    glEnd();
}
 

Code:

 
void renderSceneAO(void) {
 
 
    glClear(GL_COLOR_BUFFER_BIT | GL_ACCUM_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
    glPushMatrix();
 
    if (LightsOn) {
        // switch on lights
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
    } else {
        // switch off lights
        glDisable(GL_LIGHTING);
        glDisable(GL_LIGHT0);
    }
 
    glMatrixMode(GL_MODELVIEW);
 
    gluLookAt(model->BBox->Center.x, model->BBox->Center.y, model->BBox->Center.z + distance, model->BBox->Center.x + lx, model->BBox->Center.y + ly, model->BBox->Center.z + lz, 0.0f,1.0f,0.0f);
 
    drawSecondPass();
 
    glPopMatrix();
 
    glutSwapBuffers();
 
    GLErrorHandler();
}
 

Code:

 
void drawSecondPass() {
 
    int i;
    BOOL drawVertex; 
    setObjectMaterial();
 
    glPointSize(1.0);
    glDisable(GL_DEPTH_TEST);
    glPolygonOffset(1.0, 1.0);
    drawVertex = FALSE;
    for (i=0; i<model->nVertex; i++) {
        drawVertex = setLights(i);
        if (drawVertex) {
            glBegin(GL_POINTS);
                glVertex3f(model->VertexArray[i].x, model->VertexArray[i].y, model->VertexArray[i].z);
                glNormal3f(model->NormalArray[i].x, model->NormalArray[i].y, model->NormalArray[i].z);
            glEnd();
        }
        GLErrorHandler();
    }
}
 

Ich weiß nicht weiter!

Nach oben

Seite 1 von 1

[ 1 Beitrag ]

Foren-Übersicht » Programmierung » OpenGL

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 2 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.