C:/ScoutCGC/ScoutCGLib.cpp

説明を見る。

#include "ScoutCGLib.h"



using namespace SCGL;

/*--------------------------------------------------------------/
|                                                                                                                               |
|                                                                                                                               |
|                                               実体：便利関数                                                  |
|                                                                                                                               |
|                                                                                                                               |
/--------------------------------------------------------------*/

const double SCGL::ToRadian(const double &degree)
{
        return degree * 3.14159265358979323846 / 180.0;
}

const double SCGL::ToDegree(const double &radian)
{
        return radian * 180.0 / 3.14159265358979323846;
}


/*--------------------------------------------------------------/
|                                                                                                                               |
|                                                                                                                               |
|                                               実体：VECTOR3                                                   |
|                                                                                                                               |
|                                                                                                                               |
/--------------------------------------------------------------*/

VECTOR3::VECTOR3():x(0.0),y(0.0),z(0.0){}
VECTOR3::VECTOR3(const VECTOR3& vec):x(vec.x),y(vec.y),z(vec.z){}
VECTOR3::VECTOR3(const double &vx,
                                 const double &vy,
                                 const double &vz ):x(vx),y(vy),z(vz){}

VECTOR3::~VECTOR3(){}

void VECTOR3::init(){x=0.0;y=0.0;z=0.0;}

//長さ・ノルム
const double VECTOR3::norm() const
{
        return sqrt(x*x+y*y+z*z);
}

//正規化
const bool VECTOR3::unit()
{
        const double l = norm();
        if(l>0)
        {       
                x/=l; y/=l; z/=l;
                return true;
        }else return false;
}

//演算の定義
const VECTOR3 VECTOR3::operator+(const VECTOR3 &a) const
{
        return VECTOR3(x + a.x,
                                   y + a.y,
                                   z + a.z);
}

const VECTOR3 VECTOR3::operator-(const VECTOR3 &a) const
{
        return VECTOR3(x - a.x,
                                   y - a.y,
                                   z - a.z);
}

const VECTOR3 VECTOR3::operator*(const double &a) const
{
        return VECTOR3(x*a,y*a,z*a);
}

const VECTOR3 VECTOR3::operator/(const double &a) const
{
        return VECTOR3(x/a,y/a,z/a);
}

VECTOR3& VECTOR3::operator+=(const VECTOR3 &a)
{       
        x+=a.x;
        y+=a.y;
        z+=a.z;                                         
        return *this;
}

VECTOR3& VECTOR3::operator-=(const VECTOR3 &a)
{       
        x-=a.x;
        y-=a.y;
        z-=a.z;                                         
        return *this;
}

VECTOR3& VECTOR3::operator+=(const double &a)
{       
        x+=a;
        y+=a;
        z+=a;                                           
        return *this;
}

VECTOR3& VECTOR3::operator-=(const double &a)
{       
        x-=a;
        y-=a;
        z-=a;                                           
        return *this;
}

VECTOR3& VECTOR3::operator*=(const double &a)
{       
        x*=a;
        y*=a;
        z*=a;                                           
        return *this;
}

VECTOR3& VECTOR3::operator/=(const double &a)
{       
        x/=a;
        y/=a;
        z/=a;                                           
        return *this;
}

//内積
const double  VECTOR3::operator&(const VECTOR3 &a) const
{
        return (x * a.x + y * a.y + z * a.z);
}

//外積
const VECTOR3 VECTOR3::operator*(const VECTOR3 &a) const
{
        return VECTOR3(y * a.z - z * a.y ,
                                   z * a.x - x * a.z ,
                                   x * a.y - y * a.x );
}

VECTOR3& VECTOR3::operator*=(const VECTOR3 &a)
{
        const double tx = y * a.z - z * a.y;
        const double ty = z * a.x - x * a.z;

        z = x * a.y - y * a.x;
        x = tx;
        y = ty;

        return (*this);
}

//比較
bool VECTOR3::operator==(const VECTOR3 &a) const
{
        return (x==a.x && y==a.y && z==a.z);
}

//符号の反転
const VECTOR3 VECTOR3::operator-() const
{
        return VECTOR3(-x,-y,-z);
}


/*--------------------------------------------------------------/
|                                                                                                                               |
|                                                                                                                               |
|                                               実体：CBasic3DObject                                    |
|                                                                                                                               |
|                                                                                                                               |
/--------------------------------------------------------------*/



//初期化
CBasic3DObject::CBasic3DObject(){}
CBasic3DObject::~CBasic3DObject(){}

//初期化
void CBasic3DObject::Init()
{
        m_Vertex.clear();
        m_Triangle.clear();
        m_Texture.Init();
}

//面の追加：頂点番号1,2,3
const ID_TRIANGLE  CBasic3DObject::AddTriangle(const ID_VERTEX &Vec1,
                                                                                           const ID_VERTEX &Vec2,
                                                                                           const ID_VERTEX &Vec3)       
{
        TRIANGLE Triangle;
        Triangle.Vec1 = Vec1;
        Triangle.Vec2 = Vec2;
        Triangle.Vec3 = Vec3;

        if(Vec1>=m_Vertex.size()||Vec2>=m_Vertex.size()||Vec3>=m_Vertex.size())return 0;

        VECTOR3 V12 = m_Vertex[Vec2].Position - m_Vertex[Vec1].Position;
        VECTOR3 V13 = m_Vertex[Vec3].Position - m_Vertex[Vec1].Position;
        Triangle.Normal =  V12*V13;

        if(Triangle.Normal.unit())
        {
                Triangle.GravPoint += m_Vertex[Vec1].Position;
                Triangle.GravPoint += m_Vertex[Vec2].Position;
                Triangle.GravPoint += m_Vertex[Vec3].Position;
                Triangle.GravPoint/=3;

                const double cos_val = (V12&V13)/(V12.norm()*V13.norm());
                const double sin_val = sqrt(1.0-cos_val*cos_val);

                Triangle.S = V12.norm()*V13.norm()*sin_val/2;

                const ID_TRIANGLE ID = m_Triangle.push(Triangle);

                m_Vertex[Vec1].JointPlane.push_back(ID);
                m_Vertex[Vec2].JointPlane.push_back(ID);
                m_Vertex[Vec3].JointPlane.push_back(ID);
                return ID;
        }else return 0;
}

//頂点の追加
const ID_VERTEX CBasic3DObject::AddVertex(const VERTEX &Vertex) 
{       
        return m_Vertex.push(Vertex);
}

//座標データのみを与え頂点追加
const ID_VERTEX  CBasic3DObject::AddVertex(const VECTOR3 &Vector)
{
        VERTEX Vertex;
        Vertex.Position = Vector;

        return AddVertex(Vertex);
}

//座標データのみを与え頂点追加
const ID_VERTEX  CBasic3DObject::AddVertex(double x,double y,double z)
{
        VERTEX Vertex;
        Vertex.Position.x = x;
        Vertex.Position.y = y;
        Vertex.Position.z = z;

        return AddVertex(Vertex);
}

//初期化された頂点を追加
const ID_VERTEX CBasic3DObject::AddVertex()
{
        return AddVertex(VERTEX());
}

