Thinking Different :: [DirectX11] Tutorial 47

[DirectX11] Tutorial 47 - 피킹

DirectX 11/Basic2018. 1. 26. 18:04

뷰어
댓글로
이전글
다음글

Tutorial 47 - 피킹

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

대부분의 3D 응용 프로그램에서 사용자는 마우스로 화면을 클릭하여 장면의 3D 객체 중 하나를 선택하거나 상호 작용해야합니다. 이 프로세스는 일반적으로 선택 또는 피킹이라고 합니다. 이 튜토리얼에서는 DirectX 11을 사용하여 피킹을 구현하는 방법에 대해 설명합니다.

피킹 프로세스에는 2D 마우스 좌표 위치를 월드 공간에 있는 벡터로 변환하는 작업이 포함됩니다. 그런 다음 해당 벡터가 모든 보이는 3D 객체와의 교차 검사에 사용됩니다. 일단 3D 오브젝트가 결정되면, 그 테스트는 그 3D 오브젝트상에서 어떤 폴리곤이 선택되었는지를 정확하게 결정할 수 있습니다.

이 튜토리얼에서는 단일 구를 사용하고 사용자가 마우스 왼쪽 버튼을 누를 때마다 구가 선택되었는지 아닌지를 수행합니다.

비트맵 객체는 사용자가 화면에서 클릭하는 위치를 알 수 있도록 마우스 커서를 그리는 데 사용됩니다. 또한 m_beginCheck 변수는 화면을 클릭했는지 여부를 결정하는데 사용됩니다.

Applicationclass.h

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
#pragma once
 
/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = false;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;
 
 
class D3DClass;
class InputClass;
class CameraClass;
class ModelClass;
class TextureShaderClass;
class BitmapClass;
class LightShaderClass;
class LightClass;
class TextClass;
 
 
class ApplicationClass
{
public:
    ApplicationClass();
    ApplicationClass(const ApplicationClass&);
    ~ApplicationClass();
 
    bool Initialize(HINSTANCE, HWND, int, int);
    void Shutdown();
    bool Frame();
 
private:
    bool HandleInput();
    bool Render();
    void TestIntersection(int, int);
    bool RaySphereIntersect(XMFLOAT3, XMFLOAT3, float);
 
private:
    InputClass* m_Input = nullptr;
    D3DClass* m_D3D = nullptr;
    CameraClass* m_Camera = nullptr;
    ModelClass* m_Model = nullptr;
    TextureShaderClass* m_TextureShader = nullptr;
    LightShaderClass* m_LightShader = nullptr;
    LightClass* m_Light = nullptr;
    TextClass* m_Text = nullptr;
    BitmapClass* m_Bitmap = nullptr;
    bool m_beginCheck = false;
    int m_screenWidth = 0;
    int m_screenHeight = 0;
};
Colored by Color Scripter
cs

TestIntersection 함수는 이 듀토리얼의 거의 모든 부분을 다룹니다. 2D 마우스 좌표를 입력으로 받아 3D 공간에서 벡터를 형성하여 구와의 교차점을 확인하는 데 사용합니다. 그 벡터를 피킹 레이 라고 합니다. 피킹 레이는 원점과 방향을 가집니다. 3D 좌표 (원점) 및 3D 벡터 / 법선 (방향)을 사용하여 3D 공간에 선을 작성하고 충돌 대상을 찾을 수 있습니다.

다른 HLSL 듀토리얼에서는 3D 점 (vertice)을 3D 정점에서 2D 화면으로 이동시켜 픽셀로 렌더링 할 수 있는 정점 셰이더에 매우 익숙합니다. 이제 우리는 정반대로 화면에서 2D 지점을 3D 공간으로 이동합니다. 그래서 우리가 해야 할 일은 우리의 평범한 과정을 되돌리는 것입니다. 따라서 일반적으로 2D 지점을 만들기 위해 전 세계에서 3D 지점을 투영하여 투영할 때 2D 지점을 가져와서 투영에서 보기로 이동하여 3D 점으로 변환합니다.

역 과정을 수행하기 위해 먼저 마우스 좌표를 가져 와서 양쪽 축에서 -1에서 +1 범위로 이동하여 시작합니다. 그런 다음 우리는 투영 행렬을 사용하여 화면 측면으로 나눕니다. 이 값을 사용하여 뷰 공간에서 방향 벡터를 얻으려면 역방향보기 행렬 (반대 방향이기 때문에 역)을 곱하면 됩니다. 뷰 공간에서 벡터의 원점을 카메라의 위치로 설정할 수 있습니다.

