C:/ScoutCGC/ScoutCGLib.h

説明を見る。

/*-------------------------------------------------------------*//*-------------------------------------------------------------*/







//---------------------依存するライブラリ----------------------//
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <cmath>
#include <vector>
#include <typeinfo>

/*-------------------------------------------------------------*
                        libpng-PNG関係のライブラリ
                        http://www.libpng.org/pub/png/libpng.html

                        zlib-PNGが使う圧縮ライブラリ
                        http://www.zlib.net/
 *-------------------------------------------------------------*/
#include "lib/PNG_LIB/png.h"
#pragma comment( lib, "../lib/PNG_LIB/libpng.lib" )

#include "lib/PNG_LIB/zlib.h"
#pragma comment( lib, "../lib/PNG_LIB/zdll.lib" )

/*-------------------------------------------------------------*
                        IJG-JPEGLIB-JPEG関係のライブラリ
                        http://www.ijg.org/ 
 *-------------------------------------------------------------*/
#include "lib/JPEG_LIB/jpeglib.h"
#pragma comment( lib, "../lib/JPEG_LIB/jpeg.lib" )


#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>
#pragma comment( lib, "opengl32.lib" )
#pragma comment( lib, "glu32.lib" )
#pragma comment( lib, "glut32.lib" )



//---------------------------本体----------------------------//

namespace SCGL
{
/*-------------------------------------------------------------/

                        3DCG用お役立ち構造体
                        CGでよく使うデータ構造を定義
                                                                                   \author Scout
                                                                                   \date   2006-06-15
/--------------------------------------------------------------*/

#ifndef __SCGL_FUNC__
#define __SCGL_FUNC__
/*-------------------------------------------------------------*//*-------------------------------------------------------------*/

extern const double ToRadian(const double &degree);
extern const double ToDegree(const double &radian);


#endif //__SCGL_FUNC__



#ifndef __3DSTRUCTS__
#define __3DSTRUCTS__

/*-------------------------------------------------------------*//*-------------------------------------------------------------*/

class VECTOR3
{
public:
        union
        {
                struct{double x;double y;double z;};
                double v[3];                                            
        };

        VECTOR3();
        VECTOR3(const VECTOR3& vec);
        VECTOR3(const double &vx,
                    const double &vy,
                        const double &vz);

        void init();

        virtual ~VECTOR3();

        const double norm() const;

        const bool unit();

        const VECTOR3 operator+(const VECTOR3 &a) const;
        const VECTOR3 operator-(const VECTOR3 &a) const;

        const VECTOR3 operator*(const double &a) const;
        const VECTOR3 operator/(const double &a) const;

        
        VECTOR3& operator+=(const VECTOR3 &a);
        VECTOR3& operator-=(const VECTOR3 &a);


        VECTOR3& operator+=(const double &a);
        VECTOR3& operator-=(const double &a);

        VECTOR3& operator*=(const double &a);
        VECTOR3& operator/=(const double &a);

        const double  operator&(const VECTOR3 &a) const;

        const VECTOR3 operator*(const VECTOR3 &a) const;
        VECTOR3& operator*=(const VECTOR3 &a);

        bool operator==(const VECTOR3 &a) const;

        const VECTOR3 operator-() const;

};

union MATRIX44
{
        struct
        {
                double        _11, _12, _13, _14;
                double        _21, _22, _23, _24;
                double        _31, _32, _33, _34;
                double        _41, _42, _43, _44;
        };
        double m[4][4];
};

class Color
{
public:
        union
        {
                struct 
                {
                        BYTE Red;
                        BYTE Green;
                        BYTE Blue;
                        BYTE Alpha;
                };
                BYTE Colors[4];
        };

        Color():Red(0),Green(0),Blue(0),Alpha(255){}
        virtual ~Color(){}
};

class RGBA
{
public:
        union
        {
                struct 
                {
                        float Red;
                        float Green;
                        float Blue;
                        float Alpha;
                };
                float  Colors[4];
        };

        RGBA():Red(0.0),Green(0.0),Blue(0.0),Alpha(0.0){}
        virtual ~RGBA(){}
};

struct MATERIAL_COLOR{
        RGBA Ambient;
    RGBA Diffuse;
    RGBA Specular;
};

union TEXTURE_COORDINATE
{
        struct{ double u,v; };
        double val[2];
        TEXTURE_COORDINATE():u(0.0),v(0.0){}
};

struct VERTEX
{
        VECTOR3 Position;       
        VECTOR3 Normal;         
        TEXTURE_COORDINATE Texture_Coordinate;
        Color              VertexColor; 
        MATERIAL_COLOR Material;
        std::vector<unsigned int> JointPlane;
};

class TRIANGLE
{
public:
        union{
                struct{unsigned int Vec1,Vec2,Vec3;};
                unsigned int Vec[3];
        };

