RiB - Reflect it Baby

[NicNacMan]

jo, ich meinte jetzt eher, dass man sie garnicht erst aus m bild schieben kann.
das mit dem cursor muss ich überlesen haben, sry.

[dizzy]

Zitat:

Zitat von NicNacMan

- wenn man bei den splines die roten kästen verschiebt,
sollten sich imho die grünen kreise gleich mit verschieben. :roll:

Jupp, das hab ich schon länger vor gehabt zu ändern. Ist aber eine Kleinigkeit, die ich jetzt schon öfter wieder vergessen hab :oops:.
Muss ganz klar noch rein!

Zitat:

Zitat von NicNacMan

- bei einer hoffentlich noch folgenden als-bild-exportier-funktion wäre es schön,
wenn man die kreuze bei den emittern ausblenden könnte, damit man n schöneres wallpaper hat.^^

Eine wirklich gute Idee! Ich denke ich werde wohl ein paar Optionen einbauen, so dass man auf Wunsch z.B. die Objekte ausblenden kann, so dass nur noch die Strahlen sichtbar sind. Ja ich denke so wird es werden... :)

Zitat:

Zitat von NicNacMan

- man kann die objekte außerhalb des bildschirms (wenn man das so nennen kann^^) verschieben
und bekommt sie dann nicht mehr zurück.

Ist ja halb geklärt: Nach Resize sind sie weg. Aber der Weisheit letzter Schluss ists so natürlich noch nicht. Ich kann mich nur noch nicht ganz entscheiden zwischen "kein Verschieben über'n Rand" und "bei (ganz) Verschieben übern Rand löschen".
Auch das könnte man ja wählbar machen... Mann das wird eine Propertyschlacht ^^

Zitat:

Zitat von NicNacMan

- die bekannten probleme bei horizontalen linien...

Leidig, aber wichtig...

Zitat:

Zitat von NicNacMan

- das mit dem "Cursor wird zur Hand" funktioniert bei mir auch nicht so richtig,
manchmal wird er zur hand, bleibt es aber dann auch.

Ich würde ja gerne die Hand wieder haben... Da muss ich aber erst nochmal schauen wie ich das am wenigsten CPU-hungrig hin bekomme, da man ja OnMouseMove eine Kollisionsprüfung ALLER Knoten ALLER Objekte machen muss. Kommt Zeit, kommt Hand :)

Zitat:

Zitat von NicNacMan

hoffe ich bin nicht zu pingelig für ne prealpha version *g*

Nana! Das ist ja genau der Richtige Zeitpunkt für sowas! Dicken Dank dafür!

Zitat:

Zitat von NicNacMan

naja, aber das prog is einfach nur "top" :thumb:, hab heute echt mehrere stunden damit rumgespielt!

:D *freu*


Die Weiterentwicklung wird in den kommenden 3 Wochen u.U. etwas stocken, da ich 6 Klausuren vor der Nase hab, aber grad bei so viel schöner Resonanz macht das Proggen gleich noch mal so viel Spaß!


Ich geh erstmal in's Bett... wird ja schon wieder hell ^^
Fabian

[Khabarakh]

Vier Tage Skiurlaub beendet... und hier geht die Post ab :lol: .
Was soll ich zu deinem Programm sagen, perfekt :thumb: ! Sieht auf den ersten Blick wie eine Mischung aus der GR32 GradLines-Demo und deinem Gravitationssimulator aus :mrgreen: .

[EDIT] Das im Anhang sieht allerdings etwas komisch aus? Bzw. welche Art von Refraktion hast du eingebaut?

[dizzy]

Ja das ist evtl. noch nicht 100%ig. Im grunde hat man ständig Übergänge der Art: Medium1 -> Medium2, egal von wo aus. Nie Medium2 -> Medium 1. Da muss ich noch denken... ^^

[Khabarakh]

Das wars dann wohl mit der Umkehrbarkeit des Lichtweges :mrgreen: . Hab mal auch in den Code geschaut, Hilfe, Vektoren :lol: . Die konnte ich bei meinem Programm zum Glück vermeiden :stupid: . Nett fande ich, dass meine Prozedur auch haargenau ReCalc heißt.

