ich würd gern mithilfe von GLPolygonStipple ne schraffierte Primitive rendern. Alle meine Versuche, das zu erreichen scheitern jedoch kläglich. So siehts an der Front aus im Moment: Ich erstelle ein [0..31, 0..3] Array of Byte (wie im Wiki-Artikel)). Dann bin ich davon ausgegangen (ich schätze irgendwo hier steckt mein Fehler), 0..31 seien die möglichen X-Koordinaten und 0..3 * 0..7 die möglichen Y-Koordinaten (das Array ist ja Byte, OGL erwartet aber Bits die entweder 1 oder 0 sind (wenn ich den Artikel recht verstehe)). In der ersten Zeile sollen nun 8 Bits entlang x 1 werden, die nächsten 8 werden 0 und für die nächsten 16 Bits genau so. Also berechne ich x mod 16 und prüfe, ob das Ergebnis <= 8 ist, wenn ja setze ich Stipple[X, Y] auf Stipple[X, Y] or 1 shl Bit (X, Y und Bit sind Laufvariablen, die Schleifen wurden in dieser Reihenfolge erstellt). Soweit sollte die "Schraffur" jetzt doch eigentlich aus senkrechten Balken bestehen - tut sie aber nicht, die Balken sind waagerecht. Gut dachte ich mir, kümmert mich nicht weiter - nächsten Berechnungsschritt implementieren, wenn die Balken (wie es sich für ne Schraffur gehört) um 45° gedreht sind kommen beide Varianten aufs Gleiche hinaus. Also bin ich dazu übergegangen, (X + (Y*Bit) mod 16) <= 8 zu prüfen und meine Bits entsprechend zu setzen - was dabei rauskommt hab ich euch mal angehangen. Ich verstehe die gestippelte Welt irgendwie nicht mehr...
Meine Frage: Wie krieg ichs so hin, wies soll, also mit ner Schraffur aus Balken, die um 45° zur Senk- bzw. Waagerechten verkippt sind?
Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.
Registriert: Do Sep 25, 2003 15:56 Beiträge: 7804 Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Das Beispielim Wiki ist etwas unglücklich für dich, denn es ist komplett zufällig. Du willst aber etwas regelmäßiges machen. Selbstgemacht habe ich das noch nicht, aber was im Artikel steht ist, dass das Muster ein 32x32Pixel großer bereich ist. Im Beispiel wurde nur 32x3 verwendet, da es eh kein identifizierbares Musker ergibt.
Mach doch mal ein sehr regelmäßiges muster wo du in eine Richtung jedes 3te Bit setzt und zwar in jeder Zeile.
_________________ Blog: kevin-fleischer.de und fbaingermany.com
Also...mittlerweile bin ich etwas schlauer...oder eher nicht. Ich geb euch einfach mal ein paar Codeschnipsel, schreib dazu, was ich mir dabei gedacht habe, und was dabei rausgekommen ist...
1) Annahme das Stipple sei 32x32 Pixel, jeden Pixel setzen...
Code:
var Stipple: Array [0..31, 0..3] of Byte; [...] FillMemory(@Stipple[0, 0], 32*4, $00); for X := 0 to 31 do for Y := 0 to 3 do for Bit := 0 to 7 do Stipple[X, Y] := 1; glPolygonStipple(@Stipple[0, 0]);
Ergebnis: Braucht keinen Screenshot, das Stipple ist einfach deckend. Soweit so gut.
2) Versuchen wir es mal ohne das Bitgeschubse, vllt. ist das Array ja doch nicht Bitweise zu interpretieren
Code:
var Stipple: Array [0..31, 0..31] of Byte; [...] FillMemory(@Stipple[0, 0], 32*4, $00); for X := 0 to 31 do for Y := 0 to 31 do Stipple[X, Y] := 1;
Ergebnis: Siehe Screenshot Meine Erkenntnis: Das Array wird doch bitweise interpretiert, die Bits laufen dabei entlang x, und nicht entlang y.
3) Y läuft nur bis 3 (wie im Beispiel mit Bitgeschubse), wir lassen das Bitgeschubse trotzdem weg - wenn meine Annahme stimmt ändert sich nichts Ergebnis: Stimmt.
4) Wir lassen X bis drei laufen, Y bis 31 (Arraydimensionen natürlich auch vertauscht), Bitgeschubse ist inclusive
Code:
for X := 0 to 3 do for Y := 0 to 31 do for Bit := 0 to 7 do Stipple[X, Y] := Stipple[X, Y] or 1 shl Bit;
Ergebnis: Das Stipple ist deckend.
5) Lehnen wir uns mal weiter aus dem Fenster - versuchen wir mal, jeden zweiten Pixel zu setzen.
Code:
for X := 0 to 3 do for Y := 0 to 31 do for Bit := 0 to 7 do if ((X + 1) * (Y + 1) * (Bit + 1)) mod 2 = 0 then Stipple[X, Y] := Stipple[X, Y] or 1 shl Bit;
Ergebnis: Siehe Screenshot - Interpretation fällt mir schwer...eigentlich find ich sie unmöglich.
Es scheitert also schon an recht einfachen Problemen...
Edit: Nachtrag: Ich habs jetzt geschafft, nen "Schachbrettmuster" zu erzeugen, damit bin ich recht zufrieden, auch wenn die Schraffur immer noch mein Ziel wäre - wenn also jemand ne Idee dazu hat, immer her damit. Der Code für das Schachbrett:
Code:
for X := 0 to 3 do for Y := 0 to 31 do for Bit := 0 to 7 do if (Y+X) mod 2 = 0 then Stipple[X, Y] := Stipple[X, Y] or 1 shl Bit;
Die Schachbrettfelder sind damit 16*16 Pixel groß. Ich habe keine Ahnung, wies funktioniert xD
Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.
Du verwendest da ein 2D-Array. Ich hab ja keine Ahnung von Delphi/Pascal, aber liegt den das am Stück im Speicher? Versuchs doch mal mit einem 1D-Array.
Ein statisches Array liegt eigentlich schon am Stück im Speicher. Jedenfalls benutz ich (und einige andere auch) für Matrizen immer ein 2D - array, und da kommen die Datan eigentlich immer richtig an, wenn ich sie an OpenGL übergeb. Also von da her müsste das Problem wo anders liegen.
ah... ich seh vielleicht auch schon, wo.
Code:
var Stipple: Array [0..31, 0..3] of Byte;
Versuchs mal mit Packed Array. Sonst wird vielleicht für jedes Byte 32 bit reserviert.
Also so richtig seh' ich hier nicht durch. Ich denke ich könnte dir helfen, weiß aber nicht so richtig was du für ein Muster willst. Achja, warum steht das im Mathematik-Forum?
Also jedenfalls du dem PolygonStipple: Die Funktion erwartet als Eingabe ein 32x32 großes Muster. Soweit steht das ja auch im Wiki. Allerdings belegt 1 Pixel nur 1 Bit. Deshalb ist das 2-dimensionale Array auch 32*4 Bytes groß. Ein Byte enthält bekanntermaßen 8 Bit. 4*8=32. Also kommt man auf 32*32 Bit. Da es den Datentyp Bit ja nicht gibt muss man eben Byte nehmen. Wenn man sich das bildlich vorstellt ist eine Zelle des Arrays dann kein Quadrat sondern ein 1*8 großes Rechteck.
Also für ein beliebiges Muster, das in einem Array[0..31,0..31] of Boolean gegeben ist (damit man sich das besser vorstellen kann) könnte eine Funktion zum konvertieren in das OpenGL-Format so aussehen:
Code:
Muster:Array[0..31,0..31] of Boolean;
for X := 0 to 31 do for Y := 0 to 31 do if Muster[X,Y] then Stipple[X,Y div 8]:=Stipple[X,Y div 8] or 1 shl (Y mod 8);
Stipple ist dann das 32*4 Array of Byte. Könnte sein, dass das Muster transponiert dargestellt wird (konnte das nicht testen). In dem Fall müsste man "Muster[X,Y]" durch "Muster[Y,X]" ersetzen. Oder die Bits jedes Bytes könnten gespiegelt sein. Dann müsste man "(Y mod 8 )" eben zu "(7-Y mod 8 )" machen.
Warum das im Matheform steht? Weiß auch nicht, konnte das Problem nicht so wirklich einordnen und wusste nicht, ob das Problem wirklich an meinem Verständnis von Delphi liegt, oder daran, wie ich versuche mein Muster zu erstellen.
Deine Lösung werd ich wohl nichtmehr ausprobieren, ich bin mit meinem Schachbrettmuster jetzt eigentlich recht zufrieden - aber wenn ich nochmal ein anderes Muster brauch, dann weiß ich, wo steht, wies möglich sein sollte Also danke trotzdem.
Registriert: Do Sep 02, 2004 19:42 Beiträge: 4158
Programmiersprache: FreePascal, C++
zoiX hat geschrieben:
Warum das im Matheform steht?
Hast eigentlich recht *move*.
_________________ If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung. current projects: ManiacLab; aioxmpp zombofant network • my photostream „Writing code is like writing poetry“ - source unknown
„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb
Mitglieder in diesem Forum: 0 Mitglieder und 10 Gäste
Du darfst keine neuen Themen in diesem Forum erstellen. Du darfst keine Antworten zu Themen in diesem Forum erstellen. Du darfst deine Beiträge in diesem Forum nicht ändern. Du darfst deine Beiträge in diesem Forum nicht löschen. Du darfst keine Dateianhänge in diesem Forum erstellen.