3dplus.h

经典游戏之源程序－飞行模拟器,方便学习和自我娱乐

// 3dplus.h
//
// Copyright (c) Nigel Thompson 1996
//
// This file should be included in your application's main
// include file so that it is available to all modules that
// need access the the 3D classes
//

#ifndef _3DPLUS_H_
#define _3DPLUS_H_

// NOTE: This set of C++ classes assumes the Reality Lab APIs
// are defined using their floating point format so an RLValue is
// a double.
#ifdef FIXED_POINT_API
#pragma message("Invalid use of fixed-point API in rendering engine")
ERROR - Rendering API
#endif

// disable warning C4244 which is issued when a const double is converted
// to a float. This happens when we initialise RLValues
#pragma warning ( disable : 4244)

// include the Direct Draw classes
#include "3dDirect.h"

// include the resource symbols
#include "3dRes.h"

// global helper functions
extern CString Get3dError(HRESULT hr);

// File dialog filter strings
#define _3DOBJ_LOADFILTER "Shape Files (*.x)|*.x|All Files (*.*)|*.*||"
#define _3DOBJ_SAVEFILTER "Shape Files (*.x)|*.x|All files (*.*)|*.*||"

///////////////////////////////////////////////////////////////////
// C3dObject

class C3dObject : public CObject
{
public:
	DECLARE_DYNAMIC(C3dObject);
    C3dObject();
    virtual ~C3dObject();
	HRESULT GetResult() {return m_hr;}

protected:
	HRESULT m_hr; // result of last system call

};

///////////////////////////////////////////////////////////////////
// C3dEngine

class C3dDevice;
class C3dCamera;

class C3dEngine : public C3dObject
{
public:
	DECLARE_DYNAMIC(C3dEngine);
    C3dEngine();
    virtual ~C3dEngine();
    BOOL CreateFrame(IDirect3DRMFrame* pIParentFrame, IDirect3DRMFrame** pIFrame);
	IDirect3DRM* GetInterface() {return m_pIRM;}
    BOOL CreateViewport(C3dDevice* pDevice,
						C3dCamera* pCamera,
						int x, int y,
						int cx, int cy,
						IDirect3DRMViewport** pIViewport);
    BOOL CreateLight(D3DRMLIGHTTYPE type,
                     double r, double g, double b,
                     IDirect3DRMLight** piLight);
    BOOL CreateMeshBuilder(IDirect3DRMMeshBuilder** pIBld);
    BOOL CreateTexture(D3DRMIMAGE* pImage, IDirect3DRMTexture** pITexture);
    BOOL CreateWrap(D3DRMWRAPTYPE type,
                    IDirect3DRMFrame* pIRefFrame,
                    double ox, double oy, double oz,
                    double dx, double dy, double dz,
                    double ux, double uy, double uz,
                    double ou, double ov,
                    double su, double sv,
                    IDirect3DRMWrap** pIWrap);
	BOOL CreateMaterial(double sharp, IDirect3DRMMaterial** pIMat);

protected:
	IDirect3DRM* m_pIRM; // WinRealityLab interface 


private:
    static BOOL s_bInitialized;
    static IDirect3DRM* s_pRL; // main Reality Lab object

    static BOOL Initialize();
};

// the one and only 3dEngine object
extern C3dEngine the3dEngine;   

///////////////////////////////////////////////////////////////////
// C3dVisual

class C3dVisual : public C3dObject
{
public:
	DECLARE_DYNAMIC(C3dVisual);
	C3dVisual();
	const char* GetName() {return m_strName;}
	void SetName(const char* pszName) {m_strName = pszName;}
	IDirect3DRMVisual* GetInterface()
	{return _GetVisualInterface();}

protected:
	virtual IDirect3DRMVisual* _GetVisualInterface()
		{return NULL;}

	CString m_strName;
};

///////////////////////////////////////////////////////////////////
// C3dVector

class C3dVector	: public _D3DVECTOR

{
public:
	C3dVector();
	virtual ~C3dVector();
	C3dVector(const D3DVECTOR& r);
	C3dVector(double x, double y, double z);
    C3dVector& operator = (const D3DVECTOR& r);
    friend C3dVector operator + (const D3DVECTOR& a, const D3DVECTOR& b);
    C3dVector& operator += (const D3DVECTOR& r);
    friend C3dVector operator - (const D3DVECTOR& a, const D3DVECTOR& b);
    C3dVector& operator -= (const D3DVECTOR& r);
    friend C3dVector operator * (const D3DVECTOR& a, const D3DVECTOR& b);
    C3dVector& operator *= (const D3DVECTOR& r);
    friend C3dVector operator * (const D3DVECTOR& a, const double s);
    C3dVector& operator *= (const double s);
	C3dVector operator - ();
	double Dot(const D3DVECTOR& a);
	double Mag();
	BOOL Normalize();
	BOOL Coincident(const D3DVECTOR& r);
	C3dVector GenerateUp();
	BOOL IsNull();

public:
	//double m_x, m_y, m_z;
};

///////////////////////////////////////////////////////////////////
// C3dMatrix

class C3dMatrix	: public C3dObject

