우선 그래프를 입력받고 그래프의 0,0부터 시작해서 같은 숫자라면 그 숫자의 카운트를 증가시켜주고 아니라면 크기를
3등분하여 재귀 함수로 이 과정을 반복하게 만들어주면서 -1 0 1의 카운트를 증가시켜준다. 이 과정을 한칸로 순회할 떄 까지나 같은 숫자로만 구성되어 있을 때까지 반복해준다.
정답코드
#include <iostream>
#include <vector>
using namespace std;
vector<vector<int>> graph;
int minuscnt = 0;
int zerocnt = 0;
int onecnt = 0;
bool isSameNum(int x, int y, int size) {
int num = graph[x][y]; // 첫 번째 칸의 수
for (int i = x; i < x + size; i++) {
for (int j = y; j < y + size; j++) {
if (graph[i][j] != num) {
return false; // 다른 수가 섞여 있으면 false 반환
}
}
}
return true; // 모두 같다면 true
}
// 분할 정복 함수
void divideAndConquer(int x, int y, int size) {
if (isSameNum(x, y, size)) {
if (graph[x][y] == -1) {
minuscnt++;
}
else if(graph[x][y] == 0){
zerocnt++;
}
else
{
onecnt++;
}
}
else {
int newSize = size / 3;
divideAndConquer(x, y, newSize); // 왼쪽 위
divideAndConquer(x, y + newSize, newSize); // 가운데 위
divideAndConquer(x, y + 2 * newSize, newSize); //오른쪽 위
divideAndConquer(x + newSize, y, newSize); // 왼쪽 가운데
divideAndConquer(x + newSize, y + newSize, newSize); // 가운데 가운데
divideAndConquer(x + newSize, y + 2 * newSize, newSize); //오른쪽 가운데
divideAndConquer(x + 2 * newSize, y, newSize); // 왼쪽 아래
divideAndConquer(x + 2 * newSize, y + newSize, newSize); // 가운데 아래
divideAndConquer(x + 2 * newSize, y + 2 * newSize, newSize); //오른쪽 아래
}
}
int main()
{
int n;
cin >> n;
graph.resize(n, vector<int>(n));
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cin >> graph[i][j];
}
}
divideAndConquer(0, 0, n);
cout << minuscnt << "\n" << zerocnt << "\n" << onecnt << "\n";
return 0;
}
우선 그래프 입력을 받고 함수를 통해 같은 수로만 구성되어있다면 그 수를 출력해주고 아니라면 4등분해서 같은 수가 나올 때까지 나 한칸만 남을때까지 반복해준다.
정답코드
#include <iostream>
#include <vector>
using namespace std;
vector<vector<int>> graph;
bool isSameNum(int x, int y, int size) {
int num = graph[x][y]; // 첫 번째 칸의 수
for (int i = x; i < x + size; i++) {
for (int j = y; j < y + size; j++) {
if (graph[i][j] != num) {
return false; // 다른 수가 섞여 있으면 false 반환
}
}
}
return true; // 모두 같다면 true
}
// 분할 정복 함수
void divideAndConquer(int x, int y, int size) {
if (isSameNum(x, y, size)) {
cout << graph[x][y];
}
else {
cout << "(";
int newSize = size / 2;
divideAndConquer(x, y, newSize); // 왼쪽 위
divideAndConquer(x, y + newSize, newSize); // 오른쪽 위
divideAndConquer(x + newSize, y, newSize); // 왼쪽 아래
divideAndConquer(x + newSize, y + newSize, newSize); // 오른쪽 아래
cout << ")";
}
}
int main()
{
int n;
cin >> n;
graph.resize(n, vector<int>(n));
for(int i=0;i<n;i++)
{
for (int j = 0; j < n; j++)
{
char ch;
cin >> ch;
graph[i][j] = ch - '0';
}
}
divideAndConquer(0, 0, n);
return 0;
}
전체 색깔정보를 그래프에 저장하고 이를 함수를 통해 순회하면서 만약 같은 전체 종이가 모두 같은 색이라면 그 종이의 색을 카운트에 추가해주고 아니라면 4등분으로 나누어서 다시 순회하는 과정을 잘라진 종이가 모두 하얀색 또는 모두 파란색으로 칠해져 있거나, 하나의 정사각형 칸이 되어 더 이상 자를 수 없을 때까지 반복한다.
정답코드
#include <iostream>
#include <vector>
using namespace std;
vector<vector<int>> graph;
int whitecnt = 0;
int bluecnt = 0;
bool isSameColor(int x, int y, int size) {
int color = graph[x][y]; // 첫 번째 칸의 색
for (int i = x; i < x + size; i++) {
for (int j = y; j < y + size; j++) {
if (graph[i][j] != color) {
return false; // 다른 색이 섞여 있으면 false 반환
}
}
}
return true; // 모두 같은 색이면 true 반환
}
// 분할 정복 함수
void divideAndConquer(int x, int y, int size) {
if (isSameColor(x, y, size)) {
// 모두 같은 색이면 해당 색에 따라 개수 증가
if (graph[x][y] == 0) {
whitecnt++;
}
else {
bluecnt++;
}
}
else {
// 다른 색이 섞여 있으면 4등분하여 재귀적으로 호출
int newSize = size / 2;
divideAndConquer(x, y, newSize); // 왼쪽 위
divideAndConquer(x, y + newSize, newSize); // 오른쪽 위
divideAndConquer(x + newSize, y, newSize); // 왼쪽 아래
divideAndConquer(x + newSize, y + newSize, newSize); // 오른쪽 아래
}
}
int main()
{
int n;
cin >> n;
graph.resize(n, vector<int>(n));
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cin >> graph[i][j];
}
}
divideAndConquer(0, 0, n);
cout << whitecnt << "\n";
cout << bluecnt << "\n";
return 0;
}
오늘은 Normal Mapping 과 Displacement Mapping에 대해 학습하고 예제코드를 분석해보자.
우선 Normal Mapping은 물체를 정밀하게 표현하기 위해서는 삼각형의 개수를 늘리는 방법도 있지만 이 방법은 너무 부하가 많아진다. 그렇기 때문에 삼각형의 개수를 늘리지 않고 물체 표면의 Normal 값을 조정해주는 것으로 물체의 표면을 정밀하게 표현한다.
이때 조정할 노멀 값을 모아서 노말 텍스처를 만들어주게 되는데 이때 텍스처에는 tagent Space 좌표계가 적용되어 있는데 이때 n(normal)값이 제일 많기 때문에 파란색으로 표현되곤 한다. 이 텍스처의 normal값을 추출해서 물체에 적용해주면 된다.
우선 코드를 실행시켜보면 왼쪽에는 Normal Mapping이 적용되지 않은 모습이고 오른쪽에는 Normal Mapping이 적용된 모습이다.
보통 노멀매핑은 24비트로 8비트씩 나눠서 3개의 좌표를 사용한다. 1바이트이기 때문에 각 값은 0~1사이의 값으로
표현한다. 이를 float -1~1까지의 값으로 치환해주는 공식을 통해 치환해주게 된다.
이때 tagent space라는 개념이 나오는데 이 정보는 매쉬의 정점에 포함된 정보로 이 좌표계를 기준으로 하는 x,y,z정보를 텍스처공간에 저장해주고 이 값을 통해 Normal Mapping을 해주는 것이다. 이때 정점 정보를 입력해줄 때VertexIn 구조체의 정보와 같이 노멀정보와 탄젠트 정보를 넣어주어야한다.
예제 코드에서 쉐이더 부분을 살펴보자면 노멀 정보를 가져와서 월드좌표로 바꿔주는 부분이 함수로 만들어져있고 이를 PS단계에서 호출하여 사용해주고 있다.
월드좌표로 변환해줄 때 텍스처에서 UV좌표를 이용하여 특정 좌표를 구한다음에 그 값을 -1~1사이의 값으로 공식을 통해 변환해준 다음 월드좌표로 변환해주고 있다. 이때 이미 VS값에서 World를 구해줬지만 PS단계에서 보간때문에 normal과 tagent의 수직이 깨질 수 있기 때문에 이를 수정해주기 위해 탄젠트 값을 다시 연산을 해준 다음 탄젠트 스페이스에서 월드 스페이스로 변환해주고 있다.
//---------------------------------------------------------------------------------------
// Transforms a normal map sample to world space.
//---------------------------------------------------------------------------------------
float3 NormalSampleToWorldSpace(float3 normalMapSample, float3 unitNormalW, float3 tangentW)
{
// Uncompress each component from [0,1] to [-1,1].
float3 normalT = 2.0f * normalMapSample - 1.0f;
// Build orthonormal basis.
float3 N = unitNormalW;
float3 T = normalize(tangentW - dot(tangentW, N) * N);
float3 B = cross(N, T);
float3x3 TBN = float3x3(T, B, N);
// Transform from tangent space to world space.
float3 bumpedNormalW = mul(normalT, TBN);
return bumpedNormalW;
}
그리고 이렇게 변환된 값을 통해 빛연산을 해주고 있다.
// Sum the light contribution from each light source.
[unroll]
for (int i = 0; i < gLightCount; ++i)
{
float4 A, D, S;
ComputeDirectionalLight(gMaterial, gDirLights[i], bumpedNormalW, toEye,
A, D, S);
ambient += A;
diffuse += D;
spec += S;
}
litColor = texColor * (ambient + diffuse) + spec;
if (gReflectionEnabled)
{
float3 incident = -toEye;
float3 reflectionVector = reflect(incident, bumpedNormalW);
float4 reflectionColor = gCubeMap.Sample(samLinear, reflectionVector);
litColor += gMaterial.Reflect * reflectionColor;
}
다음은 Displacement Mapping 표면에 굴곡과 균열을 묘사하는 높이 값을 넘겨주고 이를 통해 기하구조를 변경하는 것이다. 구현은 노멀매핑에서 w값을 height로 사용하거나 따로 텍스처를 만들어주면 된다. 왼쪽이 Normal Mapping만 적용된 화면이고 오른쪽이 Displacement Mapping까지 적용된 모습이다.
이 표면의 높이값을 실시간으로 조정해주기 위해서는 매쉬를 직접 조정해주는 방법도 있지만 이렇게 하면 부하가 심해지기 때문에 정점을 건드리지 않고 조정해줄 방법을 찾아야하는데 Tesellation 단계를 통해 조정을 해준다.
코드를 보면 예제에서는 노멀 텍스처w값을 추출해서 사용하는 것을 볼 수 있다.
Texture2D gNormalMap;
PatchTess PatchHS(InputPatch<VertexOut, 3> patch,
uint patchID : SV_PrimitiveID)
{
PatchTess pt;
// Average tess factors along edges, and pick an edge tess factor for
// the interior tessellation. It is important to do the tess factor
// calculation based on the edge properties so that edges shared by
// more than one triangle will have the same tessellation factor.
// Otherwise, gaps can appear.
pt.EdgeTess[0] = 0.5f * (patch[1].TessFactor + patch[2].TessFactor);
pt.EdgeTess[1] = 0.5f * (patch[2].TessFactor + patch[0].TessFactor);
pt.EdgeTess[2] = 0.5f * (patch[0].TessFactor + patch[1].TessFactor);
pt.InsideTess = pt.EdgeTess[0];
return pt;
}
struct HullOut
{
float3 PosW : POSITION;
float3 NormalW : NORMAL;
float3 TangentW : TANGENT;
float2 Tex : TEXCOORD;
};
[domain("tri")]
[partitioning("fractional_odd")]
[outputtopology("triangle_cw")]
[outputcontrolpoints(3)]
[patchconstantfunc("PatchHS")]
HullOut HS(InputPatch<VertexOut, 3> p,
uint i : SV_OutputControlPointID,
uint patchId : SV_PrimitiveID)
{
HullOut hout;
// Pass through shader.
hout.PosW = p[i].PosW;
hout.NormalW = p[i].NormalW;
hout.TangentW = p[i].TangentW;
hout.Tex = p[i].Tex;
return hout;
}
struct DomainOut
{
float4 PosH : SV_POSITION;
float3 PosW : POSITION;
float3 NormalW : NORMAL;
float3 TangentW : TANGENT;
float2 Tex : TEXCOORD;
};
//테셀레이션- 최종 위치결정
[domain("tri")]
DomainOut DS(PatchTess patchTess,
float3 bary : SV_DomainLocation,
const OutputPatch<HullOut, 3> tri)
{
DomainOut dout;
dout.PosW = bary.x * tri[0].PosW + bary.y * tri[1].PosW + bary.z * tri[2].PosW;
dout.NormalW = bary.x * tri[0].NormalW + bary.y * tri[1].NormalW + bary.z * tri[2].NormalW;
dout.TangentW = bary.x * tri[0].TangentW + bary.y * tri[1].TangentW + bary.z * tri[2].TangentW;
dout.Tex = bary.x * tri[0].Tex + bary.y * tri[1].Tex + bary.z * tri[2].Tex;
dout.NormalW = normalize(dout.NormalW);
const float MipInterval = 20.0f;
float mipLevel = clamp((distance(dout.PosW, gEyePosW) - MipInterval) / MipInterval, 0.0f, 6.0f);
//텍스처에서 height 추출
float h = gNormalMap.SampleLevel(samLinear, dout.Tex, mipLevel).a;
//포지션 조정
dout.PosW += (gHeightScale * (h - 1.0)) * dout.NormalW;
//포지션 조정
dout.PosH = mul(float4(dout.PosW, 1.0f), gViewProj);
return dout;
}
우선 예제코드를 실행해보면 풍경이 담긴 Sky Box가 적용되어 있는 모습을 볼 수 있다.
전에 Sky Box를 구현할 때는 커다란 구를 만들어두고 여기에 텍스처를 붙이고 우리가 안에서 그 텍스처를 보는 방식으로
구현했었다. 이때 안쪽을 볼 수 있게 하기 위해 기존에 컬링으로 후면을 제거해줬는데 이를 없애고 전면을 없애는 방식으로 바꿔주어야 했고 카메라가 움직임에 따라 따라가게 해야했다. 그리고 스카이박스는 깊이를 1에 가깝게 만들어서 물체가
그려질 수 있고 Sky Box가 제일 끝에 위치하도록 만들어 줬다.
지금이 예제에는 구가 아닌 큐브를 통해 6면에 텍스처를 붙여주는 것으로 Sky Box를 구현해주고 있다. 이를 위해 상하좌우 풍경에 따라 다른 텍스처를 매핑해줘야한다. 이렇게 해주기 위해 3D Look up Vector를 사용하여 매핑해준다. 이 벡터를 활용하는 방법은 중심에서 가리키는 벡터에 따라 그려주는 연산을 해준다.
우선 쉐이더 코드를 살펴보자. 텍스처를 받아오는 변수로 TextureCube를 통해 받아오고 있으며 이를 PS단계에서 Sampler 연산을 해줄 때 pin.PosL가 Look up Vector이다.
그리고 이 pin값은 VS단계에서 위치를 xyww로 밀어주고 있다. 이는 깊이값이 정확하게 1이 되도록 해주는 것이다. 이를 통해 SkyBox가 제일 뒤에 있어서 물체가 그려질 수 있다. 그리고 원점을 기준으로하는 로컬좌표를 넘겨주는 것으로 로컬좌표를 통해 각 정점의 위치로의 벡터도 나중에 만들어 줄 수 있게 한다.
VertexOut VS(VertexIn vin)
{
VertexOut vout;
// Set z = w so that z/w = 1 (i.e., skydome always on far plane).
vout.PosH = mul(float4(vin.PosL, 1.0f), gWorldViewProj).xyww;
// Use local vertex position as cubemap lookup vector.
vout.PosL = vin.PosL;
return vout;
}
그리고 밑의 코드를 보면 컬링을 꺼주고 원래 깊이가 1인 오브젝트도 그려줄 수 있도록 옵션 설정을 해주고 있다.
RasterizerState NoCull
{
CullMode = None;
};
DepthStencilState LessEqualDSS
{
// Make sure the depth function is LESS_EQUAL and not just LESS.
// Otherwise, the normalized depth values at z = 1 (NDC) will
// fail the depth test if the depth buffer was cleared to 1.
DepthFunc = LESS_EQUAL;
};
이렇게 해주면 큐브 매핑을 통한 기본적인 Sky Box를 구현할 수 있다.
다음으로 다이나믹 큐브맵에 대해 알아보자. 다이나믹 큐브맵을 주변 환경을 반사하는 모습을 표현할 때 자주 활용된다.
우선 예제코드를 실행해보면 가운데 구에 주변 환경이 반사되어 보이는 것을 볼 수 있다.
이것을 구현하는 것은 스텐실을 활용해서 실시간으로 여섯면을 만들어줘야한다. Dynamic Cube라고 했지만 구 모양을 그려주고 있는데 이는 큐브모양을 look up vector를 통해 오려붙여서 구를 만들어 줄 수 가 있다. 구에 반사되는 모습은 카메라를 원점에 위치시키고 반사 공식을 통해 구한 각 6면의 장면을 텍스처로 만든 다음 이를 적용 시켜 주면 된다.
코드를 살펴보면 동적으로 큐브맵 텍스처를 만들기 위해 각 장면을 화면이 아닌 텍스처에 먼저 그려주기 위한 변수가 있다. 그리고 원래 DrawScene이 원래 Scene을 그리지만 당장 화면에 그려주는 것이 아니라 텍스처로 그려줄 수 있다는 것을 볼 수 있다.
이때 구의 각면에 적용할 DepthStencilView도 따로 적용해주고 있다. 이는 구에 적용하는 해상도에 맞춰서 적용해줘야하기 때문이다.
//각 장면을 텍스처로 저장하기 위한 변수
ComPtr<ID3D11RenderTargetView> _dynamicCubeMapRTV[6];
//6면의 카메라
Camera _cubeMapCamera[6];
void DynamicCubeMapDemo::DrawScene()
{
ID3D11RenderTargetView* renderTargets[1];
// 각 면을 텍스처로 저장
_deviceContext->RSSetViewports(1, &_cubeMapViewport);
for (int i = 0; i < 6; ++i)
{
// Clear cube map face and depth buffer.
_deviceContext->ClearRenderTargetView(_dynamicCubeMapRTV[i].Get(), reinterpret_cast<const float*>(&Colors::Silver));
_deviceContext->ClearDepthStencilView(_dynamicCubeMapDSV.Get(), D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
// Bind cube map face as render target.
renderTargets[0] = _dynamicCubeMapRTV[i].Get();
_deviceContext->OMSetRenderTargets(1, renderTargets, _dynamicCubeMapDSV.Get());
// Draw the scene with the exception of the center sphere to this cube map face.
DrawScene(_cubeMapCamera[i], false);
}
// 화면에 그려줄 수 있도록 렌더타켓 초기화
_deviceContext->RSSetViewports(1, &_viewport);
renderTargets[0] = _renderTargetView.Get();
_deviceContext->OMSetRenderTargets(1, renderTargets, _depthStencilView.Get());
// Have hardware generate lower mipmap levels of cube map.
_deviceContext->GenerateMips(_dynamicCubeMapSRV.Get());
// 구를 포함한 전체 그려주기
_deviceContext->ClearRenderTargetView(_renderTargetView.Get(), reinterpret_cast<const float*>(&Colors::Silver));
_deviceContext->ClearDepthStencilView(_depthStencilView.Get(), D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
DrawScene(_camera, true);
HR(_swapChain->Present(0, 0));
}
여기서 핵심은 UV매핑이 아닌 Look up Vector를 활용하여 텍스처를 그려줄 수 있고 이를 통해 환경이나 거울 같은 오브젝트를 그려줄 때도 사용할 수 있다는 것을 알 수 있다.
자동차 오브젝트가 있다. 이 자동차 오브젝트를 우클릭해보면 클릭하는 면에 클릭이 적용되고 있는 모습을 볼 수 있다.
피킹은 마우스 커서로 우리가 찍은 좌표를 통해 물체를 파악하는 것이다. 이것이 중요한 이유는 3D 게임에서 클릭을 한다고 했을 때 2D화면 좌표계에서 선택한 좌표를 3D로 변환줘야한다. 이를 통해 어떤 것을 클릭해주는 지 알 수 있기 때문이다.
피킹 연산은 우리가 물체를 그려주기 위해 했던 로컬,월드,뷰,프로젝션,NDC,Screen까지의 연산의 반대로 해주면 된다.
이때 매쉬랑 충돌 판정을 한다는 것은 매쉬의 모든 삼각형을 순회하면서 레이케스팅을 해주는 것이다.
만약 예제코드와 같이 자동차안에서도 삼각형으로 분할되어 있는 세밀한 부분에 티킹 연산을 해준다고 하면 기존 오브젝트가 있는 로컬좌표로 클릭한 스크린 좌표를 변환해서 연산해주는 것이 더 좋을 것이다.
피킹연산은 CPU에서 이루어 진다. 월드 변환은 GPU에서 이루어 지고 이에 관한 정보도 GPU에서 가지고 있다. 그렇기 때문에 CPU에서는 피킹 연산에서 각 월드 좌표를 가지고 있지 않고 연산량이 적은 좌표계로 변환해서 연산해주면 된다.
즉 레이케스트의 광선을 오브젝트의 로컬로 변환해서 연산해주면 되는 것이다.
그리고 연산에서 먼저 세밀한 부분에 피킹 연산을 해주기 보다는 충돌 영역을 지정해두고 여기에 충돌하면 2단계로 세밀한 부분에 피킹 연산을 해주는 것으로 최적화 해줄 수 있다.
코드를 보면 광선을 로컬좌표로 변환하고 있고 이를 통해 레이케스팅 연산을 해주고 있다. 이때 위에서 이야기한대로 먼저 대략적인 충돌영역으로 충돌처리를 해주고 만약 충돌했다면 2단계로 모든 삼각형에 순회를 해주며 충돌 연산을 해주고 있다. 그리고 피킹을 했을 때 가장 가까이 있는 오브젝트에 피킹을 해주어야하기 때문에 이러한 값을 추가해서 검사해주는 것을 볼 수 있다.
void PickingDemo::Pick(int32 sx, int32 sy)
{
XMMATRIX P = _camera.Proj();
Matrix m = P;
// Compute picking ray in view space.
float vx = (+2.0f * sx / _clientWidth - 1.0f) / m(0, 0); // P(0, 0);
float vy = (-2.0f * sy / _clientHeight + 1.0f) / m(1, 1); // P(1, 1);
// 뷰좌표계에서 광선정의
XMVECTOR rayOrigin = ::XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f);
XMVECTOR rayDir = ::XMVectorSet(vx, vy, 1.0f, 0.0f);
// 광선을 로컬좌표로 변환
XMMATRIX V = _camera.View();
XMVECTOR D1 = ::XMMatrixDeterminant(V);
XMMATRIX invView = ::XMMatrixInverse(&D1, V);
XMMATRIX W = ::XMLoadFloat4x4(&_meshWorld);
XMVECTOR D2 = ::XMMatrixDeterminant(W);
XMMATRIX invWorld = ::XMMatrixInverse(&D2, W);
XMMATRIX toLocal = ::XMMatrixMultiply(invView, invWorld);
rayOrigin = ::XMVector3TransformCoord(rayOrigin, toLocal);
rayDir = ::XMVector3TransformNormal(rayDir, toLocal);
// Make the ray direction unit length for the intersection tests.
rayDir = ::XMVector3Normalize(rayDir);
// If we hit the bounding box of the Mesh, then we might have picked a Mesh triangle,
// so do the ray/triangle tests.
//
// If we did not hit the bounding box, then it is impossible that we hit
// the Mesh, so do not waste effort doing ray/triangle tests.
// Assume we have not picked anything yet, so init to -1.
_pickedTriangle = -1;
float tmin = 0.0f;
if (_meshBox.Intersects(rayOrigin, rayDir, tmin))
{
// Find the nearest ray/triangle intersection.
tmin = MathHelper::Infinity;
for (UINT i = 0; i < _meshIndices.size() / 3; ++i)
{
// Indices for this triangle.
UINT i0 = _meshIndices[i * 3 + 0];
UINT i1 = _meshIndices[i * 3 + 1];
UINT i2 = _meshIndices[i * 3 + 2];
// Vertices for this triangle.
XMVECTOR v0 = ::XMLoadFloat3(&_meshVertices[i0].pos);
XMVECTOR v1 = ::XMLoadFloat3(&_meshVertices[i1].pos);
XMVECTOR v2 = ::XMLoadFloat3(&_meshVertices[i2].pos);
// We have to iterate over all the triangles in order to find the nearest intersection.
float t = 0.0f;
if (TriangleTests::Intersects(rayOrigin, rayDir, v0, v1, v2, t))
{
if (t < tmin)
{
// 가장 가까운 삼각형체크
tmin = t;
_pickedTriangle = i;
}
}
}
}
}
