4. Grüner Rand bei transparenten Bildern aufgrund GL_LINEAR

Grüner Rand bei transparenten Bildern aufgrund GL_LINEAR

  • C

    GL_SMOOTH und GL_FLAT beziehen sich auf das Lichtmodell oder nicht ? 😕
    BTW: Das Weichzeichnen ist ja gewollt - Nur pinselt OpenGL den Übergang manchmal dorthin, wo er nicht sein sollte - Zum Beispiel in dem Bereich den man per Alpha-Map durchsichtig machen wollte.
    Ich weiss leider nicht genau, wie dieses Weichzeichnen intern funktioniert. Aber wenn aus den Texturdaten einfach nur eine weichere Textur erzeugt wird, könnte man theoretisch ja die Texturdaten nachträglich nochmal überarbeiten (Alle Pixel auf Durchsichtig, wo Alpha = 0).

    0
  • V

    wenn der Fehler nur am Rand auftritt, dann hat es wahrscheinlich etwas mit dem Rand zu tun 😉

    du musst herausfinden was OpenGL da mit deinen Randpixeln anstellt und OpenGL sagen das es Randpixel anders behandeln soll - such mal nach Clamping oder so...

    0
  • J

    @Vertexwahn
    Der "Rand" ist nicht der Rand der Textur, sondern der Rand zwischen den Pixeln mit Alpha 0 und denen mit mit 255. Von CLamping hab ich noch nichts gehört, und auch nichts im Internet gefunden.

    @Cpp-Junky
    Mip-Mapping ist doch fürs verkleinern von Texturen?

    Alpha 0 bedeutet Dursichtig! Wie willst du Pixel durchsichtig machen, als mit dem Alpha Channel?

    @Pellaeon
    Ne, nicht damit. Aber mit GL_NEAREST. ABer das will ich nicht, sieht ja aus wie auf Playstation 1.

    0

  • Entweder bilineares Filtering aus oder Grün weg. Was anderes geht nicht. Oder soll sich die GraKa 'ne Farbe ausdenken?

    Bye, TGGC (Demo or Die)

    0
  • J

    TGGC schrieb:

    Entweder bilineares Filtering aus oder Grün weg. Was anderes geht nicht. Oder soll sich die GraKa 'ne Farbe ausdenken?

    Bye, TGGC (Demo or Die)

    Alles bilineares Filtering will ich eigentlich anlassen, sieht besser aus. Wie soll ich das Grün wegmachen? Also, wenn ich es wegmache, ist ja auch der dursichtige bereich weg.

    mfg.

    0

  • Wäre ja schlimm, wenn Alphablending nur auf grünen Flächen funktionierte.

    Bye, TGGC (Demo or Die)

    0
  • J

    TGGC schrieb:

    Wäre ja schlimm, wenn Alphablending nur auf grünen Flächen funktionierte.

    Bye, TGGC (Demo or Die)

    Aber welche Farbe sollen die grünnen Bereich dann haben?

    mfg.

    0
  • C

    joomoo schrieb:

    @Vertexwahn
    ...
    @Cpp-Junky
    Alpha 0 bedeutet Dursichtig! Wie willst du Pixel durchsichtig machen, als mit dem Alpha Channel?
    ...

    Meine Idee war nur: Falls der Filter so arbeitet (Was ich nicht weiss), das die Texturdaten einfach nur einmal durch eine Smoothing-Routine laufen (die vermutlich auch deinen Alpha-Kanal manipuliert) könnte man mit einer Kopie der Daten im Originalzustand die Alpha-Werte einfach überschreiben - Somit wärst du sicher, das die Alphamap wieder stimmt. Aber wie gesagt: Hängt davon ab, wie dieser Filter funktioniert und wie man überhaupt an die Texturdaten rankommt.

    0
  • C

    @Cpp_Junky:
    Wenn die Farbe eines Fragmentes (Pixel) bestimmt werden soll, sucht sich die Grafikkarte den zugehörigen Texel und färbt das Fragment damit ein. So zumindest bei GL_NEAREST. Bei GL_LINEAR wird die Farbe des Fragmentes hingegen aus dem gewichteten Mittelwert der umliegenden Texel bestimmt. Darum blutet das zum Colorkeying gedachte Grün aus.

    Mögliche Lösungen, die ich mir vostellen kann:
    - Kein Colorkeying, sondern die Textur gleich mit Transparenzwerten speichern, wie von TGGC vorgeschlagen.
    - Beim Laden der Textur alle grünen Pixel auf Transparent setzen.
    - Möglicherweise würden auch Tricks mit Pixelshader funktionieren, bringt aber unnötigen Performanceverlust mit sich.

    0
  • J

    ChockoCookie schrieb:

    - Beim Laden der Textur alle grünen Pixel auf Transparent setzen.

    Das ist doch genau das was ich mache oder? Alpha CHannel 0 ist ja transparent.

    mfg.

    0
  • C

    Nein, du lässt es von OpenGL machen. Und da geht es aufgrund von GL_LINEAR in die hose.

    Was du machen sollst:

    for each pixel in picture.pixels
  if pixel.value == COLOR_GREEN then
    pixel.value = COLOR_TRANSPARENT
  end if