const ID_LIST_VERTEX CBasic3DObject::AddVertexList(const std::vector<VERTEX> &VertexList)
{
        ID_LIST_VERTEX ID_List;

        for(int t=0;t<VertexList.size();t++)
                ID_List.push_back(AddVertex(VertexList[t]));

        return ID_List;
}
const ID_LIST_VERTEX CBasic3DObject::AddVertexList(const std::vector<VECTOR3> &VectorList)
{
        ID_LIST_VERTEX ID_List;

        for(int t=0;t<VectorList.size();t++)
                ID_List.push_back(AddVertex(VectorList[t]));

        return ID_List;
}
const ID_LIST_VERTEX CBasic3DObject::AddVertexList(const std::vector<double> &PointList)
{
        ID_LIST_VERTEX ID_List;

        if(PointList.size()%3 == 0)
        {
                for(int t=0;t<PointList.size();t+=3)
                        ID_List.push_back(AddVertex(PointList[t],PointList[t+1],PointList[t+2]));
        }

        return ID_List;
}

const ID_LIST_VERTEX CBasic3DObject::AddVertexList(const int Num)
{
        ID_LIST_VERTEX ID_List;

        for(int t=0;t<Num;t++)
                ID_List.push_back(AddVertex());

        return ID_List;
}

//テクスチャを設定
bool CBasic3DObject::SetTexture(char* pFileName){return m_Texture.LoadTexture(pFileName);}

//テクスチャ読み込み
void CBasic3DObject::SetTexture(TextureData Tex){m_Texture.LoadTexture(Tex);}

// テクスチャデータの詳細を返す
TextureData CBasic3DObject::GetTexture() const {return m_Texture.GetTextureData();}


//コピー
CBasic3DObject& CBasic3DObject::operator=(const CBasic3DObject &sorce)
{
        Init();
        for(int v=0;v<sorce.GetVertexNum();v++)
                m_Vertex.push(sorce.Vertex(v));
        for(int t=0;t<sorce.GetTriangleNum();t++)
                m_Triangle.push(sorce.Triangle(t));
        m_Texture.LoadTexture(sorce.GetTexture());

        return *this;
}

//座標変換 Object×Trans
CBasic3DObject& CBasic3DObject::operator*=(const C3DTrans &trans)
{
        for(int v=0;v<m_Vertex.size();v++)
                m_Vertex[v].Position = trans.TransVec(m_Vertex[v].Position);
        return *this;
}


//オブジェクトの追加
CBasic3DObject& CBasic3DObject::operator+=(CBasic3DObject &sorce)
{
        unsigned int *TransTable;

        TransTable = new unsigned int[sorce.GetVertexNum()];

        for(int v=0;v<sorce.GetVertexNum();v++)
                TransTable[v] = m_Vertex.push(sorce.Vertex(v));
        
        for(int t=0;t<sorce.GetTriangleNum();t++)
        {
                TRIANGLE &tri = sorce.Triangle(t);
                AddTriangle(TransTable[tri.Vec1],
                                        TransTable[tri.Vec2],
                                        TransTable[tri.Vec3]);
        }

        delete[] TransTable;
        return *this;
}


//頂点番号から頂点を取得
VERTEX& CBasic3DObject::Vertex(unsigned int VertexID) const 
{
        if(VertexID < m_Vertex.size())return m_Vertex[VertexID];
        else return (*((VERTEX*)NULL));
}


//頂点番号から頂点を取得
TRIANGLE& CBasic3DObject::Triangle(unsigned int TriangleID) const 
{
        if(TriangleID < m_Triangle.size())return m_Triangle[TriangleID];
        else return (*((TRIANGLE*)NULL));
}

//頂点数
const int CBasic3DObject::GetVertexNum() const  {return m_Vertex.size();}
//面の数
const int CBasic3DObject::GetTriangleNum() const {return m_Triangle.size();}

//頂点の法線ベクトルを求める
void CBasic3DObject::Normalize() 
{
        for(int v=0;v<m_Vertex.size();v++)
        {
                m_Vertex[v].Normal.init();

                for(int p=0;p<m_Vertex[v].JointPlane.size();p++)
                        m_Vertex[v].Normal+=m_Triangle[m_Vertex[v].JointPlane[p]].Normal;

                m_Vertex[v].Normal.unit();
        }
}



/*--------------------------------------------------------------/
|                                                                                                                               |
|                                                                                                                               |
|                                               実体：C3DObject                                                 |
|                                                                                                                               |
|                                                                                                                               |
/--------------------------------------------------------------*/



//初期化
C3DObject::C3DObject():VertexIsCached(false){}
C3DObject::~C3DObject(){}

//初期化
void C3DObject::Init()
{
        CBasic3DObject::Init();
        VertexIsCached = false;
}

//面の追加：頂点番号1,2,3
const ID_TRIANGLE  C3DObject::AddVertex(const VERTEX &Vertex)
{
        const ID = CBasic3DObject::AddVertex(Vertex);

        if(VertexIsCached)
                m_VertexCache.push_back(ID);

        return ID;
}

void C3DObject::BeginVertexCache()
{
        m_VertexCache.clear();
        VertexIsCached = true;
}

void C3DObject::EndVertexCache()
{
        VertexIsCached = false;
}

void C3DObject::TransVC(const C3DTrans &Trans)
{
        for(int t=0;t<m_VertexCache.size();t++)
        {
                VECTOR3 &vec = m_Vertex[m_VertexCache[t]].Position;
                vec = Trans.TransVec(vec);
        }
}

const ID_LIST_VERTEX C3DObject::CopyVC()
{
        ID_LIST_VERTEX ID_List;

        for(int t=0;t<m_VertexCache.size();t++)
                ID_List.push_back(AddVertex(m_Vertex[m_VertexCache[t]]));

        return ID_List;
}

const ID_LIST_VERTEX C3DObject::CopyWithTransVC(const C3DTrans &Trans)
{
        ID_LIST_VERTEX ID_List;

        for(int t=0;t<m_VertexCache.size();t++)
        {
                VERTEX NewVec(m_Vertex[m_VertexCache[t]]);

                VECTOR3 &vec = NewVec.Position;
                vec = Trans.TransVec(vec);

                ID_List.push_back(AddVertex(NewVec));
        }

        return ID_List;
}

const ID_LIST_VERTEX C3DObject::MakeWall(const ID_LIST_VERTEX &VertexList1,
                                                                                 const ID_LIST_VERTEX &VertexList2,
                                                                                 const bool IsLoop)
{
        ID_LIST_VERTEX ID_List;

        if(VertexList1.size() == VertexList2.size())
        {
                for(int t=0;t<VertexList1.size()-1;t++)
                {
                        ID_List.push_back(AddTriangle(VertexList1[t+1],
                                                                                  VertexList1[t],
                                                                                  VertexList2[t]));

                        ID_List.push_back(AddTriangle(VertexList1[t+1],
                                                                                  VertexList2[t],
                                                                                  VertexList2[t+1]));
                }
                if(IsLoop)
                {
                        ID_List.push_back(AddTriangle(VertexList1[0],
                                                                                  VertexList1[t],
                                                                                  VertexList2[t]));

                        ID_List.push_back(AddTriangle(VertexList1[0],
                                                                                  VertexList2[t],
                                                                                  VertexList2[0]));
                }
        }

        return ID_List;
}

const ID_LIST_VERTEX C3DObject::MakeWallFromVC(const ID_LIST_VERTEX &VertexList,
                                                                                           const bool IsLoop)
{
        ID_LIST_VERTEX ID_List;

        if(VertexList.size() == m_VertexCache.size())
        {
                for(int t=0;t<VertexList.size()-1;t++)
                {
                        ID_List.push_back(AddTriangle(m_VertexCache[t+1],
                                                                                  m_VertexCache[t],
                                                                                  VertexList[t]));

                        ID_List.push_back(AddTriangle(m_VertexCache[t+1],
                                                                                  VertexList[t],
                                                                                  VertexList[t+1]));
                }
                if(IsLoop)
                {
                        ID_List.push_back(AddTriangle(m_VertexCache[0],
                                                                                  m_VertexCache[t],
                                                                                  VertexList[t]));

                        ID_List.push_back(AddTriangle(m_VertexCache[0],
                                                                                  VertexList[t],
                                                                                  VertexList[0]));
                }
        }

        return ID_List;
}