{
public:
	DECLARE_DYNAMIC(C3dMatrix);
    C3dMatrix();
    virtual ~C3dMatrix();
    C3dMatrix(const C3dMatrix& r);
    C3dMatrix(double v00, double v01, double v02, double v03,
              double v10, double v11, double v12, double v13,
              double v20, double v21, double v22, double v23,
              double v30, double v31, double v32, double v33);
    C3dMatrix& operator = (const C3dMatrix& r);
    friend C3dMatrix operator + (const C3dMatrix& a, const C3dMatrix& b);
    C3dMatrix& operator += (const C3dMatrix& r);
    friend C3dMatrix operator * (const C3dMatrix& a, const C3dMatrix& b);
    C3dMatrix& operator *= (const C3dMatrix& r);
    friend C3dVector operator * (const C3dMatrix& m, const D3DVECTOR& v);
    void Rotate(double rx, double ry, double rz);
    void Translate(double dx, double dy, double dz);
	void Scale(double sx, double sy, double sz);
	void Scale(double s) {Scale(s, s, s);}
	void MakeUnit();
	void Initialize(D3DRMMATRIX4D& rlm);

	// elements
	double m_00, m_01, m_02, m_03;
	double m_10, m_11, m_12, m_13;
	double m_20, m_21, m_22, m_23;
	double m_30, m_31, m_32, m_33;
};

#if 0
///////////////////////////////////////////////////////////////////
// C3dQuaternion

class C3dQuaternion : public _D3DRMQUATERNION
{
public:
	C3dQuaternion();
	C3dQuaternion(const D3DVECTOR& v, const double theta);
	C3dQuaternion(const D3DVECTOR& vDir, const D3DVECTOR& vUp);
	virtual ~C3dQuaternion();
    C3dQuaternion& operator = (const D3DRMQUATERNION& r);
};
#endif

////////////////////////////////////////////////////////////////////
// C3dMaterial

class C3dMaterial :	public C3dObject
{
public:
	DECLARE_DYNAMIC(C3dMaterial);
	C3dMaterial();
	virtual ~C3dMaterial();
	void SetEmissiveColor(double r, double g, double b);
	void SetSpecularPower(double p);
	void SetSpecularColor(double r, double g, double b);
	IDirect3DRMMaterial* GetInterface() {return m_pIMat;}

protected:
	IDirect3DRMMaterial* m_pIMat;
};

///////////////////////////////////////////////////////////////////
// C3dFrame
//
// Note: if pRef is NULL, this implies the frame's parent is to be used
// as the reference frame
//

class C3dTexture;

class C3dFrame : public C3dVisual
{
public:
	DECLARE_DYNAMIC(C3dFrame);
    C3dFrame();
    virtual ~C3dFrame();
    IDirect3DRMFrame* GetInterface() {return this == NULL ? NULL : m_pIFrame;}
    BOOL Create(C3dFrame* pParent);
    void SetPosition(double x, double y, double z, C3dFrame* pRef = NULL);
    void SetPosition(D3DVECTOR& p, C3dFrame* pRef = NULL)
		{SetPosition(p.x, p.y, p.z, pRef);}
    void GetPosition(double& x, double& y, double& z, C3dFrame* pRef = NULL);
    void GetPosition(D3DVECTOR& p, C3dFrame* pRef = NULL);
    void SetRotation(double x, double y, double z, double t, C3dFrame* pRef = NULL);
    void SetDirection(double dx, double dy, double dz,
                      double ux, double uy, double uz, C3dFrame* pRef = NULL);
    void GetDirection(double& dx, double& dy, double& dz,
                      double& ux, double& uy, double& uz, C3dFrame* pRef = NULL);
    void GetDirection(D3DVECTOR& d,D3DVECTOR& u, C3dFrame* pRef = NULL);
    void SetDirection(double dx, double dy, double dz, C3dFrame* pRef = NULL);
    void GetDirection(double& dx, double& dy, double& dz, C3dFrame* pRef = NULL);
    void SetDirection(D3DVECTOR& d, D3DVECTOR& u, C3dFrame* pRef = NULL);
    void SetDirection(D3DVECTOR& d, C3dFrame* pRef = NULL)
		{SetDirection(d.x, d.y, d.z, pRef);}
	void AddTransform(C3dMatrix& m, D3DRMCOMBINETYPE ct = D3DRMCOMBINE_BEFORE);
	void AddRotation(double x, double y, double z,
					 double t, D3DRMCOMBINETYPE ct = D3DRMCOMBINE_BEFORE);
    BOOL AddChild(C3dFrame* pChild);
    BOOL RemoveChild(C3dFrame* pChild);
	void RemoveAllChildren();
    void SetVelocity(double x, double y, double z, C3dFrame* pRef = NULL);
    BOOL SetTexture(C3dTexture* pTexture);
	void Attach(IDirect3DRMFrame* pIFrame);
	D3DVECTOR Transform(const D3DVECTOR& vLocal);
	BOOL IsChildOf(C3dFrame* pFrame);
	BOOL IsPartOf(C3dFrame* pFrame);
	void SetMaterialMode(D3DRMMATERIALMODE mode);
	BOOL AddVisual(C3dVisual* pVisual);
	BOOL RemoveVisual(C3dVisual* pVisual);

protected:
    IDirect3DRMFrame* m_pIFrame;