[Dax]

Wie schon öfters gesagt, finde ich das Programm auch genial :stupid:
Hab' mich jetzt auch mal dran gemacht.. (wie unser MicroKuchen ;-))
Ergebnis: Durch konsequenten Einsatz von handgemachtem Assemblercode (:mrgreen:) ist RiB schon fast 5% schneller, bei manchen Funktionen hab' ich 10% bekommen, aber da geht noch mehr :)

So, genug geredet, ich hacke weiter an dizzy's Code rum ;)

[dizzy]

Zitat:

Zitat von Dax

Durch konsequenten Einsatz von handgemachtem Assemblercode

Das hab ich bisher ganz bewusst vermieden ;). Da das Dingen ja noch in der Entwicklung ist, wollte ich zunächst mal bei DL bleiben. Optimierung dann später. Aber ich wäre da nicht unwesentlich an deinen "Fummeleien" interessiert :mrgreen:.
Ich hab aber auch schon wieder weitreichende Änderungen im Kopf. Wobei man die ganzen Funktionen zur Vektorrechnung sicherlich recht gefahrlos jetzt schon assemblieren kann...
(btw: Die Bildschn aus deiner PM sind :thumb:)

Cheeriot,
Fabian

[Dax]

Danke für das Kompliment, die Bilder warn auch eine Fummelei ^^ :) (/me schenkt dizzy eine Rose zum Valentinstag *g*)

PS: Sobald alle Optimierungen fertisch sind, poste ichs mal. Zur Zeit ist es nur FPU-Code, später kommt noch SSE, falls damit schneller wird :) (Die VOrtho-Funktion konnte ich mit FPU-pur um 75% verschnellern..)

[jfheins]

Ich möchte diesen Thread nochmal aus der Versenkung hervorhohlen, weil das Prog mich jetzt wirklich interessiert :stupid:

- Wird es noch entwickelt ?

- Kann man auch gerade Linien machen ?

- Das refrakting ist irgendwi nicht ... ganz richtig ... bei einer Linie wird das Licht gebrochen, wie bei einer Sammellinse, und manchmal wird es auch komplett ... fehlgeleitet :(

Kommt da noch was ?

[dizzy]

Zitat:

Zitat von jfheins

- Wird es noch entwickelt ?

Es gibt keine neuere Version, nein. Ich hab das Teil nunmehr unter die Kategorie "Spielerei als Basis für größeres" abgestellt. Die Theorie mit Splines und Licht etc. war eine recht aufschlussreiche Sache für mein Fernziel. Da ich aber derzeit sehr viel beruflich Programmiere, leidet der private Codespieltrieb merklich :cry:

Zitat:

Zitat von jfheins

- Kann man auch gerade Linien machen ?

Theoretisch klar, aber implementiert ist's nicht. Der Fall kam mir damals zu trivial vor, so dass ich direkt an die Splines ging, und Strecken nachbasteln wollte. Naja - so weit kam's dann nicht ^^

Zitat:

Zitat von jfheins

- Das refrakting ist irgendwi nicht ... ganz richtig ... bei einer Linie wird das Licht gebrochen, wie bei einer Sammellinse, und manchmal wird es auch komplett ... fehlgeleitet :(

Da kommt das Problem ins Spiel, dass eine Linie aus Sicht des Programmes 1D ist, also nur einen Übergang in ein anderes Medium darstellt. In der Realität haben aber auch Linien (Scheiben z.B.) ein Volumen, so dass 2 Übergänge passieren, die sich im Normalfall nahezu aufheben (bzw. der Effekt kaum sichtbar ist, da die Übergänge sehr nah aneinander liegen). Das ist in der Tat eine Designschwäche. (Der Kreis z.B. verhält sich wie eine komplett aus einem Material bestehende Kugel ohne Hohlraum - aus eben o.g. Grund.)

Zitat:

Zitat von jfheins

Kommt da noch was ?

In dieser Form wie hier vermutlich nicht. Wenn du aber irgendwo spezifische Fragen hast, dann versuch ich mich gern wieder da rein zu denken =)


Schönen Gruß,
Fabian

[turboPASCAL]

Habe das Teil heute erst gesehen, ich sag nix dazu !

:!: :shock: :cyclops: :hello: :thumb:

[jfheins]

Dass das refracting nicht geht meinte ich so:

-Manchmal wird es etwa so refraktiert:

Code:

\  |  /
*\ | /
  \|/
   |

Was ja nun nicht dein kann. Ausserdem wird bei einer fast geraden Linie, das Licht gebrochen, wie bei einer Sammellinse ... das ist auch ein wenig unlogisch.

Aber ich würde gerne ein paar Features (wie gerade Linien) einbauen, könntest du mir einen Tipp geben, wo ich das am besten mache, damit ich nicht alle sourcen durchwühlen muss ? :mrgreen:

Ausserdem ... könnte man das doch so machen, dass man nur 2D Objekte nimmt, dann geht das refracting auch besser ...

[dizzy]

Zitat:

Zitat von jfheins

Dass das refracting nicht geht meinte ich so:

-Manchmal wird es etwa so refraktiert:

Code:

\  |  /
 \ | /
  \|/
   |

Was ja nun nicht dein kann. Ausserdem wird bei einer fast geraden Linie, das Licht gebrochen, wie bei einer Sammellinse ... das ist auch ein wenig unlogisch.

Jo, das ist so, weil wegen wie ichs im vorigen Beitrag geschrieben hab ;)

