OpenGL Color Picking Back-Buffer manuell leeren

Hallo Harry...

Ich bin ebenfalls gerade dabei Color Picking zu Integrieren und bin hier auf ein Problem gestoßen bei dem ich nicht weiter weis.

In meinem Fall ist es so das der ByteBuffer in dem das Pixel gespeichert wird nur dann die richtigen Werte enthält wenn die Farbanteile
in dem Pixel 1.0f oder 0.0f sind.

bei Farben wie glColor(0.5f,0.5f,0.5f,1);
Erhalte ich nicht nur falsche Werte sondern auch noch unterschiedliche Ergebnisse wenn ich den selben Pixel auswerte.

Ich vermute das es daran liegt wie ich den ByteBuffer behandle da es mir dort reichlich an Erfahrung fehlt.
Könntest du mir an dieser Stelle eventuell einen Tipp geben wie nach dem gl.ReadPixel()
der ByteBuffer ausgewertet wird.

Hier meine Version...
[code]

buffer = ByteBuffer.allocateDirect(4);

gl.glReadPixels(this.touchPoint.x, this.touchPoint.y, 1, 1, GL10.GL_RGBA,GL10.GL_UNSIGNED_BYTE,buffer);
buffer.rewind();

for(int b = 0; b < 4; b+=1){
this.pickcolor[b] = (byte)buffer.get(b)& 0xff;
if (pickcolor[b]<0)
pickcolor[b]+=256;
}

[/code]

Beste Grüße
Marcel

Hey Harry,

Danke für die schnelle Antwort. und die hilfsbereitschaft

Also bisher habe ich glColor4f verwendet, das gestern war etwas hastig dahin geschrieben .

Ich habe dann gestern auch noch herausgefunden das die unterschiedlichen Ergebnisse wie du schon sagst auf einen Rundungsfehler
zurück zu führen waren. Daraufhin habe ich versucht die Funktion glColor4x zu verwenden allerdings setzt es die Farbe dann
immer auf null und was gezeichnet wird ist Schwarz. Ich bekomme also einfach keine Farbe gesetzt.

Ich habe dann alternative versucht die Farbe als Integer zu übergeben und in float um zu rechnen.

z.B.:
glColor4f(128f/256f, 128f/256f, 128f/256f, 256f/256f)

Das ganze war soweit erfolgreich das ich zwar keine unterschiedlichen Werte mehr zurück bekomme
allerdings ist das Ergebnis immer noch falsch. Bei dem Beispiel oben enthällt der ByteBuffer z.B folgende Werte.

-124, -126, -124, -1
mit 256 addiert also
132 130 132 255
An der Tatsächlichen Farbe also knapp vorbei gerauscht und lediglich der Alphawert ist korrekt.

Hast du eine Idee wieso glColor4x bei mir die Farbe immer auf Schwarz setzt?

das teilen durch 255 bringt leider auch nix.

Ja mir ist klar das bei 255 Schluss ist

Ich hab jetzt fest gestellt das glColor4x bei mir einen anderen Wertebereich zu haben scheint...
alles bis 255 war schwarz weil es zu wenig war.

Gebe ich stattdessen z.b glColor4x(65535,0,0,65535)
bekomme ich ein sattes rot.

Jetzt habe ich aber das selbe Problem wie vorher. Ich kann das nicht ohne Rundungsfehler zurückrechnen.

Ich Blicks nicht mehr... ...
Ich danke dir wirklich sehr für dein Interesse mir zu helfen

Ich möchte das nicht unbedingt derartig beschneiden da ich das ganze gern auch in Projekten wiederverwenden möchte wo die Anzahl an Objekten durchaus mal größer werden könnte oder einfach noch nicht definiert ist. Ich will mir das ungern in ein paar Wochen erneut zu Gemüte führen müssen

Hast du denn eine Ahnung woran es liegen könnte das ich glColor4x keinen wert zwischen 0 und 255 zuweisen kann.

Hier mal kurz ein kleiner Code Ausschnitt Ich würfle das Wesentliche einfach mal zusammen. Vielleicht ist der Hund ja wo ganz anders begraben .

[code]
ByteBuffer buffer = ByteBuffer.allocate(4);
int pickcolor[] = new int[4];

gl.glReadPixels(this.touchPoint.x, this.touchPoint.y, 1, 1, GL10.GL_RGBA,GL10.GL_UNSIGNED_BYTE,buffer);

for(int b = 0; b < 4; b+=1){
this.pickcolor[b] = buffer.get(b) & 0xFF;
if(pickcolor[b]<0){
pickcolor[b] += 256;
}
}
[/code]

