1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
struct InstanceData
{
	DirectX::XMFLOAT4X4 World = MathHelper::Identity4x4();
	DirectX::XMFLOAT4X4 TexTransform = MathHelper::Identity4x4();
	UINT MaterialIndex;
	UINT InstancePad0;
	UINT InstancePad1;
	UINT InstancePad2;
};

struct MaterialData
{
	DirectX::XMFLOAT4 DiffuseAlbedo = { 1.0f, 1.0f, 1.0f, 1.0f };
	DirectX::XMFLOAT3 FresnelR0 = { 0.01f, 0.01f, 0.01f };
	float Roughness = 64.0f;

	// Used in texture mapping.
	DirectX::XMFLOAT4X4 MatTransform = MathHelper::Identity4x4();

	UINT DiffuseMapIndex = 0;
	UINT MaterialPad0;
	UINT MaterialPad1;
	UINT MaterialPad2;
};

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
class Camera
{
public:

	Camera();
	~Camera();

	// Get/Set world camera position.
	DirectX::XMVECTOR GetPosition()const;
	DirectX::XMFLOAT3 GetPosition3f()const;
	void SetPosition(float x, float y, float z);
	void SetPosition(const DirectX::XMFLOAT3& v);
	
	// Get camera basis vectors.
	DirectX::XMVECTOR GetRight()const;
	DirectX::XMFLOAT3 GetRight3f()const;
	DirectX::XMVECTOR GetUp()const;
	DirectX::XMFLOAT3 GetUp3f()const;
	DirectX::XMVECTOR GetLook()const;
	DirectX::XMFLOAT3 GetLook3f()const;

	// Get frustum properties.
	float GetNearZ()const;
	float GetFarZ()const;
	float GetAspect()const;
	float GetFovY()const;
	float GetFovX()const;

	// Get near and far plane dimensions in view space coordinates.
	float GetNearWindowWidth()const;
	float GetNearWindowHeight()const;
	float GetFarWindowWidth()const;
	float GetFarWindowHeight()const;
	
	// Set frustum.
	void SetLens(float fovY, float aspect, float zn, float zf);

	// Define camera space via LookAt parameters.
	void LookAt(DirectX::FXMVECTOR pos, DirectX::FXMVECTOR target, DirectX::FXMVECTOR worldUp);
	void LookAt(const DirectX::XMFLOAT3& pos, const DirectX::XMFLOAT3& target, const DirectX::XMFLOAT3& up);

	// Get View/Proj matrices.
	DirectX::XMMATRIX GetView()const;
	DirectX::XMMATRIX GetProj()const;

	DirectX::XMFLOAT4X4 GetView4x4f()const;
	DirectX::XMFLOAT4X4 GetProj4x4f()const;

	// Strafe/Walk the camera a distance d.
	void Strafe(float d);
	void Walk(float d);
	void Rotate(float angle);

	// Rotate the camera.
	void Pitch(float angle);
	void RotateY(float angle);

	// After modifying camera position/orientation, call to rebuild the view matrix.
	void UpdateViewMatrix();

private:

	// Camera coordinate system with coordinates relative to world space.
	DirectX::XMFLOAT3 mPosition = { 0.0f, 0.0f, 0.0f };
	DirectX::XMFLOAT3 mRight = { 1.0f, 0.0f, 0.0f };
	DirectX::XMFLOAT3 mUp = { 0.0f, 1.0f, 0.0f };
	DirectX::XMFLOAT3 mLook = { 0.0f, 0.0f, 1.0f };

	// Cache frustum properties.
	float mNearZ = 0.0f;
	float mFarZ = 0.0f;
	float mAspect = 0.0f;
	float mFovY = 0.0f;
	float mNearWindowHeight = 0.0f;
	float mFarWindowHeight = 0.0f;

	bool mViewDirty = true;

	// Cache View/Proj matrices.
	DirectX::XMFLOAT4X4 mView = MathHelper::Identity4x4();
	DirectX::XMFLOAT4X4 mProj = MathHelper::Identity4x4();
};

