xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9fe79681fb1540278db2a5e19d007bc4ef874c02
XCEngine/tests/D3D12/main.cpp

643 lines
26 KiB
C++
Raw Blame History

#include <windows.h>
#include <d3d12.h>
#include <dxgi1_4.h>
#include "XCEngine/RHI/D3D12/D3D12Shader.h"
#include <DirectXMath.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdarg.h>
#include <algorithm>
#include <unordered_map>
#include <string>
#include <cstring>
#include "stbi/stb_image.h"
#include "XCEngine/RHI/Enums.h"
#include "XCEngine/RHI/Types.h"
#include "XCEngine/RHI/Enums.h"
#include "XCEngine/RHI/D3D12/D3D12Enum.h"
#include "XCEngine/RHI/D3D12/D3D12Device.h"
#include "XCEngine/RHI/D3D12/D3D12CommandQueue.h"
#include "XCEngine/RHI/D3D12/D3D12CommandAllocator.h"
#include "XCEngine/RHI/D3D12/D3D12CommandList.h"
#include "XCEngine/RHI/D3D12/D3D12DescriptorHeap.h"
#include "XCEngine/RHI/D3D12/D3D12Fence.h"
#include "XCEngine/RHI/D3D12/D3D12SwapChain.h"
#include "XCEngine/RHI/D3D12/D3D12RootSignature.h"
#include "XCEngine/RHI/D3D12/D3D12PipelineState.h"
#include "XCEngine/RHI/D3D12/D3D12Buffer.h"
#include "XCEngine/RHI/D3D12/D3D12Texture.h"
#include "XCEngine/RHI/D3D12/D3D12RenderTargetView.h"
#include "XCEngine/RHI/D3D12/D3D12DepthStencilView.h"
#include "XCEngine/RHI/D3D12/D3D12ShaderResourceView.h"
#include "XCEngine/RHI/D3D12/D3D12Screenshot.h"
#include "XCEngine/Debug/Logger.h"
#include "XCEngine/Debug/ConsoleLogSink.h"
#include "XCEngine/Debug/FileLogSink.h"
using namespace XCEngine::RHI;
using namespace XCEngine::Debug;
#pragma comment(lib,"d3d12.lib")
#pragma comment(lib,"dxgi.lib")
#pragma comment(lib,"d3dcompiler.lib")
#pragma comment(lib,"winmm.lib")
void Log(const char* format, ...) {
char buffer[1024];
va_list args;
va_start(args, format);
vsnprintf(buffer, sizeof(buffer), format, args);
va_end(args);
Logger::Get().Debug(LogCategory::Rendering, buffer);
}
//=================================================================================
// D3D12 核心全局对象 (最小渲染所需)
//=================================================================================
XCEngine::RHI::D3D12Device gD3D12Device; // 底层实现
XCEngine::RHI::D3D12CommandQueue gCommandQueue;
XCEngine::RHI::D3D12SwapChain gSwapChain;
// 渲染目标 (SwapChain的后台Buffer)
XCEngine::RHI::D3D12Texture gColorRTs[2]; // 颜色缓冲 (双缓冲)
int gCurrentRTIndex = 0;
// 描述符堆
XCEngine::RHI::D3D12DescriptorHeap gSwapChainRTVHeap; // RTV堆
XCEngine::RHI::D3D12DescriptorHeap gSwapChainDSVHeap; // DSV堆
XCEngine::RHI::D3D12RenderTargetView gSwapChainRTVs[2];
XCEngine::RHI::D3D12DepthStencilView gSwapChainDSV;
UINT gRTVDescriptorSize = 0;
UINT gDSVDescriptorSize = 0;
// 命令相关
XCEngine::RHI::D3D12CommandAllocator gCommandAllocator;
XCEngine::RHI::D3D12CommandList gCommandList;
XCEngine::RHI::D3D12RootSignature gRootSignature;
XCEngine::RHI::D3D12PipelineState gPipelineState;
XCEngine::RHI::D3D12Shader gVertexShader;
XCEngine::RHI::D3D12Shader gGeometryShader;
XCEngine::RHI::D3D12Shader gPixelShader;
// Buffer objects
XCEngine::RHI::D3D12Buffer gConstantBuffer; // matrices
XCEngine::RHI::D3D12Buffer gMaterialBuffer; // material data
XCEngine::RHI::D3D12Texture gTexture; // earth texture
XCEngine::RHI::D3D12Texture gDepthStencil; // depth stencil buffer
XCEngine::RHI::D3D12ShaderResourceView gTextureSRV; // texture SRV
// 同步对象
XCEngine::RHI::D3D12Fence gFence;
UINT64 gFenceValue = 0;
//=================================================================================
// 工具函数
//=================================================================================
float srandom() {
float number = float(rand()) / float(RAND_MAX);
number *= 2.0f;
number -= 1.0f;
return number;
}
//=================================================================================
// 数据结构定义
//=================================================================================
struct StaticMeshComponentVertexData {
float mPosition[4];
float mTexcoord[4];
float mNormal[4];
float mTangent[4];
};
struct SubMesh {
XCEngine::RHI::D3D12Buffer mIBO;
int mIndexCount;
};
//=================================================================================
// 网格组件类 (StaticMeshComponent)
// 封装顶点缓冲(VBO)、索引缓冲(IBO)和渲染逻辑
//=================================================================================
class StaticMeshComponent {
public:
XCEngine::RHI::D3D12Buffer mVBO;
StaticMeshComponentVertexData* mVertexData;
int mVertexCount;
uint32_t mStride;
std::unordered_map<std::string, SubMesh*> mSubMeshes;
void SetVertexCount(int inVertexCount) {
mVertexCount = inVertexCount;
mVertexData = new StaticMeshComponentVertexData[inVertexCount];
memset(mVertexData, 0, sizeof(StaticMeshComponentVertexData) * inVertexCount);
}
void SetVertexPosition(int inIndex, float inX, float inY, float inZ, float inW = 1.0f) {
mVertexData[inIndex].mPosition[0] = inX;
mVertexData[inIndex].mPosition[1] = inY;
mVertexData[inIndex].mPosition[2] = inZ;
mVertexData[inIndex].mPosition[3] = inW;
}
void SetVertexTexcoord(int inIndex, float inX, float inY, float inZ, float inW = 1.0f) {
mVertexData[inIndex].mTexcoord[0] = inX;
mVertexData[inIndex].mTexcoord[1] = inY;
mVertexData[inIndex].mTexcoord[2] = inZ;
mVertexData[inIndex].mTexcoord[3] = inW;
}
void SetVertexNormal(int inIndex, float inX, float inY, float inZ, float inW = 1.0f) {
mVertexData[inIndex].mNormal[0] = inX;
mVertexData[inIndex].mNormal[1] = inY;
mVertexData[inIndex].mNormal[2] = inZ;
mVertexData[inIndex].mNormal[3] = inW;
}
void SetVertexTangent(int inIndex, float inX, float inY, float inZ, float inW = 1.0f) {
mVertexData[inIndex].mTangent[0] = inX;
mVertexData[inIndex].mTangent[1] = inY;
mVertexData[inIndex].mTangent[2] = inZ;
mVertexData[inIndex].mTangent[3] = inW;
}
void InitFromFile(ID3D12GraphicsCommandList* inCommandList, const char* inFilePath) {
FILE* pFile = nullptr;
errno_t err = fopen_s(&pFile, inFilePath, "rb");
if (err == 0) {
int temp = 0;
fread(&temp, 4, 1, pFile);
mVertexCount = temp;
mStride = sizeof(StaticMeshComponentVertexData);
mVertexData = new StaticMeshComponentVertexData[mVertexCount];
fread(mVertexData, 1, sizeof(StaticMeshComponentVertexData) * mVertexCount, pFile);
mVBO.InitializeWithData(gD3D12Device.GetDevice(), inCommandList, mVertexData,
sizeof(StaticMeshComponentVertexData) * mVertexCount,
D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER);
while (!feof(pFile)) {
fread(&temp, 4, 1, pFile);
if (feof(pFile)) {
break;
}
char name[256] = { 0 };
fread(name, 1, temp, pFile);
fread(&temp, 4, 1, pFile);
SubMesh* submesh = new SubMesh;
submesh->mIndexCount = temp;
unsigned int* indexes = new unsigned int[temp];
fread(indexes, 1, sizeof(unsigned int) * temp, pFile);
submesh->mIBO.InitializeWithData(gD3D12Device.GetDevice(), inCommandList, indexes,
sizeof(unsigned int) * temp,
D3D12_RESOURCE_STATE_INDEX_BUFFER);
mSubMeshes.insert(std::pair<std::string, SubMesh*>(name, submesh));
delete[] indexes;
}
fclose(pFile);
}
}
void Render(XCEngine::RHI::D3D12CommandList& inCommandList) {
inCommandList.SetVertexBuffer(0, mVBO.GetResource(), 0, mStride);
if (mSubMeshes.empty()) {
inCommandList.Draw(mVertexCount, 1, 0, 0);
}
else {
for (auto iter = mSubMeshes.begin();
iter != mSubMeshes.end(); iter++) {
inCommandList.SetIndexBuffer(iter->second->mIBO.GetResource(), 0, XCEngine::RHI::Format::R32_UInt);
inCommandList.DrawIndexed(iter->second->mIndexCount, 1, 0, 0, 0);
}
}
}
};
//=================================================================================
// 根签名初始化 (RootSignature)
// 定义GPU资源绑定规则: CBV(常量缓冲) / SRV(着色器资源) / DescriptorTable
//=================================================================================
ID3D12RootSignature* InitRootSignature() {
using namespace XCEngine::RHI;
D3D12_ROOT_PARAMETER rootParameters[4];
rootParameters[0] = D3D12RootSignature::CreateCBV(1, ShaderVisibility::All, 0);
rootParameters[1] = D3D12RootSignature::Create32BitConstants(0, 4, ShaderVisibility::Vertex, 0);
D3D12_DESCRIPTOR_RANGE descriptorRange[1];
descriptorRange[0].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
descriptorRange[0].RegisterSpace = 0;
descriptorRange[0].BaseShaderRegister = 0;
descriptorRange[0].NumDescriptors = 1;
descriptorRange[0].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
rootParameters[2] = D3D12RootSignature::CreateDescriptorTable(1, descriptorRange, ShaderVisibility::Pixel);
rootParameters[3] = D3D12RootSignature::CreateSRV(0, ShaderVisibility::All, 1);
D3D12_SAMPLER_DESC samplerDesc = D3D12RootSignature::CreateSamplerDesc(FilterMode::Linear, TextureAddressMode::Clamp);
D3D12_STATIC_SAMPLER_DESC staticSamplerDesc = D3D12RootSignature::CreateStaticSampler(0, samplerDesc, ShaderVisibility::Pixel);
D3D12_ROOT_SIGNATURE_DESC rootSignatureDesc = D3D12RootSignature::CreateDesc(
rootParameters, 4, &staticSamplerDesc, 1);
gRootSignature.Initialize(gD3D12Device.GetDevice(), rootSignatureDesc);
return gRootSignature.GetRootSignature();
}
//=================================================================================
//=================================================================================
//=================================================================================
// 渲染管线状态对象 (PSO)
// 包含: InputLayout / VS/GS/PS / Rasterizer / DepthStencil / Blend
//=================================================================================
ID3D12PipelineState* CreatePSO(ID3D12RootSignature* inID3D12RootSignature,
D3D12_SHADER_BYTECODE inVertexShader, D3D12_SHADER_BYTECODE inPixelShader,
D3D12_SHADER_BYTECODE inGSShader) {
using namespace XCEngine::RHI;
D3D12_INPUT_ELEMENT_DESC vertexDataElementDesc[] = {
D3D12PipelineState::CreateInputElement("POSITION", 0, Format::R32G32B32A32_Float, 0, 0),
D3D12PipelineState::CreateInputElement("TEXCOORD", 0, Format::R32G32B32A32_Float, 0, sizeof(float) * 4),
D3D12PipelineState::CreateInputElement("NORMAL", 0, Format::R32G32B32A32_Float, 0, sizeof(float) * 8),
D3D12PipelineState::CreateInputElement("TANGENT", 0, Format::R32G32B32A32_Float, 0, sizeof(float) * 12)
};
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = D3D12PipelineState::CreateDesc(
inID3D12RootSignature,
inVertexShader,
inPixelShader,
inGSShader,
4,
vertexDataElementDesc);
ID3D12PipelineState* d3d12PSO = nullptr;
gPipelineState.Initialize(gD3D12Device.GetDevice(), psoDesc);
if (!gPipelineState.GetPipelineState()) {
return nullptr;
}
return gPipelineState.GetPipelineState();
}
//=================================================================================
// D3D12 初始化核心函数 (InitD3D12)
// 最小渲染系统初始化流程:
// 1. 启用Debug层 (可选, _DEBUG)
// 2. 创建IDXGIFactory4
// 3. 枚举Adapter, 创建ID3D12Device
// 4. 创建CommandQueue (命令队列)
// 5. 创建SwapChain (交换链)
// 6. 创建DepthStencilBuffer (深度缓冲)
// 7. 创建RTV/DSV描述符堆
// 8. 创建RenderTargetView / DepthStencilView
// 9. 创建CommandAllocator / CommandList
// 10. 创建Fence (同步)
//=================================================================================
bool InitD3D12(HWND inHWND, int inWidth, int inHeight) {
if (!gD3D12Device.Initialize()) {
return false;
}
ID3D12Device* device = gD3D12Device.GetDevice();
IDXGIFactory4* dxgiFactory = gD3D12Device.GetFactory();
if (!gCommandQueue.Initialize(device, XCEngine::RHI::CommandQueueType::Direct)) {
return false;
}
DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
swapChainDesc.BufferCount = 2;
swapChainDesc.BufferDesc = {};
swapChainDesc.BufferDesc.Width = inWidth;
swapChainDesc.BufferDesc.Height = inHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = inHWND;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.Windowed = true;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
IDXGISwapChain* swapChain = nullptr;
dxgiFactory->CreateSwapChain(gCommandQueue.GetCommandQueue(), &swapChainDesc, &swapChain);
gSwapChain.Initialize(swapChain, inWidth, inHeight);
gDepthStencil.InitializeDepthStencil(device, inWidth, inHeight);
D3D12_DESCRIPTOR_HEAP_DESC d3dDescriptorHeapDescRTV = XCEngine::RHI::D3D12DescriptorHeap::CreateDesc(XCEngine::RHI::DescriptorHeapType::RTV, 2);
gSwapChainRTVHeap.Initialize(device, XCEngine::RHI::DescriptorHeapType::RTV, 2);
gRTVDescriptorSize = gD3D12Device.GetDescriptorHandleIncrementSize(XCEngine::RHI::DescriptorHeapType::RTV);
D3D12_DESCRIPTOR_HEAP_DESC d3dDescriptorHeapDescDSV = XCEngine::RHI::D3D12DescriptorHeap::CreateDesc(XCEngine::RHI::DescriptorHeapType::DSV, 1);
gSwapChainDSVHeap.Initialize(device, XCEngine::RHI::DescriptorHeapType::DSV, 1);
gDSVDescriptorSize = gD3D12Device.GetDescriptorHandleIncrementSize(XCEngine::RHI::DescriptorHeapType::DSV);
D3D12_CPU_DESCRIPTOR_HANDLE rtvHeapStart = gSwapChainRTVHeap.GetCPUDescriptorHandleForHeapStart();
for (int i = 0; i < 2; i++) {
ID3D12Resource* buffer = nullptr;
gSwapChain.GetSwapChain()->GetBuffer(i, IID_PPV_ARGS(&buffer));
gColorRTs[i].InitializeFromExisting(buffer);
D3D12_CPU_DESCRIPTOR_HANDLE rtvPointer;
rtvPointer.ptr = rtvHeapStart.ptr + i * gRTVDescriptorSize;
gSwapChainRTVs[i].InitializeAt(device, gColorRTs[i].GetResource(), rtvPointer, nullptr);
}
D3D12_DEPTH_STENCIL_VIEW_DESC d3dDSViewDesc = XCEngine::RHI::D3D12DepthStencilView::CreateDesc(XCEngine::RHI::Format::D24_UNorm_S8_UInt);
gSwapChainDSV.InitializeAt(device, gDepthStencil.GetResource(), gSwapChainDSVHeap.GetCPUDescriptorHandleForHeapStart(), &d3dDSViewDesc);
gCommandAllocator.Initialize(device, XCEngine::RHI::CommandQueueType::Direct);
gCommandList.Initialize(device, XCEngine::RHI::CommandQueueType::Direct, gCommandAllocator.GetCommandAllocator());
gFence.Initialize(device, 0);
return true;
}
//=================================================================================
// 命令相关辅助函数
//=================================================================================
void WaitForCompletionOfCommandList() {
UINT64 completed = gFence.GetCompletedValue();
UINT64 current = gFenceValue;
Log("[DEBUG] WaitForCompletion: completed=%llu, waiting for=%llu\n", completed, current);
if (completed < current) {
Log("[DEBUG] WaitForCompletion: waiting...\n");
gFence.Wait(current);
Log("[DEBUG] WaitForCompletion: done\n");
}
}
//=================================================================================
// 命令列表结束提交
// 关闭CommandList → ExecuteCommandLists → Signal Fence
//=================================================================================
void EndCommandList() {
gCommandList.Close();
ID3D12CommandList* ppCommandLists[] = { gCommandList.GetCommandList() };
gCommandQueue.ExecuteCommandLists(1, ppCommandLists);
gFenceValue += 1;
gCommandQueue.Signal(gFence.GetFence(), gFenceValue);
}
//=================================================================================
// 开始渲染到SwapChain
// 1. 获取当前BackBuffer索引
// 2. 状态转换: PRESENT → RENDER_TARGET
// 3. 设置RenderTargets (Color + Depth)
// 4. 设置Viewport/Scissor
// 5. Clear Color/Depth
//=================================================================================
void BeginRenderToSwapChain(XCEngine::RHI::D3D12CommandList& inCommandList) {
gCurrentRTIndex = gSwapChain.GetCurrentBackBufferIndex();
inCommandList.TransitionBarrier(gColorRTs[gCurrentRTIndex].GetResource(), XCEngine::RHI::ResourceStates::Present, XCEngine::RHI::ResourceStates::RenderTarget);
D3D12_CPU_DESCRIPTOR_HANDLE colorRT, dsv;
dsv.ptr = gSwapChainDSVHeap.GetCPUDescriptorHandleForHeapStart().ptr;
colorRT.ptr = gSwapChainRTVHeap.GetCPUDescriptorHandleForHeapStart().ptr + gCurrentRTIndex * gRTVDescriptorSize;
inCommandList.SetRenderTargets(1, &colorRT, &dsv);
XCEngine::RHI::Viewport viewport = { 0.0f, 0.0f, 1280.0f, 720.0f, 0.0f, 1.0f };
XCEngine::RHI::Rect scissorRect = { 0, 0, 1280, 720 };
inCommandList.SetViewport(viewport);
inCommandList.SetScissorRect(scissorRect);
const float clearColor[] = { 0.0f,0.0f,0.0f,1.0f };
inCommandList.ClearRenderTargetView(colorRT, clearColor, 0, nullptr);
inCommandList.ClearDepthStencilView(dsv, D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL, 1.0f, 0, 0, nullptr);
}
//=================================================================================
// 结束渲染到SwapChain
// 状态转换: RENDER_TARGET → PRESENT
//=================================================================================
void EndRenderToSwapChain(XCEngine::RHI::D3D12CommandList& inCommandList) {
inCommandList.TransitionBarrier(gColorRTs[gCurrentRTIndex].GetResource(), XCEngine::RHI::ResourceStates::RenderTarget, XCEngine::RHI::ResourceStates::Present);
}
//=================================================================================
// 截图保存 Debug 工具
// 使用 RHI 模块的 D3D12Screenshot 类
//=================================================================================
bool SaveScreenshot(const char* filename, int width, int height) {
Log("[DEBUG] SaveScreenshot: start\n");
ID3D12Device* device = gD3D12Device.GetDevice();
ID3D12CommandQueue* queue = gCommandQueue.GetCommandQueue();
ID3D12Resource* renderTarget = gColorRTs[gCurrentRTIndex].GetResource();
Log("[DEBUG] SaveScreenshot: calling D3D12Screenshot::Capture\n");
bool result = XCEngine::RHI::D3D12Screenshot::Capture(
device, queue, renderTarget, filename, (uint32_t)width, (uint32_t)height);
Log("[DEBUG] SaveScreenshot: done, result=%d\n", result);
return result;
}
//=================================================================================
// Win32 窗口相关
//=================================================================================
LPCTSTR gWindowClassName = L"BattleFire";
//=================================================================================
// 窗口消息回调函数
//=================================================================================
LRESULT CALLBACK WindowProc(HWND inHWND, UINT inMSG, WPARAM inWParam, LPARAM inLParam) {
switch (inMSG) {
case WM_CLOSE:
PostQuitMessage(0);
break;
}
return DefWindowProc(inHWND, inMSG, inWParam, inLParam);
}
//=================================================================================
// 主入口函数 WinMain
// 程序入口点
//=================================================================================
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int inShowCmd) {
Logger::Get().AddSink(std::make_unique<FileLogSink>("D3D12_engine_log.txt"));
Logger::Get().SetMinimumLevel(LogLevel::Debug);
AllocConsole();
freopen("CONOUT$", "w", stdout);
Log("[DEBUG] D3D12 Test Application Started\n");
WNDCLASSEX wndClassEx;
wndClassEx.cbSize = sizeof(WNDCLASSEX);
wndClassEx.style = CS_HREDRAW | CS_VREDRAW;
wndClassEx.cbClsExtra = NULL;
wndClassEx.cbWndExtra = NULL;
wndClassEx.hInstance = hInstance;
wndClassEx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wndClassEx.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
wndClassEx.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClassEx.hbrBackground = NULL;
wndClassEx.lpszMenuName = NULL;
wndClassEx.lpszClassName = gWindowClassName;
wndClassEx.lpfnWndProc = WindowProc;
if (!RegisterClassEx(&wndClassEx)) {
MessageBox(NULL, L"Register Class Failed!", L"Error", MB_OK | MB_ICONERROR);
return -1;
}
int viewportWidth = 1280;
int viewportHeight = 720;
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = viewportWidth;
rect.bottom = viewportHeight;
AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE);
int windowWidth = rect.right - rect.left;
int windowHeight = rect.bottom - rect.top;
HWND hwnd = CreateWindowEx(NULL,
gWindowClassName,
L"My Render Window",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT,
windowWidth, windowHeight,
NULL,
NULL,
hInstance,
NULL);
if (!hwnd) {
MessageBox(NULL, L"Create Window Failed!", L"Error", MB_OK | MB_ICONERROR);
return -1;
}
InitD3D12(hwnd, 1280, 720);
ID3D12CommandAllocator* commandAllocator = gCommandAllocator.GetCommandAllocator();
StaticMeshComponent staticMeshComponent;
staticMeshComponent.InitFromFile(gCommandList.GetCommandList(), "Res/Model/Sphere.lhsm");
ID3D12RootSignature* rootSignature = InitRootSignature();
gVertexShader.CompileFromFile(L"Res/Shader/gs.hlsl", "MainVS", "vs_5_1");
gGeometryShader.CompileFromFile(L"Res/Shader/gs.hlsl", "MainGS", "gs_5_1");
gPixelShader.CompileFromFile(L"Res/Shader/gs.hlsl", "MainPS", "ps_5_1");
ID3D12PipelineState* pso = CreatePSO(rootSignature, gVertexShader.GetD3D12Bytecode(), gPixelShader.GetD3D12Bytecode(), gGeometryShader.GetD3D12Bytecode());
gConstantBuffer.Initialize(gD3D12Device.GetDevice(), 65536, D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_HEAP_TYPE_UPLOAD);
DirectX::XMMATRIX projectionMatrix = DirectX::XMMatrixPerspectiveFovLH(
(45.0f * 3.141592f) / 180.0f, 1280.0f / 720.0f, 0.1f, 1000.0f);
DirectX::XMMATRIX viewMatrix = DirectX::XMMatrixIdentity();
DirectX::XMMATRIX modelMatrix = DirectX::XMMatrixTranslation(0.0f, 0.0f, 5.0f);
DirectX::XMFLOAT4X4 tempMatrix;
float matrices[64];
DirectX::XMStoreFloat4x4(&tempMatrix, projectionMatrix);
memcpy(matrices, &tempMatrix, sizeof(float) * 16);
DirectX::XMStoreFloat4x4(&tempMatrix, viewMatrix);
memcpy(matrices + 16, &tempMatrix, sizeof(float) * 16);
DirectX::XMStoreFloat4x4(&tempMatrix, modelMatrix);
memcpy(matrices + 32, &tempMatrix, sizeof(float) * 16);
DirectX::XMVECTOR determinant;
DirectX::XMMATRIX inverseModelMatrix = DirectX::XMMatrixInverse(&determinant, modelMatrix);
if (DirectX::XMVectorGetX(determinant) != 0.0f) {
DirectX::XMMATRIX normalMatrix = DirectX::XMMatrixTranspose(inverseModelMatrix);
DirectX::XMStoreFloat4x4(&tempMatrix, modelMatrix);
memcpy(matrices + 48, &tempMatrix, sizeof(float) * 16);
}
{
D3D12_RANGE d3d12Range = { 0 };
unsigned char* pBuffer = nullptr;
gConstantBuffer.GetResource()->Map(0, &d3d12Range, (void**)&pBuffer);
memcpy(pBuffer, matrices, sizeof(float) * 64);
gConstantBuffer.GetResource()->Unmap(0, nullptr);
}
gMaterialBuffer.Initialize(gD3D12Device.GetDevice(), 65536, D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_HEAP_TYPE_UPLOAD);
struct MaterialData {
float r;
};
MaterialData* materialDatas = new MaterialData[3000];
for (int i = 0; i < 3000; i++) {
materialDatas[i].r = srandom() * 0.1f + 0.1f;
}
{
D3D12_RANGE d3d12Range = { 0 };
unsigned char* pBuffer = nullptr;
gMaterialBuffer.GetResource()->Map(0, &d3d12Range, (void**)&pBuffer);
memcpy(pBuffer, materialDatas, sizeof(MaterialData) * 3000);
gMaterialBuffer.GetResource()->Unmap(0, nullptr);
}
int imageWidth, imageHeight, imageChannel;
stbi_uc* pixels = stbi_load("Res/Image/earth_d.jpg", &imageWidth, &imageHeight, &imageChannel, 4);
Log("[DEBUG] Texture loaded: width=%d, height=%d, channels=%d, pixels=%p\n", imageWidth, imageHeight, imageChannel, pixels);
gTexture.InitializeFromData(gD3D12Device.GetDevice(), gCommandList.GetCommandList(), pixels,
imageWidth, imageHeight, DXGI_FORMAT_R8G8B8A8_UNORM);
ID3D12Resource* texture = gTexture.GetResource();
delete[] pixels;
ID3D12Device* d3dDevice = gD3D12Device.GetDevice();
XCEngine::RHI::D3D12DescriptorHeap srvHeap;
srvHeap.Initialize(d3dDevice, XCEngine::RHI::DescriptorHeapType::CBV_SRV_UAV, 3, true);
ID3D12DescriptorHeap* descriptorHeaps[] = { srvHeap.GetDescriptorHeap() };
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = XCEngine::RHI::D3D12ShaderResourceView::CreateDesc(XCEngine::RHI::Format::R8G8B8A8_UNorm);
D3D12_CPU_DESCRIPTOR_HANDLE srvHeapPtr = srvHeap.GetCPUDescriptorHandleForHeapStart();
gTextureSRV.InitializeAt(d3dDevice, texture, srvHeapPtr, &srvDesc);
srvHeapPtr.ptr += gD3D12Device.GetDescriptorHandleIncrementSize(XCEngine::RHI::DescriptorHeapType::CBV_SRV_UAV);
EndCommandList();
WaitForCompletionOfCommandList();
ShowWindow(hwnd, inShowCmd);
UpdateWindow(hwnd);
float color[] = { 0.5f,0.5f,0.5f,1.0f };
MSG msg;
DWORD last_time = timeGetTime();
DWORD appStartTime = last_time;
int frameCount = 0;
while (true) {
ZeroMemory(&msg, sizeof(MSG));
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
if (msg.message == WM_QUIT) {
break;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
} else {
frameCount++;
WaitForCompletionOfCommandList();
DWORD current_time = timeGetTime();
DWORD frameTime = current_time - last_time;
DWORD timeSinceAppStartInMS = current_time - appStartTime;
last_time = current_time;
float frameTimeInSecond = float(frameTime) / 1000.0f;
float timeSinceAppStartInSecond = float(timeSinceAppStartInMS) / 1000.0f;
color[0] = timeSinceAppStartInSecond;
commandAllocator->Reset();
gCommandList.Reset(gCommandAllocator.GetCommandAllocator());
BeginRenderToSwapChain(gCommandList);
gCommandList.SetPipelineState(pso);
gCommandList.SetRootSignature(rootSignature);
gCommandList.SetDescriptorHeaps(_countof(descriptorHeaps), descriptorHeaps);
gCommandList.SetGraphicsRootConstantBufferView(0, gConstantBuffer.GetGPUVirtualAddress());
gCommandList.SetGraphicsRoot32BitConstants(1, 4, color, 0);
gCommandList.SetGraphicsRootDescriptorTable(2, srvHeap.GetGPUDescriptorHandleForHeapStart());
gCommandList.SetGraphicsRootShaderResourceView(3, gMaterialBuffer.GetGPUVirtualAddress());
gCommandList.SetPrimitiveTopology(XCEngine::RHI::PrimitiveTopology::TriangleList);
staticMeshComponent.Render(gCommandList);
// On screenshot frame, don't transition to PRESENT - keep RENDER_TARGET for screenshot
if (frameCount != 30) {
EndRenderToSwapChain(gCommandList);
}
EndCommandList();
// On screenshot frame, don't Present - we'll screenshot before next frame
if (frameCount != 30) {
gSwapChain.Present(0, 0);
}
// Screenshot after rendering is done
if (frameCount == 30) {
Log("[DEBUG] Saving screenshot at frame %d...\n", frameCount);
if (SaveScreenshot("screenshot.ppm", 1280, 720)) {
Log("[DEBUG] Screenshot saved to screenshot.ppm\n");
} else {
Log("[DEBUG] Failed to save screenshot!\n");
}
PostQuitMessage(0);
}
}
}
Logger::Get().Shutdown();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink