[DirectX 11] Terrain 06 - 높이 기반 이동

Terrain 06 - 높이 기반 이동

원문 : http://www.rastertek.com/tertut06.html

 이전 튜토리얼에서 다뤘던 쿼드 트리 기술은 또 다른 튜토리얼에서 다루고자 했던 또 다른 이점을 제공합니다. 보이지 않는 노드를 제거하여 폴리곤을 빠르게 제거할 수 있기 때문에 현재 노드가 어떤 노드인지 파악하고 나머지는 모두 제거할 수 있습니다. 그런 다음 우리가 할 수 있는 것은 전체 지형 대신에 현재 노드에서 단지 적은 수의 삼각형을 가진 선 삼각형 교차 검사입니다. 이 정보는 현재 카메라 아래에 있는 삼각형의 높이를 결정하는 데 사용될 수 있습니다. 높이를 알면 지형 바로 위에서 고정된 높이만큼 카메라를 배치할 수 있습니다.이 높이는 지형을 따라 이동할 때 수정됩니다. 즉, 지형을 기반으로 사람이 움직이는것과 같은 카메라 이동을 보여줄 수 있습니다.

QuadTreeClass 클래스의 변경 사항부터 시작하도록 하겠습니다.

Quadtreeclass.h

#pragma once
 
 
/////////////
// GLOBALS //
/////////////
const int MAX_TRIANGLES = 10000;
 
 
class TerrainClass;
class FrustumClass;
class TerrainShaderClass;
 
 
class QuadTreeClass
{
private:
    struct VertexType
    {
        XMFLOAT3 position;
        XMFLOAT2 texture;
        XMFLOAT3 normal;
    };
 
    struct VectorType
    {
        float x, y, z;
    };
 
    struct NodeType
    {
        float positionX, positionZ, width;
        int triangleCount;
        ID3D11Buffer *vertexBuffer, *indexBuffer;
        VectorType* vertexArray;
        NodeType* nodes[4];
    };
 
public:
    QuadTreeClass();
    QuadTreeClass(const QuadTreeClass&);
    ~QuadTreeClass();
 
    bool Initialize(TerrainClass*, ID3D11Device*);
    void Shutdown();
    void Render(FrustumClass*, ID3D11DeviceContext*, TerrainShaderClass*);
 
    int GetDrawCount();
    bool GetHeightAtPosition(float, float, float&);
 
private:
    void CalculateMeshDimensions(int, float&, float&, float&);
    void CreateTreeNode(NodeType*, float, float, float, ID3D11Device*);
    int CountTriangles(float, float, float);
    bool IsTriangleContained(int, float, float, float);
    void ReleaseNode(NodeType*);
    void RenderNode(NodeType*, FrustumClass*, ID3D11DeviceContext*, TerrainShaderClass*);
 
    void FindNode(NodeType*, float, float, float&);
    bool CheckHeightOfTriangle(float, float, float&, float[3], float[3], float[3]);
 
private:
    int m_triangleCount, m_drawCount;
    VertexType* m_vertexList = nullptr;
    NodeType* m_parentNode = nullptr;
};

Quadtreeclass.cpp

