ReflectionTest.simba

{$i reflection/reflection.simba}

type
  Polygon = record
    XPoints: Array of Int32;
    YPoints: Array of Int32;
    NPoints: Int32;
  end;

Procedure DrawPolygons(constref XPoints, YPoints: Array of Int32; nPoints: Int32; bmp: TMufasaBitmap; Colour: TColor);
var
  i: Integer;
  size: Int32;
begin
  size := NPoints - 2;
  if size = -1 then
    exit;

  for i := 0 to size do
  begin
    bmp.LineTo(Point(XPoints[i], YPoints[i]), Point(XPoints[i + 1], YPoints[i + 1]), Colour);
  end;

  bmp.LineTo(Point(XPoints[size + 1], YPoints[size + 1]), Point(XPoints[0], YPoints[0]), Colour);
end;

Procedure DrawPolygons(constref Vertices: Array of TPoint; constref Indices: Array of TVector; bmp: TMufasaBitmap; Colour: TColor); overload;
var
  i: Integer;
  A, B, C: TPoint;
begin
  for i := 0 to Length(indices) - 1 do
  begin
    A.x := Vertices[Indices[I].x].x;
    A.y := Vertices[Indices[I].x].y;

    B.x := Vertices[Indices[I].y].x;
    B.y := Vertices[Indices[I].y].y;

    C.x := Vertices[Indices[I].z].x;
    C.y := Vertices[Indices[I].z].y;

    bmp.LineTo(A, B, Colour);
    bmp.LineTo(B, C, Colour);
    bmp.LineTo(C, A, Colour);
  end;
end;

Procedure DrawPolygons(constref Vertices: Array of TPoint; constref Indices: Array[0..3] of Array of Int32; bmp: TMufasaBitmap; Colour: TColor); overload;
var
  i: Integer;
  A, B, C: TPoint;
begin
  for i := 0 to Length(indices[0]) - 1 do
  begin
    A.x := Vertices[Indices[0][I]].x;
    A.y := Vertices[Indices[0][I]].y;

    B.x := Vertices[Indices[1][I]].x;
    B.y := Vertices[Indices[1][I]].y;

    C.x := Vertices[Indices[2][I]].x;
    C.y := Vertices[Indices[2][I]].y;

    bmp.LineTo(A, B, Colour);
    bmp.LineTo(B, C, Colour);
    bmp.LineTo(C, A, Colour);
  end;
end;

Function ProjectTriangles(constref model: RSModel; localX, localY, localZ, orientation: Int32): Array of Polygon;
var
  i: Int32;
  cameraX, cameraY, cameraZ, cameraYaw, cameraPitch: Int32;
  viewPortScale, viewPortHeight, viewPortWidth: Int32;
  sinPitch, cosPitch, sinYaw, cosYaw: Int32;
  triangles: Array of TTriangle;
  A, B, C: TPoint;
  Face: Polygon;

  Function isValidPoint(point: TPoint): Boolean;
  begin
    Result := (point.x <> -1) and (point.y <> -1);
  end;
begin
  cameraX := RSCamera.X;
  cameraY := RSCamera.Y;
  cameraZ := RSCamera.Z;
  cameraYaw := RSCamera.Yaw;
  cameraPitch := RSCamera.Pitch;

  viewPortScale := RSClient.ViewPortScale;
  viewPortWidth := RSClient.ViewPortWidth;
  viewPortHeight := RSClient.ViewPortHeight;

  sinPitch := SINE[cameraPitch];
  cosPitch := COSINE[cameraPitch];
  sinYaw := SINE[cameraYaw];
  cosYaw := COSINE[cameraYaw];

  triangles := model.TriangleFaces;

  for i := 0 to high(triangles) do
  begin
    A := triangles[i].a.ProjectToScreen(localX, localY, localZ,
                                        orientation, cameraX, cameraY, cameraZ,
                                        sinYaw, cosYaw, sinPitch, cosPitch,
                                        viewPortWidth, viewPortHeight, viewPortScale);

    B := triangles[i].b.ProjectToScreen(localX, localY, localZ,
                                        orientation, cameraX, cameraY, cameraZ,
                                        sinYaw, cosYaw, sinPitch, cosPitch,
                                        viewPortWidth, viewPortHeight, viewPortScale);

    C := triangles[i].c.ProjectToScreen(localX, localY, localZ,
                                        orientation, cameraX, cameraY, cameraZ,
                                        sinYaw, cosYaw, sinPitch, cosPitch,
                                        viewPortWidth, viewPortHeight, viewPortScale);

    if isValidPoint(A) and isValidPoint(b) and isValidPoint(c) then
    begin
      Face := [[A.X, B.X, C.X], [A.Y, B.Y, C.Y], 3];
      Result += Face;
    end;
  end;
