Environment Mapping OpenGL

undefined

Hallo,
bin neu hier un weiß jetzt nit ob ich das bei Programmier-Ecke schreiben kann. aber zu meinem Problem:
ich will ein Objekt mit Environment Mapping texturieren. Das ganze klappt auch soweit, mein Problem ist es nun, dass sich aber die Textur immer mit der Kamera mitdreht. Vlt kann mir hier einer helfen. Wenn man sich das "Bubble"-Bsp von NVidia anschaut, dann dreht sich da nix mit. Das gleiche sollte bei mir eigentlich auch sein.

Code

//Displayfunktion die die szene zeichnet
void display(void){

    //Virtuelle Kamera
    if(EXAMINE)
        examine();
    else
        pilot();

    //Buffer zurücksetzen
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


    //ShadingModel aktivieren, hier SMOOTH-Shading
    glShadeModel(GL_SMOOTH);

    //2D-Texturen aktivieren
    glEnable(GL_TEXTURE_2D);


    //Beleuchtung wieder anschalten damit der Rest beleuchtet wird
    glEnable(GL_LIGHTING);

    //Boden ausgeben
    drawButtom();
    glDisable(GL_BLEND);

    //Den Raum jetzt richtig zeichnen
    drawRoom();

    //Die Objekte jetzt wirklich ausgeben                         
    drawObjects();


    glutSwapBuffers();
}


//CubeMapping initialisieren
void initCubeMapping(void){

    // Cube-Textur-Objekt erzeugen
    glGenTextures(2, CUBE_TEX);

    // Textur für den Boden
    vlgTextureMap2D bottom;

    bottom.readBMPFile("pics/unten.bmp");

    //Cube-Textur einbinden 0
    glBindTexture(GL_TEXTURE_2D, CUBE_TEX[0]);

    // Einstellungen für das aktuell gebundene Textur-Objekt
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);       

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

    //Setzen der Textur im Objekt
    bottom.setTexture();

    //Cube-Textur einbinden 1
    glBindTexture(GL_TEXTURE_CUBE_MAP, CUBE_TEX[1]);


    //6 Instanzen für die Cube Map
    vlgTextureMap2D cubeFaces[6];

    //Pfadangaben für die einzelnen Texturen
    const char* faceNames[6] = {"pics/GebirgeVorne.bmp", "pics/GebirgeHinten.bmp", "pics/GebirgeOben.bmp", "pics/GebirgeUnten.bmp", "pics/GebirgeRechts.bmp", "pics/GebirgeLinks.bmp"};
    //const char* faceNames[6] = {"pics/vorne2.bmp", "pics/hinten2.bmp", "pics/oben2.bmp", "pics/unten2.bmp", "pics/rechts2.bmp", "pics/links2.bmp"};

    // Load Cube Map images
    for(int i = 0; i < 6; i++){

        //BMP-Datei lesen
        cubeFaces[i].readBMPFile(faceNames[i]);


        //Textur setzen
        cubeFaces[i].setTexture(cube[i], GL_RGBA8);
    }

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
}


//Kameraeinstellungen
//Projektionsmatrix setzen
void examine(void){
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glTranslatef(PAN_X, PAN_Y, -RADIUS);
    glRotatef(-ELEVATION, 1.0, 0.0, 0.0);
    glRotatef(AZIMUTH, 0.0, 1.0, 0.0);

    return;
}


//In der Funktion wird das Objekt gezeichnet und die Textur daraufgelegt
void drawObjects(){
    glMatrixMode(GL_MODELVIEW);
    glEnable(GL_TEXTURE_CUBE_MAP_EXT);


        //Wie soll berechnet werden
        glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT,   GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MAG_FILTER, GL_NEAREST);


        //Berechnung der Texture-Koordinaten aktivieren
        glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
        glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
        glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
        //Würfel in der Mitte und Kugeln in den Ecken des Raumes mit EnvironmentMapping
        //Texturen für EnvironmentMapping aktivieren
        //Cube-Mapping aktivieren

        glEnable(GL_TEXTURE_GEN_S);
        glEnable(GL_TEXTURE_GEN_T);
        glEnable(GL_TEXTURE_GEN_R);
        glEnable(GL_NORMALIZE);

        //Cub-Textur einbinden
        glBindTexture(GL_TEXTURE_2D, CUBE_TEX[0]);

        //Farbe auf weiß setzen
        glColor3f(SHADER_RED, SHADER_BLUE, SHADER_GREEN);
    }


    glPushMatrix();

        //Materialien festlegen
        //glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 60);

        //Zum schluss wieder um 2.5 nach oben verschieben
        glTranslatef(X, Y, Z);

        //Auf der X-Achse rotieren
        glRotatef(CUBE_ROTATEX, 1.0f, 0.0f, 0.0f);

        //Auf der Y-Achse rotieren
        glRotatef(CUBE_ROTATEY, 0.0f, 1.0f, 0.0f);

        //Auf der Z-Achse rotieren
        glRotatef(CUBE_ROTATEZ, 0.0f, 0.0f, 1.0f);

        if(FIGURE != 3)
            //Object um 10, 10, 10 strecken
            glScalef(10.0f, 10.0f, 10.0f);


        //Im Ursprung die Objekte zeichnen
        //glutSolidTeapot(1.0);
        if(FIGURE == 0)
            glCallList(hebeObject);
        else
            if(FIGURE == 1)
                glCallList(elephantObject);
            else
                if(FIGURE == 2)
                    glCallList(torusObject);
                else
                    if(FIGURE == 3)
                        glutSolidSphere(3.0f, 512, 1024);

    glPopMatrix();
    //Texturen wieder deaktivieren damit keine weiteren Objekte davon  betroffen sind
        glDisable(GL_TEXTURE_GEN_S);
        glDisable(GL_TEXTURE_GEN_T);
        glDisable(GL_TEXTURE_GEN_R);
        glDisable(GL_TEXTURE_CUBE_MAP_ARB);
}


