开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 2D图形编程 > 查看源码
Matrices4.pas
资源名称：asphyre410.rar　[点击查看]
上传用户：ctlcnc
上传日期：2021-12-10
资源大小：4933k
文件大小：25k
源码类别：

2D图形编程

开发平台：

Delphi

Matrices4.pas：源码内容
  1. unit Matrices4;
  2. //---------------------------------------------------------------------------
  3. // Matrices4.pas                                        Modified: 02-Apr-2007
  4. // Definitions and functions working with 3D 4x4 matrices         Version 1.0
  5. //---------------------------------------------------------------------------
  6. // Important Notice:
  7. //
  8. // If you modify/use this code or one of its parts either in original or
  9. // modified form, you must comply with Mozilla Public License v1.1,
  10. // specifically section 3, "Distribution Obligations". Failure to do so will
  11. // result in the license breach, which will be resolved in the court.
  12. // Remember that violating author's rights is considered a serious crime in
  13. // many countries. Thank you!
  14. //
  15. // !! Please *read* Mozilla Public License 1.1 document located at:
  16. //  http://www.mozilla.org/MPL/
  17. //
  18. // If you require any clarifications about the license, feel free to contact
  19. // us or post your question on our forums at: http://www.afterwarp.net
  20. //---------------------------------------------------------------------------
  21. // The contents of this file are subject to the Mozilla Public License
  22. // Version 1.1 (the "License"); you may not use this file except in
  23. // compliance with the License. You may obtain a copy of the License at
  24. // http://www.mozilla.org/MPL/
  25. //
  26. // Software distributed under the License is distributed on an "AS IS"
  27. // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
  28. // License for the specific language governing rights and limitations
  29. // under the License.
  30. //
  31. // The Original Code is Matrices4.pas.
  32. //
  33. // The Initial Developer of the Original Code is M. Sc. Yuriy Kotsarenko.
  34. // Portions created by M. Sc. Yuriy Kotsarenko are Copyright (C) 2007,
  35. // M. Sc. Yuriy Kotsarenko. All Rights Reserved.
  36. //---------------------------------------------------------------------------
  37. interface
  39. //---------------------------------------------------------------------------
  40. // Enable the following option to take advantage of mathematical routines
  41. // from D3DX interface.
  42. //---------------------------------------------------------------------------
  43. {$define SupportD3DX}
  45. //---------------------------------------------------------------------------
  46. uses
  47.  {$ifdef SupportD3DX}d3dx9,{$endif} SysUtils, Math, Vectors3;
  49. //---------------------------------------------------------------------------
  50. type
  51.  PMatrix4 = ^TMatrix4;
  52.  TMatrix4 = record
  53.   Data: array[0..3, 0..3] of Single;
  55.   class operator Add(const a, b: TMatrix4): TMatrix4;
  56.   class operator Subtract(const a, b: TMatrix4): TMatrix4;
  57.   class operator Multiply(const a, b: TMatrix4): TMatrix4;
  58.   class operator Multiply(const Mtx: TMatrix4; Theta: Single): TMatrix4;
  59.   class operator Multiply(const v: TVector3; const m: TMatrix4): TVector3;
  60.   class operator Divide(const Mtx: TMatrix4; Theta: Single): TMatrix4;
  62.   function GetPos(): TVector3;
  63.  end;
  65. //---------------------------------------------------------------------------
  66. const
  67.  IdentityMtx4: TMatrix4 = (Data: ((1.0, 0.0, 0.0, 0.0), (0.0, 1.0, 0.0, 0.0),
  68.   (0.0, 0.0, 1.0, 0.0), (0.0, 0.0, 0.0, 1.0)));
  70.  ZeroMtx4: TMatrix4 = (Data: ((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0),
  71.   (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0)));
  73. //---------------------------------------------------------------------------
  74. // Matrix Transposition
  75. //---------------------------------------------------------------------------
  76. function TransposeMtx4(const Mtx: TMatrix4): TMatrix4;
  78. //---------------------------------------------------------------------------
  79. // Inverse of the Matrix
  80. //---------------------------------------------------------------------------
  81. function InvertMtx4(const m: TMatrix4): TMatrix4;
  83. //---------------------------------------------------------------------------
  84. // Translation Matrix
  85. //---------------------------------------------------------------------------
  86. function TranslateMtx4(const Offset: TVector3): TMatrix4;
  88. //---------------------------------------------------------------------------
  89. // Scaling Matrix
  90. //---------------------------------------------------------------------------
  91. function ScaleMtx4(const Coef: TVector3): TMatrix4;
  93. //---------------------------------------------------------------------------
  94. // String Representation of Matrix
  95. //---------------------------------------------------------------------------
  96. function StringMtx4(const m: TMatrix4): string;
  98. //---------------------------------------------------------------------------
  99. // Rotation Matrix around X-axis
  100. //---------------------------------------------------------------------------
  101. function RotateXMtx4(Angle: Single): TMatrix4;
  103. //---------------------------------------------------------------------------
  104. // Rotation Matrix around Y-axis
  105. //---------------------------------------------------------------------------
  106. function RotateYMtx4(Angle: Single): TMatrix4;
  108. //---------------------------------------------------------------------------
  109. // Rotation Matrix around Z-axis
  110. //---------------------------------------------------------------------------
  111. function RotateZMtx4(Angle: Single): TMatrix4;
  113. //---------------------------------------------------------------------------
  114. // Rotation Matrix around an arbitrary axis
  115. //---------------------------------------------------------------------------
  116. function RotateMtx4(const Axis: TVector3; Angle: Single): TMatrix4;
  118. //---------------------------------------------------------------------------
  119. // Reflection Matrix
  120. //---------------------------------------------------------------------------
  121. function ReflectMtx4(const Axis: TVector3): TMatrix4;
  123. //---------------------------------------------------------------------------
  124. // Look at given point Matrix (left-handed coordinates)
  125. //---------------------------------------------------------------------------
  126. function LookAtMtx4(const Origin, Target, Roof: TVector3): TMatrix4;
  128. //---------------------------------------------------------------------------
  129. // Perspective Projection with Field of View in Y-axis
  130. //---------------------------------------------------------------------------
  131. function PerspectiveFOVYMtx4(FieldOfView, AspectRatio, MinRange,
  132.  MaxRange: Single): TMatrix4;
  134. //---------------------------------------------------------------------------
  135. // Perspective Projection with Field of View in X-axis
  136. //---------------------------------------------------------------------------
  137. function PerspectiveFOVXMtx4(FieldOfView, AspectRatio, MinRange,
  138.  MaxRange: Single): TMatrix4;
  140. //---------------------------------------------------------------------------
  141. // Perspective Projection with View Volume
  142. //---------------------------------------------------------------------------
  143. function PerspectiveVOLMtx4(Width, Height, MinRange, MaxRange: Single): TMatrix4;
  145. //---------------------------------------------------------------------------
  146. // Perspective Projection with Axis Boundaries
  147. //---------------------------------------------------------------------------
  148. function PerspectiveBDSMtx4(Left, Right, Top, Bottom, MinRange,
  149.  MaxRange: Single): TMatrix4;
  151. //---------------------------------------------------------------------------
  152. // Orthogonal Projection with View Volume
  153. //---------------------------------------------------------------------------
  154. function OrthogonalVOLMtx4(Width, Height, MinRange, MaxRange: Single): TMatrix4;
  156. //---------------------------------------------------------------------------
  157. // Orthogonal Projection with Axis Boundaries
  158. //---------------------------------------------------------------------------
  159. function OrthogonalBDSMtx4(Left, Right, Top, Bottom, MinRange,
  160.  MaxRange: Single): TMatrix4;
  162. //---------------------------------------------------------------------------
  163. // Euler rotation matrix with respective heading, pitch and bank.
  164. //---------------------------------------------------------------------------
  165. function HeadingPitchBankMtx4(Heading, Pitch,
  166.  Bank: Single): TMatrix4; overload;
  167. function HeadingPitchBankMtx4(const v: TVector3): TMatrix4; overload;
  169. //---------------------------------------------------------------------------
  170. {$ifdef SupportD3DX}
  171. function YawPitchRollMtx4(Yaw, Pitch, Roll: Single): TMatrix4; overload;
  172. function YawPitchRollMtx4(const v: TVector3): TMatrix4; overload;
  173. {$endif}
  175. //---------------------------------------------------------------------------
  176. implementation
  178. //--------------------------------------------------------------------------
  179. type
  180.  PLMatrix4 = ^TLMatrix4;
  181.  TLMatrix4 = array[0..15] of Single;
  183. //---------------------------------------------------------------------------
  184. function TMatrix4.GetPos(): TVector3;
  185. var
  186.  View: PLMatrix4;
  187. begin
  188.  View:= @Data[0, 0];
  190.  Result.x:= -View[0] * View[12] - View[1] * View[13] - View[2] * View[14];
  191.  Result.y:= -View[4] * View[12] - View[5] * View[13] - View[6] * View[14];
  192.  Result.z:= -View[8] * View[12] - View[9] * View[13] - View[10] * View[14];
  193. end;
  195. //---------------------------------------------------------------------------
  196. class operator TMatrix4.Add(const a, b: TMatrix4): TMatrix4;
  197. var
  198.  i, j: Integer;
  199. begin
  200.  for j:= 0 to 3 do
  201.   for i:= 0 to 3 do
  202.    Result.Data[j, i]:= a.Data[j, i] + b.Data[j, i];
  203. end;
  205. //---------------------------------------------------------------------------
  206. class operator TMatrix4.Subtract(const a, b: TMatrix4): TMatrix4;
  207. var
  208.  i, j: Integer;
  209. begin
  210.  for j:= 0 to 3 do
  211.   for i:= 0 to 3 do
  212.    Result.Data[j, i]:= a.Data[j, i] - b.Data[j, i];
  213. end;
  215. //---------------------------------------------------------------------------
  216. class operator TMatrix4.Multiply(const a, b: TMatrix4): TMatrix4;
  217. {$ifndef SupportD3DX}
  218. var
  219.  i, j: Integer;
  220. {$endif}
  221. begin
  222.  {$ifdef SupportD3DX}
  223.  D3DXMatrixMultiply(TD3DXMatrix(Result), TD3DXMatrix(a), TD3DXMatrix(b));
  224.  {$else}
  225.  for j:= 0 to 3 do
  226.   for i:= 0 to 3 do
  227.    Result.Data[j, i]:= (a.Data[j, 0] * b.Data[0, i]) +
  228.     (a.Data[j, 1] * b.Data[1, i]) +
  229.     (a.Data[j, 2] * b.Data[2, i]) +
  230.     (a.Data[j, 3] * b.Data[3, i]);
  231.  {$endif}   
  232. end;
  234. //---------------------------------------------------------------------------
  235. class operator TMatrix4.Multiply(const Mtx: TMatrix4; Theta: Single): TMatrix4;
  236. var
  237.  i, j: Integer;
  238. begin
  239.  for j:= 0 to 3 do
  240.   for i:= 0 to 3 do
  241.    Result.Data[j, i]:= Mtx.Data[j, i] * Theta;
  242. end;
  244. //---------------------------------------------------------------------------
  245. class operator TMatrix4.Divide(const Mtx: TMatrix4; Theta: Single): TMatrix4;
  246. var
  247.  i, j: Integer;
  248. begin
  249.  for j:= 0 to 3 do
  250.   for i:= 0 to 3 do
  251.    Result.Data[j, i]:= Mtx.Data[j, i] / Theta;
  252. end;
  254. //---------------------------------------------------------------------------
  255. class operator TMatrix4.Multiply(const v: TVector3;
  256.  const m: TMatrix4): TVector3;
  257. begin
  258.  Result.x:= (v.x * m.Data[0, 0]) + (v.y * m.Data[1, 0]) +
  259.   (v.z * m.Data[2, 0]) + (1.0 * m.Data[3, 0]);
  260.  Result.y:= (v.x * m.Data[0, 1]) + (v.y * m.Data[1, 1]) +
  261.   (v.z * m.Data[2, 1]) + (1.0 * m.Data[3, 1]);
  262.  Result.z:= (v.x * m.Data[0, 2]) + (v.y * m.Data[1, 2]) +
  263.  (v.z * m.Data[2, 2]) + (1.0 * m.Data[3, 2]);
  264. end;
  266. //---------------------------------------------------------------------------
  267. function StringMtx4(const m: TMatrix4): string;
  268. var
  269.  s: string;
  270.  i, j: Integer;
  271. begin
  272.  s:= '{';
  273.  for i:= 0 to 3 do
  274.   begin
  275.    s:= s + '(';
  276.    for j:= 0 to 3 do
  277.     begin
  278.      s:= s + Format('%1.2f', [m.Data[i, j]]);
  279.      if (j < 3) then s:= s + ', ';
  280.     end;
  281.    s:= s + ')';
  282.    if (i < 3) then s:= s + #13#10;
  283.   end;
  284.  Result:= s + '}';
  285. end;
  287. //--------------------------------------------------------------------------
  288. function TransposeMtx4(const Mtx: TMatrix4): TMatrix4;
  289. var
  290.  i, j: Integer;
  291. begin
  292.  for i:= 0 to 3 do
  293.   for j:= 0 to 3 do
  294.    Result.Data[i, j]:= Mtx.Data[j, i];
  295. end;
  297. //---------------------------------------------------------------------------
  298. function TranslateMtx4(const Offset: TVector3): TMatrix4;
  299. begin
  300.  Result:= IdentityMtx4;
  301.  Result.Data[3, 0]:= Offset.x;
  302.  Result.Data[3, 1]:= Offset.y;
  303.  Result.Data[3, 2]:= Offset.z;
  304. end;
  306. //--------------------------------------------------------------------------
  307. function ScaleMtx4(const Coef: TVector3): TMatrix4;
  308. begin
  309.  Result:= IdentityMtx4;
  310.  Result.Data[0, 0]:= Coef.x;
  311.  Result.Data[1, 1]:= Coef.y;
  312.  Result.Data[2, 2]:= Coef.z;
  313. end;
  315. //---------------------------------------------------------------------------
  316. function DetMtx3(a1, a2, a3, b1, b2, b3, c1, c2, c3: Single): Single;
  317. begin
  318.  Result:= a1 * (b2 * c3 - b3 * c2) - b1 * (a2 * c3 - a3 * c2) +
  319.   c1 * (a2 * b3 - a3 * b2);
  320. end;
  322. //---------------------------------------------------------------------------
  323. function AdjointMtx4(const m: TMatrix4): TMatrix4;
  324. begin
  325.  Result.Data[0, 0]:=  DetMtx3(m.Data[1, 1], m.Data[2, 1], m.Data[3, 1],
  326.   m.Data[1, 2], m.Data[2, 2], m.Data[3, 2], m.Data[1, 3], m.Data[2, 3],
  327.   m.Data[3, 3]);
  328.  Result.Data[1, 0]:= -DetMtx3(m.Data[1, 0], m.Data[2, 0], m.Data[3, 0],
  329.   m.Data[1, 2], m.Data[2, 2], m.Data[3, 2], m.Data[1, 3], m.Data[2, 3],
  330.   m.Data[3, 3]);
  331.  Result.Data[2, 0]:=  DetMtx3(m.Data[1, 0], m.Data[2, 0], m.Data[3, 0],
  332.   m.Data[1, 1], m.Data[2, 1], m.Data[3, 1], m.Data[1, 3], m.Data[2, 3],
  333.   m.Data[3, 3]);
  334.  Result.Data[3, 0]:= -DetMtx3(m.Data[1, 0], m.Data[2, 0], m.Data[3, 0],
  335.   m.Data[1, 1], m.Data[2, 1], m.Data[3, 1], m.Data[1, 2], m.Data[2, 2],
  336.   m.Data[3, 2]);
  338.  Result.Data[0, 1]:= -DetMtx3(m.Data[0, 1], m.Data[2, 1], m.Data[3, 1],
  339.   m.Data[0, 2], m.Data[2, 2], m.Data[3, 2], m.Data[0, 3], m.Data[2, 3],
  340.   m.Data[3, 3]);
  341.  Result.Data[1, 1]:=  DetMtx3(m.Data[0, 0], m.Data[2, 0], m.Data[3, 0],
  342.   m.Data[0, 2], m.Data[2, 2], m.Data[3, 2], m.Data[0, 3], m.Data[2, 3],
  343.   m.Data[3, 3]);
  344.  Result.Data[2, 1]:= -DetMtx3(m.Data[0, 0], m.Data[2, 0], m.Data[3, 0],
  345.   m.Data[0, 1], m.Data[2, 1], m.Data[3, 1], m.Data[0, 3], m.Data[2, 3],
  346.   m.Data[3, 3]);
  347.  Result.Data[3, 1]:=  DetMtx3(m.Data[0, 0], m.Data[2, 0], m.Data[3, 0],
  348.   m.Data[0, 1], m.Data[2, 1], m.Data[3, 1], m.Data[0, 2], m.Data[2, 2],
  349.   m.Data[3, 2]);
  351.  Result.Data[0, 2]:=  DetMtx3(m.Data[0, 1], m.Data[1, 1], m.Data[3, 1],
  352.   m.Data[0, 2], m.Data[1, 2], m.Data[3, 2], m.Data[0, 3], m.Data[1, 3],
  353.   m.Data[3, 3]);
  354.  Result.Data[1, 2]:= -DetMtx3(m.Data[0, 0], m.Data[1, 0], m.Data[3, 0],
  355.   m.Data[0, 2], m.Data[1, 2], m.Data[3, 2], m.Data[0, 3], m.Data[1, 3],
  356.   m.Data[3, 3]);
  357.  Result.Data[2, 2]:=  DetMtx3(m.Data[0, 0], m.Data[1, 0], m.Data[3, 0],
  358.   m.Data[0, 1], m.Data[1, 1], m.Data[3, 1], m.Data[0, 3], m.Data[1, 3],
  359.   m.Data[3, 3]);
  360.  Result.Data[3, 2]:= -DetMtx3(m.Data[0, 0], m.Data[1, 0], m.Data[3, 0],
  361.   m.Data[0, 1], m.Data[1, 1], m.Data[3, 1], m.Data[0, 2], m.Data[1, 2],
  362.   m.Data[3, 2]);
  364.  Result.Data[0, 3]:= -DetMtx3(m.Data[0, 1], m.Data[1, 1], m.Data[2, 1],
  365.   m.Data[0, 2], m.Data[1, 2], m.Data[2, 2], m.Data[0, 3], m.Data[1, 3],
  366.   m.Data[2, 3]);
  367.  Result.Data[1, 3]:=  DetMtx3(m.Data[0, 0], m.Data[1, 0], m.Data[2, 0],
  368.   m.Data[0, 2], m.Data[1, 2], m.Data[2, 2], m.Data[0, 3], m.Data[1, 3],
  369.   m.Data[2, 3]);
  370.  Result.Data[2, 3]:= -DetMtx3(m.Data[0, 0], m.Data[1, 0], m.Data[2, 0],
  371.   m.Data[0, 1], m.Data[1, 1], m.Data[2, 1], m.Data[0, 3], m.Data[1, 3],
  372.   m.Data[2, 3]);
  373.  Result.Data[3, 3]:=  DetMtx3(m.Data[0, 0], m.Data[1, 0], m.Data[2, 0],
  374.   m.Data[0, 1], m.Data[1, 1], m.Data[2, 1], m.Data[0, 2], m.Data[1, 2],
  375.   m.Data[2, 2]);
  376. end;
  378. //---------------------------------------------------------------------------
  379. function DetMtx4(const m: TMatrix4): Single;
  380. begin
  381.  {$ifdef SupportD3DX}
  382.  Result:= D3DXMatrixDeterminant(TD3DXMatrix(m));
  383.  {$else}
  384.  Result:= m.Data[0, 0] * DetMtx3(m.Data[1, 1], m.Data[2, 1], m.Data[3, 1],
  385.   m.Data[1, 2], m.Data[2, 2], m.Data[3, 2], m.Data[1, 3], m.Data[2, 3],
  386.   m.Data[3, 3]) - m.Data[0, 1] * DetMtx3(m.Data[1, 0], m.Data[2, 0],
  387.   m.Data[3, 0], m.Data[1, 2], m.Data[2, 2], m.Data[3, 2], m.Data[1, 3],
  388.   m.Data[2, 3], m.Data[3, 3]) + m.Data[0, 2] * DetMtx3(m.Data[1, 0],
  389.   m.Data[2, 0], m.Data[3, 0], m.Data[1, 1], m.Data[2, 1], m.Data[3, 1],
  390.   m.Data[1, 3], m.Data[2, 3], m.Data[3, 3]) - m.Data[0, 3] *
  391.   DetMtx3(m.Data[1, 0], m.Data[2, 0], m.Data[3, 0], m.Data[1, 1],
  392.   m.Data[2, 1], m.Data[3, 1], m.Data[1, 2], m.Data[2, 2], m.Data[3, 2]);
  393.  {$endif}
  394. end;
  396. //---------------------------------------------------------------------------
  397. function InvertMtx4(const m: TMatrix4): TMatrix4;
  398. {$ifndef SupportD3DX}
  399. var
  400.  Det: Single;
  401. {$endif}
  402. begin
  403.  {$ifdef SupportD3DX}
  404.  D3DXMatrixInverse(TD3DXMatrix(Result), nil, TD3DXMatrix(m));
  405.  {$else}
  406.  Det:= DetMtx4(m);
  407.  if (Det <> 0.0) then
  408.   begin
  409.    Result:= AdjointMtx4(m) / Det;
  410.   end else Result:= IdentityMtx4
  411.  {$endif} 
  412. end;
  414. //--------------------------------------------------------------------------
  415. function RotateXMtx4(Angle: Single): TMatrix4;
  416. begin
  417.  {$ifdef SupportD3DX}
  418.  D3DXMatrixRotationX(TD3DXMatrix(Result), Angle);
  419.  {$else}
  420.  Result:= IdentityMtx4;
  422.  Result.Data[1, 1]:=  Cos(Angle);
  423.  Result.Data[1, 2]:=  Sin(Angle);
  424.  Result.Data[2, 1]:= -Result.Data[1, 2];
  425.  Result.Data[2, 2]:=  Result.Data[1, 1];
  426.  {$endif}
  427. end;
  429. //--------------------------------------------------------------------------
  430. function RotateYMtx4(Angle: Single): TMatrix4;
  431. begin
  432.  {$ifdef SupportD3DX}
  433.  D3DXMatrixRotationY(TD3DXMatrix(Result), Angle);
  434.  {$else}
  435.  Result:= IdentityMtx4;
  437.  Result.Data[0, 0]:=  Cos(Angle);
  438.  Result.Data[0, 2]:= -Sin(Angle);
  439.  Result.Data[2, 0]:= -Result.Data[0, 2];
  440.  Result.Data[2, 2]:=  Result.Data[0, 0];
  441.  {$endif}
  442. end;
  444. //--------------------------------------------------------------------------
  445. function RotateZMtx4(Angle: Single): TMatrix4;
  446. begin
  447.  {$ifdef SupportD3DX}
  448.  D3DXMatrixRotationZ(TD3DXMatrix(Result), Angle);
  449.  {$else}
  450.  Result:= IdentityMtx4;
  452.  Result.Data[0, 0]:=  Cos(Angle);
  453.  Result.Data[0, 1]:=  Sin(Angle);
  454.  Result.Data[1, 0]:= -Result.Data[0, 1];
  455.  Result.Data[1, 1]:=  Result.Data[0, 0];
  456.  {$endif}
  457. end;
  459. //--------------------------------------------------------------------------
  460. function RotateMtx4(const Axis: TVector3; Angle: Single): TMatrix4;
  461. {$ifndef SupportD3DX}
  462. var
  463.  CosTh, iCosTh, SinTh: Single;
  464.  xy, xz, yz, xSin, ySin, zSin: Single;
  465. {$endif}
  466. begin
  467.  {$ifdef SupportD3DX}
  468.  D3DXMatrixRotationAxis(TD3DXMatrix(Result), TD3DXVector3(Axis), Angle);
  469.  {$else}
  470.  CosTh := Cos(Angle);
  471.  iCosTh:= 1.0 - CosTh;
  472.  SinTh := Sin(Angle);
  473.  xy    := Axis.x * Axis.y * iCosTh;
  474.  xz    := Axis.x * Axis.z * iCosTh;
  475.  yz    := Axis.y * Axis.z * iCosTh;
  476.  xSin  := Axis.x * SinTh;
  477.  ySin  := Axis.y * SinTh;
  478.  zSin  := Axis.z * SinTh;
  480.  Result:= IdentityMtx4;
  481.  Result.Data[0, 0]:= (Sqr(Axis.x) * iCosTh) + CosTh;
  482.  Result.Data[0, 1]:= xy + zSin;
  483.  Result.Data[0, 2]:= xz - ySin;
  484.  Result.Data[1, 0]:= xy - zSin;
  485.  Result.Data[1, 1]:= (Sqr(Axis.y) * iCosTh) + CosTh;
  486.  Result.Data[1, 2]:= yz + xSin;
  487.  Result.Data[2, 0]:= xz + ySin;
  488.  Result.Data[2, 1]:= yz - xSin;
  489.  Result.Data[2, 2]:= (Sqr(Axis.z) * iCosTh) + CosTh;
  490.  {$endif}
  491. end;
  493. //---------------------------------------------------------------------------
  494. function ReflectMtx4(const Axis: TVector3): TMatrix4;
  495. var
  496.  xy, yz, xz: Single;
  497. begin
  498.  xy:= -2.0 * Axis.x * Axis.y;
  499.  xz:= -2.0 * Axis.x * Axis.z;
  500.  yz:= -2.0 * Axis.y * Axis.z;
  502.  Result:= IdentityMtx4;
  503.  Result.Data[0, 0]:= 1.0 - (2.0 * Sqr(Axis.x));
  504.  Result.Data[0, 1]:= xy;
  505.  Result.Data[0, 2]:= xz;
  506.  Result.Data[1, 0]:= xy;
  507.  Result.Data[1, 1]:= 1.0 - (2.0 * Sqr(Axis.y));
  508.  Result.Data[1, 2]:= yz;
  509.  Result.Data[2, 0]:= xz;
  510.  Result.Data[2, 1]:= yz;
  511.  Result.Data[2, 2]:= 1.0 - (2.0 * Sqr(Axis.z));
  512. end;
  514. //---------------------------------------------------------------------------
  515. function LookAtMtx4(const Origin, Target, Roof: TVector3): TMatrix4;
  516. {$ifndef SupportD3DX}
  517. var
  518.  xAxis, yAxis, zAxis: TVector3;
  519. {$endif}
  520. begin
  521.  {$ifdef SupportD3DX}
  522.  D3DXMatrixLookAtLH(TD3DXMatrix(Result), TD3DXVector3(Origin),
  523.   TD3DXVector3(Target), TD3DXVector3(Roof));
  524.  {$else}
  525.  zAxis:= Norm3(Target - Origin);
  526.  xAxis:= Norm3(Cross3(Roof, zAxis));
  527.  yAxis:= Cross3(zAxis, xAxis);
  529.  Result.Data[0, 0]:= xAxis.x;
  530.  Result.Data[0, 1]:= yAxis.x;
  531.  Result.Data[0, 2]:= zAxis.x;
  532.  Result.Data[0, 3]:= 0.0;
  534.  Result.Data[1, 0]:= xAxis.y;
  535.  Result.Data[1, 1]:= yAxis.y;
  536.  Result.Data[1, 2]:= zAxis.y;
  537.  Result.Data[1, 3]:= 0.0;
  539.  Result.Data[2, 0]:= xAxis.z;
  540.  Result.Data[2, 1]:= yAxis.z;
  541.  Result.Data[2, 2]:= zAxis.z;
  542.  Result.Data[2, 3]:= 0.0;
  544.  Result.Data[3, 0]:= -Dot3(xAxis, Origin);
  545.  Result.Data[3, 1]:= -Dot3(yAxis, Origin);
  546.  Result.Data[3, 2]:= -Dot3(zAxis, Origin);
  547.  Result.Data[3, 3]:= 1.0;
  548.  {$endif}
  549. end;
  551. //---------------------------------------------------------------------------
  552. function PerspectiveFOVYMtx4(FieldOfView, AspectRatio, MinRange,
  553.  MaxRange: Single): TMatrix4;
  554. var
  555.  xScale, yScale, zCoef: Single;
  556. begin
  557.  yScale:= Cot(FieldOfView * 0.5);
  558.  xScale:= yScale / AspectRatio;
  559.  zCoef := MaxRange / (MaxRange - MinRange);
  561.  Result:= ZeroMtx4;
  563.  Result.Data[0, 0]:= xScale;
  564.  Result.Data[1, 1]:= yScale;
  565.  Result.Data[2, 2]:= zCoef;
  566.  Result.Data[2, 3]:= 1.0;
  567.  Result.Data[3, 2]:= -MinRange * zCoef;
  568. end;
  570. //---------------------------------------------------------------------------
  571. function PerspectiveFOVXMtx4(FieldOfView, AspectRatio, MinRange,
  572.  MaxRange: Single): TMatrix4;
  573. var
  574.  xScale, yScale, zCoef: Single;
  575. begin
  576.  xScale:= Cot(FieldOfView * 0.5);
  577.  yScale:= xScale / AspectRatio;
  578.  zCoef := MaxRange / (MaxRange - MinRange);
  580.  Result:= ZeroMtx4;
  582.  Result.Data[0, 0]:= xScale;
  583.  Result.Data[1, 1]:= yScale;
  584.  Result.Data[2, 2]:= zCoef;
  585.  Result.Data[2, 3]:= 1.0;
  586.  Result.Data[3, 2]:= -MinRange * zCoef;
  587. end;
  589. //---------------------------------------------------------------------------
  590. function PerspectiveVOLMtx4(Width, Height, MinRange, MaxRange: Single): TMatrix4;
  591. begin
  592.  Result:= ZeroMtx4;
  594.  Result.Data[0, 0]:= (2.0 * MinRange) / Width;
  595.  Result.Data[1, 1]:= (2.0 * MinRange) / Height;
  596.  Result.Data[2, 2]:= MaxRange / (MaxRange - MinRange);
  597.  Result.Data[2, 3]:= 1.0;
  598.  Result.Data[3, 2]:= MinRange * MaxRange / (MinRange - MaxRange);
  599. end;
  601. //---------------------------------------------------------------------------
  602. function PerspectiveBDSMtx4(Left, Right, Top, Bottom, MinRange,
  603.  MaxRange: Single): TMatrix4;
  604. begin
  605.  Result:= ZeroMtx4;
  607.  Result.Data[0, 0]:= (2.0 * MinRange) / (Right - Left);
  608.  Result.Data[1, 1]:= (2.0 * MinRange) / (Top - Bottom);
  610.  Result.Data[2, 0]:= (Left + Right) / (Left - Right);
  611.  Result.Data[2, 1]:= (Top + Bottom) / (Bottom - Top);
  612.  Result.Data[2, 2]:= MaxRange / (MaxRange - MinRange);
  613.  Result.Data[2, 3]:= 1.0;
  614.  Result.Data[3, 2]:= MinRange * MaxRange / (MinRange - MaxRange);
  615. end;
  617. //---------------------------------------------------------------------------
  618. function OrthogonalVOLMtx4(Width, Height, MinRange, MaxRange: Single): TMatrix4;
  619. begin
  620.  Result:= ZeroMtx4;
  622.  Result.Data[0, 0]:= 2.0 / Width;
  623.  Result.Data[1, 1]:= 2.0 / Height;
  624.  Result.Data[2, 2]:= 1.0 / (MaxRange - MinRange);
  625.  Result.Data[2, 3]:= MinRange / (MinRange - MaxRange);
  626.  Result.Data[3, 3]:= 1.0;
  627. end;
  629. //---------------------------------------------------------------------------
  630. function OrthogonalBDSMtx4(Left, Right, Top, Bottom, MinRange,
  631.  MaxRange: Single): TMatrix4;
  632. begin
  633.  Result:= ZeroMtx4;
  635.  Result.Data[0, 0]:= 2.0 / (Right - Left);
  636.  Result.Data[1, 1]:= 2.0 / (Top - Bottom);
  637.  Result.Data[2, 2]:= 1.0 / (MaxRange - MinRange);
  638.  Result.Data[2, 3]:= MinRange / (MinRange - MaxRange);
  639.  Result.Data[3, 0]:= (Left + Right) / (Left - Right);
  640.  Result.Data[3, 1]:= (Top + Bottom) / (Bottom - Top);
  641.  Result.Data[3, 2]:= MinRange / (MinRange - MaxRange);
  642.  Result.Data[3, 3]:= 1.0;
  643. end;
  645. //--------------------------------------------------------------------------
  646. function HeadingPitchBankMtx4(Heading, Pitch, Bank: Single): TMatrix4;
  647. var
  648.  CosH, SinH: Single;
  649.  CosP, SinP: Single;
  650.  CosB, SinB: Single;
  651. begin
  652.  Result:= IdentityMtx4;
  654.  CosH:= Cos(Heading);
  655.  SinH:= Sin(Heading);
  656.  CosP:= Cos(Pitch);
  657.  SinP:= Sin(Pitch);
  658.  CosB:= Cos(Bank);
  659.  SinB:= Sin(Bank);
  661.  Result.Data[0, 0]:= (CosH * CosB) + (SinH * SinP * SinB);
  662.  Result.Data[0, 1]:= (-CosH * SinB) + (SinH * SinP * CosB);
  663.  Result.Data[0, 2]:= SinH * CosP;
  664.  Result.Data[1, 0]:= SinB * CosP;
  665.  Result.Data[1, 1]:= CosB * CosP;
  666.  Result.Data[1, 2]:= -SinP;
  667.  Result.Data[2, 0]:= (-SinH * CosB) + (CosH * SinP * SinB);
  668.  Result.Data[2, 1]:= (SinB * SinH) + (CosH * SinP * CosB);
  669.  Result.Data[2, 2]:= CosH * CosP;
  670. end;
  672. //---------------------------------------------------------------------------
  673. function HeadingPitchBankMtx4(const v: TVector3): TMatrix4; overload;
  674. begin
  675.  Result:= HeadingPitchBankMtx4(v.y, v.x, v.z);
  676. end;
  678. //---------------------------------------------------------------------------
  679. {$ifdef SupportD3DX}
  680. function YawPitchRollMtx4(Yaw, Pitch, Roll: Single): TMatrix4; overload;
  681. begin
  682.  D3DXMatrixRotationYawPitchRoll(TD3DXMatrix(Result), Yaw, Pitch, Roll);
  683. end;
  685. //---------------------------------------------------------------------------
  686. function YawPitchRollMtx4(const v: TVector3): TMatrix4; overload;
  687. begin
  688.  D3DXMatrixRotationYawPitchRoll(TD3DXMatrix(Result), v.y, v.x, v.z);
  689. end;
  690. {$endif}
  692. //---------------------------------------------------------------------------
  693. end.