Re: include: Add d3dx10math.h/inl

[Matteo Bruni]

2016-01-07 8:16 GMT+01:00 Alistair Leslie-Hughes :
> The d3dx10math.h guard has the define as in d3dx9math.h, which is
> to prevent double-inclusion. This is the same as the DirectX SDK.
>
> This is just a copy of d3dx9math.h/inl with the following changes
> - D3D9_VIEWPORT -> D3D10_VIEWPORT
> - Copied D3DVECTOR, D3DMATRIX types from d3d9types.h

This makes part of the review (which is late, sorry about that :/)
very easy by checking the diff with the corresponding d3dx9 headers.
Unfortunately the comment from MS's d3dx10math.h isn't quite right
(i.e. the d3dx10 header doesn't perfectly match the d3dx9 header) and
our d3dx9math.h isn't exactly a paragon of quality.
> Signed-off-by: Alistair Leslie-Hughes
>
> include/Makefile.in    |    2 +
>  include/d3dx10.h       |    1 +
>  include/d3dx10math.h   |  500 +++++++++++++++++++
>  include/d3dx10math.inl | 1298 ++++++++++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 1801 insertions(+)
>  create mode 100644 include/d3dx10math.h
>  create mode 100644 include/d3dx10math.inl
>
> diff --git a/include/Makefile.in b/include/Makefile.in
> index ea0e3fd..ac5e9ea 100644
> --- a/include/Makefile.in
> +++ b/include/Makefile.in
> @@ -247,6 +247,8 @@ HEADER_SRCS = \
>         d3dvec.inl \
>         d3dx10.h \
>         d3dx10async.h \
> -
>   d3dx10math.h \
> -
>   d3dx10math.inl \
>   d3dx9.h \
>   d3dx9anim.h \
>   d3dx9core.h \
>
> diff --git a/include/d3dx10.h b/include/d3dx10.h
> index df7cdb1..b3825b3 100644
> --- a/include/d3dx10.h
> +++ b/include/d3dx10.h
> @@ -27,6 +27,7 @@
>  #define DXGI_FORMAT_FROM_FILE ((DXGI_FORMAT)0xfffffffdu)
>
> #include "d3d10.h"
> +#include "d3dx10math.h"
>  #include "d3dx10core.h"
>  #include "d3dx10async.h"
>
> diff --git a/include/d3dx10math.h b/include/d3dx10math.h
> new file mode 100644
> index 0000000..5ef8738
> --- /dev/null
> +++ b/include/d3dx10math.h
> @@ -0,0 +1,500 @@
> +/*
> -
> - Copyright (C) 2007 David Adam
> -
> - Copyright (C) 2007 Tony Wasserka
> -
> -
> -
> - This library is free software; you can redistribute it and/or
> -
> - modify it under the terms of the GNU Lesser General Public
> -
> - License as published by the Free Software Foundation; either
> -
> - version 2.1 of the License, or (at your option) any later version.
> -
> -
> -
> - This library is distributed in the hope that it will be useful,
> -
> - but WITHOUT ANY WARRANTY; without even the implied warranty of
> -
> - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> -
> - Lesser General Public License for more details.
> -
> -
> -
> - You should have received a copy of the GNU Lesser General Public
> -
> - License along with this library; if not, write to the Free Software
> -
> - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
> - */
> -
>
> +#include <d3dx10.h>
> -
>
> +/* This guaud is the same as D3DX9 to prevent double-inclusion */

Typo.
> +#ifndef __D3DX9MATH_H__
> +#define __D3DX9MATH_H__
> -
>
> +#include <math.h>
> -
>
> +#define D3DX_PI    ((FLOAT)3.141592654)
> +#define D3DX_1BYPI ((FLOAT)0.318309886)

In d3dx10math.h these use double constants (and they actually make use
of the additional available precision).
> -
>
> +#define D3DXSH_MINORDER 2
> +#define D3DXSH_MAXORDER 6
> -
>
> +#define D3DXToRadian(degree) ((degree) * (D3DX_PI / 180.0f))
> +#define D3DXToDegree(radian) ((radian) * (180.0f / D3DX_PI))

Same for those two.
> -
>
> +/* Copied from d3d9types.h */
> +#ifndef D3DVECTOR_DEFINED
> +typedef struct _D3DVECTOR {
> - float x;
> - float y;
> - float z;
>
> +} D3DVECTOR;
> +#define D3DVECTOR_DEFINED
> +#endif

I don't think the comment adds much. While you're here, can you please
put the '{' on its own line?
> -
>
> +#ifndef D3DMATRIX_DEFINED
> +typedef struct _D3DMATRIX {
> - union {
> -
>    struct {
> -
>        float        _11, _12, _13, _14;
> -
>        float        _21, _22, _23, _24;
> -
>        float        _31, _32, _33, _34;
> -
>        float        _41, _42, _43, _44;
> -
>    } DUMMYSTRUCTNAME;
> -
>    float m[4][4];
> - } DUMMYUNIONNAME;
>
> +} D3DMATRIX;
> +#define D3DMATRIX_DEFINED
> +#endif
> -
>
> +typedef struct D3DXVECTOR2
> +{
> +#ifdef __cplusplus
> - D3DXVECTOR2();
> - D3DXVECTOR2(const FLOAT *pf);
> - D3DXVECTOR2(FLOAT fx, FLOAT fy);

There should be an additional constructor from D3DXFLOAT16 *, here and
for most of the other types.
FWIW it should also be in the d3dx9 header. I guess it's not critical.
Similarly, D3DXVECTOR{2,3,4}_16F are missing in both versions.
> -
> - operator FLOAT* ();
> - operator const FLOAT* () const;
> -
> - D3DXVECTOR2& operator += (const D3DXVECTOR2&);
> - D3DXVECTOR2& operator -= (const D3DXVECTOR2&);
> - D3DXVECTOR2& operator *= (FLOAT);
> - D3DXVECTOR2& operator /= (FLOAT);
> -
> - D3DXVECTOR2 operator + () const;
> - D3DXVECTOR2 operator - () const;
> -
> - D3DXVECTOR2 operator + (const D3DXVECTOR2&) const;
> - D3DXVECTOR2 operator - (const D3DXVECTOR2&) const;
> - D3DXVECTOR2 operator * (FLOAT) const;
> - D3DXVECTOR2 operator / (FLOAT) const;
> -
> - friend D3DXVECTOR2 operator * (FLOAT, const D3DXVECTOR2&);
> -
> - BOOL operator == (const D3DXVECTOR2&) const;
> - BOOL operator != (const D3DXVECTOR2&) const;
>
> +#endif /* __cplusplus */
> - FLOAT x, y;
>
> +} D3DXVECTOR2, *LPD3DXVECTOR2;

I think you can use plain "float" instead. Also, maybe it's just me,
but I find the space between the keyword "operator" and the overloaded
operator, or between the operator and the '(' ugly. Certainly not a
big deal though.
> -
>
> +#ifdef __cplusplus
> +typedef struct D3DXVECTOR3 : public D3DVECTOR
> +{
> - D3DXVECTOR3();
> - D3DXVECTOR3(const FLOAT *pf);
> - D3DXVECTOR3(const D3DVECTOR& v);
> - D3DXVECTOR3(FLOAT fx, FLOAT fy, FLOAT fz);
> -
> - operator FLOAT* ();
> - operator const FLOAT* () const;
> -
> - D3DXVECTOR3& operator += (const D3DXVECTOR3&);
> - D3DXVECTOR3& operator -= (const D3DXVECTOR3&);
> - D3DXVECTOR3& operator *= (FLOAT);
> - D3DXVECTOR3& operator /= (FLOAT);
> -
> - D3DXVECTOR3 operator + () const;
> - D3DXVECTOR3 operator - () const;
> -
> - D3DXVECTOR3 operator + (const D3DXVECTOR3&) const;
> - D3DXVECTOR3 operator - (const D3DXVECTOR3&) const;
> - D3DXVECTOR3 operator * (FLOAT) const;
> - D3DXVECTOR3 operator / (FLOAT) const;
> -
> - friend D3DXVECTOR3 operator * (FLOAT, const struct D3DXVECTOR3&);
> -
> - BOOL operator == (const D3DXVECTOR3&) const;
> - BOOL operator != (const D3DXVECTOR3&) const;
>
> +} D3DXVECTOR3, *LPD3DXVECTOR3;
> +#else /* !__cplusplus */
> +typedef struct _D3DVECTOR D3DXVECTOR3, *LPD3DXVECTOR3;
> +#endif /* !__cplusplus */
> -
>
> +typedef struct D3DXVECTOR4
> +{
> +#ifdef __cplusplus
> - D3DXVECTOR4();
> - D3DXVECTOR4(const FLOAT *pf);
> - D3DXVECTOR4(FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw);

This misses a constructor taking a D3DVECTOR and a float. Again, it's
also missing from the d3dx9 version.
> -
> - operator FLOAT* ();
> - operator const FLOAT* () const;
> -
> - D3DXVECTOR4& operator += (const D3DXVECTOR4&);
> - D3DXVECTOR4& operator -= (const D3DXVECTOR4&);
> - D3DXVECTOR4& operator *= (FLOAT);
> - D3DXVECTOR4& operator /= (FLOAT);
> -
> - D3DXVECTOR4 operator + () const;
> - D3DXVECTOR4 operator - () const;
> -
> - D3DXVECTOR4 operator + (const D3DXVECTOR4&) const;
> - D3DXVECTOR4 operator - (const D3DXVECTOR4&) const;
> - D3DXVECTOR4 operator * (FLOAT) const;
> - D3DXVECTOR4 operator / (FLOAT) const;
> -
> - friend D3DXVECTOR4 operator * (FLOAT, const D3DXVECTOR4&);
> -
> - BOOL operator == (const D3DXVECTOR4&) const;
> - BOOL operator != (const D3DXVECTOR4&) const;
>
> +#endif /* __cplusplus */
> - FLOAT x, y, z, w;
>
> +} D3DXVECTOR4, *LPD3DXVECTOR4;
> -
>
> +#ifdef __cplusplus
> +typedef struct D3DXMATRIX : public D3DMATRIX
> +{
> - D3DXMATRIX();
> - D3DXMATRIX(const FLOAT *pf);
> - D3DXMATRIX(const D3DMATRIX& mat);
> - D3DXMATRIX(FLOAT f11, FLOAT f12, FLOAT f13, FLOAT f14,
> -
>           FLOAT f21, FLOAT f22, FLOAT f23, FLOAT f24,
> -
>           FLOAT f31, FLOAT f32, FLOAT f33, FLOAT f34,
> -
>           FLOAT f41, FLOAT f42, FLOAT f43, FLOAT f44);
> -
> - FLOAT& operator () (UINT row, UINT col);
> - FLOAT operator () (UINT row, UINT col) const;
> -
> - operator FLOAT* ();
> - operator const FLOAT* () const;
> -
> - D3DXMATRIX& operator *= (const D3DXMATRIX&);
> - D3DXMATRIX& operator += (const D3DXMATRIX&);
> - D3DXMATRIX& operator -= (const D3DXMATRIX&);
> - D3DXMATRIX& operator *= (FLOAT);
> - D3DXMATRIX& operator /= (FLOAT);
> -
> - D3DXMATRIX operator + () const;
> - D3DXMATRIX operator - () const;
> -
> - D3DXMATRIX operator * (const D3DXMATRIX&) const;
> - D3DXMATRIX operator + (const D3DXMATRIX&) const;
> - D3DXMATRIX operator - (const D3DXMATRIX&) const;
> - D3DXMATRIX operator * (FLOAT) const;
> - D3DXMATRIX operator / (FLOAT) const;
> -
> - friend D3DXMATRIX operator * (FLOAT, const D3DXMATRIX&);
> -
> - BOOL operator == (const D3DXMATRIX&) const;
> - BOOL operator != (const D3DXMATRIX&) const;
>
> +} D3DXMATRIX, *LPD3DXMATRIX;
> +#else /* !__cplusplus */
> +typedef struct _D3DMATRIX D3DXMATRIX, *LPD3DXMATRIX;
> +#endif /* !__cplusplus */
> -
>
> +typedef struct D3DXQUATERNION
> +{
> +#ifdef __cplusplus
> - D3DXQUATERNION();
> - D3DXQUATERNION(const FLOAT *pf);
> - D3DXQUATERNION(FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw);
> -
> - operator FLOAT* ();
> - operator const FLOAT* () const;
> -
> - D3DXQUATERNION& operator += (const D3DXQUATERNION&);
> - D3DXQUATERNION& operator -= (const D3DXQUATERNION&);
> - D3DXQUATERNION& operator *= (const D3DXQUATERNION&);
> - D3DXQUATERNION& operator *= (FLOAT);
> - D3DXQUATERNION& operator /= (FLOAT);
> -
> - D3DXQUATERNION  operator + () const;
> - D3DXQUATERNION  operator - () const;
> -
> - D3DXQUATERNION operator + (const D3DXQUATERNION&) const;
> - D3DXQUATERNION operator - (const D3DXQUATERNION&) const;
> - D3DXQUATERNION operator * (const D3DXQUATERNION&) const;
> - D3DXQUATERNION operator * (FLOAT) const;
> - D3DXQUATERNION operator / (FLOAT) const;
> -
> - friend D3DXQUATERNION operator * (FLOAT, const D3DXQUATERNION&);
> -
> - BOOL operator == (const D3DXQUATERNION&) const;
> - BOOL operator != (const D3DXQUATERNION&) const;
>
> +#endif /* __cplusplus */
> - FLOAT x, y, z, w;
>
> +} D3DXQUATERNION, *LPD3DXQUATERNION;
> -
>
> +typedef struct D3DXPLANE
> +{
> +#ifdef __cplusplus
> - D3DXPLANE();
> - D3DXPLANE(const FLOAT *pf);
> - D3DXPLANE(FLOAT fa, FLOAT fb, FLOAT fc, FLOAT fd);
> -
> - operator FLOAT* ();
> - operator const FLOAT* () const;
> -
> - D3DXPLANE operator + () const;
> - D3DXPLANE operator - () const;
> -
> - BOOL operator == (const D3DXPLANE&) const;
> - BOOL operator != (const D3DXPLANE&) const;
>
> +#endif /* __cplusplus */
> - FLOAT a, b, c, d;
>
> +} D3DXPLANE, *LPD3DXPLANE;

There should be two other overloaded operators, * and /, with their
assignment version.
> -
>
> +typedef struct D3DXCOLOR
> +{
> +#ifdef __cplusplus
> - D3DXCOLOR();
> - D3DXCOLOR(DWORD col);
> - D3DXCOLOR(const FLOAT *pf);
> - D3DXCOLOR(const D3DCOLORVALUE& col);

The last constructor was dropped in d3dx10.
> - D3DXCOLOR(FLOAT fr, FLOAT fg, FLOAT fb, FLOAT fa);
> -
> - operator DWORD () const;
> -
> - operator FLOAT* ();
> - operator const FLOAT* () const;
> -
> - operator D3DCOLORVALUE* ();
> - operator const D3DCOLORVALUE* () const;
> -
> - operator D3DCOLORVALUE& ();
> - operator const D3DCOLORVALUE& () const;

Same with these conversions.
> -
> - D3DXCOLOR& operator += (const D3DXCOLOR&);
> - D3DXCOLOR& operator -= (const D3DXCOLOR&);
> - D3DXCOLOR& operator *= (FLOAT);
> - D3DXCOLOR& operator /= (FLOAT);
> -
> - D3DXCOLOR operator + () const;
> - D3DXCOLOR operator - () const;
> -
> - D3DXCOLOR operator + (const D3DXCOLOR&) const;
> - D3DXCOLOR operator - (const D3DXCOLOR&) const;
> - D3DXCOLOR operator * (FLOAT) const;
> - D3DXCOLOR operator / (FLOAT) const;
> -
> - friend D3DXCOLOR operator * (FLOAT, const D3DXCOLOR&);
> -
> - BOOL operator == (const D3DXCOLOR&) const;
> - BOOL operator != (const D3DXCOLOR&) const;
>
> +#endif /* __cplusplus */
> - FLOAT r, g, b, a;
>
> +} D3DXCOLOR, *LPD3DXCOLOR;
> -
>
> +typedef struct D3DXFLOAT16
> +{
> +#ifdef __cplusplus
> - D3DXFLOAT16();
> - D3DXFLOAT16(FLOAT f);
> - D3DXFLOAT16(const D3DXFLOAT16 &f);
> -
> - operator FLOAT ();
> -
> - BOOL operator == (const D3DXFLOAT16 &) const;
> - BOOL operator != (const D3DXFLOAT16 &) const;
>
> +#endif /* __cplusplus */
> - WORD value;
>
> +} D3DXFLOAT16, *LPD3DXFLOAT16;
> -
>
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> -
>
> +D3DXCOLOR* WINAPI D3DXColorAdjustContrast(D3DXCOLOR *pout, const D3DXCOLOR *pc, FLOAT s);

Please consistently put a space between the type and the '*' (that
maybe doesn't quite look as nice in those operator overloading
declarations above and it's arguably a pretty standard practice in C++
to not put spaces before the '*' or '&' when the type is not followed
by a variable, so I'm okay with no space there). Same for the other C
prototypes below.
> +D3DXCOLOR* WINAPI D3DXColorAdjustSaturation(D3DXCOLOR *pout, const D3DXCOLOR *pc, FLOAT s);
> -
>
> +FLOAT WINAPI D3DXFresnelTerm(FLOAT costheta, FLOAT refractionindex);
> -
>
> +D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation(D3DXMATRIX *pout, FLOAT scaling, const D3DXVECTOR3 *rotationcenter, const D3DXQUATERNION *rotation,
> - const D3DXVECTOR3 *translation);
>
> +D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation2D(D3DXMATRIX *pout, FLOAT scaling, const D3DXVECTOR2 *protationcenter, FLOAT rotation,
> - const D3DXVECTOR2 *ptranslation);
>
> +HRESULT WINAPI D3DXMatrixDecompose(D3DXVECTOR3 *poutscale, D3DXQUATERNION *poutrotation, D3DXVECTOR3 *pouttranslation, const D3DXMATRIX *pm);
> +FLOAT WINAPI D3DXMatrixDeterminant(const D3DXMATRIX *pm);
> +D3DXMATRIX* WINAPI D3DXMatrixInverse(D3DXMATRIX *pout, FLOAT *pdeterminant, const D3DXMATRIX *pm);
> +D3DXMATRIX* WINAPI D3DXMatrixLookAtLH(D3DXMATRIX *pout, const D3DXVECTOR3 *peye, const D3DXVECTOR3 *pat, const D3DXVECTOR3 *pup);
> +D3DXMATRIX* WINAPI D3DXMatrixLookAtRH(D3DXMATRIX *pout, const D3DXVECTOR3 *peye, const D3DXVECTOR3 *pat, const D3DXVECTOR3 *pup);
> +D3DXMATRIX* WINAPI D3DXMatrixMultiply(D3DXMATRIX *pout, const D3DXMATRIX *pm1, const D3DXMATRIX *pm2);
> +D3DXMATRIX* WINAPI D3DXMatrixMultiplyTranspose(D3DXMATRIX *pout, const D3DXMATRIX *pm1, const D3DXMATRIX *pm2);
> +D3DXMATRIX* WINAPI D3DXMatrixOrthoLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf);
> +D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterLH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf);
> +D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterRH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf);
> +D3DXMATRIX* WINAPI D3DXMatrixOrthoRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf);
> +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf);
> +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovRH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf);
> +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf);
> +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterLH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf);
> +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterRH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf);
> +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf);
> +D3DXMATRIX* WINAPI D3DXMatrixReflect(D3DXMATRIX *pout, const D3DXPLANE *pplane);
> +D3DXMATRIX* WINAPI D3DXMatrixRotationAxis(D3DXMATRIX *pout, const D3DXVECTOR3 *pv, FLOAT angle);
> +D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion(D3DXMATRIX *pout, const D3DXQUATERNION *pq);
> +D3DXMATRIX* WINAPI D3DXMatrixRotationX(D3DXMATRIX *pout, FLOAT angle);
> +D3DXMATRIX* WINAPI D3DXMatrixRotationY(D3DXMATRIX *pout, FLOAT angle);
> +D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll(D3DXMATRIX *pout, FLOAT yaw, FLOAT pitch, FLOAT roll);
> +D3DXMATRIX* WINAPI D3DXMatrixRotationZ(D3DXMATRIX *pout, FLOAT angle);
> +D3DXMATRIX* WINAPI D3DXMatrixScaling(D3DXMATRIX *pout, FLOAT sx, FLOAT sy, FLOAT sz);
> +D3DXMATRIX* WINAPI D3DXMatrixShadow(D3DXMATRIX *pout, const D3DXVECTOR4 *plight, const D3DXPLANE *pPlane);
> +D3DXMATRIX* WINAPI D3DXMatrixTransformation(D3DXMATRIX *pout, const D3DXVECTOR3 *pscalingcenter, const D3DXQUATERNION *pscalingrotation, const D3DXVECTOR3 *pscaling, const D3DXVECTOR3 *protationcenter,
> - const D3DXQUATERNION *protation, const D3DXVECTOR3 *ptranslation);
>
> +D3DXMATRIX* WINAPI D3DXMatrixTransformation2D(D3DXMATRIX *pout, const D3DXVECTOR2 *pscalingcenter, FLOAT scalingrotation, const D3DXVECTOR2 *pscaling,
> - const D3DXVECTOR2 *protationcenter, FLOAT rotation, const D3DXVECTOR2 *ptranslation);
>
> +D3DXMATRIX* WINAPI D3DXMatrixTranslation(D3DXMATRIX *pout, FLOAT x, FLOAT y, FLOAT z);
> +D3DXMATRIX* WINAPI D3DXMatrixTranspose(D3DXMATRIX *pout, const D3DXMATRIX *pm);
> -
>
> +D3DXPLANE* WINAPI D3DXPlaneFromPointNormal(D3DXPLANE *pout, const D3DXVECTOR3 *pvpoint, const D3DXVECTOR3 *pvnormal);
> +D3DXPLANE* WINAPI D3DXPlaneFromPoints(D3DXPLANE *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2, const D3DXVECTOR3 *pv3);
> +D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine(D3DXVECTOR3 *pout, const D3DXPLANE *pp, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2);
> +D3DXPLANE* WINAPI D3DXPlaneNormalize(D3DXPLANE *pout, const D3DXPLANE *pp);
> +D3DXPLANE* WINAPI D3DXPlaneTransform(D3DXPLANE *pout, const D3DXPLANE *pplane, const D3DXMATRIX *pm);
> +D3DXPLANE* WINAPI D3DXPlaneTransformArray(D3DXPLANE *pout, UINT outstride, const D3DXPLANE *pplane, UINT pstride, const D3DXMATRIX *pm, UINT n);
> -
>
> +D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric(D3DXQUATERNION *pout, const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2, const D3DXQUATERNION *pq3, FLOAT f, FLOAT g);
> +D3DXQUATERNION* WINAPI D3DXQuaternionExp(D3DXQUATERNION *pout, const D3DXQUATERNION *pq);
> +D3DXQUATERNION* WINAPI D3DXQuaternionInverse(D3DXQUATERNION *pout, const D3DXQUATERNION *pq);
> +D3DXQUATERNION* WINAPI D3DXQuaternionLn(D3DXQUATERNION *pout, const D3DXQUATERNION *pq);
> +D3DXQUATERNION* WINAPI D3DXQuaternionMultiply(D3DXQUATERNION *pout, const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2);
> +D3DXQUATERNION* WINAPI D3DXQuaternionNormalize(D3DXQUATERNION *pout, const D3DXQUATERNION *pq);
> +D3DXQUATERNION* WINAPI D3DXQuaternionRotationAxis(D3DXQUATERNION *pout, const D3DXVECTOR3 *pv, FLOAT angle);
> +D3DXQUATERNION* WINAPI D3DXQuaternionRotationMatrix(D3DXQUATERNION *pout, const D3DXMATRIX *pm);
> +D3DXQUATERNION* WINAPI D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION *pout, FLOAT yaw, FLOAT pitch, FLOAT roll);
> +D3DXQUATERNION* WINAPI D3DXQuaternionSlerp(D3DXQUATERNION *pout, const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2, FLOAT t);
> +D3DXQUATERNION* WINAPI D3DXQuaternionSquad(D3DXQUATERNION *pout, const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2, const D3DXQUATERNION *pq3,
> - const D3DXQUATERNION *pq4, FLOAT t);
>
> +void WINAPI D3DXQuaternionSquadSetup(D3DXQUATERNION *paout, D3DXQUATERNION *pbout, D3DXQUATERNION *pcout, const D3DXQUATERNION *pq0,
> - const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2, const D3DXQUATERNION *pq3);
>
> +void WINAPI D3DXQuaternionToAxisAngle(const D3DXQUATERNION *pq, D3DXVECTOR3 *paxis, FLOAT *pangle);
> -
>
> +D3DXVECTOR2* WINAPI D3DXVec2BaryCentric(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2, const D3DXVECTOR2 *pv3, FLOAT f, FLOAT g);
> +D3DXVECTOR2* WINAPI D3DXVec2CatmullRom(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv0, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2, const D3DXVECTOR2 *pv3, FLOAT s);
> +D3DXVECTOR2* WINAPI D3DXVec2Hermite(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pt1, const D3DXVECTOR2 *pv2, const D3DXVECTOR2 *pt2, FLOAT s);
> +D3DXVECTOR2* WINAPI D3DXVec2Normalize(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv);
> +D3DXVECTOR4* WINAPI D3DXVec2Transform(D3DXVECTOR4 *pout, const D3DXVECTOR2 *pv, const D3DXMATRIX *pm);
> +D3DXVECTOR4* WINAPI D3DXVec2TransformArray(D3DXVECTOR4 *pout, UINT outstride, const D3DXVECTOR2 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n);
> +D3DXVECTOR2* WINAPI D3DXVec2TransformCoord(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv, const D3DXMATRIX *pm);
> +D3DXVECTOR2* WINAPI D3DXVec2TransformCoordArray(D3DXVECTOR2 *pout, UINT outstride, const D3DXVECTOR2 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n);
> +D3DXVECTOR2* WINAPI D3DXVec2TransformNormal(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv, const D3DXMATRIX *pm);
> +D3DXVECTOR2* WINAPI D3DXVec2TransformNormalArray(D3DXVECTOR2 *pout, UINT outstride, const D3DXVECTOR2 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n);
> -
>
> +D3DXVECTOR3* WINAPI D3DXVec3BaryCentric(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2, const D3DXVECTOR3 *pv3, FLOAT f, FLOAT g);
> +D3DXVECTOR3* WINAPI D3DXVec3CatmullRom( D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv0, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2, const D3DXVECTOR3 *pv3, FLOAT s);
> +D3DXVECTOR3* WINAPI D3DXVec3Hermite(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pt1, const D3DXVECTOR3 *pv2, const D3DXVECTOR3 *pt2, FLOAT s);
> +D3DXVECTOR3* WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv);
> +D3DXVECTOR3* WINAPI D3DXVec3Project(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv, const D3D10_VIEWPORT *pviewport, const D3DXMATRIX *pprojection,
> - const D3DXMATRIX *pview, const D3DXMATRIX *pworld);
>
> +D3DXVECTOR3* WINAPI D3DXVec3ProjectArray(D3DXVECTOR3 *pout, UINT outstride, const D3DXVECTOR3 *pv, UINT vstride, const D3D10_VIEWPORT *pviewport,
> - const D3DXMATRIX *pprojection, const D3DXMATRIX *pview, const D3DXMATRIX *pworld, UINT n);
>
> +D3DXVECTOR4* WINAPI D3DXVec3Transform(D3DXVECTOR4 *pout, const D3DXVECTOR3 *pv, const D3DXMATRIX *pm);
> +D3DXVECTOR4* WINAPI D3DXVec3TransformArray(D3DXVECTOR4 *pout, UINT outstride, const D3DXVECTOR3 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n);
> +D3DXVECTOR3* WINAPI D3DXVec3TransformCoord(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv, const D3DXMATRIX *pm);
> +D3DXVECTOR3* WINAPI D3DXVec3TransformCoordArray(D3DXVECTOR3 *pout, UINT outstride, const D3DXVECTOR3 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n);
> +D3DXVECTOR3* WINAPI D3DXVec3TransformNormal(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv, const D3DXMATRIX *pm);
> +D3DXVECTOR3* WINAPI D3DXVec3TransformNormalArray(D3DXVECTOR3 *pout, UINT outstride, const D3DXVECTOR3 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n);
> +D3DXVECTOR3* WINAPI D3DXVec3Unproject(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv, const D3D10_VIEWPORT *pviewport, const D3DXMATRIX *pprojection,
> - const D3DXMATRIX *pview, const D3DXMATRIX *pworld);
>
> +D3DXVECTOR3* WINAPI D3DXVec3UnprojectArray(D3DXVECTOR3 *pout, UINT outstride, const D3DXVECTOR3 *pv, UINT vstride, const D3D10_VIEWPORT *pviewport,
> - const D3DXMATRIX *pprojection, const D3DXMATRIX *pview, const D3DXMATRIX *pworld, UINT n);
>
> +D3DXVECTOR4* WINAPI D3DXVec4BaryCentric(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2, const D3DXVECTOR4 *pv3, FLOAT f, FLOAT g);
> +D3DXVECTOR4* WINAPI D3DXVec4CatmullRom(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv0, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2, const D3DXVECTOR4 *pv3, FLOAT s);
> +D3DXVECTOR4* WINAPI D3DXVec4Cross(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2, const D3DXVECTOR4 *pv3);
> +D3DXVECTOR4* WINAPI D3DXVec4Hermite(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pt1, const D3DXVECTOR4 *pv2, const D3DXVECTOR4 *pt2, FLOAT s);
> +D3DXVECTOR4* WINAPI D3DXVec4Normalize(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv);
> +D3DXVECTOR4* WINAPI D3DXVec4Transform(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv, const D3DXMATRIX *pm);
> +D3DXVECTOR4* WINAPI D3DXVec4TransformArray(D3DXVECTOR4 *pout, UINT outstride, const D3DXVECTOR4 *pv, UINT vstride, const D3DXMATRIX *pm, UINT n);
> -
>
> +D3DXFLOAT16 *WINAPI D3DXFloat32To16Array(D3DXFLOAT16 *pout, const FLOAT *pin, UINT n);
> +FLOAT *WINAPI D3DXFloat16To32Array(FLOAT *pout, const D3DXFLOAT16 *pin, UINT n);
> -
>
> +FLOAT* WINAPI D3DXSHAdd(FLOAT *out, UINT order, const FLOAT *a, const FLOAT *b);
> +FLOAT WINAPI D3DXSHDot(UINT order, const FLOAT *a, const FLOAT *b);
> +HRESULT WINAPI D3DXSHEvalConeLight(UINT order, const D3DXVECTOR3 *dir, FLOAT radius, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT *rout, FLOAT *gout, FLOAT *bout);
> +FLOAT* WINAPI D3DXSHEvalDirection(FLOAT *out, UINT order, const D3DXVECTOR3 *dir);
> +HRESULT WINAPI D3DXSHEvalDirectionalLight(UINT order, const D3DXVECTOR3 *dir, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT *rout, FLOAT *gout, FLOAT *bout);
> +HRESULT WINAPI D3DXSHEvalHemisphereLight(UINT order, const D3DXVECTOR3 *dir, D3DXCOLOR top, D3DXCOLOR bottom, FLOAT *rout, FLOAT *gout, FLOAT *bout);
> +HRESULT WINAPI D3DXSHEvalSphericalLight(UINT order, const D3DXVECTOR3 *dir, FLOAT radius, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT *rout, FLOAT *gout, FLOAT *bout);
> +FLOAT* WINAPI D3DXSHMultiply2(FLOAT *out, const FLOAT *a, const FLOAT *b);
> +FLOAT* WINAPI D3DXSHMultiply3(FLOAT *out, const FLOAT *a, const FLOAT *b);
> +FLOAT* WINAPI D3DXSHMultiply4(FLOAT *out, const FLOAT *a, const FLOAT *b);

In theory there should also be D3DXSHMultiply5 and D3DXSHMultiply6 here.
> +FLOAT* WINAPI D3DXSHRotate(FLOAT *out, UINT order, const D3DXMATRIX *matrix, const FLOAT *in);
> +FLOAT* WINAPI D3DXSHRotateZ(FLOAT *out, UINT order, FLOAT angle, const FLOAT *in);
> +FLOAT* WINAPI D3DXSHScale(FLOAT *out, UINT order, const FLOAT *a, const FLOAT scale);
> -

These function should probably alphabetically sorted with those above.
There are some "new" functions in d3dx10math.h compared to d3dx9math.h
which should be added (possibly in a separate patch):
D3DXIntersectTri, D3DXSphereBoundProbe, D3DXBoxBoundProbe,
D3DXComputeBoundingSphere and D3DXComputeBoundingBox and
D3DXCpuOptimizations are those I noticed.
> +#ifdef __cplusplus
> +}
> +#endif
> -
>
> +typedef interface ID3DXMatrixStack *LPD3DXMATRIXSTACK;
> -
>
> +DEFINE_GUID(IID_ID3DXMatrixStack,
> +0xc7885ba7, 0xf990, 0x4fe7, 0x92, 0x2d, 0x85, 0x15, 0xe4, 0x77, 0xdd, 0x85);
> -
>
> +#undef INTERFACE
> +#define INTERFACE ID3DXMatrixStack
> -
>
> +DECLARE_INTERFACE_(ID3DXMatrixStack, IUnknown)
> +{
> - STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
> - STDMETHOD_(ULONG,AddRef)(THIS) PURE;
> - STDMETHOD_(ULONG,Release)(THIS) PURE;
> - STDMETHOD(Pop)(THIS) PURE;
> - STDMETHOD(Push)(THIS) PURE;
> - STDMETHOD(LoadIdentity)(THIS) PURE;
> - STDMETHOD(LoadMatrix)(THIS_ const D3DXMATRIX* pM ) PURE;
> - STDMETHOD(MultMatrix)(THIS_ const D3DXMATRIX* pM ) PURE;
> - STDMETHOD(MultMatrixLocal)(THIS_ const D3DXMATRIX* pM ) PURE;
> - STDMETHOD(RotateAxis)(THIS_ const D3DXVECTOR3* pV, FLOAT Angle) PURE;
> - STDMETHOD(RotateAxisLocal)(THIS_ const D3DXVECTOR3* pV, FLOAT Angle) PURE;
> - STDMETHOD(RotateYawPitchRoll)(THIS_ FLOAT Yaw, FLOAT Pitch, FLOAT Roll) PURE;
> - STDMETHOD(RotateYawPitchRollLocal)(THIS_ FLOAT Yaw, FLOAT Pitch, FLOAT Roll) PURE;
> - STDMETHOD(Scale)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE;
> - STDMETHOD(ScaleLocal)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE;
> - STDMETHOD(Translate)(THIS_ FLOAT x, FLOAT y, FLOAT z ) PURE;
> - STDMETHOD(TranslateLocal)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE;
> - STDMETHOD_(D3DXMATRIX*, GetTop)(THIS) PURE;
>
> +};