뷰 공간에서 방향 벡터와 원점을 사용하여 이제 3D 세계 공간으로 이동하는 최종 프로세스를 완료할 수 있습니다. 그렇게 하려면 먼저 월드 행렬을 구하여 구의 위치로 변환해야 합니다. 업데이트 된 월드 행렬을 사용하여 우리는 다시 역전해야 합니다 (과정이 반대 방향으로 진행되기 때문에). 그러면 역원 행렬에 의한 원점과 방향을 곱할수 있습니다. 또한 곱셈후 방향을 정규화 합니다. 이것은 우리가 3D 세계 공간에서 벡터의 원점과 방향을 제공하여 3D 세계 공간에서도 존재하는 다른 객체들과 함께 테스트를 수행 할 수 있게 합니다.

이제 우리는 벡터의 원점과 벡터의 방향을 가지고 교차 테스트를 수행 할 수 있습니다. 이 튜토리얼에서는 광선 구 교차 테스트를 수행하지만 3D 월드 공간에 벡터가 있으므로 교차 테스트를 수행 할 수 있습니다.

Applicationclass.cpp

#include "stdafx.h"
#include "inputclass.h"
#include "d3dclass.h"
#include "cameraclass.h"
#include "modelclass.h"
#include "textureshaderclass.h"
#include "lightshaderclass.h"
#include "lightclass.h"
#include "textclass.h"
#include "bitmapclass.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_screenWidth = screenWidth;
    m_screenHeight = 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_D3D = new D3DClass;
    if(!m_D3D)
    {
        return false;
    }
 
    // Direct3D 개체를 초기화합니다.
    result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize Direct3D.", L"Error", MB_OK);
        return false;
    }
 
    // 카메라 객체를 만듭니다.
    m_Camera = new CameraClass;
    if(!m_Camera)
    {
        return false;
    }
 
    // 카메라의 초기 위치를 설정합니다.
    XMMATRIX baseViewMatrix;
    m_Camera->SetPosition(-2.0f, 0.0f, -5.0f);
    m_Camera->Render();
    m_Camera->GetViewMatrix(baseViewMatrix);
 
    // 모델 객체를 만듭니다.
    m_Model = new ModelClass;
    if(!m_Model)
    {
        return false;
    }
 
    // 모델 객체를 초기화합니다.
    result = m_Model->Initialize(m_D3D->GetDevice(), "../Dx11Demo_47/data/sphere.txt", L"../Dx11Demo_47/data/blue.dds");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK);
        return false;
    }
 
    // 텍스처 쉐이더 객체를 생성한다.
    m_TextureShader = new TextureShaderClass;
    if(!m_TextureShader)
    {
        return false;
    }
 
    // 텍스처 쉐이더 객체를 초기화한다.
    result = m_TextureShader->Initialize(m_D3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the texture shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 라이트 쉐이더 객체를 생성합니다.
    m_LightShader = new LightShaderClass;
    if(!m_LightShader)
    {
        return false;
    }
 
    // 라이트 쉐이더 객체를 초기화합니다.
    result = m_LightShader->Initialize(m_D3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the light shader object.", L"Error", MB_OK);
        return false;
    }
 
    // light 객체를 만듭니다.
    m_Light = new LightClass;
    if(!m_Light)
    {
        return false;
    }
 
    // 라이트 오브젝트를 초기화한다.
    m_Light->SetDirection(0.0f, 0.0f, 1.0f);
 
    // 텍스트 객체를 만듭니다.
    m_Text = new TextClass;
    if(!m_Text)
    {
        return false;
    }
 
    // 텍스트 객체를 초기화합니다.
    result = m_Text->Initialize(m_D3D->GetDevice(), m_D3D->GetDeviceContext(), hwnd, screenWidth, screenHeight,
                                baseViewMatrix);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the text object.", L"Error", MB_OK);
        return false;
    }
 
    // 비트맵 객체를 만듭니다.
    m_Bitmap = new BitmapClass;
    if(!m_Bitmap)
    {
        return false;
    }
 
    // 비트맵 객체를 초기화합니다.
    result = m_Bitmap->Initialize(m_D3D->GetDevice(), screenWidth, screenHeight, L"../Dx11Demo_47/data/mouse.dds", 32, 32);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the bitmap object.", L"Error", MB_OK);
        return false;
    }
 
    return true;
}
 
 
void ApplicationClass::Shutdown()
{
    // 비트맵 객체를 해제합니다.
    if(m_Bitmap)
    {
        m_Bitmap->Shutdown();
        delete m_Bitmap;
        m_Bitmap = 0;
    }
 
    // 텍스트 객체를 해제합니다.
    if(m_Text)
    {
        m_Text->Shutdown();
        delete m_Text;
        m_Text = 0;
    }
 
    // light 객체를 해제합니다.
    if(m_Light)
    {
        delete m_Light;
        m_Light = 0;
    }
 
    // 라이트 쉐이더 객체를 해제합니다.
    if(m_LightShader)
    {
        m_LightShader->Shutdown();
        delete m_LightShader;
        m_LightShader = 0;
    }
 
    // 텍스처 쉐이더 객체를 해제한다.
    if(m_TextureShader)
    {
        m_TextureShader->Shutdown();
        delete m_TextureShader;
        m_TextureShader = 0;
    }
 
    // 모델 객체를 해제합니다.
    if(m_Model)
    {
        m_Model->Shutdown();
        delete m_Model;
        m_Model = 0;
    }
 
    // 카메라 객체를 해제합니다.
    if(m_Camera)
    {
        delete m_Camera;
        m_Camera = 0;
    }
 
    // D3D 객체를 해제합니다.
    if (m_D3D)
    {
        m_D3D->Shutdown();
        delete m_D3D;
        m_D3D = 0;
    }
 
    // 입력 객체를 해제합니다.
    if(m_Input)
    {
        m_Input->Shutdown();
        delete m_Input;
        m_Input = 0;
    }
}
 
 
bool ApplicationClass::Frame()
{
    // 입력 처리를 처리합니다.
    bool result = HandleInput();
    if(!result)
    {
        return false;
    }
 
    // 그래픽 장면을 렌더링합니다.
    result = Render();
    if(!result)
    {
        return false;
    }
 
    return true;
}
 
 
bool ApplicationClass::HandleInput()
{
    int mouseX = 0;
    int mouseY = 0;
 
    // 입력 프레임 처리를 수행합니다.
    if(m_Input->Frame() == false)
    {
        return false;
    }
 
    // 사용자가 이스케이프를 눌렀을 때 응용 프로그램을 종료 할 것인지 확인합니다.
    if(m_Input->IsEscapePressed() == true)
    {
        return false;
    }
 
    // 마우스 왼쪽 버튼이 눌러 졌는지 확인하십시오
    if(m_Input->IsLeftMouseButtonDown() == true)
    {
        // 마우스로 화면을 클릭 한 다음 교차 테스트를 수행합니다
        if(m_beginCheck == false)
        {
            m_beginCheck = true;
            m_Input->GetMouseLocation(mouseX, mouseY);
            TestIntersection(mouseX, mouseY);
        }
    }
 
    // 왼쪽 마우스 단추가 놓여 졌는지 확인하십시오
    if(m_Input->IsLeftMouseButtonDown() == false)
    {
        m_beginCheck = false;
    }
 
    return true;
}
 
 
bool ApplicationClass::Render()
{
    XMMATRIX worldMatrix, viewMatrix, projectionMatrix, orthoMatrix, translateMatrix;
 
    // 장면을 시작할 버퍼를 지운다.
    m_D3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);
 
    // 카메라의 위치에 따라 뷰 행렬을 생성합니다.
    m_Camera->Render();
 
    // 카메라 및 d3d 객체에서 월드, 뷰 및 투영 행렬을 가져옵니다.
    m_Camera->GetViewMatrix(viewMatrix);
    m_D3D->GetWorldMatrix(worldMatrix);
    m_D3D->GetProjectionMatrix(projectionMatrix);
    m_D3D->GetOrthoMatrix(orthoMatrix);
 
    // 구의 위치로 변환합니다.
    translateMatrix = XMMatrixTranslation(-5.0f, 1.0f, 5.0f);
    worldMatrix = XMMatrixMultiply(worldMatrix, translateMatrix);
 
    // 라이트 쉐이더를 사용하여 모델을 렌더링합니다.
    m_Model->Render(m_D3D->GetDeviceContext());
    if(m_LightShader->Render(m_D3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix,
                             m_Model->GetTexture(), m_Light->GetDirection()) == false)
    {
        return false;
    }
 
    // 월드 행렬을 재설정합니다.
    m_D3D->GetWorldMatrix(worldMatrix);
 
    // 모든 2D 렌더링을 시작하려면 Z 버퍼를 끕니다.
    m_D3D->TurnZBufferOff();
 
    // 알파 블렌딩을 켭니다.
    m_D3D->EnableAlphaBlending();
 
    // 입력 객체에서 마우스의 위치를 ​​가져옵니다.
    int mouseX = 0;
    int mouseY = 0;
    m_Input->GetMouseLocation(mouseX, mouseY);
 
    // 텍스처 셰이더로 마우스 커서를 렌더링합니다.
    if(m_Bitmap->Render(m_D3D->GetDeviceContext(), mouseX, mouseY) == false)
    {
        return false;
    }
    
    if (m_TextureShader->Render(m_D3D->GetDeviceContext(), m_Bitmap->GetIndexCount(), worldMatrix, viewMatrix, orthoMatrix,
                                m_Bitmap->GetTexture()) == false)
    {
        return false;
    }
 
    // 텍스트 문자열을 렌더링합니다.
    if(m_Text->Render(m_D3D->GetDeviceContext(), worldMatrix, orthoMatrix) == false)
    {
        return false;
    }
 
    // 알파 블렌딩을 돌립니다.
    m_D3D->DisableAlphaBlending();
 
    // 모든 2D 렌더링이 완료되었으므로 Z 버퍼를 다시 켜십시오.
    m_D3D->TurnZBufferOn();
 
    // 렌더링 된 장면을 화면에 표시합니다.
    m_D3D->EndScene();
 
    return true;
}
 
 
void ApplicationClass::TestIntersection(int mouseX, int mouseY)
{
    XMMATRIX projectionMatrix, viewMatrix, inverseViewMatrix, worldMatrix, translateMatrix, inverseWorldMatrix;
    XMFLOAT3 direction, origin, rayOrigin, rayDirection;
 
    // 마우스 커서 좌표를 -1에서 +1 범위로 이동합니다
    float pointX = ((2.0f * (float)mouseX) / (float)m_screenWidth) - 1.0f;
    float pointY = (((2.0f * (float)mouseY) / (float)m_screenHeight) - 1.0f) * -1.0f;
        
    // 뷰포트의 종횡비를 고려하여 투영 행렬을 사용하여 점을 조정합니다
    m_D3D->GetProjectionMatrix(projectionMatrix);
 
    XMFLOAT3X3 projectionMatrix4;
    XMStoreFloat3x3(&projectionMatrix4, projectionMatrix);
 
    pointX = pointX / projectionMatrix4._11;
    pointY = pointY / projectionMatrix4._22;
 
    // 뷰 행렬의 역함수를 구합니다.
    m_Camera->GetViewMatrix(viewMatrix);
    inverseViewMatrix = XMMatrixInverse(nullptr, viewMatrix);
 
    XMFLOAT3X3 inverseViewMatrix4;
    XMStoreFloat3x3(&inverseViewMatrix4, inverseViewMatrix);
 
    // 뷰 공간에서 피킹 레이의 방향을 계산합니다.
    direction.x = (pointX * inverseViewMatrix4._11) + (pointY * inverseViewMatrix4._21) + inverseViewMatrix4._31;
    direction.y = (pointX * inverseViewMatrix4._12) + (pointY * inverseViewMatrix4._22) + inverseViewMatrix4._32;
    direction.z = (pointX * inverseViewMatrix4._13) + (pointY * inverseViewMatrix4._23) + inverseViewMatrix4._33;
 
    // 카메라의 위치 인 picking ray의 원점을 가져옵니다.
    origin = m_Camera->GetPosition();
 
    // 세계 행렬을 가져와 구의 위치로 변환합니다.
    m_D3D->GetWorldMatrix(worldMatrix);
    translateMatrix = XMMatrixTranslation(-5.0f, 1.0f, 5.0f);
    worldMatrix = XMMatrixMultiply(worldMatrix, translateMatrix);
 
    // 이제 번역 된 행렬의 역함수를 구하십시오.
    inverseWorldMatrix = XMMatrixInverse(nullptr, worldMatrix);
    
    // 이제 광선 원점과 광선 방향을 뷰 공간에서 월드 공간으로 변환합니다.
    XMStoreFloat3(&rayOrigin, XMVector3TransformCoord(XMVectorSet(origin.x, origin.y, origin.z, 0.0f), inverseWorldMatrix));
    XMStoreFloat3(&direction, XMVector3TransformNormal(XMVectorSet(direction.x, direction.y, direction.z, 0.0f),
                  inverseWorldMatrix));
 
    // 광선 방향을 표준화합니다.
    XMStoreFloat3(&rayDirection, XMVector3Normalize(XMVectorSet(direction.x, direction.y, direction.z, 0.0f)));
 
    // 이제 광선 구 교차 테스트를 수행하십시오.
    if(RaySphereIntersect(rayOrigin, rayDirection, 1.0f) == true)
    {
        // 교차하는 경우 화면에 표시되는 텍스트 문자열에서 교차로를 "yes"로 설정합니다.
        m_Text->SetIntersection(true, m_D3D->GetDeviceContext());
    }
    else
    {
        // 그렇지 않으면 "No"로 교차를 설정하십시오.
        m_Text->SetIntersection(false, m_D3D->GetDeviceContext());
    }
}
 
 
bool ApplicationClass::RaySphereIntersect(XMFLOAT3 rayOrigin, XMFLOAT3 rayDirection, float radius)
{
    // a, b 및 c 계수를 계산합니다.
    float a = (rayDirection.x * rayDirection.x) + (rayDirection.y * rayDirection.y) + (rayDirection.z * rayDirection.z);
    float b = ((rayDirection.x * rayOrigin.x) + (rayDirection.y * rayOrigin.y) + (rayDirection.z * rayOrigin.z)) * 2.0f;
    float c = ((rayOrigin.x * rayOrigin.x) + (rayOrigin.y * rayOrigin.y) + (rayOrigin.z * rayOrigin.z)) - (radius * radius);
 
    // 결과값을 얻는다
    float discriminant = (b * b) - (4 * a * c);
 
    // 결과값이 음수이면 피킹 선이 구를 벗어난 것입니다. 그렇지 않으면 구를 선택합니다.
    if (discriminant < 0.0f)
    {
        return false;
    }
 
    return true;
}