Zitat:

Zitat von jfheins

Aber ich würde gerne ein paar Features (wie gerade Linien) einbauen, könntest du mir einen Tipp geben, wo ich das am besten mache, damit ich nicht alle sourcen durchwühlen muss ? :mrgreen:

Schau dir mal die Unit "Objects.pas" an. Dort sind alle Primitives drin, die RiB bisher kann, und daran siehst du auch die Schnittstelle die ein solches bieten muss. Methoden zum Erzeugen müssen dann noch der Klasse TScene hinzugefügt werden, und die Methode TScene.MouseMove() unterscheidet noch zwischen den Objekttypen. Dort müsste von dir noch rein, ob wann und wie deine Objekte als selektiert gelten sollen, und wie mit den Kontrollpunkten verfahren werden soll. Im Grunde ist die Methode ne große "if then else if then..."-Klamotte. An den existierenden Objekten sollte alles wichtige ablesbar sein (das ist zudem eines der wenigen Programme, die ich mal ordentlich kommentiert hab ^^).
Dann fehlen noch die entsprechenden Elemente für's GUI, aber das sollte dann das kleinste Problem sein denk ich.

Zitat:

Zitat von jfheins

Ausserdem ... könnte man das doch so machen, dass man nur 2D Objekte nimmt, dann geht das refracting auch besser ...

Naja, das ist nicht ganz so einfach wie es zunächst klingt. Dafür müsste das Teil etwas ganz entscheidendes dazu lernen: Ein Strahl muss zu jedem Punkt wissen, wie der Brechugnsindex des Materials ist, in dem er sich soeben befindet. Aus dem Unterschied der Indezes an einem Übergangspunkt würde sich dann die Brechung errechnen. Das hab ich jedoch in dieser Komplexität hier garnicht vorgesehen (das Prog war schon zu weit als mir das bewusst wurde). Wie gesagt: Das ist 1a eine Designschwäche, und auch einer der wichtigen Erkenntnisse die ich an dem Teil gewonnen hab ^^.

[jfheins]

Ok, ich bin jetzt soweit:

Delphi-Quellcode:

  TLineObj = class(TSceneObject)
  protected
    procedure SetColor(v: TColor32); override;
    function GetColor: TColor32; override;
  public
    Line: TLine;
    SelPoint: Integer;
    constructor Create(Owner: TScene; x1, y1, x2, y2: Single; FX: TEffect; Color: TColor32);
    procedure Draw; override;
    function GetIntersects(a, b: TFloatPoint): TZS; override;
    procedure Changed; override;
  end;