        VECTOR3 Normal;
        Color              PlaneColor;
        MATERIAL_COLOR Material;
        VECTOR3 GravPoint;
        double  S;
        TRIANGLE() :Vec1(0),Vec2(0),Vec3(0),S(0.0){}
        virtual ~TRIANGLE(){}
};


#endif  //__3DSTRUCTS_H__






#ifndef __CARRAY_H__
#define __CARRAY_H__

#define INIT_ARRAY_SIZE 32      //初期配列サイズ
#define ID unsigned int         //IDの型
#define FAIL -1                         //エラーコード

/*-------------------------------------------------------------*//*-------------------------------------------------------------*/
template <typename Type>
class CArray  
{
public:
        CArray()
        {
                m_DataList = new Type[INIT_ARRAY_SIZE];
                m_Used = 0;
                m_Free = INIT_ARRAY_SIZE;
                m_Locked = false;
        }

        virtual ~CArray(){delete[] m_DataList;}

        CArray<Type>& operator =(CArray<Type>& sorce)
        {
                clear();
                for(ID id=0;id<sorce.size();id++)push(sorce[id]);

                return *this;
        }


        const ID size() const {return m_Used;}


        const ID push(const Type& Data) 
        {
                if(m_Locked)return FAIL;

                if(m_Free == 1)
                        if(!ExpandArray((m_Used+m_Free)*2))
                                return FAIL;

                m_DataList[m_Used] = (Type)Data;
                m_Free--;m_Used++;

                return m_Used-1;
        }
        

        const ID push(Type* Data,int size)
        {
                if(m_Locked)return FAIL;

                if(m_Free < size)
                {
                        while(m_Free < size)
                        {
                                if(!ExpandArray((m_Used+m_Free)*2))
                                        return FAIL;
                        }
                }

                for(int t=0;t<size;t++)
                        m_DataList[m_Used+t] = Data[t];

                m_Free-=size;m_Used+=size;

                return m_Used-1-size;
        }



        Type& pop()     
        {
                if(m_Locked)return m_DataList[m_Used-1];
                if(m_Used == 0)return (*(Type*)NULL);

                m_Free++;m_Used--;
                return m_DataList[m_Used];
        }

        void clear()
        {       
                if(m_Locked)return;

                delete[] m_DataList;
                m_DataList = new Type[INIT_ARRAY_SIZE];
                m_Used = 0;
                m_Free = INIT_ARRAY_SIZE;
        }
        
        void lock()     
        {
                m_Locked = true;

                Type *pNewDataList = new Type[m_Used];
                for(int t=0;t<m_Used;t++)
                        pNewDataList[t] = m_DataList[t];

                delete[] m_DataList;

                m_DataList = pNewDataList;
                m_Free = 0;
        }

        void unlock(){m_Locked=false;}

        template <class T>
        Type& operator[](const T& val) const
        {
                ID id = static_cast<ID>(val);
                return m_DataList[id];
        }


        const Type* GetFirstAdder() const {return m_DataList;}

private:
        bool ExpandArray(const ID &size)        
        {
                if(m_Used + m_Free > size)return false;

                Type *pNewDataList = new Type[size];
                if(pNewDataList == NULL)return false;

                for(int t=0;t<m_Used;t++)
                        pNewDataList[t] = m_DataList[t];

                delete[] m_DataList;

                m_DataList = pNewDataList;
                m_Free = size-m_Used;

                return true;
        }

        Type* m_DataList;               
        ID m_Used;                              
        ID m_Free;                              

        bool m_Locked;                  
};

//定数を破棄
#undef INIT_ARRAY_SIZE
#undef ID
#undef FAIL

#endif // __CARRAY_H__

#ifndef __CNDARRAY_H__
#define __CNDARRAY_H__

template <class Type>
class CNDArray
{
        public:
        CNDArray()
        {
                m_Data=NULL;
                m_CurrentOffset=0;
                m_RefCount=0;
                m_DataSize=0;
        }

        virtual ~CNDArray(){delete[] m_Data;}

        void SetDim(unsigned int Dim,...)
        {
                delete[] m_Data;
                m_Offset.clear();
                m_Size.clear();

                
                va_list SizeList;
                va_start(SizeList,Dim);
                
                for(int d=0;d<Dim;d++)
                        m_Size.push_back(va_arg(SizeList,unsigned int));
                
                va_end(SizeList);

                unsigned int TotalSize=1;
                m_Offset.resize(Dim);

                for(d=Dim-1;d>=0;d--)
                {
                        m_Offset[d] = TotalSize;
                        TotalSize *= m_Size[d];
                }
                
                m_Data = new Type[TotalSize];
                if(m_Data == NULL)
                {
                        printf("Fail:allocates memory.(size:%dByte)\n",sizeof(Type)*TotalSize);
                        exit(-1);
                }

                m_RefCount=0;
                m_DataSize=TotalSize;
        }