#include "stdafx.h"
#include "terrainclass.h"
#include "frustumclass.h"
#include "terrainshaderclass.h"
#include "quadtreeclass.h"
 
 
QuadTreeClass::QuadTreeClass()
{
}
 
 
QuadTreeClass::QuadTreeClass(const QuadTreeClass& other)
{
}
 
 
QuadTreeClass::~QuadTreeClass()
{
}
 
 
bool QuadTreeClass::Initialize(TerrainClass* terrain, ID3D11Device* device)
{
    float centerX = 0.0f;
    float centerZ = 0.0f;
    float width = 0.0f;
    
    // 지형 정점 배열의 정점 수를 가져옵니다.
    int vertexCount = terrain->GetVertexCount();
 
    // 정점리스트의 총 삼각형 수를 저장합니다.
    m_triangleCount = vertexCount / 3;
 
    // 모든 지형 정점을 포함하는 정점 배열을 만듭니다.
    m_vertexList = new VertexType[vertexCount];
    if(!m_vertexList)
    {
        return false;
    }
 
    // 지형 정점을 정점 목록에 복사합니다.
    terrain->CopyVertexArray((void*)m_vertexList);
 
    // 중심 x, z와 메쉬의 너비를 계산합니다.
    CalculateMeshDimensions(vertexCount, centerX, centerZ, width);
 
    // 쿼드 트리의 부모 노드를 만듭니다.
    m_parentNode = new NodeType;
    if(!m_parentNode)
    {
        return false;
    }
 
    // 정점 목록 데이터와 메쉬 차원을 기반으로 쿼드 트리를 재귀 적으로 빌드합니다.
    CreateTreeNode(m_parentNode, centerX, centerZ, width, device);
 
    // 쿼드 트리가 각 노드에 정점을 갖기 때문에 정점 목록을 놓습니다.
    if(m_vertexList)
    {
        delete [] m_vertexList;
        m_vertexList = 0;
    }
 
    return true;
}
 
 
void QuadTreeClass::Shutdown()
{
    // 쿼드 트리 데이터를 재귀 적으로 해제합니다.
    if(m_parentNode)
    {
        ReleaseNode(m_parentNode);
        delete m_parentNode;
        m_parentNode = 0;
    }
}
 
 
void QuadTreeClass::Render(FrustumClass* frustum, ID3D11DeviceContext* deviceContext, TerrainShaderClass* shader)
{
    // 이 프레임에 대해 그려지는 삼각형의 수를 초기화합니다.
    m_drawCount = 0;
 
    // 부모 노드에서 시작하여 트리 아래로 이동하여 보이는 각 노드를 렌더링합니다.
    RenderNode(m_parentNode, frustum, deviceContext, shader);
}
 
 
int QuadTreeClass::GetDrawCount()
{
    return m_drawCount;
}
 
 
void QuadTreeClass::CalculateMeshDimensions(int vertexCount, float& centerX, float& centerZ, float& meshWidth)
{
    // 메쉬의 중심 위치를 0으로 초기화합니다.
    centerX = 0.0f;
    centerZ = 0.0f;
 
    // 메쉬의 모든 정점을 합친다.
    for(int i=0; i<vertexCount; i++)
    {
        centerX += m_vertexList[i].position.x;
        centerZ += m_vertexList[i].position.z;
    }
 
    // 그리고 메쉬의 중간 점을 찾기 위해 정점의 수로 나눕니다.
    centerX = centerX / (float)vertexCount;
    centerZ = centerZ / (float)vertexCount;
 
    // 메쉬의 최대 및 최소 크기를 초기화합니다.
    float maxWidth = 0.0f;
    float maxDepth = 0.0f;
 
    float minWidth = fabsf(m_vertexList[0].position.x - centerX);
    float minDepth = fabsf(m_vertexList[0].position.z - centerZ);
 
    // 모든 정점을 살펴보고 메쉬의 최대 너비와 최소 너비와 깊이를 찾습니다.
    for(int i=0; i<vertexCount; i++)
    {
        float width = fabsf(m_vertexList[i].position.x - centerX);    
        float depth = fabsf(m_vertexList[i].position.z - centerZ);    
 
        if(width > maxWidth) { maxWidth = width; }
        if(depth > maxDepth) { maxDepth = depth; }
        if(width < minWidth) { minWidth = width; }
        if(depth < minDepth) { minDepth = depth; }
    }
 
    // 최소와 최대 깊이와 너비 사이의 절대 최대 값을 찾습니다.
    float maxX = (float)max(fabs(minWidth), fabs(maxWidth));
    float maxZ = (float)max(fabs(minDepth), fabs(maxDepth));
    
    // 메쉬의 최대 직경을 계산합니다.
    meshWidth = max(maxX, maxZ) * 2.0f;
}
 
 
void QuadTreeClass::CreateTreeNode(NodeType* node, float positionX, float positionZ, float width, ID3D11Device* device)
{
    // 노드의 위치와 크기를 저장한다.
    node->positionX = positionX;
    node->positionZ = positionZ;
    node->width = width;
 
    // 노드의 삼각형 수를 0으로 초기화합니다.
    node->triangleCount = 0;
 
    //정점 및 인덱스 버퍼를 null로 초기화합니다.
    node->vertexBuffer = 0;
    node->indexBuffer = 0;
 
    // Initialize the vertex array to null.
    node->vertexArray = 0;
    
    // 이 노드의 자식 노드를 null로 초기화합니다.
    node->nodes[0] = 0;
    node->nodes[1] = 0;
    node->nodes[2] = 0;
    node->nodes[3] = 0;
 
    // 이 노드 안에 있는 삼각형 수를 센다.
    int numTriangles = CountTriangles(positionX, positionZ, width);
 
    // 사례 1: 이 노드에 삼각형이 없으면 비어있는 상태로 돌아가서 처리할 필요가 없습니다.
    if(numTriangles == 0)
    {
        return;
    }
 
    // 사례 2: 이 노드에 너무 많은 삼각형이 있는 경우 4 개의 동일한 크기의 더 작은 트리 노드로 분할합니다.
    if(numTriangles > MAX_TRIANGLES)
    {
        for(int i=0; i<4; i++)
        {
            // 새로운 자식 노드에 대한 위치 오프셋을 계산합니다.
            float offsetX = (((i % 2) < 1) ? -1.0f : 1.0f) * (width / 4.0f);
            float offsetZ = (((i % 4) < 2) ? -1.0f : 1.0f) * (width / 4.0f);
 
            // 새 노드에 삼각형이 있는지 확인합니다.
            int count = CountTriangles((positionX + offsetX), (positionZ + offsetZ), (width / 2.0f));
            if(count > 0)
            {
                // 이 새 노드가있는 삼각형이있는 경우 자식 노드를 만듭니다.
                node->nodes[i] = new NodeType;
 
                // 이제이 새 자식 노드에서 시작하는 트리를 확장합니다.
                CreateTreeNode(node->nodes[i], (positionX + offsetX), (positionZ + offsetZ), (width / 2.0f), device);
            }
        }
        return;
    }
 
    // 사례 3: 이 노드가 비어 있지않고 그 노드의 삼각형 수가 최대 값보다 작으면 
    // 이 노드는 트리의 맨 아래에 있으므로 저장할 삼각형 목록을 만듭니다.
    node->triangleCount = numTriangles;
 
    // 정점의 수를 계산합니다.
    int vertexCount = numTriangles * 3;
 
    // 정점 배열을 만듭니다.
    VertexType* vertices = new VertexType[vertexCount];
 
    // 인덱스 배열을 만듭니다.
    unsigned long* indices = new unsigned long[vertexCount];
 
    // 정점 배열을 만듭니다.
    node->vertexArray = new VectorType[vertexCount];
    
    // 이 새로운 정점 및 인덱스 배열의 인덱스를 초기화합니다.
    int index = 0;
 
    // 정점 목록의 모든 삼각형을 살펴 봅니다.
    int vertexIndex = 0;
    for(int i=0; i<m_triangleCount; i++)
    {
        // 삼각형이이 노드 안에 있으면 꼭지점 배열에 추가합니다.
        if(IsTriangleContained(i, positionX, positionZ, width) == true)
        {
            // 지형 버텍스 목록에 인덱스를 계산합니다.
            vertexIndex = i * 3;
 
            // 정점 목록에서 이 삼각형의 세 꼭지점을 가져옵니다.
            vertices[index].position = m_vertexList[vertexIndex].position;
            vertices[index].texture = m_vertexList[vertexIndex].texture;
            vertices[index].normal = m_vertexList[vertexIndex].normal;
            indices[index] = index;
 
            // 또한 정점 위치 정보를 노드 정점 배열에 저장합니다.
            node->vertexArray[index].x = m_vertexList[vertexIndex].position.x;
            node->vertexArray[index].y = m_vertexList[vertexIndex].position.y;
            node->vertexArray[index].z = m_vertexList[vertexIndex].position.z;
 
            // 인덱스 값을 증가합니다.
            index++;
 
            vertexIndex++;
 
            // 다음 요점에 대해서도 똑같이하십시오.
            vertices[index].position = m_vertexList[vertexIndex].position;
            vertices[index].texture = m_vertexList[vertexIndex].texture;
            vertices[index].normal = m_vertexList[vertexIndex].normal;
            indices[index] = index;
            node->vertexArray[index].x = m_vertexList[vertexIndex].position.x;
            node->vertexArray[index].y = m_vertexList[vertexIndex].position.y;
            node->vertexArray[index].z = m_vertexList[vertexIndex].position.z;
            index++;
 
            vertexIndex++;
            
            // 다음 요점에 대해서도 똑같이하십시오.
            vertices[index].position = m_vertexList[vertexIndex].position;
            vertices[index].texture = m_vertexList[vertexIndex].texture;
            vertices[index].normal = m_vertexList[vertexIndex].normal;
            indices[index] = index;
            node->vertexArray[index].x = m_vertexList[vertexIndex].position.x;
            node->vertexArray[index].y = m_vertexList[vertexIndex].position.y;
            node->vertexArray[index].z = m_vertexList[vertexIndex].position.z;
            index++;
        }
    }
 
    // 정점 버퍼의 구조체를 설정합니다.
    D3D11_BUFFER_DESC vertexBufferDesc;
    vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    vertexBufferDesc.ByteWidth = sizeof(VertexType) * vertexCount;
    vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = 0;
    vertexBufferDesc.MiscFlags = 0;
    vertexBufferDesc.StructureByteStride = 0;
 
    // subresource 구조에 정점 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA vertexData;
    vertexData.pSysMem = vertices;
    vertexData.SysMemPitch = 0;
    vertexData.SysMemSlicePitch = 0;
 
    // 이제 마침내 정점 버퍼를 만듭니다.
    device->CreateBuffer(&vertexBufferDesc, &vertexData, &node->vertexBuffer);
 
    // 인덱스 버퍼의 설명을 설정합니다.
    D3D11_BUFFER_DESC indexBufferDesc;
    indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(unsigned long) * vertexCount;
    indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;
    indexBufferDesc.StructureByteStride = 0;
 
    // 하위 리소스 구조에 인덱스 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA indexData;
    indexData.pSysMem = indices;
    indexData.SysMemPitch = 0;
    indexData.SysMemSlicePitch = 0;
 
    // 인덱스 버퍼를 만듭니다.
    device->CreateBuffer(&indexBufferDesc, &indexData, &node->indexBuffer);
 
    // 이제 노드의 버퍼에 데이터가 저장되므로 꼭지점과 인덱스 배열을 해제합니다.
    delete [] vertices;
    vertices = 0;
 
    delete [] indices;
    indices = 0;
}
 
 
int QuadTreeClass::CountTriangles(float positionX, float positionZ, float width)
{
    // 카운트를 0으로 초기화한다.
    int count = 0;
 
    // 전체 메쉬의 모든 삼각형을 살펴보고 어떤 노드가 이 노드 안에 있어야 하는지 확인합니다.
    for(int i=0; i<m_triangleCount; i++)
    {
        // 삼각형이 노드 안에 있으면 1씩 증가시킵니다.
        if(IsTriangleContained(i, positionX, positionZ, width) == true)
        {
            count++;
        }
    }
 
    return count;
}
 
 
bool QuadTreeClass::IsTriangleContained(int index, float positionX, float positionZ, float width)
{
    // 이 노드의 반경을 계산합니다.
    float radius = width / 2.0f;
 
    // 인덱스를 정점 목록으로 가져옵니다.
    int vertexIndex = index * 3;
 
    // 정점 목록에서 이 삼각형의 세 꼭지점을 가져옵니다.
    float x1 = m_vertexList[vertexIndex].position.x;
    float z1 = m_vertexList[vertexIndex].position.z;
    vertexIndex++;
    
    float x2 = m_vertexList[vertexIndex].position.x;
    float z2 = m_vertexList[vertexIndex].position.z;
    vertexIndex++;
 
    float x3 = m_vertexList[vertexIndex].position.x;
    float z3 = m_vertexList[vertexIndex].position.z;
 
    // 삼각형의 x 좌표의 최소값이 노드 안에 있는지 확인하십시오.
    float minimumX = min(x1, min(x2, x3));
    if(minimumX > (positionX + radius))
    {
        return false;
    }
 
    // 삼각형의 x 좌표의 최대 값이 노드 안에 있는지 확인하십시오.
    float maximumX = max(x1, max(x2, x3));
    if(maximumX < (positionX - radius))
    {
        return false;
    }
 
    // 삼각형의 z 좌표의 최소값이 노드 안에 있는지 확인하십시오.
    float minimumZ = min(z1, min(z2, z3));
    if(minimumZ > (positionZ + radius))
    {
        return false;
    }
 
    // 삼각형의 z 좌표의 최대 값이 노드 안에 있는지 확인하십시오.
    float maximumZ = max(z1, max(z2, z3));
    if(maximumZ < (positionZ - radius))
    {
        return false;
    }
 
    return true;
}
 
 
void QuadTreeClass::ReleaseNode(NodeType* node)
{
    // 재귀적으로 트리 아래로 내려와 맨 아래 노드를 먼저 놓습니다.
    for(int i=0; i<4; i++)
    {
        if(node->nodes[i] != 0)
        {
            ReleaseNode(node->nodes[i]);
        }
    }
 
    // 이 노드의 버텍스 버퍼를 해제한다.
    if(node->vertexBuffer)
    {
        node->vertexBuffer->Release();
        node->vertexBuffer = 0;
    }
 
    // 이 노드의 인덱스 버퍼를 해제합니다.
    if(node->indexBuffer)
    {
        node->indexBuffer->Release();
        node->indexBuffer = 0;
    }
 
    // 이 노드의 정점 배열을 해제합니다.
    if(node->vertexArray)
    {
        delete [] node->vertexArray;
        node->vertexArray = 0;
    }
 
    // 4개의 자식 노드를 해제합니다.
    for(int i=0; i<4; i++)
    {
        if(node->nodes[i])
        {
            delete node->nodes[i];
            node->nodes[i] = 0;
        }
    }
}
 
 
void QuadTreeClass::RenderNode(NodeType* node, FrustumClass* frustum, ID3D11DeviceContext* deviceContext,
                               TerrainShaderClass* shader)
{
    // 노드를 볼 수 있는지, 높이는 쿼드 트리에서 중요하지 않은지 확인합니다.
    // 보이지 않는 경우 자식 중 하나도 트리 아래로 계속 진행할 수 없으며 속도가 증가한 곳입니다.
    if(!frustum->CheckCube(node->positionX, 0.0f, node->positionZ, (node->width / 2.0f)))
    {
        return;
    }
 
    // 볼 수 있는 경우 네 개의 자식 노드를 모두 확인하여 볼 ​​수 있는지 확인합니다.
    int count = 0;
    for(int i=0; i<4; i++)
    {
        if(node->nodes[i] != 0)
        {
            count++;
            RenderNode(node->nodes[i], frustum, deviceContext, shader);
        }
    }
 
    // 자식 노드가 있는 경우 부모 노드가 렌더링 할 삼각형을 포함하지 않으므로 계속할 필요가 없습니다.
    if(count != 0)
    {
        return;
    }
 
    // 그렇지 않으면 이 노드를 볼 수 있고 그 안에 삼각형이 있으면 이 삼각형을 렌더링합니다.
 
    // 정점 버퍼 보폭 및 오프셋을 설정합니다.
    unsigned int stride = sizeof(VertexType); 
    unsigned int offset = 0;
 
    // 렌더링 할 수 있도록 입력 어셈블러에서 정점 버퍼를 활성으로 설정합니다.
    deviceContext->IASetVertexBuffers(0, 1, &node->vertexBuffer, &stride, &offset);
 
    // 렌더링 할 수 있도록 입력 어셈블러에서 인덱스 버퍼를 활성으로 설정합니다.
    deviceContext->IASetIndexBuffer(node->indexBuffer, DXGI_FORMAT_R32_UINT, 0);
 
    // 이 꼭지점 버퍼에서 렌더링 되어야 하는 프리미티브 유형을 설정합니다. 이 경우에는 삼각형입니다.
    deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 
    // 이 노드에서 인덱스의 수를 결정합니다.
    int indexCount = node->triangleCount * 3;
 
    // 지형 셰이더를 호출하여 이 노드의 다각형을 렌더링합니다.
    shader->RenderShader(deviceContext, indexCount);
 
    // 이 프레임 동안 렌더링 된 폴리곤의 수를 늘립니다.
    m_drawCount += node->triangleCount;
}
 
 
bool QuadTreeClass::GetHeightAtPosition(float positionX, float positionZ, float& height)
{
    float meshMinX = m_parentNode->positionX - (m_parentNode->width / 2.0f);
    float meshMaxX = m_parentNode->positionX + (m_parentNode->width / 2.0f);
 
    float meshMinZ = m_parentNode->positionZ - (m_parentNode->width / 2.0f);
    float meshMaxZ = m_parentNode->positionZ + (m_parentNode->width / 2.0f);
 
    // 좌표가 실제로 다각형 위에 있는지 확인하십시오.
    if((positionX < meshMinX) || (positionX > meshMaxX) || (positionZ < meshMinZ) || (positionZ > meshMaxZ))
    {
        return false;
    }
 
    // 이 위치에 대한 다각형을 포함하는 노드를 찾습니다.
    FindNode(m_parentNode, positionX, positionZ, height);
    
    return true;
}
 
 
void QuadTreeClass::FindNode(NodeType* node, float x, float z, float& height)
{
    // 이 노드의 크기를 계산합니다.
    float xMin = node->positionX - (node->width / 2.0f);
    float xMax = node->positionX + (node->width / 2.0f);
 
    float zMin = node->positionZ - (node->width / 2.0f);
    float zMax = node->positionZ + (node->width / 2.0f);
 
    // x 및 z 좌표가이 노드에 있는지 확인합니다. 그렇지 않으면 트리의이 부분을 탐색하지 않습니다.
    if((x < xMin) || (x > xMax) || (z < zMin) || (z > zMax))
    {
        return;
    }
 
    // 좌표가 이 노드에 있으면 자식 노드가 있는지 먼저 확인합니다.
    int count = 0;
 
    for(int i=0; i<4; i++)
    {
        if(node->nodes[i] != 0)
        {
            count++;
            FindNode(node->nodes[i], x, z, height);
        }
    }
 
    // 자식 노드가 있는 경우 폴리곤이 자식중 하나에 있으므로 노드가 반환됩니다.
    if(count > 0)
    {
        return;
    }
 
    float vertex1[3] = { 0.0f, 0.0f, 0.0f };
    float vertex2[3] = { 0.0f, 0.0f, 0.0f };
    float vertex3[3] = { 0.0f, 0.0f, 0.0f };
 
    // 자식이 없으면 다각형이이 노드에 있어야합니다. 이 노드의 모든 다각형을 확인하여 찾습니다.
    // 우리가 찾고있는 폴리곤의 높이.
    for(int i=0; i<node->triangleCount; i++)
    {
        int index = i * 3;
        vertex1[0] = node->vertexArray[index].x;
        vertex1[1] = node->vertexArray[index].y;
        vertex1[2] = node->vertexArray[index].z;
 
        index++;
        vertex2[0] = node->vertexArray[index].x;
        vertex2[1] = node->vertexArray[index].y;
        vertex2[2] = node->vertexArray[index].z;
 
        index++;
        vertex3[0] = node->vertexArray[index].x;
        vertex3[1] = node->vertexArray[index].y;
        vertex3[2] = node->vertexArray[index].z;
 
        // 이것이 우리가 찾고있는 폴리곤인지 확인합니다.
        // 삼각형 인 경우 함수를 종료하고 높이가 호출 함수에 반환됩니다.
        if(CheckHeightOfTriangle(x, z, height, vertex1, vertex2, vertex3))
        {
            return;
        }
    }
}
 
 
bool QuadTreeClass::CheckHeightOfTriangle(float x, float z, float& height, float v0[3], float v1[3], float v2[3])
{
    float startVector[3] = { 0.0f, 0.0f, 0.0f };
    float directionVector[3] = { 0.0f, 0.0f, 0.0f };
    float edge1[3] = { 0.0f, 0.0f, 0.0f };
    float edge2[3] = { 0.0f, 0.0f, 0.0f };
    float normal[3] = { 0.0f, 0.0f, 0.0f };
    float Q[3] = { 0.0f, 0.0f, 0.0f };
    float e1[3] = { 0.0f, 0.0f, 0.0f };
    float e2[3] = { 0.0f, 0.0f, 0.0f };
    float e3[3] = { 0.0f, 0.0f, 0.0f };
    float edgeNormal[3] = { 0.0f, 0.0f, 0.0f };
    float temp[3] = { 0.0f, 0.0f, 0.0f };
    
    // 전송중인 광선의 시작 위치.
    startVector[0] = x;
    startVector[1] = 0.0f;
    startVector[2] = z;
 
    // 광선이 투영되는 방향입니다.
    directionVector[0] =  0.0f;
    directionVector[1] = -1.0f;
    directionVector[2] =  0.0f;
 
    // 주어진 세 점으로부터 두 모서리를 계산합니다.
    edge1[0] = v1[0] - v0[0];
    edge1[1] = v1[1] - v0[1];
    edge1[2] = v1[2] - v0[2];
 
    edge2[0] = v2[0] - v0[0];
    edge2[1] = v2[1] - v0[1];
    edge2[2] = v2[2] - v0[2];
 
    // 두 모서리에서 삼각형의 법선을 계산합니다.
    normal[0] = (edge1[1] * edge2[2]) - (edge1[2] * edge2[1]);
    normal[1] = (edge1[2] * edge2[0]) - (edge1[0] * edge2[2]);
    normal[2] = (edge1[0] * edge2[1]) - (edge1[1] * edge2[0]);
 
    float magnitude = (float)sqrt((normal[0] * normal[0]) + (normal[1] * normal[1]) + (normal[2] * normal[2]));
    normal[0] = normal[0] / magnitude;
    normal[1] = normal[1] / magnitude;
    normal[2] = normal[2] / magnitude;
 
    // 원점에서 평면까지의 거리를 구합니다.
    float D = ((-normal[0] * v0[0]) + (-normal[1] * v0[1]) + (-normal[2] * v0[2]));
 
    // 방정식의 분모를 구하십시오.
    float denominator = ((normal[0] * directionVector[0]) + (normal[1] * directionVector[1]) + 
                         (normal[2] * directionVector[2]));
 
    // 결과가 0에 너무 가까워지지 않도록하여 0으로 나누는 것을 방지하십시오.
    if(fabs(denominator) < 0.0001f)
    {
        return false;
    }
 
    // 방정식의 분자를 구합니다.
    float numerator = -1.0f * (((normal[0] * startVector[0]) + (normal[1] * startVector[1]) +
                               (normal[2] * startVector[2])) + D);
 
    // 삼각형과 교차하는 위치를 계산합니다.
    float t = numerator / denominator;
 
    // 교차 벡터를 찾습니다.
    Q[0] = startVector[0] + (directionVector[0] * t);
    Q[1] = startVector[1] + (directionVector[1] * t);
    Q[2] = startVector[2] + (directionVector[2] * t);
 
    // 삼각형의 세 모서리를 찾습니다.
    e1[0] = v1[0] - v0[0];
    e1[1] = v1[1] - v0[1];
    e1[2] = v1[2] - v0[2];
 
    e2[0] = v2[0] - v1[0];
    e2[1] = v2[1] - v1[1];
    e2[2] = v2[2] - v1[2];
 
    e3[0] = v0[0] - v2[0];
    e3[1] = v0[1] - v2[1];
    e3[2] = v0[2] - v2[2];
 
    // 첫 번째 가장자리의 법선을 계산합니다.
    edgeNormal[0] = (e1[1] * normal[2]) - (e1[2] * normal[1]);
    edgeNormal[1] = (e1[2] * normal[0]) - (e1[0] * normal[2]);
    edgeNormal[2] = (e1[0] * normal[1]) - (e1[1] * normal[0]);
 
    // 행렬이 내부, 외부 또는 직접 가장자리에 있는지 결정하기 위해 행렬식을 계산합니다.
    temp[0] = Q[0] - v0[0];
    temp[1] = Q[1] - v0[1];
    temp[2] = Q[2] - v0[2];
 
    float determinant = ((edgeNormal[0] * temp[0]) + (edgeNormal[1] * temp[1]) + (edgeNormal[2] * temp[2]));
 
    // 외부에 있는지 확인하십시오.
    if(determinant > 0.001f)
    {
        return false;
    }
 
    // 두 번째 가장자리의 법선을 계산합니다.
    edgeNormal[0] = (e2[1] * normal[2]) - (e2[2] * normal[1]);
    edgeNormal[1] = (e2[2] * normal[0]) - (e2[0] * normal[2]);
    edgeNormal[2] = (e2[0] * normal[1]) - (e2[1] * normal[0]);
 
    // 행렬이 내부, 외부 또는 직접 가장자리에 있는지 결정하기 위해 행렬식을 계산합니다.
    temp[0] = Q[0] - v1[0];
    temp[1] = Q[1] - v1[1];
    temp[2] = Q[2] - v1[2];
 
    determinant = ((edgeNormal[0] * temp[0]) + (edgeNormal[1] * temp[1]) + (edgeNormal[2] * temp[2]));
 
    // 외부에 있는지 확인하십시오.
    if(determinant > 0.001f)
    {
        return false;
    }
 
    // 세 번째 가장자리의 법선을 계산합니다.
    edgeNormal[0] = (e3[1] * normal[2]) - (e3[2] * normal[1]);
    edgeNormal[1] = (e3[2] * normal[0]) - (e3[0] * normal[2]);
    edgeNormal[2] = (e3[0] * normal[1]) - (e3[1] * normal[0]);
 
    // 행렬이 내부, 외부 또는 직접 가장자리에 있는지 결정하기 위해 행렬식을 계산합니다.
    temp[0] = Q[0] - v2[0];
    temp[1] = Q[1] - v2[1];
    temp[2] = Q[2] - v2[2];
 
    determinant = ((edgeNormal[0] * temp[0]) + (edgeNormal[1] * temp[1]) + (edgeNormal[2] * temp[2]));
 
    // 외부에 있는지 확인하십시오.
    if(determinant > 0.001f)
    {
        return false;
    }
 
    // 이제 우리 높이가 있습니다.
    height = Q[1];
 
    return true;
}