constructor TLineObj.Create(Owner: TScene; x1, y1, x2, y2: Single;  FX: TEffect; Color: TColor32);
begin
  inherited Create(Owner, FX, Color);

  Line.a.X := x1;
  Line.a.Y := y1;
  Line.b.X := x2;
  Line.b.Y := y2;

  Changed;
end;

procedure TLineObj.Changed;
begin
  Rect.Left   := Min (Line.a.X, Line.b.X) - 5;
  Rect.Right  := Max (Line.a.X, Line.b.X) + 5;
  Rect.Top    := Min (Line.a.Y, Line.b.Y) - 5;
  Rect.Bottom := Max (Line.a.Y, Line.b.Y) + 5;
end;

procedure TLineObj.Draw;
var
  c: TColor32;
begin
  if isSelected then
  begin
    FOwner.FObjectBMP.Canvas.Pen.Color   := clRed;
    FOwner.FObjectBMP.Canvas.Brush.Color := clRed;

    FOwner.FObjectBMP.Canvas.Rectangle(round(Line.a.X)-4,
                                       round(Line.a.Y)-4,
                                       round(Line.a.X)+4,
                                       round(Line.a.Y)+4);

    FOwner.FObjectBMP.Canvas.Rectangle(round(Line.b.X)-4,
                                       round(Line.b.Y)-4,
                                       round(Line.b.X)+4,
                                       round(Line.b.Y)+4);


  end;


  if isSelected then c := Color32(255,255,255)
  else c := self.FColor;


    FOwner.FObjectBMP.LineFS(Line.a.X,
                             Line.a.Y,
                             Line.b.X,
                             Line.b.Y,
                             c);
end;

procedure TLineObj.SetColor(v: TColor32);
begin
  FColor := v;
end;

function TLineObj.GetColor: TColor32;
begin
  result := FColor;
end;

function TLineObj.GetIntersects(a, b: TFloatPoint): TZS;
begin
//
end;