Also nach meinem Verständnis sollte das ja soweit passen. Ich habe das so verwendet als ich noch mit glcolorf die Farbe gesetzt habe.
Ich denke das Hauptproblem ist jetzt halt das das ich glcolorx nicht so wirklich verwenden kann.

Hmm mit den Maskierungen hab ichs auch nicht so aber ich werde das einfach mal testen.

Eine Frage hab ich dazu noch.. was genau steckt in color...
Ist das jetzt ein Farbanteil im Wertebereich von 0-255 oder von 0-65535 oder ist color wieder was anderes .

Ja das stimmt...

Vielen Dank nochmal... Ich werd es einfach mal ausprobieren.
Schönen Abend wünsch ich dir noch.

Eine Sache noch

Ich verwende GL10 eventuell ist das auch das Problem
nun habe ich eine Möglichkeit gefunden die Farbe direkt mit einem byte zu setzen und zwar sieht das ganze dann so aus.

public void irgendeinefunktion(GL10 gl){

GL11 gl11 = (GL11)gl;

glx.glColor4ub((byte)255, (byte)0, (byte)255, (byte)255);
}

Das Funktioniert auf meinem Samsung wirklich prima
und liefert beim picking logischerweise genau das was ich erwarte..
Jetzt bin ich mir aber nicht sicher ob dieses vorgehen zulässig ist...
kannst du darüber was sagen?

Naja ich hab mich ohnehin zu früh gefreut.

Ob ich nun,

glColor4f(r,g,b,a);
glColor4x(r,g,b,a);
oder
glColor4ub(r,g,b,a);https://www.nextpit.de/de/android/forum/post/form?postId=957920&action=respond#

verwende ist völlig egal, Ich erhalte immer die selben verwirrenden Ergebnisse.
bei einem Farbanteil von 100 für r,g und b bzw. dem äquivalent für die jeweilige Funktion... erhalte ich zum Beispiel Grundsätzlich

r == 99 g == 101 b == 99 a == 255

wenn ich statt 100 einen farbanteil von 200 verwende sieht das ganze so aus...

r == 206 g == 203 b ==206 a == 255

Also ich beiße mir jetzt seit gut 5 Tagen die Zähne daran aus und bin nun wirklich mit meinem Latein am Ende.

Danke ich werde mir das gleich nochmal etwas genauer ansehen...
Kann es auch sein das ich das Picking zur falschen Zeit durchführe???
Momentan läuft das alles in der onDrawFrame Methode ab.

Kurz umrissen läuft das bei mir so...
Ich habe eine Liste von Objekten die in einem anderen Thread Simuliert werden also meinetwegen ständig Ihre Position verändern usw..
Jedes Objekt hat eine eigene Draw(GL10 gl) die das Objekt komplett zeichnet, und eine eigene DrawUniqe_Colore(GL10 gl) Methode die nur die Farbe Zeichnet die gepickt werden könnte. Ob das Objekt anklick bar ist welche einzigartige Farbe es hat, Texturen , Meshs Position usw wird bereits bei der Initialisierung festgelegt.

In der OnDrawFrame Methode passiert nun folgendes


Wie gesagt alle Effekte sind deaktiviert und alles Funktioniert. Nur die Farbe die ich von glReadPixels zurück bekomme stimmt nicht

Hantierst du mit so vielen Objekten, dass ein normales Ray-Picking zu aufwendig wäre ..?

Naja ich plane eine App wo schon so einiges zusammen kommen kann.
Im Prinzip geht´s ja kaum einfacher als mit colorpicking und für mich wäre diese variante wohl die beste.

Wenn da nicht diese Seltsamen Werte währen.

Ich hab mich hier mal an einen anderen thread dran gehangen aber leider hat das auch nicht zur Lösung des Problems gefüht kannst ja mal reinschauen.
https://www.nextpit.de/de/android/forum/thread/421019/OpenGL-Color-Picking-Back-Buffer-manuell-leeren

Mittlerweile hab ich auch alles mögliche Probiert die Farben als float, integer und byte gesetzt, gestern die nullen und einsen im binärcode gezählt usw.
Keine Lösung in Sicht.
Rundungsfehler sind nun auch ausgeschlossen. Das lag am Vorzeichen und wurde behoben. Mittlerweile bekomme ich also keine unterschiedlichen Ergebnisse mehr sondern immer die gleichen falschen Zahlen. Die Abweichung beträgt immer nur ein wenig vom tatsächlichen Wert ist aber bei unterschiedlichen werten auch immer unterschiedlich groß in der Abweichung. Einziges Gemeinsames Merkmal bei der Abweichung ist folgendes.

