ul.h

游戏编程精华02－含有几十个游戏编程例子

};

class ComRef: public IUnknown
{
public:
    ComRef() 
    { 
        m_dwRef = 0;
    }
    
    virtual ~ComRef()
    {
        m_dwRef = 0;
    }
    
    HRESULT __stdcall QueryInterface(const IID & riid, LPVOID * ppvObj)
    {
        if (riid == IID_IUnknown)
        {
            *ppvObj = this;
            AddRef();
            return 0;
        }
        return 1;
    }  
    
    DWORD __stdcall AddRef() 
    { 
        return ++m_dwRef; 
    }
    DWORD __stdcall GetRef() 
    { 
        return m_dwRef; 
    }
    DWORD __stdcall SetRef(ULONG v) 
    { 
        m_dwRef = v; 
    }
    
    
    DWORD __stdcall Release() 
    { 
        if (--m_dwRef == 0) 
        {
            delete this; 
            return 0;
        }
        return m_dwRef;
    }
    
private:
    DWORD m_dwRef;
    
};


template <class _BaseClass, class _TypePtr> 
class InstanceList
{
    friend class Instance;
    
public:
    
    ~InstanceList() 
    {
        // in a destructor, leave the data hanging around
        EraseList(false); 
    }
    
    class Instance
    {
        friend class InstanceList<_BaseClass, _TypePtr>;
    public:
        Instance * GetNext() {return m_next;}
        Instance * GetPrev() {return m_prev;}
        void GetNext(Instance * n) {m_next = n;}
        void GetPrev(Instance * n) {m_prev = n;}
        
        Instance(Instance *p, Instance *n, _TypePtr v)
        {
            set(p,n,v);
        }
        
        void set(Instance *p, Instance *n, _TypePtr v)
        {
            m_prev = p;
            m_next = n;
            data = v;
        }    
        
        operator _TypePtr() const
        {
            return data;
        }
        
        _TypePtr operator->() const
        {
            ATLASSERT(data!=NULL);
            return data;
        }
        
        bool operator==(_TypePtr pT) const
        {
            return data == pT;
        }
        
    protected:
        
        Instance * m_next;   
        Instance * m_prev;   
        
    private:
        _TypePtr data;
    };
    
    
    typedef Instance * iterator;
    
    
    
    Instance * m_head;
    Instance * m_tail;
    _TypePtr m_current;
    int m_currentnum;
    int m_NumNodes;   
    Instance * iptr; // traversal
    
    
public:
    InstanceList() 
    {
        InitList();
    }
    
    void InitList()
    {
        m_head = 0; 
        m_tail = 0; 
        m_NumNodes  = 0; 
        m_current = 0; 
        m_currentnum = -1;
    }
    
    Instance * Head() { return m_head;}
    Instance * Tail() { return m_tail;}
    bool IsEmpty() { return (Size() == 0);}
    bool empty() { return (Size() == 0);}
    int Size() {return m_NumNodes;}
    int size() {return m_NumNodes;}
    _TypePtr SetCurrentByNumber(const int & n) 
    {
        m_current = GetEntryByNumber(n);
        m_currentnum = n;
        return m_current;
    }
    _TypePtr GetFirstEntry()
    {
        iptr = Head();
        if (iptr)
            return iptr->data;
        return 0;
    }
    _TypePtr GetNextEntry()
    {
        if (iptr)
        {
            iptr = iptr->GetNext();
            if (iptr)
                return iptr->data;
        }
        
        return 0;
    }
    _TypePtr GetLastEntry()
    {
        iptr = Tail();
        if (iptr)
            return iptr->data;
        return 0;
    }
    _TypePtr GetPrevEntry()
    {
        if (iptr)
        {
            iptr = iptr->GetPrev();
            if (iptr)
                return iptr->data;
        }
        return 0;
    }
    
    
    void SetCurrent(_TypePtr node) {m_current = node;}
    void SetCurrentAndNumber(_TypePtr node) 
    {
        FindNode(node, m_currentnum);
        m_current = node;
    }

    _TypePtr GetCurrent()
	 {
		 return m_current;
	 }
    int GetCurrentNumber() {return m_currentnum;}
    
    
    _TypePtr GetEntryByNumber(int n)
    {
        iterator p;
        int i = 0;
        
        for(p = Head(); p;  p = p->GetNext() /*NextItem(p) */ )
        {
            if (i == n)
            {
                if (p)
					 {
						 iptr = Head();
                    return p->data;
					 }
                else
					 {
						 iptr = Head();
                    return 0;
					 }
            }
            i++;
        }
		  iptr = Head();
        return 0;
    }
    