In der GetIntersects-Methodem muss ich eventuelle überschneidungen zurückliefern, oder ?
(In weiser (?) Vorraussicht auch: http://www.delphipraxis.net/internal...ct.php?t=76738 :mrgreen: )

[dizzy]

Zitat:

Zitat von jfheins

In der GetIntersects-Methodem muss ich eventuelle überschneidungen zurückliefern, oder ?
(In weiser (?) Vorraussicht auch: http://www.delphipraxis.net/internal...ct.php?t=76738 :mrgreen: )

Jopp. Du bekommst mit a und b die beiden Punkte der Strecke mit der dein Objekt geschnitten werden soll, und das Ergebnis wird in der TZS-Struktur zurückgegeben.

[Meriones]

Hallo dizzy, habe das ray trace programm gesehen und bin begeistert. :thumb:


Ich bin gerade dabei ein Programm zur Rekonstruktion mikroskopischer Schnitte zu schreiben. Dazu brauche ich Splines!
In deinem Programm sind die Splines wunderbar implemetiert!!! Allerdings nur Start- und Endpunkt mit zwei Kontrollpunkten.
Mir schwebt eine geschlossene Spline Kurve mit beliebig vielen Punkten und zugehörigen Kontrollpukten vor (so ala Freehand, CorellDraw oder Illustrator). Ich frage mich jetzt wie man soetwas implementiert. Momentan benutze ich OpenGL da das automatisch die Kurve rendered . Wenn ich da allerings ein Spline höheren Grades (sagen wir 5) erstelle liegen wieder nur start und enpunkt auf der Linie, die restlichen Punkte sind Kontrollpunkte und "ziehen" die Kurve nur an. Ich brauche aber eine Linie mit beliebig vielen punkten, die jeweils durch Kontrollpunkte kontroliert werden. :gruebel:

Hat jemand eine Idee???

[dizzy]

Bezier-Splines haben grundsätzlich zur Eigenschaft, dass alle Punkte ausser den Randpunkten keine Durchgangspunkte der Kurve sind (ausser man legt es darauf an, z.B. bei einer Geraden). Es gibt Spline Verfahren, die das ermöglichen, aber man geht in fast jeder Grafik Suite die ich kenne so vor, dass man Bezier-Spline Segmente mit je 4 Kontrollpunkten aneinander stückelt.
Das hat den großen Vorteil, dass die beiden mittleren Punkte mit ihrem jeweiligen am selben Ende liegenden Endpunkt verbunden, die Tangente in den Endpunkten darstellen. Dadurch kann man recht einfach erreichen, dass die Kurve an den Übergangsstellen wirklich weich ist, ja sogar differenzierbar 8). Du musst nur die Tangenten zweier Segmente im Berührungspunkt auf eine Gerade bekommen.
Das bietet dann also nicht nur gute Kontrolle über die grobe Form, sondern auch über die Art der "Ecken", bzw. die Ausprägung der Rundung in selbigen.

:love: Bezier

[alzaimar]

Splines, die durch Kontrollpunkte verlaufen, lassen sich relativ einfach berechnen. Im Prinzip sind es polynome 3.Grades, die durch die einzelnen Punkte laufen. Betrachten wir drei Punkte P[i-1], P[i] und P[i+1]. Ein Spline durch diese Punkte besteht aus 2 Polynomen. PN1 geht von P[i-1] zu P[i] und PN2 geht von P[i] zu P[i+1].

Die beiden Polynome müssen am Punkt P[i] in ihrer 1. und 2.Ableitung gleich sein, damit keine Stufen entstehen und das Ganze glatt verläuft.

Wir wissen also:
1. PN1'(x[i]) = PN2'(x[i]) // gleiche Steigung
2. PN1''(x[i]) = PN2''(x[i])

Ich weiss nicht mehr, wieso, aber ich habe alle Polynome nicht von x[i]...x[i+1], sondern von 0... x[i+1]-x[i] laufen lassen.

Damit ergeben sich folgende Bedingungen (sei dx0 = x[i]-x[i-1] und dx1 = x[i-1] - x[i]):
1. PN1[0] = y[i-1]
2. PN2[0] = y[i]
3. PN1[dx0] = y[i]
4. PN2[dx1] = y[i+1]

Wir haben nun 6 Gleichungen für 8 unbekannte (2x 4 Koeffizienten für die Polynome). 2 fehlen noch. der nächste Abschnitt liefert uns jedoch die fehlenden 2 Gleichungen (für PN2) und so weiter. Wenn man das Gleichungssystem für alle Punkte in eine Matrix schreibt, erhält man M-2 Gleichungen mit M Unbekannten. Fast fertig. Nun kann man einfach definieren, das PN0"(0) = 0 und PNn"(dxn) = 0, also setzt einfach die 2.Ableitung am ersten Punkt und die am letzten Punkt auf 0.

Somit ist das Gleichungsystem vollständig und man kann es mit einfachen Mitteln lösen. Dann erhält man N 4-tupel, die Koeffizienten der Polynome.

Kleiner Haken: Die Sache klappt nur bei streng monoton steigenden X-Werten.

Um nun beliebige Kurven zu zeichnen, Erstellt man zwei Splines:
Eins für die Punkte x[i],z[i] und eins für die Punkte y[i],z[i], wobei z[i] eine streng monoton steigende Hilfsfunktion ist, z.B. der Abstand zwischen den einzelnen Punkten aufsummiert. Abschließend berechnet man die Splines S1 und S2 und trägt die Werte S1 S2 auf. Fertig ist die glatte Kurve.

Leider hab ich den Sourcecode nicht auf meinem Laptop, sondern -wenn überhaupt- nur uff Aaabeet. Aber das selbst ich das vor 10-15 Jahren mal hinbekommen habe, schaffst Du das auch: Einfach mal 10 Minuten sacken lassen, Gleichungssystem aufschreiben und lösen (lassen).

[Pfoto]

Hut hab zu dem Teil! :thumb:
Toll, wenn man Mathematik beherrscht... aber das muss man wohl auch in die Wiege gelegt bekommen haben :-(

Weiter so!

Gruß
Pfoto

[alzaimar]

Hier mein uralter TP-Code. Wer es unter Delphi zum Laufen bringt, kann und sollte es hier auch posten.

[edit] Ich hatte immer ne 3 oder 4 in Mathe. Im Studium bin ich gerade so durch die Prüfung gerauscht. Aber über die Jahre muss man sich mit dem Zeugs nun mal auseinandersetzen. Und so schwer ist das ja nicht.[/edit]

[dizzy]

Wenn ich das richtig sehe, ist dein Verfahren der Kubischen Interpolation recht ähnlich. Eine recht interessante Seite dazu gibts auch auf Wikipedia. Was ich an stückweisen Bezier-Splines so elegant finde ist, dass man volle Kontrolle über die Kurve erlangt, da man eben das Tangentenverhalten sehr intuitiv und frei beeinflussen kann. Für eine vollautomatische Interpolation, die nur über die gegebenen Punkte laufen soll, eignet sich Hermite- oder Kubische Interpolation vermutlich sogar besser. Wobei man auch bei Bezier-Segmenten die Tangente in einem Punkt anhand seiner 2 Nachbarpunkte interpolieren, und die fehlenden Kontrollpunkte somit automatisch recht sinnvoll ergänzen kann. Dann hätte man nachher mehr Einfluss auf die Kurve. Alles eine Frage von "was will ich" :)

[alzaimar]

dizzy, ich glaube, ich habe die kubischen Splines aus dem Gedächtnis hergeleitet. Das Verfahren ist mit Sicherheit nicht von mir.

Wenn Du übrigens die Eckpunkte deiner Spline mit den Kontrollpunkten verbindest und von der Strecke den Mittelpunkt nimmst und dann diese Mittelpunkte wieder verbindest und davon die Mitte nimmst und dann wieder und wieder und wieder, dann hast Du ...

... die Bezierkurve. Ganz ohne Polynom oder höhere Mathematik.

[dizzy]

Das wollt ich ja garnicht untergraben ;). Ich wollt dem Kind nur nen Namen geben, damit Suchende ein Wort haben. Diese Wiki-Seite beschreibt ebenfalls die kubische Interpolation, und es ist in der Tat ziemlich genau das, was du gebaut hast.

