Shader Hintergrundfarbe ignorierenn

RedPuma

Hast du die Ergebnisse für die Augen per Fragment-Shader ausgegeben oder per Code?
Wenn du sie per Shader einzeln ausgibst und sie dann korrekt sind muss der Fehler im Shader liegen.

die.krone

Hab sie über den Shader ausgegeben.
Also zB

uniform sampler2D left;
uniform sampler2D right;

void main(void)
{
  vec3 cleft = texture2D(left, gl_TexCoord[1].st).rgb;
  vec3 cright = texture2D(right, gl_TexCoord[2].st).rgb;
  vec3 col;

   col.r = (cleft.r + cleft.g + cleft.b) / 3.0;
    col.g = 0.0;
    col.b = (cright.r + cright.g + cright.b) / 3.0;

  gl_FragColor = vec4(vec3(col.rg,1.0), 1.0);

inter2k3

Die Ergebnisse sind doch völlig klar und nachvollziehbar.

Weisser Hintergrund (bezieht sich auf die Hintergrundfarbe beim erstelleln der beiden Texturen) http://img651.imageshack.us/i/redblue.png/, also linkes Bild:

Du versetzt ja beim erstellen der beiden Texturen ein wenig die Sicht, das heisst natürlich, dass die Position der beiden Objekte innerhalb der beiden Texturen ebenfalls versetzt ist.

Betrachten wir den linken blauen Rand - wie kommt der zustande?
An diesen Stellen hat Textur1 schwarze Farbwerte (nämlich die Farbwerte der "Weltkarte") wohingegen Textur2 weisse Farbwerte hat (Hintergrundfarbe beim erstellen der Textur).

Im Shader addierst du die Komponenten des Farbwertes der Textur1 auf und speicherst das Ergebniss als Rot-Komponente. Die Rot-Komponente ist also 0.
Nun addierst du die Farbwertkomponenten der Textur2 und speicherst das Ergebnis als Blau-Komponente -> 1
Resultierende Farbe also: (0.0,0.0,1.0) -> Blau

Nehmen wir an die Hintergrundfarbe war schwarz:
Rot-Komponente bleibt natürlich 0, da ja hier der Farbwert der Weltkarte benutzt wurde, Blau-Komponente wird ebenfalls 0.
Resultierende Farbe also (0.0,0.0,0.0) -> Schwarz

Wie kommt es nun, dass du meinst dass dort der rote Balken wäre? Schau mal genau hin. Nicht die Stellen sind rot, die im ersten Fall blau waren, sondern es sind die Stellen rot, die im ersten Fall pink waren.
Grund: An diesen Stellen war in Textur1 die Farbe weiss anstelle von schwarz. Im ersten Fall wurde also die resultierende Rot-Komponente auf 1.0 (weil Farbwert der Weltkarte hier weiss war) gesetzt und die Blau-Komponente ebenfalls auf 1.0 (weil Hintergrundfarbe weiss war) -> (1.0,0.0,1.0)
Im zweiten Fall wird hier die resultiernde Rot-Komponente wieder 1.0 sein (s.o.) und die Blau-Komponente 0 (weil ja die Hintergrundfarbe schwarz ist) -> (1.0,0.0,0.0)

Was du eigentlich möchtest ist doch, dass die Hintergrundfarbe beim erstellen der Texturen übehraupt keine Rolle spielt. Also setzt du den Alpha-Wert der Hintergrundfarbe auf 0.
Im shader überprüfst du nun, ob der Alphawert 0 ist oder nicht und nur im letzten Fall addierst du die Farbkomponenten auf und setzt den entsprechenden Kanal.

die.krone

Du meinst also, wenn der Alpha-Wert 0 wäre, müsste das dann so im Shader aussehen:

uniform sampler2D left;
uniform sampler2D right;

void main(void)
{
  vec3 cleft = texture2D(left, gl_TexCoord[1].st).rgb;
  vec3 cright = texture2D(right, gl_TexCoord[2].st).rgb;
  vec3 col;

   col.r = cleft.r;
    col.g = 0.0;
    col.b = cright.b;

  gl_FragColor = vec4(col, 1.0);

Hab ich das so richtig verstanden?
Danke für die Hilfe!

inter2k3

Nicht ganz.
Hm - wie erklär ich das nun.

Momentan gehst du ja folgendermassen vor:
- du erstellst beide Texturen (offscreen rendering), wobei der Blickwinkel leicht versetzt ist (für linkes Auge + rechtes Auge).
- dann erstellst du ein fullscreen-quad und möchtest nun die Farbwerte der beiden Texturen vereinen und damit dann das quad texturieren.

Dabei ist eigentlich die Hintergrundfarbe, die beim erstellen der beiden Texturen verwendet wurde, uninteressant und nicht erwünscht. Momentan berücksichtigst du sie aber noch - daher wird das Resultat auch so pink bei dir, was vermutlich so nicht sein sollte.

Was du nun machen könntest ist folgendes:
Während du die texturen erstellst setzt du die Hintergrundfarbe auf einen beliebegen Farbwert, aber der Alpha-Wert sollte 0 sein (bsp: glClearColor(1.0f,1.0f,1.0f,0.0f))
Alle anderen Farbinformationen sollten allerdings dann einen Alphawert ungleich 0 haben.

Deinem shader, der nun die Farbwerte kombiniert würde in etwa folgendermassen aussehen:

uniform sampler2D left;
uniform sampler2D right;

void main(void)
{
  vec4 cleft = texture2D(left, gl_TexCoord[0].st);
  vec4 cright = texture2D(right, gl_TexCoord[0].st);
  vec3 col(0.0);

  // falls sowohl in Textur1 als auch in Textur2 der Hintergrund sichtbar ist:
  if (cleft.a == 0.0 && cright.a == 0.0) {
      // entweder discard; oder konstante Farbe setzten
  }

  else {
    // falls texel in Textur1 einen Alphawert ungleich 0 hat -> blau-Kanal setzen
    if (cleft.a != 0) {
        col.b = (cleft.r + cleft.g + cleft.b) / 3.0;
    }

   // falls texel in Textur2 einen Alphawert ungleich 0 hat -> rot-Kanal setzen
    if (cright.a != 0){
        col.r = (cright.r + cright.g + cright.b) / 3.0;
    }

  }
  gl_FragColor = vec4(col, 1.0);
}

die.krone

Okay. Aber was genau meinst du mit discard und wie mache ich das?
Dass würde doch dann heißen, dass wenn der Alphawert beider Texturen 0 ist, der Hintergrund nicht miteinbezogen wird oder?

inter2k3

discard verwirft das aktuelle Fragment - sprich, sobald der Fragment-Shader auf discard trifft, wird die Ausführung des shaders beendet und das Fragment verworfen (also es werden keine neuen Werte in den framebuffer / oder sonstige target-buffer geschrieben).

Richtig, wenn beide texel einen alpha-Wert von 0 haben würde dann im framebuffer weiterhin der von dir durch glClearColor festgelegte Wert stehen (also die Hintergrundfarben der Texturen würden nicht berücksichtigt). Auch in den depthbuffer wird kein Wert eingetragen.

Das Schlüsselwort discard verwirft den pixel. Das meint er damit :).

die.krone

Kann mir jemand sagen, wieso ich keine RGBA textur verwenden kann.
Wenn ich folgendes schreibe,kriege ich immer ein "Segmentation fault".

glTexImage2D(GL_TEXTURE_2D, 0, 4, SIZE, SIZE, 0, GL_RGBA,
            GL_UNSIGNED_BYTE, textureL);

Verwende ich nur GL_RGB klappt es wunderbar.

Naja, ist es auch ein RGBA Bild bzw ist der Puffer den du übergibst ausreichend groß?

die.krone

Mh...ich habe es jetzt mal mit LUMINANCE_ALPHA als Test versucht, aber ich glaube irgendwas läuft schief. Ich kriege genau das gleiche Ergebnis wie vorher auch. Hintergrund ist pink und wenn ich die Hintergrundfarbe ändere, nimmt sie Einfluss auf den Rest.

Ich hab mal gelernt, dass man floats nicht miteinander vergleichen soll.
Liegt dort vielleicht das Problem?

Für Zb das linke Auge sieht das Rendering so aus:

glActiveTexture(GL_TEXTURE0);

        /* Define a view-port adapted to the texture */
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        //frustum for left eye
        glFrustum(L_l, L_r, L_b, L_t, Near, Far);

        glViewport(0, 0, SIZE, SIZE);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(-IOD / 2, 0.0, 5.0, /* eye is at (0,0,5) */
                0.0, 0.0, 0.0, /* center is at (0,0,0) */
                0.0, 1.0, 0.); /* up is in positive Y direction */

        /* Render to buffer */
        glClearColor(background_color, background_color, background_color, [b]0.0[/b]);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glScalef(zoom, zoom, zoom);
        glEnable(GL_BLEND);
        glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
        drawCubes();
        glDisable(GL_BLEND);
        drawBackground();
        glFlush();

        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, leftTexture);
        /* Copy buffer to texture */
        glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, SIZE, SIZE);