        operator Type&()
        {
                Type &ret       = m_Data[m_CurrentOffset];
                m_CurrentOffset = 0;
                m_RefCount      = 0;
                return ret;
        }

        operator Type*()
        {
                Type* ret       = &m_Data[m_CurrentOffset];
                m_CurrentOffset = 0;
                m_RefCount      = 0;
                return ret;
        }


        template <class ArgType>
        CNDArray<Type>& operator[](const ArgType index)
        {
                unsigned int ID = static_cast<unsigned int>(index);

                m_CurrentOffset+=m_Offset[m_RefCount]*ID;
                m_RefCount++;

                if(m_RefCount > m_Offset.size() || m_CurrentOffset > m_DataSize)
                {
                        m_CurrentOffset = 0;
                        m_RefCount      = 0;
                        return *((CNDArray<Type>*)NULL);
                }
                else
                        return *this;
        }

        Type& operator=(const Type &val)
        {
                Type &ret   = m_Data[m_CurrentOffset];
                ret = val;

                m_CurrentOffset=0;
                m_RefCount=0;

                return ret;
        }

        unsigned int GetSize(const unsigned int Dim)
        {
                if(Dim >= m_Size.size())
                        return 0;
                else
                        return m_Size[Dim];
        }

        void InitData(const Type &InitVal)
        {
                for(int id=0;id<m_DataSize;id++)
                        m_Data[id]=InitVal;
        }
private:
        std::vector<unsigned int> m_Offset;
        std::vector<unsigned int> m_Size;

        Type *m_Data;
        unsigned int m_CurrentOffset;
        unsigned int m_RefCount;
        unsigned int m_DataSize;
};


#endif //__CNDARRAY_H__



#ifndef __QUATERNION_H__
#define __QUATERNION_H__

/*-------------------------------------------------------------*//*-------------------------------------------------------------*/

class CQuaternion
{
public:
        double w,x,y,z;


        CQuaternion();


        CQuaternion(double val);


        CQuaternion(double qw,double qx,double qy,double qz);


        CQuaternion(double ww,const VECTOR3 &vec);


        CQuaternion(VECTOR3 dir, VECTOR3 up);

        virtual ~CQuaternion();

        void init();


        void SetRotate(const VECTOR3 &axis,const double &theta);


        CQuaternion& operator=(const CQuaternion &q );


        const CQuaternion operator -() const;


        CQuaternion& operator+=(const CQuaternion &q);



        CQuaternion& operator+=(const double &val );
        


        CQuaternion& operator-=(const CQuaternion &q);



        CQuaternion& operator-=(const double &val );



        CQuaternion& operator*=(const CQuaternion &q);



        CQuaternion& operator*=(const double &val);



        const CQuaternion operator*(const CQuaternion &q) const ;



        CQuaternion& operator /=(const CQuaternion &q);


        CQuaternion &operator /=(const double &val);


        const CQuaternion  operator / (const CQuaternion &q) const ;


        const CQuaternion  operator / (const double &val) const ;


        const double norm() const;


        const double norm2() const;



        const CQuaternion conjugate() const;


        const CQuaternion inv() const;



        const CQuaternion unit() const;



        double operator&(CQuaternion &q);



        VECTOR3 Rotate(const VECTOR3 &vec) const;

        const VECTOR3 operator*(const VECTOR3 &vec) const;

        void Rotate(VECTOR3 v1, VECTOR3 v2);

        CQuaternion Rotate(VECTOR3 v1,VECTOR3 v2,VECTOR3 axis);
        

        MATRIX44 GetMatrix();