	IDirect3DRMFrame* _GetRef(C3dFrame* pRef);

};

class C3dFrameList : protected CObList
{
public:
	C3dFrameList();
	virtual ~C3dFrameList();
	void Append(C3dFrame* pFrame) {CObList::AddTail(pFrame);}
	void Remove(C3dFrame* pFrame);
	void Delete(C3dFrame* pFrame);
	void DeleteAll();
	C3dFrame* GetNext(POSITION& rPosition)
		{return (C3dFrame*) CObList::GetNext(rPosition);}

};

///////////////////////////////////////////////////////////////////
// C3dCamera

class C3dCamera : public C3dFrame
{
public:
	DECLARE_DYNAMIC(C3dCamera);

protected:

};

///////////////////////////////////////////////////////////////////
// C3dLight

class C3dLight : public C3dFrame
{
public:
	DECLARE_DYNAMIC(C3dLight);
    C3dLight();
    virtual ~C3dLight();
    BOOL Create(D3DRMLIGHTTYPE type, double r, double g, double b);
    BOOL SetColor(double r, double g, double b);
	void GetColor(double& r, double& g, double& b);
	void GetAttenuation(double& c, double& l, double& q);
	double GetRange();
	void SetAttenuation(double c, double l, double q);
	void SetRange(double r);
	IDirect3DRMLight* GetLight() {return m_pILight;}

protected:
   IDirect3DRMLight* m_pILight;

};

///////////////////////////////////////////////////////////////////
// C3dAmbLight

class C3dAmbLight : public C3dLight
{
public:
	DECLARE_DYNAMIC(C3dAmbLight);
    BOOL Create(double r, double g, double b);
};

///////////////////////////////////////////////////////////////////
// C3dDirLight

class C3dDirLight : public C3dLight
{
public:
	DECLARE_DYNAMIC(C3dDirLight);
    BOOL Create(double r, double g, double b);
};

///////////////////////////////////////////////////////////////////
// C3dParPtLight

class C3dParPtLight : public C3dLight
{
public:
	DECLARE_DYNAMIC(C3dParPtLight);
    BOOL Create(double r, double g, double b);
};

///////////////////////////////////////////////////////////////////
// C3dPtLight

class C3dPtLight : public C3dLight
{
public:
	DECLARE_DYNAMIC(C3dPtLight);
    BOOL Create(double r, double g, double b);
};

///////////////////////////////////////////////////////////////////
// C3dSpotLight

class C3dSpotLight : public C3dLight
{
public:
	DECLARE_DYNAMIC(C3dSpotLight);
    BOOL Create(double r, double g, double b);
};

///////////////////////////////////////////////////////////////////
// C3dImage and CImageList

class C3dImage : public C3dVisual
{
public:
	DECLARE_DYNAMIC(C3dImage);
    C3dImage();
    virtual ~C3dImage();
    BOOL Load(CFile* fp);
    BOOL Load(const char* pszFilename);
	BOOL Load() {return Load((const char*) NULL);}
    BOOL Load(UINT uiResid)
		{return LoadResource(MAKEINTRESOURCE(uiResid));}
	BOOL LoadResource(const char* pszResname);
    D3DRMIMAGE* GetObject() {return &m_rlimg;}
	int C3dImage::GetWidth() {return m_rlimg.width;}
	int C3dImage::GetHeight() {return m_rlimg.height;}
	BOOL SetNumPhases(int iPhases);
	int GetNumPhases() {return m_iPhases;}
	BOOL SetPhase(int iPhase);
	int GetPhase() {return m_iCurPhase;}

protected:
    void _Create(BITMAPINFOHEADER* pBMI, RGBQUAD* pRGB, BYTE* pBits);
    void _ReleaseMemory();
	virtual void _OnImageChanged() {;}

    D3DRMIMAGE m_rlimg;
	BYTE* m_pBits;
	int m_iTotalHeight;
	int m_iPhases;
	int m_iCurPhase;
};

class C3dImageList : protected CObList
{
public:
	C3dImageList();
	virtual ~C3dImageList();
	void Append(C3dImage* pImage) {CObList::AddTail(pImage);}
	void Remove(C3dImage* pImage);
	void Delete(C3dImage* pImage);
	void DeleteAll();
	C3dImage* GetNext(POSITION& rPosition)
		{return (C3dImage*) CObList::GetNext(rPosition);}
	POSITION GetHeadPosition()
		{return CObList::GetHeadPosition();}
	C3dImage* Find(const char* pszName);

};

// handy helper
extern BOOL DIBSave(const char* pszFilename, BITMAPINFO* pBMI, void* pBits);
extern int DIBColorEntries(BITMAPINFOHEADER* pBIH); 
extern int DIBStorageWidth(BITMAPINFOHEADER* pBIH);

///////////////////////////////////////////////////////////////////
// C3dShape

typedef double (* SURFHTFN)(double x, double z, void* pArg);
typedef double (* SOLIDRFN)(double z, void* pArg);