Was die Beziers angeht, muss ich dich aber korrigieren, bzw. ergänzen. Was du beschreibst, ist eher das Corner-Cut Verfahren, wobei da als Teilungsverhältnis idR 1/4 angesetzt wird. Beim Bezier ist der "Trick", dass man das Teilungsverhältnis verschiebt. Der De Casteljau Algo macht genau dies, also Bezierpunkte über dieses Kontruktionsverfahren ermitteln, ohne je die Bezier Summenformeln gesehen zu haben. Lustigerweise wurden dieser Algo und die Bezier Formel nahezu gleichzeitig von 2 Franzosen getrennt entwickelt, ohne dass sie voneinander wussten. Sie haben sogar beide bei konkurrierenden Autoherstellern gearbeitet. Dass beide Verfahren exakt die selbe Kurve beschreiben, hat man erst nachher entdeckt. Find ich irre :stupid:
Folglich nimmt man zur Analyse die Formeln, aber auf dem PC eigentlich ausschließlich die grafische Konstruktion (da sie auch weiiiit effizienter im Rechner ist).

[Catbytes]

Zitat:

Zitat von dizzy

RiB
Reflect it Baby

Mach doch ein rekursives Backronym draus:

"RiB it Baby"

[inherited]

Zitat:

Zitat von Catbytes

Zitat:

Zitat von dizzy

RiB
Reflect it Baby

Mach doch ein rekursives Backronym draus:

"RiB it Baby"

Zuviel Wine geguckt, was? :P :mrgreen:

Gibt es eigentlich so etwas wie eine maximale Strahllänge?
Warum kackt mein PC hierbei (Anhang) nicht in einer (nahezu) Endlosschleife ab? :P

[dizzy]

In deinem Screenie steht schon die Antwort ;) "Ray-Depth" gibt an, wie oft ein Strahl reflektiert werden darf. Standardeinstellung ist: Nach 32 Reflektionen/Refraktionen hört der Strahl einfach auf.