        bool operator ==( const CQuaternion &q ) const;
        bool operator !=( const CQuaternion &q ) const;
        bool operator <=( const CQuaternion &q ) const;
        bool operator > ( const CQuaternion &q ) const;
        bool operator >=( const CQuaternion &q ) const;
        bool operator < ( const CQuaternion &q ) const;

};

#endif //__QUATERNION_H__



/*これからつくる

00644 
00645 
00646 
00655 template < class T1, class T2 >
00656 const quaternion< double > interpolate( const quaternion< T1 > &q1, const quaternion< T2 > &q2, double t )
00657 {
00658     typedef quaternion< double > quaternion_type;
00659 
00660     quaternion_type Q1( q1.unit( ) );
00661     quaternion_type Q2( q2.unit( ) );
00662 
00663     double dot = Q1.inner( Q2 );
00664 
00665     if( std::abs( dot ) < 1.0e-6 )
00666     {
00667         return( Q1 );
00668     }
00669     else if( dot < 0.0 )
00670     {
00671         double theta = std::acos( dot );
00672 
00673         // 球面線形補間を行う
00674         return( quaternion_type( Q1 * std::sin( theta * ( 1.0 - t ) ) - Q2 * std::sin( theta * t ) ).unit( ) );
00675     }
00676     else
00677     {
00678         double theta = std::acos( dot );
00679 
00680         // 球面線形補間を行う
00681         return( quaternion_type( Q1 * std::sin( theta * ( 1.0 - t ) ) + Q2 * std::sin( theta * t ) ).unit( ) );
00682     }
00683 }
00684 
00685 

00709 
00710 // 
00711 // 
00712 //
00713 //
00714 
00715 
00743 template < class T >
00744 const quaternion< T > track_ball( const vector2< T > &p1, const vector2< T > &p2, const vector3< T > &axisX, const vector3< T > axisY, const vector3< T > axisZ, const typename vector3< T >::value_type &trackball_size )
00745 {
00746     typedef typename quaternion< T >::value_type value_type;
00747 
00748     if( p1 == p2 )
00749     {
00750         return( quaternion< T >( 1, 0, 0, 0 ) );
00751     }
00752 
00753     vector3< T > sp1( p1.x, p1.y, 0 ), sp2( p2.x, p2.y, 0 );
00754     value_type l, _2 = std::sqrt( value_type( 2.0 ) );
00755 
00756     // 点1の座標を仮想トラックボール上に投影
00757     l = p1.length( );
00758     if( l < trackball_size / _2 )
00759     {
00760         sp1.z = - std::sqrt( trackball_size * trackball_size - l * l );
00761     }
00762     else
00763     {
00764         sp1.z = - trackball_size * trackball_size / 2.0 / l;
00765     }
00766 
00767     // 点2の座標を仮想トラックボール上に投影
00768     l = p2.length( );
00769     if( l < trackball_size / _2 )
00770     {
00771         sp2.z = - std::sqrt( trackball_size * trackball_size - l * l );
00772     }
00773     else
00774     {
00775         sp2.z = - trackball_size * trackball_size / 2.0 / l;
00776     }
00777 
00778     //  sp1 = sp1.unit();
00779     //  sp2 = sp2.unit();
00780 
00781     // 右手系と左手系でここの外積の向きを反転させる
00782     //  Vector3<double> axis = (sp2 * sp1).unit();
00783     vector3< T > axis = ( sp1 * sp2 ).unit( );
00784     axis = ( axis.x * axisX + axis.y * axisY + axis.z * axisZ ).unit( );
00785 
00786     l = ( sp2 - sp1 ).length( ) / ( 2 * trackball_size );
00787     //  l = (l < -1.0)? -1.0: l;
00788     l = l > 1 ? 1: l;
00789 
00790     double phi = std::asin( l );
00791     //  fprintf(stdout, "axis(%.1f, %.1f, %.1f)   theta = %.1f\n", axis.x, axis.y, axis.z, phi * 180 / PAI);
00792     //  printf("%.1f\n", phi * 180 / PAI);
00793     return( quaternion< T >( std::cos( phi ), std::sin( phi ) * axis ) );
00794 }
00795 
00822 template < class T >
00823 inline const quaternion< T > track_ball( const vector2< T > &p1, const vector2< T > &p2, const vector3< T > &axisX, const vector3< T > axisY, const vector3< T > axisZ )
00824 {
00825     return( track_ball( p1, p2, axisX, axisY, axisZ, 0.8 ) );
00826 }
00827 
00828 
00844 template < class T >
00845 const quaternion< T > track_ball( const typename vector3< T >::value_type &x1, const typename vector3< T >::value_type &y1, const typename vector3< T >::value_type &x2, const typename vector3< T >::value_type &y2,
00846                                                 const vector3< T > &axisX, const vector3< T > &axisY, const vector3< T > &axisZ, const typename vector3< T >::value_type &trackball_size )
00847 {
00848     return( track_ball( vector2< T >( x1, y1 ), vector2< T >( x2, y2 ), axisX, axisY, axisZ, trackball_size ) );
00849 }
00850 
00851 
00866 template < class T >
00867 const quaternion< T > track_ball( const typename vector3< T >::value_type &x1, const typename vector3< T >::value_type &y1, const typename vector3< T >::value_type &x2,
00868                                             const typename vector3< T >::value_type &y2, const vector3< T > &axisX, const vector3< T > &axisY, const vector3< T > &axisZ )
00869 {
00870     return( track_ball( vector2< T >( x1, y1 ), vector2< T >( x2, y2 ), axisX, axisY, axisZ, 0.8 ) );
00871 }
00872 
00873 
00874 // mist名前空間の終わり
00875 _MIST_END
00876 
00877 #endif // __INCLUDE_MIST_QUATERNION__
00878 

*/


#ifndef __C3DTRNAS_H__
#define __C3DTRNAS_H__

/*-------------------------------------------------------------*//*-------------------------------------------------------------*/
class C3DTrans  
{
public:
        C3DTrans():m_AxisX(1.0,0.0,0.0),
                           m_AxisY(0.0,1.0,0.0),
                           m_AxisZ(0.0,0.0,1.0) {}
        virtual ~C3DTrans(){}
        