Wenn ich einen ByteBuffer mit 4 Bytes habe von denen jedes Byte den gleichen wert haben sollte weil z.B. ein Pixel mit eine Farbe mit jeweils 100 für RGBA gesetzt wurde. Dann enthält mein byteBuffer die Werte 99 101 99 101.
Wie gesagt bei anderen Werten ist die Abweichung auch mal größer als 1.
Also fällt hier auf das das erste und dritte Byte sowie das zweite und vierte Byte den gleichen Wert haben.
(Lass dich von dem Alpha Wert nicht stören... der is nur zur Verdeutlichung was im bytebuffer los ist .ich zeichne die Farben natürlich ohne Transparenz.)

Das Problem ist das der Bytebuffer mit diesen Werten zurück kommt und ich nicht weis wo ich noch suchen soll. Zwischen dem Zeichnen und dem auslesen passiert sonst nichts.

Reihenfolge:
Farbe Zeichnen.
Pixel mit glReadpixels(...) aus dem Framebuffer holen und in den ByteBuffer schreiben
und hier sind dann auch schon die seltsamen werte im buffer gelandet.

Es gibt keine Seite mehr zum Thema deren Link bei mir nicht schon lila hinterlegt ist weil ich sie gelesen habe
Eigentlich gibts nur noch zwei Möglichkeiten.
1. Die Farbe liegt schon Falsch im Framebuffer (Das Schließe ich allerdings aus)
2. Ich Mach irgendwas mit dem ByteBuffer Falsch.

Ja Genau so mache ich das.


-Der Render-Mode ist RENDERMODE_CONTINUOUSLY
-Ich dividiere die 100 durch 255f und setzte die Farbe

-Effekte werden deaktiviert

-das objekt wird gezeichnet
-jetzt initialisiere ich den Bytebuffer und picke das Pixel

-nun wird in einer Liste mit Objekten das objekt mit der passenden Farbe gesucht allerdings ist das Ergebniss hier schon Falsch.

die 100 führt dazu das ich 99 zurück bekomme
wenn ich das Selbe statt mit dem Rot anteil mit Grün versuche,
ist das Ergebnis 101,
bei Blau ist das Ergebnis wieder 99.

Wenn statt 100 , z.B. 200 gesetzt wird bekomme ich für

Rot 206
Grün 203 und
Blau 206

Und dann geht´s weiter mit dem Rendern der Szene die gesehen werden soll.
ob ich davor den Framebuffer mit

leere oder nicht ändert am Ergebniss auch nichts.

Ich habs auch auf einem anderen Gerät getestet... genau das gleiche Schauspiel.
Stellst du mit dem Bytebuffer noch irgendetwas an auser...

Oder setzt du noch irgendwelche Flags die fürs Picking wichtig sind...

Das Alles Läuft bei mir der Reihe nach in der onDrawFrame Methode kann es daran eventuell liegen?

EDIT:
Wegen der Picking Koordinaten....
die stimmen... Is aber auch das selbe wenn ich den ganzen Bildschirm mit der Farbe Zeichne.
Und da kann ich nicht vorbei klicken ;)

— geändert am 28.02.2012, 16:12:34

Also am Blending liegt es auch nicht...
Wirklich ne harte Nuss das ganze.
Ich hab jetzt mal folgendes Gemacht.

Ich führe bei jedem Rendervorgang das hier aus

[code]if(r < 256){
gl.glClearColor(r/255f, 0, 0, 1);
ByteBuffer buffer = ByteBuffer.allocateDirect(3);
buffer.order(ByteOrder.nativeOrder());
gl.glReadPixels(240, 400, 1, 1, GL10.GL_RGBA,GL10.GL_UNSIGNED_BYTE,buffer);


for(int b = 0; b < 3; b+=1){
if(buffer.get(b)<0){
pickcolor[b] = (int)((buffer.get(b)) + 256);
}
else{
pickcolor[b] = (int)(buffer.get(b));
}
}
Log.i("INFO","R == "+r+" == "+ (float)r/255f+ " Byte: "+buffer.get(0)+" Farbwert: " + this.pickcolor[0]);

r+=1;
}[/code]

Also bei jedem Render Vorgang erhöhe ich den Farbanteil um 1 Zeichne die Farbe in den Hintergrund, Picke sie und werte den ByteBuffer aus das ganze lasse ich mir dann mit LogCat ausgeben.

Die erste Zahl ist der Integer Farbwert die zweite Zahl hinter == ist der float Wert der sich durch r/255f ergibt
und dann kommt der wert im ByteBuffer und die errechnete Farbe ganz hinten

Jede achte Zahl liefert ein korrektes Ergebnis woran kann das aber liegen.