    iterator FindNode(_TypePtr f, int & n)
    {
        iterator p;
        n = 0;
        
        for(p = Head(); p;  p = p->GetNext() /*NextItem(p) */ )
        {
            if (f == p->data)
                return p;
            n++;
        }
        return 0; // not found
    }
    
    
    
    
    iterator Erase(iterator p, bool del_obj = true) 
    {
        iterator nextnode = 0;  // return next in list
        if (p)
        {
            nextnode = p->GetNext();  // return next in list
            
            if (p == m_head)
            {
                // at start
                m_head = m_head->m_next;  // inc head
                if (m_head)
                    m_head->m_prev = 0;     // terminate start
                else
                    m_tail = 0;   // no more list
                
            }
            else if (p == m_tail)
            {
                m_tail = m_tail->m_prev;
                if (m_tail)
                    m_tail->m_next = 0;     // terminate end
                else
                    m_head = 0;
                
            }
            else
            {
                // at start
                Instance * prevnode = p->m_prev;  // return prev in list
                
                prevnode->m_next = nextnode;  
                nextnode->m_prev = prevnode;  
            }
            if (*p == m_current)
            {
                m_current = 0;
                m_currentnum = -1;
            }
            
            if (del_obj)
                DeleteData(*p);
            delete p;
            p = 0;
            m_NumNodes--;
        }
        
        if (m_tail && m_tail->m_next != 0)
            m_tail->m_next = 0;
        
        if (m_head && m_head->m_prev != 0)
            m_head->m_prev = 0; 
        
        return nextnode;
    }
    
    void EraseList(bool del_obj = true) 
    {
        m_current = 0;
        
        iterator p = m_head;
        while (p)
            p = Erase(p, del_obj);
        
        InitList();
        
    }
    
    void DeleteData(_BaseClass * p)
    {
        if (p)
            delete p;
    }
    
    void DeleteData(ulComPtr<_BaseClass> p)
    {
        p->DeleteLists();
    }
    
    
    void SoilList() 
    {
        iterator p;
        
        for(p = Head(); p;  p = p->GetNext() /*NextItem(p) */)
        {
            (*p)->SetChanged(true);
        }
    }
    void RefreshList() 
    {
        iterator p;
        
        for(p = Head(); p;  p = p->GetNext() /*NextItem(p) */ )
        {
            (*p)->RefreshRenderer();
        }
    }
    
    void AddListToRenderer() 
    {
        iterator p;
        
        for(p = Head(); p;  p = p->GetNext() /*NextItem(p) */ )
        {
            (*p)->AddToRenderer();
            (*p)->SetChanged(true);
        }
    }
    void RemoveListFromRenderer() 
    {
        iterator p;
        
        for(p = Head(); p; p = p->GetNext() /*NextItem(p) */)
        {
            (*p)->RemoveFromRenderer();
        }
    }
    
    
    void ApplyFunc(ulFuncPtrv function) 
    {
        iterator p;
        
        for(p = Head(); p; p = p->GetNext() /*NextItem(p) */)
        {
            (*p)->function();
        }
    }
    
    void ApplyFunc(ulFuncPtrb function, bool b) 
    {
        iterator p;
        
        for(p = Head(); p;  p = p->GetNext() /*NextItem(p) */)
        {
            (*p)->function(b);
        }
    }
    
    
    // insert at the end of the list
    iterator Insert(_TypePtr data)
    {
        if (data == 0)
            return 0;
        Instance * p = new Instance(0,0,data);
        
        if (p == 0)
            return 0;
        if (m_head)  
        { 
            m_tail->m_next = p;
            p->m_prev = m_tail;
            
            // new tail
            m_tail = p;
            m_tail->m_next = 0;
        } 
        else // no head so insert
        { 
            m_tail = m_head = p; 
            m_head->m_next = 0;
            m_head->m_prev = 0; 
        }
        m_NumNodes++;    
        
        if (m_tail && m_tail->m_next != 0)
            m_tail->m_next = 0;
        
        if (m_head && m_head->m_prev != 0)
            m_head->m_prev = 0; 
        
        return p;
    }
    
        
};



//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////



/*inline Float random0 (void)
{
    return (Float (rand ()) / Float (RAND_MAX)) *2.0f - 1.0f;
} */

#define RELEASE(x) if (x != NULL) {x->Release(); x = NULL;}


#define bcopy(s,d,n)  memcpy(d,s,n)
#define rand0() ((Float)rand() / 32768.0)  // excludes 1
#define rand1() ((Float)rand() / 32767.0)  // includes 1

#define UL_FRAC(x) ((x) - (Float)(int)(x))
#define UL_DOT(a,b) ((a).x*(b).x + (a).y*(b).y + (a).z*(b).z)


#define UL_M2KTS(z) ( 1.9438  * (z) ) /* macro to convert m/s to kts    */
#define UL_KTS2M(z) ( (z) / 1.7821782 ) /* macro to convert kts to m/s  */
#define UL_M2FT(z) ( 3.28 * (z) ) /* macro to convert meters to feet    */
#define UL_FT2M(z) ( (z) / 3.28 ) /* macro to convert feet to meters    */
#define UL_NM2FT(z) ( (z) * 6075.0 ) /* macro to convert nautical miles to feet    */
#define UL_NM2M(z) ( (z) * 1852.0 )  /* macro to convert nautical miles to meters  */
#define UL_M2NM(z) ( (z) / 1852.0 )  /* macro to convert meters to nautical miles  */