void mouse(int btn, int state, int x, int y){
    MOUSE_BUTTON_PRESSED = btn;
}


//Mausbewegung
void mouseMotion(int x, int y){
    static int OLD_MOUSE_X = 0, OLD_MOUSE_Y = 0;
    //Distanz zu x-und y-Koordinate
    int distX, distY;
    int bremse = 5;


    distX = x - OLD_MOUSE_X;
    distY = y - OLD_MOUSE_Y;


    switch(MOUSE_BUTTON_PRESSED){
        case GLUT_LEFT_BUTTON:
            if(EXAMINE){
                if (abs(distX)>abs(distY)) {
                    if (distX > 0)
                        AZIMUTH += AZIMUTH_INC;
                    else
                        if (distX < 0)
                            AZIMUTH -= AZIMUTH_INC;
                }
                else 
                    if (distY > 0)
                        ELEVATION -= ELEVATION_INC;
                    else
                        if (distY < 0)
                            ELEVATION += ELEVATION_INC;    
            }
            else{
                if (abs(distX)>abs(distY)) {
                    if (distX > 0)
                        GIERUNG += GIERUNG_INC;
                    else
                        if (distX < 0)
                            GIERUNG -= GIERUNG_INC;
                }
                else 
                    if (distY > 0)
                        NEIGUNG -= NEIGUNG_INC;
                    else
                        if (distY < 0)
                            NEIGUNG += NEIGUNG_INC;
            }
            break;

        case GLUT_MIDDLE_BUTTON: 
            if (EXAMINE) {
                if (abs(distX) > abs(distY)) {
                    if (distX > 0)
                        PAN_X += PAN_INC;
                    else
                        if (distX < 0)
                            PAN_X -= PAN_INC;
                }
                else 
                    if (distY > 0)
                        PAN_Y -= PAN_INC;
                    else
                        if (distY < 0)
                            PAN_Y += PAN_INC;
            }
            else {
                if (distX > 0)
                    ROLL += ROLL_INC;
                else
                    if (distX < 0)
                        ROLL -= ROLL_INC;
            }
            break;

        // Examine: Zoom-Funktion (mit Bremse; sollte auf verschiedene Treiber angepasst werden!)
        // Pilots View: Veränderung in y-Richtung führt zu Fahren; je nach dem, ob nach vorne oder
        //                                                         nach Hinten.
        case GLUT_RIGHT_BUTTON:  //Zoom
            if (EXAMINE) {
                if (distY > 0) 
                    RADIUS += RADIUS_INC;
                else
                    if (distY < 0)
                        RADIUS -= RADIUS_INC;
                break;
            }
            else 
                if (distY > 0)
                    driveBackward();
                else
                    driveForward();
        default: break;
        }




    OLD_MOUSE_X = x;
    OLD_MOUSE_Y = y;


    glutPostRedisplay();
}

Alles anzeigen

Ich hoffe jemand versteht meinen Code und kann mir helfen, vlt weil er das gleiche problem hatte. Bis jetzt hab ich noch keine nützliche Hilfe bekommen. Texturberechnung und alles machen die meisten genauso. Ich denke, da es im RenderMonkey auch nicht geht (Habs auch mit Shadern versucht) aber bei NVidias "Bubble" denk ich mir dass es an den dll's liegt die NVidia für sich neu geschrieben hat.
Aber vlt weiß jemand von euch noch was...
danke schonmal

leadpen

Hi!

Setze mal das "glPushMatrix();" in der drawObjects() VOR die Zeilen

//Cub-Textur einbinden
glBindTexture(GL_TEXTURE_2D, CUBE_TEX[0]);

also 5 Zeilen höher.

undefined

also irgendwie wills nit... egal wie ich mich dreh un wende, ich bekomme immer die gleiche sicht zur cube-map auf dem objekt. am besten merkt man es bei einer kugel. da wirkt es als ob sich die kugel mit der kamera dreht, aber es dreht sich nur die textur.
ich werde noch die dll's von NVidia ausprobieren. vlt liegts doch daran...
danke aber trotzdem

Jetzt mitmachen!