void C3DObject::MakeWallByVC(const C3DTrans &Trans,const bool IsLoop)
{

        const ID_LIST_VERTEX OldVC = m_VertexCache;

        for(int t=0;t<OldVC.size();t++)
        {
                VERTEX NewVec(m_Vertex[OldVC[t]]);

                VECTOR3 &vec = NewVec.Position;
                vec = Trans.TransVec(vec);

                m_VertexCache[t] = AddVertex(NewVec);
        }


        for(t=0;t<OldVC.size()-1;t++)
        {
                AddTriangle(OldVC[t+1],OldVC[t],m_VertexCache[t]);
                AddTriangle(OldVC[t+1],m_VertexCache[t],m_VertexCache[t+1]);
        }
        if(IsLoop)
        {
                AddTriangle(OldVC[0],OldVC[t],m_VertexCache[t]);
                AddTriangle(OldVC[0],m_VertexCache[t],m_VertexCache[0]);
        }
}


const ID_LIST_VERTEX C3DObject::MakeCircle(double Radius,
                                                                                   const int VertexNum,
                                                                                   VECTOR3 &Normal,
                                                                                   VECTOR3 &Center)
{
        ID_LIST_VERTEX ID_List;
        VECTOR3 ZVec(0.0,0.0,1.0);
        VECTOR3 Vec(Radius,0.0,0.0);
        
        CQuaternion Axis;

        Axis.Rotate(-Normal,ZVec);

        CQuaternion Rot;

        if(VertexNum%2 == 0)
        {
                Rot.SetRotate(ZVec,-180.0/VertexNum);
                Axis*=Rot;
        }

        Rot.SetRotate(ZVec,360.0/VertexNum);

        for(int t=0;t<VertexNum;t++)
        {
                ID_List.push_back(AddVertex(Axis*Vec+Center));
                Axis*=Rot;
        }

        return ID_List;
}

void C3DObject::MakeSolidRotation(const ID_LIST_VERTEX &VertexList,
                                                                  int Div,
                                                                  const bool IsLoop,
                                                                  const VECTOR3 &BasePos,
                                                                  const double Theta,
                                                                  const VECTOR3 &Axis)
{
        const ID_LIST_VERTEX BK_Cache = m_VertexCache;

        m_VertexCache = VertexList;

        
        C3DTrans Trans;

        Trans.Translate(BasePos);
        Trans.Rotate(Axis,Theta/Div);
        Trans.Translate(-BasePos);
        
        if(Theta == 360.0)Div--;

        for(int t=0;t<Div;t++)
                MakeWallByVC(Trans,IsLoop);

        if(Theta == 360.0)MakeWall(m_VertexCache,VertexList);

        m_VertexCache = BK_Cache;
}

void C3DObject::MakeSolidRotationVC(int Div,
                                                                        const bool IsLoop,
                                                                        const VECTOR3 &BasePos,
                                                                        const double Theta,
                                                                        const VECTOR3 &Axis)
{
        const ID_LIST_VERTEX BK_Cache = m_VertexCache;

        C3DTrans Trans;

        Trans.Translate(BasePos);
        Trans.Rotate(Axis,Theta/Div);
        Trans.Translate(-BasePos);
        
        if(Theta == 360.0)Div--;

        for(int t=0;t<Div;t++)
                MakeWallByVC(Trans,IsLoop);

        if(Theta == 360.0)MakeWall(m_VertexCache,BK_Cache);
}


//単位球形状の生成
void C3DObject::SetSphere(int detail)
{
        const double X = 0.525731112;
        const double Z = 0.850650808;

        const VECTOR3 vdata[12] =
        {
                VECTOR3(-X ,0.0,Z)  ,VECTOR3(X  ,0.0,Z)  ,VECTOR3(-X ,0.0,-Z) ,VECTOR3(X  ,0.0,-Z),
                VECTOR3(0.0,Z  ,X)  ,VECTOR3(0.0,Z  ,-X) ,VECTOR3(0.0,-Z ,X)  ,VECTOR3(0.0,-Z ,-X),
                VECTOR3(Z  ,X  ,0.0),VECTOR3(-Z ,X  ,0.0),VECTOR3(Z  ,-X ,0.0),VECTOR3(-Z ,-X ,0.0)
        };

        const ID_TRIANGLE tindices[20][3]={
                {0,4,1},{0,9,4},{9,5,4},{4,5,8},{4,8,1},
                {8,10,1},{8,3,10},{5,3,8},{5,2,3},{2,7,3},
                {7,10,3},{7,6,10},{7,11,6},{11,0,6},{0,1,6},
                {6,1,10},{9,0,11},{9,11,2},{9,2,5},{7,2,11},
        };
        
        const ID_TRIANGLE offset = m_Vertex.size();

        for(int t=0;t<12;t++)
                AddVertex(vdata[t]);

        for(int i=0;i<20;i++)
                subdivide(tindices[i][2]+offset,tindices[i][1]+offset,tindices[i][0]+offset,detail);
}

//三角形を再分割
void C3DObject::subdivide(ID_TRIANGLE V1_ID, ID_TRIANGLE V2_ID, ID_TRIANGLE V3_ID,int depth)
{
        VECTOR3 Vec12,Vec23,Vec31;
        
        Vec12=m_Vertex[V1_ID].Position+m_Vertex[V2_ID].Position;
        Vec23=m_Vertex[V2_ID].Position+m_Vertex[V3_ID].Position;
        Vec31=m_Vertex[V3_ID].Position+m_Vertex[V1_ID].Position;
        
        Vec12.unit();
        Vec23.unit();
        Vec31.unit();

        ID_TRIANGLE V12_ID;
        ID_TRIANGLE V23_ID;
        ID_TRIANGLE V31_ID;

        if((V12_ID = FindVertex(Vec12))>m_Vertex.size())V12_ID = AddVertex(Vec12);
        if((V23_ID = FindVertex(Vec23))>m_Vertex.size())V23_ID = AddVertex(Vec23);
        if((V31_ID = FindVertex(Vec31))>m_Vertex.size())V31_ID = AddVertex(Vec31);


        if(--depth == 0)
        {
                AddTriangle(V1_ID, V12_ID,V31_ID);
                AddTriangle(V2_ID, V23_ID,V12_ID);
                AddTriangle(V3_ID, V31_ID,V23_ID);
                AddTriangle(V12_ID,V23_ID,V31_ID);
        }
        else
        {
                subdivide(V1_ID, V12_ID, V31_ID,depth);
                subdivide(V2_ID, V23_ID, V12_ID,depth);
                subdivide(V3_ID, V31_ID, V23_ID,depth);
                subdivide(V12_ID,V23_ID, V31_ID,depth);
        }
}

//座標から頂点を検索する
const ID_TRIANGLE C3DObject::FindVertex(const VECTOR3 &Vector) const 
{
        for(int VID=0;VID<m_Vertex.size();VID++)
                if(m_Vertex[VID].Position == Vector)return VID;

        return -1;
}

//座標から頂点を検索する
const ID_TRIANGLE C3DObject::FineVertex(double x,double y,double z) const 
{
        VECTOR3 Vector(x,y,z);

        for(int VID=0;VID<m_Vertex.size();VID++)
                if(m_Vertex[VID].Position == Vector)return VID;

        return -1;
}


