BOOL IntersectTriangle( const D3DXVECTOR3& orig, const D3DXVECTOR3& dir,
                       D3DXVECTOR3& v0, D3DXVECTOR3& v1, D3DXVECTOR3& v2, FLOAT* t, FLOAT* u, FLOAT* v )
{
    // Find vectors for two edges sharing vert0
    D3DXVECTOR3 edge1 = v1 - v0;
    D3DXVECTOR3 edge2 = v2 - v0;

    // Begin calculating determinant - also used to calculate U parameter
    D3DXVECTOR3 pvec;
    D3DXVec3Cross( &pvec, &dir, &edge2 );

    // If determinant is near zero, ray lies in plane of triangle
    FLOAT det = D3DXVec3Dot( &edge1, &pvec );

    D3DXVECTOR3 tvec;
    if( det > 0 )
    {
        tvec = orig - v0;
    }
    else
    {
        tvec = v0 - orig;
        det = -det;
    }

    if( det < 0.0001f )
        return FALSE;

    // Calculate U parameter and test bounds
    *u = D3DXVec3Dot( &tvec, &pvec );
    if( *u < 0.0f || *u > det )
        return FALSE;

    // Prepare to test V parameter
    D3DXVECTOR3 qvec;
    D3DXVec3Cross( &qvec, &tvec, &edge1 );

    // Calculate V parameter and test bounds
    *v = D3DXVec3Dot( &dir, &qvec );
    if( *v < 0.0f || *u + *v > det )
        return FALSE;

    // Calculate t, scale parameters, ray intersects triangle
    *t = D3DXVec3Dot( &edge2, &qvec );
    FLOAT fInvDet = 1.0f / det;
    *t *= fInvDet;
    *u *= fInvDet;
    *v *= fInvDet;

    return TRUE;
}

