Tags:    delphi
For at modtage og sætte cursorens position, bruger vi to Windows funktioner: GetCursorPos() og SetCursorPos(). Den første nævnte prcedure forventer en TPoint, hvor den sidste forventer to integer (X,Y). Med disse kald vil vi modtage/sætte cursorens position på vores skærm og ikke på vores form. Så når vi skal sætte cursoren præcis i centrum af vores form, skal vi halvere bredden og højden og lægge left og top positionerne til. Den samme beregning trækker vi fra koordinaterne vi modtager for at få afstanden. Resultatet trækker vi fra vores viewports rotaion. Da vi hele tiden skal være sikke på at cursoren til sidst bliver sat i centrum på formen, skriver vi det hele i Idle proceduren. Så tilføj en lokal variant: P, som TPoint i denne procedure og skriv følgende kode:

procedure TForm1.Idle(Sender : TObject; var Done : Boolean); 
var
  P : TPoint;
begin 
  Done := False;
  if Jump then 
  begin
    if Translation.Y > -1 then 
    Translation.Y := Translation.Y-0.1 
    else 
      Jump := False;
  end 
  else 
    if Translation.Y < 0 then 
    Translation.Y := Translation.Y+0.1;

  //Modtage cursorens position
  GetCursorPos(P);

  //Beregener os frem til centrum af vores form
  P.X := (Left+(Width div 2))-P.X;
  P.Y := (Top+(Height div 2))-P.Y;

  //Rotere vores viewport
  Rotation.Y := Rotation.Y-(P.X*0.1);
  Rotation.X := Rotation.X-(P.Y*0.1);

  //Sætter cursorens position i centrum af vores form 
  SetCursorPos(Left+(Width div 2),Top+(Height div 2));/ 

  FormPaint(nil); 
  Caption := IntToStr(FPS); 
  Inc(I); 
end; 

Som du sikkert har bemærket ganger jeg afstanden med 0.1 inden jeg trækker den fra vores rotation. Det bevirker at det bliver lettere at styre. Prøv at kompile og se den nye og meget bedere måde at navigere på. For at lukke din applikation bliver du nødt til at taste Alt+F4 eller tilføj en tase funktion eks: vk_Escape: Close; i FormKeyDown proceduren. Det eneste vi mangler, er, at fjerne cursoren, da den er lidt irriterende at havde synlig. Det kan vi gøre med Windows funktionen: ShowCursor(). Denne procedure forventer en Boolean, så vi skriver selvfølgelig False. Vi behøver kun at gøre det én gang, så vi skriver den i FormCreate proceduren. (De forskellige bmp billeder er fra den tidligere artikel!)

procedure TForm1.FormCreate(Sender: TObject);
begin
  Context := SetupContext(Form1);
  Gulv_ID := LoadTexture('C:\\Gulv.Bmp');
  Vaeg_ID := LoadTexture('C:\\Væg.Bmp');
  Loft_ID := LoadTexture('C:\\Loft.Bmp');

  //Skjuler cursoren
  ShowCursor(False);

  Application.OnIdle := Idle;
end;

For at fuldende vores nye styremåde, kunne det være interessant at bruge venstre og højre museknapper til at bevæge os frem ad og tilbage. Det vil være nemmest at skrive vores nye navigations funktioner i Idle proceduren. Vi kan bruge den samme teknik, som da vi lavede vores hoppe animation, ved at lade nogle booleans aktivere vores bevægelse i Idle proceduren. Meget logisk, vil vi derfor lade vores booleans blive True i vores forms OnMouseDown property og False i OnMouseUp property. Når en boolean en er True skal der bevæges og når den er False skal bevægelsen stoppes. Vi tilføjer to globale varianter: MoveForward og MoveBackward og flytter vores tidligere kode, der fik os til at bevæge gå frem og tilbage fra FormKeyDown proceduren til Idle proceduren.

var
  FPS, I : Integer;
  Jump, MoveForward, MoveBackward : Boolean;