        CQuaternion m_Quaternion;
        VECTOR3 m_Trans;                 

        void Init(){m_Quaternion.init();
                            m_Trans.init();}



        void Translate(const VECTOR3 &TransVec)
        {
                m_Trans += m_Quaternion.Rotate(TransVec);
        }


        void Translate(double x,double y,double z)
        {
                m_Trans += m_Quaternion.Rotate(VECTOR3(x,y,z));
        }
        

        void Rotate(const VECTOR3 &Axis,double theta)
        {
                CQuaternion q;
                q.SetRotate(Axis,theta);
                m_Quaternion*=q;
        }


        void RotateX(double theta)
        {
                CQuaternion q;
                q.SetRotate(m_AxisX,theta);
                m_Quaternion*=q;
        }


        void RotateY(double theta)
        {
                CQuaternion q;
                q.SetRotate(m_AxisY,theta);
                m_Quaternion*=q;
        }


        void RotateZ(double theta)
        {
                CQuaternion q;
                q.SetRotate(m_AxisZ,theta);
                m_Quaternion*=q;
        }


        const VECTOR3 TransVec(const VECTOR3 &vec) const 
        {
                return m_Quaternion.Rotate(vec) + m_Trans;
        }
        
        void PushState()
        {
                m_QuatStack.push_back(m_Quaternion);
                m_TransStack.push_back(m_Trans);
        }

        void PopState()
        {
                if(m_QuatStack.size()>0)
                {
                        m_Quaternion = m_QuatStack[m_QuatStack.size()-1];
                        m_QuatStack.pop_back();
                        m_Trans = m_TransStack[m_TransStack.size()-1];
                        m_TransStack.pop_back();
                }
        }
        
        void TransByOGL()
        {
                glTranslated(m_Trans.x,m_Trans.y,m_Trans.z);
                const double angle = ToDegree(acos(m_Quaternion.w)); 

                if(angle != 0)
                {
                        VECTOR3 RotVec(m_Quaternion.x,m_Quaternion.y,m_Quaternion.z);
                        RotVec.unit();
                        glRotated(angle,RotVec.x,RotVec.y,RotVec.z);
                }
        }
private:
        const VECTOR3 m_AxisX;
        const VECTOR3 m_AxisY;
        const VECTOR3 m_AxisZ;

        std::vector<CQuaternion> m_QuatStack;
        std::vector<VECTOR3>     m_TransStack;
};

#endif //__C3DTRNAS_H__


#ifndef __CTEXTURE_H__
#define __CTEXTURE_H__

struct RGBA_BYTE
{
        BYTE Blue;
        BYTE Green;
        BYTE Red;
        BYTE Alpha;
};

struct TextureData
{
        RGBA_BYTE *pColor;
        int Width;
        int Height;
};

/*-------------------------------------------------------------*//*-------------------------------------------------------------*/
class CTexture  
{
public:
        CTexture();
        virtual ~CTexture();

        void Init();



        bool LoadTexture(char* pFileName);

        bool LoadPngFile(FILE *fp);
        bool LoadJpegFile(FILE *fp);


        void LoadTexture(TextureData Tex);


        TextureData GetTextureData() const;


        void BindTextureOGL();


private:
        static void PNGReader(png_structp png_ptr,png_bytep data,png_size_t length);

        int m_TextureNumber;
        bool bIsBinded;
        
        TextureData m_Texture_Data;
};


#endif // __CTEXTURE_H__




#ifndef __3DONJECT_H__
#define __3DONJECT_H__

/*-------------------------------------------------------------*//*-------------------------------------------------------------*/

typedef unsigned int ID_VERTEX;
typedef unsigned int ID_TRIANGLE;

typedef std::vector<unsigned int> ID_LIST_VERTEX;
typedef std::vector<unsigned int> ID_LIST_TRIANGLE;

class CBasic3DObject
{
public:
        CBasic3DObject();
        virtual ~CBasic3DObject();

        virtual void Init();
        

