MathDX.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_MathDX_H
#define _INC_MathDX_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "../Image/cColorRef.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
typedef float D3DVALUE;         // #define DX_SHARED_DEFINES
 
#ifdef USE_DXM
// let DX define its own math stuff.
#include <DirectXMath.h> // XMFLOAT3
using namespace DirectX;
 
#else // USE_DXM
// define stuff i might use without including <DirectXMath.h>
 
#if _MSC_VER >= 1300  // VC7
#define D3DX_ALIGN16 __declspec(align(16)) // for faster matrix access.
#else
#define D3DX_ALIGN16  // Earlier compiler may not understand this, do nothing.
#endif
 
typedef DWORD D3DCOLOR;
 
struct XMFLOAT2
{
        // XMFLOAT2
        XMFLOAT2() noexcept
        {}
        XMFLOAT2( const D3DVALUE* pVal ) noexcept
        : x(pVal[0]), y(pVal[1])
        {
        }
        operator D3DVALUE*() noexcept
        {
                return &x;
        }
        operator const D3DVALUE*() const noexcept
        {
                return &x;
        }
public:
        D3DVALUE x, y;
};
 
struct XMFLOAT3 
{
        // XMFLOAT3
        D3DVALUE x, y, z;
 
        XMFLOAT3() noexcept
        {
                // x=_x; y=_y; z=_z;
        }
        XMFLOAT3( D3DVALUE _x, D3DVALUE _y, D3DVALUE _z ) noexcept
        {
                x=_x; y=_y; z=_z;
        }
        XMFLOAT3( const XMFLOAT3& v ) noexcept
        {
                x = v.x; y = v.y; z = v.z;
        }
        XMFLOAT3( const D3DVALUE* pVal )  
        {
                x = pVal[0]; y=pVal[1]; z=pVal[2];
        }
        operator D3DVALUE*() noexcept
        {
                return &x;
        }
        operator const D3DVALUE*() const noexcept
        {
                return &x;
        }
        XMFLOAT3 operator + ( const XMFLOAT3& v ) const
        {
                return XMFLOAT3( x + v.x, y + v.y, z + v.z );
        }
        XMFLOAT3 operator * ( const XMFLOAT3& v ) const
        {
                // HLSL, but no d3dx equivalent
                return XMFLOAT3( x * v.x, y * v.y, z * v.z );
        }
        XMFLOAT3 operator * ( D3DVALUE fScale ) const
        {
                // HLSL, but no d3dx equivalent
                return XMFLOAT3( x * fScale, y *fScale, z * fScale );
        }
        friend XMFLOAT3 operator * ( D3DVALUE f, const XMFLOAT3& v )
        {
                return XMFLOAT3( f * v.x, f * v.y, f * v.z);
        }
};
struct XMFLOAT4
{
        // like XMFLOAT4 .
        // Use XMLoadFloat4() to get XMVECTOR FXMVECTOR
 
        XMFLOAT4() noexcept
        {}
        XMFLOAT4( D3DVALUE _x, D3DVALUE _y, D3DVALUE _z, D3DVALUE _w ) noexcept
        : x(_x), y(_y), z(_z), w(_w)
        {
        }
        XMFLOAT4( const D3DVALUE* pVal )
        {
                x = pVal[0]; y=pVal[1]; z=pVal[2]; w=pVal[3];
        }
        XMFLOAT4( const XMFLOAT3& xyz, float _w ) noexcept
        {
                x = xyz.x; y=xyz.y; z=xyz.z; w=_w;
        }
        operator D3DVALUE*() noexcept
        {
                return &x;
        }
        operator const D3DVALUE*() const noexcept
        {
                return &x;
        }
 
public:
        D3DVALUE x, y, z, w;
};
 
struct XMFLOAT4X4
{
        // XMFLOAT4X4
        union
        {
                struct
                {
                        D3DVALUE        _11, _12, _13, _14;
                        D3DVALUE        _21, _22, _23, _24;
                        D3DVALUE        _31, _32, _33, _34;
                        D3DVALUE        _41, _42, _43, _44;
                };
                D3DVALUE m[4][4];
                D3DVALUE a[16];
        };
};
 
struct D3DX_ALIGN16 XMMATRIX : public XMFLOAT4X4   
{
        // 16 byte aligned block.
        XMMATRIX() noexcept
        {
                // undefined.
        }
        XMMATRIX( const D3DVALUE* src )
        {
                ::memcpy( this->m, src, sizeof(m));
        }
        XMMATRIX( const XMFLOAT4X4& src ) noexcept
        {
                ::memcpy(this->m, src.m, sizeof(m));
        }
        XMMATRIX( D3DVALUE a11, D3DVALUE a12, D3DVALUE a13, D3DVALUE a14,
                D3DVALUE a21, D3DVALUE a22, D3DVALUE a23, D3DVALUE a24,
                D3DVALUE a31, D3DVALUE a32, D3DVALUE a33, D3DVALUE a34,
                D3DVALUE a41, D3DVALUE a42, D3DVALUE a43, D3DVALUE a44 ) noexcept
        {
                _11=a11; _12=a12; _13=a13; _14=a14;
                _21=a21; _22=a22; _23=a23; _24=a24;
                _31=a31; _32=a32; _33=a33; _34=a34;
                _41=a41; _42=a42; _43=a43; _44=a44;
        }
 
        D3DVALUE& operator()(int i, int j) 
        { return m[i][j]; }
        D3DVALUE  operator()(int i, int j) const
        { return m[i][j]; }
};
 
#endif  // USE_DXM
 
#endif // _INC_MathDX_H