1 == 0.003921569 Byte: 0 Farbwert: 0
2 == 0.007843138 Byte: 0 Farbwert: 0
3 == 0.011764706 Byte: 0 Farbwert: 0
4 == 0.015686275 Byte: 0 Farbwert: 0
5 == 0.019607844 Byte: 0 Farbwert: 0
6 == 0.023529412 Byte: 0 Farbwert: 0
7 == 0.02745098 Byte: 0 Farbwert: 0
8 == 0.03137255 Byte: 0 Farbwert: 0
9 == 0.03529412 Byte: 8 Farbwert: 8
10 == 0.039215688 Byte: 8 Farbwert: 8
11 == 0.043137256 Byte: 8 Farbwert: 8
12 == 0.047058824 Byte: 8 Farbwert: 8
13 == 0.050980393 Byte: 8 Farbwert: 8
14 == 0.05490196 Byte: 8 Farbwert: 8
15 == 0.05882353 Byte: 8 Farbwert: 8
16 == 0.0627451 Byte: 8 Farbwert: 8
17 == 0.06666667 Byte: 16 Farbwert: 16
18 == 0.07058824 Byte: 16 Farbwert: 16
19 == 0.07450981 Byte: 16 Farbwert: 16
20 == 0.078431375 Byte: 16 Farbwert: 16
21 == 0.08235294 Byte: 16 Farbwert: 16
22 == 0.08627451 Byte: 16 Farbwert: 16
23 == 0.09019608 Byte: 16 Farbwert: 16
24 == 0.09411765 Byte: 16 Farbwert: 16
25 == 0.09803922 Byte: 24 Farbwert: 24
26 == 0.101960786 Byte: 24 Farbwert: 24
27 == 0.105882354 Byte: 24 Farbwert: 24
28 == 0.10980392 Byte: 24 Farbwert: 24
29 == 0.11372549 Byte: 24 Farbwert: 24
30 == 0.11764706 Byte: 24 Farbwert: 24
31 == 0.12156863 Byte: 24 Farbwert: 24
32 == 0.1254902 Byte: 24 Farbwert: 24
33 == 0.12941177 Byte: 33 Farbwert: 33
34 == 0.13333334 Byte: 33 Farbwert: 33
35 == 0.13725491 Byte: 33 Farbwert: 33
36 == 0.14117648 Byte: 33 Farbwert: 33
37 == 0.14509805 Byte: 33 Farbwert: 33
38 == 0.14901961 Byte: 33 Farbwert: 33
39 == 0.15294118 Byte: 33 Farbwert: 33
40 == 0.15686275 Byte: 33 Farbwert: 33
41 == 0.16078432 Byte: 41 Farbwert: 41
42 == 0.16470589 Byte: 41 Farbwert: 41
43 == 0.16862746 Byte: 41 Farbwert: 41
44 == 0.17254902 Byte: 41 Farbwert: 41
45 == 0.1764706 Byte: 41 Farbwert: 41
46 == 0.18039216 Byte: 41 Farbwert: 41
47 == 0.18431373 Byte: 41 Farbwert: 41
48 == 0.1882353 Byte: 41 Farbwert: 41
49 == 0.19215687 Byte: 49 Farbwert: 49
50 == 0.19607843 Byte: 49 Farbwert: 49
51 == 0.2 Byte: 49 Farbwert: 49
52 == 0.20392157 Byte: 49 Farbwert: 49
53 == 0.20784314 Byte: 49 Farbwert: 49
54 == 0.21176471 Byte: 49 Farbwert: 49
55 == 0.21568628 Byte: 49 Farbwert: 49
56 == 0.21960784 Byte: 49 Farbwert: 49
57 == 0.22352941 Byte: 57 Farbwert: 57
58 == 0.22745098 Byte: 57 Farbwert: 57
59 == 0.23137255 Byte: 57 Farbwert: 57
60 == 0.23529412 Byte: 57 Farbwert: 57
61 == 0.23921569 Byte: 57 Farbwert: 57
62 == 0.24313726 Byte: 57 Farbwert: 57
63 == 0.24705882 Byte: 57 Farbwert: 57
64 == 0.2509804 Byte: 57 Farbwert: 57
65 == 0.25490198 Byte: 66 Farbwert: 66
66 == 0.25882354 Byte: 66 Farbwert: 66
67 == 0.2627451 Byte: 66 Farbwert: 66
68 == 0.26666668 Byte: 66 Farbwert: 66
69 == 0.27058825 Byte: 66 Farbwert: 66
70 == 0.27450982 Byte: 66 Farbwert: 66
71 == 0.2784314 Byte: 66 Farbwert: 66
72 == 0.28235295 Byte: 66 Farbwert: 66
73 == 0.28627452 Byte: 74 Farbwert: 74
74 == 0.2901961 Byte: 74 Farbwert: 74
75 == 0.29411766 Byte: 74 Farbwert: 74
76 == 0.29803923 Byte: 74 Farbwert: 74
77 == 0.3019608 Byte: 74 Farbwert: 74
78 == 0.30588236 Byte: 74 Farbwert: 74
79 == 0.30980393 Byte: 74 Farbwert: 74
80 == 0.3137255 Byte: 74 Farbwert: 74
81 == 0.31764707 Byte: 82 Farbwert: 82
82 == 0.32156864 Byte: 82 Farbwert: 82
83 == 0.3254902 Byte: 82 Farbwert: 82
84 == 0.32941177 Byte: 82 Farbwert: 82
85 == 0.33333334 Byte: 82 Farbwert: 82
86 == 0.3372549 Byte: 82 Farbwert: 82
87 == 0.34117648 Byte: 82 Farbwert: 82
88 == 0.34509805 Byte: 82 Farbwert: 82
89 == 0.34901962 Byte: 90 Farbwert: 90
90 == 0.3529412 Byte: 90 Farbwert: 90
91 == 0.35686275 Byte: 90 Farbwert: 90
92 == 0.36078432 Byte: 90 Farbwert: 90
93 == 0.3647059 Byte: 90 Farbwert: 90
94 == 0.36862746 Byte: 90 Farbwert: 90
95 == 0.37254903 Byte: 90 Farbwert: 90
96 == 0.3764706 Byte: 90 Farbwert: 90
97 == 0.38039216 Byte: 99 Farbwert: 99
98 == 0.38431373 Byte: 99 Farbwert: 99
99 == 0.3882353 Byte: 99 Farbwert: 99
100 == 0.39215687 Byte: 99 Farbwert: 99
101 == 0.39607844 Byte: 99 Farbwert: 99
102 == 0.4 Byte: 99 Farbwert: 99
103 == 0.40392157 Byte: 99 Farbwert: 99
104 == 0.40784314 Byte: 99 Farbwert: 99
105 == 0.4117647 Byte: 107 Farbwert: 107
106 == 0.41568628 Byte: 107 Farbwert: 107
107 == 0.41960785 Byte: 107 Farbwert: 107
108 == 0.42352942 Byte: 107 Farbwert: 107
109 == 0.42745098 Byte: 107 Farbwert: 107
110 == 0.43137255 Byte: 107 Farbwert: 107
111 == 0.43529412 Byte: 107 Farbwert: 107
112 == 0.4392157 Byte: 107 Farbwert: 107
113 == 0.44313726 Byte: 115 Farbwert: 115
114 == 0.44705883 Byte: 115 Farbwert: 115
115 == 0.4509804 Byte: 115 Farbwert: 115
116 == 0.45490196 Byte: 115 Farbwert: 115
117 == 0.45882353 Byte: 115 Farbwert: 115
118 == 0.4627451 Byte: 115 Farbwert: 115
119 == 0.46666667 Byte: 115 Farbwert: 115
120 == 0.47058824 Byte: 115 Farbwert: 115
121 == 0.4745098 Byte: 123 Farbwert: 123
122 == 0.47843137 Byte: 123 Farbwert: 123
123 == 0.48235294 Byte: 123 Farbwert: 123
124 == 0.4862745 Byte: 123 Farbwert: 123
125 == 0.49019608 Byte: 123 Farbwert: 123
126 == 0.49411765 Byte: 123 Farbwert: 123
127 == 0.49803922 Byte: 123 Farbwert: 123
128 == 0.5019608 Byte: 123 Farbwert: 123
129 == 0.5058824 Byte: -124 Farbwert: 132
130 == 0.50980395 Byte: -124 Farbwert: 132
131 == 0.5137255 Byte: -124 Farbwert: 132
132 == 0.5176471 Byte: -124 Farbwert: 132
133 == 0.52156866 Byte: -124 Farbwert: 132
134 == 0.5254902 Byte: -124 Farbwert: 132
135 == 0.5294118 Byte: -124 Farbwert: 132
136 == 0.53333336 Byte: -124 Farbwert: 132
137 == 0.5372549 Byte: -116 Farbwert: 140
138 == 0.5411765 Byte: -116 Farbwert: 140
139 == 0.54509807 Byte: -116 Farbwert: 140
140 == 0.54901963 Byte: -116 Farbwert: 140
141 == 0.5529412 Byte: -116 Farbwert: 140
142 == 0.5568628 Byte: -116 Farbwert: 140
143 == 0.56078434 Byte: -116 Farbwert: 140
144 == 0.5647059 Byte: -116 Farbwert: 140
145 == 0.5686275 Byte: -108 Farbwert: 148
146 == 0.57254905 Byte: -108 Farbwert: 148
147 == 0.5764706 Byte: -108 Farbwert: 148
148 == 0.5803922 Byte: -108 Farbwert: 148
149 == 0.58431375 Byte: -108 Farbwert: 148
150 == 0.5882353 Byte: -108 Farbwert: 148
151 == 0.5921569 Byte: -108 Farbwert: 148
152 == 0.59607846 Byte: -108 Farbwert: 148
153 == 0.6 Byte: -100 Farbwert: 156
154 == 0.6039216 Byte: -100 Farbwert: 156
155 == 0.60784316 Byte: -100 Farbwert: 156
156 == 0.6117647 Byte: -100 Farbwert: 156
157 == 0.6156863 Byte: -100 Farbwert: 156
158 == 0.61960787 Byte: -100 Farbwert: 156
159 == 0.62352943 Byte: -100 Farbwert: 156
160 == 0.627451 Byte: -100 Farbwert: 156
161 == 0.6313726 Byte: -91 Farbwert: 165
162 == 0.63529414 Byte: -91 Farbwert: 165
163 == 0.6392157 Byte: -91 Farbwert: 165
164 == 0.6431373 Byte: -91 Farbwert: 165
165 == 0.64705884 Byte: -91 Farbwert: 165
166 == 0.6509804 Byte: -91 Farbwert: 165
167 == 0.654902 Byte: -91 Farbwert: 165
168 == 0.65882355 Byte: -91 Farbwert: 165
169 == 0.6627451 Byte: -83 Farbwert: 173
170 == 0.6666667 Byte: -83 Farbwert: 173
171 == 0.67058825 Byte: -83 Farbwert: 173
172 == 0.6745098 Byte: -83 Farbwert: 173
173 == 0.6784314 Byte: -83 Farbwert: 173
174 == 0.68235296 Byte: -83 Farbwert: 173
175 == 0.6862745 Byte: -83 Farbwert: 173
176 == 0.6901961 Byte: -83 Farbwert: 173
177 == 0.69411767 Byte: -75 Farbwert: 181
178 == 0.69803923 Byte: -75 Farbwert: 181
179 == 0.7019608 Byte: -75 Farbwert: 181
180 == 0.7058824 Byte: -75 Farbwert: 181
181 == 0.70980394 Byte: -75 Farbwert: 181
182 == 0.7137255 Byte: -75 Farbwert: 181
183 == 0.7176471 Byte: -75 Farbwert: 181
184 == 0.72156864 Byte: -75 Farbwert: 181
185 == 0.7254902 Byte: -67 Farbwert: 189
186 == 0.7294118 Byte: -67 Farbwert: 189
187 == 0.73333335 Byte: -67 Farbwert: 189
188 == 0.7372549 Byte: -67 Farbwert: 189
189 == 0.7411765 Byte: -67 Farbwert: 189
190 == 0.74509805 Byte: -67 Farbwert: 189
191 == 0.7490196 Byte: -67 Farbwert: 189
192 == 0.7529412 Byte: -67 Farbwert: 189
193 == 0.75686276 Byte: -58 Farbwert: 198
194 == 0.7607843 Byte: -58 Farbwert: 198
195 == 0.7647059 Byte: -58 Farbwert: 198
196 == 0.76862746 Byte: -58 Farbwert: 198
197 == 0.77254903 Byte: -58 Farbwert: 198
198 == 0.7764706 Byte: -58 Farbwert: 198
199 == 0.78039217 Byte: -58 Farbwert: 198
200 == 0.78431374 Byte: -58 Farbwert: 198
201 == 0.7882353 Byte: -50 Farbwert: 206
202 == 0.7921569 Byte: -50 Farbwert: 206
203 == 0.79607844 Byte: -50 Farbwert: 206
204 == 0.8 Byte: -50 Farbwert: 206
205 == 0.8039216 Byte: -50 Farbwert: 206
206 == 0.80784315 Byte: -50 Farbwert: 206
207 == 0.8117647 Byte: -50 Farbwert: 206
208 == 0.8156863 Byte: -50 Farbwert: 206
209 == 0.81960785 Byte: -42 Farbwert: 214
210 == 0.8235294 Byte: -42 Farbwert: 214
211 == 0.827451 Byte: -42 Farbwert: 214
212 == 0.83137256 Byte: -42 Farbwert: 214
213 == 0.8352941 Byte: -42 Farbwert: 214
214 == 0.8392157 Byte: -42 Farbwert: 214
215 == 0.84313726 Byte: -42 Farbwert: 214
216 == 0.84705883 Byte: -42 Farbwert: 214
217 == 0.8509804 Byte: -34 Farbwert: 222
218 == 0.85490197 Byte: -34 Farbwert: 222
219 == 0.85882354 Byte: -34 Farbwert: 222
220 == 0.8627451 Byte: -34 Farbwert: 222
221 == 0.8666667 Byte: -34 Farbwert: 222
222 == 0.87058824 Byte: -34 Farbwert: 222
223 == 0.8745098 Byte: -34 Farbwert: 222
224 == 0.8784314 Byte: -34 Farbwert: 222
225 == 0.88235295 Byte: -25 Farbwert: 231
226 == 0.8862745 Byte: -25 Farbwert: 231
227 == 0.8901961 Byte: -25 Farbwert: 231
228 == 0.89411765 Byte: -25 Farbwert: 231
229 == 0.8980392 Byte: -25 Farbwert: 231
230 == 0.9019608 Byte: -25 Farbwert: 231
231 == 0.90588236 Byte: -25 Farbwert: 231
232 == 0.9098039 Byte: -25 Farbwert: 231
233 == 0.9137255 Byte: -17 Farbwert: 239
234 == 0.91764706 Byte: -17 Farbwert: 239
235 == 0.92156863 Byte: -17 Farbwert: 239
236 == 0.9254902 Byte: -17 Farbwert: 239
237 == 0.92941177 Byte: -17 Farbwert: 239
238 == 0.93333334 Byte: -17 Farbwert: 239
239 == 0.9372549 Byte: -17 Farbwert: 239
240 == 0.9411765 Byte: -17 Farbwert: 239
241 == 0.94509804 Byte: -9 Farbwert: 247
242 == 0.9490196 Byte: -9 Farbwert: 247
243 == 0.9529412 Byte: -9 Farbwert: 247
244 == 0.95686275 Byte: -9 Farbwert: 247
245 == 0.9607843 Byte: -9 Farbwert: 247
246 == 0.9647059 Byte: -9 Farbwert: 247
247 == 0.96862745 Byte: -9 Farbwert: 247
248 == 0.972549 Byte: -9 Farbwert: 247
249 == 0.9764706 Byte: -1 Farbwert: 255
250 == 0.98039216 Byte: -1 Farbwert: 255
251 == 0.9843137 Byte: -1 Farbwert: 255
252 == 0.9882353 Byte: -1 Farbwert: 255
253 == 0.99215686 Byte: -1 Farbwert: 255
254 == 0.99607843 Byte: -1 Farbwert: 255
255 == 1.0 Byte: -1 Farbwert: 255