        virtual const ID_TRIANGLE  AddTriangle(const ID_VERTEX &Vec1,
                                                                                   const ID_VERTEX &Vec2,
                                                                                   const ID_VERTEX &Vec3);      

        virtual const ID_VERTEX  AddVertex(const VERTEX &Vertex);


        virtual const ID_VERTEX  AddVertex(const VECTOR3 &Vector);


        virtual const ID_VERTEX  AddVertex(double x,double y,double z);


        virtual const ID_VERTEX  AddVertex();


        virtual const ID_LIST_VERTEX AddVertexList(const std::vector<VERTEX> &VertexList);
        virtual const ID_LIST_VERTEX AddVertexList(const std::vector<VECTOR3> &VectorList);
        virtual const ID_LIST_VERTEX AddVertexList(const std::vector<double> &PointList);
        virtual const ID_LIST_VERTEX AddVertexList(const int Num);



        bool SetTexture(char* pFileName);


        void SetTexture(TextureData Tex);


        TextureData GetTexture() const;

        virtual CBasic3DObject& operator=(const CBasic3DObject &sorce);

        virtual CBasic3DObject& operator*=(const C3DTrans &trans);



        virtual CBasic3DObject& operator+=(CBasic3DObject &sorce);


        VERTEX& Vertex(ID_VERTEX VertexID) const ;


        TRIANGLE& Triangle(ID_TRIANGLE TriangleID) const ;

        const int GetVertexNum() const ;
        const int GetTriangleNum() const ;
        
        void Normalize();

        C3DTrans Position;                                      
        MATERIAL_COLOR          Material;               

        CTexture                        m_Texture;              
protected:
        CArray<VERTEX>          m_Vertex;               
        CArray<TRIANGLE>        m_Triangle;             
};


class C3DObject : public CBasic3DObject
{
public:
        C3DObject();
        virtual ~C3DObject();
        virtual void Init();

        virtual const ID_VERTEX AddVertex(const VERTEX &Vertex);
        virtual const ID_VERTEX AddVertex(const VECTOR3 &Vector)                {return CBasic3DObject::AddVertex(Vector);}
        virtual const ID_VERTEX AddVertex(double x,double y,double z)   {return CBasic3DObject::AddVertex(x,y,z);}
        virtual const ID_VERTEX AddVertex()                                                             {return CBasic3DObject::AddVertex();}

        virtual void Draw() = 0;
        
        void BeginVertexCache();
        void EndVertexCache();

        void  TransVC(const C3DTrans &Trans);

        const ID_LIST_VERTEX CopyVC();
        const ID_LIST_VERTEX CopyWithTransVC(const C3DTrans &Trans);




        const ID_LIST_VERTEX MakeCircle(double Radius,          
                                                                        const int VertexNum,
                                                                        VECTOR3 &Normal = VECTOR3(0.0,0.0,1.0),
                                                                        VECTOR3 &Center = VECTOR3());
        const ID_LIST_TRIANGLE MakeWall(const ID_LIST_VERTEX &VertexList1,
                                                                        const ID_LIST_VERTEX &VertexList2,
                                                                        const bool IsLoop = false);//頂点リストをループ状に繋げるかどうか

        const ID_LIST_VERTEX MakeWallFromVC(const ID_LIST_VERTEX &VertexList,
                                                                                const bool IsLoop = false);

        void MakeWallByVC(const C3DTrans &Trans,
                                          const bool IsLoop = false);


        void MakeSolidRotation(const ID_LIST_VERTEX &VertexList,
                                                   int Div,
                                                   const bool IsLoop = false,
                                                   const VECTOR3 &BasePos = VECTOR3(0.0,0.0,0.0),
                                                   const double Theta = 360.0,
                                                   const VECTOR3 &Axis = VECTOR3(0.0,1.0,0.0));

        void MakeSolidRotationVC(const int Div,
                                                         const bool IsLoop = false,
                                                         const VECTOR3 &BasePos = VECTOR3(0.0,0.0,0.0),
                                                         const double Theta = 360.0,
                                                         const VECTOR3 &Axis = VECTOR3(0.0,1.0,0.0));



        virtual const ID_VERTEX  FindVertex(const VECTOR3 &Vector) const ;


        virtual const ID_VERTEX  FineVertex(double x,double y,double z) const;




        void SetSphere(int detail=2);


        bool LoadOBJFile(char* FileName);
        
protected:

        std::vector<ID_VERTEX> m_VertexCache; 
        bool    VertexIsCached; 


