Question

What are the pro’s and con’s of, for example, using a D3DXVECTOR3 (a directX triple float) as opposed to using three floats in a function call.

so

Scale(D3DXVECTOR3(1, 1, 1));

as opposed to

Scale(1, 1, 1);

Is it better to use the second and only convert to a D3DXVECTOR3 when you need to use a library specific maths functions?

I also notice that many libraries have their own types for floats and doubles and so on. thoughts?

Answer 1

One big reason to have APIs accept structures of floats instead of the floats themselves is readability. In any application using 3D graphics, you’re certainly going to have to work with lots of vectors. This is way more readable and maintainable:

D3DXVECTOR Scale(D3DXVECTOR a, double scale)
{
    return D3DXVECTOR(a.x * scale, a.y * scale, a.z * scale);
}

class MyClass
{
public:
    void DoSomething()
    {
        a = Scale(b, 2.0);
        ::D3DXVec3Cross(&out, &a, &b);
    }

private:
    D3DXVECTOR3 out;
    D3DXVECTOR3 a;
    D3DXVECTOR3 b;
};

than this:

class MyClass
{
public:
    void DoSomething()
    {
        float scale = 2.0;
        a1 = Scale(b1, scale);
        a2 = Scale(b2, scale);
        a3 = Scale(b3, scale);
        // Hypothetical D3DX function accepting floats directly
        ::D3DXVec3Cross(&out1, &out2, &out3, a1, a2, a3, b1, b2, b3);
    }

private:
    float out1;
    float out2;
    float out3;
    float a1;
    float a2;
    float a3;
    float b1;
    float b2;
    float b3;
};

In other words, it allows for self-documenting code. Not to mention taking less time to type when you need to declare a vector (one D3DXVECTOR as opposed to three separate floats).

That being said, typically a 3D graphics library/framework would define their own vector types and floating point types for portability across different platforms and configurations. One may simply define these types as follows:

namespace My3DLib
{

    typedef MyFloat float;

    struct MyVector
    {
        MyFloat x;
        MyFloat y;
        MyFloat z;
    };

    MyVector Scale(MyVector a, MyFloat b);
    MyFloat DotProduct(MyVector a, MyVector b);
    MyVector CrossProduct(MyVector a, MyVector b);
   // ...
}