Wenn ich das ganze nun mit dem Blauanteil mache und das zweite Byte auslese

dann liefert jede vierte Zahl das richtige Ergebnis,.. daher auch die schwankungen zwischen den bytes obwohl das selbe drinn stehen sollte...

EDIT:
Stimmt nicht ganz wo 32 kommen sollte ist es 33 und dann wieder jedes weitere + 8.
Wenn ich das gleiche mit dem Grün Anteil mache ist übrigens jedes 4te ein treffer...

Durchblick == null ;)

— geändert am 28.02.2012, 19:43:03

ist rundungsfehler (auf binärebene) .. alles kleiner 8 (erinnere dich wie 8 als binär aussieht)

Scheinbar löst die technik dahinter nicht größer als 8 auf du kriegst also nur farbwerte in 8er schritten.

Wie gesagt eine RGB Farbe ist nunmal nicht float und 1f = maximal RGB Kanal, 0f = 0 - openGL (oder was auch immer) interpoliert die werte entsprechend, es wäre nicht sonderlich "flott", wenn die grafikkarte (oder opengl) hier einen vollen gleitkoma datentyp "verbraucht" - vermutlich liegt dahinter ein festkommatyp der nur zu float konvertiert wird.

1000

Aber wenn es so einfach ist wieso macht er es mit dem zweiten Byte im Buffer nicht genau so sondern bringt dort dann jeden vierten Wert korrekt zurück.