BOOL Picking(HWND hWnd)
{
        POINT ptCursor;
        D3DXVECTOR3 vPickRayDir;
        D3DXVECTOR3 vPickRayOrig;

        INTERSECTION_HEIGHTMAP Intersection;
        ZeroMemory(&Intersection, sizeof(INTERSECTION_HEIGHTMAP));
        Intersection.m_fDist = FAR_DISTANCE;


        _cdbg("Picking Start");

        // 마우스 포인터로 부터 3D객체를 향해서 뻗는 3D직선의 백터를 얻는다. 언프로젝션부분
        D3DVIEWPORT9 vp;
        m_pGraphics->GetDeviceCOM()->GetViewport(&vp);
        D3DXMATRIXA16 matProj;
        m_pGraphics->GetDeviceCOM()->GetTransform( D3DTS_PROJECTION, &matProj );

        GetCursorPos( &ptCursor );
        ScreenToClient( hWnd, &ptCursor );

        D3DXVECTOR3 v;
        v.x = ((  (((ptCursor.x-vp.X)*2.0f/vp.Width ) - 1.0f)) - matProj._31 ) / matProj._11;
        v.y = ((- (((ptCursor.y-vp.Y)*2.0f/vp.Height) - 1.0f)) - matProj._32 ) / matProj._22;
        v.z = 1.0f;

        // Get the inverse view matrix
        D3DXMATRIXA16 matView, m;
        m_pGraphics->GetDeviceCOM()->GetTransform( D3DTS_VIEW, &matView );
        D3DXMatrixInverse( &m, NULL, &matView );

        // Transform the screen space pick ray into 3D space
        vPickRayDir.x  = v.x*m._11 + v.y*m._21 + v.z*m._31;
        vPickRayDir.y  = v.x*m._12 + v.y*m._22 + v.z*m._32;
        vPickRayDir.z  = v.x*m._13 + v.y*m._23 + v.z*m._33;
        vPickRayOrig.x = m._41;
        vPickRayOrig.y = m._42;
        vPickRayOrig.z = m._43;

        // 위에서 얻는 백터와 Picking의 대상이 되는 오브젝트의 충돌 체크를 한다.
        FVF_HEIGHTMAP*  pVerHeightMap;
        WORD*                   pIndexHeightMap;
        GetVertexBuffer()->Lock();
        pVerHeightMap = (FVF_HEIGHTMAP*)m_pVB->GetPtr();

        GetIndexBuffer()->Lock();
        pIndexHeightMap = (WORD*)m_pIB->GetPtr();

        FLOAT fBary1, fBary2, fDist;
        for( DWORD i=0; i<m_dwPrimitives; i++ )
        {
                D3DXVECTOR3 v0 = pVerHeightMap[pIndexHeightMap[3*i+0]].p;
                D3DXVECTOR3 v1 = pVerHeightMap[pIndexHeightMap[3*i+1]].p;
                D3DXVECTOR3 v2 = pVerHeightMap[pIndexHeightMap[3*i+2]].p;

                // Check if the pick ray passes through this point
                // 충돌이 있다면 
                if( IntersectTriangle( vPickRayOrig, vPickRayDir, v0, v1, v2, &fDist, &fBary1, &fBary2 ) )
                {
                        _cdbg("Intersection occour");

                        // 일단 가장 가까운 값을 유지 해야 한다
                        if(Intersection.m_fDist > fDist)
                        {
                                Intersection.m_fDist = fDist;

                                Intersection.m_verHeightMap[0].p = v0;
                                Intersection.m_verHeightMap[1].p = v1;
                                Intersection.m_verHeightMap[2].p = v2;

                                Intersection.m_dwPrimitiveIndex = i;
                        }
                }
        }

        m_pIB->Unlock();
        m_pVB->Unlock();

        // Picking 된 버텍스로 출력할 것 설정
        WORD Indexs[3] = {0,1,2};
        m_pVBIntersect->Set(0,3,Intersection.m_verHeightMap);
        m_pIBIntersect->Set(0,3,Indexs);

        // Debug ///////////////////////////////////
        sprintf(m_szDebugBuff,
                "Primitive Index : %d, Picking Distance : %f\nMouse Position X : %d, Mouse Position Y : %d",
                Intersection.m_dwPrimitiveIndex, Intersection.m_fDist, ptCursor.x, ptCursor.y);
        // Debug ///////////////////////////////////

        return TRUE;
}

        D3DVIEWPORT9 vp;
        m_pGraphics->GetDeviceCOM()->GetViewport(&vp);
        D3DXMATRIXA16 matProj;
        m_pGraphics->GetDeviceCOM()->GetTransform( D3DTS_PROJECTION, &matProj );

        GetCursorPos( &ptCursor );
        ScreenToClient( hWnd, &ptCursor );

        D3DXVECTOR3 v;
        v.x = ((  (((ptCursor.x-vp.X)*2.0f/vp.Width ) - 1.0f)) - matProj._31 ) / matProj._11;
        v.y = ((- (((ptCursor.y-vp.Y)*2.0f/vp.Height) - 1.0f)) - matProj._32 ) / matProj._22;
        v.z = 1.0f;

        RECT rt;
        GetClientRect( hWnd, &rt );
        D3DXMATRIXA16 matProj;
        m_pGraphics->GetDeviceCOM()->GetTransform( D3DTS_PROJECTION, &matProj );

        GetCursorPos( &ptCursor );
        ScreenToClient( hWnd, &ptCursor );

        D3DXVECTOR3 v;
        v.x = ((  (((ptCursor.x-rt.left)*2.0f/rt.right ) - 1.0f)) - matProj._31 ) / matProj._11;
        v.y = ((- (((ptCursor.y-rt.top)*2.0f/rt.bottom) - 1.0f)) - matProj._32 ) / matProj._22;
        v.z = 1.0f;

         unsigned char TmpHeight;

        // 버텍스버퍼와 인덱스버퍼를 위한 중간 버퍼들
        FVF_HEIGHTMAP*  pVertexData = new FVF_HEIGHTMAP[m_dwVertices];
        WORD*                   pIndexData  = new WORD[m_dwPrimitives*3];

        //파일에서 높이 정보를 읽어오고 버텍스정보를 삽입한다.
        FILE* pFile;
        UINT nIndex = 0;
        pFile = fopen(szFilename, "rb");
        for(unsigned y = 0;y < (HEIMAP_Y + 1); y++)
        {
                for(unsigned x = 0;x < (HEIMAP_X + 1); x++)
                {
                        TmpHeight = fgetc(pFile);

                        // 버텍스 데이타 구성
                        pVertexData[x + y * (HEIMAP_X+1)].fX = (float)x;
                        pVertexData[x + y * (HEIMAP_X+1)].fY = (float)TmpHeight / 15.0f - 40;
                        pVertexData[x + y * (HEIMAP_X+1)].fZ = (float)y;
                        pVertexData[x + y * (HEIMAP_X+1)].dwColor = 0xffffffff;

                        if( (y < HEIMAP_Y) && (x < HEIMAP_X) )
                        {
                                // 인덱스 데이타 구성
                                pIndexData[(x+y*(HEIMAP_X))*6 +0] = x   + y     * (HEIMAP_X+1);
                                pIndexData[(x+y*(HEIMAP_X))*6 +1] = x+1 + y     * (HEIMAP_X+1);
                                pIndexData[(x+y*(HEIMAP_X))*6 +2] = x   + (y+1) * (HEIMAP_X+1);

                                pIndexData[(x+y*(HEIMAP_X))*6 +3] = x   + y     * (HEIMAP_X+1);
                                pIndexData[(x+y*(HEIMAP_X))*6 +4] = x+1 + (y+1) * (HEIMAP_X+1);
                                pIndexData[(x+y*(HEIMAP_X))*6 +5] = x   + (y+1) * (HEIMAP_X+1);
                        }
                }
        }
        fclose(pFile);

        // 버텍스버퍼를 구성한다. 
        m_pVB->Create(m_pGraphics, m_dwVertices, sizeof(FVF_HEIGHTMAP), D3DFVF_HEIGHTMAP);
        m_pVB->Set(0, m_dwVertices, pVertexData);

        //인덱스데이타를 구성한다.
        m_pIB->Create(m_pGraphics, m_dwPrimitives*3);
        m_pIB->Set(0, m_dwPrimitives*3, pIndexData);

        // 버덱스데이타, 인덱스데이타 메모리를 해재한다.
        delete [] pVertexData;
        delete [] pIndexData;