Oder muss ich für das Alpha irgendwo noch etwas aktivieren oder ähnliches?
Also "glutInitDisplayMode(GLUT_RGBA)" habe ich.

Naja, wenn es bei glTexImage2D kracht, dann ist der Puffer nicht groß genug. Ist das ne Textur die aus ner Datei geladen wurde oder ne FBO-Textur?
Der Puffer muss bei einer geladenen Datei size_x*size_y*anzahl_farben groß sein.
Bei nem FBO übergibt man NULL.

die.krone

Ok danke für den Tipp. Daran lag es natürlich.

Aber der weiße Hintergrund wird trotzdem pink beim rendern. Was könnte ich denn noch falsch machen?

inter2k3

die.krone schrieb:

glTexImage2D(GL_TEXTURE_2D, 0, 4, SIZE, SIZE, 0, GL_RGBA,
            GL_UNSIGNED_BYTE, textureL);

Was stellt die 4 als drittes Argument dar? Dort sollte GL_RGBA stehen.

Und wie sehen drawCubes() und drawBackground() aus?

die.krone

Das stellt doch GL_RGBA dar. Man kann dort entweder GL_RGBA eintragen oder eben 4, siehe: http://www.opengl.org/sdk/docs/man/xhtml/glTexImage2D.xml

Meine initialisierung:

void init() {

    //Calculations for Left eye/camera frustum
    L_l = -(Near * ((w / 2 - IOD / 2) / z)); // Left clipping pane
    L_r = (Near * ((w / 2.0 + IOD / 2.0) / z)); // Right clipping pane
    L_b = -(Near * ((h / 2.0) / z)); // Bottom clipping pane
    L_t = (Near * ((h / 2.0) / z)); // Top clipping pane

    //Calculations for Right eye/camera frustum
    R_l = -(Near * ((w / 2.0 + IOD / 2.0) / z)); // Left clipping pane
    R_r = (Near * ((w / 2.0 - IOD / 2.0) / z)); // Right clipping pane
    R_b = -(Near * ((h / 2.0) / z)); // Bottom clipping pane
    R_t = (Near * ((h / 2.0) / z)); // Top clipping pane

    /**
     * TEXTURES
     */
    glEnable(GL_TEXTURE_2D);

    /* --- Texture Setup --- */
    glGenTextures(2, textures); // Platz f. NUM_TEXTURES Texturobjekte anfordern...
    for (int i = 0; i < 2; i++) {
        /* Aktuelles Texturobjekt selektieren */
        glBindTexture(GL_TEXTURE_2D, textures[i]);
        /* Image laden.. */
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // scale linearly when image bigger than texture
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // scale linearly when image smalled than texture

        teximage = (GLuint *) read_texture(tex[i].filename, &tex[i].width, &tex[i].height, &texcomps);
        /* ...und Pixeldaten an das Texturobjekt uebergeben. */
        gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, tex[0].width, tex[0].height, GL_RGBA, GL_UNSIGNED_BYTE, teximage);

    }
    /* Per Default berechnete Pixelfarbe durch Texelfarbe ersetzen */
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

    /** Init textures to render into*/
    glGenTextures(1, &leftTexture);
    glBindTexture(GL_TEXTURE_2D, leftTexture);
    glTexImage2D(GL_TEXTURE_2D, 0, 4, SIZE, SIZE, 0, GL_RGBA,
            GL_UNSIGNED_BYTE, textureL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

    glGenTextures(1, &rightTexture);
    glBindTexture(GL_TEXTURE_2D, rightTexture);
    glTexImage2D(GL_TEXTURE_2D, 0, 4, SIZE, SIZE, 0, GL_RGBA,
            GL_UNSIGNED_BYTE, textureR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, leftTexture);

    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, rightTexture);

    setShaders();

    texLeftSampler = glGetUniformLocation(program, "left");
    glUniform1i(texLeftSampler, 1); // 0 für Texture-Unit 0
    cout << "ERR texleft: " << glGetError() << endl;

    texRightSampler = glGetUniformLocation(program, "right");
    glUniform1i(texRightSampler, 2); // 1 für Texture-Unit 1
    cout << "ERR texright: " << glGetError() << endl;

    glUseProgram(0);

    glDisable(GL_BLEND);
}