Insofern ich das jetzt nicht überlesen,.. habe steht hier auch nix darüber das glReadpixels nicht die Werte zwischen 0 und 256 ausspuckt
http://www.opengl.org/sdk/docs/man/xhtml/glReadPixels.xml

1000 ist ne binäre 8 :-)

ist von mir nur eine vermutung, dass intern eventuell festkomma genutzt wird und die unteren bits we-gerundet werden .. ist aber nur eine Vermutung, ich kenne die opengl-internas nicht.

Harrys Post sieht vielversprechend aus, oder?

Sorry Harry...

Das mit der 1000 oben war für reiti.net. , eure Antworten kamen nahezu gleichzeitig rein
und dabei hat sich alles ein wenig verschoben.
Ich schau mal ob ich meine Formulierungen in Zukunft soweit Optimieren kann das es
keine Verständnisschwierigkeiten mehr gibt.

Im Moment führt das setzten von setEGLConfigChooser zum Abbruch der App.
Ich bleib da jetzt mal dran, denn der Gedanke ist wirklich nahe liegend.

Also ich werde mich auf Jeden Fall noch ein wenig damit beschäftigen, da es mir am liebsten wäre wenn es einfach korrekt funktioniert.
Bis dahin habe ich mich jetzt für einen anderen Weg Entschieden.