Colored by Color Scripter

출력 화면

마치면서

피킹을 사용하여 다음 장면에 있는 구 객체를 사용하여 기본적인 충돌 교차 테스트를 수행할 수 있습니다.

연습문제

1. 프로그램을 컴파일하고 실행하십시오. 마우스를 사용하여 커서를 이동하고 구 또는 빈 공간을 왼쪽 클릭하여 교차점을 테스트합니다. 종료하려면 ESC 키를 누릅니다.

2. 큐브, 삼각형 및 직사각형 모델을 장면에 추가하십시오. 또한 새로운 세 가지 유형에 대한 교차 테스트 기능을 추가하십시오.

3. "경계 상자"테스트를 추가 했으므로 이제 선을 구체와 교차하면 구체의 모든 삼각형에 대해 두 번째 검사를 수행하고 선택한 삼각형을 강조 표시합니다.

4. 3 번과 똑같은 방법으로 직사각형과 큐브를 기대하십시오.

5. 두 객체를 서로 앞에 놓고 교차 검사가 카메라에 가장 가까운 객체만 반환하고 교차 검사에서 여러 교차가 반환되면 객체 뒤에 있는 객체를 무시합니다.

소스코드

소스코드 : Dx11Demo_47.zip

저작자표시 비영리 동일조건

'DirectX 11 > Basic' 카테고리의 다른 글

[DirectX11] Tutorial 49 - 그림자 매핑 및 투명도 (0)	2018.01.31
[DirectX11] Tutorial 48 - 방향성 그림자 맵 (0)	2018.01.28
[DirectX11] Tutorial 46 - 광선 효과 (0)	2018.01.22
[DirectX11] Tutorial 45 - 쉐이더 관리자 (0)	2018.01.19
[DirectX11] Tutorial 44 - 투영 라이트 맵 (0)	2018.01.18

Thinking Different

[DirectX11] Tutorial 47 - 피킹

'DirectX 11 > Basic' 카테고리의 다른 글

최근에 올라온 글

최근에 달린 댓글

링크

블로그 방문자 수

티스토리툴바

« 2024/04 »
일	월	화	수	목	금	토
	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