#endif // CAMERA_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
// 적용 전
	// Convert Spherical to Cartesian coordinates.
	mEyePos.x = mRadius * sinf(mPhi) * cosf(mTheta);
	mEyePos.z = mRadius * sinf(mPhi) * sinf(mTheta);
	mEyePos.y = mRadius * cosf(mPhi);

	// Build the view matrix.
	XMVECTOR pos = XMVectorSet(mEyePos.x, mEyePos.y, mEyePos.z, 1.0f);
	XMVECTOR target = XMVectorZero();
	XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);

	XMMATRIX view = XMMatrixLookAtLH(pos, target, up);
	XMStoreFloat4x4(&mView, view);


// 적용 후
	const float dt = gt.DeltaTime();

	if (GetAsyncKeyState('W') & 0x8000)
		mCamera.Walk(10.0f * dt);

	if (GetAsyncKeyState('S') & 0x8000)
		mCamera.Walk(-10.0f * dt);

	if (GetAsyncKeyState('A') & 0x8000)
		mCamera.Strafe(-10.0f * dt);

	if (GetAsyncKeyState('D') & 0x8000)
		mCamera.Strafe(10.0f * dt);

	if (GetAsyncKeyState('Q') & 0x8000)
		mCamera.Rotate(5.0f * dt);

	if (GetAsyncKeyState('E') & 0x8000)
		mCamera.Rotate(-5.0f * dt);

	mCamera.UpdateViewMatrix();

  XMMATRIX view = mCamera.GetView();
	XMMATRIX proj = mCamera.GetProj();

	XMMATRIX viewProj = XMMatrixMultiply(view, proj);
	XMVECTOR det = XMMatrixDeterminant(view);
  .
  .
  .

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
void CameraAndDynamicIndexingApp::BuildShapeGeometry()
{
	GeometryGenerator geoGen;
	GeometryGenerator::MeshData box = geoGen.CreateBox(1.0f, 1.0f, 1.0f, 3);

	// 박스 5개의 위치 정의
	XMFLOAT3 boxPositions[5] = {
		XMFLOAT3(-8.0f, 0.0f, 0.0f),
		XMFLOAT3(-4.0f, 0.0f, 0.0f),
		XMFLOAT3(0.0f, 0.0f, 0.0f),
		XMFLOAT3(4.0f, 0.0f, 0.0f),
		XMFLOAT3(8.0f, 0.0f, 0.0f),
	};

	UINT singleBoxVertexCount = (UINT)box.Vertices.size();
	UINT singleBoxIndexCount = (UINT)box.Indices32.size();

	UINT totalVertexCount = singleBoxVertexCount * 5;
	UINT totalIndexCount = singleBoxIndexCount * 5;

	std::vector<CustomVertex> vertices(totalVertexCount);
	std::vector<std::uint16_t> indices;

	for (int b = 0; b < 5; b++)
	{
		UINT vertexOffset = b * singleBoxVertexCount;

		for (UINT i = 0; i < singleBoxVertexCount; i++)
		{
			UINT k = vertexOffset + i;
			vertices[k].Position = XMFLOAT3(
				box.Vertices[i].Position.x + boxPositions[b].x,
				box.Vertices[i].Position.y + boxPositions[b].y,
				box.Vertices[i].Position.z + boxPositions[b].z
			);
			vertices[k].Normal = box.Vertices[i].Normal;
			vertices[k].TangentU = box.Vertices[i].TangentU;
			vertices[k].TexC = box.Vertices[i].TexC;
			vertices[k].MatIndex = b;
		}

		for (UINT i = 0; i < singleBoxIndexCount; i++)
		{
			indices.push_back((std::uint16_t)(box.Indices32[i] + vertexOffset));
		}
	}

	// Submesh 하나로 전체 통합
	SubmeshGeometry submesh;
	submesh.IndexCount = totalIndexCount;
	submesh.StartIndexLocation = 0;
	submesh.BaseVertexLocation = 0;

	const UINT vbByteSize = totalVertexCount * sizeof(CustomVertex);
	const UINT ibByteSize = totalIndexCount * sizeof(std::uint16_t);

	auto geo = std::make_unique<MeshGeometry>();
	geo->Name = "shapeGeo";

	ThrowIfFailed(D3DCreateBlob(vbByteSize, &geo->VertexBufferCPU));
	CopyMemory(geo->VertexBufferCPU->GetBufferPointer(), vertices.data(), vbByteSize);

	ThrowIfFailed(D3DCreateBlob(ibByteSize, &geo->IndexBufferCPU));
	CopyMemory(geo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);

	geo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), vertices.data(), vbByteSize, geo->VertexBufferUploader);

	geo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);

	geo->VertexByteStride = sizeof(CustomVertex);
	geo->VertexBufferByteSize = vbByteSize;
	geo->IndexFormat = DXGI_FORMAT_R16_UINT;
	geo->IndexBufferByteSize = ibByteSize;

	geo->DrawArgs["box"] = submesh;

	mGeometries[geo->Name] = std::move(geo);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