'*' next to the parameter name, no spurious spaces before the ')',
please avoid caps / hungarian notation in the parameter names. BTW, I
guess this shows pretty clearly that this piece of text started as a
copy of the MS header :/
> -
>
> +#undef INTERFACE
> -
>
> +#if !defined(__cplusplus) || defined(CINTERFACE)
> -
>
> +#define ID3DXMatrixStack_QueryInterface(p,a,b)            (p)->lpVtbl->QueryInterface(p,a,b)
> +#define ID3DXMatrixStack_AddRef(p)                        (p)->lpVtbl->AddRef(p)
> +#define ID3DXMatrixStack_Release(p)                       (p)->lpVtbl->Release(p)
> +#define ID3DXMatrixStack_Pop(p)                           (p)->lpVtbl->Pop(p)
> +#define ID3DXMatrixStack_Push(p)                          (p)->lpVtbl->Push(p)
> +#define ID3DXMatrixStack_LoadIdentity(p)                  (p)->lpVtbl->LoadIdentity(p)
> +#define ID3DXMatrixStack_LoadMatrix(p,a)                  (p)->lpVtbl->LoadMatrix(p,a)
> +#define ID3DXMatrixStack_MultMatrix(p,a)                  (p)->lpVtbl->MultMatrix(p,a)
> +#define ID3DXMatrixStack_MultMatrixLocal(p,a)             (p)->lpVtbl->MultMatrixLocal(p,a)
> +#define ID3DXMatrixStack_RotateAxis(p,a,b)                (p)->lpVtbl->RotateAxis(p,a,b)
> +#define ID3DXMatrixStack_RotateAxisLocal(p,a,b)           (p)->lpVtbl->RotateAxisLocal(p,a,b)
> +#define ID3DXMatrixStack_RotateYawPitchRoll(p,a,b,c)      (p)->lpVtbl->RotateYawPitchRoll(p,a,b,c)
> +#define ID3DXMatrixStack_RotateYawPitchRollLocal(p,a,b,c) (p)->lpVtbl->RotateYawPitchRollLocal(p,a,b,c)
> +#define ID3DXMatrixStack_Scale(p,a,b,c)                   (p)->lpVtbl->Scale(p,a,b,c)
> +#define ID3DXMatrixStack_ScaleLocal(p,a,b,c)              (p)->lpVtbl->ScaleLocal(p,a,b,c)
> +#define ID3DXMatrixStack_Translate(p,a,b,c)               (p)->lpVtbl->Translate(p,a,b,c)
> +#define ID3DXMatrixStack_TranslateLocal(p,a,b,c)          (p)->lpVtbl->TranslateLocal(p,a,b,c)
> +#define ID3DXMatrixStack_GetTop(p)                        (p)->lpVtbl->GetTop(p)
> -
>
> +#endif

