[DirectX] 재질(Material)
in Study on WinAPI&DirectX
재질의 역할
바로 쉐이더를 참조했던 기존과는 달리, 지금부터는 Obj가 재질을 참조하고, 재질이 다시 쉐이더를 참조하는 식으로 진행할 것이다.
재질은 쉐이더를 참조할 뿐만 아니라, 쉐이더에게 전달할 값도 가지고 있을 것이다.
앞으로 재질에다가 원하는 텍스쳐를 설정해놓으면 된다.
즉, 재질에 따라서 텍스쳐가 달라지는 것이다.
같은 쉐이더를 쓰더라도 재질이 다름에 따라서 다른 형태로 보여지는 것이다.
재질 또한 여러 종류가 나올 것이기에 리소스 클래스를 상속받고, 리소스로 분류된다.
CMaterial Class 코드 구성
// 헤더파일
#pragma once
#include "CRes.h"
#include "ptr.h"
#include "CGraphicsShader.h"
#include "CTexture.h"
class CMaterial :
public CRes
{
private:
Ptr<CGraphicsShader> m_pShader;
tMtrlConst m_Const;
Ptr<CTexture> m_arrTex[TEX_END];
public:
void SetScalarParam(SCALAR_PARAM _Param, void* _Src);
void SetTexParam(TEX_PARAM _Param, const Ptr<CTexture>& _Tex);
void SetShader(Ptr<CGraphicsShader> _Shader) { m_pShader = _Shader; }
virtual void UpdateData() override;
private:
virtual int Load(const wstring& _strFilePath) { return S_OK; }
public:
virtual int Save(const wstring& _strRelativePath) { return S_OK; }
public:
CMaterial();
~CMaterial();
};
// cpp파일
#include "pch.h"
#include "CMaterial.h"
#include "CDevice.h"
#include "CConstBuffer.h"
CMaterial::CMaterial()
: CRes(RES_TYPE::MATERIAL)
, m_Const{}
, m_arrTex{}
{
}
CMaterial::~CMaterial()
{
}
void CMaterial::UpdateData()
{
if (nullptr == m_pShader)
return;
m_pShader->UpdateData();
// Texture Update
for (UINT i = 0; i < TEX_END; ++i)
{
if (nullptr == m_arrTex[i])
{
continue;
}
else
{
m_arrTex[i]->UpdateData(i, PIPELINE_STAGE::PS_PIXEL);
}
}
// Constant Update
CConstBuffer* pMtrlBuffer = CDevice::GetInst()->GetConstBuffer(CB_TYPE::MATERIAL);
pMtrlBuffer->SetData(&m_Const);
pMtrlBuffer->UpdateData();
}
void CMaterial::SetScalarParam(SCALAR_PARAM _Param, void* _Src)
{
switch (_Param)
{
case INT_0:
case INT_1:
case INT_2:
case INT_3:
m_Const.arrInt[_Param] = *((int*)_Src);
break;
case FLOAT_0:
case FLOAT_1:
case FLOAT_2:
case FLOAT_3:
m_Const.arrFloat[_Param - FLOAT_0] = *((float*)_Src);
break;
case VEC2_0:
case VEC2_1:
case VEC2_2:
case VEC2_3:
m_Const.arrV2[_Param - VEC2_0] = *((Vec2*)_Src);
break;
case VEC4_0:
case VEC4_1:
case VEC4_2:
case VEC4_3:
m_Const.arrV4[_Param - VEC4_0] = *((Vec4*)_Src);
break;
case MAT_0:
case MAT_1:
case MAT_2:
case MAT_3:
m_Const.arrMat[_Param - MAT_0] = *((Matrix*)_Src);
break;
}
}
void CMaterial::SetTexParam(TEX_PARAM _Param, const Ptr<CTexture>& _Tex)
{
m_arrTex[_Param] = _Tex;
}
tMtrlConst 구조체의 설계
상수버퍼 크기를 저장할 구조체의 설계
struct tMtrlConst
{
int arrInt[4];
float arrFloat[4];
Vec2 arrV2[4];
Vec4 arrV4[4];
Matrix arrMat[4]; // Matrix 하나당 Vec4 4개
}
define.h의 변화
원하는 Material 상수버퍼를 넣어주기 위한 구조체(SCALAR_PARAM)가 추가된다.
그리고 원하는 텍스쳐를 사용하기 위해 TEX_PARAM 구조체가 추가된다.
또한, 원하는 파이프라인을 고르기 위해 파이프라인을 설정할 PIPELINE_STAGE enum class를 추가한다.
// define.h 파일
#pragma once
#define DEVICE CDevice::GetInst()->GetDevice()
#define CONTEXT CDevice::GetInst()->GetDeviceContext()
#define CLONE(type) public: virtual type* Clone() { return new type(*this); }
#define CLONE_DISABLE(type) public: virtual type* Clone() { return nullptr; assert(nullptr); }
#define KEY_TAP(Key) CKeyMgr::GetInst()->GetKeyState(Key) == KEY_STATE::TAP
#define KEY_RELEASE(Key) CKeyMgr::GetInst()->GetKeyState(Key) == KEY_STATE::RELEASE
#define KEY_PRESSED(Key) CKeyMgr::GetInst()->GetKeyState(Key) == KEY_STATE::PRESSED
#define DT CTimeMgr::GetInst()->GetDeltaTime()
#define MAX_LAYER 32
#define SINGLE(type) private: type(); ~type(); friend class CSingleton<type>;
enum class COMPONENT_TYPE
{
// update
TRANSFORM, // 위치, 크기, 회전
COLLIDER2D, // 2차원 충돌
COLLIDER3D, // 3차원 충돌
ANIMATOR2D, // Sprite Animation
ANIMATOR3D, // Bone Sknning Animation
LIGHT2D, // 2차원 광원
LIGHT3D, // 3차원 광원
CAMERA, // Camera
// render
MESHRENDER, // 기본적인 렌더링
PARTICLESYSTEM, // 입자 렌더링
TILEMAP, // 2차원 타일
LANDSCAPE, // 3차원 지형
DECAL, // 내부 렌더링
// custom
SCRIPT,
END,
};
enum class RES_TYPE
{
MESHDATA,
MATERIAL,
PREFAB,
MESH, // 형태
TEXTURE, // 이미지
SOUND,
GRAPHICS_SHADER,
COMPUTE_SHADER,
END,
};
enum class CB_TYPE
{
TRANSFORM, // b0
MATERIAL, // b1
END,
};
enum SCALAR_PARAM
{
INT_0,
INT_1,
INT_2,
INT_3,
FLOAT_0,
FLOAT_1,
FLOAT_2,
FLOAT_3,
VEC2_0,
VEC2_1,
VEC2_2,
VEC2_3,
VEC4_0,
VEC4_1,
VEC4_2,
VEC4_3,
MAT_0,
MAT_1,
MAT_2,
MAT_3,
};
enum TEX_PARAM
{
TEX_0,
TEX_1,
TEX_2,
TEX_3,
TEX_4,
TEX_5,
TEX_6,
TEX_7,
TEX_END,
};
enum PIPELINE_STAGE
{
PS_VERTEX = 0x00,
PS_HULL = 0x01,
PS_DOMAIN = 0x02,
PS_GEOMETRY = 0x04,
PS_PIXEL = 0x08,
PS_ALL = PS_VERTEX | PS_HULL | PS_DOMAIN | PS_GEOMETRY | PS_PIXEL,
};
CDevice의 변화
이에 따라 상수버퍼를 관리하고 있는 Device 클래스에도 변화가 생긴다.
그리고 Sampler State와 관련된 함수(CreateSampler)를 추가하였다.
여기서 D3D11_TEXTURE_ADDRESS_WRAP은 텍스쳐가 반복된다고 보는 것이다.
이것이 무슨 소리냐, 만약에 UV좌표계에서 1을 초과한 좌표값이 들어온다면 어떻게 될까?
WRAP 모드 : 텍스쳐가 1마다 반복되는 구조로 본다.
예를 들어 1.1이 들어올 경우 0.1과 같은 값으로 본다.MIRROR 모드 : 텍스쳐가 1을 기준으로 반전되는 구조로 본다.
예를 들어 1.1이 들어올 경우 0.9와 같은 값으로 본다.
// 헤더파일
#pragma once
class CConstBuffer;
class CDevice
: public CSingleton<CDevice>
{
private:
HWND m_hWnd;
ComPtr<ID3D11Device> m_Device; // GPU 메모리 할당
ComPtr<ID3D11DeviceContext> m_Context; // GPU 제어, 렌더링, 동작 수행
ComPtr<IDXGISwapChain> m_SwapChain;
ComPtr<ID3D11Texture2D> m_RTTex;
ComPtr<ID3D11RenderTargetView> m_RTV;
ComPtr<ID3D11Texture2D> m_DSTex;
ComPtr<ID3D11DepthStencilView> m_DSV;
// Sampler
ComPtr<ID3D11SamplerState> m_Sampler[2];
D3D11_VIEWPORT m_ViewPort;
// 렌더타겟 해상도
Vec2 m_vRenderResolution;
CConstBuffer* m_arrConstBuffer[(UINT)CB_TYPE::END];
// ID3D11RenderTargetView
// ID3D11DepthStencilView
// ID3D11ShaderResourceView
// ID3D11UnorderedAccessView
public:
int init(HWND _hWnd, UINT _iWidth, UINT _iHeight);
void ClearTarget(float(&_color)[4]);
void Present() { m_SwapChain->Present(0, 0); }
private:
int CreateSwapChain();
int CreateView();
int CreateSampler();
void CreateConstBuffer();
public:
ID3D11Device* GetDevice() { return m_Device.Get(); }
ID3D11DeviceContext* GetDeviceContext() { return m_Context.Get(); }
CConstBuffer* GetConstBuffer(CB_TYPE _Type) { return m_arrConstBuffer[(UINT)_Type]; }
public:
CDevice();
~CDevice();
};
// cpp파일
#include "pch.h"
#include "CDevice.h"
#include "CEngine.h"
#include "CConstBuffer.h"
CDevice::CDevice()
: m_hWnd(nullptr)
, m_ViewPort{}
, m_arrConstBuffer{}
{
}
CDevice::~CDevice()
{
Safe_Del_Array(m_arrConstBuffer);
}
int CDevice::init(HWND _hWnd, UINT _iWidth, UINT _iHeight)
{
m_hWnd = _hWnd;
m_vRenderResolution = Vec2((float)_iWidth, (float)_iHeight);
int iFlag = 0;
#ifdef _DEBUG
iFlag = D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_FEATURE_LEVEL eLevel = D3D_FEATURE_LEVEL::D3D_FEATURE_LEVEL_11_0;
if (FAILED(D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE
, nullptr, iFlag
, nullptr, 0
, D3D11_SDK_VERSION
, m_Device.GetAddressOf(), &eLevel
, m_Context.GetAddressOf())))
{
MessageBox(nullptr, L"Device, Context 생성 실패", L"Device 초기화 에러", MB_OK);
return E_FAIL;
}
if (FAILED(CreateSwapChain()))
{
MessageBox(nullptr, L"스왚체인 생성 실패", L"Device 초기화 에러", MB_OK);
return E_FAIL;
}
if (FAILED(CreateView()))
{
MessageBox(nullptr, L"View 생성 실패", L"Device 초기화 에러", MB_OK);
return E_FAIL;
}
// 출력 타겟 설정
m_Context->OMSetRenderTargets(1, m_RTV.GetAddressOf(), m_DSV.Get());
// ViewPort 설정
m_ViewPort.TopLeftX = 0.f;
m_ViewPort.TopLeftY = 0.f;
Vec2 vWindowResol = CEngine::GetInst()->GetWindowResolution();
m_ViewPort.Width = vWindowResol.x;
m_ViewPort.Height = vWindowResol.y;
m_ViewPort.MinDepth = 0.f;
m_ViewPort.MaxDepth = 1.f;
m_Context->RSSetViewports(1, &m_ViewPort);
// 샘플러 생성
if (FAILED(CreateSampler()))
{
MessageBox(nullptr, L"샘플러 생성 실패", L"Device 초기화 에러", MB_OK);
return E_FAIL;
}
// 상수버퍼 생성
CreateConstBuffer();
return S_OK; // E_FAIL;
}
int CDevice::CreateSwapChain()
{
// 스왚체인 설정
DXGI_SWAP_CHAIN_DESC tDesc = {};
tDesc.OutputWindow = m_hWnd; // 출력 윈도우
tDesc.Windowed = true; // 창모드, 전체화면 모드
tDesc.BufferCount = 1;
tDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
tDesc.BufferDesc.Width = (UINT)m_vRenderResolution.x;
tDesc.BufferDesc.Height = (UINT)m_vRenderResolution.y;
tDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
tDesc.BufferDesc.RefreshRate.Denominator = 1;
tDesc.BufferDesc.RefreshRate.Numerator = 60;
tDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
tDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER::DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
tDesc.SwapEffect = DXGI_SWAP_EFFECT::DXGI_SWAP_EFFECT_DISCARD;
tDesc.SampleDesc.Count = 1;
tDesc.SampleDesc.Quality = 0;
tDesc.Flags = 0;
// 스왚체인 생성
ComPtr<IDXGIDevice> pDXGIDevice;
ComPtr<IDXGIAdapter> pAdapter;
ComPtr<IDXGIFactory> pFactory;
HRESULT hr = S_OK;
hr = m_Device->QueryInterface(__uuidof(IDXGIDevice), (void**)pDXGIDevice.GetAddressOf());
hr = pDXGIDevice->GetParent(__uuidof(IDXGIAdapter), (void**)pAdapter.GetAddressOf());
hr = pAdapter->GetParent(__uuidof(IDXGIFactory), (void**)pFactory.GetAddressOf());
hr = pFactory->CreateSwapChain(m_Device.Get(), &tDesc, m_SwapChain.GetAddressOf());
return hr;
}
int CDevice::CreateView()
{
m_SwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)m_RTTex.GetAddressOf());
if (FAILED(m_Device->CreateRenderTargetView(m_RTTex.Get(), nullptr, m_RTV.GetAddressOf())))
{
return E_FAIL;
}
// DepthStencil 용도 텍스쳐 생성
D3D11_TEXTURE2D_DESC tDesc = {};
tDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
// 반드시 렌더타겟과 같은 해상도로 설정해야 함
tDesc.Width = (UINT)m_vRenderResolution.x;
tDesc.Height = (UINT)m_vRenderResolution.y;
tDesc.ArraySize = 1;
tDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
tDesc.Usage = D3D11_USAGE_DEFAULT;
tDesc.CPUAccessFlags = 0;
tDesc.MipLevels = 1; // 원본만 생성
tDesc.SampleDesc.Count = 1;
tDesc.SampleDesc.Quality = 0;
if (FAILED(m_Device->CreateTexture2D(&tDesc, nullptr, m_DSTex.GetAddressOf())))
{
return E_FAIL;
}
// DepthStencilView 생성
if (FAILED(m_Device->CreateDepthStencilView(m_DSTex.Get(), nullptr, m_DSV.GetAddressOf())))
{
return E_FAIL;
}
return S_OK;
}
int CDevice::CreateSampler()
{
D3D11_SAMPLER_DESC tSamDesc = {};
tSamDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
tSamDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
tSamDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
tSamDesc.Filter = D3D11_FILTER_ANISOTROPIC;
DEVICE->CreateSamplerState(&tSamDesc, m_Sampler[0].GetAddressOf());
tSamDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
tSamDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
tSamDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
tSamDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
DEVICE->CreateSamplerState(&tSamDesc, m_Sampler[1].GetAddressOf());
CONTEXT->VSSetSamplers(0, 1, m_Sampler[0].GetAddressOf());
CONTEXT->HSSetSamplers(0, 1, m_Sampler[0].GetAddressOf());
CONTEXT->DSSetSamplers(0, 1, m_Sampler[0].GetAddressOf());
CONTEXT->GSSetSamplers(0, 1, m_Sampler[0].GetAddressOf());
CONTEXT->PSSetSamplers(0, 1, m_Sampler[0].GetAddressOf());
CONTEXT->VSSetSamplers(1, 1, m_Sampler[1].GetAddressOf());
CONTEXT->HSSetSamplers(1, 1, m_Sampler[1].GetAddressOf());
CONTEXT->DSSetSamplers(1, 1, m_Sampler[1].GetAddressOf());
CONTEXT->GSSetSamplers(1, 1, m_Sampler[1].GetAddressOf());
CONTEXT->PSSetSamplers(1, 1, m_Sampler[1].GetAddressOf());
return S_OK;
}
void CDevice::ClearTarget(float(&_color)[4])
{
m_Context->ClearRenderTargetView(m_RTV.Get(), _color);
m_Context->ClearDepthStencilView(m_DSV.Get(), D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.f, 0);
}
void CDevice::CreateConstBuffer()
{
m_arrConstBuffer[(UINT)CB_TYPE::TRANSFORM] = new CConstBuffer((UINT)CB_TYPE::TRANSFORM);
m_arrConstBuffer[(UINT)CB_TYPE::TRANSFORM]->Create(sizeof(Vec4), 1);
m_arrConstBuffer[(UINT)CB_TYPE::MATERIAL] = new CConstBuffer((UINT)CB_TYPE::MATERIAL);
m_arrConstBuffer[(UINT)CB_TYPE::MATERIAL]->Create(sizeof(tMtrlConst), 1);
}
쉐이더 코드의 변화
상수버퍼 MATERIAL이 추가되었다.
그리고 쉐이더 코드에서는 무조건 배열의 개수만큼 선언을 일일이 해줘야한다.
요소 하나당 크기가 16비트이기 때문에 메모리가 꼬이는 것을 방지하기 위함.
또한, 텍스쳐를 여러장 쓰기 위해서 Texture2D g_tex_# : register(t#)을 여러개 추가한다.
// example
// int arrInt[4]; 을 선언했을 경우
int g_int_0;
int g_int_1;
int g_int_2;
int g_int_3;
// float arrFloat[4]; 을 선언했을 경우
float g_float_0;
float g_float_1;
float g_float_2;
float g_float_3;
#ifndef _TEST
#define _TEST
cbuffer TRANSFORM : register(b0)
{
float4 vPlayerPos;
};
cbuffer MATERIAL : register(b1)
{
int g_int_0;
int g_int_1;
int g_int_2;
int g_int_3;
float g_float_0;
float g_float_1;
float g_float_2;
float g_float_3;
float2 g_vec2_0;
float2 g_vec2_1;
float2 g_vec2_2;
float2 g_vec2_3;
float4 g_vec4_0;
float4 g_vec4_1;
float4 g_vec4_2;
float4 g_vec4_3;
matrix g_mat_0;
matrix g_mat_1;
matrix g_mat_2;
matrix g_mat_3;
};
Texture2D g_tex_0 : register(t0);
Texture2D g_tex_1 : register(t1);
Texture2D g_tex_2 : register(t2);
Texture2D g_tex_3 : register(t3);
Texture2D g_tex_4 : register(t4);
Texture2D g_tex_5 : register(t5);
Texture2D g_tex_6 : register(t6);
Texture2D g_tex_7 : register(t7);
SamplerState g_sam_0 : register(s0);
SamplerState g_sam_1 : register(s1);
// VS 입력 구조체
struct VS_IN
{
float3 vPos : POSITION; // semantic
float4 vColor : COLOR;
float2 vUV : TEXCOORD;
};
struct VS_OUT
{
float4 vPosition : SV_Position;
float4 vOutColor : COLOR;
float2 vOutUV : TEXCOORD;
};
// vertex shader
// LocalSpace 물체를 NDC 좌표계로 이동
VS_OUT VS_Test(VS_IN _in)
{
VS_OUT output = (VS_OUT) 0.f;
// 입력으로 들어온 정점좌표에 상수버퍼 값을 더해서 출력
float3 vPos = _in.vPos;
vPos.xy += vPlayerPos.xy;
output.vPosition = float4(vPos, 1.f);
output.vOutColor = _in.vColor;
output.vOutUV = _in.vUV;
return output;
}
// pixel shader
float4 PS_Test(VS_OUT _in) : SV_Target
{
float4 vColor = (float4) 0.f;
if(g_int_0 == 0)
vColor = g_tex_0.Sample(g_sam_0, _in.vOutUV);
else if(g_int_0 == 1)
vColor = g_tex_0.Sample(g_sam_1, _in.vOutUV);
return vColor;
}
#endif
//struct PS_OUT
//{
// float4 vColor : SV_Target;
//};
//PS_OUT PS_Test(VS_OUT _in)
//{
// PS_OUT output = (PS_OUT) 0.f;
// output.vColor = float4(1.f, 0.f, 0.f, 1.f);
// return output;
//}
CMeshRender 클래스의 변화
메쉬렌더가 이제 쉐이더를 직접 참조하는 것이 아니라, 재질(Material)을 참조해야 하므로 변화가 생긴다.
또한, 업데이트도 재질을 업데이트 하는 과정이 추가로 진행된다.
// 헤더파일
#pragma once
#include "CComponent.h"
#include "CMesh.h"
#include "CGraphicsShader.h"
#include "CMaterial.h"
#include "ptr.h"
class CMeshRender :
public CComponent
{
private:
Ptr<CMesh> m_pMesh;
Ptr<CMaterial> m_pMtrl;
public:
void SetMesh(Ptr<CMesh> _Mesh) { m_pMesh = _Mesh; }
void SetMaterial(Ptr<CMaterial> _Mtrl) { m_pMtrl = _Mtrl; }
Ptr<CMesh> GetMesh() { return m_pMesh; }
Ptr<CMaterial> GetMaterial() { return m_pMtrl; }
public:
virtual void finaltick() override;
void render();
CLONE(CMeshRender);
public:
CMeshRender();
~CMeshRender();
};
// cpp파일
#include "pch.h"
#include "CMeshRender.h"
#include "CTransform.h"
CMeshRender::CMeshRender()
: CComponent(COMPONENT_TYPE::MESHRENDER)
{
}
CMeshRender::~CMeshRender()
{
}
void CMeshRender::finaltick()
{
}
void CMeshRender::render()
{
if (nullptr == m_pMesh || nullptr == m_pMtrl)
return;
// Transform 에 UpdateData 요청
Transform()->UpdateData();
m_pMtrl->UpdateData();
m_pMesh->render();
}
CConstBuffer 클래스의 변화
// 헤더파일
#pragma once
#include "CEntity.h"
class CConstBuffer :
public CEntity
{
private:
ComPtr<ID3D11Buffer> m_CB;
D3D11_BUFFER_DESC m_Desc;
const UINT m_iRegisterNum;
UINT m_iElementSize;
UINT m_iElementCount;
public:
void Create(UINT _iElementSize, UINT _iElementCount);
void SetData(void* _pSrc, UINT _iSize = 0);
void UpdateData();
CLONE_DISABLE(CConstBuffer);
public:
CConstBuffer(UINT _iRegisterNum);
~CConstBuffer();
};
// cpp파일
#include "pch.h"
#include "CConstBuffer.h"
#include "CDevice.h"
CConstBuffer::CConstBuffer(UINT _iRegisterNum)
: m_Desc{}
, m_iRegisterNum(_iRegisterNum)
, m_iElementSize(0)
, m_iElementCount(0)
{
}
CConstBuffer::~CConstBuffer()
{
}
void CConstBuffer::Create(UINT _iElementSize, UINT _iElementCount)
{
m_iElementSize = _iElementSize;
m_iElementCount = _iElementCount;
UINT iBufferSize = m_iElementSize * _iElementCount;
// 16바이트 단위 메모리 정렬
assert(!(iBufferSize % 16));
// 상수버퍼 생성
m_Desc.ByteWidth = iBufferSize;
m_Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
m_Desc.Usage = D3D11_USAGE_DYNAMIC;
m_Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
if (FAILED(DEVICE->CreateBuffer(&m_Desc, nullptr, m_CB.GetAddressOf())))
{
assert(nullptr);
}
}
void CConstBuffer::SetData(void* _pSrc, UINT _iSize)
{
// 크기가 지정되지 않은 데이터는 상수버퍼 크기로 본다.
UINT size = _iSize;
if (0 == _iSize)
{
size = m_iElementSize* m_iElementCount;
}
// 상수버퍼 크기보다 더 큰 데이터가 입력으로 들어온 경우
assert(!(size > m_iElementSize * m_iElementCount));
// SysMem -> GPU Mem
D3D11_MAPPED_SUBRESOURCE tSubRes = {};
if (!FAILED(CONTEXT->Map(m_CB.Get(), 0, D3D11_MAP::D3D11_MAP_WRITE_DISCARD, 0, &tSubRes)))
{
memcpy(tSubRes.pData, _pSrc, size);
CONTEXT->Unmap(m_CB.Get(), 0);
}
}
void CConstBuffer::UpdateData()
{
CONTEXT->VSSetConstantBuffers(m_iRegisterNum, 1, m_CB.GetAddressOf());
CONTEXT->HSSetConstantBuffers(m_iRegisterNum, 1, m_CB.GetAddressOf());
CONTEXT->DSSetConstantBuffers(m_iRegisterNum, 1, m_CB.GetAddressOf());
CONTEXT->GSSetConstantBuffers(m_iRegisterNum, 1, m_CB.GetAddressOf());
CONTEXT->PSSetConstantBuffers(m_iRegisterNum, 1, m_CB.GetAddressOf());
}
CResMgr 클래스의 변화
재질을 만드는 과정이 추가된다.
(CreateDefaultMaterial 함수)
그리고 ResMgr는 텍스쳐를 로딩만 하고, 재질에게 전달한다. 그리고 재질이 쉐이더에게 텍스쳐를 전달하는 역할을 하도록 만든다.
// 헤더파일
#pragma once
#include "CSingleton.h"
#include "ptr.h"
#include "CMesh.h"
#include "CTexture.h"
#include "CGraphicsShader.h"
#include "CMaterial.h"
class CResMgr :
public CSingleton<CResMgr>
{
SINGLE(CResMgr)
private:
map<wstring, Ptr<CRes>> m_arrRes[(UINT)RES_TYPE::END];
public:
void init();
private:
void CreateDefaultMesh();
void CreateDefaultGraphicsShader();
void CreateDefaultMaterial();
void LoadDefaultTexture();
public:
template<typename T>
Ptr<T> FindRes(const wstring& _strKey);
template<typename T>
void AddRes(const wstring& _strKey, Ptr<T>& _Res);
template<typename T>
Ptr<T> Load(const wstring& _strKey, const wstring& _strRelativePath);
};
template<typename T>
RES_TYPE GetResType()
{
const type_info& mesh = typeid(CMesh);
//const type_info& meshdata = typeid(CMeshData);
const type_info& material = typeid(CMaterial);
const type_info& texture = typeid(CTexture);
//const type_info& sound = typeid(CSound);
//const type_info& prefab = typeid(CPrefab);
const type_info& gs = typeid(CGraphicsShader);
//const type_info& cs = typeid(CComputeShader);
if (typeid(T).hash_code() == mesh.hash_code())
return RES_TYPE::MESH;
if (typeid(T).hash_code() == gs.hash_code())
return RES_TYPE::GRAPHICS_SHADER;
if (typeid(T).hash_code() == texture.hash_code())
return RES_TYPE::TEXTURE;
if (typeid(T).hash_code() == material.hash_code())
return RES_TYPE::MATERIAL;
return RES_TYPE::END;
}
template<typename T>
inline Ptr<T> CResMgr::FindRes(const wstring& _strKey)
{
RES_TYPE type = GetResType<T>();
map<wstring, Ptr<CRes>>::iterator iter = m_arrRes[(UINT)type].find(_strKey);
if (iter == m_arrRes[(UINT)type].end())
return nullptr;
return (T*)iter->second.Get();
}
template<typename T>
inline void CResMgr::AddRes(const wstring& _strKey, Ptr<T>& _Res)
{
// 중복키로 리소스 추가하려는 경우
assert( ! FindRes<T>(_strKey).Get() );
RES_TYPE type = GetResType<T>();
m_arrRes[(UINT)type].insert(make_pair(_strKey, _Res.Get()));
_Res->SetKey(_strKey);
}
template<typename T>
inline Ptr<T> CResMgr::Load(const wstring& _strKey, const wstring& _strRelativePath)
{
Ptr<CRes> pRes = FindRes<T>(_strKey).Get();
// 이미 해당 키로 리소스가 있다면, 반환
if (nullptr != pRes)
return (T*)pRes.Get();
pRes = new T;
pRes->SetKey(_strKey);
pRes->SetRelativePath(_strRelativePath);
wstring strFilePath = CPathMgr::GetInst()->GetContentPath();
strFilePath += _strRelativePath;
if (FAILED(pRes->Load(strFilePath)))
{
assert(nullptr);
}
RES_TYPE type = GetResType<T>();
m_arrRes[(UINT)type].insert(make_pair(_strKey, pRes));
return (T*)pRes.Get();
}
// cpp파일
#include "pch.h"
#include "CResMgr.h"
#include "CPathMgr.h"
CResMgr::CResMgr()
{
}
CResMgr::~CResMgr()
{
}
void CResMgr::init()
{
CreateDefaultMesh();
CreateDefaultGraphicsShader();
CreateDefaultMaterial();
LoadDefaultTexture();
}
void CResMgr::CreateDefaultMesh()
{
vector<Vtx> vecVtx;
vector<UINT> vecIdx;
Vtx v;
Ptr<CMesh> pMesh = nullptr;
// =============
// RectMesh 생성
// =============
// 0 --- 1
// | \ |
// 3 --- 2
v.vPos = Vec3(-0.5f, 0.5f, 0.5f);
v.vColor = Vec4(1.f, 0.f, 0.f, 1.f);
v.vUV = Vec2(0.f, 0.f);
vecVtx.push_back(v);
v.vPos = Vec3(0.5f, 0.5f, 0.5f);
v.vColor = Vec4(0.f, 1.f, 0.f, 1.f);
v.vUV = Vec2(1.f, 0.f);
vecVtx.push_back(v);
v.vPos = Vec3(0.5f, -0.5f, 0.5f);
v.vColor = Vec4(0.f, 0.f, 1.f, 1.f);
v.vUV = Vec2(1.f, 1.f);
vecVtx.push_back(v);
v.vPos = Vec3(-0.5f, -0.5f, 0.5f);
v.vColor = Vec4(0.f, 0.f, 0.f, 1.f);
v.vUV = Vec2(0.f, 1.f);
vecVtx.push_back(v);
vecIdx.push_back(0);
vecIdx.push_back(2);
vecIdx.push_back(3);
vecIdx.push_back(0);
vecIdx.push_back(1);
vecIdx.push_back(2);
pMesh = new CMesh;
pMesh->Create(vecVtx.data(), (UINT)vecVtx.size(), vecIdx.data(), (UINT)vecIdx.size());
AddRes(L"RectMesh", pMesh);
}
void CResMgr::CreateDefaultGraphicsShader()
{
Ptr<CGraphicsShader> pShader = nullptr;
// ===========
// Test Shader
// ===========
pShader = new CGraphicsShader;
pShader->SetKey(L"TestShader");
pShader->CreateVertexShader(L"shader\\test.fx", "VS_Test");
pShader->CreatePixelShader(L"shader\\test.fx", "PS_Test");
AddRes(L"TestShader", pShader);
}
void CResMgr::CreateDefaultMaterial()
{
Ptr<CMaterial> pMtrl = nullptr;
// Test Material
pMtrl = new CMaterial;
pMtrl->SetShader(FindRes<CGraphicsShader>(L"TestShader"));
AddRes(L"TestMtrl", pMtrl);
}
void CResMgr::LoadDefaultTexture()
{
Ptr<CTexture> pTexture = Load<CTexture>(L"PlayerTex", L"texture\\Fighter.bmp");
}
CPlayerScript 클래스의 변화
객체를 구분짓기 위해서 CMeshRender 헤더를 include한다.
그리고 0번과 1번을 누를 때마다 상수버퍼값을 바꿔본다.
// 헤더파일
#pragma once
#include "CScript.h"
class CPlayerScript :
public CScript
{
private:
public:
virtual void tick() override;
CLONE(CPlayerScript);
public:
CPlayerScript();
~CPlayerScript();
};
// cpp파일
#include "pch.h"
#include "CPlayerScript.h"
#include "CMeshRender.h"
#include "CMaterial.h"
CPlayerScript::CPlayerScript()
{
}
CPlayerScript::~CPlayerScript()
{
}
void CPlayerScript::tick()
{
Vec3 vCurPos = Transform()->GetRelativePos();
if (KEY_PRESSED(KEY::UP))
{
for (int i = 0; i < 4; ++i)
{
vCurPos.y += DT * 1.f;
}
}
if (KEY_PRESSED(KEY::DOWN))
{
for (int i = 0; i < 4; ++i)
{
vCurPos.y -= DT * 1.f;
}
}
if (KEY_PRESSED(KEY::LEFT))
{
for (int i = 0; i < 4; ++i)
{
vCurPos.x -= DT * 1.f;
}
}
if (KEY_PRESSED(KEY::RIGHT))
{
for (int i = 0; i < 4; ++i)
{
vCurPos.x += DT * 1.f;
}
}
Transform()->SetRelativePos(vCurPos);
if (KEY_TAP(KEY::_1))
{
int a = 0;
MeshRender()->GetMaterial()->SetScalarParam(INT_0, &a);
}
else if (KEY_TAP(KEY::_2))
{
int a = 1;
MeshRender()->GetMaterial()->SetScalarParam(INT_0, &a);
}
}
CTexture 클래스의 변화
원하는 파이프라인을 고를 수 있도록 세팅을 변경한다.
(UpdateData 함수의 변화)
// 헤더파일
#pragma once
#include "CRes.h"
#include <DirectXTex\DirectXTex.h>
#ifdef _DEBUG
#pragma comment(lib, "DirectXTex//DirectXTex_debug")
#else
#pragma comment(lib, "DirectXTex//DirectXTex")
#endif
class CTexture :
public CRes
{
private:
ComPtr<ID3D11Texture2D> m_Tex2D;
ComPtr<ID3D11ShaderResourceView> m_SRV;
D3D11_TEXTURE2D_DESC m_Desc;
ScratchImage m_Image;
private:
virtual int Load(const wstring& _strFilePath) override;
public:
virtual int Save(const wstring& _strRelativePath) override;
public:
// _PipelineStage : PIPELINE_STAGE
void UpdateData(int _iRegisterNum, int _PipelineStage);
private:
virtual void UpdateData() override;
public:
CTexture();
~CTexture();
};
// cpp파일
#include "pch.h"
#include "CTexture.h"
#include "CDevice.h"
CTexture::CTexture()
: CRes(RES_TYPE::TEXTURE)
, m_Desc{}
{
}
CTexture::~CTexture()
{
}
void CTexture::UpdateData(int _iRegisterNum, int _PipelineStage)
{
if (PIPELINE_STAGE::PS_VERTEX & _PipelineStage)
{
CONTEXT->VSSetShaderResources(_iRegisterNum, 1, m_SRV.GetAddressOf());
}
if (PIPELINE_STAGE::PS_HULL & _PipelineStage)
{
CONTEXT->HSSetShaderResources(_iRegisterNum, 1, m_SRV.GetAddressOf());
}
if (PIPELINE_STAGE::PS_DOMAIN & _PipelineStage)
{
CONTEXT->DSSetShaderResources(_iRegisterNum, 1, m_SRV.GetAddressOf());
}
if (PIPELINE_STAGE::PS_GEOMETRY & _PipelineStage)
{
CONTEXT->GSSetShaderResources(_iRegisterNum, 1, m_SRV.GetAddressOf());
}
if (PIPELINE_STAGE::PS_PIXEL & _PipelineStage)
{
CONTEXT->PSSetShaderResources(_iRegisterNum, 1, m_SRV.GetAddressOf());
}
}
void CTexture::UpdateData()
{
}
int CTexture::Load(const wstring& _strFilePath)
{
wchar_t szExt[50] = L"";
_wsplitpath_s(_strFilePath.c_str(), nullptr, 0, nullptr, 0, nullptr, 0, szExt, 50);
wstring strExt = szExt;
HRESULT hr = S_OK;
if (L".dds" == strExt || L".DDS" == strExt)
{
// dds, DDS
hr = LoadFromDDSFile(_strFilePath.c_str(), DDS_FLAGS::DDS_FLAGS_NONE, nullptr, m_Image);
}
else if (L".tga" == strExt || L".TGA" == strExt)
{
// tga, TGA
hr = LoadFromTGAFile(_strFilePath.c_str(), nullptr, m_Image);
}
else
{
// png, jpg, jpeg, bmp
hr = LoadFromWICFile(_strFilePath.c_str(), WIC_FLAGS::WIC_FLAGS_NONE, nullptr, m_Image);
}
if (FAILED(hr))
{
MessageBox(nullptr, L"리소스 로딩 실패", L"텍스쳐 로딩 실패", MB_OK);
return E_FAIL;
}
hr = CreateShaderResourceView(DEVICE
, m_Image.GetImages()
, m_Image.GetImageCount()
, m_Image.GetMetadata()
, m_SRV.GetAddressOf());
if (FAILED(hr))
{
MessageBox(nullptr, L"ShaderResourceView 생성 실패", L"텍스쳐 로딩 실패", MB_OK);
return E_FAIL;
}
m_SRV->GetResource((ID3D11Resource**)m_Tex2D.GetAddressOf());
m_Tex2D->GetDesc(&m_Desc);
return S_OK;
}
int CTexture::Save(const wstring& _strRelativePath)
{
return S_OK;
}
