OpenGL glViewPort

[IceBube]

Zitat von DaCoda:

Also ich würde gerne zeichnen "ausserhalb" von Render und das bis dahin gezeichnete soll aber erhalten bleiben.

Du kannst das aber auch in einem Array abspeichern und in der "Render-Funktion" dann umsetzen. Hab ich damals immer so gemacht. So in etwa..

Delphi-Quellcode:

type
TVector4 = Record
 x, y, z, w : single
end;


LinePoints = class // Oder Record
angle : TVector4
color : TVector4
start, ende : TVector4
end;

var MeinArray:Array of LinePoints

function rgba(r, g, b, a :single) : TVector4;
begin
 result.x := r/255; result.y := g/255; result.z := b/255; Result.w := a/100
end;

function Vector4(x, y, z, w :single) : TVector4;
begin
 result.x := x; result.y := y; result.z := z; Result.w := w
end;

function Vector2(x, y :single) : TVector4;
begin
 result.x := x; result.y := y; result.z := 0; Result.w := 0
end;

procedure BtnClick
begin
SetLength(MeinArray, Length(MeinARray)+1)
MeinARray[High(MeinArray)] := LinePoints.Create()
MeinArray[High(MeinArray)].Start := Vector2(Start.X, Start.Y)
MeinArray[High(MeinArray)].Ende  := Vector2(Ende.X, Ende.Y)
MeinArray[High(MeinArray)].color := rgba(255, 255, 255, 100)
MeinArray[High(MeinArray)].angle := Vector4(0, 0, 1, 90)

procedure Render()
... GL / PROJECTION

for i = 0 To High(MeinArray) do
begin
glpushmatrix();
 // Anpassen des Origin mittels glTranslate...
 glrotateF(MeinArray[i].Angle.W, MeinArray[i].Angle.x, MeinArray[i].Angle.y, MeinArray[i].Angle.z)
 //
  glBegin(GL_LINES);
  glColor4fv(@(@MeinArray[i].color);
  glVertex2fv(@MeinArray[i].start);
  glVertex2fv(@(@MeinArray[i].ende);
  glEnd;
glPopmatrix();
end

... SWAP
end

lg

[DaCoda]

@IceBube:

Jo, das war genau der Gedankenansatz. Manchmal ist es so einfach, wenn man dann die Idee hat

Nun muss ich nur noch schauen, wie ich die Meine "ARC-Funktion" nachbauen kann, da es Arc ja scheinbar so nicht gibt.

Code:

procedure TGCodeRenderer.DrawArc(CX, CY, Radius, StartAngle, EndAngle: Double; Clockwise: Boolean; Color: TColor);
var
  StartX, StartY, EndX, EndY: Double;
  ArcRect: TRect;
begin
  StartX := CX + Radius * Cos(StartAngle);
  StartY := CY + Radius * Sin(StartAngle);
  EndX := CX + Radius * Cos(EndAngle);
  EndY := CY + Radius * Sin(EndAngle);

  if (Round(StartX * FScale) = Round(EndX * FScale)) and (Round(StartY * FScale) = Round(EndY * FScale)) then begin
    FCurrentX := EndX;
    FCurrentY := EndY;
    Exit;
  end;

  ArcRect := Rect(
    Round((CX - Radius) * FScale),
    Round((CY - Radius) * FScale),
    Round((CX + Radius) * FScale),
    Round((CY + Radius) * FScale)
    );
  ArcRect.NormalizeRect;

  FCanvas.Pen.Color := Color;
   if Clockwise then begin
     FCanvas.Arc(ArcRect.Left, Round(AdjustY(ArcRect.Top)), Round(ArcRect.Right), Round(AdjustY(ArcRect.Bottom)), Round(EndX * FScale), Round(AdjustY(EndY * FScale)), Round(StartX * FScale), Round(AdjustY(StartY * FScale)));
  end else begin
     FCanvas.Arc(ArcRect.Left, Round(AdjustY(ArcRect.Top)), Round(ArcRect.Right), Round(AdjustY(ArcRect.Bottom)), Round(StartX * FScale), Round(AdjustY(StartY * FScale)), Round(EndX * FScale), Round(AdjustY(EndY * FScale)));
  end;

  FCurrentX := EndX;
  FCurrentY := EndY;
end;

Wobei man das Runden und Scale ja nicht mehr braucht dann.

Ich hab das so versucht:

Code:

procedure TGCodeRenderer.DrawArc(CX, CY, CZ, Radius, StartAngle, EndAngle: Double; Clockwise: Boolean; Color: TColor);
const
  Segments = 100; // Anzahl der Segmente für den Bogen
var
  Step, Angle, NextAngle: Double;
  i: Integer;
  X1, Y1, Z1, X2, Y2, Z2: Double;
begin
  // Setze die Farbe (abhängig vom verwendeten OpenGL-Setup)
  glColor3f(GetRValue(Color) / 255.0, GetGValue(Color) / 255.0, GetBValue(Color) / 255.0);

  // Berechne die Winkel-Differenz für die Richtung
  if Clockwise then
  begin
    if EndAngle > StartAngle then
      EndAngle := EndAngle - 360;
    Step := (StartAngle - EndAngle) / Segments;
  end
  else
  begin
    if EndAngle < StartAngle then
      EndAngle := EndAngle + 360;
    Step := (EndAngle - StartAngle) / Segments;
  end;

  // Zeichnen des Bogens im 3D-Raum mit GL_LINES
  glBegin(GL_LINES);
  for i := 0 to Segments - 1 do
  begin
    // Berechne den aktuellen Winkel und den nächsten Winkel für die Linie
    Angle := StartAngle + i * Step;
    NextAngle := StartAngle + (i + 1) * Step;

    // Aktuellen Punkt (X1, Y1, Z1) berechnen
    X1 := CX + Radius * Cos(DegToRad(Angle));
    Y1 := CY + Radius * Sin(DegToRad(Angle));
    Z1 := CZ;

    // Nächsten Punkt (X2, Y2, Z2) berechnen
    X2 := CX + Radius * Cos(DegToRad(NextAngle));
    Y2 := CY + Radius * Sin(DegToRad(NextAngle));
    Z2 := CZ;

    // Linie zeichnen zwischen den Punkten (X1, Y1, Z1) und (X2, Y2, Z2)
    glVertex3f(X1, Y1, Z1);
    glVertex3f(X2, Y2, Z2);
  end;
  glEnd;

  FCurrentX := X2;
  FCurrentY := Y2;
  FCurrentZ := Z2;

end;

Vielen Dank!