end;

Function ProjectTriangles(constref model: RSAnimatedModel; localX, localY, localZ, orientation: Int32): Array of Polygon; overload;
var
  i: Int32;
  cameraX, cameraY, cameraZ, cameraYaw, cameraPitch: Int32;
  viewPortScale, viewPortHeight, viewPortWidth: Int32;
  sinPitch, cosPitch, sinYaw, cosYaw: Int32;
  triangles: Array of TTriangle;
  A, B, C: TPoint;
  Face: Polygon;

  Function isValidPoint(point: TPoint): Boolean;
  begin
    Result := (point.x <> -1) and (point.y <> -1);
  end;
begin
  cameraX := RSCamera.X;
  cameraY := RSCamera.Y;
  cameraZ := RSCamera.Z;
  cameraYaw := RSCamera.Yaw;
  cameraPitch := RSCamera.Pitch;

  viewPortScale := RSClient.ViewPortScale;
  viewPortWidth := RSClient.ViewPortWidth;
  viewPortHeight := RSClient.ViewPortHeight;

  sinPitch := SINE[cameraPitch];
  cosPitch := COSINE[cameraPitch];
  sinYaw := SINE[cameraYaw];
  cosYaw := COSINE[cameraYaw];

  triangles := model.triangles;

  for i := 0 to high(triangles) do
  begin
    A := triangles[i].a.ProjectToScreen(localX, localY, localZ,
                                        orientation, cameraX, cameraY, cameraZ,
                                        sinYaw, cosYaw, sinPitch, cosPitch,
                                        viewPortWidth, viewPortHeight, viewPortScale);

    B := triangles[i].b.ProjectToScreen(localX, localY, localZ,
                                        orientation, cameraX, cameraY, cameraZ,
                                        sinYaw, cosYaw, sinPitch, cosPitch,
                                        viewPortWidth, viewPortHeight, viewPortScale);

    C := triangles[i].c.ProjectToScreen(localX, localY, localZ,
                                        orientation, cameraX, cameraY, cameraZ,
                                        sinYaw, cosYaw, sinPitch, cosPitch,
                                        viewPortWidth, viewPortHeight, viewPortScale);

    if isValidPoint(A) and isValidPoint(b) and isValidPoint(c) then
    begin
      Face := [[A.X, B.X, C.X], [A.Y, B.Y, C.Y], 3];
      Result += Face;
    end;
  end;
end;

Function ProjectVertices(constref model: RSAnimatedModel; localX, localY, localZ, orientation: Int32): Array of TPoint; overload;
var
  i: Int32;
  cameraX, cameraY, cameraZ, cameraYaw, cameraPitch: Int32;
  viewPortScale, viewPortHeight, viewPortWidth: Int32;
  sinPitch, cosPitch, sinYaw, cosYaw: Int32;
  vertices: Array of TVector;
  p: TPoint;

  Function isValidPoint(point: TPoint): Boolean;
  begin
    Result := (point.x <> -1) and (point.y <> -1);
  end;
begin
  cameraX := RSCamera.X;
  cameraY := RSCamera.Y;
  cameraZ := RSCamera.Z;
  cameraYaw := RSCamera.Yaw;
  cameraPitch := RSCamera.Pitch;

  viewPortScale := RSClient.ViewPortScale;
  viewPortWidth := RSClient.ViewPortWidth;
  viewPortHeight := RSClient.ViewPortHeight;

  sinPitch := SINE[cameraPitch];
  cosPitch := COSINE[cameraPitch];
  sinYaw := SINE[cameraYaw];
  cosYaw := COSINE[cameraYaw];

  vertices := model.vertices;

  for i := 0 to high(vertices) do
  begin
    P := vertices[i].ProjectToScreen(localX, localY, localZ,
                                     orientation, cameraX, cameraY, cameraZ,
                                     sinYaw, cosYaw, sinPitch, cosPitch,
                                     viewPortWidth, viewPortHeight, viewPortScale);
    if isValidPoint(P) then
    begin
      Result += P;
    end;
  end;
end;

Procedure DrawPlayer(constref player: RSPlayer; Bmp: TMufasaBitmap; Colour: TColor);
var
  i: Int32;
  orientation: Int32;
  localTile: RSTile;
  model: RSAnimatedModel;
  triangles: Array of Polygon;
