System.Math.Vectors.TPoint3D

• Aller au parent : System.Math.Vectors
• Méthodes
• Champs
• Types

Delphi

  TPoint3D = record
    type
      TPoint3DArray = array [0..2] of Single;
    class function Create(const AX, AY, AZ: Single): TPoint3D; overload; static; inline;
    class function Create(const P: TVector3DType): TPoint3D; overload; static; inline;
    class function Create(const APoint: TPointF; const AZ: Single = 0.0): TPoint3D; overload; static; inline;
    class operator Add(const APoint1, APoint2: TPoint3D): TPoint3D;
    class operator Subtract(const APoint1, APoint2: TPoint3D): TPoint3D;
    class operator Equal(const APoint1, APoint2: TPoint3D): Boolean; inline;
    class operator NotEqual(const APoint1, APoint2: TPoint3D): Boolean; inline;
    class operator Negative(const APoint: TPoint3D): TPoint3D;
    class operator Multiply(const APoint1, APoint2: TPoint3D): TPoint3D;
    class operator Multiply(const APoint: TPoint3D; const AFactor: Single): TPoint3D; inline;
    class operator Multiply(const AFactor: Single; const APoint: TPoint3D): TPoint3D; inline;
    class operator Divide(const APoint: TPoint3D; const AFactor: Single): TPoint3D;
    class function Zero: TPoint3D; inline; static;
    procedure Offset(const ADelta: TPoint3D); overload; inline;
    procedure Offset(const ADeltaX, ADeltaY, ADeltaZ: Single); overload; inline;
    function CrossProduct(const APoint: TPoint3D): TPoint3D;
    function DotProduct(const APoint: TPoint3D): Single; inline;
    function EqualsTo(const APoint: TPoint3D; const Epsilon: Single = 0): Boolean; inline;
    function Length: Single; inline;
    function Normalize: TPoint3D;
    function Distance(const APoint: TPoint3D): Single;
    function Rotate(const AAxis: TPoint3D; const AAngle: Single): TPoint3D; inline;
    function Reflect(const APoint: TPoint3D): TPoint3D; inline;
    function MidPoint(const APoint: TPoint3D): TPoint3D; inline;
    function AngleCosine(const APoint: TPoint3D): Single;
    case Integer of
      0: (V: TPoint3DArray;);
      1: (X: Single;
          Y: Single;
          Z: Single;);
  end;

C++

struct DECLSPEC_DRECORD TPoint3D
{
public:
    typedef System::StaticArray<float, 3> TPoint3DArray;
public:
    static TPoint3D __fastcall Create(const float AX, const float AY, const float AZ)/* overload */;
    static TPoint3D __fastcall Create(const TVector3DType &P)/* overload */;
    static TPoint3D __fastcall Create(const System::Types::TPointF &APoint, const float AZ = 0.000000E+00f)/* overload */;
    static TPoint3D __fastcall _op_Addition(const TPoint3D &APoint1, const TPoint3D &APoint2);
    static TPoint3D __fastcall _op_Subtraction(const TPoint3D &APoint1, const TPoint3D &APoint2);
    static bool __fastcall _op_Equality(const TPoint3D &APoint1, const TPoint3D &APoint2);
    static bool __fastcall _op_Inequality(const TPoint3D &APoint1, const TPoint3D &APoint2);
    static TPoint3D __fastcall _op_UnaryNegation(const TPoint3D &APoint);
    static TPoint3D __fastcall _op_Multiply(const TPoint3D &APoint1, const TPoint3D &APoint2);
    static TPoint3D __fastcall _op_Multiply(const TPoint3D &APoint, const float AFactor);
    static TPoint3D __fastcall _op_Multiply(const float AFactor, const TPoint3D &APoint);
    static TPoint3D __fastcall _op_Division(const TPoint3D &APoint, const float AFactor);
    static TPoint3D __fastcall Zero();
    void __fastcall Offset(const TPoint3D &ADelta)/* overload */;
    void __fastcall Offset(const float ADeltaX, const float ADeltaY, const float ADeltaZ)/* overload */;
    TPoint3D __fastcall CrossProduct(const TPoint3D &APoint);
    float __fastcall DotProduct(const TPoint3D &APoint);
    bool __fastcall EqualsTo(const TPoint3D &APoint, const float Epsilon = 0.000000E+00f);
    float __fastcall Length();
    TPoint3D __fastcall Normalize();
    float __fastcall Distance(const TPoint3D &APoint);
    TPoint3D __fastcall Rotate(const TPoint3D &AAxis, const float AAngle);
    TPoint3D __fastcall Reflect(const TPoint3D &APoint);
    TPoint3D __fastcall MidPoint(const TPoint3D &APoint);
    float __fastcall AngleCosine(const TPoint3D &APoint);
    friend TPoint3D operator +(const TPoint3D &APoint1, const TPoint3D &APoint2) { return TPoint3D::_op_Addition(APoint1, APoint2); }
    friend TPoint3D operator -(const TPoint3D &APoint1, const TPoint3D &APoint2) { return TPoint3D::_op_Subtraction(APoint1, APoint2); }
    friend bool operator ==(const TPoint3D &APoint1, const TPoint3D &APoint2) { return TPoint3D::_op_Equality(APoint1, APoint2); }
    friend bool operator !=(const TPoint3D &APoint1, const TPoint3D &APoint2) { return TPoint3D::_op_Inequality(APoint1, APoint2); }
    TPoint3D operator -() { return TPoint3D::_op_UnaryNegation(*this); }
    friend TPoint3D operator *(const TPoint3D &APoint1, const TPoint3D &APoint2) { return TPoint3D::_op_Multiply(APoint1, APoint2); }
    friend TPoint3D operator *(const TPoint3D &APoint, const float AFactor) { return TPoint3D::_op_Multiply(APoint, AFactor); }
    friend TPoint3D operator *(const float AFactor, const TPoint3D &APoint) { return TPoint3D::_op_Multiply(AFactor, APoint); }
    friend TPoint3D operator /(const TPoint3D &APoint, const float AFactor) { return TPoint3D::_op_Division(APoint, AFactor); }
public:
    union
    {
        struct
        {
            float X;
            float Y;
            float Z;
        };
        struct
        {
            TPoint3DArray V;
        };
    };
};

Propriétés

Type	Visibilité	Source	Unité	Parent
record struct	public	System.Math.Vectors.pas System.Math.Vectors.hpp	System.Math.Vectors	System.Math.Vectors

Description

Représente un point dans l'espace 3D.

TPoint3D décrit un point dans l'espace 3D relatif aux axes X, Y et Z.