Those macros seem to be missing in the MS header, probably it's better
to drop them here too (similarly to e.g. the mesh-related interfaces
in d3dx9mesh.h). The d3dx9 header is identical in this respect.
> -
>
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> -
>
> +HRESULT WINAPI D3DXCreateMatrixStack(DWORD flags, ID3DXMatrixStack **stack);
> -
>
> +#ifdef __cplusplus
> +}
> +#endif
> -
>
> +#include <d3dx10math.inl>
> -
>
> +#endif /* __D3DX9MATH_H__ */
> diff --git a/include/d3dx10math.inl b/include/d3dx10math.inl
> new file mode 100644
> index 0000000..71cfe41
> --- /dev/null
> +++ b/include/d3dx10math.inl
> @@ -0,0 +1,1298 @@
> +/*
> -
> - Copyright (C) 2007 David Adam
> -
> - Copyright (C) 2007 Tony Wasserka
> -
> -
> -
> - This library is free software; you can redistribute it and/or
> -
> - modify it under the terms of the GNU Lesser General Public
> -
> - License as published by the Free Software Foundation; either
> -
> - version 2.1 of the License, or (at your option) any later version.
> -
> -
> -
> - This library is distributed in the hope that it will be useful,
> -
> - but WITHOUT ANY WARRANTY; without even the implied warranty of
> -
> - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> -
> - Lesser General Public License for more details.
> -
> -
> -
> - You should have received a copy of the GNU Lesser General Public
> -
> - License along with this library; if not, write to the Free Software
> -
> - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
> - */
> -
>
> +#ifndef __D3DXMATH_INL__
> +#define __D3DXMATH_INL__
> -
>
> +/* constructors & operators */
> +#ifdef __cplusplus
> -
>
> +inline D3DXVECTOR2::D3DXVECTOR2()
> +{
> +}
> -
>
> +inline D3DXVECTOR2::D3DXVECTOR2(const FLOAT *pf)
> +{
> - if(!pf) return;
> - x = pf[0];
> - y = pf[1];
>
> +}