#define arcsec_lon_to_meters(x)  ((Float)(x) * 21.94061103)
#define arcsec_lat_to_meters(x)  ((Float)(x) * 30.0)
#define lon_to_meters(x)  ((Float)(x) * 78986.19971)
#define lat_to_meters(x)  ((Float)(x) * 108000.0)
#define meters_to_lon(x)  ((Float)(x) / 78986.19971)
#define meters_to_lat(x)  ((Float)(x) / 108000.0)
#define feet_to_meters(x)  ((Float)(x) * 0.3048)
#define meters_to_feet(x)  ((Float)(x) / 0.3048)






#define roundf(x)  truncf((x) + 0.5)




// r = 1/p
#define ulFpInvert(r,p)                                                          \
{                                                                            \
    int _i = 2 * FP_ONE_BITS - *(int *)&(p);                                 \
    r = *(float *)&_i;                                                       \
    r = r * (2.0f - (p) * r);                                                \
}

///////////////////////////////////////////////////////
// Thanks to Vincent Van Eeckhout for this

const float two = 2.0f;

#define FP_INV2(r,p)                     \
{                                        \
    __asm { mov     eax,0x7F000000    }; \
    __asm { sub     eax,dword ptr [p] }; \
    __asm { mov     dword ptr [r],eax }; \
    __asm { fld     dword ptr [p]     }; \
    __asm { fmul    dword ptr [r]     }; \
    __asm { fsubr   [two]             }; \
    __asm { fmul    dword ptr [r]     }; \
    __asm { fstp    dword ptr [r]     }; \
}

///////////////////////////////////////////////////////

#define ulFpExponent(e,p)                                                          \
{                                                                            \
    int _i;                                                                  \
    e = -1.44269504f * (float)0x00800000 * (p);                              \
    _i = (int)e + FP_ONE_BITS;                                                \
    e = *(float *)&_i;                                                       \
}

/*float f;
long l;

  
    inline long ulFpNormToByte(float f)
    {
    f += (1L << (23 - 8));
    l = 0xff & (*(DWORD *)&f);
    }
*/

#define ulFpNormToByte(i,p)                                                 \
{                                                                            \
    float _n = (p) + 1.0f;                                                   \
    i = *(int *)&_n;                                                         \
    if (i >= 0x40000000)     i = 0xFF;                                       \
    else if (i <= FP_ONE_BITS) i = 0;                                          \
    else i = ((i) >> 15) & 0xFF;                                             \
}


/*
inline DWORD FP_NORM_TO_BYTE2(float p)                                                 
{                                                                            
float fpTmp = p + 1.0f;                                                      
return ((*(unsigned *)&fpTmp) >> 15) & 0xFF;  
}

  
    inline DWORD FP_NORM_TO_BYTE3(float p)     
    {
    float ftmp = p + 12582912.0f;                                                      
    return ((*(DWORD *)&ftmp) & 0xFF);
    }
*/







__forceinline void ulFloatToInt(int *int_pointer, float f) 
{
    __asm  fld  f
    __asm  mov  edx,int_pointer
    __asm  FRNDINT
    __asm  fistp dword ptr [edx];
    
}



typedef enum PlaneRelationship
{
    OFF_PLANE  ,
        ON_PLANE ,
        ON_POLYGON,           
} PlaneRelationship;


//////////////////////////////////////////////////////////////////////
// These are defined in each of the class's header files:

//inline ostream &operator<<(ostream &os, const Vec3 &v)  {return v.print(os);}
//inline ostream &operator<<(ostream &os, const Mat3 &M)  {return M.print(os);}
//inline ostream &operator<<(ostream &os, const MatR &X)  {return X.print(os);}
//inline ostream &operator<<(ostream &os, const Quat &q)  {return q.print(os);}
//inline ostream &operator<<(ostream &os, const MatQ &T)  {return T.print(os);}

//////////////////////////////////////////////////////////////////////
// combined operators

#include "..\CommonSrc\Utility\ulMatrixVec.h"



//////////////////////////////////////////////////////////////////////
// Graphics file stuff:

// ### Graphics file routines moved to nvImageLib library
//  What was ulGraphicsFile.h is now NVI_ImageLib.h


///////////////////////////////////////////////////////////
//  class ulOrientation

#include "..\CommonSrc\Utility\ulOrientation.h"


///////////////////////////////////////////////////////////

void ulComputeYDDerivative(double *Y, int len, double *YD);
void ulTriDiagonal(double *D, int len);
int ulComputeYDDerivativeIrregular(double *X, double *Y, double *YD, int len);
int ulTriDiagonalIrregular(double *A, double *B, double *C, double *D, int len);


          

#endif  // UL_H