end for
    0
  • J

    ChockoCookie schrieb:

    Nein, du lässt es von OpenGL machen. Und da geht es aufgrund von GL_LINEAR in die hose.

    Was du machen sollst:

    for each pixel in picture.pixels
  if pixel.value == COLOR_GREEN then
    pixel.value = COLOR_TRANSPARENT
  end if
end for

    Jeder Pixel hat drei Werte, und die Konstante COLOR_TRANSPARENT gibt's nicht.
    Ich glaube wir verstehen uns falsch, deswegen schick ich mal meinen Code hinterher:

    GLuint BildGroesse = TextureImage[loop]->sizeX * TextureImage[loop]->sizeY;
     GLubyte TextureTemp[BildGroesse * 4];
     for(int i=BildGroesse;i>0;i--)
     {
      TextureTemp[4*i-4] = TextureImage[loop]->data[3*i-3]; // R
      TextureTemp[4*i-3] = TextureImage[loop]->data[3*i-2]; // G
      TextureTemp[4*i-2] = TextureImage[loop]->data[3*i-1]; // B
      if(TextureImage[loop]->data[3*i-3] == 0
       &&TextureImage[loop]->data[3*i-2] == 255
       &&TextureImage[loop]->data[3*i-1] == 0)
      {
       TextureTemp[4*i-1] = 0; // A
      }
      else
      {
       TextureTemp[4*i-1] = 255; // A
      }
     }
    0
  • C

    joomoo schrieb:

    Jeder Pixel hat drei Werte, und die Konstante COLOR_TRANSPARENT gibt's nicht.

    😕 schon mal was von pseudocode gehört?

    joomoo schrieb:

    Ich glaube wir verstehen uns falsch, deswegen schick ich mal meinen Code hinterher:

    GLuint BildGroesse = TextureImage[loop]->sizeX * TextureImage[loop]->sizeY;
     GLubyte TextureTemp[BildGroesse * 4];
     for(int i=BildGroesse;i>0;i--)
     {
      TextureTemp[4*i-4] = TextureImage[loop]->data[3*i-3]; // R
      TextureTemp[4*i-3] = TextureImage[loop]->data[3*i-2]; // G
      TextureTemp[4*i-2] = TextureImage[loop]->data[3*i-1]; // B
      if(TextureImage[loop]->data[3*i-3] == 0
       &&TextureImage[loop]->data[3*i-2] == 255
       &&TextureImage[loop]->data[3*i-1] == 0)
      {
       TextureTemp[4*i-1] = 0; // A
      }
      else
      {
       TextureTemp[4*i-1] = 255; // A
      }
     }

    OK, das is eigentlich das, was ich gemeint habe.
    Dann hast du wohl das Bild schon vorher weichgezeichnet. Also entweder Vergrössert, verkleinert, die grüne Farbe mit einer Unscharfmaskierung aufgetragen ... Der Punkt ist, das am Rand der Grünen Fläche keine scharfe Abgrenzung ist, sondern die Randpixel mit der originalen Bildfarbe geblendet sind. Dadurch bleibt ein grüner Rand stehen. Zoom mal mit einer Bildbearbeitung genau ran, ich wette, da ist ein weicher Übergang zwischen Grün und Bild.

    0
  • J

    ChockoCookie schrieb:

    OK, das is eigentlich das, was ich gemeint habe.
    Dann hast du wohl das Bild schon vorher weichgezeichnet. Also entweder Vergrössert, verkleinert, die grüne Farbe mit einer Unscharfmaskierung aufgetragen ... Der Punkt ist, das am Rand der Grünen Fläche keine scharfe Abgrenzung ist, sondern die Randpixel mit der originalen Bildfarbe geblendet sind. Dadurch bleibt ein grüner Rand stehen. Zoom mal mit einer Bildbearbeitung genau ran, ich wette, da ist ein weicher Übergang zwischen Grün und Bild.

    Ja du hast Recht, da ist ein weicher Übergang. Aber ich hab schon Spiele gesehen wo es dann einen weichen Übergang nach durchsichtig gibt. Genau sowas bräuchte ich.

    mfg.

    edit: der weiche übergang ist das was ich sehe, nicht das im bild. Im bild ist ein harter übergang. Ich glaube da hab ich euch falsch verstanden.

    0

  • Dann mach halt 'nen Alphakanal mit weichem Übergang.

    Bye, TGGC (Demo or Die)

    0
  • J

    TGGC schrieb:

    Dann mach halt 'nen Alphakanal mit weichem Übergang.

    Bye, TGGC (Demo or Die)

    Wie meinst du das? Bzw. wie geht das?

    mfg.

    0
  • C

    Du kannst schon einen gewissen Spielraum von Grün auf Transparent umzeichnen, nur besteht dann die Gefahr, dass Teile des restlichen Bildes auch plotzlich Transparent werden.
    Wenn du so scharf drauf bist, kannst du dir ja auch einen Algorithmus ausdenken, der grüne Flächen erkennt und am Rand von diesen den Grünanteil durch einen Transparenzanteil ersetzt. Nein, ich habe keine Tutorials dazu, aber im Prinzip sehe ich da eine Verwandtschaft mit Umwandlung von Rastergrafik in Vektorgrafik, genannt Tracing. Kannst dich ja in diese Richtung schlau machen. Da gibts auch Open Source Projekte zu.
    Oder du machst es dir einfach und speicherst das Bild schon mit Transparenz ab, wie von TGGC vorgeschlagen.

    LG Chocko

    PS:
    Heute mein Abendgebet:
    Lieber Gott, wenn es einen offensichtlichen, einfachen Weg gibt, lass die Leute ihn nehmen weil sie sich bewusst sind, dass es auch so kompliziert genug wird.
    SCNR 😉

    0
  • J

    ChockoCookie schrieb:

    Oder du machst es dir einfach und speicherst das Bild schon mit Transparenz ab, wie von TGGC vorgeschlagen.

    Hä??? Wo ist der Unterschied zu dem was ich mache??? Opengl bekommt einen Array mit den Daten und ich glaube nicht, dass es Opengl interessiert, ob der Alphakanal nachträglich hinzugefügt wurde, oder schon beim laden vorhanden war. WICHTIG: Mit Laden mein ich, die Bitmap informationen in einen array zu laden. Da hat Opengl noch gar nichts zu tun. Erst wenn ich den Alphakanal hinzugefügt habe, kriegt opengl die bilddaten. Also ist es so zusagen das gleiche als wären sie schon von Anfang an im Bild. Deswegen kann ich mir es nicht einfach machen, wie von TGGC vorgeschlagen.

    ChockoCookie schrieb:

    Wenn du so scharf drauf bist, kannst du dir ja auch einen Algorithmus ausdenken, der grüne Flächen erkennt und am Rand von diesen den Grünanteil durch einen Transparenzanteil ersetzt.

    Am Rand von den grünen Flächen, ist kein grün mehr. Also GRÜN -> KEINGRÜN. Es ist ein ganz harter übergang. Und im Array was ich OpenGL gebe, ist kein einziger Pixel grün drinn, der nicht alphakanal 0 hat. Also kann ich auch keinen Grünanteil durch transparens ersetzen, weil überhaupt kein grünanteil da ist.

    mfg.

    0
  • C

    WTF??? Was willst du eigentlich?
    Ich geb's auf.

    0
  • J

    ChockoCookie schrieb:

    WTF??? Was willst du eigentlich?
    Ich geb's auf.

    Ich möchte Bitmaps in OpenGL zeichnen, wo alles was grün ist transparent ist ohne grünen rand. Außerdem möchte ich dabei nicht auf GL_LINEAR verzichten.

    Hier ist mein Code:
    http://joomoo.g2host.de/lesson20-1.zip
    Wenn du die exe ausführst, siehst du mein problem.

    mfg.

    0
Anmelden zum Antworten