void CHeightMap::Rendering(HEIGHTMAP_DRAW_OPTION hdOption)
{
        D3DXMATRIX matrixView;
        m_pGraphics->GetDeviceCOM()->GetTransform(D3DTS_VIEW, &matrixView);
        FLOAT fDeterminantMatView = D3DXMatrixDeterminant(&matrixView);

        D3DXMATRIX matViewInv;
        D3DXMatrixInverse(&matViewInv, &fDeterminantMatView, &matrixView);

        D3DXMATRIX matScale;
        ZeroMemory(&matScale, sizeof(D3DXMATRIX));
        matScale._11=1.0f/1.0f;
        matScale._32=1.0f/1.0f;

        D3DXMATRIX matTex;
        D3DXMatrixMultiply(&matTex, &matViewInv, &matScale);

        // 텍스쳐 좌표 자동생성을 위한 세팅
        m_pGraphics->GetDeviceCOM()->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION);
        m_pGraphics->GetDeviceCOM()->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
        m_pGraphics->GetDeviceCOM()->SetTransform(D3DTS_TEXTURE0, &matTex);

        // 랜더링 옵션이 WIRE이면 랜더링 상태를 설정
        if(hdOption == RENDER_WIRE)
                m_pGraphics->GetDeviceCOM()->SetRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);

        m_pIB->Render( D3DPT_TRIANGLELIST, 0, 0, m_pVB->GetNumVertices(), 0, m_dwPrimitives, m_pVB, m_pTextureDefault );

        // 랜더링 옵션이 WIRE이면 랜더링 상태를 해제
        if(hdOption == RENDER_WIRE)
                m_pGraphics->GetDeviceCOM()->SetRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);


        // 텍스쳐 좌표 자동생성을 위한 세팅 해제
        m_pGraphics->GetDeviceCOM()->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_PASSTHRU);
        m_pGraphics->GetDeviceCOM()->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
}