begin
  orientation := player.Orientation;
  localTile := player.LocalTile;

  model := Player.AnimatedModel;
  triangles := ProjectTriangles(model, localTile.X, localTile.Y, localTile.GetHeight(), orientation);
  model.Free;

  for i := 0 to high(triangles) do
  begin
    DrawPolygons(Triangles[I].XPoints, Triangles[I].YPoints, Triangles[I].NPoints, Bmp, Colour);
  end;
end;

Procedure DrawPlayer2(constref player: RSPlayer; Bmp: TMufasaBitmap; Colour: TColor);
var
  orientation: Int32;
  localTile: RSTile;
  model: RSModel;
  animatedModel: RSAnimatedModel;
  vertices: Array of TPoint;
  indices: Array[0..3] of Array of Int32;
begin
  orientation := player.Orientation;
  localTile := player.LocalTile;

  animatedModel := Player.AnimatedModel;
  if animatedModel.ref <> nil then
  begin
    model.ref := animatedModel.ref;
    vertices := ProjectVertices(animatedModel, localTile.X, localTile.Y, localTile.GetHeight(), orientation);
    indices := model.RawIndices;
    model.Free;

    DrawPolygons(vertices, indices, Bmp, Colour);
  end;
end;

Procedure DrawNPC(constref npc: RSNPC; Bmp: TMufasaBitmap; Colour: TColor);
var
  i: Int32;
  orientation: Int32;
  localTile: RSTile;
  model: RSAnimatedModel;
  triangles: Array of Polygon;
begin
  orientation := npc.Orientation;
  localTile := npc.LocalTile;

  model := npc.AnimatedModel;
  if model.ref <> nil then
  begin
    triangles := ProjectTriangles(model, localTile.X, localTile.Y, localTile.GetHeight(), orientation);
    model.Free;

    for i := 0 to high(triangles) do
    begin
      DrawPolygons(Triangles[I].XPoints, Triangles[I].YPoints, Triangles[I].NPoints, Bmp, Colour);
    end;
  end;
end;

procedure DebugClient;
var
  w,h, bmp: Integer;
begin
  GetClientDimensions(w, h);
  bmp := BitmapFromClient(0, 0, w - 1, h - 1);
  DisplayDebugImgWindow(w, h);
  DrawBitmapDebugImg(bmp);
  FreeBitmap(bmp);
end;

procedure DebugMe(bmp: TMufasaBitmap; w, h: Int32);
var
  i: Integer;
  me: RSPlayer;
begin
  me := RSPlayer.Me;

  if me.ref <> nil then
  begin
    for i := 0 to 1000 do
    begin
      DrawPlayer2(me, bmp, $FFFFFF);

      if i mod 2 = 0 then
        Bmp.Rectangle([0, 0, w - 1, h - 1], $00);
    end;
  end;

  me.Free;
end;

procedure DebugPlayers(bmp: TMufasaBitmap);
var
  i: Integer;
  players: array of RSPlayer;
  def: RSPlayerDefinition;
  Garbage: RSTypeArray;
begin
  players := RSClient.AllPlayers;

  for i := 0 to high(players) do
  begin
    if players[i].ref <> nil then
    begin
      def := players[i].Definition;
      if def.ref <> nil then
      begin
        try
          DrawPlayer2(players[i], bmp, $FFFFFF);
        except
        end;
        garbage += def;
      end;
    end;
  end;

  RSTypeArray(players).Free;
end;

procedure DebugNPCs(bmp: TMufasaBitmap);
var
  i: Integer;
  npcs: array of RSNPC;
  def: RSNPCDefinition;
  garbage: RSTypeArray;
begin
  npcs := RSClient.AllNPCs;

  for i := 0 to high(npcs) do
  begin
    if npcs[i].ref <> nil then
    begin
      def := npcs[i].Definition;
      if def.ref <> nil then
      begin
        try
          DrawNPC(npcs[i], bmp, $FFFFFF);
        except
        end
        garbage += def;
      end;
    end;
  end;

  Garbage.Free;
  RSTypeArray(npcs).Free;
end;

var
  w, h: Int32;
  debugBuffer: ^UInt8;
  bmp: TMufasaBitmap;
begin
  RSetup;

  GetClientDimensions(w, h);
  DebugBuffer := EIOS_GetDebugImageBuffer(R_EIOS);
  EIOS_SetGraphicsDebugging(R_EIOS, True);

  Bmp.Init;
  Bmp.SetPersistentMemory(PtrUInt(debugBuffer), w, h);

  Bmp.Rectangle([0, 0, w - 1, h - 1], $00);
  DebugMe(bmp, w, h);
  //DebugPlayers(bmp);
  //DebugNPCs(bmp);




  Bmp.ResetPersistentMemory;
  Bmp.Free;
end.