# System.Math.Vectors.TMatrix

Delphi

```  TMatrix = record
private
function Scale(const AFactor: Single): TMatrix;
public
class function CreateRotation(const AAngle: Single): TMatrix; static;
class function CreateScaling(const AScaleX, AScaleY: Single): TMatrix; static;
class operator Multiply(const AMatrix1, AMatrix2: TMatrix): TMatrix;
class operator Multiply(const APoint: TPointF; const AMatrix: TMatrix): TPointF;
class operator Multiply(const AVector: TVector; const AMatrix: TMatrix): TVector;
class operator Multiply(const AVector: TPoint3D; const AMatrix: TMatrix): TPoint3D;
class operator Equal(const RightMatrix, LeftMatrix: TMatrix): Boolean; static;
function Determinant: Single;
function Inverse: TMatrix;
function ExtractScale: TPointF;
function EqualsTo(const AMatrix: TMatrix; const Epsilon: Single = TEpsilon.Matrix): Boolean;
case Integer of
0: (M: TMatrixArray;);
1: (m11, m12, m13: Single;
m21, m22, m23: Single;
m31, m32, m33: Single);
end;
```

C++

```struct DECLSPEC_DRECORD TMatrix
{
private:
TMatrix __fastcall Scale(const float AFactor);
public:
static TMatrix __fastcall CreateRotation(const float AAngle);
static TMatrix __fastcall CreateScaling(const float AScaleX, const float AScaleY);
static TMatrix __fastcall _op_Multiply(const TMatrix &AMatrix1, const TMatrix &AMatrix2);
static System::Types::TPointF __fastcall _op_Multiply(const System::Types::TPointF &APoint, const TMatrix &AMatrix);
static TVector __fastcall _op_Multiply(const TVector &AVector, const TMatrix &AMatrix);
static TPoint3D __fastcall _op_Multiply(const TPoint3D &AVector, const TMatrix &AMatrix);
static bool __fastcall _op_Equality(const TMatrix &RightMatrix, const TMatrix &LeftMatrix);
float __fastcall Determinant();
TMatrix __fastcall Inverse();
System::Types::TPointF __fastcall ExtractScale();
bool __fastcall EqualsTo(const TMatrix &AMatrix, const float Epsilon = 1.000000E-05f);
friend TMatrix operator *(const TMatrix &AMatrix1, const TMatrix &AMatrix2) { return TMatrix::_op_Multiply(AMatrix1, AMatrix2); }
friend System::Types::TPointF operator *(const System::Types::TPointF &APoint, const TMatrix &AMatrix) { return TMatrix::_op_Multiply(APoint, AMatrix); }
friend TVector operator *(const TVector &AVector, const TMatrix &AMatrix) { return TMatrix::_op_Multiply(AVector, AMatrix); }
friend TPoint3D operator *(const TPoint3D &AVector, const TMatrix &AMatrix) { return TMatrix::_op_Multiply(AVector, AMatrix); }
friend bool operator ==(const TMatrix &RightMatrix, const TMatrix &LeftMatrix) { return TMatrix::_op_Equality(RightMatrix, LeftMatrix); }
public:
union
{
struct
{
float m11;
float m12;
float m13;
float m21;
float m22;
float m23;
float m31;
float m32;
float m33;
};
struct
{
System::Math::Vectors::TMaxtrixArrayBase M;
};
};
};
```

#### Eigenschaften

Typ Sichtbarkeit Quelle Unit Übergeordnet
record
struct
public
System.Math.Vectors.pas
System.Math.Vectors.hpp
System.Math.Vectors System.Math.Vectors

## Beschreibung

Embarcadero Technologies verfügt zurzeit über keine zusätzlichen Informationen. Bitte unterstützen Sie uns bei der Dokumentation dieses Themas, indem Sie Ihre Kommentare auf der Diskussionsseite eingeben.