Tags:    delphi


Prøver vi at kompile, skulle vi gerne se en stor hvid trekant. Hvis der ikke er defineret nogen farve tegner OpenGL nemlig alt hvidt som default. Hvis du vil farve din trekant, kan du vælge at definere dine farver som floats eller som bytes. Det var kun ved glColorClear() at du kun kunne definere din farve som floats. Hvis du vil definere den som floats, kan du bruge glColor3f(), og med en alpha værdi bruger du glColor4f(). Vil du derimod definere din farve som Bytes, skal du bruge glColor3ub(), og med en alpha værdi glColor4ub(). Farven skal selvfølig defineres før din primitiv bliver tegnet. Koden vil derfor se således ud:

procedure TForm1.FormPaint(Sender: TObject);
begin
  glClearColor(0,0,0,0);
  glClear(gl_Color_Buffer_Bit);

  //Farver hele vores trekant rød
  glColor3ub(255,0,0):

  glBegin(gl_Triangles);
  glVertex3f(0 ,+0.5,0);
  glVertex3f(+0.5,-0.5,0);
  glVertex3f(-0.5,-0.5,0);
  glEnd;

  SwapBuffers(Context.DeviceContext);
end;

Kompiler vi nu, vil vi se at trekanten er blevet rød. Du har også mulighed for at farve hver enkelt vertex i din primitiv i stedet for hele din primitiv. For at gøre det skriver du blot dine farve værdier for hver vertex:

procedure TForm1.FormPaint(Sender: TObject);
begin
  glClearColor(0,0,0,0);
  glClear(gl_Color_Buffer_Bit);

  glBegin(gl_Triangles);

  //Tegner første vertex rød...
  glColor3ub(255,0,0);
  glVertex3f(0 ,+0.5,0);

  //...anden vertex grøn...
  glColor3ub(0,255,0);
  glVertex3f(+0.5,-0.5,0);

  //...og den tredje vertex blå
  glColor3ub(0,0,255);
  glVertex3f(-0.5,-0.5,0);

  glEnd;

  SwapBuffers(Context.DeviceContext);
end;

Kompiler vi igen, vil vi se at vores trekant nu både er rød, grøn og blå. Lad os i stedet prøve at lave en firkant. Til dette formål findes der faktisk en primitiv der hedder gl_Quads som er designet til at lave firkanter. Med gl_Quads behøver vi kun at angive 4 punkter for at få en firkant, hvor vi med gl_Triangles skal angive 6 punkter. Det vil derfor resultere i mindre kode og større overskuelighed at bruge gl_Quads:

procedure TForm1.FormPaint(Sender: TObject);
begin
  glClearColor(0,0,0,0);
  glClear(gl_Color_Buffer_Bit);

  //Tegner en firkant med gl_Quads
  glBegin(gl_Quads);

  glColor3ub(255,0,0);
  glVertex3f(-0.5, -0.5, 0);

  glColor3ub(0,255,0);
  glVertex3f(-0.5, +0.5, 0);

  glColor3ub(0,0,255);
  glVertex3f(+0.5, +0.5, 0);

  glColor3ub(255,255,0);
  glVertex3f(+0.5 ,-0.5, 0);

  glEnd;


  SwapBuffers(Context.DeviceContext);
end;

Som du sikkert har bemærket ser vores figur lidt udstrukket ud, trods det, at vi har sat vores koordinater med lige store forhold mellem hinanden. Det er fordi vi ikke har defineret nogen frustum, så OpenGL bruger derfor en standard frustum. Dette kan vi selvfølig ændre på. Funktionen glFrustum() vil gøre os i stand til selv at definere en frustum. Grunden til at vi overhovedet har et begreb som en Frustum, er, for at gøre vores kære grafikkort's liv lidt lettere. Det vi egenligt gør, er, at definere en kasse (frustum) foran vores viewport. Alt hvad der er inde i vores kasse, vil blive beregnet og dermed synligt, og alt der er udenfor vil OpenGL ignorere. Dette vil dermed resultere i, at dit grafikkort ikke behøver at arbejde med unødvendige store buffers. Da OpenGL som default har sat en frustum (kasse) der ligger så tæt på vores viewport (0 units væk) at vinklen mellem vores viewport og frustum er så stor, at det får vores perspektiv til at se næsten helt forvrænget ud. Man kan sammenligne det lidt med en kamera's linse. En vinkel på omkring 45 grader (er en frustum der er ca. 2 units væk fra viewporten) giver en fornuftig perspektiv. Men det er selvfølig en smags sag.

glFrustum(-1.0, +1.0, -(ClientHeight/ClientWidth), ClientHeight/ClientWidth, 2, 500);

Udover at jeg beregner den korrekte forhold mellem bredde og højde ved at dividere formens bredde og højde med hinanden, og bestemt at min frustum skal være 2 units væk fra min viewport, har jeg yderlig bestemt at den fjerneste side af min frustum skal være 100 units væk fra min viewport. Med andre ord, så har jeg en frustum (kasse) der er 498 units lang via Z aksen. Da vores frustum kun behøver at blive defineret når formens bredde eller højde bliver ændret vil det være meget oplagt at skrive det i formens OnResize property:

procedure TForm1.FormResize(Sender: TObject);
begin
  //Laver vores egen frustum der er 2 units væk fra viewporten, og er 498 units lang!
  glFrustum(-1.0, +1.0, -(ClientHeight/ClientWidth), ClientHeight/ClientWidth, 2, 500);
end;