Da ich mir nicht sicher sein kann das die Werte auf jedem Telefon die selben sind erzeuge ich jetzt in den ersten paar Render-durchläufen eine Farbtabelle die auf dem verwendeten Telefon auch funktioniert.

Ich erhöhe dazu die ersten 255 Durchläufe von onDrawFrame() kontinuierlich den Farbanteil x um 1. ,
überzeichne den Bildschirm mit glClearColor( x/255f , x/255f , x/255f , 1) , picke mir jedesmal ein Pixel heraus und prüfe
ob der ByteBuffer das erwartete Ergebnis für RGB mitbringt.

Wenn die Werte im ByteBuffer nicht mit x übereinstimmt, werden sie verworfen wenn doch kommen sie in eine Liste.
Am ende dieser Prozedur habe ich drei Listen mit gültigen Farbwerten für den R, G und B Kanal.

Aus den Farbwerten in den drei Listen bilde ich nun eine gewisse Anzahl von Farbkombinationen. und diese Verwende ich dann fürs Picking.
Das alles wird jetzt von einer Klasse verwaltet die sich so zu sagen darum kümmert das jedes Objekt das anklickbar ist auch eine eigene
Farbe aus der Liste zugewiesen bekommt.

Erstaunlicher weise erhalte ich genau 32 gültige Farbwerte für R und B und genau 64 Farbwerte für G.
"Zufälliger" weise ergeben sich daraus ziemlich genau 65536 mögliche Kombinationsmöglichkeiten.
Vorläufig sollte das dann auch reichen

