matrix.inc

著名的游戏开发库Allegro4.2.0 for DELPHI

{*         ______   ___    ___
 *        /\  _  \ /\_ \  /\_ \
 *        \ \ \L\ \\//\ \ \//\ \      __     __   _ __   ___
 *         \ \  __ \ \ \ \  \ \ \   /'__`\ /'_ `\/\`'__\/ __`\
 *          \ \ \/\ \ \_\ \_ \_\ \_/\  __//\ \L\ \ \ \//\ \L\ \
 *           \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
 *            \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
 *                                           /\____/
 *                                           \_/__/
 *
 *      Matrix math routines.
 *
 *      By Shawn Hargreaves.
 *
 *      See readme.txt for copyright information.
 *}
{$IFDEF ALLEGRO_INTERFACE}
type
  P_MATRIX = ^MATRIX;
  MATRIX = record                // transformation matrix (fixed point)
    v: array[0..2,0..2] of fixed; // scaling and rotation
    t: array[0..2] of fixed;     // translation
  end;

  P_MATRIX_f = ^MATRIX_f;        // transformation matrix (floating point)
  MATRIX_f = record
    v: array[0..2,0..2] of single; // scaling and rotation
    t: array[0..2] of single;    // translation
  end;

var
  identity_matrix: P_MATRIX;
  identity_matrix_f: P_MATRIX_f;

  get_translation_matrix: procedure(m: P_MATRIX; x, y, z: fixed); cdecl;
  get_translation_matrix_f: procedure(m: P_MATRIX_f; x, y, z: single); cdecl;

  get_scaling_matrix: procedure(m: P_MATRIX; x, y, z: fixed); cdecl;
  get_scaling_matrix_f: procedure(m: P_MATRIX_f; x, y, z: single); cdecl;

  get_x_rotate_matrix: procedure(m: P_MATRIX; r: fixed); cdecl;
  get_x_rotate_matrix_f: procedure(m: P_MATRIX_f; r: single); cdecl;

  get_y_rotate_matrix: procedure(m: P_MATRIX; r: fixed); cdecl;
  get_y_rotate_matrix_f: procedure(m: P_MATRIX_f; r: single); cdecl;

  get_z_rotate_matrix: procedure(m: P_MATRIX; r: fixed); cdecl;
  get_z_rotate_matrix_f: procedure(m: P_MATRIX_f; r: single); cdecl;

  get_rotation_matrix: procedure(m: P_MATRIX; x, y, z: fixed); cdecl;
  get_rotation_matrix_f: procedure(m: P_MATRIX_f; x, y, z: single); cdecl;

  get_align_matrix: procedure(m: P_MATRIX; xfront, yfront, zfront, xup, yup, zup: fixed); cdecl;
  get_align_matrix_f: procedure(m: P_MATRIX_f; xfront, yfront, zfront, xup, yup, zup: single); cdecl;

  get_vector_rotation_matrix: procedure(m: P_MATRIX; x, y, z, a: fixed); cdecl;
  get_vector_rotation_matrix_f: procedure(m: P_MATRIX_f; x, y, z, a: single); cdecl;

  get_transformation_matrix: procedure(m: P_MATRIX; scale, xrot, yrot, zrot, x, y, z: fixed); cdecl;
  get_transformation_matrix_f: procedure(m: P_MATRIX_f; scale, xrot, yrot, zrot, x, y, z: single); cdecl;

  get_camera_matrix: procedure(m: P_MATRIX; x, y, z, xfront, yfront, zfront, xup, yup, zup, fov, aspect: fixed); cdecl;
  get_camera_matrix_f: procedure(m: P_MATRIX_f; x, y, z, xfront, yfront, zfront, xup, yup, zup, fov, aspect: single); cdecl;

  qtranslate_matrix: procedure(m: P_MATRIX; x, y, z: fixed); cdecl;
  qtranslate_matrix_f: procedure(m: P_MATRIX_f; x, y, z: single); cdecl;

  qscale_matrix: procedure(m: P_MATRIX; scale: fixed); cdecl;
  qscale_matrix_f: procedure(m: P_MATRIX_f; scale: single); cdecl;

  matrix_mul: procedure(const m1, m2: P_MATRIX; outm: P_MATRIX); cdecl;
  matrix_mul_f: procedure(const m1, m2: P_MATRIX_f; outm: P_MATRIX_f); cdecl;

  apply_matrix_f: procedure(const m: P_MATRIX_f; x, y, z: single; xout, yout, zout: single); cdecl;
{$ENDIF ALLEGRO_INTERFACE}
{$IFDEF ALLEGRO_IMPLEMENTATION}
{$ENDIF ALLEGRO_IMPLEMENTATION}
{$IFDEF ALLEGRO_LOADVARIABLE}
  identity_matrix              := LoadDLL('identity_matrix');
  identity_matrix_f            := LoadDLL('identity_matrix_f');
  get_translation_matrix       := LoadDLL('get_translation_matrix');
  get_translation_matrix_f     := LoadDLL('get_translation_matrix_f');
  get_scaling_matrix           := LoadDLL('get_scaling_matrix');
  get_scaling_matrix_f         := LoadDLL('get_scaling_matrix_f');
  get_x_rotate_matrix          := LoadDLL('get_x_rotate_matrix');
  get_x_rotate_matrix_f        := LoadDLL('get_x_rotate_matrix_f');
  get_y_rotate_matrix          := LoadDLL('get_y_rotate_matrix');
  get_y_rotate_matrix_f        := LoadDLL('get_y_rotate_matrix_f');
  get_z_rotate_matrix          := LoadDLL('get_z_rotate_matrix');
  get_z_rotate_matrix_f        := LoadDLL('get_z_rotate_matrix_f');
  get_rotation_matrix          := LoadDLL('get_rotation_matrix');
  get_rotation_matrix_f        := LoadDLL('get_rotation_matrix_f');
  get_align_matrix             := LoadDLL('get_align_matrix');
  get_align_matrix_f           := LoadDLL('get_align_matrix_f');
  get_vector_rotation_matrix   := LoadDLL('get_vector_rotation_matrix');
  get_vector_rotation_matrix_f := LoadDLL('get_vector_rotation_matrix_f');
  get_transformation_matrix    := LoadDLL('get_transformation_matrix');
  get_transformation_matrix_f  := LoadDLL('get_transformation_matrix_f');
  get_camera_matrix            := LoadDLL('get_camera_matrix');
  get_camera_matrix_f          := LoadDLL('get_camera_matrix_f');
  qtranslate_matrix            := LoadDLL('qtranslate_matrix');
  qtranslate_matrix_f          := LoadDLL('qtranslate_matrix_f');
  qscale_matrix                := LoadDLL('qscale_matrix');
  qscale_matrix_f              := LoadDLL('qscale_matrix_f');
  matrix_mul                   := LoadDLL('matrix_mul');
  matrix_mul_f                 := LoadDLL('matrix_mul_f');
  apply_matrix_f               := LoadDLL('apply_matrix_f');
{$ENDIF ALLEGRO_LOADVARIABLE}