Hallo,

ich Zeichne mehrere Quads an verschiedene Stellen im System Wie kann ich den abfragen welches Quad sich in der Mitte meines gezeichneten Bildes befindet?

Gruß mylcars

Hey,

das klingt nach einem Fall für Selektion oder Color-Picking
€: Wenn du nur 2D renderst, kannst du das aber auch ganz gut in ner Liste auf der CPU verwalten.

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Die Ideen sind mir auch schon gekommen aber eigentlich zu umständlich für meine Zwecke.

Kann ich nicht erst etwas an die Stelle ein Quad oder einen Punkt recht weit hinten Zeichnen. Dann meine Matrix Verschieben und danach beim schreiben des anzuzeigenden Quads feststellen ob an der Position mein Quad ist? Ich habe aber keine Ahnung mit welchen Befehlen ich da arbeiten müsste.

Gruß mylcars.

Sowas könnte man evtl. mit Occlusion Queries machen.

Ansonsten ist Color-Picking, besonders mit Shadern ganz einfach zu implementieren.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Color Picking verbraucht viele Ressourcen und ist eigentlich kein besonders schöner Ansatz.
Du weißt ja die Koordinaten des Quads, also kannst du auf der CPU ganz einfach mathematisch testen,
ob der Punkt darin liegt. Je nach deinem Fall kann das extrem trivial sein. Handelt es sich zum Beispiel um ein Rechteck in einer 2 dimensionalen Szene, muss ich zum Beispiel wohl nichts weiter dazu sagen.
Handelt es sich um ein beliebiges Quad in einer 2 dimensionalen Szene, ist es immernoch einfach. Das geht zum Beispiel so. In einer 3D Szene musst du einen Strahl losschicken und gegen das Quad testen.

So werden es mit Sicherheit alle Spiele machen.

Also um Unklarheiten zu beseitigen es geht um 3D Objekte.

So ein Ansatz ist ich Rendere alle doppelt und lese anhand der Farbe aus Welches Objekt es ist. Finde ich aber nicht sin der Sache da ich so alles doppelt Rendern müsste.

Nächster Ansatz ich rechne über Algebra aus wo sich der Betrachtungswinkel hin verschiebt und rechne mir das auf der CPU mit und kann dann feststellen wo mein mittleres Quad liegt. Hier scheitert es aktuell an meinen Algebra Kenntnissen und ich mache die Arbeit der Grafikkarte vereinfacht auf der CPU noch einmal.

Nächster Ansatz ich zeichne mir einen Punkt von 3x3 Pixel (oder wie groß auch immer) in die Mitte und verschiebe erst dann meine Ansicht. Jetzt habe ich mit Sicherheit etwas im Schnittpunkt. Naja nicht ganz ein Strahl aber es Kollidiert mit der Z Achse und dem Vertex Quad Block welchen ich darüber oder dahinter Zeichne. Hier fehlt es mir jetzt konkret (vermutlich aus Mangel der richtigen Befehle) an Möglichkeiten wie ich feststelle das mein gezeichneter Vertex Block über oder unter dem bereits in Mitte Zentrierten Vertex liegt.

Nächster Ansatz ich Zeichne meine Szene sende einen Strahl ich die Mitte des Bildschirms und schaue wo er Kollidiert auch hier fehlen mir die Befehle für. Problematisch ist hierbei euch das der Strahl rein Theoretisch auch schon an Vertex Blocks vor der Mitte des Bildschirms Kollidieren könnte. Ansonsten habe ich ja nichts anderes wie den Punkt.

Die Umrechnungen von Fenster in OpenGL Koordinaten sollten eigentlich genau das machen was ich will aber ich habe die Funktion leider nicht ganz verstanden.

Was mir fehlt ist wie ich Rückschlüsse der Vertex Blocks bekomme wo diese auf das Fenster gezeichnet werden. Möglichst schon bevor ich das Vertex überhaupt Zeichne. Was auch funktionieren würde ist nach dem Zeichnen dann würde ich diesen einen Betreffenden Block noch mal neu Schreiben können.

Danke für eure Hilfe. Gruß mylcars

Color picking optimiert man in der regel, in dem man ein 3x3 Bereich auf der Maus rendert.
Dabei setzt man die Scissor auf -1+1 von der Cursor pos und rendert alle Objekte an der Stelle.
Danach liest man die 9 Pixel per CPU.
Damit kann man dann auch Objekte picken, die in der nähe liegen, in dem man die nachbarpixel vom zentrum noch untersucht.
-1+1 macht man wegen dem sampling/rasterizer.

Bibliotheken wie Bullet bringen schon fertige Raycast picking Systeme mit, wenn man noch kein eigenes hat.
Das benutzt ein recht effizientes Raumunterteilungs System und ist auch SIMD optimiert, von daher dauert es ne weile was bessere eigenes zu basteln.
Man benötigt nur das Collide Modul und muss das Dynamic nicht initialisieren, weil man ja keine Physik Simulation macht.

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004

Die Sache ist: Um einen 3*3 Bereich an der Maus zu rendern, muss man ja ermitteln, welche Objekte/Polygone in dem Bereich liegen. Sonst kann man es sich die Optimierung gleich schenken, schließlich sind die doppelten Draw Calls und Geometrieverarbeitung eh teurer wie Rendern mit einer konstanten. Und wenn man ermitteln kann, welche Objekte in dem 3² Pixelfeld liegen, sollte man auch fast gleich alles auf der CPU ermitteln können.

Falls du dich dazu entschließen solltest, doch den analytischen Ansatz auf der CPU selbst umzusetzen:
Um es komplett auf der CPU zu implementieren, ist ein einfaches Raumunterteilungssystem von nutzen. Das sollte man eh besitzen. Und dann prüft man eben den Sichtstrahl gegen jede Bounding Box und schließlich Quad. Informationen dazu findest du genug im Internet.

Um den Sichtstrahl zu ermitteln, musst du die Fensterkoordinaten in normalisierte Koordinaten umrechnen(durch halbe Fenstergröße teilen und eins abziehen, dann ist es in [-1;1]).
Anschließend musst du die normalisierten Koordinaten einmal mit z=-1 und einmal mit z=1 erweitern. Das entspricht dem Punkt nahe der Kamera und weit von ihr entfernt. Die Koordinaten sind aber noch in normalisierten Fensterkoordinaten. Als letzten Schritt musst du nur noch diese Koordinaten mit der invertierten ModelViewProjectionMatrix transformieren. (Invertiert, weil du die Transformation ja rückgängig machen willst als sonst)