Wenn ich noch dahinter komme was genau mein Problem hier ist werde ich euch das natürlich mitteilen.

Vielen dank nochmal an dich Harry für deine Hilfsbereitschaft - hättest du mir nicht so intensiv geholfen hätte ich bereits vor
zwei Tagen alles entnervt in die Tonne gekloppt .

Hallo ich bin es Nochmal.

Also da meine Lösung lediglich auf Samsung geräten zu funktionieren scheint, war ich heute gezwungen mir das Problem nochmals vor zu nehmen.
Was soll ich sagen... nach einem Nervenzusammenbruch und ca. einer halben Stunde sucherei. Bin ich dem Fehler dann tatsächlich auf die schliche gekommen.

Ich kann nur sagen das es ein dummer Fehler in der EGLConfiguration war wie es der Harry ja bereits vermutet hatte, jetzt läuft endlich alles wie es soll, und ich bin froh dem ganzen den Rücken zukehren zu können .
Nächstes mal geh ichs einfach etwas ruhiger an und suche gleich beim Ursprung .

beste Grüße an alle

Du erinnerst dich sicher daran das du meintest ich soll glSurface.setEGLConfigChooser(8, 8, 8, 8, 16, 0); setzen.
Das ganze führte bei mir zum Crash und es lag daran wie ich den Renderer und die View Implementiert hatte.

Soviel dazu warum dein Ansatz nicht gleich Funktioniert hat.

Die seltsamen Werte kamen also dadurch zu stande. Das in meiner Methode in der der beste Modus für setEGLConfigChooser ermittelt werden sollte
auf verschiedenen Geräten verschiedenen Werten ausgegeben wurden.
Aufgefallen ist mir das aber erst als ich die Werte eines Samsungs mit den Werten eines Htc´s verglichen habe.

Ich hab die MainActivity nun einfach neu gechrieben und die View und den Renderer so implementiert wie es sich gehört.
Sowie auf das Automatische ermitteln der richtigen Einstellungen verzichtet.

Hier die Funktionierende Activity vielleicht nutzt das ja mal jemandem etwas.

Hallo Marcel,
Ich bin absoluter Android Neuling und suche schon lange ein funktionierendes Beispiel für Color-Picking (Android, OpenGl 10). Du hast ja offensichtlich eine Lösung. Leider ist das Listing von Deiner 'OpenglActivity' nicht komplett. Es Endet bei Zeile 65 und ob mir die komplette Activity alleine weiterhilft, bezweifle ich im Moment noch.
Jetzt meine Bitte: Kannst Du das komplette Projekt als Download veröffentlichen oder mir auf anderem Weg Zukommen lassen?
Im Voraus vielen Dank.
Grüße Walter G.
PS.: Ein weiteres Großes Problem von mir, ich kann kein Englisch!