That if (and many other similar checks) is actually conditional on a
define. That was already the case in d3dx9, although it used a
different define.
> -
>
> +inline D3DXVECTOR2::D3DXVECTOR2(FLOAT fx, FLOAT fy)
> +{
> - x = fx;
> - y = fy;
>
> +}
> -
>
> +inline D3DXVECTOR2::operator FLOAT* ()
> +{
> - return (FLOAT*)&x;
>
> +}
> -
>
> +inline D3DXVECTOR2::operator const FLOAT* () const
> +{
> - return (const FLOAT*)&x;
>
> +}
> -
>
> +inline D3DXVECTOR2& D3DXVECTOR2::operator += (const D3DXVECTOR2& v)
> +{
> - x += v.x;
> - y += v.y;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR2& D3DXVECTOR2::operator -= (const D3DXVECTOR2& v)
> +{
> - x -= v.x;
> - y -= v.y;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR2& D3DXVECTOR2::operator *= (FLOAT f)
> +{
> - x *= f;
> - y *= f;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR2& D3DXVECTOR2::operator /= (FLOAT f)
> +{
> - x /= f;
> - y /= f;
> - return *this;
>
> +}

These kind of '/' operators are implemented in the original header by
computing the reciprocal and then multiplying it by the operand. I
guess that was changed to make it different compared to the header
from the SDK but that isn't exactly an equivalent implementation. I'm
sure it doesn't really matter in practice (these would only matter if
someone compiles a C++ program using those methods with the wine
headers AND the actual numbers used would happen to make a visible
difference) but I'd be happier if this used the same idea as the
original.
> -
>
> +inline D3DXVECTOR2 D3DXVECTOR2::operator + () const
> +{
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR2 D3DXVECTOR2::operator - () const
> +{
> - return D3DXVECTOR2(-x, -y);
>
> +}
> -
>
> +inline D3DXVECTOR2 D3DXVECTOR2::operator + (const D3DXVECTOR2& v) const
> +{
> - return D3DXVECTOR2(x + v.x, y + v.y);
>
> +}
> -
>
> +inline D3DXVECTOR2 D3DXVECTOR2::operator - (const D3DXVECTOR2& v) const
> +{
> - return D3DXVECTOR2(x - v.x, y - v.y);
>
> +}
> -
>
> +inline D3DXVECTOR2 D3DXVECTOR2::operator * (FLOAT f) const
> +{
> - return D3DXVECTOR2(x * f, y * f);
>
> +}
> -
>
> +inline D3DXVECTOR2 D3DXVECTOR2::operator / (FLOAT f) const
> +{
> - return D3DXVECTOR2(x / f, y / f);
>
> +}
> -
>
> +inline D3DXVECTOR2 operator * (FLOAT f, const D3DXVECTOR2& v)
> +{
> - return D3DXVECTOR2(f * v.x, f * v.y);
>
> +}
> -
>
> +inline BOOL D3DXVECTOR2::operator == (const D3DXVECTOR2& v) const
> +{
> - return x == v.x && y == v.y;
>
> +}
> -
>
> +inline BOOL D3DXVECTOR2::operator != (const D3DXVECTOR2& v) const
> +{
> - return x != v.x || y != v.y;
>
> +}
> -
>
> +inline D3DXVECTOR3::D3DXVECTOR3()
> +{
> +}
> -
>
> +inline D3DXVECTOR3::D3DXVECTOR3(const FLOAT *pf)
> +{
> - if(!pf) return;
> - x = pf[0];
> - y = pf[1];
> - z = pf[2];
>
> +}
> -
>
> +inline D3DXVECTOR3::D3DXVECTOR3(const D3DVECTOR& v)
> +{
> - x = v.x;
> - y = v.y;
> - z = v.z;
>
> +}
> -
>
> +inline D3DXVECTOR3::D3DXVECTOR3(FLOAT fx, FLOAT fy, FLOAT fz)
> +{
> - x = fx;
> - y = fy;
> - z = fz;
>
> +}
> -
>
> +inline D3DXVECTOR3::operator FLOAT* ()
> +{
> - return (FLOAT*)&x;
>
> +}
> -
>
> +inline D3DXVECTOR3::operator const FLOAT* () const
> +{
> - return (const FLOAT*)&x;
>
> +}
> -
>
> +inline D3DXVECTOR3& D3DXVECTOR3::operator += (const D3DXVECTOR3& v)
> +{
> - x += v.x;
> - y += v.y;
> - z += v.z;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR3& D3DXVECTOR3::operator -= (const D3DXVECTOR3& v)
> +{
> - x -= v.x;
> - y -= v.y;
> - z -= v.z;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR3& D3DXVECTOR3::operator *= (FLOAT f)
> +{
> - x *= f;
> - y *= f;
> - z *= f;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR3& D3DXVECTOR3::operator /= (FLOAT f)
> +{
> - x /= f;
> - y /= f;
> - z /= f;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR3 D3DXVECTOR3::operator + () const
> +{
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR3 D3DXVECTOR3::operator - () const
> +{
> - return D3DXVECTOR3(-x, -y, -z);
>
> +}
> -
>
> +inline D3DXVECTOR3 D3DXVECTOR3::operator + (const D3DXVECTOR3& v) const
> +{
> - return D3DXVECTOR3(x + v.x, y + v.y, z + v.z);
>
> +}
> -
>
> +inline D3DXVECTOR3 D3DXVECTOR3::operator - (const D3DXVECTOR3& v) const
> +{
> - return D3DXVECTOR3(x - v.x, y - v.y, z - v.z);
>
> +}
> -
>
> +inline D3DXVECTOR3 D3DXVECTOR3::operator * (FLOAT f) const
> +{
> - return D3DXVECTOR3(x * f, y * f, z * f);
>
> +}
> -
>
> +inline D3DXVECTOR3 D3DXVECTOR3::operator / (FLOAT f) const
> +{
> - return D3DXVECTOR3(x / f, y / f, z / f);
>
> +}
> -
>
> +inline D3DXVECTOR3 operator * (FLOAT f, const D3DXVECTOR3& v)
> +{
> - return D3DXVECTOR3(f * v.x, f * v.y, f * v.z);
>
> +}
> -
>
> +inline BOOL D3DXVECTOR3::operator == (const D3DXVECTOR3& v) const
> +{
> - return x == v.x && y == v.y && z == v.z;
>
> +}
> -
>
> +inline BOOL D3DXVECTOR3::operator != (const D3DXVECTOR3& v) const
> +{
> - return x != v.x || y != v.y || z != v.z;
>
> +}
> -
>
> +inline D3DXVECTOR4::D3DXVECTOR4()
> +{
> +}
> -
>
> +inline D3DXVECTOR4::D3DXVECTOR4(const FLOAT *pf)
> +{
> - if(!pf) return;
> - x = pf[0];
> - y = pf[1];
> - z = pf[2];
> - w = pf[3];
>
> +}
> -
>
> +inline D3DXVECTOR4::D3DXVECTOR4(FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw)
> +{
> - x = fx;
> - y = fy;
> - z = fz;
> - w = fw;
>
> +}
> -
>
> +inline D3DXVECTOR4::operator FLOAT* ()
> +{
> - return (FLOAT*)&x;
>
> +}
> -
>
> +inline D3DXVECTOR4::operator const FLOAT* () const
> +{
> - return (const FLOAT*)&x;
>
> +}
> -
>
> +inline D3DXVECTOR4& D3DXVECTOR4::operator += (const D3DXVECTOR4& v)
> +{
> - x += v.x;
> - y += v.y;
> - z += v.z;
> - w += v.w;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR4& D3DXVECTOR4::operator -= (const D3DXVECTOR4& v)
> +{
> - x -= v.x;
> - y -= v.y;
> - z -= v.z;
> - w -= v.w;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR4& D3DXVECTOR4::operator *= (FLOAT f)
> +{
> - x *= f;
> - y *= f;
> - z *= f;
> - w *= f;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR4& D3DXVECTOR4::operator /= (FLOAT f)
> +{
> - x /= f;
> - y /= f;
> - z /= f;
> - w /= f;
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR4 D3DXVECTOR4::operator + () const
> +{
> - return *this;
>
> +}
> -
>
> +inline D3DXVECTOR4 D3DXVECTOR4::operator - () const
> +{
> - return D3DXVECTOR4(-x, -y, -z, -w);
>
> +}
> -
>
> +inline D3DXVECTOR4 D3DXVECTOR4::operator + (const D3DXVECTOR4& v) const
> +{
> - return D3DXVECTOR4(x + v.x, y + v.y, z + v.z, w + v.w);
>
> +}
> -
>
> +inline D3DXVECTOR4 D3DXVECTOR4::operator - (const D3DXVECTOR4& v) const
> +{
> - return D3DXVECTOR4(x - v.x, y - v.y, z - v.z, w - v.w);
>
> +}
> -
>
> +inline D3DXVECTOR4 D3DXVECTOR4::operator * (FLOAT f) const
> +{
> - return D3DXVECTOR4(x * f, y * f, z * f, w * f);
>
> +}
> -
>
> +inline D3DXVECTOR4 D3DXVECTOR4::operator / (FLOAT f) const
> +{
> - return D3DXVECTOR4(x / f, y / f, z / f, w / f);
>
> +}
> -
>
> +inline D3DXVECTOR4 operator * (FLOAT f, const D3DXVECTOR4& v)
> +{
> - return D3DXVECTOR4(f * v.x, f * v.y, f * v.z, f * v.w);
>
> +}
> -
>
> +inline BOOL D3DXVECTOR4::operator == (const D3DXVECTOR4& v) const
> +{
> - return x == v.x && y == v.y && z == v.z && w == v.w;
>
> +}
> -
>
> +inline BOOL D3DXVECTOR4::operator != (const D3DXVECTOR4& v) const
> +{
> - return x != v.x || y != v.y || z != v.z || w != v.w;
>
> +}
> -
>
> +inline D3DXMATRIX::D3DXMATRIX()
> +{
> +}
> -
>
> +inline D3DXMATRIX::D3DXMATRIX(const FLOAT *pf)
> +{
> - if(!pf) return;
> - memcpy(&_11, pf, sizeof(D3DXMATRIX));
>
> +}
> -
>
> +inline D3DXMATRIX::D3DXMATRIX(const D3DMATRIX& mat)
> +{
> - memcpy(&_11, &mat, sizeof(D3DXMATRIX));
>
> +}
> -
>
> +inline D3DXMATRIX::D3DXMATRIX(FLOAT f11, FLOAT f12, FLOAT f13, FLOAT f14,
> -
>                          FLOAT f21, FLOAT f22, FLOAT f23, FLOAT f24,
> -
>                          FLOAT f31, FLOAT f32, FLOAT f33, FLOAT f34,
> -
>                          FLOAT f41, FLOAT f42, FLOAT f43, FLOAT f44)
>
> +{
> - _11 = f11; _12 = f12; _13 = f13; _14 = f14;
> - _21 = f21; _22 = f22; _23 = f23; _24 = f24;
> - _31 = f31; _32 = f32; _33 = f33; _34 = f34;
> - _41 = f41; _42 = f42; _43 = f43; _44 = f44;
>
> +}
> -
>
> +inline FLOAT& D3DXMATRIX::operator () (UINT row, UINT col)
> +{
> - return m[row][col];
>
> +}
> -
>
> +inline FLOAT D3DXMATRIX::operator () (UINT row, UINT col) const
> +{
> - return m[row][col];
>
> +}
> -
>
> +inline D3DXMATRIX::operator FLOAT* ()
> +{
> - return (FLOAT*)&_11;
>
> +}
> -
>
> +inline D3DXMATRIX::operator const FLOAT* () const
> +{
> - return (const FLOAT*)&_11;
>
> +}
> -
>
> +inline D3DXMATRIX& D3DXMATRIX::operator *= (const D3DXMATRIX& mat)
> +{
> - D3DXMatrixMultiply(this, this, &mat);
> - return *this;
>
> +}
> -
>
> +inline D3DXMATRIX& D3DXMATRIX::operator += (const D3DXMATRIX& mat)
> +{
> - _11 += mat._11; _12 += mat._12; _13 += mat._13; _14 += mat._14;
> - _21 += mat._21; _22 += mat._22; _23 += mat._23; _24 += mat._24;
> - _31 += mat._31; _32 += mat._32; _33 += mat._33; _34 += mat._34;
> - _41 += mat._41; _42 += mat._42; _43 += mat._43; _44 += mat._44;
> - return *this;
>
> +}
> -
>
> +inline D3DXMATRIX& D3DXMATRIX::operator -= (const D3DXMATRIX& mat)
> +{
> - _11 -= mat._11; _12 -= mat._12; _13 -= mat._13; _14 -= mat._14;
> - _21 -= mat._21; _22 -= mat._22; _23 -= mat._23; _24 -= mat._24;
> - _31 -= mat._31; _32 -= mat._32; _33 -= mat._33; _34 -= mat._34;
> - _41 -= mat._41; _42 -= mat._42; _43 -= mat._43; _44 -= mat._44;
> - return *this;
>
> +}
> -
>
> +inline D3DXMATRIX& D3DXMATRIX::operator *= (FLOAT f)
> +{
> - _11 *= f; _12 *= f; _13 *= f; _14 *= f;
> - _21 *= f; _22 *= f; _23 *= f; _24 *= f;
> - _31 *= f; _32 *= f; _33 *= f; _34 *= f;
> - _41 *= f; _42 *= f; _43 *= f; _44 *= f;
> - return *this;
>
> +}
> -
>
> +inline D3DXMATRIX& D3DXMATRIX::operator /= (FLOAT f)
> +{
> - FLOAT inv = 1.0f / f;
> - _11 *= inv; _12 *= inv; _13 *= inv; _14 *= inv;
> - _21 *= inv; _22 *= inv; _23 *= inv; _24 *= inv;
> - _31 *= inv; _32 *= inv; _33 *= inv; _34 *= inv;
> - _41 *= inv; _42 *= inv; _43 *= inv; _44 *= inv;
> - return *this;
>
> +}
> -
>
> +inline D3DXMATRIX D3DXMATRIX::operator + () const
> +{
> - return *this;
>
> +}
> -
>
> +inline D3DXMATRIX D3DXMATRIX::operator - () const
> +{
> - return D3DXMATRIX(-_11, -_12, -_13, -_14,
> -
>                  -_21, -_22, -_23, -_24,
> -
>                  -_31, -_32, -_33, -_34,
> -
>                  -_41, -_42, -_43, -_44);
>
> +}
> -
>
> +inline D3DXMATRIX D3DXMATRIX::operator * (const D3DXMATRIX& mat) const
> +{
> - D3DXMATRIX buf;
> - D3DXMatrixMultiply(&buf, this, &mat);
> - return buf;
>
> +}
> -
>
> +inline D3DXMATRIX D3DXMATRIX::operator + (const D3DXMATRIX& mat) const
> +{
> - return D3DXMATRIX(_11 + mat._11, _12 + mat._12, _13 + mat._13, _14 + mat._14,
> -
>                  _21 + mat._21, _22 + mat._22, _23 + mat._23, _24 + mat._24,
> -
>                  _31 + mat._31, _32 + mat._32, _33 + mat._33, _34 + mat._34,
> -
>                  _41 + mat._41, _42 + mat._42, _43 + mat._43, _44 + mat._44);
>
> +}
> -
>
> +inline D3DXMATRIX D3DXMATRIX::operator - (const D3DXMATRIX& mat) const
> +{
> - return D3DXMATRIX(_11 - mat._11, _12 - mat._12, _13 - mat._13, _14 - mat._14,
> -
>                  _21 - mat._21, _22 - mat._22, _23 - mat._23, _24 - mat._24,
> -
>                  _31 - mat._31, _32 - mat._32, _33 - mat._33, _34 - mat._34,
> -
>                  _41 - mat._41, _42 - mat._42, _43 - mat._43, _44 - mat._44);
>
> +}
> -
>
> +inline D3DXMATRIX D3DXMATRIX::operator * (FLOAT f) const
> +{
> - return D3DXMATRIX(_11 * f, _12 * f, _13 * f, _14 * f,
> -
>                  _21 * f, _22 * f, _23 * f, _24 * f,
> -
>                  _31 * f, _32 * f, _33 * f, _34 * f,
> -
>                  _41 * f, _42 * f, _43 * f, _44 * f);
>
> +}
> -
>
> +inline D3DXMATRIX D3DXMATRIX::operator / (FLOAT f) const
> +{
> - FLOAT inv = 1.0f / f;
> - return D3DXMATRIX(_11 * inv, _12 * inv, _13 * inv, _14 * inv,
> -
>                  _21 * inv, _22 * inv, _23 * inv, _24 * inv,
> -
>                  _31 * inv, _32 * inv, _33 * inv, _34 * inv,
> -
>                  _41 * inv, _42 * inv, _43 * inv, _44 * inv);
>
> +}
> -
>
> +inline D3DXMATRIX operator * (FLOAT f, const D3DXMATRIX& mat)
> +{
> - return D3DXMATRIX(f * mat._11, f * mat._12, f * mat._13, f * mat._14,
> -
>                  f * mat._21, f * mat._22, f * mat._23, f * mat._24,
> -
>                  f * mat._31, f * mat._32, f * mat._33, f * mat._34,
> -
>                  f * mat._41, f * mat._42, f * mat._43, f * mat._44);
>
> +}
> -
>
> +inline BOOL D3DXMATRIX::operator == (const D3DXMATRIX& mat) const
> +{
> - return (memcmp(this, &mat, sizeof(D3DXMATRIX)) == 0);
>
> +}

Just use !memcmp(...) I'd say.
> -
>
> +inline BOOL D3DXMATRIX::operator != (const D3DXMATRIX& mat) const
> +{
> - return (memcmp(this, &mat, sizeof(D3DXMATRIX)) != 0);
>
> +}
> -
>
> +inline D3DXQUATERNION::D3DXQUATERNION()
> +{
> +}
> -
>
> +inline D3DXQUATERNION::D3DXQUATERNION(const FLOAT *pf)
> +{
> - if(!pf) return;
> - x = pf[0];
> - y = pf[1];
> - z = pf[2];
> - w = pf[3];
>
> +}
> -
>
> +inline D3DXQUATERNION::D3DXQUATERNION(FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw)
> +{
> - x = fx;
> - y = fy;
> - z = fz;
> - w = fw;
>
> +}
> -
>
> +inline D3DXQUATERNION::operator FLOAT* ()
> +{
> - return (FLOAT*)&x;
>
> +}
> -
>
> +inline D3DXQUATERNION::operator const FLOAT* () const
> +{
> - return (const FLOAT*)&x;
>
> +}
> -
>
> +inline D3DXQUATERNION& D3DXQUATERNION::operator += (const D3DXQUATERNION& quat)
> +{
> - x += quat.x;
> - y += quat.y;
> - z += quat.z;
> - w += quat.w;
> - return *this;
>
> +}
> -
>
> +inline D3DXQUATERNION& D3DXQUATERNION::operator -= (const D3DXQUATERNION& quat)
> +{
> - x -= quat.x;
> - y -= quat.y;
> - z -= quat.z;
> - w -= quat.w;
> - return *this;
>
> +}
> -
>
> +inline D3DXQUATERNION& D3DXQUATERNION::operator *= (const D3DXQUATERNION& quat)
> +{
> - D3DXQuaternionMultiply(this, this, &quat);
> - return *this;
>
> +}
> -
>
> +inline D3DXQUATERNION& D3DXQUATERNION::operator *= (FLOAT f)
> +{
> - x *= f;
> - y *= f;
> - z *= f;
> - w *= f;
> - return *this;
>
> +}
> -
>
> +inline D3DXQUATERNION& D3DXQUATERNION::operator /= (FLOAT f)
> +{
> - FLOAT inv = 1.0f / f;
> - x *= inv;
> - y *= inv;
> - z *= inv;
> - w *= inv;
> - return *this;
>
> +}
> -
>
> +inline D3DXQUATERNION D3DXQUATERNION::operator + () const
> +{
> - return *this;
>
> +}
> -
>
> +inline D3DXQUATERNION D3DXQUATERNION::operator - () const
> +{
> - return D3DXQUATERNION(-x, -y, -z, -w);
>
> +}
> -
>
> +inline D3DXQUATERNION D3DXQUATERNION::operator + (const D3DXQUATERNION& quat) const
> +{
> - return D3DXQUATERNION(x + quat.x, y + quat.y, z + quat.z, w + quat.w);
>
> +}
> -
>
> +inline D3DXQUATERNION D3DXQUATERNION::operator - (const D3DXQUATERNION& quat) const
> +{
> - return D3DXQUATERNION(x - quat.x, y - quat.y, z - quat.z, w - quat.w);
>
> +}
> -
>
> +inline D3DXQUATERNION D3DXQUATERNION::operator * (const D3DXQUATERNION& quat) const
> +{
> - D3DXQUATERNION buf;
> - D3DXQuaternionMultiply(&buf, this, &quat);
> - return buf;
>
> +}
> -
>
> +inline D3DXQUATERNION D3DXQUATERNION::operator * (FLOAT f) const
> +{
> - return D3DXQUATERNION(x * f, y * f, z * f, w * f);
>
> +}
> -
>
> +inline D3DXQUATERNION D3DXQUATERNION::operator / (FLOAT f) const
> +{
> - FLOAT inv = 1.0f / f;
> - return D3DXQUATERNION(x * inv, y * inv, z * inv, w * inv);
>
> +}
> -
>
> +inline D3DXQUATERNION operator * (FLOAT f, const D3DXQUATERNION& quat)
> +{
> - return D3DXQUATERNION(f * quat.x, f * quat.y, f * quat.z, f * quat.w);
>
> +}
> -
>
> +inline BOOL D3DXQUATERNION::operator == (const D3DXQUATERNION& quat) const
> +{
> - return x == quat.x && y == quat.y && z == quat.z && w == quat.w;
>
> +}
> -
>
> +inline BOOL D3DXQUATERNION::operator != (const D3DXQUATERNION& quat) const
> +{
> - return x != quat.x || y != quat.y || z != quat.z || w != quat.w;
>
> +}
> -
>
> +inline D3DXPLANE::D3DXPLANE()
> +{
> +}
> -
>
> +inline D3DXPLANE::D3DXPLANE(const FLOAT *pf)
> +{
> - if(!pf) return;
> - a = pf[0];
> - b = pf[1];
> - c = pf[2];
> - d = pf[3];
>
> +}
> -
>
> +inline D3DXPLANE::D3DXPLANE(FLOAT fa, FLOAT fb, FLOAT fc, FLOAT fd)
> +{
> - a = fa;
> - b = fb;
> - c = fc;
> - d = fd;
>
> +}
> -
>
> +inline D3DXPLANE::operator FLOAT* ()
> +{
> - return (FLOAT*)&a;
>
> +}
> -
>
> +inline D3DXPLANE::operator const FLOAT* () const
> +{
> - return (const FLOAT*)&a;
>
> +}
> -
>
> +inline D3DXPLANE D3DXPLANE::operator + () const
> +{
> - return *this;
>
> +}
> -
>
> +inline D3DXPLANE D3DXPLANE::operator - () const
> +{
> - return D3DXPLANE(-a, -b, -c, -d);
>
> +}
> -
>
> +inline BOOL D3DXPLANE::operator == (const D3DXPLANE& pl) const
> +{
> - return a == pl.a && b == pl.b && c == pl.c && d == pl.d;
>
> +}
> -
>
> +inline BOOL D3DXPLANE::operator != (const D3DXPLANE& pl) const
> +{
> - return a != pl.a || b != pl.b || c != pl.c || d != pl.d;
>
> +}
> -
>
> +inline D3DXCOLOR::D3DXCOLOR()
> +{
> +}
> -
>
> +inline D3DXCOLOR::D3DXCOLOR(DWORD col)
> +{
> - const FLOAT f = 1.0f / 255.0f;
> - r = f * (FLOAT)(unsigned char)(col >> 16);
> - g = f * (FLOAT)(unsigned char)(col >>  8);
> - b = f * (FLOAT)(unsigned char)col;
> - a = f * (FLOAT)(unsigned char)(col >> 24);
>
> +}

I'm pretty sure the cast to float is unnecessary. The cast to unsigned
char could be replaced by masking the value with 0xff.
> -
>
> +inline D3DXCOLOR::D3DXCOLOR(const FLOAT *pf)
> +{
> - if(!pf) return;
> - r = pf[0];
> - g = pf[1];
> - b = pf[2];
> - a = pf[3];
>
> +}
> -
>
> +inline D3DXCOLOR::D3DXCOLOR(const D3DCOLORVALUE& col)
> +{
> - r = col.r;
> - g = col.g;
> - b = col.b;
> - a = col.a;
>
> +}
> -
>
> +inline D3DXCOLOR::D3DXCOLOR(FLOAT fr, FLOAT fg, FLOAT fb, FLOAT fa)
> +{
> - r = fr;
> - g = fg;
> - b = fb;
> - a = fa;
>
> +}
> -
>
> +inline D3DXCOLOR::operator DWORD () const
> +{
> - DWORD _r = r >= 1.0f ? 0xff : r <= 0.0f ? 0x00 : (DWORD)(r * 255.0f + 0.5f);
> - DWORD _g = g >= 1.0f ? 0xff : g <= 0.0f ? 0x00 : (DWORD)(g * 255.0f + 0.5f);
> - DWORD _b = b >= 1.0f ? 0xff : b <= 0.0f ? 0x00 : (DWORD)(b * 255.0f + 0.5f);
> - DWORD _a = a >= 1.0f ? 0xff : a <= 0.0f ? 0x00 : (DWORD)(a * 255.0f + 0.5f);
> -
> - return (_a << 24) | (_r << 16) | (_g << 8) | _b;
>
> +}

This is way too similar to the original header for my taste.
> -
>
> +inline D3DXCOLOR::operator FLOAT * ()
> +{
> - return (FLOAT*)&r;
>
> +}
> -
>
> +inline D3DXCOLOR::operator const FLOAT * () const
> +{
> - return (const FLOAT*)&r;
>
> +}
> -
>
> +inline D3DXCOLOR::operator D3DCOLORVALUE * ()
> +{
> - return (D3DCOLORVALUE*)&r;
>
> +}
> -
>
> +inline D3DXCOLOR::operator const D3DCOLORVALUE * () const
> +{
> - return (const D3DCOLORVALUE*)&r;
>
> +}
> -
>
> +inline D3DXCOLOR::operator D3DCOLORVALUE& ()
> +{
> - return *((D3DCOLORVALUE*)&r);
>
> +}
> -
>
> +inline D3DXCOLOR::operator const D3DCOLORVALUE& () const
> +{
> - return *((const D3DCOLORVALUE*)&r);
>
> +}

These were dropped in d3dx10 and need to go.
> -
>
> +inline D3DXCOLOR& D3DXCOLOR::operator += (const D3DXCOLOR& col)
> +{
> - r += col.r;
> - g += col.g;
> - b += col.b;
> - a += col.a;
> - return *this;
>
> +}
> -
>
> +inline D3DXCOLOR& D3DXCOLOR::operator -= (const D3DXCOLOR& col)
> +{
> - r -= col.r;
> - g -= col.g;
> - b -= col.b;
> - a -= col.a;
> - return *this;
>
> +}
> -
>
> +inline D3DXCOLOR& D3DXCOLOR::operator *= (FLOAT f)
> +{
> - r *= f;
> - g *= f;
> - b *= f;
> - a *= f;
> - return *this;
>
> +}
> -
>
> +inline D3DXCOLOR& D3DXCOLOR::operator /= (FLOAT f)
> +{
> - FLOAT inv = 1.0f / f;
> - r *= inv;
> - g *= inv;
> - b *= inv;
> - a *= inv;
> - return *this;
>
> +}
> -
>
> +inline D3DXCOLOR D3DXCOLOR::operator + () const
> +{
> - return *this;
>
> +}
> -
>
> +inline D3DXCOLOR D3DXCOLOR::operator - () const
> +{
> - return D3DXCOLOR(-r, -g, -b, -a);
>
> +}
> -
>
> +inline D3DXCOLOR D3DXCOLOR::operator + (const D3DXCOLOR& col) const
> +{
> - return D3DXCOLOR(r + col.r, g + col.g, b + col.b, a + col.a);
>
> +}
> -
>
> +inline D3DXCOLOR D3DXCOLOR::operator - (const D3DXCOLOR& col) const
> +{
> - return D3DXCOLOR(r - col.r, g - col.g, b - col.b, a - col.a);
>
> +}
> -
>
> +inline D3DXCOLOR D3DXCOLOR::operator * (FLOAT f) const
> +{
> - return D3DXCOLOR(r * f, g * f, b * f, a * f);
>
> +}
> -
>
> +inline D3DXCOLOR D3DXCOLOR::operator / (FLOAT f) const
> +{
> - FLOAT inv = 1.0f / f;
> - return D3DXCOLOR(r * inv, g * inv, b * inv, a * inv);
>
> +}
> -
>
> +inline D3DXCOLOR operator * (FLOAT f, const D3DXCOLOR& col)
> +{
> - return D3DXCOLOR(f * col.r, f * col.g, f * col.b, f * col.a);
>
> +}
> -
>
> +inline BOOL D3DXCOLOR::operator == (const D3DXCOLOR& col) const
> +{
> - return r == col.r && g == col.g && b == col.b && a == col.a;
>
> +}
> -
>
> +inline BOOL D3DXCOLOR::operator != (const D3DXCOLOR& col) const
> +{
> - return r != col.r || g != col.g || b != col.b || a != col.a;
>
> +}
> -
>
> +inline D3DXFLOAT16::D3DXFLOAT16()
> +{
> +}
> -
>
> +inline D3DXFLOAT16::D3DXFLOAT16(FLOAT f)
> +{
> - D3DXFloat32To16Array(this, &f, 1);
>
> +}
> -
>
> +inline D3DXFLOAT16::D3DXFLOAT16(const D3DXFLOAT16 &f)
> +{
> - value = f.value;
>
> +}
> -
>
> +inline D3DXFLOAT16::operator FLOAT ()
> +{
> - FLOAT f;
> - D3DXFloat16To32Array(&f, this, 1);
> - return f;
>
> +}
> -
>
> +inline BOOL D3DXFLOAT16::operator == (const D3DXFLOAT16 &f) const
> +{
> - return value == f.value;
>
> +}
> -
>
> +inline BOOL D3DXFLOAT16::operator != (const D3DXFLOAT16 &f) const
> +{
> - return value != f.value;
>
> +}

These changed with d3dx10 to handle NaN and +/-0 comparisons correctly.
> -
>
> +#endif /* __cplusplus */
> -
>
> +/*_______________D3DXCOLOR_____________________*/
> -
>
> +static inline D3DXCOLOR* D3DXColorAdd(D3DXCOLOR *pout, const D3DXCOLOR *pc1, const D3DXCOLOR *pc2)
> +{
> - if ( !pout || !pc1 || !pc2 ) return NULL;

Whitespace inside the parentheses, here and below a number of times.
> - pout->r = (pc1->r) + (pc2->r);
> - pout->g = (pc1->g) + (pc2->g);
> - pout->b = (pc1->b) + (pc2->b);
> - pout->a = (pc1->a) + (pc2->a);
> - return pout;
>
> +}

I guess those extra parentheses are just to make the code somewhat
different from the original. I would remove them and also remove the
'p' prefix from the parameters.
> -
>
> +static inline D3DXCOLOR* D3DXColorLerp(D3DXCOLOR *pout, const D3DXCOLOR *pc1, const D3DXCOLOR *pc2, FLOAT s)
> +{
> - if ( !pout || !pc1 || !pc2 ) return NULL;
> - pout->r = (1-s) * (pc1->r) + s *(pc2->r);
> - pout->g = (1-s) * (pc1->g) + s *(pc2->g);
> - pout->b = (1-s) * (pc1->b) + s *(pc2->b);
> - pout->a = (1-s) * (pc1->a) + s *(pc2->a);
> - return pout;
>
> +}

This one is also slightly changed, probably to make it different from
the original but it won't give exactly the same results. Again, it
does hardly matter, but...
> -
>
> +static inline D3DXCOLOR* D3DXColorModulate(D3DXCOLOR *pout, const D3DXCOLOR *pc1, const D3DXCOLOR *pc2)
> +{
> - if ( !pout || !pc1 || !pc2 ) return NULL;
> - pout->r = (pc1->r) * (pc2->r);
> - pout->g = (pc1->g) * (pc2->g);
> - pout->b = (pc1->b) * (pc2->b);
> - pout->a = (pc1->a) * (pc2->a);
> - return pout;
>
> +}
> -
>
> +static inline D3DXCOLOR* D3DXColorNegative(D3DXCOLOR *pout, const D3DXCOLOR *pc)
> +{
> - if ( !pout || !pc ) return NULL;
> - pout->r = 1.0f - pc->r;
> - pout->g = 1.0f - pc->g;
> - pout->b = 1.0f - pc->b;
> - pout->a = pc->a;
> - return pout;
>
> +}
> -
>
> +static inline D3DXCOLOR* D3DXColorScale(D3DXCOLOR *pout, const D3DXCOLOR *pc, FLOAT s)
> +{
> - if ( !pout || !pc ) return NULL;
> - pout->r = s* (pc->r);
> - pout->g = s* (pc->g);
> - pout->b = s* (pc->b);
> - pout->a = s* (pc->a);
> - return pout;
>
> +}

Whitespaces.
> -
>
> +static inline D3DXCOLOR* D3DXColorSubtract(D3DXCOLOR *pout, const D3DXCOLOR *pc1, const D3DXCOLOR *pc2)
> +{
> - if ( !pout || !pc1 || !pc2 ) return NULL;
> - pout->r = (pc1->r) - (pc2->r);
> - pout->g = (pc1->g) - (pc2->g);
> - pout->b = (pc1->b) - (pc2->b);
> - pout->a = (pc1->a) - (pc2->a);
> - return pout;
>
> +}
> -
>
> +/*_______________D3DXVECTOR2________________________*/
> -
>
> +static inline D3DXVECTOR2* D3DXVec2Add(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x + pv2->x;
> - pout->y = pv1->y + pv2->y;
> - return pout;
>
> +}
> -
>
> +static inline FLOAT D3DXVec2CCW(const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
> +{
> - if ( !pv1 || !pv2) return 0.0f;
> - return ( (pv1->x) * (pv2->y) - (pv1->y) * (pv2->x) );
>
> +}
> -
>
> +static inline FLOAT D3DXVec2Dot(const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
> +{
> - if ( !pv1 || !pv2) return 0.0f;
> - return ( (pv1->x * pv2->x + pv1->y * pv2->y) );
>
> +}
> -
>
> +static inline FLOAT D3DXVec2Length(const D3DXVECTOR2 *pv)
> +{
> - if (!pv) return 0.0f;
> - return sqrtf( pv->x * pv->x + pv->y * pv->y );
>
> +}
> -
>
> +static inline FLOAT D3DXVec2LengthSq(const D3DXVECTOR2 *pv)
> +{
> - if (!pv) return 0.0f;
> - return( (pv->x) * (pv->x) + (pv->y) * (pv->y) );
>
> +}
> -
>
> +static inline D3DXVECTOR2* D3DXVec2Lerp(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2, FLOAT s)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = (1-s) * (pv1->x) + s * (pv2->x);
> - pout->y = (1-s) * (pv1->y) + s * (pv2->y);
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR2* D3DXVec2Maximize(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
> - pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR2* D3DXVec2Minimize(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
> - pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR2* D3DXVec2Scale(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv, FLOAT s)
> +{
> - if ( !pout || !pv) return NULL;
> - pout->x = s * (pv->x);
> - pout->y = s * (pv->y);
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR2* D3DXVec2Subtract(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x - pv2->x;
> - pout->y = pv1->y - pv2->y;
> - return pout;
>
> +}
> -
>
> +/*__________________D3DXVECTOR3_______________________*/
> -
>
> +static inline D3DXVECTOR3* D3DXVec3Add(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x + pv2->x;
> - pout->y = pv1->y + pv2->y;
> - pout->z = pv1->z + pv2->z;
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR3* D3DXVec3Cross(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
> +{
> - D3DXVECTOR3 temp;
> -
> - if ( !pout || !pv1 || !pv2) return NULL;
> - temp.x = (pv1->y) * (pv2->z) - (pv1->z) * (pv2->y);
> - temp.y = (pv1->z) * (pv2->x) - (pv1->x) * (pv2->z);
> - temp.z = (pv1->x) * (pv2->y) - (pv1->y) * (pv2->x);
> - *pout = temp;
> - return pout;
>
> +}
> -
>
> +static inline FLOAT D3DXVec3Dot(const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
> +{
> - if ( !pv1 || !pv2 ) return 0.0f;
> - return (pv1->x) * (pv2->x) + (pv1->y) * (pv2->y) + (pv1->z) * (pv2->z);
>
> +}
> -
>
> +static inline FLOAT D3DXVec3Length(const D3DXVECTOR3 *pv)
> +{
> - if (!pv) return 0.0f;
> - return sqrtf( pv->x * pv->x + pv->y * pv->y + pv->z * pv->z );
>
> +}
> -
>
> +static inline FLOAT D3DXVec3LengthSq(const D3DXVECTOR3 *pv)
> +{
> - if (!pv) return 0.0f;
> - return (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z);
>
> +}
> -
>
> +static inline D3DXVECTOR3* D3DXVec3Lerp(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2, FLOAT s)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = (1-s) * (pv1->x) + s * (pv2->x);
> - pout->y = (1-s) * (pv1->y) + s * (pv2->y);
> - pout->z = (1-s) * (pv1->z) + s * (pv2->z);
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR3* D3DXVec3Maximize(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
> - pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
> - pout->z = pv1->z > pv2->z ? pv1->z : pv2->z;
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR3* D3DXVec3Minimize(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
> - pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
> - pout->z = pv1->z < pv2->z ? pv1->z : pv2->z;
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR3* D3DXVec3Scale(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv, FLOAT s)
> +{
> - if ( !pout || !pv) return NULL;
> - pout->x = s * (pv->x);
> - pout->y = s * (pv->y);
> - pout->z = s * (pv->z);
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR3* D3DXVec3Subtract(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x - pv2->x;
> - pout->y = pv1->y - pv2->y;
> - pout->z = pv1->z - pv2->z;
> - return pout;
>
> +}
> +/*__________________D3DXVECTOR4_______________________*/
> -
>
> +static inline D3DXVECTOR4* D3DXVec4Add(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x + pv2->x;
> - pout->y = pv1->y + pv2->y;
> - pout->z = pv1->z + pv2->z;
> - pout->w = pv1->w + pv2->w;
> - return pout;
>
> +}
> -
>
> +static inline FLOAT D3DXVec4Dot(const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2)
> +{
> - if (!pv1 || !pv2 ) return 0.0f;
> - return (pv1->x) * (pv2->x) + (pv1->y) * (pv2->y) + (pv1->z) * (pv2->z) + (pv1->w) * (pv2->w);
>
> +}
> -
>
> +static inline FLOAT D3DXVec4Length(const D3DXVECTOR4 *pv)
> +{
> - if (!pv) return 0.0f;
> - return sqrtf( pv->x * pv->x + pv->y * pv->y + pv->z * pv->z + pv->w * pv->w );
>
> +}
> -
>
> +static inline FLOAT D3DXVec4LengthSq(const D3DXVECTOR4 *pv)
> +{
> - if (!pv) return 0.0f;
> - return (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z) + (pv->w) * (pv->w);
>
> +}
> -
>
> +static inline D3DXVECTOR4* D3DXVec4Lerp(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2, FLOAT s)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = (1-s) * (pv1->x) + s * (pv2->x);
> - pout->y = (1-s) * (pv1->y) + s * (pv2->y);
> - pout->z = (1-s) * (pv1->z) + s * (pv2->z);
> - pout->w = (1-s) * (pv1->w) + s * (pv2->w);
> - return pout;
>
> +}
> -
> -
>
> +static inline D3DXVECTOR4* D3DXVec4Maximize(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
> - pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
> - pout->z = pv1->z > pv2->z ? pv1->z : pv2->z;
> - pout->w = pv1->w > pv2->w ? pv1->w : pv2->w;
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR4* D3DXVec4Minimize(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
> - pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
> - pout->z = pv1->z < pv2->z ? pv1->z : pv2->z;
> - pout->w = pv1->w < pv2->w ? pv1->w : pv2->w;
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR4* D3DXVec4Scale(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv, FLOAT s)
> +{
> - if ( !pout || !pv) return NULL;
> - pout->x = s * (pv->x);
> - pout->y = s * (pv->y);
> - pout->z = s * (pv->z);
> - pout->w = s * (pv->w);
> - return pout;
>
> +}
> -
>
> +static inline D3DXVECTOR4* D3DXVec4Subtract(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2)
> +{
> - if ( !pout || !pv1 || !pv2) return NULL;
> - pout->x = pv1->x - pv2->x;
> - pout->y = pv1->y - pv2->y;
> - pout->z = pv1->z - pv2->z;
> - pout->w = pv1->w - pv2->w;
> - return pout;
>
> +}
> -
>
> +/*__________________D3DXMatrix____________________*/
> +#ifdef NONAMELESSUNION
> +# define D3DX_U(x)  (x).u
> +#else
> +# define D3DX_U(x)  (x)
> +#endif
> -
>
> +static inline D3DXMATRIX* D3DXMatrixIdentity(D3DXMATRIX *pout)
> +{
> - if ( !pout ) return NULL;
> - D3DX_U(*pout).m[0][1] = 0.0f;
> - D3DX_U(*pout).m[0][2] = 0.0f;
> - D3DX_U(*pout).m[0][3] = 0.0f;
> - D3DX_U(*pout).m[1][0] = 0.0f;
> - D3DX_U(*pout).m[1][2] = 0.0f;
> - D3DX_U(*pout).m[1][3] = 0.0f;
> - D3DX_U(*pout).m[2][0] = 0.0f;
> - D3DX_U(*pout).m[2][1] = 0.0f;
> - D3DX_U(*pout).m[2][3] = 0.0f;
> - D3DX_U(*pout).m[3][0] = 0.0f;
> - D3DX_U(*pout).m[3][1] = 0.0f;
> - D3DX_U(*pout).m[3][2] = 0.0f;
> - D3DX_U(*pout).m[0][0] = 1.0f;
> - D3DX_U(*pout).m[1][1] = 1.0f;
> - D3DX_U(*pout).m[2][2] = 1.0f;
> - D3DX_U(*pout).m[3][3] = 1.0f;
> - return pout;
>
> +}
> -
>
> +static inline BOOL D3DXMatrixIsIdentity(D3DXMATRIX *pm)
> +{
> - int i,j;
> - D3DXMATRIX testmatrix;
> -
> - if ( !pm ) return FALSE;
> - D3DXMatrixIdentity(&testmatrix);
> - for (i=0; i<4; i++)
> - {
> -
> for (j=0; j<4; j++)
> -
> {
> -
>  if ( D3DX_U(*pm).m[i][j] != D3DX_U(testmatrix).m[i][j] ) return FALSE;
> -
> }
> - }
> - return TRUE;
>
> +}
> +#undef D3DX_U
> -
>
> +/*__________________D3DXPLANE____________________*/
> -
>
> +static inline FLOAT D3DXPlaneDot(const D3DXPLANE *pp, const D3DXVECTOR4 *pv)
> +{
> - if ( !pp || !pv ) return 0.0f;
> - return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) + (pp->d) * (pv->w) );
>
> +}
> -
>
> +static inline FLOAT D3DXPlaneDotCoord(const D3DXPLANE *pp, const D3DXVECTOR4 *pv)
> +{
> - if ( !pp || !pv ) return 0.0f;
> - return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) + (pp->d) );
>
> +}
> -
>
> +static inline FLOAT D3DXPlaneDotNormal(const D3DXPLANE *pp, const D3DXVECTOR4 *pv)
> +{
> - if ( !pp || !pv ) return 0.0f;
> - return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) );
>
> +}

D3DXPlaneScale() is missing.
> -
>
> +/*__________________D3DXQUATERNION____________________*/
> -
>
> +static inline D3DXQUATERNION* D3DXQuaternionConjugate(D3DXQUATERNION *pout, const D3DXQUATERNION *pq)
> +{
> - if ( !pout || !pq) return NULL;
> - pout->x = -pq->x;
> - pout->y = -pq->y;
> - pout->z = -pq->z;
> - pout->w = pq->w;
> - return pout;
>
> +}
> -
>
> +static inline FLOAT D3DXQuaternionDot(const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2)
> +{
> - if ( !pq1 || !pq2 ) return 0.0f;
> - return (pq1->x) * (pq2->x) + (pq1->y) * (pq2->y) + (pq1->z) * (pq2->z) + (pq1->w) * (pq2->w);
>
> +}
> -
>
> +static inline D3DXQUATERNION* D3DXQuaternionIdentity(D3DXQUATERNION *pout)
> +{
> - if ( !pout) return NULL;
> - pout->x = 0.0f;
> - pout->y = 0.0f;
> - pout->z = 0.0f;
> - pout->w = 1.0f;
> - return pout;
>
> +}
> -
>
> +static inline BOOL D3DXQuaternionIsIdentity(D3DXQUATERNION *pq)
> +{
> - if ( !pq) return FALSE;
> - return ( (pq->x == 0.0f) && (pq->y == 0.0f) && (pq->z == 0.0f) && (pq->w == 1.0f) );
>
> +}
> -
>
> +static inline FLOAT D3DXQuaternionLength(const D3DXQUATERNION *pq)
> +{
> - if (!pq) return 0.0f;
> - return sqrtf( pq->x * pq->x + pq->y * pq->y + pq->z * pq->z + pq->w * pq->w );
>
> +}
> -
>
> +static inline FLOAT D3DXQuaternionLengthSq(const D3DXQUATERNION *pq)
> +{
> - if (!pq) return 0.0f;
> - return (pq->x) * (pq->x) + (pq->y) * (pq->y) + (pq->z) * (pq->z) + (pq->w) * (pq->w);
>
> +}
> -
> +#endif
>
> 1.9.1

General comment (already hinted above), I'd drop all the 'p's prefixed
to pointer function argument names.

Many of the issues of this patch come from our current d3dx9 headers.
It might be a good idea to fix some of the worst offenders there
before adding the d3dx10math.* files. Since formatting-only patches
are generally not allowed, you might for example write a patch adding
the missing D3DXVECTOR4 constructor and fix up the ID3DXMatrixStack
interface at the same time.
If someone disagrees with this kind of plan just speak up.

There is more stuff missing I haven't mentioned above, e.g. aligned
matrices defines and structs. It's probably fine to leave those out
for the time being.