Die Methode, welche das hintere Quad zeichnet:

void drawBackground() {

    //Draw Background
    glPushMatrix();
        glBindTexture(GL_TEXTURE_2D, textures[0]);
        glTranslatef(0.0, 0.0, -5.0);
        //glRotatef(rotation_y, 0.0, 1.0, 0.0);

        glScalef(7.0, 7.0, 1.0);
        glBegin(GL_QUADS); // begin drawing a cube
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad
            glTexCoord2f(0.0f, 1.0f);
            glVertex3f(1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(1.0f, 1.0f, 1.0f); // Top Right Of The Texture and Quad
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(-1.0f, 1.0f, 1.0f); // Top Left Of The Texture and Quad
            glEnd();
    glPopMatrix();
}

Methoden für das Zeichnen der Würfel:

void drawCube() {
    glPushMatrix();
        glRotatef(rotation_y, 0.0, 1.0, 0.0);
        glBindTexture(GL_TEXTURE_2D, textures[1]);
        glBegin(GL_QUADS); // begin drawing a cube

            // Front Face (note that the texture's corners have to match the quad's corners)
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(1.0f, 1.0f, 1.0f); // Top Right Of The Texture and Quad
            glTexCoord2f(0.0f, 1.0f);
            glVertex3f(-1.0f, 1.0f, 1.0f); // Top Left Of The Texture and Quad

            // Back Face
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(-1.0f, -1.0f, -1.0f); // Bottom Right Of The Texture and Quad
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(-1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad
            glTexCoord2f(0.0f, 1.0f);
            glVertex3f(1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(1.0f, -1.0f, -1.0f); // Bottom Left Of The Texture and Quad

            // Top Face
            glTexCoord2f(0.0f, 1.0f);
            glVertex3f(-1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(-1.0f, 1.0f, 1.0f); // Bottom Left Of The Texture and Quad
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(1.0f, 1.0f, 1.0f); // Bottom Right Of The Texture and Quad
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad

            // Bottom Face
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(-1.0f, -1.0f, -1.0f); // Top Right Of The Texture and Quad
            glTexCoord2f(0.0f, 1.0f);
            glVertex3f(1.0f, -1.0f, -1.0f); // Top Left Of The Texture and Quad
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad

            // Right face
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(1.0f, -1.0f, -1.0f); // Bottom Right Of The Texture and Quad
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad
            glTexCoord2f(0.0f, 1.0f);
            glVertex3f(1.0f, 1.0f, 1.0f); // Top Left Of The Texture and Quad
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad

            // Left Face
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(-1.0f, -1.0f, -1.0f); // Bottom Left Of The Texture and Quad
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(-1.0f, 1.0f, 1.0f); // Top Right Of The Texture and Quad
            glTexCoord2f(0.0f, 1.0f);
            glVertex3f(-1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad

        glEnd(); // done with the polygon.

    glPopMatrix();
}

void drawCubes() {
    glPushMatrix();
        glTranslatef(-1.5, -1.0, -2.0);
        drawCube();
        glTranslatef(3.0, 3.0, 0.0);
        drawCube();
    glPopMatrix();
}

Und zuletzt nochmal das Rendern in die Textur bzw. die Display-Methode:

void renderToTexture(int eye) {
    if (eye == 0) { //LEFT EYE
        glActiveTexture(GL_TEXTURE0);

        /* Define a view-port adapted to the texture */
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        //frustum for left eye
        glFrustum(L_l, L_r, L_b, L_t, Near, Far);

        glViewport(0, 0, SIZE, SIZE);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(-IOD / 2, 0.0, 5.0, /* eye is at (0,0,5) */
                0.0, 0.0, 0.0, /* center is at (0,0,0) */
                0.0, 1.0, 0.); /* up is in positive Y direction */

        /* Render to buffer */
        glClearColor(background_color, background_color, background_color, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glScalef(zoom, zoom, zoom);
        drawCubes();
        drawBackground();
        glFlush();

        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, leftTexture);
        /* Copy buffer to texture */
        glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, SIZE, SIZE);
    } else if (eye == 1) { //RIGHT EYE
        glActiveTexture(GL_TEXTURE0);

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        //frustum for right eye
        glFrustum(R_l, R_r, R_b, R_t, Near, Far);

        glViewport(0, 0, SIZE, SIZE);
                glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(IOD / 2, 0.0, 5.0, /* eye is at (0,0,5) */
                0.0, 0.0, 0.0, /* center is at (0,0,0) */
                0.0, 1.0, 0.); /* up is in positive Y direction */

        /* Render to buffer */
        glClearColor(background_color, background_color, background_color, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glScalef(zoom, zoom, zoom);
        drawCubes();
        drawBackground();
        glFlush();

        glActiveTexture(GL_TEXTURE2);
        glBindTexture(GL_TEXTURE_2D, rightTexture);
        /* Copy buffer to texture */
        glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, SIZE, SIZE);
    }
   // glActiveTexture(GL_TEXTURE0);

}

void display() {

    /** render into two textures */
    renderToTexture(0);
    renderToTexture(1);

    glViewport(0,0,SIZE,SIZE);
    glClearColor(0.0, 0.0, 0.0, 1.0);

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();

    glDisable(GL_DEPTH_TEST);

    /** draw rendered textures */
    glUseProgram(program);

    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, leftTexture);

    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, rightTexture);

    glBegin(GL_QUADS);
        glMultiTexCoord2f(GL_TEXTURE2, 0.0f, 1.0f);
        glMultiTexCoord2f(GL_TEXTURE1, 0.0f, 1.0f);
        glVertex3i(-1, -1, -1);
        glMultiTexCoord2f(GL_TEXTURE2, 1.0f, 1.0f);
        glMultiTexCoord2f(GL_TEXTURE1, 1.0f, 1.0f);
        glVertex3i(1, -1, -1);
        glMultiTexCoord2f(GL_TEXTURE2, 1.0f, 0.0f);
        glMultiTexCoord2f(GL_TEXTURE1, 1.0f, 0.0f);
        glVertex3i(1, 1, -1);
        glMultiTexCoord2f(GL_TEXTURE2, 0.0f, 0.0f);
        glMultiTexCoord2f(GL_TEXTURE1, 0.0f, 0.0f);
        glVertex3i(-1, 1, -1);
    glEnd();
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();

    glUseProgram(0);
    glEnable(GL_DEPTH_TEST);

    glFlush();
    glutSwapBuffers();
    glutPostRedisplay();
}

Viel mehr gibt es auch in meinem Programm nicht..

inter2k3

Versuch trotzdem als erstes mal anstelle von 4 GL_RGBA anzugeben bei glTexImage2D.
Danach schauen wir mal weiter

die.krone

Okay gemacht. Wie schon gedacht. Gleicher Effekt. Hat nichts verändert.

Du verwendest ja auch den immidiate-mode, da werden doch die shader garnicht berücksichtigt.
Im Pinrzip kannst du die shader komplett weglassen - und solltest immernoch dsa gleiche Ergebniss erhalten.

die.krone

Nee also wenn ich den Shader komplett weglasse, dann bekomme ich eine einheitliche Farbe übers ganze Bild.

was muss ich denn anders machen?

ogl schrieb:

Du verwendest ja auch den immidiate-mode, da werden doch die shader garnicht berücksichtigt.
Im Pinrzip kannst du die shader komplett weglassen - und solltest immernoch dsa gleiche Ergebniss erhalten.

Das stimmt so nicht afaik. Er wird schon berücksichtig. Habe das auch schon selbst gemacht. Aber es ist ein böser Mix.

@krone
Denke mal drüber nach komplett nach OpenGL 3.x zu migrieren und die fixed Pipeline hinter dir zu lassen. Da gehören Shader dann auch zum Core.
Ob das jetzt dein Problem behebt mag ich allerdings nicht zu sagen.