procedure TForm1.Idle(Sender : TObject; var Done : Boolean);
var
  P : TPoint;
begin
  Done := False;

  if Jump then
  begin
    if Translation.Y > -1 then
    Translation.Y := Translation.Y-0.1
    else
      Jump := False;
  end
  else
    if Translation.Y < 0 then
    Translation.Y := Translation.Y+0.1;

  GetCursorPos(P);
  //Beregener
  P.X := (Left+(Width div 2))-P.X;
  P.Y := (Top+(Height div 2))-P.Y;
  Rotation.Y := Rotation.Y-(P.X*0.1);
  Rotation.X := Rotation.X-(P.Y*0.1);
  SetCursorPos(Left+(Width div 2),Top+(Height div 2));

  //Gå frem
  if MoveForward then
  begin
    Translation.X := Translation.X-(Sin(DegToRad(Rotation.Y))*0.5);
    Translation.Z := Translation.Z+(Cos(DegToRad(Rotation.Y))*0.5);
  end;
  //Gå tilbage
  if MoveBackward then
  begin
    Translation.X := Translation.X+(Sin(DegToRad(Rotation.Y))*0.5);
    Translation.Z := Translation.Z-(Cos(DegToRad(Rotation.Y))*0.5);
  end;

  FormPaint(nil);
  Caption := IntToStr(FPS);
  Inc(I);
end;

Som du kan se har jeg gjort vores to nye booleans klar til at aktivere bevægelserne. Yderligere har jeg halveret farten (ganget med 0.5), da det vil gå meget hurtigere, da beregningen foregår i Idle prodeuren. Nu skal vi bare havde gjort dem aktivér-bare i vores forms OnMouseDown og OnMouseUp properties.

procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
  //Når venstre knap holdes nede går vi frem ad
  if Button = mbLeft then
  MoveForward := True;

  //Når højre knap holdes nede går vi tilbage
  if Button = mbRight then
  MoveBackward := True;
end;

procedure TForm1.FormMouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
  //Stopper med at gå frem ad
  if Button = mbLeft then
  MoveForward := False;

  //Stopper med at gå tilbage
  if Button = mbRight then
  MoveBackward := False;
end;

Som du sikkert kan mærke er det en meget mere behageligt måde at navigere rundt på. Vi kan nu hurtig vende os om, kigge op og ned. Desuden virker det også meget mere flydende når vi går.

Texures bevirkede i at vores lille "spil" fra sidste artikel kom grafisk til at se meget mere spændende ud. Det spil industrien har stræbet efter de sidste mange år er realisme. Vi er et skridt på vej, til at opnå den grafiske resultat som den professionelle spil-industri har mellem fingerene. Men som du sikkert har bemærket ser vores textures lidt pixeleret ud, hvis vi enten står tæt på eller langt fra. Dette er fordi OpenGL projektere hele vores 2D textures på samme måde uanset hvor vi befinder os i forhold til vores geometri. Dette kan ændres med en teknik der bliver kaldt for MipMapping. Ordet "Mip" er latinsk og betyder mange. Ideén er derfor at OpenGL skal lave mange textures ud af vores ene texure, men i forskellige størrelser. Da vores texture er en format 256x256, kan vi lade OpenGL generere 8 yderligere textures med formaterne: 128x128, 64x64, 32x32, 16x16, 8x8, 4x4, 2x2 og 1x1. Dette vil betyde at står vi tæt på projektere OpenGL vores originale 256x256 texture, men jo længere vi går væk fra vores geometri, jo mindre format vil OpenGL projektere. Dette bevirkere i at vores textures ikke vil komme til at se så pixeleret ud, men det vil også bevirke i at vi får en dybde fornemmelse. Funktionen der får OpenGL til at projektere vores MipMap formater er ikke inkluderet i OpenGL 1.1, derfor bliver vi nødt til at definere den selv.

function gluBuild2DMipmaps(Target: GLenum; Components, Width, Height: GLint; Format, atype: GLenum; Data: Pointer): GLint; stdcall; external glu32;

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