Kompiler du vores tidligere kode med vores nye frustum i FormResize proceduren, vil du opleve, at formen er helt sort. Det skyldes at vores geometri ligger udenfor vores frustum, da vi lige har flyttet den 2 units væk fra vores viewport. Siden vi som default altid har vores viewport liggende pa netop koordinat: (0,0,0) og kigger ned langs Z aksen (mod minus værdierne), skal vi skubbe vores tidligere primitiv minus 2 units langs Z aksen, for at komme til at se vores firkant som før.

procedure TForm1.FormPaint(Sender: TObject);
begin
  glClearColor(0,0,0,0);
  glClear(gl_Color_Buffer_Bit);

  //Flytter alle vores Z værdier -2 units, så vores firkant er inde i vores frustum igen - og der med synlig igen!
  glBegin(gl_Quads);

  glColor3ub(255,0,0);
  glVertex3f(-0.5, -0.5, -2);

  glColor3ub(0,255,0);
  glVertex3f(-0.5, +0.5, -2);

  glColor3ub(0,0,255);
  glVertex3f(+0.5, +0.5, -2);

  glColor3ub(255,255,0);
  glVertex3f(+0.5 ,-0.5, -2);

  glEnd;

  SwapBuffers(Context.DeviceContext);
end;

Indtil nu har vi tegnet primitiver der let kunne forveksles med 2D grafik. Lad os derfor prøve at gøre vores kode lidt interaktiv. Med glTranslatef() og glRotatef() kan man flytte og rotere geometri. I følgende eksempel vil vi bruge pil-tasterne til at flytte og rotere rundt på vores firkant. Til det har vi brug for at definere en ny record, der er i stand til at indeholde X, Y og Z koordinater:

type
  TVector = record
    X, Y, Z : Single;
  end;

Vi definere nu to nye globale varianter: Translation og Rotation som TVector, og skriver følgende i vores FormPaint procedure:

var
  Translation, Rotation : TVector;
procedure TForm1.FormPaint(Sender: TObject);
begin
  glClearColor(0,0,0,0);
  glClear(gl_Color_Buffer_Bit);


  //Vil flytte vores firkant. Som du kan se vil den altid blive skubbet minus 5 units væk fra viewporten så vi kan se den rotere rundt!
  with Translation do
  glTranslatef(X,Y,Z-5);

  //Vil rotere vores firkant rundt om hver akse (X, Y, Z)
  with Rotation do
  begin
    glRotatef(X,1,0,0);
    glRotatef(Y,0,1,0);
    glRotatef(Z,0,0,1);
  end;

  glBegin(gl_Quads);

  glColor3ub(255,0,0);
  glVertex3f(-0.5, -0.5, 0);

  glColor3ub(0,255,0);
  glVertex3f(-0.5, +0.5, 0);

  glColor3ub(0,0,255);
  glVertex3f(+0.5, +0.5, 0);

  glColor3ub(255,255,0);
  glVertex3f(+0.5 ,-0.5, 0);

  glEnd;

  SwapBuffers(Context.DeviceContext);
end;

Ud over det skriver vi følgende kode i vores OnKeyDown property:

procedure TForm1.FormKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  case Key of
    //Flytter vores firkant til venstre
    VK_Left: Translation.X := Translation.X-0.01;

    //Flytter vores firkant til højre
    VK_Right: Translation.X := Translation.X+0.01;

    //Rotere vores firkant rundt om X aksen
    VK_Up: Rotation.X := Rotation.X+1;
    VK_Down: Rotation.X := Rotation.X-1;
    end; //Case

  FormPaint(nil);
end;

Prøv at kompile. Når du taster pil- Venstre/Højre vil firkanten bevæge sig til venstre og højre af skærmen. Taster du pil- Op/Ned rotere firkanten rundt om sig selv via X aksen. Men som du sikkert hurtig vil opdage, at det er det svært at styre den, fordi OpenGL ikke husker på den oprindelige position og rotation. Dette kan heldigvis meget let løses ved hjælp af en standard matrix. Ligesom da vi definerede vores primitiv med glBegin() og glEnd kan vi definér en matrix med glPushMatrix og glPopMatrix. Disse kald skal selvfolig indsættes før vi begynder at flytte og rotere og lige efter vi har tegnet vores firkant:

var
  Translation, Rotation : TVector;
procedure TForm1.FormPaint(Sender: TObject);
begin
  glClearColor(0,0,0,0);
  glClear(gl_Color_Buffer_Bit);

  //Begynder på en standard Matrix. Med fag ord, så skubber vi en matrix ind i OpenGL matrix-stak!
  glPushMatrix;

  with Translation do
  glTranslatef(X,Y,Z-5);

  with Rotation do
  begin
    glRotatef(X,1,0,0);
    glRotatef(Y,0,1,0);
    glRotatef(Z,0,0,1);
  end;

  glBegin(gl_Quads);

  glColor3ub(255,0,0);
  glVertex3f(-0.5, -0.5, 0);

  glColor3ub(0,255,0);
  glVertex3f(-0.5, +0.5, 0);

  glColor3ub(0,0,255);
  glVertex3f(+0.5, +0.5, 0);

  glColor3ub(255,255,0);
  glVertex3f(+0.5 ,-0.5, 0);

  glEnd;

  //Afslutter vores matrix igen. Med fag ord, så popper vi den af OpenGL's matrix-stak igen!
  glPopMatrix;

  SwapBuffers(Context.DeviceContext);
end;

Hvad synes du om denne artikel? Giv din mening til kende ved at stemme via pilene til venstre og/eller lægge en kommentar herunder.

Del også gerne artiklen med dine Facebook venner:  

Karma barometer (30 dage)

IT jobs | Kontakt | Om Udvikleren.dk | Om karma | IT nyheds arkiv | Annoncering

X