[KesseK]

Wieso wird bei "Ray-Depth" immer gleich der Wert für alle Emitter gesetzt? Das find ich etwas unglücklich.

[xZise]

Also dein RiB it Baby ^^ hat ein Problem bei einem 90° Spiegel (Also: |<---* : * = Emitter, <--- = Strahl, | = "Spline")...

Und zwar is dann nichts mit refelktieren :P

[inherited]

Den gleichen Fehler konnte ich auch feststellen, allerdings auch bei 45°-Winkeln

[xZise]

Wie wäre es, wenn man das speichern könnte :D

PS: Der eine Strahl ist dann irgendwie "weg"... Andere Objekte brechen ihn net mehr (egal wohin)

[Nicodius]

ich hab einen ermitter mit der shift taste und maus nach rechts die strahlen halt so aufgeteilt - dann kam eine fehlernachricht

Zitat:

---------------------------
Rib
---------------------------
Ungültige Gleitkommaoperation.
---------------------------
OK
---------------------------

sonst klasse :thumb:


edit

selber fehler wenn ich mit der strg taste einen spline nach rechts "gezogen" verschoben habe (bei jedem punkt des splines wie ich gerade merke selebr fehler :( )

edit auch beim bewegen jetzt jeder splines : :lol: das problem wurde nur durch löschen dieses splines gelöst

lg

[hadschi92]

Ich muss sagen das Programm macht einem Spaß, es ist echt super gemacht :thumb:

So, ich möchte ein Stück Code aus deinem Quelltext "klauen" bzw. verstehen. Und zwar handelt es sich um die Funktion, dass ein Objekt mit einem Auswahlrahmen umgeben wird wenn man darüber fährt. So wie es aussieht hast du das mit einem Timer gelöst, mir erschließt sich jedoch nicht wie du den Rahmen zeichnest.

Hier der Ausschnitt:

Delphi-Quellcode:

procedure TScene.OnStippleTimer(Sender: TObject);
begin
  if Assigned(FMouseOver) then
  begin
    FStippleCount := FStippleCount + 0.4;
    DrawFrame;
    Redraw;
  end
  else
  begin
    DrawFrame;
    Redraw;
    FStippleTimer.Enabled := false;
  end;
end;

procedure TScene.DrawFrame;
var
  sel, moov: TFloatRect;
begin
  FFrameBMP.Clear(0);
  FFrameBMP.BeginUpdate;
  if Assigned(FSelection) then
  begin
    sel := FSelection.Rect;
    FFrameBMP.LineS(round(sel.Left),  round(sel.Top),    round(sel.Right), round(sel.Top),    Color32(0,127,255));
    FFrameBMP.LineS(round(sel.Right), round(sel.Top),    round(sel.Right), round(sel.Bottom), Color32(0,127,255));
    FFrameBMP.LineS(round(sel.Right), round(sel.Bottom), round(sel.Left),  round(sel.Bottom), Color32(0,127,255));
    FFrameBMP.LineS(round(sel.Left),  round(sel.Bottom), round(sel.Left),  round(sel.Top),    Color32(0,127,255));
  end;

  if Assigned(FMouseOver) then
  begin
    moov := FMouseOver.Rect;
    FFrameBMP.StippleCounter := FStippleCount;
    FFrameBMP.LineFSP(round(moov.Left),  round(moov.Top),    round(moov.Right), round(moov.Top));
    FFrameBMP.LineFSP(round(moov.Right), round(moov.Top),    round(moov.Right), round(moov.Bottom));
    FFrameBMP.LineFSP(round(moov.Right), round(moov.Bottom), round(moov.Left),  round(moov.Bottom));
    FFrameBMP.LineFSP(round(moov.Left),  round(moov.Bottom), round(moov.Left),  round(moov.Top));
  end;
  FFrameBMP.EndUpdate;
end;

procedure TScene.Redraw;
begin
  FObjectBMP.DrawTo(Display);
  FFieldBMP.DrawTo(Display);
  FFrameBMP.DrawTo(Display);
  Control.Refresh;
end;