bool C3DObject::LoadOBJFile(char* FileName)
{

        FILE *fp = fopen(FileName,"ra");
        if(fp==NULL)return false;

        Init();

        char buf[256];

    while( fscanf(fp, "%s", buf) != EOF )
        {
                if(buf[0] == '#')
                { // comment
            fgets(buf, sizeof(buf), fp);
        }
        else if(buf[0] == 'v' && buf[1] == '\0')
                {
                        VECTOR3 NewVec;
                        char ValBuf[3][32];

            if(fscanf(fp, "%s %s %s\n", &ValBuf[0],&ValBuf[1],&ValBuf[2]) > 0)
                        {
                                NewVec.v[0] = atof(ValBuf[0]);
                                NewVec.v[1] = atof(ValBuf[1]);
                                NewVec.v[2] = atof(ValBuf[2]);

                                AddVertex(NewVec);
                        }
        }
        else if(buf[0] == 'f')
                {
                        std::vector<unsigned int> VectorIndex;
                        int VID = 0,tmp;

                        tmp = m_Vertex.size();

                        while(fscanf(fp,"%d/%d/%d",&VID,&tmp,&tmp)>0)
                                VectorIndex.push_back(VID-1);
                        

                        if(VectorIndex.size() > 2)
                        {
                                unsigned int FirstVec = VectorIndex[0];
                                for(int t=1;t<VectorIndex.size()-1;t++)
                                {
                                        //subdivide(FirstVec,VectorIndex[t],VectorIndex[t+1],1);
                                        AddTriangle(FirstVec,VectorIndex[t],VectorIndex[t+1]);
                                }
                        }
        }
        else 
            fgets(buf, sizeof(buf), fp);
  
        }

        fclose(fp);

        return true;
}


/*--------------------------------------------------------------/
|                                                                                                                               |
|                                                                                                                               |
|                                               実体：CTexture                                                  |
|                                                                                                                               |
|                                                                                                                               |
/--------------------------------------------------------------*/

CTexture::CTexture()
{
        m_Texture_Data.pColor = NULL;
        bIsBinded = false;
        m_TextureNumber = -1;
}

CTexture::~CTexture()
{
        if(m_Texture_Data.pColor != NULL)
                delete[] m_Texture_Data.pColor;
}

bool CTexture::LoadJpegFile(FILE *fp)
{
        // jpeg ライブラリでは次の２つの構造体が使われる
    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;

    JSAMPARRAY buffer;              /* 行出力バッファ */
    int   row_stride;               /* 出力バッファの物理行幅 */

    RGBA_BYTE *bmp_image;
    int   bmp_row;
    int   bmp_row_bytes;
    int   bmp_image_size;


    // エラーのハンドリング
    cinfo.err = jpeg_std_error(&jerr);

    // 構造体の初期設定
    jpeg_create_decompress(&cinfo);

    // ファイル入力ハンドルの設定
    jpeg_stdio_src(&cinfo, fp);

    // ファイルの情報ヘッダの読込み
    jpeg_read_header(&cinfo, TRUE);

    // 解凍の開始
    jpeg_start_decompress(&cinfo);

    // 行バッファの領域設定
    row_stride = cinfo.output_width * cinfo.output_components;

    buffer = (*cinfo.mem->alloc_sarray)
                ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);

    if( !buffer ) goto SKIP1;

    // DIB のイメージ領域確保
    m_Texture_Data.Width  = cinfo.image_width;
    m_Texture_Data.Height = cinfo.image_height;

    // DIB の行は、DWORD 境界で終わる必要がある
    bmp_row_bytes = m_Texture_Data.Width*4;
    bmp_image_size = bmp_row_bytes * m_Texture_Data.Height;

    // LIBJPEG 展開後のピクセル形式変換
    m_Texture_Data.pColor = new RGBA_BYTE[m_Texture_Data.Width*m_Texture_Data.Height];
    if( !m_Texture_Data.pColor ) goto END1;

    bmp_image = m_Texture_Data.pColor;

    // １行ずつ読み、バッファへ格納する
    bmp_row = 0;
    while (cinfo.output_scanline < cinfo.output_height) {
        int i;
        BYTE *src;
                RGBA_BYTE *dest;

        (void) jpeg_read_scanlines(&cinfo, buffer, 1);

        src = buffer[0];
        dest = &bmp_image[m_Texture_Data.Width*bmp_row++];

        for( i = row_stride-1; i > 0; i-=3 ) 
                {
           dest->Blue  = src[i-2];
           dest->Green = src[i-1];
           dest->Red   = src[i];
                   dest->Alpha = 255;
                   dest++;
        }
    }

    SKIP1:;
    (void) jpeg_finish_decompress(&cinfo);

    jpeg_destroy_decompress(&cinfo);
        
        END1:;

        return true;
}

//読み込みコールバック関数
void CTexture::PNGReader(png_structp png_ptr,png_bytep data,png_size_t length)
{
    FILE* fp=(FILE*)png_get_io_ptr(png_ptr);
        fread((char*)data,length,1,fp);
}

bool CTexture::LoadPngFile(FILE *fp)
{
        // PNG読み込み開始
    png_structp png_ptr;
    png_infop   info_ptr;
    
        //読み込みオブジェクト作成
        png_ptr=png_create_read_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL);
    if(png_ptr==NULL)return false;
        
        //Info構造体作成
        info_ptr=png_create_info_struct(png_ptr);
    if(info_ptr==NULL)
        {
                png_destroy_read_struct(&png_ptr,NULL,NULL);
                return false;
        }

        //読み込みコールバック関数の指定
    png_set_read_fn(png_ptr,fp,PNGReader);
    

    // 画像情報の取得
    png_uint_32 width,height;
    int bit_depth,color_type,interlace_type;
    int compression_type,filter_type;
    
        png_read_info(png_ptr,info_ptr);
        png_get_IHDR(png_ptr,info_ptr,&width,&height,&bit_depth,&color_type,
                  &interlace_type,&compression_type,&filter_type);


        std::vector<png_bytep> row_pointers;
    {
        for(int y=0;y<height;y++){
                        unsigned int size = png_get_rowbytes(png_ptr, info_ptr);
                        png_bytep OneLine = new BYTE[size];
            row_pointers.push_back(OneLine);
        }
    }

    png_set_bgr(png_ptr);
    png_read_image(png_ptr,row_pointers.begin());

    png_read_end(png_ptr,info_ptr);

        m_Texture_Data.Width  = width;
        m_Texture_Data.Height = height;
        m_Texture_Data.pColor = new RGBA_BYTE[m_Texture_Data.Width*m_Texture_Data.Height];

        for(int y=0;y<height;y++)
        {
                for(int x=0;x<width;x++)
                {
                        switch(color_type)
                        {
                        case PNG_COLOR_TYPE_RGB:
                                m_Texture_Data.pColor[x+y*width].Blue  = row_pointers[y][x*3];
                                m_Texture_Data.pColor[x+y*width].Green = row_pointers[y][x*3+1];
                                m_Texture_Data.pColor[x+y*width].Red   = row_pointers[y][x*3+2];
                                m_Texture_Data.pColor[x+y*width].Alpha = 255;
                        break;
                        case PNG_COLOR_TYPE_RGBA:
                                m_Texture_Data.pColor[x+y*width].Blue  = row_pointers[y][x*4];
                                m_Texture_Data.pColor[x+y*width].Green = row_pointers[y][x*4+1];
                                m_Texture_Data.pColor[x+y*width].Red   = row_pointers[y][x*4+2];
                                m_Texture_Data.pColor[x+y*width].Alpha = row_pointers[y][x*4+3];
                        break;
                        case PNG_COLOR_TYPE_GRAY:
                                m_Texture_Data.pColor[x+y*width].Red   = row_pointers[y][x];
                                m_Texture_Data.pColor[x+y*width].Green = row_pointers[y][x];
                                m_Texture_Data.pColor[x+y*width].Blue  = row_pointers[y][x];
                                m_Texture_Data.pColor[x+y*width].Alpha = 255;
                        break;
                        }
                }
                delete[] row_pointers[y];
        }
   
    png_destroy_read_struct(&png_ptr,&info_ptr,(png_infopp)NULL);
        return true;
}

