2

我正在使用 DirectXMath（或 XNAMath）库（在 Windows SDK 的 DirectXMath.h 头文件中定义），因为它看起来非常高效，并提供了物理和渲染所需的一切。但是我发现它非常冗长（到处使用 XMStoreFloatX 和 XMLoadFloatX 很累）。

我试图让它更容易操作，并想出了在赋值运算符/转换运算符中隐藏 Stores/Loads 的想法。由于这两个都必须是成员函数，因此我想出了以下代码作为示例：

struct Vector2F : public DirectX::XMFLOAT2 {
    inline Vector2F() : DirectX::XMFLOAT2() {};
    inline Vector2F(float x, float y) : DirectX::XMFLOAT2(x, y) {};
    inline Vector2F(float const * pArray) : DirectX::XMFLOAT2(pArray) {};

    inline Vector2F(DirectX::XMVECTOR vector) {
        DirectX::XMStoreFloat2(this, vector);
    }
    inline Vector2F& __vectorcall operator= (DirectX::XMVECTOR vector) {
        DirectX::XMStoreFloat2(this, vector);
        return *this;
    }

    inline __vectorcall operator DirectX::XMVECTOR() {
        return DirectX::XMLoadFloat2(this);
    }
};

如您所见，它复制了 XMFLOAT2 的公共接口，并为 XMVECTOR 添加了构造函数、赋值运算符和转换，这是 DirectXMath 用于计算的 SIMD 类型。我打算为 DirectXMath 提供的每个存储结构执行此操作。

性能对于数学库来说是一个非常重要的因素，因此我的问题是：这种继承的性能影响是什么？与库的正常使用相比，是否生成了任何额外的代码（当然假设完全优化）？

直观地说，生成的代码应该与我在没有这些便利运算符的情况下使用详细变体时完全相同，因为我本质上只是重命名结构和函数。但也许有些方面我不知道？

PS 我有点担心赋值运算符的返回类型，因为它添加了额外的代码。省略引用返回以优化它会是一个好主意吗？

4

1 回答 1

2

如果您发现DirectXMath对于您的口味来说有点过于冗长，请查看DirectX Tool Kit中的SimpleMath。特别是，类：Vector2

struct Vector2 : public XMFLOAT2
{
    Vector2() : XMFLOAT2(0.f, 0.f) {}
    explicit Vector2(float x) : XMFLOAT2( x, x ) {}
    Vector2(float _x, float _y) : XMFLOAT2(_x, _y) {}
    explicit Vector2(_In_reads_(2) const float *pArray) : XMFLOAT2(pArray) {}
    Vector2(FXMVECTOR V) { XMStoreFloat2( this, V ); }
    Vector2(const XMFLOAT2& V) { this->x = V.x; this->y = V.y; }
    explicit Vector2(const XMVECTORF32& F) { this->x = F.f[0]; this->y = F.f[1]; }

    operator XMVECTOR() const { return XMLoadFloat2( this ); }

    // Comparison operators
    bool operator == ( const Vector2& V ) const;
    bool operator != ( const Vector2& V ) const;

    // Assignment operators
    Vector2& operator= (const Vector2& V) { x = V.x; y = V.y; return *this; }
    Vector2& operator= (const XMFLOAT2& V) { x = V.x; y = V.y; return *this; }
    Vector2& operator= (const XMVECTORF32& F) { x = F.f[0]; y = F.f[1]; return *this; }
    Vector2& operator+= (const Vector2& V);
    Vector2& operator-= (const Vector2& V);
    Vector2& operator*= (const Vector2& V);
    Vector2& operator*= (float S);
    Vector2& operator/= (float S);

    // Unary operators
    Vector2 operator+ () const { return *this; }
    Vector2 operator- () const { return Vector2(-x, -y); }

    // Vector operations
    bool InBounds( const Vector2& Bounds ) const;

    float Length() const;
    float LengthSquared() const;

    float Dot( const Vector2& V ) const;
    void Cross( const Vector2& V, Vector2& result ) const;
    Vector2 Cross( const Vector2& V ) const;

    void Normalize();
    void Normalize( Vector2& result ) const;

    void Clamp( const Vector2& vmin, const Vector2& vmax );
    void Clamp( const Vector2& vmin, const Vector2& vmax, Vector2& result ) const;

    // Static functions
    static float Distance( const Vector2& v1, const Vector2& v2 );
    static float DistanceSquared( const Vector2& v1, const Vector2& v2 );

    static void Min( const Vector2& v1, const Vector2& v2, Vector2& result );
    static Vector2 Min( const Vector2& v1, const Vector2& v2 );