        void C3DObject::subdivide(ID_VERTEX V1_ID, ID_VERTEX V2_ID, ID_VERTEX V3_ID,int depth);
};


#endif // __3DONJECT_H__

#ifndef __CGLOBJECT_H__
#define __CGLOBJECT_H__


// glext.h からの VBO Extension の定義
#define GL_ARRAY_BUFFER_ARB                     0x8892
#define GL_ELEMENT_ARRAY_BUFFER_ARB     0x8893
#define GL_STATIC_DRAW_ARB      0x88E4
#define GL_DYNAMIC_DRAW_ARB 0x88E8
typedef void (APIENTRY * PFNGLBINDBUFFERARBPROC)    (GLenum target, GLuint buffer);
typedef void (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
typedef void (APIENTRY * PFNGLGENBUFFERSARBPROC)    (GLsizei n, GLuint *buffers);
typedef void (APIENTRY * PFNGLBUFFERDATAARBPROC)    (GLenum target, int size, const GLvoid *data, GLenum usage);

enum GLObjectOptions{   GLOps_Normal            =       1,              
                                                GLOps_Texture           =       2,              
                                                GLOps_ObjectMaterial=   4,              
                                                GLOps_VertexMaterial=   8,              
                                                GLOps_PlaneMaterial     =       16,             
                                                GLOps_VertexColor       =       32,             
                                                GLOps_PlaneColor        =       64,             
                                                GLOps_ALPHA                     =       128,    
                                                GLOps_VBO                       =       256};   


#define IfEnable(flag) if(m_DrawOption&(flag))


/*-------------------------------------------------------------*//*-------------------------------------------------------------*/

class CGLObject :public C3DObject  
{
public:
        CGLObject();
        virtual ~CGLObject();

        void Draw();
        

        const unsigned int  AddTriangle(const unsigned int &Vec1,
                                                                        const unsigned int &Vec2,
                                                                        const unsigned int &Vec3);
        init();

        void SetDrawOption(GLObjectOptions OptionFlag);
        void Lock();
        void Unlock();

private:

        void CreateVBO();
        void InitVBO();
        void DrawVBO();

        bool IsExtensionSupported( char* szTargetExtension );
        
        unsigned int m_VBO_VERTEX;      
        unsigned int m_VBO_NORMAL;      
        unsigned int m_VBO_TEXCODE; 
        unsigned int m_VBO_COLOR;       
        unsigned int m_IBO_ID;  
        
        CArray<float> m_VertexList;     
        CArray<float> m_NormalList;     
        CArray<float> m_TexCodeList;    
        CArray<BYTE>  m_ColorList;      
        CArray<unsigned int> m_IndexList;       

        
        void DrawStandard();

        GLObjectOptions m_DrawOption;
        bool IsStatic;                  
};

#endif // __CGLOBJECT_H__









#ifndef __CGLUTVIEW_H__
#define __CGLUTVIEW_H__

struct MouseState
{
        int state;
        int button;
        int option;
        int x;
        int y;
};

struct KeyState
{
        unsigned char key;
        int SpKey;
        int x;
        int y;
};

struct GLCameraState
{
        double Aspect;
        double NearPlane;
        double FarPlane;
        double ViewAngle;
};


/*-------------------------------------------------------------*//*-------------------------------------------------------------*/
template<class Type>
class CGLUTView  
{
public:
        CGLUTView(){m_pDoc =NULL;}
        virtual ~CGLUTView(){}
        
        //仮想関数・各種コールバックを受け取る関数を空宣言
        virtual void OnDraw(){glutSwapBuffers();}               
        virtual void OnMouseMove(MouseState mouse){}    
        virtual void OnMouseEvent(MouseState mouse){}   
        virtual void OnKeyEvent(KeyState State){}               
        virtual void OnTimer(int ID){}                                  
        virtual void OnMenu (unsigned int ID){}                 
        virtual void OnReshape(int width, int height){} 

        void SetDocument(Type *pDoc){m_pDoc = pDoc;}
protected:
        Type *m_pDoc;   
};

#endif // __CGLUTVIEW_H__






#ifndef __GLUTMASTER_H__
#define __GLUTMASTER_H__

struct TimerState
{
        int WindowID;   
        int TimerInt;   
};

/*-------------------------------------------------------------*//*-------------------------------------------------------------*/
template<class Type>
class CGLUTMaster  
{
public:
        CGLUTMaster()
        {
                LPSTR argvt;
                int argc=1;
                argvt=GetCommandLine();

                glutInit(&argc,&argvt);
                glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
        }
        virtual ~CGLUTMaster(){}

        int CreateGLUTWindow(CGLUTView<Type>* pViewClass,char *WindowTitle=NULL,int WindowWidth=200,int WindowHeight=200,int WndPosX=0,int WndPosY=0)
        {
                int WindowID;
                //窓サイズ
                glutInitWindowPosition(WndPosX,WndPosY); 
                glutInitWindowSize(WindowWidth, WindowHeight);
                //glutで窓作成
                if(WindowTitle==NULL)WindowID = glutCreateWindow("GLUT");
                else WindowID = glutCreateWindow(WindowTitle);

                //ViewClassをリストに登録
                m_pViewClassList.resize(WindowID+1,NULL);
                m_pViewClassList[WindowID] = pViewClass;

                pViewClass->SetDocument(&m_Document);
                //各種コールバック関数をGLUTに教える。
                //全てこのクラスが呼ばれる
                glutDisplayFunc(Display);
                glutMouseFunc(Mouse);
                glutMotionFunc(Motion);
                glutReshapeFunc(Reshape);
                glutKeyboardFunc(Keyboard);
                glutSpecialFunc(SpecialKey);

                return WindowID;
        }

        void MainLoop(){glutMainLoop();}

        static void Display()
        {
                //呼び出された窓IDからViewClassを検索
                int Call_ID=glutGetWindow();
                //Viewのメソッドを呼び出し
                m_pViewClassList[Call_ID]->OnDraw();
        }

        static void Reshape(int width, int height)
        {
                int Call_ID=glutGetWindow();
                m_pViewClassList[Call_ID]->OnReshape(width,height);
        }

        static void Keyboard(unsigned char key, int x, int y)
        {
                m_KeyState.key   = key;
                m_KeyState.SpKey = -1;
                m_KeyState.x=x;
                m_KeyState.y=y;

                int Call_ID=glutGetWindow();
                m_pViewClassList[Call_ID]->OnKeyEvent(m_KeyState);
        }

        static void SpecialKey(int key, int x, int y)
        {
                m_KeyState.key   = -1;
                m_KeyState.SpKey = key;
                m_KeyState.x=x;
                m_KeyState.y=y;

                int Call_ID=glutGetWindow();
                m_pViewClassList[Call_ID]->OnKeyEvent(m_KeyState);
        }

        static void Mouse(int button, int state, int x, int y)
        {
                m_Mouse.button  = button;
                m_Mouse.state   = state;
                m_Mouse.x = x;
                m_Mouse.y = y;

                int Call_ID=glutGetWindow();
                m_pViewClassList[Call_ID]->OnMouseEvent(m_Mouse);
        }

        static void Motion(int x, int y)
        {
                m_Mouse.x = x;
                m_Mouse.y = y;

                int Call_ID=glutGetWindow();
                m_pViewClassList[Call_ID]->OnMouseEvent(m_Mouse);
        }

        static void Idle(){/*(´ー｀●)*/}

        static void Timer(int ID)
        {
                glutSetWindow(m_TimerList[ID].WindowID);

                m_pViewClassList[m_TimerList[ID].WindowID]->OnTimer(ID);
                m_TimerList[ID].WindowID = -1;
        }

        static void AutoRepeatTimer(int ID)
        {
                glutSetWindow(m_TimerList[ID].WindowID);
                m_pViewClassList[m_TimerList[ID].WindowID]->OnTimer(ID);
                glutTimerFunc(m_TimerList[ID].TimerInt,AutoRepeatTimer,ID);
        }

        void SetTimer(int TimerInt,int WindowID,bool IsRepeat=false)
        {
                TimerState NewTimer;

                NewTimer.TimerInt = TimerInt;
                NewTimer.WindowID = WindowID;

                int TID;

                for(TID=0;TID<m_TimerList.size();TID++)
                {
                        if(m_TimerList[TID].WindowID==-1)
                        {
                                m_TimerList[TID]=NewTimer;
                                break;
                        }
                }
                if(TID == m_TimerList.size())
                        m_TimerList.push_back(NewTimer);

                if(IsRepeat)
                        glutTimerFunc(NewTimer.TimerInt,AutoRepeatTimer,TID);
                else
                        glutTimerFunc(NewTimer.TimerInt,Timer,TID);
        }
        
        Type* GetDoc(){return &m_Document;}

private:
        static std::vector<CGLUTView<Type>*> m_pViewClassList;  
        static Type m_Document;                                                                 
        static MouseState m_Mouse;                                                              
        static KeyState   m_KeyState;                                                   
        static std::vector<TimerState> m_TimerList;                             
};

//各データの実体を定義
template<class Type>
Type CGLUTMaster<Type>::m_Document;

template<class Type>
MouseState CGLUTMaster<Type>::m_Mouse;

template<class Type>
std::vector<CGLUTView<Type>*> CGLUTMaster<Type>::m_pViewClassList;

template<class Type>
KeyState   CGLUTMaster<Type>::m_KeyState;

template<class Type>
std::vector<TimerState> CGLUTMaster<Type>::m_TimerList;

#endif // __GLUTMASTER_H__












};
/*------------------------------------------------The-End-of-SCGL*/

---