void  CTexture::BindTextureOGL()
{
        if(m_Texture_Data.pColor == NULL)
                return;

        glEnable(GL_TEXTURE_2D);

        if(bIsBinded)
        {
                glBindTexture(GL_TEXTURE_2D, m_TextureNumber);
                return;
        }
        
        glGenTextures(1, (unsigned int*)&m_TextureNumber);

        glBindTexture(GL_TEXTURE_2D, m_TextureNumber);
        
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_Texture_Data.Width, 
                                m_Texture_Data.Height, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, m_Texture_Data.pColor);

        bIsBinded = true;
}

TextureData CTexture::GetTextureData() const 
{
        return m_Texture_Data;
}

bool CTexture::LoadTexture(char* pFileName)
{
        Init();
        return true;
}

void CTexture::LoadTexture(TextureData Tex)
{
        Init();
        if(Tex.pColor==NULL)return;

        m_Texture_Data.Height = Tex.Height;
        m_Texture_Data.Width  = Tex.Width;
        m_Texture_Data.pColor = new RGBA_BYTE[m_Texture_Data.Width*m_Texture_Data.Height];

        for(int i=0;i<m_Texture_Data.Width*m_Texture_Data.Height;i++)
                m_Texture_Data.pColor[i]=Tex.pColor[i];

}

void CTexture::Init()
{
        if(m_Texture_Data.pColor != NULL)
        {
                delete m_Texture_Data.pColor;
                glDeleteTextures(1 , (unsigned int*)&m_TextureNumber);
        }

        m_Texture_Data.pColor = NULL;
        bIsBinded = false;
        m_TextureNumber = -1;
}



/*--------------------------------------------------------------/
|                                                                                                                               |
|                                                                                                                               |
|                                               実体：CQuaternion                                               |
|                                                                                                                               |
|                                                                                                                               |
/--------------------------------------------------------------*/

CQuaternion::CQuaternion():w(1.0),x(0.0),y(0.0),z(0.0){}
CQuaternion::CQuaternion(double val):w(val),x(0.0),y(0.0),z(0.0){}
CQuaternion::CQuaternion(double qw,double qx,double qy,double qz):w(qw),x(qx),y(qy),z(qz){}
CQuaternion::CQuaternion(double ww,const VECTOR3 &vec):w(ww),x(vec.x),y(vec.y),z(vec.z){}

//デストラクタ
CQuaternion::~CQuaternion(){}

//単位クォータニオンで初期化
void CQuaternion::init(){w=1;x=0;y=0;z=0;}

//カメラの視線制御
CQuaternion::CQuaternion(VECTOR3 dir, VECTOR3 up)
{
        // ワールド座標の単位ベクトル
        VECTOR3 eye_y; eye_y.y=1.0;
        VECTOR3 eye_z; eye_y.z=1.0;
        // 単位ベクトルにする
        dir.unit();
        up.unit();
        // 視線方向を合わせるクォータニオンを作成
        CQuaternion q1;
        q1.Rotate( eye_z, dir );
        
        // Y軸を回転させる
        eye_y = q1.Rotate( eye_y );

        // 上向き方向を合わせるクォータニオンを作成
        CQuaternion q2 = Rotate( eye_y, up, dir );

        // 回転を合成する
        (*this) = ( q2 * q1 );
}

// 任意軸回転
void CQuaternion::SetRotate(const VECTOR3 &axis,const double &theta)
{
        double rad = ToRadian(theta) / 2.0;

        double s = sin( rad );
        w = cos( rad );
        x = s * axis.x;
        y = s * axis.y;
        z = s * axis.z;
}

//コピー
CQuaternion& CQuaternion::operator=(const CQuaternion &q )
{
        w = q.w;
        x = q.x;
        y = q.y;
        z = q.z;
        return (*this);
}

//符号の反転
const CQuaternion CQuaternion::operator -() const { return (CQuaternion( -w, -x, -y, -z ));}

//加算代入
CQuaternion& CQuaternion::operator+=(const CQuaternion &q)
{
        w += q.w;
        x += q.x;
        y += q.y;
        z += q.z;
        return (*this);
}

//加算代入(w成分)
CQuaternion& CQuaternion::operator+=(const double &val ){w+=val;return (*this);}

CQuaternion& CQuaternion::operator-=(const CQuaternion &q)
{
        w -= q.w;
        x -= q.x;
        y -= q.y;
        z -= q.z;
        return (*this);
}
//減算代入(w成分)
CQuaternion& CQuaternion::operator-=(const double &val ){w-=val;return (*this);}


CQuaternion& CQuaternion::operator*=(const CQuaternion &q)
{
        const double tw = w * q.w - x * q.x - y * q.y - z * q.z;
        const double tx = w * q.x + x * q.w + y * q.z - z * q.y;
        const double ty = w * q.y + y * q.w + z * q.x - x * q.z;
        const double tz = w * q.z + z * q.w + x * q.y - y * q.x;

        w = tw; x = tx; y = ty; z = tz;
        return (*this);
}
//乗算代入(w成分)
CQuaternion& CQuaternion::operator*=(const double &val)
{
        w *= val;
        x *= val;
        y *= val;
        z *= val;
        return (*this);
}

//乗算
const CQuaternion CQuaternion::operator*(const CQuaternion &q) const 
{
        const double tw = w * q.w - x * q.x - y * q.y - z * q.z;
        const double tx = w * q.x + x * q.w + y * q.z - z * q.y;
        const double ty = w * q.y + y * q.w + z * q.x - x * q.z;
        const double tz = w * q.z + z * q.w + x * q.y - y * q.x;

        return CQuaternion( tw, tx, ty, tz );
}

//除算代入
CQuaternion& CQuaternion::operator /=(const CQuaternion &q){return (*this) *= (q.inv());}

//除算代入(w成分)
CQuaternion& CQuaternion::operator /=(const double &val)
{
        w /= val;
        x /= val;
        y /= val;
        z /= val;
        return (*this);
}

//除算
const CQuaternion  CQuaternion::operator/(const CQuaternion &q) const {return CQuaternion((*this) * q.inv());}
//除算(各成分)
const CQuaternion  CQuaternion::operator/(const double &val) const {return CQuaternion( w/val , x/val , y/val , z/val );}

//ノルム・長さ
const double CQuaternion::norm() const{ return sqrt(w*w + x*x + y*y + z*z);}

//ノルム・長さの2乗
const double CQuaternion::norm2() const{ return (w*w + x*x + y*y + z*z);}

//共役クォータニオン
const CQuaternion CQuaternion::conjugate() const {return CQuaternion( w, -x, -y, -z );}

//逆クォータニオン
const CQuaternion CQuaternion::inv() const
{
        const double length2 = norm2();
        return CQuaternion( w/length2, -x/length2, -y/length2, -z/length2);
}