    static void Max( const Vector2& v1, const Vector2& v2, Vector2& result );
    static Vector2 Max( const Vector2& v1, const Vector2& v2 );

    static void Lerp( const Vector2& v1, const Vector2& v2, float t, Vector2& result );
    static Vector2 Lerp( const Vector2& v1, const Vector2& v2, float t );

    static void SmoothStep( const Vector2& v1, const Vector2& v2, float t, Vector2& result );
    static Vector2 SmoothStep( const Vector2& v1, const Vector2& v2, float t );

    static void Barycentric( const Vector2& v1, const Vector2& v2, const Vector2& v3, float f, float g, Vector2& result );
    static Vector2 Barycentric( const Vector2& v1, const Vector2& v2, const Vector2& v3, float f, float g );

    static void CatmullRom( const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4, float t, Vector2& result );
    static Vector2 CatmullRom( const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4, float t );

    static void Hermite( const Vector2& v1, const Vector2& t1, const Vector2& v2, const Vector2& t2, float t, Vector2& result );
    static Vector2 Hermite( const Vector2& v1, const Vector2& t1, const Vector2& v2, const Vector2& t2, float t );

    static void Reflect( const Vector2& ivec, const Vector2& nvec, Vector2& result );
    static Vector2 Reflect( const Vector2& ivec, const Vector2& nvec );

    static void Refract( const Vector2& ivec, const Vector2& nvec, float refractionIndex, Vector2& result );
    static Vector2 Refract( const Vector2& ivec, const Vector2& nvec, float refractionIndex );

    static void Transform( const Vector2& v, const Quaternion& quat, Vector2& result );
    static Vector2 Transform( const Vector2& v, const Quaternion& quat );

    static void Transform( const Vector2& v, const Matrix& m, Vector2& result );
    static Vector2 Transform( const Vector2& v, const Matrix& m );
    static void Transform( _In_reads_(count) const Vector2* varray, size_t count, const Matrix& m, _Out_writes_(count) Vector2* resultArray );

    static void Transform( const Vector2& v, const Matrix& m, Vector4& result );
    static void Transform( _In_reads_(count) const Vector2* varray, size_t count, const Matrix& m, _Out_writes_(count) Vector4* resultArray );

    static void TransformNormal( const Vector2& v, const Matrix& m, Vector2& result );
    static Vector2 TransformNormal( const Vector2& v, const Matrix& m );
    static void TransformNormal( _In_reads_(count) const Vector2* varray, size_t count, const Matrix& m, _Out_writes_(count) Vector2* resultArray );

    // Constants
    static const Vector2 Zero;
    static const Vector2 One;
    static const Vector2 UnitX;
    static const Vector2 UnitY;
};

// Binary operators
Vector2 operator+ (const Vector2& V1, const Vector2& V2);
Vector2 operator- (const Vector2& V1, const Vector2& V2);
Vector2 operator* (const Vector2& V1, const Vector2& V2);
Vector2 operator* (const Vector2& V, float S);
Vector2 operator/ (const Vector2& V1, const Vector2& V2);
Vector2 operator* (float S, const Vector2& V);

DirectXMath 如此冗长的主要原因首先是为了让程序员在“溢出到内存”时非常清楚，因为这往往会对 SIMD 代码的性能产生负面影响。当我从 XNAMath 迁移到 DirectXMath 时，我曾考虑添加类似用于“SimpleMath”的隐式转换，但我想确保任何此类“C++ 魔法”都是可选的，并且不会让对性能敏感的人感到意外开发商。SimpleMath 的作用也有点像训练轮，可以更轻松地移植不支持对齐的现有代码，并随着时间的推移将其转变为对 SIMD 更友好的东西。

SimpleMath（和您的包装器）的真正性能问题是每个函数实现都必须围绕相当少量的 SIMD 执行显式加载和存储。理想情况下，在优化的代码中它们都会被合并掉，但在调试代码中它们总是存在的。为了从 SIMD 获得真正的性能优势，您希望在每个加载和存储对之间进行长时间的寄存器内 SIMD 操作。

另一个含义是传递一个包装器的参数Vector2或者你Vector2F永远不会特别有效。XMVECTOR使用 typedef__m128而不是 struct的全部原因，以及FXMVECTOR, GXMVECTOR, HXMVECTOR,和的存在CXMVECTOR是为了尝试优化所有可能的调用约定场景，并在最好的情况下获得寄存器内传递行为（如果事情没有内联）。请参阅MSDN。实际上，您能做的最好的事情Vector2就是始终如一地传递它const&以最小化临时文件和堆栈副本。

于 2016-09-19T05:40:10.317 回答