struct	PatchTess
{
  float	EdgeTess[4] : SV_TessFactor; // 모서리 divide 파라미터
  float	InsideTess[2] : SV_InsideTessFactor; // 내부 divide 파라미터
};

PatchTess ConstantHS(InputPatch<VertexOut, 4> patch,
uint patchID : SV_PrimitiveID)
{
  PatchTess pt;

  pt.EdgeTess[0] = 3;
  pt.EdgeTess[1] = 3;
  pt.EdgeTess[2] = 3;
  pt.EdgeTess[3] = 3;
  pt.InsideTess[0] = 3;
  pt.InsideTess[1] = 3;
  return pt;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
struct	HullOut
{
  float3 PosL : POSITION;
};

[domain(“quad”)] // 패치의 모양 결정
[partitioning(“integer”)] // 
[outputtopology(“triangle_cw”)] // culling face 결정
[outputcontrolpoints(4)]
[patchconstantfunc(“ConstantHS”)]
[maxtessfactor(64.0f)]
HullOut	HS(InputPatch<VertexOut,4>	p,
uint i : SV_OutputControlPointID,
uint patchId : SV_PrimitiveID)
{
  HullOut	hout;
  hout.PosL	=	p[i].PosL;
  return	hout;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct DomainOut
{
  float4 PosH : SV_POSITION;
};
[domain(“quad”)] // 패치의 모양 결정
DomainOut DS(PatchTess patchTess,	
float2 uv : SV_DomainLocation,	
const OutputPatch<HullOut,4> quad)
{
  DomainOut dout;
  float3 v1 = lerp(quad[0].PosL, quad[1].PosL, uv.x);	
  float3 v2 = lerp(quad[2].PosL, quad[3].PosL, uv.x);	
  float3 p = lerp(v1, v2, uv.y);	
  float4 posW = mul(float4(p, 1.0f), gWorld);
  dout.PosH = mul(posW, gViewProj);
  return dout;
}

1
[partitioning(“integer”)]

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
float4 BernsteinBasis(float t)
{
    float invT = 1.0f - t;

    return float4( invT * invT * invT,
                   3.0f * t * invT * invT,
                   3.0f * t * t * invT,
                   t * t * t );
}

float4 dBernsteinBasis(float t) // 미분
{
    float invT = 1.0f - t;

    return float4( -3 * invT * invT,
                   3 * invT * invT - 6 * t * invT,
                   6 * t * invT - 3 * t * t,
                   3 * t * t );
}

float3 CubicBezierSum(const OutputPatch<HullOut, 16> bezpatch, float4 basisU, float4 basisV)
{
    float3 sum = float3(0.0f, 0.0f, 0.0f);
    sum  = basisV.x * (basisU.x*bezpatch[0].PosL  + basisU.y*bezpatch[1].PosL  + basisU.z*bezpatch[2].PosL  + basisU.w*bezpatch[3].PosL );
    sum += basisV.y * (basisU.x*bezpatch[4].PosL  + basisU.y*bezpatch[5].PosL  + basisU.z*bezpatch[6].PosL  + basisU.w*bezpatch[7].PosL );
    sum += basisV.z * (basisU.x*bezpatch[8].PosL  + basisU.y*bezpatch[9].PosL  + basisU.z*bezpatch[10].PosL + basisU.w*bezpatch[11].PosL);
    sum += basisV.w * (basisU.x*bezpatch[12].PosL + basisU.y*bezpatch[13].PosL + basisU.z*bezpatch[14].PosL + basisU.w*bezpatch[15].PosL);

    return sum;
}

[domain("quad")]
DomainOut DS(PatchTess patchTess,
             float2 uv : SV_DomainLocation,
             const OutputPatch<HullOut, 16> bezPatch)
{
	DomainOut dout;

	float4 basisU  = BernsteinBasis(uv.x);
	float4 basisV  = BernsteinBasis(uv.y);
	float4 dbasisU = dBernsteinBasis(uv.x);
	float4 dbasisV = dBernsteinBasis(uv.y);

	float3 p    = CubicBezierSum(bezPatch, basisU,  basisV);
	float3 dpdu = CubicBezierSum(bezPatch, dbasisU, basisV);  // u 방향 접선
	float3 dpdv = CubicBezierSum(bezPatch, basisU,  dbasisV); // v 방향 접선

	float3 normal = normalize(cross(dpdu, dpdv));

	float4 posW  = mul(float4(p, 1.0f), gWorld);
	dout.PosH    = mul(posW, gViewProj);
	dout.PosW    = posW.xyz;
	dout.NormalW = mul(normal, (float3x3)gWorld);

	return dout;
}

float4 PS(DomainOut pin) : SV_Target
{
	pin.NormalW = normalize(pin.NormalW);

	float3 toEye = normalize(gEyePosW - pin.PosW);

	float4 ambient = gAmbientLight * gDiffuseAlbedo;

	const float shininess = 1.0f - gRoughness;
	Material mat = { gDiffuseAlbedo, gFresnelR0, shininess };
	float3 shadowFactor = 1.0f;
	float4 directLight = ComputeLighting(gLights, mat, pin.PosW,
		pin.NormalW, toEye, shadowFactor);

	float4 litColor = ambient + directLight;
	litColor.a = gDiffuseAlbedo.a;

	return litColor;
}

1
2
3
4
5
6
7
8
9
10
11
Texture2D gInputA;	
Texture2D gInputB;
RWTexture2D<float4>	gOutput;

[numthreads(16,	16,	1)]
void CS(int3 dispatchThreadID :	SV_DispatchThreadID)
{
    gOutput[dispatchThreadID.xy] =	
    gInputA[dispatchThreadID.xy] +
    gInputB[dispatchThreadID.xy];
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct Particle
{
    float3 Position;
    float3 Velocity;
    float3 Acceleration;
};

float TimeStep = 1.0f / 60.0f;

ConsumeStructuredBuffer<Particle> gInput;
AppendStructuredBuffer<Particle> gOutput;

[numthreads(16,	16,	1)]
void CS()
{
    Particle p = gInput.Consume();
    p.Velocity += p.Acceleration*TimeStep;
    p.Position += p.Velocity*TimeStep;
    gOutput.Append(	p);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Texture2D gInput;
RWTexture2D gOutput;
groupshared float4 gCache[256];

[numthreads(256, 1, 1)]
void CS(int3 groupThreadID : SV_GroupThreadID,
        int3 dispatchThreadID : SV_DispatchThreadID)
{

    gCache[groupThreadID.x] = gInput[dispatchThreadID.xy];

    GroupMemoryBarrierWithGroupSync();

    float4 left  = gCache[groupThreadID.x - 1];
    float4 right = gCache[groupThreadID.x + 1];
    …
}

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
Texture2D gInput            : register(t0);
RWTexture2D<float4> gOutput : register(u0);

float CalcLuminance(float3 color)
{
    return dot(color, float3(0.299f, 0.587f, 0.114f));
}

[numthreads(16, 16, 1)]
void SobelCS(int3 dispatchThreadID : SV_DispatchThreadID)
{
    
	float4 c[3][3];
	for(int i = 0; i < 3; ++i)
	{
		for(int j = 0; j < 3; ++j)
		{
			int2 xy = dispatchThreadID.xy + int2(-1 + j, -1 + i);
			c[i][j] = gInput[xy];
		}
	}

	float4 Gx = -1.0f*c[0][0] - 2.0f*c[1][0] - 1.0f*c[2][0] + 1.0f*c[0][2] + 2.0f*c[1][2] + 1.0f*c[2][2];

	float4 Gy = -1.0f*c[2][0] - 2.0f*c[2][1] - 1.0f*c[2][1] + 1.0f*c[0][0] + 2.0f*c[0][1] + 1.0f*c[0][2];

	float4 mag = sqrt(Gx*Gx + Gy*Gy);
	mag = 1.0f - saturate(CalcLuminance(mag.rgb));

	gOutput[dispatchThreadID.xy] = mag;
}