OpenGL glViewPort

[DaCoda]

Hallo,
ich habe mal so ein kleines Testprogramm zusammengebaut.
Mit den Buttons wird was gezeichnet. Ich mache das bewusst nicht im Render, weil ich später in einer anderen Routine zeichnen muss.
Mein derzeitiges Problem ist, das mein Panel zum Zeichnen 900x540 ist, was 3 mal so gross ist, wie meine gewünschte "Auflösung" von 300mm x 180mm.
Somit müsste ich das ganze mir 3.0 Skalieren beim Zeichnen.

Aber ich würde gerne so zeichnen, das Unten-Links der Nullpunkt ist und Oben-Rechts eben die Koordinate W900 x H540.
Nun dachte ich das diese Einstellungen mit glViewpost gemacht wird, aber scheinbar verstehe ich mal wieder alles falsch.

Kann mir da jemand einen Tip geben ? (Mein kleines Testprogramm habe ich beigefügt)

Vielen Dank schon mal :-)

[TSchnuckenbock]

Ich bin bei OpenGL zu lange raus und hab' gerade nicht die Zeit, mich wieder in OpenGL einzuarbeiten.

Aber mir haben damals die ganzen Tutorials gut geholfen. Wenn es um das "alte" OpenGL geht und die Grundlagen:

https://wiki.delphigl.com/index.php/Tutorial

Z.B. auf die Schnelle würde ich dir raten mal in "Tutorial 2D" zu schauen...vieleicht klärt sich da schon dein Problem:

https://wiki.delphigl.com/index.php/Tutorial_2D

Wenn du dann OpenGL mit Shadern und so einsetzen möchtest, dann hat Mathias aus dem Lazarus-Forum mal diesbezüglich eine Tutorial-Reihe gestartet:

https://wiki.delphigl.com/index.php/...nGL_einrichten

Die Beispiel-Projekte findest du unter

https://github.com/sechshelme/Lazaru...L-3.3-Tutorial

Ich glaube, Mathias hatte das folgende C/C++-Tutorial für seine Pascal-OpenGL-3.3-Projekte zur Grundlage gemacht:

https://learnopengl.com/Introduction

Chris Rorden bietet auch (fast) unendlich viel Stuff zu OpenGL mit Pascal:

https://github.com/neurolabusc/OpenGLCoreTutorials

Schau beim ChrisR mal durch seine ganzen Repos, wenn du Zeit und Muße hast.;-)

Die einfachen OpenGL-Projekte wird man recht einfach auf Delphi umtoasten können.
Notfalls ist Lazarus auch kostenlos und mit FPCDeluxe kann man sich viele "Distributionen" parallel auf seinen Rechner ziehen.

[DaCoda]

Hallo,
vielen Dank für die vielen Links. Dann hab ich ja was zu tun :-)

Derzeit erarbeite ich mir Grundlagen und deine Links passen da sehr gut,

[Alter Mann]

Moin,

schau dir mal die Beschreibung zu glViewport an(inkl. Normalisierte Gerätekoordinaten).

[DaCoda]

Bis dahin habe ich das ja auch verstanden mit dem ViewPort, aber ich würde gerne zeichnen, wie auf dem normalen Canvas.
Ich habe das versucht (Button1), aber das kann so nicht stimmen. Es geht, kommt mir aber komisch vor. Also ich würde gerne zeichnen "ausserhalb" von Render und das bis dahin gezeichnete soll aber erhalten bleiben.

Und Rotation (Button2) geht in meiner Testversion dann natürlich auch nicht :-)

[IceBube]

Zitat:

Zitat von DaCoda (Beitrag 1541804)

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!