ApplicationClass 헤더는 이전 듀토리얼 이후 변경되지 않았으므로 생략합니다.

Applicationclass.cpp

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506

#include "stdafx.h" #include "inputclass.h" #include "d3dclass.h" #include "cameraclass.h" #include "terrainclass.h" #include "timerclass.h" #include "positionclass.h" #include "fpsclass.h" #include "cpuclass.h" #include "fontshaderclass.h" #include "textclass.h" #include "terrainshaderclass.h" #include "lightclass.h" #include "frustumclass.h" #include "quadtreeclass.h" #include "ApplicationClass.h"     ApplicationClass::ApplicationClass() { }     ApplicationClass::ApplicationClass(const ApplicationClass& other) { }     ApplicationClass::~ApplicationClass() { }     bool ApplicationClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight) {     // 입력 개체를 생성합니다.     m_Input = new InputClass;     if(!m_Input)     {         return false;     }       // 입력 개체를 초기화 합니다.     bool result = m_Input->Initialize(hinstance, hwnd, screenWidth, screenHeight);     if(!result)     {         MessageBox(hwnd, L"Could not initialize the input object.", L"Error", MB_OK);         return false;     }       // Direct3D 개체를 생성합니다.     m_Direct3D = new D3DClass;     if(!m_Direct3D)     {         return false;     }       // Direct3D 개체를 초기화 합니다.     result = m_Direct3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);     if(!result)     {         MessageBox(hwnd, L"Could not initialize DirectX 11.", L"Error", MB_OK);         return false;     }       // 카메라 객체를 생성합니다.     m_Camera = new CameraClass;     if(!m_Camera)     {         return false;     }       // 2D 사용자 인터페이스 렌더링을 위해 카메라로 기본 뷰 행렬을 초기화 합니다.     XMMATRIX baseViewMatrix;     m_Camera->SetPosition(XMFLOAT3(0.0f, 0.0f, -1.0f));     m_Camera->Render();     m_Camera->GetViewMatrix(baseViewMatrix);       // 카메라의 초기 위치를 설정합니다.     XMFLOAT3 camera = XMFLOAT3(50.0f, 2.0f, -7.0f);     m_Camera->SetPosition(camera);       // 지형 객체를 생성합니다.     m_Terrain = new TerrainClass;     if(!m_Terrain)     {         return false;     }       // 지형 객체를 초기화 합니다.     result = m_Terrain->Initialize(m_Direct3D->GetDevice(), "../Dx11Terrain_06/data/heightmap01.bmp",  L"../Dx11Terrain_06/data/dirt01.dds");     if(!result)     {         MessageBox(hwnd, L"Could not initialize the terrain object.", L"Error", MB_OK);         return false;     }       // 타이머 객체를 생성합니다.     m_Timer = new TimerClass;     if(!m_Timer)     {         return false;     }       // 타이머 객체를 초기화 합니다.     result = m_Timer->Initialize();     if(!result)     {         MessageBox(hwnd, L"Could not initialize the timer object.", L"Error", MB_OK);         return false;     }       // 위치 개체를 생성합니다.     m_Position = new PositionClass;     if(!m_Position)     {         return false;     }       // 뷰어의 초기 위치를 초기 카메라 위치와 동일하게 설정합니다.     m_Position->SetPosition(camera);       // fps 객체를 생성합니다.     m_Fps = new FpsClass;     if(!m_Fps)     {         return false;     }       // fps 객체를 초기화 합니다.     m_Fps->Initialize();       // cpu 객체를 생성합니다.     m_Cpu = new CpuClass;     if(!m_Cpu)     {         return false;     }       // cpu 객체를 초기화 합니다.     m_Cpu->Initialize();       // 폰트 셰이더 객체를 생성합니다.     m_FontShader = new FontShaderClass;     if(!m_FontShader)     {         return false;     }       // 폰트 셰이더 객체를 초기화 합니다.     result = m_FontShader->Initialize(m_Direct3D->GetDevice(), hwnd);     if(!result)     {         MessageBox(hwnd, L"Could not initialize the font shader object.", L"Error", MB_OK);         return false;     }       // 텍스트 객체를 생성합니다.     m_Text = new TextClass;     if(!m_Text)     {         return false;     }       // 텍스트 객체를 초기화 합니다.     result = m_Text->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), hwnd, screenWidth, screenHeight,  baseViewMatrix);     if(!result)     {         MessageBox(hwnd, L"Could not initialize the text object.", L"Error", MB_OK);         return false;     }       // 비디오 카드 정보를 가져옵니다.     char videoCard[128] = { 0, };     int videoMemory = 0;     m_Direct3D->GetVideoCardInfo(videoCard, videoMemory);       // 텍스트 객체에 비디오 카드 정보를 설정합니다.     result = m_Text->SetVideoCardInfo(videoCard, videoMemory, m_Direct3D->GetDeviceContext());     if(!result)     {         MessageBox(hwnd, L"Could not set video card info in the text object.", L"Error", MB_OK);         return false;     }       // 지형 쉐이더 객체를 생성합니다.     m_TerrainShader = new TerrainShaderClass;     if(!m_TerrainShader)     {         return false;     }       // 지형 쉐이더 객체를 초기화 합니다.     result = m_TerrainShader->Initialize(m_Direct3D->GetDevice(), hwnd);     if(!result)     {         MessageBox(hwnd, L"Could not initialize the terrain shader object.", L"Error", MB_OK);         return false;     }       // 조명 객체를 생성합니다.     m_Light = new LightClass;     if(!m_Light)     {         return false;     }       // 조명 객체를 초기화 합니다.     m_Light->SetAmbientColor(XMFLOAT4(0.05f, 0.05f, 0.05f, 1.0f));     m_Light->SetDiffuseColor(XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f));     m_Light->SetDirection(XMFLOAT3(-0.5f, -1.0f, 0.0f));       // frustum 객체를 생성합니다.     m_Frustum = new FrustumClass;     if(!m_Frustum)     {         return false;     }       // 쿼드 트리 객체를 생성합니다.     m_QuadTree = new QuadTreeClass;     if(!m_QuadTree)     {         return false;     }       // 쿼드 트리 객체를 초기화 합니다.     result = m_QuadTree->Initialize(m_Terrain, m_Direct3D->GetDevice());     if(!result)     {         MessageBox(hwnd, L"Could not initialize the quad tree object.", L"Error", MB_OK);         return false;     }          return true; }     void ApplicationClass::Shutdown() {     // 쿼드 트리 객체를 해제합니다.     if(m_QuadTree)     {         m_QuadTree->Shutdown();         delete m_QuadTree;         m_QuadTree = 0;     }       // frustum 객체를 해제합니다.     if(m_Frustum)     {         delete m_Frustum;         m_Frustum = 0;     }       // 조명 객체를 해제합니다.     if(m_Light)     {         delete m_Light;         m_Light = 0;     }       // 지형 쉐이더 객체를 해제합니다.     if(m_TerrainShader)     {         m_TerrainShader->Shutdown();         delete m_TerrainShader;         m_TerrainShader = 0;     }       // 텍스트 객체를 해제합니다.     if(m_Text)     {         m_Text->Shutdown();         delete m_Text;         m_Text = 0;     }       // 폰트 쉐이더 객체를 해제합니다..     if(m_FontShader)     {         m_FontShader->Shutdown();         delete m_FontShader;         m_FontShader = 0;     }       // cpu 객체를 해제합니다.     if(m_Cpu)     {         m_Cpu->Shutdown();         delete m_Cpu;         m_Cpu = 0;     }       // fps 객체를 해제합니다.     if(m_Fps)     {         delete m_Fps;         m_Fps = 0;     }       // 위치 객체를 해제합니다.     if(m_Position)     {         delete m_Position;         m_Position = 0;     }       // 타이머 객체를 해제합니다.     if(m_Timer)     {         delete m_Timer;         m_Timer = 0;     }       // 지형 객체를 해제합니다.     if(m_Terrain)     {         m_Terrain->Shutdown();         delete m_Terrain;         m_Terrain = 0;     }       // 카메라 객체를 해제합니다.     if(m_Camera)     {         delete m_Camera;         m_Camera = 0;     }       // D3D 객체를 해제합니다.     if (m_Direct3D)     {         m_Direct3D->Shutdown();         delete m_Direct3D;         m_Direct3D = 0;     }       // 입력 객체를 해제합니다.     if(m_Input)     {         m_Input->Shutdown();         delete m_Input;         m_Input = 0;     } }     bool ApplicationClass::Frame() {     // 사용자 입력을 읽습니다.     bool result = m_Input->Frame();     if(!result)     {         return false;     }          // 사용자가 ESC를 눌렀을 때 응용 프로그램을 종료 할 것인지 확인합니다.     if(m_Input->IsEscapePressed() == true)     {         return false;     }       // 시스템 통계를 업데이트 합니다.     m_Timer->Frame();     m_Fps->Frame();     m_Cpu->Frame();       // 텍스트 개체에서 FPS 값을 업데이트 합니다.     result = m_Text->SetFps(m_Fps->GetFps(), m_Direct3D->GetDeviceContext());     if(!result)     {         return false;     }          // 텍스트 개체의 CPU 사용값을 업데이트 합니다.     result = m_Text->SetCpu(m_Cpu->GetCpuPercentage(), m_Direct3D->GetDeviceContext());     if(!result)     {         return false;     }       // 프레임 입력 처리를 수행합니다.     result = HandleInput(m_Timer->GetTime());     if(!result)     {         return false;     }       // 카메라의 현재 위치를 가져옵니다.     XMFLOAT3 position = m_Camera->GetPosition();       // 주어진 카메라 위치 바로 아래에있는 삼각형의 높이를 가져옵니다.     float height = 0.0f;     if(m_QuadTree->GetHeightAtPosition(position.x, position.z, height))     {         // 카메라 아래에 삼각형이 있는 경우 카메라를 두 개 단위로 배치합니다.         m_Camera->SetPosition(XMFLOAT3(position.x, height + 2.0f, position.z));     }       // 그래픽을 렌더링 합니다.     return RenderGraphics(); }     bool ApplicationClass::HandleInput(float frameTime) {     XMFLOAT3 pos = XMFLOAT3(0.0f, 0.0f, 0.0f);     XMFLOAT3 rot = XMFLOAT3(0.0f, 0.0f, 0.0f);         // 갱신된 위치를 계산하기 위한 프레임 시간을 설정합니다.     m_Position->SetFrameTime(frameTime);       // 입력을 처리합니다.     m_Position->TurnLeft(m_Input->IsLeftPressed());     m_Position->TurnRight(m_Input->IsRightPressed());     m_Position->MoveForward(m_Input->IsUpPressed());     m_Position->MoveBackward(m_Input->IsDownPressed());     m_Position->MoveUpward(m_Input->IsAPressed());     m_Position->MoveDownward(m_Input->IsZPressed());     m_Position->LookUpward(m_Input->IsPgUpPressed());     m_Position->LookDownward(m_Input->IsPgDownPressed());          // 시점 위치 / 회전을 가져옵니다.     m_Position->GetPosition(pos);     m_Position->GetRotation(rot);       // 카메라의 위치를 ​​설정합니다.     m_Camera->SetPosition(pos);     m_Camera->SetRotation(rot);       // 텍스트 개체의 위치 값을 업데이트 합니다.     if(!m_Text->SetCameraPosition(pos, m_Direct3D->GetDeviceContext()))     {         return false;     }       // 텍스트 객체의 회전 값을 업데이트 합니다.     if(!m_Text->SetCameraRotation(rot, m_Direct3D->GetDeviceContext()))     {         return false;     }       return true; }     bool ApplicationClass::RenderGraphics() {     XMMATRIX worldMatrix, viewMatrix, projectionMatrix, orthoMatrix;       // 장면을 지웁니다.     m_Direct3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);       // 카메라의 위치에 따라 뷰 행렬을 생성합니다.     m_Camera->Render();       // 카메라 및 Direct3D 객체에서 월드, 뷰, 투영 및 ortho 행렬을 가져옵니다.     m_Direct3D->GetWorldMatrix(worldMatrix);     m_Camera->GetViewMatrix(viewMatrix);     m_Direct3D->GetProjectionMatrix(projectionMatrix);     m_Direct3D->GetOrthoMatrix(orthoMatrix);       // 절두체를 만듭니다.     m_Frustum->ConstructFrustum(SCREEN_DEPTH, projectionMatrix, viewMatrix);       // 렌더링에 사용할 터 레인 셰이더 매개 변수를 설정합니다.     if(!m_TerrainShader->SetShaderParameters(m_Direct3D->GetDeviceContext(), worldMatrix, viewMatrix, projectionMatrix,  m_Light->GetAmbientColor(), m_Light->GetDiffuseColor(), m_Light->GetDirection(), m_Terrain->GetTexture()))     {         return false;     }       // 쿼드 트리 및 지형 셰이더를 사용하여 지형을 렌더링합니다.     m_QuadTree->Render(m_Frustum, m_Direct3D->GetDeviceContext(), m_TerrainShader);       // 일부가 제거 된 이후에 렌더링 된 터 레인 삼각형의 수를 설정합니다.     if(!m_Text->SetRenderCount(m_QuadTree->GetDrawCount(), m_Direct3D->GetDeviceContext()))     {         return false;     }       // 모든 2D 렌더링을 시작하려면 Z 버퍼를 끕니다.     m_Direct3D->TurnZBufferOff();              // 텍스트를 렌더링하기 전에 알파 블렌딩을 켭니다.     m_Direct3D->TurnOnAlphaBlending();       // 텍스트 사용자 인터페이스 요소를 렌더링 합니다.     if(!m_Text->Render(m_Direct3D->GetDeviceContext(), m_FontShader, worldMatrix, orthoMatrix))     {         return false;     }       // 텍스트를 렌더링 한 후 알파 블렌딩을 끕니다.     m_Direct3D->TurnOffAlphaBlending();       // 모든 2D 렌더링이 완료되었으므로 Z 버퍼를 다시 켭니다.     m_Direct3D->TurnZBufferOn();       // 렌더링 된 장면을 화면에 표시합니다.     m_Direct3D->EndScene();       return true; } Colored by Color Scripter

cs

출력 화면

마치면서

지형의 정확한 높이를 계산하여 얻어냄으로써 카메라를 항상 지형 바로 위에 오도록 배치할 수 있게 되었습니다.

연습문제

1. 프로그램을 컴파일하고 실행하십시오. 지형을 따라 이동하면 높이가 자동으로 변화하는 높이에 맞게 조정됩니다. 종료하려면 ESC 키를 누릅니다.

2. 지형 위로부터 설정된 카메라의 높이 값을 변경하십시오.

3. 쿼드 트리의 정보를 기반으로 높이를 조정하면서 지형 주위를 무작위로 움직이는 물체를 배치해보세요.

소스코드

소스코드 : Dx11Terrain_06.zip