4. etwas anderes einfaerben einer textur

etwas anderes einfaerben einer textur

  • T

    hallo,

    ich moechte folgendes machen und suche eine idee fuer die umsetzung mit opengl.

    ich habe ein quad welches mit einer relativ hellen textur belegt ist. ausserdem habe ich ein array mit farbwerten von der gleichen groesse wie das quad. nun moechte ich die farbe der textur so modulieren, dass sie die farben aus dem array annimmt. ich moechte also nicht nur die 4 farben an den vertices veraendern, sondern die ganze flaeche mit unterschiedlichen farben einfaerben. ich hoffe ich konnte das halbwegs verstaendlich erklaeren.

    dieses einfaerben wird zeimlich oft gemacht und darf daher nicht zu aufwendig sein. ich hatte schon ueberlegt das quad in viele kleine quads aufzuteilen und deren ecken dann einzufaerben. das scheint mir aber recht dumm zu sein. vielleicht gibt es da ja eine clevere loesung.

    0
  • X

    Das Array ist genauso groß wie das Quad? Also 1x1 ?
    Was meinst du damit?
    Oder in Grafikkarteneinheiten?

    0
  • T

    ok, damit habe ich gerechnet. tut mir leid, dass war sehr ungenau.

    stell dir vor man guckt senkrecht auf das quad und es ist so gross, dass es den ganzen sichtbaren bereich ausfuellt. die resultierende hoehe und breite nach dem rendern entspricht also der bildschirm/ fenster aufloesung.
    mein array ist immer genausogross.

    beispiel:
    das fenster ist 512x512 pixel gross. dann ist auch mein array 512x512.

    ich muss die farbwerte nicht exakt auf der textur repraesentiert haben, aber annaehernd waere schon gut.

    0
  • E

    Ich weiß jan icht, ändern sich die Werte in der Matrix öffters oder bleiben die konstant (solange sich die Größe nicht äandert)? Fall sie konstant sind, würde ich vll versuchen, die Farben schon beim Erstellen der Textur mit selbiger zu verknüpfen.
    Anderenfalls fällt mir auch nichts ein, außer das alles in kleine Teilchen zu zerstückeln.

    0
  • T

    die groesse bleibt konstant. die farb-eintraege aendern sich staendig.

    lauter kleine quads generieren ist leider keine loesung fuer mich. die anwendung laeuft auf einem 2800x2100 display. da muesste ich schon sehr viele kleine quads machen, damit man die uebergaenge zwischen den farbverlaeufen nicht sieht.

    0
  • X

    Man könnte doch immer wieder eine Textur generieren aus den Farbwerten und diese dann mit der anderen blenden?

    Oder muss es pixelgenau sein? Dann wär das wahrscheinlich nicht so performancefreundlich.

    0
  • T

    nein, es muss nicht sehr genau sein. die performance ist wichtiger.

    das ist schonmal eine gute idee. leider weiss ich nicht, wie man aus einem array eine textur macht. fuer das blending zweier texturen brauche ich sicherlich die ARB_multitexture extension. auch damit habe ich noch keine erfahrungen.

    muss ich mich mal einlesen...
    fuer andere vorschlaege und hinweise bin ich weiterhin dankbar.

    0
  • X

    Nein, du brauchst nicht unbedingt Multitexturing. Du kannst auch einfach das Quad zweimal zeichnen. Einmal mit der Textur und dann Blending aktivieren und nochmal mit der generierten Textur.

    Und hiermit generierst du eine Textur aus deinen Pixeldaten: glTexImage2D
    http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html

    0
  • T

    so, das hab ich jetzt mal probiert. nun bin ich mir aber unsicher, was fuer ein array glTexImage2D von mir erwartet. in der referenz steht ja folgendes.

    data is read from pixels as a
    sequence of signed or unsigned bytes, shorts, or longs, or
    single-precision floating-point values, depending on type.
    These values are grouped into sets of one, two, three, or
    four values, depending on format, to form elements.

    und ich habe folgendes probiert: zuerst lege ich mir ein 1D array an.

    // hoehe * breite * anzahl der farbwerte
unsigned char colorBufferValues[2048 * 2048 * 3];

// nur mal zum testen ueberall weiss reingeschrieben.
for (unsigned int x = 0; x < 2048; ++x) {
    for (unsigned int y = 0; y < 2048; ++y) {
	colorBufferValues[x * y + 0] = 255;
	colorBufferValues[x * y + 1] = 255;
	colorBufferValues[x * y + 2] = 255;
    }
}

GLenum colorTexture = 0;
glTexImage2D(colorTexture,		// GLenum target
	 0,				// GLint level
	 GL_RGB,			// GLint internalformat
         1024,				// GLsizei width
	 1024,				// GLsizei height
	 0,				// GLint border
	 GL_RGB,			// GLenum format
	 GL_UNSIGNED_BYTE,	// GLenum type
	 colorBufferValues);// const GLvoid *pixels

    leider funtionierts nicht. das verursacht dann stack probleme oder so.

    0
  • H
     

    unsigned char colorBufferValues[2048 * 2048 * 3];

    das verursacht dann stack probleme oder so

    fuer 12 megabyte kann man ruhig mal den heap bemuehen 😉
    wenn sich die farben dieser textur irgendwie berechnen lassen, sollte man das besser in einem pixelshader erledigen anstatt die daten jedes mal zu uebertragen.

    0
  • T

    man koennte sicherlich die farbe aus dem array und die farbe der textur multiplizieren.

    mit pixelshadern habe ich leider auch noch nichts gemacht. koennte man da die GL shader language nehmen? probieren wuerde ich es ja gerne mal.

    0
Anmelden zum Antworten