//単位クォータニオン
const CQuaternion CQuaternion::unit() const
{
        const double length = norm( );
        return CQuaternion( w/length, x/length, y/length, z/length);
}

//内積
double CQuaternion::operator&(CQuaternion &q){return (w * q.w + x * q.x + y * q.y + z * q.z);}

//ベクトルを回転する
VECTOR3 CQuaternion::Rotate(const VECTOR3 &vec) const 
{
        const CQuaternion &q = ( *this ) * CQuaternion(0,vec.x,vec.y,vec.z) * inv();
        return VECTOR3(q.x,q.y,q.z);
}


const VECTOR3 CQuaternion::operator*(const VECTOR3 &vec) const 
{
        const CQuaternion &q = ( *this ) * CQuaternion(0,vec.x,vec.y,vec.z) * inv();
        return VECTOR3(q.x,q.y,q.z);
}

void CQuaternion::Rotate(VECTOR3 v1, VECTOR3 v2)
{
        // 単位ベクトルにする
        v1.unit( );
        v2.unit( );

        // 回転角度を計算する
        double dot = v1&v2;

        if( dot < -1.0 )
        {
                w=-1.0;
                x=0.0; y=0.0; z=0.0;
                return;
        }

        double c = sqrt( ( dot + 1.0 ) * 0.5 );

        VECTOR3 rt = ( v1*v2 );
                        rt.unit();
                        rt *= sqrt(1.0 - c*c);
                        


        if( fabs( c - 1.0 ) < 1.0e-6 || c > 1.0  )
        {
                w=1.0;
                x=0.0; y=0.0; z=0.0;
        }
        else if( fabs( c + 1.0 ) < 1.0e-6 || c < -1.0 )
        {
                w=-1.0;
                x=0.0; y=0.0; z=0.0;
        }
        else
        {
                w = c;
                if(w==0 && rt.norm() == 0)
                {
                        rt.x = v1.y;
                        rt.y = v1.z;
                        rt.z = v1.x;
                }
                x=rt.x; y=rt.y; z=rt.z;
        }
}

CQuaternion CQuaternion::Rotate(VECTOR3 v1,VECTOR3 v2,VECTOR3 axis)
{
        // 単位ベクトルにする
        v1.unit( );
        v2.unit( );
        
        // 回転角度を計算する
        double dot = v1&v2;
        if( dot < -1.0 ) return CQuaternion( -1, 0, 0, 0 );

        double c = sqrt( ( dot + 1.0 ) * 0.5 );

        if( fabs( c - 1.0 ) < 1.0e-6 || c > 1.0 )      return CQuaternion(  1, 0, 0, 0 );
        else if( fabs( c + 1.0 ) < 1.0e-6 || c < -1.0 )return CQuaternion( -1, 0, 0, 0 );

        double s = sqrt( 1.0 - c * c );
        if( (axis&( v1*v2 )) < 0.0 ) s = -s;
        return CQuaternion( c, axis*s );
}

// 変換行列を求める
MATRIX44 CQuaternion::GetMatrix()
{
        MATRIX44 Matrix;
        Matrix._11 = w*w + x*x - y*y - z*z;
        Matrix._12 = 2.0 * ( x*y - w*z );
        Matrix._13 = 2.0 * ( x*z + w*y );
        Matrix._14 = 0.0;

        Matrix._21 = 2.0 * ( x*y + w * z );
        Matrix._22 = w * w-x * x + y*y - z*z;
        Matrix._23 = 2.0 * ( y*z - w * x );
        Matrix._24 = 0.0;

        Matrix._31 = 2.0 * ( x*z - w*y );
        Matrix._32 = 2.0 * ( y*z + w*x );
        Matrix._33 = w*w - x*x - y*y + z*z;
        Matrix._34 = 0.0;

        Matrix._41 = 0.0;
        Matrix._42 = 0.0;
        Matrix._43 = 0.0;
        Matrix._44 = 1.0;

        return Matrix;
}

bool CQuaternion::operator ==( const CQuaternion &q ) const { return (    w == q.w && x == q.x && y == q.y && z == q.z ); }
bool CQuaternion::operator !=( const CQuaternion &q ) const { return ( !( w == q.w && x == q.x && y == q.y && z == q.z ));}
bool CQuaternion::operator <=( const CQuaternion &q ) const { return (    w >= q.w && x >= q.x && y >= q.y && z >= q.z ) ;}
bool CQuaternion::operator > ( const CQuaternion &q ) const { return ( !( w >= q.w && x >= q.x && y >= q.y && z >= q.z ));}
bool CQuaternion::operator >=( const CQuaternion &q ) const { return (    w <= q.w && x <= q.x && y <= q.y && z <= q.z ) ;}
bool CQuaternion::operator < ( const CQuaternion &q ) const { return ( !( w <= q.w && x <= q.x && y <= q.y && z <= q.z ));}




/*--------------------------------------------------------------/
|                                                                                                                               |
|                                                                                                                               |
|                                               実体：CGLObject                                                 |
|                                                                                                                               |
|                                                                                                                               |
/--------------------------------------------------------------*/

// VBO Extension 関数のポインタ
PFNGLGENBUFFERSARBPROC glGenBuffersARB = NULL;                  // VBO 名前生成
PFNGLBINDBUFFERARBPROC glBindBufferARB = NULL;                  // VBO 結びつけ
PFNGLBUFFERDATAARBPROC glBufferDataARB = NULL;                  // VBO データロード
PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = NULL;            // VBO 削除


CGLObject::CGLObject()
{
        C3DObject::Init();

        m_IBO_ID = -1;

        m_VBO_VERTEX    = -1;
        m_VBO_NORMAL    = -1;
        m_VBO_TEXCODE   = -1;
        m_VBO_COLOR             = -1;

        m_DrawOption = (GLObjectOptions)(GLOps_Normal | GLOps_ObjectMaterial);  
        IsStatic=false;
}

CGLObject::~CGLObject()
{
}

CGLObject::init()
{
        C3DObject::Init();
        m_IndexList.clear();

        if(glDeleteBuffersARB != NULL)
        {
                if(m_VBO_VERTEX != -1)  glDeleteBuffersARB( 1, &m_VBO_VERTEX );
                if(m_VBO_NORMAL != -1)  glDeleteBuffersARB( 1, &m_VBO_NORMAL );
                if(m_VBO_TEXCODE != -1) glDeleteBuffersARB( 1, &m_VBO_TEXCODE );
                if(m_VBO_COLOR != -1)   glDeleteBuffersARB( 1, &m_VBO_COLOR );

                if(m_IBO_ID != -1)glDeleteBuffersARB( 1, &m_IBO_ID );
        }

        m_VBO_VERTEX    = -1;
        m_VBO_NORMAL    = -1;
        m_VBO_TEXCODE   = -1;
        m_VBO_COLOR             = -1;

        m_IBO_ID = -1;

        IsStatic=false;
}

