+ Add a matrix unit I wrote some time ago

This commit is contained in:
daniel 2004-07-07 14:12:51 +00:00
parent cf5c3b77c2
commit 1b36a0b437
3 changed files with 2095 additions and 0 deletions

811
rtl/inc/matrix.pp Normal file
View File

@ -0,0 +1,811 @@
unit matrix;
{
$Id$
This file is part of the Free Pascal run time library.
Copyright (c) 2004 by Daniel Mantione
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{*****************************************************************************}
interface
{*****************************************************************************}
{$MACRO on}
type Tvector2_single_data=array[0..1] of single;
Tvector2_double_data=array[0..1] of double;
Tvector2_extended_data=array[0..1] of extended;
Tvector3_single_data=array[0..2] of single;
Tvector3_double_data=array[0..2] of double;
Tvector3_extended_data=array[0..2] of extended;
Tvector4_single_data=array[0..3] of single;
Tvector4_double_data=array[0..3] of double;
Tvector4_extended_data=array[0..3] of extended;
Tmatrix2_single_data=array[0..1,0..1] of single;
Tmatrix2_double_data=array[0..1,0..1] of double;
Tmatrix2_extended_data=array[0..1,0..1] of extended;
Tmatrix3_single_data=array[0..2,0..2] of single;
Tmatrix3_double_data=array[0..2,0..2] of double;
Tmatrix3_extended_data=array[0..2,0..2] of extended;
Tmatrix4_single_data=array[0..3,0..3] of single;
Tmatrix4_double_data=array[0..3,0..3] of double;
Tmatrix4_extended_data=array[0..3,0..3] of extended;
Tvector2_single=object
data:Tvector2_single_data;
constructor init_zero;
constructor init_one;
constructor init(a,b:single);
function length:single;
function squared_length:single;
end;
Tvector2_double=object
data:Tvector2_double_data;
constructor init_zero;
constructor init_one;
constructor init(a,b:double);
function length:double;
function squared_length:double;
end;
Tvector2_extended=object
data:Tvector2_extended_data;
constructor init_zero;
constructor init_one;
constructor init(a,b:extended);
function length:extended;
function squared_length:extended;
end;
Tvector3_single=object
data:Tvector3_single_data;
constructor init_zero;
constructor init_one;
constructor init(a,b,c:single);
function length:single;
function squared_length:single;
end;
Tvector3_double=object
data:Tvector3_double_data;
constructor init_zero;
constructor init_one;
constructor init(a,b,c:double);
function length:double;
function squared_length:double;
end;
Tvector3_extended=object
data:Tvector3_extended_data;
constructor init_zero;
constructor init_one;
constructor init(a,b,c:extended);
function length:extended;
function squared_length:extended;
end;
Tvector4_single=object
data:Tvector4_single_data;
constructor init_zero;
constructor init_one;
constructor init(a,b,c,d:single);
function length:single;
function squared_length:single;
end;
Tvector4_double=object
data:Tvector4_double_data;
constructor init_zero;
constructor init_one;
constructor init(a,b,c,d:double);
function length:double;
function squared_length:double;
end;
Tvector4_extended=object
data:Tvector4_extended_data;
constructor init_zero;
constructor init_one;
constructor init(a,b,c,d:extended);
function length:extended;
function squared_length:extended;
end;
Tmatrix2_single=object
data:Tmatrix2_single_data;
constructor init_zero;
constructor init_identity;
constructor init(aa,ab,ba,bb:single);
function get_column(c:byte):Tvector2_single;
function get_row(r:byte):Tvector2_single;
procedure set_column(c:byte;const v:Tvector2_single);
procedure set_row(r:byte;const v:Tvector2_single);
function determinant:single;
function inverse(Adeterminant:single):Tmatrix2_single;
function transpose:Tmatrix2_single;
end;
Tmatrix2_double=object
data:Tmatrix2_double_data;
constructor init_zero;
constructor init_identity;
constructor init(aa,ab,ba,bb:double);
function get_column(c:byte):Tvector2_double;
function get_row(r:byte):Tvector2_double;
procedure set_column(c:byte;const v:Tvector2_double);
procedure set_row(r:byte;const v:Tvector2_double);
function determinant:double;
function inverse(Adeterminant:double):Tmatrix2_double;
function transpose:Tmatrix2_double;
end;
Tmatrix2_extended=object
data:Tmatrix2_extended_data;
constructor init_zero;
constructor init_identity;
constructor init(aa,ab,ba,bb:extended);
function get_column(c:byte):Tvector2_extended;
function get_row(r:byte):Tvector2_extended;
procedure set_column(c:byte;const v:Tvector2_extended);
procedure set_row(r:byte;const v:Tvector2_extended);
function determinant:extended;
function inverse(Adeterminant:extended):Tmatrix2_extended;
function transpose:Tmatrix2_extended;
end;
Tmatrix3_single=object
data:Tmatrix3_single_data;
constructor init_zero;
constructor init_identity;
constructor init(aa,ab,ac,ba,bb,bc,ca,cb,cc:single);
function get_column(c:byte):Tvector3_single;
function get_row(r:byte):Tvector3_single;
procedure set_column(c:byte;const v:Tvector3_single);
procedure set_row(r:byte;const v:Tvector3_single);
function determinant:single;
function inverse(Adeterminant:single):Tmatrix3_single;
function transpose:Tmatrix3_single;
end;
Tmatrix3_double=object
data:Tmatrix3_double_data;
constructor init_zero;
constructor init_identity;
constructor init(aa,ab,ac,ba,bb,bc,ca,cb,cc:double);
function get_column(c:byte):Tvector3_double;
function get_row(r:byte):Tvector3_double;
procedure set_column(c:byte;const v:Tvector3_double);
procedure set_row(r:byte;const v:Tvector3_double);
function determinant:double;
function inverse(Adeterminant:double):Tmatrix3_double;
function transpose:Tmatrix3_double;
end;
Tmatrix3_extended=object
data:Tmatrix3_extended_data;
constructor init_zero;
constructor init_identity;
constructor init(aa,ab,ac,ba,bb,bc,ca,cb,cc:extended);
function get_column(c:byte):Tvector3_extended;
function get_row(r:byte):Tvector3_extended;
procedure set_column(c:byte;const v:Tvector3_extended);
procedure set_row(r:byte;const v:Tvector3_extended);
function determinant:extended;
function inverse(Adeterminant:extended):Tmatrix3_extended;
function transpose:Tmatrix3_extended;
end;
Tmatrix4_single=object
data:Tmatrix4_single_data;
constructor init_zero;
constructor init_identity;
constructor init(aa,ab,ac,ad,ba,bb,bc,bd,ca,cb,cc,cd,da,db,dc,dd:single);
function get_column(c:byte):Tvector4_single;
function get_row(r:byte):Tvector4_single;
procedure set_column(c:byte;const v:Tvector4_single);
procedure set_row(r:byte;const v:Tvector4_single);
function determinant:single;
function inverse(Adeterminant:single):Tmatrix4_single;
function transpose:Tmatrix4_single;
end;
Tmatrix4_double=object
data:Tmatrix4_double_data;
constructor init_zero;
constructor init_identity;
constructor init(aa,ab,ac,ad,ba,bb,bc,bd,ca,cb,cc,cd,da,db,dc,dd:double);
function get_column(c:byte):Tvector4_double;
function get_row(r:byte):Tvector4_double;
procedure set_column(c:byte;const v:Tvector4_double);
procedure set_row(r:byte;const v:Tvector4_double);
function determinant:double;
function inverse(Adeterminant:double):Tmatrix4_double;
function transpose:Tmatrix4_double;
end;
Tmatrix4_extended=object
data:Tmatrix4_extended_data;
constructor init_zero;
constructor init_identity;
constructor init(aa,ab,ac,ad,ba,bb,bc,bd,ca,cb,cc,cd,da,db,dc,dd:extended);
function get_column(c:byte):Tvector4_extended;
function get_row(r:byte):Tvector4_extended;
procedure set_column(c:byte;const v:Tvector4_extended);
procedure set_row(r:byte;const v:Tvector4_extended);
function determinant:extended;
function inverse(Adeterminant:extended):Tmatrix4_extended;
function transpose:Tmatrix4_extended;
end;
{Operators to make different vectors assignable to each other}
operator := (const v:Tvector2_single) result:Tvector2_double;
operator := (const v:Tvector2_single) result:Tvector2_extended;
operator := (const v:Tvector2_double) result:Tvector2_single;
operator := (const v:Tvector2_double) result:Tvector2_extended;
operator := (const v:Tvector2_extended) result:Tvector2_single;
operator := (const v:Tvector2_extended) result:Tvector2_double;
operator := (const v:Tvector2_single) result:Tvector3_single;
operator := (const v:Tvector2_single) result:Tvector3_double;
operator := (const v:Tvector2_single) result:Tvector3_extended;
operator := (const v:Tvector2_double) result:Tvector3_single;
operator := (const v:Tvector2_double) result:Tvector3_double;
operator := (const v:Tvector2_double) result:Tvector3_extended;
operator := (const v:Tvector2_extended) result:Tvector3_single;
operator := (const v:Tvector2_extended) result:Tvector3_double;
operator := (const v:Tvector2_extended) result:Tvector3_extended;
operator := (const v:Tvector2_single) result:Tvector4_single;
operator := (const v:Tvector2_single) result:Tvector4_double;
operator := (const v:Tvector2_single) result:Tvector4_extended;
operator := (const v:Tvector2_double) result:Tvector4_single;
operator := (const v:Tvector2_double) result:Tvector4_double;
operator := (const v:Tvector2_double) result:Tvector4_extended;
operator := (const v:Tvector2_extended) result:Tvector4_single;
operator := (const v:Tvector2_extended) result:Tvector4_double;
operator := (const v:Tvector2_extended) result:Tvector4_extended;
operator := (const v:Tvector3_single) result:Tvector2_single;
operator := (const v:Tvector3_single) result:Tvector2_double;
operator := (const v:Tvector3_single) result:Tvector2_extended;
operator := (const v:Tvector3_double) result:Tvector2_single;
operator := (const v:Tvector3_double) result:Tvector2_double;
operator := (const v:Tvector3_double) result:Tvector2_extended;
operator := (const v:Tvector3_extended) result:Tvector2_single;
operator := (const v:Tvector3_extended) result:Tvector2_double;
operator := (const v:Tvector3_extended) result:Tvector2_extended;
operator := (const v:Tvector3_single) result:Tvector3_double;
operator := (const v:Tvector3_single) result:Tvector3_extended;
operator := (const v:Tvector3_double) result:Tvector3_single;
operator := (const v:Tvector3_double) result:Tvector3_extended;
operator := (const v:Tvector3_extended) result:Tvector3_single;
operator := (const v:Tvector3_extended) result:Tvector3_double;
operator := (const v:Tvector3_single) result:Tvector4_single;
operator := (const v:Tvector3_single) result:Tvector4_double;
operator := (const v:Tvector3_single) result:Tvector4_extended;
operator := (const v:Tvector3_double) result:Tvector4_single;
operator := (const v:Tvector3_double) result:Tvector4_double;
operator := (const v:Tvector3_double) result:Tvector4_extended;
operator := (const v:Tvector3_extended) result:Tvector4_single;
operator := (const v:Tvector3_extended) result:Tvector4_double;
operator := (const v:Tvector3_extended) result:Tvector4_extended;
operator := (const v:Tvector4_single) result:Tvector2_single;
operator := (const v:Tvector4_single) result:Tvector2_double;
operator := (const v:Tvector4_single) result:Tvector2_extended;
operator := (const v:Tvector4_double) result:Tvector2_single;
operator := (const v:Tvector4_double) result:Tvector2_double;
operator := (const v:Tvector4_double) result:Tvector2_extended;
operator := (const v:Tvector4_extended) result:Tvector2_single;
operator := (const v:Tvector4_extended) result:Tvector2_double;
operator := (const v:Tvector4_extended) result:Tvector2_extended;
operator := (const v:Tvector4_single) result:Tvector3_single;
operator := (const v:Tvector4_single) result:Tvector3_double;
operator := (const v:Tvector4_single) result:Tvector3_extended;
operator := (const v:Tvector4_double) result:Tvector3_single;
operator := (const v:Tvector4_double) result:Tvector3_double;
operator := (const v:Tvector4_double) result:Tvector3_extended;
operator := (const v:Tvector4_extended) result:Tvector3_single;
operator := (const v:Tvector4_extended) result:Tvector3_double;
operator := (const v:Tvector4_extended) result:Tvector3_extended;
operator := (const v:Tvector4_single) result:Tvector4_double;
operator := (const v:Tvector4_single) result:Tvector4_extended;
operator := (const v:Tvector4_double) result:Tvector4_single;
operator := (const v:Tvector4_double) result:Tvector4_extended;
operator := (const v:Tvector4_extended) result:Tvector4_single;
operator := (const v:Tvector4_extended) result:Tvector4_double;
{Vector to vector operations.}
operator + (const x,y:Tvector2_single) result:Tvector2_single;
operator + (const x,y:Tvector2_double) result:Tvector2_double;
operator + (const x,y:Tvector2_extended) result:Tvector2_extended;
operator + (const x,y:Tvector3_single) result:Tvector3_single;
operator + (const x,y:Tvector3_double) result:Tvector3_double;
operator + (const x,y:Tvector3_extended) result:Tvector3_extended;
operator + (const x,y:Tvector4_single) result:Tvector4_single;
operator + (const x,y:Tvector4_double) result:Tvector4_double;
operator + (const x,y:Tvector4_extended) result:Tvector4_extended;
operator - (const x,y:Tvector2_single) result:Tvector2_single;
operator - (const x,y:Tvector2_double) result:Tvector2_double;
operator - (const x,y:Tvector2_extended) result:Tvector2_extended;
operator - (const x,y:Tvector3_single) result:Tvector3_single;
operator - (const x,y:Tvector3_double) result:Tvector3_double;
operator - (const x,y:Tvector3_extended) result:Tvector3_extended;
operator - (const x,y:Tvector4_single) result:Tvector4_single;
operator - (const x,y:Tvector4_double) result:Tvector4_double;
operator - (const x,y:Tvector4_extended) result:Tvector4_extended;
operator - (const x:Tvector2_single) result:Tvector2_single;
operator - (const x:Tvector2_double) result:Tvector2_double;
operator - (const x:Tvector2_extended) result:Tvector2_extended;
operator - (const x:Tvector3_single) result:Tvector3_single;
operator - (const x:Tvector3_double) result:Tvector3_double;
operator - (const x:Tvector3_extended) result:Tvector3_extended;
operator - (const x:Tvector4_single) result:Tvector4_single;
operator - (const x:Tvector4_double) result:Tvector4_double;
operator - (const x:Tvector4_extended) result:Tvector4_extended;
operator * (const x,y:Tvector2_single) result:Tvector2_single;
operator * (const x,y:Tvector2_double) result:Tvector2_double;
operator * (const x,y:Tvector2_extended) result:Tvector2_extended;
operator * (const x,y:Tvector3_single) result:Tvector3_single;
operator * (const x,y:Tvector3_double) result:Tvector3_double;
operator * (const x,y:Tvector3_extended) result:Tvector3_extended;
operator * (const x,y:Tvector4_single) result:Tvector4_single;
operator * (const x,y:Tvector4_double) result:Tvector4_double;
operator * (const x,y:Tvector4_extended) result:Tvector4_extended;
operator ** (const x,y:Tvector2_single) result:single;
operator ** (const x,y:Tvector2_double) result:double;
operator ** (const x,y:Tvector2_extended) result:extended;
operator ** (const x,y:Tvector3_single) result:single;
operator ** (const x,y:Tvector3_double) result:double;
operator ** (const x,y:Tvector3_extended) result:extended;
operator ** (const x,y:Tvector4_single) result:single;
operator ** (const x,y:Tvector4_double) result:double;
operator ** (const x,y:Tvector4_extended) result:extended;
operator >< (const x,y:Tvector3_single) result:Tvector3_single;
operator >< (const x,y:Tvector3_double) result:Tvector3_double;
operator >< (const x,y:Tvector3_extended) result:Tvector3_extended;
{Vector/scalar operations.}
operator + (const x:Tvector2_single;y:single) result:Tvector2_single;
operator + (const x:Tvector2_double;y:double) result:Tvector2_double;
operator + (const x:Tvector2_extended;y:extended) result:Tvector2_extended;
operator + (const x:Tvector3_single;y:single) result:Tvector3_single;
operator + (const x:Tvector3_double;y:double) result:Tvector3_double;
operator + (const x:Tvector3_extended;y:extended) result:Tvector3_extended;
operator + (const x:Tvector4_single;y:single) result:Tvector4_single;
operator + (const x:Tvector4_double;y:double) result:Tvector4_double;
operator + (const x:Tvector4_extended;y:extended) result:Tvector4_extended;
operator - (const x:Tvector2_single;y:single) result:Tvector2_single;
operator - (const x:Tvector2_double;y:double) result:Tvector2_double;
operator - (const x:Tvector2_extended;y:extended) result:Tvector2_extended;
operator - (const x:Tvector3_single;y:single) result:Tvector3_single;
operator - (const x:Tvector3_double;y:double) result:Tvector3_double;
operator - (const x:Tvector3_extended;y:extended) result:Tvector3_extended;
operator - (const x:Tvector4_single;y:single) result:Tvector4_single;
operator - (const x:Tvector4_double;y:double) result:Tvector4_double;
operator - (const x:Tvector4_extended;y:extended) result:Tvector4_extended;
operator * (const x:Tvector2_single;y:single) result:Tvector2_single;
operator * (const x:Tvector2_double;y:double) result:Tvector2_double;
operator * (const x:Tvector2_extended;y:extended) result:Tvector2_extended;
operator * (const x:Tvector3_single;y:single) result:Tvector3_single;
operator * (const x:Tvector3_double;y:double) result:Tvector3_double;
operator * (const x:Tvector3_extended;y:extended) result:Tvector3_extended;
operator * (const x:Tvector4_single;y:single) result:Tvector4_single;
operator * (const x:Tvector4_double;y:double) result:Tvector4_double;
operator * (const x:Tvector4_extended;y:extended) result:Tvector4_extended;
operator / (const x:Tvector2_single;y:single) result:Tvector2_single;
operator / (const x:Tvector2_double;y:double) result:Tvector2_double;
operator / (const x:Tvector2_extended;y:extended) result:Tvector2_extended;
operator / (const x:Tvector3_single;y:single) result:Tvector3_single;
operator / (const x:Tvector3_double;y:double) result:Tvector3_double;
operator / (const x:Tvector3_extended;y:extended) result:Tvector3_extended;
operator / (const x:Tvector4_single;y:single) result:Tvector4_single;
operator / (const x:Tvector4_double;y:double) result:Tvector4_double;
operator / (const x:Tvector4_extended;y:extended) result:Tvector4_extended;
{Operators to make different matrixes assignable to each other}
operator := (const v:Tmatrix2_single) result:Tmatrix2_double;
operator := (const v:Tmatrix2_single) result:Tmatrix2_extended;
operator := (const v:Tmatrix2_double) result:Tmatrix2_single;
operator := (const v:Tmatrix2_double) result:Tmatrix2_extended;
operator := (const v:Tmatrix2_extended) result:Tmatrix2_single;
operator := (const v:Tmatrix2_extended) result:Tmatrix2_double;
operator := (const v:Tmatrix2_single) result:Tmatrix3_single;
operator := (const v:Tmatrix2_single) result:Tmatrix3_double;
operator := (const v:Tmatrix2_single) result:Tmatrix3_extended;
operator := (const v:Tmatrix2_double) result:Tmatrix3_single;
operator := (const v:Tmatrix2_double) result:Tmatrix3_double;
operator := (const v:Tmatrix2_double) result:Tmatrix3_extended;
operator := (const v:Tmatrix2_extended) result:Tmatrix3_single;
operator := (const v:Tmatrix2_extended) result:Tmatrix3_double;
operator := (const v:Tmatrix2_extended) result:Tmatrix3_extended;
operator := (const v:Tmatrix2_single) result:Tmatrix4_single;
operator := (const v:Tmatrix2_single) result:Tmatrix4_double;
operator := (const v:Tmatrix2_single) result:Tmatrix4_extended;
operator := (const v:Tmatrix2_double) result:Tmatrix4_single;
operator := (const v:Tmatrix2_double) result:Tmatrix4_double;
operator := (const v:Tmatrix2_double) result:Tmatrix4_extended;
operator := (const v:Tmatrix2_extended) result:Tmatrix4_single;
operator := (const v:Tmatrix2_extended) result:Tmatrix4_double;
operator := (const v:Tmatrix2_extended) result:Tmatrix4_extended;
operator := (const v:Tmatrix3_single) result:Tmatrix2_single;
operator := (const v:Tmatrix3_single) result:Tmatrix2_double;
operator := (const v:Tmatrix3_single) result:Tmatrix2_extended;
operator := (const v:Tmatrix3_double) result:Tmatrix2_single;
operator := (const v:Tmatrix3_double) result:Tmatrix2_double;
operator := (const v:Tmatrix3_double) result:Tmatrix2_extended;
operator := (const v:Tmatrix3_extended) result:Tmatrix2_single;
operator := (const v:Tmatrix3_extended) result:Tmatrix2_double;
operator := (const v:Tmatrix3_extended) result:Tmatrix2_extended;
operator := (const v:Tmatrix3_single) result:Tmatrix3_double;
operator := (const v:Tmatrix3_single) result:Tmatrix3_extended;
operator := (const v:Tmatrix3_double) result:Tmatrix3_single;
operator := (const v:Tmatrix3_double) result:Tmatrix3_extended;
operator := (const v:Tmatrix3_extended) result:Tmatrix3_single;
operator := (const v:Tmatrix3_extended) result:Tmatrix3_double;
operator := (const v:Tmatrix3_single) result:Tmatrix4_single;
operator := (const v:Tmatrix3_single) result:Tmatrix4_double;
operator := (const v:Tmatrix3_single) result:Tmatrix4_extended;
operator := (const v:Tmatrix3_double) result:Tmatrix4_single;
operator := (const v:Tmatrix3_double) result:Tmatrix4_double;
operator := (const v:Tmatrix3_double) result:Tmatrix4_extended;
operator := (const v:Tmatrix3_extended) result:Tmatrix4_single;
operator := (const v:Tmatrix3_extended) result:Tmatrix4_double;
operator := (const v:Tmatrix3_extended) result:Tmatrix4_extended;
operator := (const v:Tmatrix4_single) result:Tmatrix2_single;
operator := (const v:Tmatrix4_single) result:Tmatrix2_double;
operator := (const v:Tmatrix4_single) result:Tmatrix2_extended;
operator := (const v:Tmatrix4_double) result:Tmatrix2_single;
operator := (const v:Tmatrix4_double) result:Tmatrix2_double;
operator := (const v:Tmatrix4_double) result:Tmatrix2_extended;
operator := (const v:Tmatrix4_extended) result:Tmatrix2_single;
operator := (const v:Tmatrix4_extended) result:Tmatrix2_double;
operator := (const v:Tmatrix4_extended) result:Tmatrix2_extended;
operator := (const v:Tmatrix4_single) result:Tmatrix3_single;
operator := (const v:Tmatrix4_single) result:Tmatrix3_double;
operator := (const v:Tmatrix4_single) result:Tmatrix3_extended;
operator := (const v:Tmatrix4_double) result:Tmatrix3_single;
operator := (const v:Tmatrix4_double) result:Tmatrix3_double;
operator := (const v:Tmatrix4_double) result:Tmatrix3_extended;
operator := (const v:Tmatrix4_extended) result:Tmatrix3_single;
operator := (const v:Tmatrix4_extended) result:Tmatrix3_double;
operator := (const v:Tmatrix4_extended) result:Tmatrix3_extended;
operator := (const v:Tmatrix4_single) result:Tmatrix4_double;
operator := (const v:Tmatrix4_single) result:Tmatrix4_extended;
operator := (const v:Tmatrix4_double) result:Tmatrix4_single;
operator := (const v:Tmatrix4_double) result:Tmatrix4_extended;
operator := (const v:Tmatrix4_extended) result:Tmatrix4_single;
operator := (const v:Tmatrix4_extended) result:Tmatrix4_double;
{Matrix to matrix operatons.}
operator + (const m1,m2:Tmatrix2_single) result:Tmatrix2_single;
operator + (const m1,m2:Tmatrix2_double) result:Tmatrix2_double;
operator + (const m1,m2:Tmatrix2_extended) result:Tmatrix2_extended;
operator + (const m1,m2:Tmatrix3_single) result:Tmatrix3_single;
operator + (const m1,m2:Tmatrix3_double) result:Tmatrix3_double;
operator + (const m1,m2:Tmatrix3_extended) result:Tmatrix3_extended;
operator + (const m1,m2:Tmatrix4_single) result:Tmatrix4_single;
operator + (const m1,m2:Tmatrix4_double) result:Tmatrix4_double;
operator + (const m1,m2:Tmatrix4_extended) result:Tmatrix4_extended;
operator - (const m1,m2:Tmatrix2_single) result:Tmatrix2_single;
operator - (const m1,m2:Tmatrix2_double) result:Tmatrix2_double;
operator - (const m1,m2:Tmatrix2_extended) result:Tmatrix2_extended;
operator - (const m1,m2:Tmatrix3_single) result:Tmatrix3_single;
operator - (const m1,m2:Tmatrix3_double) result:Tmatrix3_double;
operator - (const m1,m2:Tmatrix3_extended) result:Tmatrix3_extended;
operator - (const m1,m2:Tmatrix4_single) result:Tmatrix4_single;
operator - (const m1,m2:Tmatrix4_double) result:Tmatrix4_double;
operator - (const m1,m2:Tmatrix4_extended) result:Tmatrix4_extended;
operator - (const m1:Tmatrix2_single) result:Tmatrix2_single;
operator - (const m1:Tmatrix2_double) result:Tmatrix2_double;
operator - (const m1:Tmatrix2_extended) result:Tmatrix2_extended;
operator - (const m1:Tmatrix3_single) result:Tmatrix3_single;
operator - (const m1:Tmatrix3_double) result:Tmatrix3_double;
operator - (const m1:Tmatrix3_extended) result:Tmatrix3_extended;
operator - (const m1:Tmatrix4_single) result:Tmatrix4_single;
operator - (const m1:Tmatrix4_double) result:Tmatrix4_double;
operator - (const m1:Tmatrix4_extended) result:Tmatrix4_extended;
operator * (const m1,m2:Tmatrix2_single) result:Tmatrix2_single;
operator * (const m1,m2:Tmatrix2_double) result:Tmatrix2_double;
operator * (const m1,m2:Tmatrix2_extended) result:Tmatrix2_extended;
operator * (const m1,m2:Tmatrix3_single) result:Tmatrix3_single;
operator * (const m1,m2:Tmatrix3_double) result:Tmatrix3_double;
operator * (const m1,m2:Tmatrix3_extended) result:Tmatrix3_extended;
operator * (const m1,m2:Tmatrix4_single) result:Tmatrix4_single;
operator * (const m1,m2:Tmatrix4_double) result:Tmatrix4_double;
operator * (const m1,m2:Tmatrix4_extended) result:Tmatrix4_extended;
{Matrix/vector operations}
operator * (const m:Tmatrix2_single;const v:Tvector2_single) result:Tvector2_single;
operator * (const m:Tmatrix2_double;const v:Tvector2_double) result:Tvector2_double;
operator * (const m:Tmatrix2_extended;const v:Tvector2_extended) result:Tvector2_extended;
operator * (const m:Tmatrix3_single;const v:Tvector3_single) result:Tvector3_single;
operator * (const m:Tmatrix3_double;const v:Tvector3_double) result:Tvector3_double;
operator * (const m:Tmatrix3_extended;const v:Tvector3_extended) result:Tvector3_extended;
operator * (const m:Tmatrix4_single;const v:Tvector4_single) result:Tvector4_single;
operator * (const m:Tmatrix4_double;const v:Tvector4_double) result:Tvector4_double;
operator * (const m:Tmatrix4_extended;const v:Tvector4_extended) result:Tvector4_extended;
{Matrix/scalar operations}
operator + (const m:Tmatrix2_single;const x:single) result:Tmatrix2_single;
operator + (const m:Tmatrix2_double;const x:double) result:Tmatrix2_double;
operator + (const m:Tmatrix2_extended;const x:extended) result:Tmatrix2_extended;
operator + (const m:Tmatrix3_single;const x:single) result:Tmatrix3_single;
operator + (const m:Tmatrix3_double;const x:double) result:Tmatrix3_double;
operator + (const m:Tmatrix3_extended;const x:extended) result:Tmatrix3_extended;
operator + (const m:Tmatrix4_single;const x:single) result:Tmatrix4_single;
operator + (const m:Tmatrix4_double;const x:double) result:Tmatrix4_double;
operator + (const m:Tmatrix4_extended;const x:extended) result:Tmatrix4_extended;
operator - (const m:Tmatrix2_single;const x:single) result:Tmatrix2_single;
operator - (const m:Tmatrix2_double;const x:double) result:Tmatrix2_double;
operator - (const m:Tmatrix2_extended;const x:extended) result:Tmatrix2_extended;
operator - (const m:Tmatrix3_single;const x:single) result:Tmatrix3_single;
operator - (const m:Tmatrix3_double;const x:double) result:Tmatrix3_double;
operator - (const m:Tmatrix3_extended;const x:extended) result:Tmatrix3_extended;
operator - (const m:Tmatrix4_single;const x:single) result:Tmatrix4_single;
operator - (const m:Tmatrix4_double;const x:double) result:Tmatrix4_double;
operator - (const m:Tmatrix4_extended;const x:extended) result:Tmatrix4_extended;
operator * (const m:Tmatrix2_single;const x:single) result:Tmatrix2_single;
operator * (const m:Tmatrix2_double;const x:double) result:Tmatrix2_double;
operator * (const m:Tmatrix2_extended;const x:extended) result:Tmatrix2_extended;
operator * (const m:Tmatrix3_single;const x:single) result:Tmatrix3_single;
operator * (const m:Tmatrix3_double;const x:double) result:Tmatrix3_double;
operator * (const m:Tmatrix3_extended;const x:extended) result:Tmatrix3_extended;
operator * (const m:Tmatrix4_single;const x:single) result:Tmatrix4_single;
operator * (const m:Tmatrix4_double;const x:double) result:Tmatrix4_double;
operator * (const m:Tmatrix4_extended;const x:extended) result:Tmatrix4_extended;
operator / (const m:Tmatrix2_single;const x:single) result:Tmatrix2_single;
operator / (const m:Tmatrix2_double;const x:double) result:Tmatrix2_double;
operator / (const m:Tmatrix2_extended;const x:extended) result:Tmatrix2_extended;
operator / (const m:Tmatrix3_single;const x:single) result:Tmatrix3_single;
operator / (const m:Tmatrix3_double;const x:double) result:Tmatrix3_double;
operator / (const m:Tmatrix3_extended;const x:extended) result:Tmatrix3_extended;
operator / (const m:Tmatrix4_single;const x:single) result:Tmatrix4_single;
operator / (const m:Tmatrix4_double;const x:double) result:Tmatrix4_double;
operator / (const m:Tmatrix4_extended;const x:extended) result:Tmatrix4_extended;
{*****************************************************************************}
implementation
{*****************************************************************************}
{******************************************************************************
Tvector2_single
******************************************************************************}
{Need to use capitals due to bug in FPC. Bug was fixed in FPC 1.9.3 on
10 Feb. 2004}
{$DEFINE datatype:=SINGLE}
{$DEFINE objectname:=Tvector2_single}
{$DEFINE vecsize:=2}
{$INFO Compile mvecimp.inc for Tvector2_single}
{$i mvecimp.inc}
{******************************************************************************
Tvector2_double
******************************************************************************}
{$DEFINE datatype:=DOUBLE}
{$DEFINE objectname:=Tvector2_double}
{$DEFINE vecsize:=2}
{$INFO Compile mvecimp.inc for Tvector2_double}
{$i mvecimp.inc}
{******************************************************************************
Tvector2_extended
******************************************************************************}
{$DEFINE datatype:=EXTENDED}
{$DEFINE objectname:=Tvector2_extended}
{$DEFINE vecsize:=2}
{$INFO Compile mvecimp.inc for Tvector2_extended}
{$i mvecimp.inc}
{******************************************************************************
Tvector3_single
******************************************************************************}
{Need to use capitals due to bug in FPC. Bug was fixed in FPC 1.9.3 on
10 Feb. 2004}
{$DEFINE datatype:=SINGLE}
{$DEFINE objectname:=Tvector3_single}
{$DEFINE vecsize:=3}
{$INFO Compile mvecimp.inc for Tvector3_single}
{$i mvecimp.inc}
{******************************************************************************
Tvector3_double
******************************************************************************}
{$DEFINE datatype:=DOUBLE}
{$DEFINE objectname:=Tvector3_double}
{$DEFINE vecsize:=3}
{$INFO Compile mvecimp.inc for Tvector3_double}
{$i mvecimp.inc}
{******************************************************************************
Tvector3_extended
******************************************************************************}
{$DEFINE datatype:=EXTENDED}
{$DEFINE objectname:=Tvector3_extended}
{$DEFINE vecsize:=3}
{$INFO Compile mvecimp.inc for Tvector3_extended}
{$i mvecimp.inc}
{******************************************************************************
Tvector4_single
******************************************************************************}
{Need to use capitals due to bug in FPC. Bug was fixed in FPC 1.9.3 on
10 Feb. 2004}
{$DEFINE datatype:=SINGLE}
{$DEFINE objectname:=Tvector4_single}
{$DEFINE vecsize:=4}
{$INFO Compile mvecimp.inc for Tvector4_single}
{$i mvecimp.inc}
{******************************************************************************
Tvector4_double
******************************************************************************}
{$DEFINE datatype:=DOUBLE}
{$DEFINE objectname:=Tvector4_double}
{$DEFINE vecsize:=4}
{$INFO Compile mvecimp.inc for Tvector4_double}
{$i mvecimp.inc}
{******************************************************************************
Tvector4_extended
******************************************************************************}
{$DEFINE datatype:=EXTENDED}
{$DEFINE objectname:=Tvector4_extended}
{$DEFINE vecsize:=4}
{$INFO Compile mvecimp.inc for Tvector4_extended}
{$i mvecimp.inc}
{******************************************************************************
Tmatrix2_single
******************************************************************************}
{$DEFINE datatype:=SINGLE}
{$DEFINE objectname:=Tmatrix2_single}
{$DEFINE vectorcompanion:=Tvector2_single}
{$DEFINE matsize:=2}
{$INFO Compile mmatimp.inc for Tmatrix2_single}
{$i mmatimp.inc}
{******************************************************************************
Tmatrix2_double
******************************************************************************}
{$DEFINE datatype:=DOUBLE}
{$DEFINE objectname:=Tmatrix2_double}
{$DEFINE vectorcompanion:=Tvector2_double}
{$DEFINE matsize:=2}
{$INFO Compile mmatimp.inc for Tmatrix2_double}
{$i mmatimp.inc}
{******************************************************************************
Tmatrix2_extended
******************************************************************************}
{$DEFINE datatype:=EXTENDED}
{$DEFINE objectname:=Tmatrix2_extended}
{$DEFINE vectorcompanion:=Tvector2_extended}
{$DEFINE matsize:=2}
{$INFO Compile mmatimp.inc for Tmatrix2_extended}
{$i mmatimp.inc}
{******************************************************************************
Tmatrix3_single
******************************************************************************}
{$DEFINE datatype:=SINGLE}
{$DEFINE objectname:=Tmatrix3_single}
{$DEFINE vectorcompanion:=Tvector3_single}
{$DEFINE matsize:=3}
{$INFO Compile mmatimp.inc for Tmatrix3_single}
{$i mmatimp.inc}
{******************************************************************************
Tmatrix3_double
******************************************************************************}
{$DEFINE datatype:=DOUBLE}
{$DEFINE objectname:=Tmatrix3_double}
{$DEFINE vectorcompanion:=Tvector3_double}
{$DEFINE matsize:=3}
{$INFO Compile mmatimp.inc for Tmatrix3_double}
{$i mmatimp.inc}
{******************************************************************************
Tmatrix3_extended
******************************************************************************}
{$DEFINE datatype:=EXTENDED}
{$DEFINE objectname:=Tmatrix3_extended}
{$DEFINE vectorcompanion:=Tvector3_extended}
{$DEFINE matsize:=3}
{$INFO Compile mmatimp.inc for Tmatrix3_extended}
{$i mmatimp.inc}
{******************************************************************************
Tmatrix4_single
******************************************************************************}
{$DEFINE datatype:=SINGLE}
{$DEFINE objectname:=Tmatrix4_single}
{$DEFINE vectorcompanion:=Tvector4_single}
{$DEFINE matsize:=4}
{$INFO Compile mmatimp.inc for Tmatrix4_single}
{$i mmatimp.inc}
{******************************************************************************
Tmatrix4_double
******************************************************************************}
{$DEFINE datatype:=DOUBLE}
{$DEFINE objectname:=Tmatrix4_double}
{$DEFINE vectorcompanion:=Tvector4_double}
{$DEFINE matsize:=4}
{$INFO Compile mmatimp.inc for Tmatrix4_double}
{$i mmatimp.inc}
{******************************************************************************
Tmatrix4_extended
******************************************************************************}
{$DEFINE datatype:=EXTENDED}
{$DEFINE objectname:=Tmatrix4_extended}
{$DEFINE vectorcompanion:=Tvector4_extended}
{$DEFINE matsize:=4}
{$INFO Compile mmatimp.inc for Tmatrix4_extended}
{$i mmatimp.inc}
end.

903
rtl/inc/mmatimp.inc Normal file
View File

@ -0,0 +1,903 @@
{*****************************************************************************
Methods of the matrix object
*****************************************************************************}
constructor objectname.init_zero;
begin
fillchar(data,sizeof(data),0);
end;
constructor objectname.init_identity;
begin
fillchar(data,sizeof(data),0);
data[0,0]:=1;
data[1,1]:=1;
{$if matsize>=3}
data[2,2]:=1;
{$endif}
{$if matsize>=4}
data[3,3]:=1;
{$endif}
end;
constructor objectname.init(aa
,ab
{$if matsize>=3},ac{$endif}
{$if matsize>=4},ad{$endif}
,ba
,bb
{$if matsize>=3},bc{$endif}
{$if matsize>=4},bd{$endif}
{$if matsize>=3}
,ca
,cb
,cc
{$if matsize>=4},cd{$endif}
{$endif}
{$if matsize>=4}
,da
,db
,dc
,dd
{$endif}:datatype);
begin
data[0,0]:=aa;
data[0,1]:=ab;
{$if matsize>=3}data[0,2]:=ac;{$endif}
{$if matsize>=4}data[0,3]:=ad;{$endif}
data[1,0]:=ba;
data[1,1]:=bb;
{$if matsize>=3}data[1,2]:=bc;{$endif}
{$if matsize>=4}data[1,3]:=bd;{$endif}
{$if matsize>=3}
data[2,0]:=ca;
data[2,1]:=cb;
data[2,2]:=cc;
{$if matsize>=4}data[2,3]:=cd;{$endif}
{$endif}
{$if matsize>=4}
data[3,0]:=da;
data[3,1]:=db;
data[3,2]:=dc;
data[3,3]:=dd;
{$endif}
end;
function objectname.get_column(c:byte):vectorcompanion;
begin
get_column.data[0]:=data[0,c];
get_column.data[1]:=data[1,c];
{$if matsize>=3}
get_column.data[2]:=data[2,c];
{$endif}
{$if matsize>=4}
get_column.data[3]:=data[3,c];
{$endif}
end;
function objectname.get_row(r:byte):vectorcompanion;
begin
get_row.data:=data[r];
end;
procedure objectname.set_column(c:byte;const v:vectorcompanion);
begin
data[0,c]:=v.data[0];
data[1,c]:=v.data[1];
{$if matsize>=3}
data[2,c]:=v.data[2];
{$endif}
{$if matsize>=4}
data[3,c]:=v.data[3];
{$endif}
end;
procedure objectname.set_row(r:byte;const v:vectorcompanion);
begin
data[r]:=v.data;
end;
function objectname.transpose:objectname;
begin
transpose.data[0,0]:=data[0,0];
transpose.data[0,1]:=data[1,0];
{$if matsize>=3}
transpose.data[0,2]:=data[2,0];
{$endif}
{$if matsize>=4}
transpose.data[0,3]:=data[3,0];
{$endif}
transpose.data[1,0]:=data[0,1];
transpose.data[1,1]:=data[1,1];
{$if matsize>=3}
transpose.data[1,2]:=data[2,1];
{$endif}
{$if matsize>=4}
transpose.data[1,3]:=data[3,1];
{$endif}
{$if matsize>=3}
transpose.data[2,0]:=data[0,2];
transpose.data[2,1]:=data[1,2];
transpose.data[2,2]:=data[2,2];
{$endif}
{$if matsize>=4}
transpose.data[2,3]:=data[3,2];
transpose.data[3,0]:=data[0,3];
transpose.data[3,1]:=data[1,3];
transpose.data[3,2]:=data[2,3];
transpose.data[3,3]:=data[3,3];
{$endif}
end;
{$if matsize=2}
function objectname.determinant:datatype;
begin
determinant:=data[0,0]*data[1,1]-data[0,1]*data[1,0];
end;
{$endif}
{$if matsize=3}
function objectname.determinant:datatype;
begin
determinant:=data[0,0]*(data[1,1]*data[2,2]-data[1,2]*data[2,1])-
data[0,1]*(data[1,0]*data[2,2]-data[1,2]*data[2,0])+
data[0,2]*(data[1,0]*data[2,1]-data[1,1]*data[2,0]);
end;
{$endif}
{$if matsize=4}
function objectname.determinant:datatype;
begin
determinant:=(data[0,0]*data[1,1]-data[0,1]*data[1,0])*(data[2,2]*data[3,3]-data[2,3]*data[3,2])-
(data[0,0]*data[1,2]-data[0,2]*data[1,0])*(data[2,1]*data[3,3]-data[2,3]*data[3,1])+
(data[0,0]*data[1,3]-data[0,3]*data[1,0])*(data[2,1]*data[3,2]-data[2,2]*data[3,1])+
(data[0,1]*data[1,2]-data[0,2]*data[1,1])*(data[2,0]*data[3,3]-data[2,3]*data[3,0])-
(data[0,1]*data[1,3]-data[0,3]*data[1,1])*(data[2,0]*data[3,2]-data[2,2]*data[3,0])+
(data[0,2]*data[1,3]-data[0,3]*data[1,2])*(data[2,0]*data[3,1]-data[2,1]*data[3,0]);
end;
{$endif}
{$if matsize=2}
function objectname.inverse(Adeterminant:datatype):objectname;
begin
Adeterminant:=1/Adeterminant;
inverse.data[0,0]:=data[1,1]*Adeterminant;
inverse.data[0,1]:=-data[0,1]*Adeterminant;
inverse.data[1,0]:=-data[1,0]*Adeterminant;
inverse.data[1,1]:=data[0,0]*Adeterminant;
end;
{$endif}
{$if matsize=3}
function objectname.inverse(Adeterminant:datatype):objectname;
begin
Adeterminant:=1/Adeterminant;
inverse.data[0,0]:=(data[1,1]*data[2,2]-data[2,1]*data[1,2])*Adeterminant;
inverse.data[0,1]:=-(data[1,0]*data[2,2]-data[2,0]*data[1,2])*Adeterminant;
inverse.data[0,2]:=(data[1,0]*data[2,1]-data[2,0]*data[1,1])*Adeterminant;
inverse.data[1,0]:=-(data[0,1]*data[2,2]-data[2,1]*data[0,2])*Adeterminant;
inverse.data[1,1]:=(data[0,0]*data[2,2]-data[2,0]*data[0,2])*Adeterminant;
inverse.data[1,2]:=-(data[0,0]*data[2,1]-data[2,0]*data[0,1])*Adeterminant;
inverse.data[2,0]:=(data[0,1]*data[1,2]-data[1,1]*data[0,2])*Adeterminant;
inverse.data[2,1]:=-(data[0,0]*data[1,2]-data[1,0]*data[0,2])*Adeterminant;
inverse.data[2,2]:=(data[0,0]*data[1,1]-data[1,0]*data[0,1])*Adeterminant;
end;
{$endif}
{$if matsize=4}
function objectname.inverse(Adeterminant:datatype):objectname;
begin
Adeterminant:=1/Adeterminant;
inverse.data[0,0]:=Adeterminant*(data[1,1]*(data[2,2]*data[3,3]-data[2,3]*data[3,2])+
data[1,2]*(data[2,3]*data[3,1]-data[2,1]*data[3,3])+
data[1,3]*(data[2,1]*data[3,2]-data[2,2]*data[3,1]));
inverse.data[0,1]:=Adeterminant*(data[2,1]*(data[0,2]*data[3,3]-data[0,3]*data[3,2])+
data[2,2]*(data[0,3]*data[3,1]-data[0,1]*data[3,3])+
data[2,3]*(data[0,1]*data[3,2]-data[0,2]*data[3,1]));
inverse.data[0,2]:=Adeterminant*(data[3,1]*(data[0,2]*data[1,3]-data[0,3]*data[1,2])+
data[3,2]*(data[0,3]*data[1,1]-data[0,1]*data[1,3])+
data[3,3]*(data[0,1]*data[1,2]-data[0,2]*data[1,1]));
inverse.data[0,3]:=Adeterminant*(data[0,1]*(data[1,3]*data[2,2]-data[1,2]*data[2,3])+
data[0,2]*(data[1,1]*data[2,3]-data[1,3]*data[2,1])+
data[0,3]*(data[1,2]*data[2,1]-data[1,1]*data[2,2]));
inverse.data[1,0]:=Adeterminant*(data[1,2]*(data[2,0]*data[3,3]-data[2,3]*data[3,0])+
data[1,3]*(data[2,2]*data[3,0]-data[2,0]*data[3,2])+
data[1,0]*(data[2,3]*data[3,2]-data[2,2]*data[3,3]));
inverse.data[1,1]:=Adeterminant*(data[2,2]*(data[0,0]*data[3,3]-data[0,3]*data[3,0])+
data[2,3]*(data[0,2]*data[3,0]-data[0,0]*data[3,2])+
data[2,0]*(data[0,3]*data[3,2]-data[0,2]*data[3,3]));
inverse.data[1,2]:=Adeterminant*(data[3,2]*(data[0,0]*data[1,3]-data[0,3]*data[1,0])+
data[3,3]*(data[0,2]*data[1,0]-data[0,0]*data[1,2])+
data[3,0]*(data[0,3]*data[1,2]-data[0,2]*data[1,3]));
inverse.data[1,3]:=Adeterminant*(data[0,2]*(data[1,3]*data[2,0]-data[1,0]*data[2,3])+
data[0,3]*(data[1,0]*data[2,2]-data[1,2]*data[2,0])+
data[0,0]*(data[1,2]*data[2,3]-data[1,3]*data[2,2]));
inverse.data[2,0]:=Adeterminant*(data[1,3]*(data[2,0]*data[3,1]-data[2,1]*data[3,0])+
data[1,0]*(data[2,1]*data[3,3]-data[2,3]*data[3,1])+
data[1,1]*(data[2,3]*data[3,0]-data[2,0]*data[3,3]));
inverse.data[2,1]:=Adeterminant*(data[2,3]*(data[0,0]*data[3,1]-data[0,1]*data[3,0])+
data[2,0]*(data[0,1]*data[3,3]-data[0,3]*data[3,1])+
data[2,1]*(data[0,3]*data[3,0]-data[0,0]*data[3,3]));
inverse.data[2,2]:=Adeterminant*(data[3,3]*(data[0,0]*data[1,1]-data[0,1]*data[1,0])+
data[3,0]*(data[0,1]*data[1,3]-data[0,3]*data[1,1])+
data[3,1]*(data[0,3]*data[1,0]-data[0,0]*data[1,3]));
inverse.data[2,3]:=Adeterminant*(data[0,3]*(data[1,1]*data[2,0]-data[1,0]*data[2,1])+
data[0,0]*(data[1,3]*data[2,1]-data[1,1]*data[2,3])+
data[0,1]*(data[1,0]*data[2,3]-data[1,3]*data[2,0]));
inverse.data[3,0]:=Adeterminant*(data[1,0]*(data[2,2]*data[3,1]-data[2,1]*data[3,2])+
data[1,1]*(data[2,0]*data[3,2]-data[2,2]*data[3,0])+
data[1,2]*(data[2,1]*data[3,0]-data[2,0]*data[3,1]));
inverse.data[3,1]:=Adeterminant*(data[2,0]*(data[0,2]*data[3,1]-data[0,1]*data[3,2])+
data[2,1]*(data[0,0]*data[3,2]-data[0,2]*data[3,0])+
data[2,2]*(data[0,1]*data[3,0]-data[0,0]*data[3,1]));
inverse.data[3,2]:=Adeterminant*(data[3,0]*(data[0,2]*data[1,1]-data[0,1]*data[1,2])+
data[3,1]*(data[0,0]*data[1,2]-data[0,2]*data[1,0])+
data[3,2]*(data[0,1]*data[1,0]-data[0,0]*data[1,1]));
inverse.data[3,3]:=Adeterminant*(data[0,0]*(data[1,1]*data[2,2]-data[1,2]*data[2,1])+
data[0,1]*(data[1,2]*data[2,0]-data[1,0]*data[2,2])+
data[0,2]*(data[1,0]*data[2,1]-data[1,1]*data[2,0]));
end;
{$endif}
{*****************************************************************************
Conversion from matrix2
*****************************************************************************}
{$if (matsize<>2) or (datatype<>single)}
operator := (const v:Tmatrix2_single) result:objectname;
begin
result.data[0,0]:=v.data[0,0];
result.data[0,1]:=v.data[0,1];
{$if matsize>=3}
result.data[0,2]:=0;
{$endif}
{$if matsize>=4}
result.data[0,3]:=0;
{$endif}
result.data[1,0]:=v.data[1,0];
result.data[1,1]:=v.data[1,1];
{$if matsize>=3}
result.data[1,2]:=0;
{$endif}
{$if matsize>=4}
result.data[1,3]:=0;
{$endif}
{$if matsize>=3}
result.data[2,0]:=0;
result.data[2,1]:=0;
result.data[2,2]:=0;
{$endif}
{$if matsize>=4}
result.data[2,3]:=0;
result.data[3,0]:=0;
result.data[3,1]:=0;
result.data[3,2]:=0;
result.data[3,3]:=0;
{$endif}
end;
{$endif}
{$if (matsize<>2) or (datatype<>double)}
operator := (const v:Tmatrix2_double) result:objectname;
begin
result.data[0,0]:=v.data[0,0];
result.data[0,1]:=v.data[0,1];
{$if matsize>=3}
result.data[0,2]:=0;
{$endif}
{$if matsize>=4}
result.data[0,3]:=0;
{$endif}
result.data[1,0]:=v.data[1,0];
result.data[1,1]:=v.data[1,1];
{$if matsize>=3}
result.data[1,2]:=0;
{$endif}
{$if matsize>=4}
result.data[1,3]:=0;
{$endif}
{$if matsize>=3}
result.data[2,0]:=0;
result.data[2,1]:=0;
result.data[2,2]:=0;
{$endif}
{$if matsize>=4}
result.data[2,3]:=0;
result.data[3,0]:=0;
result.data[3,1]:=0;
result.data[3,2]:=0;
result.data[3,3]:=0;
{$endif}
end;
{$endif}
{$if (matsize<>2) or (datatype<>extended)}
operator := (const v:Tmatrix2_extended) result:objectname;
begin
result.data[0,0]:=v.data[0,0];
result.data[0,1]:=v.data[0,1];
{$if matsize>=3}
result.data[0,2]:=0;
{$endif}
{$if matsize>=4}
result.data[0,3]:=0;
{$endif}
result.data[1,0]:=v.data[1,0];
result.data[1,1]:=v.data[1,1];
{$if matsize>=3}
result.data[1,2]:=0;
{$endif}
{$if matsize>=4}
result.data[1,3]:=0;
{$endif}
{$if matsize>=3}
result.data[2,0]:=0;
result.data[2,1]:=0;
result.data[2,2]:=0;
{$endif}
{$if matsize>=4}
result.data[2,3]:=0;
result.data[3,0]:=0;
result.data[3,1]:=0;
result.data[3,2]:=0;
result.data[3,3]:=0;
{$endif}
end;
{$endif}
{*****************************************************************************
Conversion from matrix3
*****************************************************************************}
{$if (matsize<>3) or (datatype<>single)}
operator := (const v:Tmatrix3_single) result:objectname;
begin
result.data[0,0]:=v.data[0,0];
result.data[0,1]:=v.data[0,1];
{$if matsize>=3}
result.data[0,2]:=v.data[0,2];
{$endif}
{$if matsize>=4}
result.data[0,3]:=0;
{$endif}
result.data[1,0]:=v.data[1,0];
result.data[1,1]:=v.data[1,1];
{$if matsize>=3}
result.data[1,2]:=v.data[1,2];
{$endif}
{$if matsize>=4}
result.data[1,3]:=0;
{$endif}
{$if matsize>=3}
result.data[2,0]:=v.data[2,0];
result.data[2,1]:=v.data[2,1];
result.data[2,2]:=v.data[2,2];
{$endif}
{$if matsize>=4}
result.data[2,3]:=0;
result.data[3,0]:=0;
result.data[3,1]:=0;
result.data[3,2]:=0;
result.data[3,3]:=0;
{$endif}
end;
{$endif}
{$if (matsize<>3) or (datatype<>double)}
operator := (const v:Tmatrix3_double) result:objectname;
begin
result.data[0,0]:=v.data[0,0];
result.data[0,1]:=v.data[0,1];
{$if matsize>=3}
result.data[0,2]:=v.data[0,2];
{$endif}
{$if matsize>=4}
result.data[0,3]:=0;
{$endif}
result.data[1,0]:=v.data[1,0];
result.data[1,1]:=v.data[1,1];
{$if matsize>=3}
result.data[1,2]:=v.data[1,2];
{$endif}
{$if matsize>=4}
result.data[1,3]:=0;
{$endif}
{$if matsize>=3}
result.data[2,0]:=v.data[2,0];
result.data[2,1]:=v.data[2,1];
result.data[2,2]:=v.data[2,2];
{$endif}
{$if matsize>=4}
result.data[2,3]:=0;
result.data[3,0]:=0;
result.data[3,1]:=0;
result.data[3,2]:=0;
result.data[3,3]:=0;
{$endif}
end;
{$endif}
{$if (matsize<>3) or (datatype<>extended)}
operator := (const v:Tmatrix3_extended) result:objectname;
begin
result.data[0,0]:=v.data[0,0];
result.data[0,1]:=v.data[0,1];
{$if matsize>=3}
result.data[0,2]:=v.data[0,2];
{$endif}
{$if matsize>=4}
result.data[0,3]:=0;
{$endif}
result.data[1,0]:=v.data[1,0];
result.data[1,1]:=v.data[1,1];
{$if matsize>=3}
result.data[1,2]:=v.data[1,2];
{$endif}
{$if matsize>=4}
result.data[1,3]:=0;
{$endif}
{$if matsize>=3}
result.data[2,0]:=v.data[2,0];
result.data[2,1]:=v.data[2,1];
result.data[2,2]:=v.data[2,2];
{$endif}
{$if matsize>=4}
result.data[2,3]:=0;
result.data[3,0]:=0;
result.data[3,1]:=0;
result.data[3,2]:=0;
result.data[3,3]:=0;
{$endif}
end;
{$endif}
{*****************************************************************************
Conversion from matrix4
*****************************************************************************}
{$if (matsize<>4) or (datatype<>single)}
operator := (const v:Tmatrix4_single) result:objectname;
begin
result.data[0,0]:=v.data[0,0];
result.data[0,1]:=v.data[0,1];
{$if matsize>=3}
result.data[0,2]:=v.data[0,2];
{$endif}
{$if matsize>=4}
result.data[0,3]:=v.data[0,3];
{$endif}
result.data[1,0]:=v.data[1,0];
result.data[1,1]:=v.data[1,1];
{$if matsize>=3}
result.data[1,2]:=v.data[1,2];
{$endif}
{$if matsize>=4}
result.data[1,3]:=v.data[1,3];
{$endif}
{$if matsize>=3}
result.data[2,0]:=v.data[2,0];
result.data[2,1]:=v.data[2,1];
result.data[2,2]:=v.data[2,2];
{$endif}
{$if matsize>=4}
result.data[2,3]:=v.data[2,3];
result.data[3,0]:=v.data[3,0];
result.data[3,1]:=v.data[3,1];
result.data[3,2]:=v.data[3,2];
result.data[3,3]:=v.data[3,3];
{$endif}
end;
{$endif}
{$if (matsize<>4) or (datatype<>double)}
operator := (const v:Tmatrix4_double) result:objectname;
begin
result.data[0,0]:=v.data[0,0];
result.data[0,1]:=v.data[0,1];
{$if matsize>=3}
result.data[0,2]:=v.data[0,2];
{$endif}
{$if matsize>=4}
result.data[0,3]:=v.data[0,3];
{$endif}
result.data[1,0]:=v.data[1,0];
result.data[1,1]:=v.data[1,1];
{$if matsize>=3}
result.data[1,2]:=v.data[1,2];
{$endif}
{$if matsize>=4}
result.data[1,3]:=v.data[1,3];
{$endif}
{$if matsize>=3}
result.data[2,0]:=v.data[2,0];
result.data[2,1]:=v.data[2,1];
result.data[2,2]:=v.data[2,2];
{$endif}
{$if matsize>=4}
result.data[2,3]:=v.data[2,3];
result.data[3,0]:=v.data[3,0];
result.data[3,1]:=v.data[3,1];
result.data[3,2]:=v.data[3,2];
result.data[3,3]:=v.data[3,3];
{$endif}
end;
{$endif}
{$if (matsize<>4) or (datatype<>extended)}
operator := (const v:Tmatrix4_extended) result:objectname;
begin
result.data[0,0]:=v.data[0,0];
result.data[0,1]:=v.data[0,1];
{$if matsize>=3}
result.data[0,2]:=v.data[0,2];
{$endif}
{$if matsize>=4}
result.data[0,3]:=v.data[0,3];
{$endif}
result.data[1,0]:=v.data[1,0];
result.data[1,1]:=v.data[1,1];
{$if matsize>=3}
result.data[1,2]:=v.data[1,2];
{$endif}
{$if matsize>=4}
result.data[1,3]:=v.data[1,3];
{$endif}
{$if matsize>=3}
result.data[2,0]:=v.data[2,0];
result.data[2,1]:=v.data[2,1];
result.data[2,2]:=v.data[2,2];
{$endif}
{$if matsize>=4}
result.data[2,3]:=v.data[2,3];
result.data[3,0]:=v.data[3,0];
result.data[3,1]:=v.data[3,1];
result.data[3,2]:=v.data[3,2];
result.data[3,3]:=v.data[3,3];
{$endif}
end;
{$endif}
{*****************************************************************************
Matrix to matrix operations
*****************************************************************************}
operator + (const m1,m2:objectname) result:objectname;
{Add the elements of a matrix to each other.}
begin
result.data[0,0]:=m1.data[0,0]+m2.data[0,0];
result.data[0,1]:=m1.data[0,1]+m2.data[0,1];
{$if matsize>=3}
result.data[0,2]:=m1.data[0,2]+m2.data[0,2];
{$endif}
{$if matsize>=4}
result.data[0,3]:=m1.data[0,3]+m2.data[0,3];
{$endif}
result.data[1,0]:=m1.data[1,0]+m2.data[1,0];
result.data[1,1]:=m1.data[1,1]+m2.data[1,1];
{$if matsize>=3}
result.data[1,2]:=m1.data[1,2]+m2.data[1,2];
{$endif}
{$if matsize>=4}
result.data[1,3]:=m1.data[1,3]+m2.data[1,3];
{$endif}
{$if matsize>=3}
result.data[2,0]:=m1.data[2,0]+m2.data[2,0];
result.data[2,1]:=m1.data[2,1]+m2.data[2,1];
result.data[2,2]:=m1.data[2,2]+m2.data[2,2];
{$endif}
{$if matsize>=4}
result.data[2,3]:=m1.data[2,3]+m2.data[2,3];
result.data[3,0]:=m1.data[3,0]+m2.data[3,0];
result.data[3,1]:=m1.data[3,1]+m2.data[3,1];
result.data[3,2]:=m1.data[3,2]+m2.data[3,2];
result.data[3,3]:=m1.data[3,3]+m2.data[3,3];
{$endif}
end;
operator - (const m1,m2:objectname) result:objectname;
{Subtract the elements of two matrixes from each other.}
begin
result.data[0,0]:=m1.data[0,0]-m2.data[0,0];
result.data[0,1]:=m1.data[0,1]-m2.data[0,1];
{$if matsize>=3}
result.data[0,2]:=m1.data[0,2]-m2.data[0,2];
{$endif}
{$if matsize>=4}
result.data[0,3]:=m1.data[0,3]-m2.data[0,3];
{$endif}
result.data[1,0]:=m1.data[1,0]-m2.data[1,0];
result.data[1,1]:=m1.data[1,1]-m2.data[1,1];
{$if matsize>=3}
result.data[1,2]:=m1.data[1,2]-m2.data[1,2];
{$endif}
{$if matsize>=4}
result.data[1,3]:=m1.data[1,3]-m2.data[1,3];
{$endif}
{$if matsize>=3}
result.data[2,0]:=m1.data[2,0]-m2.data[2,0];
result.data[2,1]:=m1.data[2,1]-m2.data[2,1];
result.data[2,2]:=m1.data[2,2]-m2.data[2,2];
{$endif}
{$if matsize>=4}
result.data[2,3]:=m1.data[2,3]-m2.data[2,3];
result.data[3,0]:=m1.data[3,0]-m2.data[3,0];
result.data[3,1]:=m1.data[3,1]-m2.data[3,1];
result.data[3,2]:=m1.data[3,2]-m2.data[3,2];
result.data[3,3]:=m1.data[3,3]-m2.data[3,3];
{$endif}
end;
operator - (const m1:objectname) result:objectname;
{Negate the elements of a matrix.}
begin
result.data[0,0]:=-m1.data[0,0];
result.data[0,1]:=-m1.data[0,1];
{$if matsize>=3}
result.data[0,2]:=-m1.data[0,2];
{$endif}
{$if matsize>=4}
result.data[0,3]:=-m1.data[0,3];
{$endif}
result.data[1,0]:=-m1.data[1,0];
result.data[1,1]:=-m1.data[1,1];
{$if matsize>=3}
result.data[1,2]:=-m1.data[1,2];
{$endif}
{$if matsize>=4}
result.data[1,3]:=-m1.data[1,3];
{$endif}
{$if matsize>=3}
result.data[2,0]:=-m1.data[2,0];
result.data[2,1]:=-m1.data[2,1];
result.data[2,2]:=-m1.data[2,2];
{$endif}
{$if matsize>=4}
result.data[2,3]:=-m1.data[2,3];
result.data[3,0]:=-m1.data[3,0];
result.data[3,1]:=-m1.data[3,1];
result.data[3,2]:=-m1.data[3,2];
result.data[3,3]:=-m1.data[3,3];
{$endif}
end;
operator * (const m1,m2:objectname) result:objectname;
{Multiply two matrixes.}
var r:array[0..matsize-1] of datatype;
i:byte;
begin
for i:=0 to matsize-1 do
begin
r:=m1.data[i];
result.data[i,0]:=r[0]*m2.data[0,0]
+r[1]*m2.data[1,0]
{$if matsize>=3}+r[2]*m2.data[2,0]{$endif}
{$if matsize>=4}+r[3]*m2.data[3,0]{$endif};
result.data[i,1]:=r[0]*m2.data[0,1]
+r[1]*m2.data[1,1]
{$if matsize>=3}+r[2]*m2.data[2,1]{$endif}
{$if matsize>=4}+r[3]*m2.data[3,1]{$endif};
{$if matsize>=3}
result.data[i,2]:=r[0]*m2.data[0,2]
+r[1]*m2.data[1,2]
+r[2]*m2.data[2,2]
{$if matsize>=4}+r[3]*m2.data[3,2]{$endif};
{$endif}
{$if matsize>=4}
result.data[i,3]:=r[0]*m2.data[0,3]
+r[1]*m2.data[1,3]
+r[2]*m2.data[2,3]
+r[3]*m2.data[3,3];
{$endif}
end;
end;
{*****************************************************************************
Vector/matrix operations
*****************************************************************************}
operator * (const m:objectname;const v:vectorcompanion) result:vectorcompanion;
{Multiplies a matrix with a vector.}
begin
result.data[0]:=m.data[0,0]*v.data[0]
+m.data[1,0]*v.data[1]
{$if matsize>=3}+m.data[2,0]*v.data[2]{$endif}
{$if matsize>=4}+m.data[3,0]*v.data[3]{$endif};
result.data[1]:=m.data[0,1]*v.data[0]
+m.data[1,1]*v.data[1]
{$if matsize>=3}+m.data[2,1]*v.data[2]{$endif}
{$if matsize>=4}+m.data[3,1]*v.data[3]{$endif};
{$if matsize>=3}
result.data[2]:=m.data[0,2]*v.data[0]
+m.data[1,2]*v.data[1]
+m.data[2,2]*v.data[2]
{$if matsize>=4}+m.data[3,2]*v.data[3]{$endif};
{$endif}
{$if matsize>=4}
result.data[3]:=m.data[0,3]*v.data[0]
+m.data[1,3]*v.data[1]
+m.data[2,3]*v.data[2]
+m.data[3,3]*v.data[3];
{$endif}
end;
{*****************************************************************************
Matrix/scalar operations
*****************************************************************************}
operator + (const m:objectname;const x:datatype) result:objectname;
{Adds to the elements of a matrix.}
begin
result.data[0,0]:=m.data[0,0]+x;
result.data[0,1]:=m.data[0,1]+x;
{$if matsize>=3}
result.data[0,2]:=m.data[0,2]+x;
{$endif}
{$if matsize>=4}
result.data[0,3]:=m.data[0,3]+x;
{$endif}
result.data[1,0]:=m.data[1,0]+x;
result.data[1,1]:=m.data[1,1]+x;
{$if matsize>=3}
result.data[1,2]:=m.data[1,2]+x;
{$endif}
{$if matsize>=4}
result.data[1,3]:=m.data[1,3]+x;
{$endif}
{$if matsize>=3}
result.data[2,0]:=m.data[2,0]+x;
result.data[2,1]:=m.data[2,1]+x;
result.data[2,2]:=m.data[2,2]+x;
{$endif}
{$if matsize>=4}
result.data[2,3]:=m.data[2,3]+x;
result.data[3,0]:=m.data[3,0]+x;
result.data[3,1]:=m.data[3,1]+x;
result.data[3,2]:=m.data[3,2]+x;
result.data[3,3]:=m.data[3,3]+x;
{$endif}
end;
operator - (const m:objectname;const x:datatype) result:objectname;
{Subtracts from the elements of a matrix.}
begin
result.data[0,0]:=m.data[0,0]-x;
result.data[0,1]:=m.data[0,1]-x;
{$if matsize>=3}
result.data[0,2]:=m.data[0,2]-x;
{$endif}
{$if matsize>=4}
result.data[0,3]:=m.data[0,3]-x;
{$endif}
result.data[1,0]:=m.data[1,0]-x;
result.data[1,1]:=m.data[1,1]-x;
{$if matsize>=3}
result.data[1,2]:=m.data[1,2]-x;
{$endif}
{$if matsize>=4}
result.data[1,3]:=m.data[1,3]-x;
{$endif}
{$if matsize>=3}
result.data[2,0]:=m.data[2,0]-x;
result.data[2,1]:=m.data[2,1]-x;
result.data[2,2]:=m.data[2,2]-x;
{$endif}
{$if matsize>=4}
result.data[2,3]:=m.data[2,3]-x;
result.data[3,0]:=m.data[3,0]-x;
result.data[3,1]:=m.data[3,1]-x;
result.data[3,2]:=m.data[3,2]-x;
result.data[3,3]:=m.data[3,3]-x;
{$endif}
end;
operator * (const m:objectname;const x:datatype) result:objectname;
{Multiplies the elements of a matrix.}
begin
result.data[0,0]:=m.data[0,0]*x;
result.data[0,1]:=m.data[0,1]*x;
{$if matsize>=3}
result.data[0,2]:=m.data[0,2]*x;
{$endif}
{$if matsize>=4}
result.data[0,3]:=m.data[0,3]*x;
{$endif}
result.data[1,0]:=m.data[1,0]*x;
result.data[1,1]:=m.data[1,1]*x;
{$if matsize>=3}
result.data[1,2]:=m.data[1,2]*x;
{$endif}
{$if matsize>=4}
result.data[1,3]:=m.data[1,3]*x;
{$endif}
{$if matsize>=3}
result.data[2,0]:=m.data[2,0]*x;
result.data[2,1]:=m.data[2,1]*x;
result.data[2,2]:=m.data[2,2]*x;
{$endif}
{$if matsize>=4}
result.data[2,3]:=m.data[2,3]*x;
result.data[3,0]:=m.data[3,0]*x;
result.data[3,1]:=m.data[3,1]*x;
result.data[3,2]:=m.data[3,2]*x;
result.data[3,3]:=m.data[3,3]*x;
{$endif}
end;
operator / (const m:objectname;const x:datatype) result:objectname;
{Divides the elements of a matrix.
In most cases, you will want to avoid this and multiply by the inverse.
In case you need to preserve accuracy, dividing might be better though.}
begin
result.data[0,0]:=m.data[0,0]/x;
result.data[0,1]:=m.data[0,1]/x;
{$if matsize>=3}
result.data[0,2]:=m.data[0,2]/x;
{$endif}
{$if matsize>=4}
result.data[0,3]:=m.data[0,3]/x;
{$endif}
result.data[1,0]:=m.data[1,0]/x;
result.data[1,1]:=m.data[1,1]/x;
{$if matsize>=3}
result.data[1,2]:=m.data[1,2]/x;
{$endif}
{$if matsize>=4}
result.data[1,3]:=m.data[1,3]/x;
{$endif}
{$if matsize>=3}
result.data[2,0]:=m.data[2,0]/x;
result.data[2,1]:=m.data[2,1]/x;
result.data[2,2]:=m.data[2,2]/x;
{$endif}
{$if matsize>=4}
result.data[2,3]:=m.data[2,3]/x;
result.data[3,0]:=m.data[3,0]/x;
result.data[3,1]:=m.data[3,1]/x;
result.data[3,2]:=m.data[3,2]/x;
result.data[3,3]:=m.data[3,3]/x;
{$endif}
end;

381
rtl/inc/mvecimp.inc Normal file
View File

@ -0,0 +1,381 @@
{*****************************************************************************
Methods of the vector object
*****************************************************************************}
constructor objectname.init_zero;
begin
data[0]:=0;
data[1]:=0;
{$if vecsize>=3}
data[2]:=0;
{$endif}
{$if vecsize>=4}
data[3]:=0;
{$endif}
end;
constructor objectname.init_one;
begin
data[0]:=1;
data[1]:=1;
{$if vecsize>=3}
data[2]:=1;
{$endif}
{$if vecsize>=4}
data[3]:=1;
{$endif}
end;
constructor objectname.init(a,b
{$if vecsize>=3},c{$endif}
{$if vecsize>=4},d{$endif}:datatype);
begin
data[0]:=a;
data[1]:=b;
{$if vecsize>=3}
data[2]:=c;
{$endif}
{$if vecsize>=4}
data[3]:=d;
{$endif}
end;
function objectname.length:datatype;
begin
length:=sqrt(data[0]*data[0]
+data[1]*data[1]
{$if vecsize>=3}+data[2]*data[2]{$endif}
{$if vecsize>=4}+data[3]*data[3]{$endif});
end;
function objectname.squared_length:datatype;
begin
squared_length:=data[0]*data[0]
+data[1]*data[1]
{$if vecsize>=3}+data[2]*data[2]{$endif}
{$if vecsize>=4}+data[3]*data[3]{$endif};
end;
{*****************************************************************************
Conversion from vector2
*****************************************************************************}
{$if (vecsize<>2) or (datatype<>single)}
operator := (const v:Tvector2_single) result:objectname;
begin
result.data[0]:=v.data[0];
result.data[1]:=v.data[1];
{$if vecsize>=3}
result.data[2]:=0;
{$endif}
{$if vecsize>=4}
result.data[3]:=0;
{$endif}
end;
{$endif}
{$if (vecsize<>2) or (datatype<>double)}
operator := (const v:Tvector2_double) result:objectname;
begin
result.data[0]:=v.data[0];
result.data[1]:=v.data[1];
{$if vecsize>=3}
result.data[2]:=0;
{$endif}
{$if vecsize>=4}
result.data[3]:=0;
{$endif}
end;
{$endif}
{$if (vecsize<>2) or (datatype<>extended)}
operator := (const v:Tvector2_extended) result:objectname;
begin
result.data[0]:=v.data[0];
result.data[1]:=v.data[1];
{$if vecsize>=3}
result.data[2]:=0;
{$endif}
{$if vecsize>=4}
result.data[3]:=0;
{$endif}
end;
{$endif}
{*****************************************************************************
Conversion from vector3
*****************************************************************************}
{$if (vecsize<>3) or (datatype<>single)}
operator := (const v:Tvector3_single) result:objectname;
begin
result.data[0]:=v.data[0];
result.data[1]:=v.data[1];
{$if vecsize>=3}
result.data[2]:=v.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=0;
{$endif}
end;
{$endif}
{$if (vecsize<>3) or (datatype<>double)}
operator := (const v:Tvector3_double) result:objectname;
begin
result.data[0]:=v.data[0];
result.data[1]:=v.data[1];
{$if vecsize>=3}
result.data[2]:=v.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=0;
{$endif}
end;
{$endif}
{$if (vecsize<>3) or (datatype<>extended)}
operator := (const v:Tvector3_extended) result:objectname;
begin
result.data[0]:=v.data[0];
result.data[1]:=v.data[1];
{$if vecsize>=3}
result.data[2]:=v.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=0;
{$endif}
end;
{$endif}
{*****************************************************************************
Conversion from vector4
*****************************************************************************}
{$if (vecsize<>4) or (datatype<>single)}
operator := (const v:Tvector4_single) result:objectname;
begin
result.data[0]:=v.data[0];
result.data[1]:=v.data[1];
{$if vecsize>=3}
result.data[2]:=v.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=v.data[3];
{$endif}
end;
{$endif}
{$if (vecsize<>4) or (datatype<>double)}
operator := (const v:Tvector4_double) result:objectname;
begin
result.data[0]:=v.data[0];
result.data[1]:=v.data[1];
{$if vecsize>=3}
result.data[2]:=v.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=v.data[3];
{$endif}
end;
{$endif}
{$if (vecsize<>4) or (datatype<>extended)}
operator := (const v:Tvector4_extended) result:objectname;
begin
result.data[0]:=v.data[0];
result.data[1]:=v.data[1];
{$if vecsize>=3}
result.data[2]:=v.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=v.data[3];
{$endif}
end;
{$endif}
{*****************************************************************************
Vector to vector operations
*****************************************************************************}
operator + (const x,y:objectname) result:objectname;
{Adds the elements of both vectors together.}
begin
result.data[0]:=x.data[0]+y.data[0];
result.data[1]:=x.data[1]+y.data[1];
{$if vecsize>=3}
result.data[2]:=x.data[2]+y.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=x.data[3]+y.data[3];
{$endif}
end;
operator - (const x:objectname) result:objectname;
{Negates the elements of a vector.}
begin
result.data[0]:=-x.data[0];
result.data[1]:=-x.data[1];
{$if vecsize>=3}
result.data[2]:=-x.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=-x.data[3];
{$endif}
end;
operator - (const x,y:objectname) result:objectname;
{Subtracts the elements of both vectors together.}
begin
result.data[0]:=x.data[0]-y.data[0];
result.data[1]:=x.data[1]-y.data[1];
{$if vecsize>=3}
result.data[2]:=x.data[2]-y.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=x.data[3]-y.data[3];
{$endif}
end;
operator * (const x,y:objectname) result:objectname;
{Multiplies the elements of two vectors.}
begin
result.data[0]:=x.data[0]*y.data[0];
result.data[1]:=x.data[1]*y.data[1];
{$if vecsize>=3}
result.data[2]:=x.data[2]*y.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=x.data[3]*y.data[3];
{$endif}
end;
operator / (const x,y:objectname) result:objectname;
{Divides the elements of two vectors.
In most cases, you will want to avoid this and multiply by the inverse.
In case you need to preserve accuracy, dividing might be better though.}
begin
result.data[0]:=x.data[0]/y.data[0];
result.data[1]:=x.data[1]/y.data[1];
{$if vecsize>=3}
result.data[2]:=x.data[2]/y.data[2];
{$endif}
{$if vecsize>=4}
result.data[3]:=x.data[3]/y.data[3];
{$endif}
end;
operator ** (const x,y:objectname) result:datatype;
{Calculates the inproduct of two vectors.}
begin
result:=x.data[0]*y.data[0]
+x.data[1]*y.data[1]
{$if vecsize>=3}+x.data[2]*y.data[2]{$endif}
{$if vecsize>=4}+x.data[3]*y.data[3]{$endif};
end;
{$if vecsize=3}
operator >< (const x,y:objectname) result:objectname;
{Calculates the exproduct of two vectors. The exproduct exists only for
3-dimensional vectors}
begin
result.data[0]:=x.data[1]*y.data[2]-x.data[2]*y.data[1];
result.data[1]:=x.data[2]*y.data[0]-x.data[0]*y.data[2];
result.data[2]:=x.data[0]*y.data[1]-x.data[1]*y.data[0];
end;
{$endif}
{*****************************************************************************
Vector/scalar operations
*****************************************************************************}
operator + (const x:objectname;y:datatype) result:objectname;
{Adds a scalar to all vector elements.}
begin
result.data[0]:=x.data[0]+y;
result.data[1]:=x.data[1]+y;
{$if vecsize>=3}
result.data[2]:=x.data[2]+y;
{$endif}
{$if vecsize>=4}
result.data[3]:=x.data[3]+y;
{$endif}
end;
operator - (const x:objectname;y:datatype) result:objectname;
{Subtracts a scalar to all vector elements.}
begin
result.data[0]:=x.data[0]-y;
result.data[1]:=x.data[1]-y;
{$if vecsize>=3}
result.data[2]:=x.data[2]-y;
{$endif}
{$if vecsize>=4}
result.data[3]:=x.data[3]-y;
{$endif}
end;
operator * (const x:objectname;y:datatype) result:objectname;
{Multiplies all vector elements by a scalar.}
begin
result.data[0]:=x.data[0]*y;
result.data[1]:=x.data[1]*y;
{$if vecsize>=3}
result.data[2]:=x.data[2]*y;
{$endif}
{$if vecsize>=4}
result.data[3]:=x.data[3]*y;
{$endif}
end;
operator / (const x:objectname;y:datatype) result:objectname;
{Divides all vector elements by a scalar.}
begin
result.data[0]:=x.data[0]/y;
result.data[1]:=x.data[1]/y;
{$if vecsize>=3}
result.data[2]:=x.data[2]/y;
{$endif}
{$if vecsize>=4}
result.data[3]:=x.data[3]/y;
{$endif}
end;