void CGLObject::SetDrawOption(enum GLObjectOptions OptionFlag)
{
        if(OptionFlag&GLOps_VertexMaterial)
                OptionFlag = (GLObjectOptions)(OptionFlag | GLOps_Normal);
        

        if(OptionFlag&GLOps_VBO)
        {
                OptionFlag = (GLObjectOptions)(OptionFlag & ~GLOps_PlaneMaterial);
                OptionFlag = (GLObjectOptions)(OptionFlag & ~GLOps_VertexMaterial);
                OptionFlag = (GLObjectOptions)(OptionFlag & ~GLOps_PlaneColor);
        }

        if(OptionFlag&GLOps_VertexMaterial)
        {
                OptionFlag = (GLObjectOptions)(OptionFlag & ~GLOps_ObjectMaterial);
                OptionFlag = (GLObjectOptions)(OptionFlag & ~GLOps_PlaneMaterial);
        }

        if(OptionFlag&GLOps_PlaneMaterial)
                OptionFlag = (GLObjectOptions)(OptionFlag & ~GLOps_ObjectMaterial);
        

        if(OptionFlag&GLOps_VertexColor)
                OptionFlag = (GLObjectOptions)(OptionFlag & ~GLOps_PlaneColor);

        if(OptionFlag&GLOps_Texture)
        {
                OptionFlag = (GLObjectOptions)(OptionFlag & ~GLOps_PlaneColor);
                OptionFlag = (GLObjectOptions)(OptionFlag & ~GLOps_VertexColor);
        }
        m_DrawOption = OptionFlag;
}


void CGLObject::Draw()
{
        glPushMatrix();

        glTranslated(Position.m_Trans.x,Position.m_Trans.y,Position.m_Trans.z);

        const double angle = ToDegree(acos(Position.m_Quaternion.w)); 

        if(angle != 0)
        {
                VECTOR3 RotVec(Position.m_Quaternion.x,
                                           Position.m_Quaternion.y,
                                           Position.m_Quaternion.z);
                RotVec.unit();
                glRotated(angle,RotVec.x,RotVec.y,RotVec.z);
        }

        IfEnable(GLOps_VBO)
                DrawVBO();
        else
                DrawStandard();

        glPopMatrix();
}


void CGLObject::DrawStandard()
{
        if(!IsStatic)
                if(m_DrawOption&GLOps_Normal)Normalize();
        
        IfEnable(GLOps_ALPHA)
        {
                glEnable(GL_BLEND);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glDepthMask(GL_FALSE);
        }

        IfEnable(GLOps_Texture)
        {
                m_Texture.BindTextureOGL();
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        }

        IfEnable(GLOps_ObjectMaterial)
        {
                glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT ,Material.Ambient. Colors);
                glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE ,Material.Diffuse. Colors);
                glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,Material.Specular.Colors);
        }


        glBegin(GL_TRIANGLES);
        for(int TID=0;TID<m_Triangle.size();TID++)
        {
                IfEnable(GLOps_PlaneMaterial)
                {
                        glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT ,m_Triangle[TID].Material.Ambient. Colors);
                        glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE ,m_Triangle[TID].Material.Diffuse. Colors);
                        glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,m_Triangle[TID].Material.Specular.Colors);
                }
                else IfEnable(GLOps_PlaneColor)
                        glColor4ubv(m_Triangle[TID].PlaneColor.Colors);

                IfEnable(GLOps_VertexMaterial)
                {
                        glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT ,m_Vertex[m_Triangle[TID].Vec1].Material.Ambient. Colors);
                        glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE ,m_Vertex[m_Triangle[TID].Vec1].Material.Diffuse. Colors);
                        glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,m_Vertex[m_Triangle[TID].Vec1].Material.Specular.Colors);
                }
                else IfEnable(GLOps_VertexColor)
                        glColor4ubv(m_Vertex[m_Triangle[TID].Vec1].VertexColor.Colors);

                IfEnable(GLOps_Normal)  glNormal3dv  (m_Vertex[m_Triangle[TID].Vec1].Normal.v);
                IfEnable(GLOps_Texture) glTexCoord2dv(m_Vertex[m_Triangle[TID].Vec1].Texture_Coordinate.val);
                glVertex3dv(m_Vertex[m_Triangle[TID].Vec1].Position.v);


                IfEnable(GLOps_VertexMaterial)
                {
                        glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT ,m_Vertex[m_Triangle[TID].Vec2].Material.Ambient. Colors);
                        glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE ,m_Vertex[m_Triangle[TID].Vec2].Material.Diffuse. Colors);
                        glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,m_Vertex[m_Triangle[TID].Vec2].Material.Specular.Colors);
                }
                else IfEnable(GLOps_VertexColor)
                        glColor4ubv(m_Vertex[m_Triangle[TID].Vec2].VertexColor.Colors);

                IfEnable(GLOps_Normal)  glNormal3dv  (m_Vertex[m_Triangle[TID].Vec2].Normal.v);
                IfEnable(GLOps_Texture) glTexCoord2dv(m_Vertex[m_Triangle[TID].Vec2].Texture_Coordinate.val);
                glVertex3dv(m_Vertex[m_Triangle[TID].Vec2].Position.v);



                IfEnable(GLOps_VertexMaterial)
                {
                        glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT ,m_Vertex[m_Triangle[TID].Vec3].Material.Ambient. Colors);
                        glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE ,m_Vertex[m_Triangle[TID].Vec3].Material.Diffuse. Colors);
                        glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,m_Vertex[m_Triangle[TID].Vec3].Material.Specular.Colors);
                }
                else IfEnable(GLOps_VertexColor)
                        glColor4ubv(m_Vertex[m_Triangle[TID].Vec3].VertexColor.Colors);

                IfEnable(GLOps_Normal)  glNormal3dv  (m_Vertex[m_Triangle[TID].Vec3].Normal.v);
                IfEnable(GLOps_Texture) glTexCoord2dv(m_Vertex[m_Triangle[TID].Vec3].Texture_Coordinate.val);
                glVertex3dv(m_Vertex[m_Triangle[TID].Vec3].Position.v);
        }
        glEnd();

        IfEnable(GLOps_ALPHA)
        {
                glDisable(GL_BLEND);
                glDepthMask(GL_TRUE);
        }
}

void CGLObject::DrawVBO()
{
        //各種機能を有効化
        glEnableClientState( GL_VERTEX_ARRAY );//頂点配列
        IfEnable(GLOps_Normal)          glEnableClientState( GL_NORMAL_ARRAY );//法線配列
        IfEnable(GLOps_Texture)         glEnableClientState( GL_TEXTURE_COORD_ARRAY );//テクスチャ座標配列
        IfEnable(GLOps_VertexColor)     glEnableClientState( GL_COLOR_ARRAY  );//色配列

        if(!IsStatic)//頂点データを常に書き換えるならば
        {
                IfEnable(GLOps_Normal)Normalize();//頂点法線の計算
                if(glGenBuffersARB==NULL)InitVBO();//VBO初期化
                CreateVBO();//VBO作成
        }

        IfEnable(GLOps_ALPHA)
        {
                glEnable(GL_BLEND);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

                glDepthMask(GL_FALSE);
        }

        IfEnable(GLOps_ObjectMaterial)
        {
                glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT ,Material.Ambient. Colors);
                glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE ,Material.Diffuse. Colors);
                glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,Material.Specular.Colors);
        }
        
        IfEnable(GLOps_Normal)
        {
                glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_VBO_NORMAL );
                glNormalPointer(GL_FLOAT, 0,0);
        }

        IfEnable(GLOps_Texture)
        {
                //テクスチャを有効化
                glEnable(GL_TEXTURE_2D);
                //テクスチャをバインド
                m_Texture.BindTextureOGL();

                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        
                glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_VBO_TEXCODE );
                glTexCoordPointer( 2, GL_FLOAT, 0 , 0 );
        }

        //色情報の場所
        IfEnable(GLOps_VertexColor)
        {
                glDisable(GL_LIGHTING);
                glDisable(GL_TEXTURE_2D);

                glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_VBO_COLOR );
                glColorPointer(4,GL_UNSIGNED_BYTE ,0,0);
        }

        //頂点
        glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_VBO_VERTEX );
        glVertexPointer( 3, GL_FLOAT, 0, 0 );

        //インデックスバッファを呼び出し
        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, m_IBO_ID );
        //図形描画
        glDrawElements(GL_TRIANGLES, m_Triangle.size()*3, GL_UNSIGNED_INT, 0);
        

        IfEnable(GLOps_ALPHA)
        {
                glDisable(GL_BLEND);
                glDepthMask(GL_TRUE);
        }

        //各種機能を無効化
        glDisableClientState( GL_VERTEX_ARRAY );
        IfEnable(GLOps_Normal)          glDisableClientState( GL_NORMAL_ARRAY );//法線配列
        IfEnable(GLOps_Texture)         glDisableClientState( GL_TEXTURE_COORD_ARRAY );//テクスチャ座標配列
        IfEnable(GLOps_VertexColor)     glDisableClientState( GL_COLOR_ARRAY  );//色配列
}

void CGLObject::InitVBO()
{       
        if(IsExtensionSupported( "GL_ARB_vertex_buffer_object" ) )
        {
                 // VBO関連の関数ポインタを所得する
                glGenBuffersARB = (PFNGLGENBUFFERSARBPROC) wglGetProcAddress("glGenBuffersARB");
                glBindBufferARB = (PFNGLBINDBUFFERARBPROC) wglGetProcAddress("glBindBufferARB");
                glBufferDataARB = (PFNGLBUFFERDATAARBPROC) wglGetProcAddress("glBufferDataARB");
                glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) wglGetProcAddress("glDeleteBuffersARB");
        }
}

bool CGLObject::IsExtensionSupported( char* szTargetExtension )
{
        const unsigned char *pszExtensions = NULL;
        const unsigned char *pszStart;
        unsigned char *pszWhere, *pszTerminator;

        // Extension の名前が正しいか調べる(NULLや空白が入っちゃ駄目)
        pszWhere = (unsigned char *) strchr( szTargetExtension, ' ' );
        if( pszWhere || *szTargetExtension == '\0' )return false;

        // Extension の文字列を所得する
        pszExtensions = glGetString( GL_EXTENSIONS );

        // 文字列の中に必要な extension があるか調べる
        pszStart = pszExtensions;
        for(;;)
        {
                pszWhere = (unsigned char *) strstr( (const char *) pszStart, szTargetExtension );
                if( !pszWhere )break;
                pszTerminator = pszWhere + strlen( szTargetExtension );
                if( pszWhere == pszStart || *( pszWhere - 1 ) == ' ' )
                        if( *pszTerminator == ' ' || *pszTerminator == '\0' )return true;
                pszStart = pszTerminator;
        }
        return false;
}

void CGLObject::CreateVBO()
{

        m_VertexList.clear();
        m_NormalList.clear();
        m_TexCodeList.clear();
        m_ColorList.clear();

        for(int v=0;v<m_Vertex.size();v++)
        {
                m_VertexList.push(m_Vertex[v].Position.x);
                m_VertexList.push(m_Vertex[v].Position.y);
                m_VertexList.push(m_Vertex[v].Position.z);

                IfEnable(GLOps_Normal)
                {
                        m_NormalList.push(m_Vertex[v].Normal.x);
                        m_NormalList.push(m_Vertex[v].Normal.y);
                        m_NormalList.push(m_Vertex[v].Normal.z);
                }

                IfEnable(GLOps_Texture)
                {
                        m_TexCodeList.push(m_Vertex[v].Texture_Coordinate.u);
                        m_TexCodeList.push(m_Vertex[v].Texture_Coordinate.v);
                }

                IfEnable(GLOps_VertexColor)
                {
                        m_ColorList.push(m_Vertex[v].VertexColor.Red);
                        m_ColorList.push(m_Vertex[v].VertexColor.Green);
                        m_ColorList.push(m_Vertex[v].VertexColor.Blue);
                }
        }


        if(m_VBO_VERTEX != -1)glDeleteBuffersARB( 1, &m_VBO_VERTEX );

        glGenBuffersARB( 1, &m_VBO_VERTEX );                                    // ID を得る
        glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_VBO_VERTEX );   // バッファを結びつける
        glBufferDataARB( GL_ARRAY_BUFFER_ARB, m_VertexList.size()*sizeof(float), m_VertexList.GetFirstAdder(), GL_STATIC_DRAW_ARB );

        IfEnable(GLOps_Texture)
        {
                if(m_VBO_TEXCODE != -1)glDeleteBuffersARB( 1, &m_VBO_TEXCODE );

                glGenBuffersARB( 1, &m_VBO_TEXCODE );                                   // ID を得る
                glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_VBO_TEXCODE );  // バッファを結びつける
                glBufferDataARB( GL_ARRAY_BUFFER_ARB, m_TexCodeList.size()*sizeof(float), m_TexCodeList.GetFirstAdder(), GL_STATIC_DRAW_ARB );

        }

        IfEnable(GLOps_Normal)
        {
                if(m_VBO_NORMAL != -1)glDeleteBuffersARB( 1, &m_VBO_NORMAL );

                glGenBuffersARB( 1, &m_VBO_NORMAL );                                    // ID を得る
                glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_VBO_NORMAL );   // バッファを結びつける
                glBufferDataARB( GL_ARRAY_BUFFER_ARB, m_NormalList.size()*sizeof(float), m_NormalList.GetFirstAdder(), GL_STATIC_DRAW_ARB );
        }

        IfEnable(GLOps_VertexColor)
        {
                if(m_VBO_COLOR != -1)glDeleteBuffersARB( 1, &m_VBO_COLOR );

                glGenBuffersARB( 1, &m_VBO_COLOR );                                     // ID を得る
                glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_VBO_COLOR );    // バッファを結びつける
                glBufferDataARB( GL_ARRAY_BUFFER_ARB, m_ColorList.size()*sizeof(float), m_ColorList.GetFirstAdder(), GL_STATIC_DRAW_ARB );
        }

        if(m_IBO_ID != -1)glDeleteBuffersARB( 1, &m_IBO_ID );
        glGenBuffersARB( 1, &m_IBO_ID );                                        // ID を得る
        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, m_IBO_ID );       // バッファを結びつける
        glBufferDataARB( GL_ELEMENT_ARRAY_BUFFER_ARB, m_Triangle.size()*sizeof(unsigned int)*3, m_IndexList.GetFirstAdder(), GL_STATIC_DRAW_ARB );
}

//インデックスリスト作成のためオーバーライド
const unsigned int  CGLObject::AddTriangle(const unsigned int &Vec1,
                                                                                   const unsigned int &Vec2,
                                                                                   const unsigned int &Vec3)
{
        unsigned int ID = C3DObject::AddTriangle(Vec1,Vec2,Vec3);
        
        if(ID<m_Triangle.size())
        {
                m_IndexList.push(Vec1);
                m_IndexList.push(Vec2);
                m_IndexList.push(Vec3);
        }

        return ID;
}

void CGLObject::Lock()
{
        if(m_DrawOption&GLOps_Normal)Normalize();//頂点法線の計算

        if(m_DrawOption & GLOps_VBO)
        {
                if(glGenBuffersARB==NULL)InitVBO();//VBO初期化

                if(glGenBuffersARB!=NULL)
                        CreateVBO();//VBO作成
                else//初期化失敗
                        m_DrawOption = (GLObjectOptions)(m_DrawOption & ~GLOps_VBO);
        }

        IsStatic=true;
}


void CGLObject::Unlock()
{
        IsStatic=false;
}

---