feat: 添加独立的输入系统和平台抽象层
- 新增 Platform 模块：PlatformTypes.h, Window.h, WindowsWindow - 新增 Input 模块：InputTypes, InputEvent, InputAxis, InputModule, InputManager - 新增 WindowsInputModule 处理 Win32 消息转换 - 将 RHI 集成测试从 render_model 迁移到 sphere - 更新 CMakeLists.txt 添加 Platform 和 Input 模块
This commit is contained in:
572
tests/RHI/D3D12/integration/sphere/main.cpp
Normal file
572
tests/RHI/D3D12/integration/sphere/main.cpp
Normal file
@@ -0,0 +1,572 @@
|
||||
#include <windows.h>
|
||||
#include <d3d12.h>
|
||||
#include <dxgi1_4.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <stdarg.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "XCEngine/RHI/RHIEnums.h"
|
||||
#include "XCEngine/RHI/RHITypes.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/D3D12Buffer.h"
|
||||
#include "XCEngine/RHI/D3D12/D3D12Texture.h"
|
||||
#include "XCEngine/RHI/D3D12/D3D12RenderTargetView.h"
|
||||
#include "XCEngine/RHI/D3D12/D3D12DepthStencilView.h"
|
||||
#include "XCEngine/RHI/D3D12/D3D12Shader.h"
|
||||
#include "XCEngine/RHI/D3D12/D3D12RootSignature.h"
|
||||
#include "XCEngine/RHI/D3D12/D3D12PipelineState.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"
|
||||
#include "XCEngine/Containers/String.h"
|
||||
#include "third_party/stb/stb_image.h"
|
||||
|
||||
using namespace XCEngine::RHI;
|
||||
using namespace XCEngine::Debug;
|
||||
using namespace XCEngine::Containers;
|
||||
|
||||
#pragma comment(lib,"d3d12.lib")
|
||||
#pragma comment(lib,"dxgi.lib")
|
||||
#pragma comment(lib,"dxguid.lib")
|
||||
#pragma comment(lib,"d3dcompiler.lib")
|
||||
#pragma comment(lib,"winmm.lib")
|
||||
|
||||
D3D12Device gDevice;
|
||||
D3D12CommandQueue gCommandQueue;
|
||||
D3D12SwapChain gSwapChain;
|
||||
D3D12CommandAllocator gCommandAllocator;
|
||||
D3D12CommandList gCommandList;
|
||||
D3D12Texture gDepthStencil;
|
||||
D3D12DescriptorHeap gRTVHeap;
|
||||
D3D12DescriptorHeap gDSVHeap;
|
||||
D3D12DescriptorHeap gSRVHeap;
|
||||
D3D12RenderTargetView gRTVs[2];
|
||||
D3D12DepthStencilView gDSV;
|
||||
|
||||
D3D12Shader gVertexShader;
|
||||
D3D12Shader gPixelShader;
|
||||
D3D12RootSignature gRootSignature;
|
||||
D3D12PipelineState gPipelineState;
|
||||
D3D12Buffer gVertexBuffer;
|
||||
D3D12Buffer gIndexBuffer;
|
||||
D3D12Buffer gMVPBuffer;
|
||||
D3D12Texture gDiffuseTexture;
|
||||
D3D12ShaderResourceView gDiffuseSRV;
|
||||
|
||||
UINT gRTVDescriptorSize = 0;
|
||||
UINT gDSVDescriptorSize = 0;
|
||||
int gCurrentRTIndex = 0;
|
||||
|
||||
UINT gIndexCount = 0;
|
||||
|
||||
float gProjectionMatrix[16];
|
||||
float gViewMatrix[16];
|
||||
float gModelMatrix[16];
|
||||
float gMVPMatrix[16];
|
||||
float gTempMatrix[16];
|
||||
float gTransposedMatrix[16];
|
||||
|
||||
HWND gHWND = nullptr;
|
||||
int gWidth = 1280;
|
||||
int gHeight = 720;
|
||||
|
||||
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, String(buffer));
|
||||
}
|
||||
|
||||
LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
|
||||
switch (msg) {
|
||||
case WM_CLOSE:
|
||||
PostQuitMessage(0);
|
||||
break;
|
||||
}
|
||||
return DefWindowProc(hwnd, msg, wParam, lParam);
|
||||
}
|
||||
|
||||
void IdentityMatrix(float* m) {
|
||||
memset(m, 0, 16 * sizeof(float));
|
||||
m[0] = m[5] = m[10] = m[15] = 1.0f;
|
||||
}
|
||||
|
||||
void PerspectiveMatrix(float* m, float fov, float aspect, float nearZ, float farZ) {
|
||||
memset(m, 0, 16 * sizeof(float));
|
||||
float tanHalfFov = tanf(fov / 2.0f);
|
||||
m[0] = 1.0f / (aspect * tanHalfFov);
|
||||
m[5] = 1.0f / tanHalfFov;
|
||||
m[10] = (farZ + nearZ) / (nearZ - farZ);
|
||||
m[11] = -1.0f;
|
||||
m[14] = (2.0f * farZ * nearZ) / (nearZ - farZ);
|
||||
}
|
||||
|
||||
void LookAtMatrix(float* m, const float* eye, const float* target, const float* up) {
|
||||
float zAxis[3] = { eye[0] - target[0], eye[1] - target[1], eye[2] - target[2] };
|
||||
float zLen = sqrtf(zAxis[0] * zAxis[0] + zAxis[1] * zAxis[1] + zAxis[2] * zAxis[2]);
|
||||
if (zLen > 0) { zAxis[0] /= zLen; zAxis[1] /= zLen; zAxis[2] /= zLen; }
|
||||
|
||||
float xAxis[3] = { up[1] * zAxis[2] - up[2] * zAxis[1],
|
||||
up[2] * zAxis[0] - up[0] * zAxis[2],
|
||||
up[0] * zAxis[1] - up[1] * zAxis[0] };
|
||||
float xLen = sqrtf(xAxis[0] * xAxis[0] + xAxis[1] * xAxis[1] + xAxis[2] * xAxis[2]);
|
||||
if (xLen > 0) { xAxis[0] /= xLen; xAxis[1] /= xLen; xAxis[2] /= xLen; }
|
||||
|
||||
float yAxis[3] = { zAxis[1] * xAxis[2] - zAxis[2] * xAxis[1],
|
||||
zAxis[2] * xAxis[0] - zAxis[0] * xAxis[2],
|
||||
zAxis[0] * xAxis[1] - zAxis[1] * xAxis[0] };
|
||||
|
||||
m[0] = xAxis[0]; m[1] = yAxis[0]; m[2] = zAxis[0]; m[3] = 0;
|
||||
m[4] = xAxis[1]; m[5] = yAxis[1]; m[6] = zAxis[1]; m[7] = 0;
|
||||
m[8] = xAxis[2]; m[9] = yAxis[2]; m[10] = zAxis[2]; m[11] = 0;
|
||||
m[12] = -xAxis[0] * eye[0] - xAxis[1] * eye[1] - xAxis[2] * eye[2];
|
||||
m[13] = -yAxis[0] * eye[0] - yAxis[1] * eye[1] - yAxis[2] * eye[2];
|
||||
m[14] = -zAxis[0] * eye[0] - zAxis[1] * eye[1] - zAxis[2] * eye[2];
|
||||
m[15] = 1.0f;
|
||||
}
|
||||
|
||||
void MultiplyMatrix(float* dst, const float* a, const float* b) {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
for (int j = 0; j < 4; j++) {
|
||||
dst[i * 4 + j] = 0;
|
||||
for (int k = 0; k < 4; k++) {
|
||||
dst[i * 4 + j] += a[i * 4 + k] * b[k * 4 + j];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void TransposeMatrix(float* dst, const float* src) {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
for (int j = 0; j < 4; j++) {
|
||||
dst[i * 4 + j] = src[j * 4 + i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Vertex {
|
||||
float pos[4];
|
||||
float texcoord[4];
|
||||
};
|
||||
|
||||
void GenerateSphere(std::vector<Vertex>& vertices, std::vector<UINT32>& indices, float radius, int segments) {
|
||||
vertices.clear();
|
||||
indices.clear();
|
||||
|
||||
for (int lat = 0; lat <= segments; lat++) {
|
||||
float theta = lat * 3.14159f / segments;
|
||||
float sinTheta = sinf(theta);
|
||||
float cosTheta = cosf(theta);
|
||||
|
||||
for (int lon = 0; lon <= segments; lon++) {
|
||||
float phi = lon * 2.0f * 3.14159f / segments;
|
||||
float sinPhi = sinf(phi);
|
||||
float cosPhi = cosf(phi);
|
||||
|
||||
Vertex v;
|
||||
v.pos[0] = radius * sinTheta * cosPhi;
|
||||
v.pos[1] = radius * cosTheta;
|
||||
v.pos[2] = radius * sinTheta * sinPhi;
|
||||
v.pos[3] = 1.0f;
|
||||
|
||||
v.texcoord[0] = (float)lon / segments;
|
||||
v.texcoord[1] = (float)lat / segments;
|
||||
v.texcoord[2] = 0.0f;
|
||||
v.texcoord[3] = 0.0f;
|
||||
|
||||
vertices.push_back(v);
|
||||
}
|
||||
}
|
||||
|
||||
for (int lat = 0; lat < segments; lat++) {
|
||||
for (int lon = 0; lon < segments; lon++) {
|
||||
int first = lat * (segments + 1) + lon;
|
||||
int second = first + segments + 1;
|
||||
|
||||
indices.push_back(first);
|
||||
indices.push_back(second);
|
||||
indices.push_back(first + 1);
|
||||
|
||||
indices.push_back(second);
|
||||
indices.push_back(second + 1);
|
||||
indices.push_back(first + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool LoadTexture(const char* filename, D3D12Texture& texture, D3D12ShaderResourceView& srv, ID3D12Device* device, D3D12DescriptorHeap& srvHeap, ID3D12GraphicsCommandList* commandList, D3D12CommandAllocator& allocator, D3D12CommandQueue& queue) {
|
||||
int width, height, channels;
|
||||
stbi_uc* pixels = stbi_load(filename, &width, &height, &channels, STBI_rgb_alpha);
|
||||
if (!pixels) {
|
||||
Log("[ERROR] Failed to load texture: %s", filename);
|
||||
return false;
|
||||
}
|
||||
|
||||
allocator.Reset();
|
||||
commandList->Reset(allocator.GetCommandAllocator(), nullptr);
|
||||
|
||||
if (!texture.InitializeFromData(device, commandList, pixels, width, height, DXGI_FORMAT_R8G8B8A8_UNORM)) {
|
||||
Log("[ERROR] Failed to initialize texture");
|
||||
stbi_image_free(pixels);
|
||||
return false;
|
||||
}
|
||||
|
||||
commandList->Close();
|
||||
ID3D12CommandList* lists[] = { commandList };
|
||||
queue.ExecuteCommandListsInternal(1, lists);
|
||||
queue.WaitForIdle();
|
||||
|
||||
texture.SetName(filename);
|
||||
|
||||
srvHeap.Initialize(device, DescriptorHeapType::CBV_SRV_UAV, 1, true);
|
||||
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = D3D12ShaderResourceView::CreateDesc(Format::R8G8B8A8_UNorm, D3D12_SRV_DIMENSION_TEXTURE2D);
|
||||
srv.InitializeAt(device, texture.GetResource(), srvHeap.GetCPUDescriptorHandleForHeapStart(), &srvDesc);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool InitD3D12() {
|
||||
RHIDeviceDesc deviceDesc;
|
||||
deviceDesc.windowHandle = gHWND;
|
||||
deviceDesc.width = gWidth;
|
||||
deviceDesc.height = gHeight;
|
||||
deviceDesc.adapterIndex = 0;
|
||||
deviceDesc.enableDebugLayer = false;
|
||||
deviceDesc.enableGPUValidation = false;
|
||||
|
||||
if (!gDevice.Initialize(deviceDesc)) {
|
||||
Log("[ERROR] Failed to initialize D3D12 device");
|
||||
return false;
|
||||
}
|
||||
|
||||
ID3D12Device* device = gDevice.GetDevice();
|
||||
IDXGIFactory4* factory = gDevice.GetFactory();
|
||||
|
||||
if (!gCommandQueue.Initialize(device, CommandQueueType::Direct)) {
|
||||
Log("[ERROR] Failed to initialize command queue");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!gSwapChain.Initialize(factory, gCommandQueue.GetCommandQueue(), gHWND, gWidth, gHeight, 2)) {
|
||||
Log("[ERROR] Failed to initialize swap chain");
|
||||
return false;
|
||||
}
|
||||
|
||||
gDepthStencil.InitializeDepthStencil(device, gWidth, gHeight);
|
||||
|
||||
gRTVHeap.Initialize(device, DescriptorHeapType::RTV, 2);
|
||||
gRTVDescriptorSize = gDevice.GetDescriptorHandleIncrementSize(DescriptorHeapType::RTV);
|
||||
|
||||
gDSVHeap.Initialize(device, DescriptorHeapType::DSV, 1);
|
||||
gDSVDescriptorSize = gDevice.GetDescriptorHandleIncrementSize(DescriptorHeapType::DSV);
|
||||
|
||||
for (int i = 0; i < 2; i++) {
|
||||
D3D12Texture& backBuffer = gSwapChain.GetBackBuffer(i);
|
||||
CPUDescriptorHandle rtvCpuHandle = gRTVHeap.GetCPUDescriptorHandle(i);
|
||||
D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = { rtvCpuHandle.ptr };
|
||||
gRTVs[i].InitializeAt(device, backBuffer.GetResource(), rtvHandle, nullptr);
|
||||
}
|
||||
|
||||
D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc = D3D12DepthStencilView::CreateDesc(Format::D24_UNorm_S8_UInt);
|
||||
CPUDescriptorHandle dsvCpuHandle = gDSVHeap.GetCPUDescriptorHandle(0);
|
||||
D3D12_CPU_DESCRIPTOR_HANDLE dsvHandle = { dsvCpuHandle.ptr };
|
||||
gDSV.InitializeAt(device, gDepthStencil.GetResource(), dsvHandle, &dsvDesc);
|
||||
|
||||
gCommandAllocator.Initialize(device, CommandQueueType::Direct);
|
||||
gCommandList.Initialize(device, CommandQueueType::Direct, gCommandAllocator.GetCommandAllocator());
|
||||
|
||||
if (!gVertexShader.CompileFromFile(L"Res/Shader/sphere.hlsl", "MainVS", "vs_5_1")) {
|
||||
Log("[ERROR] Failed to compile vertex shader");
|
||||
return false;
|
||||
}
|
||||
Log("[INFO] Vertex shader compiled, bytecode size: %zu", gVertexShader.GetBytecodeSize());
|
||||
|
||||
if (!gPixelShader.CompileFromFile(L"Res/Shader/sphere.hlsl", "MainPS", "ps_5_1")) {
|
||||
Log("[ERROR] Failed to compile pixel shader");
|
||||
return false;
|
||||
}
|
||||
Log("[INFO] Pixel shader compiled, bytecode size: %zu", gPixelShader.GetBytecodeSize());
|
||||
|
||||
D3D12_DESCRIPTOR_RANGE descriptorRange = D3D12RootSignature::CreateDescriptorRange(
|
||||
D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 1, 0);
|
||||
|
||||
D3D12_ROOT_PARAMETER rootParameters[2];
|
||||
rootParameters[0].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
|
||||
rootParameters[0].ShaderVisibility = D3D12_SHADER_VISIBILITY_VERTEX;
|
||||
rootParameters[0].Descriptor.ShaderRegister = 0;
|
||||
rootParameters[0].Descriptor.RegisterSpace = 0;
|
||||
|
||||
rootParameters[1].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
|
||||
rootParameters[1].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
|
||||
rootParameters[1].DescriptorTable.NumDescriptorRanges = 1;
|
||||
rootParameters[1].DescriptorTable.pDescriptorRanges = &descriptorRange;
|
||||
|
||||
D3D12_STATIC_SAMPLER_DESC samplerDesc = D3D12RootSignature::CreateStaticSampler(
|
||||
0,
|
||||
D3D12RootSignature::CreateSamplerDesc(
|
||||
FilterMode::Linear,
|
||||
TextureAddressMode::Clamp,
|
||||
D3D12_FLOAT32_MAX
|
||||
),
|
||||
ShaderVisibility::Pixel
|
||||
);
|
||||
|
||||
D3D12_ROOT_SIGNATURE_DESC rsDesc = D3D12RootSignature::CreateDesc(
|
||||
rootParameters, 2,
|
||||
&samplerDesc, 1,
|
||||
D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT
|
||||
);
|
||||
|
||||
if (!gRootSignature.Initialize(device, rsDesc)) {
|
||||
Log("[ERROR] Failed to initialize root signature");
|
||||
return false;
|
||||
}
|
||||
|
||||
D3D12_INPUT_ELEMENT_DESC inputElements[] = {
|
||||
D3D12PipelineState::CreateInputElement("POSITION", 0, Format::R32G32B32A32_Float, 0, 0),
|
||||
D3D12PipelineState::CreateInputElement("TEXCOORD", 0, Format::R32G32B32A32_Float, 0, 16),
|
||||
};
|
||||
|
||||
D3D12_SHADER_BYTECODE emptyGs = {};
|
||||
|
||||
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
|
||||
psoDesc.pRootSignature = gRootSignature.GetRootSignature();
|
||||
psoDesc.VS = gVertexShader.GetD3D12Bytecode();
|
||||
psoDesc.PS = gPixelShader.GetD3D12Bytecode();
|
||||
psoDesc.GS = emptyGs;
|
||||
psoDesc.InputLayout.NumElements = 2;
|
||||
psoDesc.InputLayout.pInputElementDescs = inputElements;
|
||||
psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
|
||||
psoDesc.DSVFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
|
||||
psoDesc.SampleDesc.Count = 1;
|
||||
psoDesc.SampleDesc.Quality = 0;
|
||||
psoDesc.SampleMask = 0xffffffff;
|
||||
psoDesc.NumRenderTargets = 1;
|
||||
psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
|
||||
psoDesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
|
||||
psoDesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
|
||||
psoDesc.RasterizerState.FrontCounterClockwise = FALSE;
|
||||
psoDesc.RasterizerState.DepthClipEnable = TRUE;
|
||||
psoDesc.DepthStencilState.DepthEnable = FALSE;
|
||||
psoDesc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ZERO;
|
||||
psoDesc.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS;
|
||||
psoDesc.BlendState.RenderTarget[0].BlendEnable = FALSE;
|
||||
psoDesc.BlendState.RenderTarget[0].SrcBlend = D3D12_BLEND_ONE;
|
||||
psoDesc.BlendState.RenderTarget[0].DestBlend = D3D12_BLEND_ZERO;
|
||||
psoDesc.BlendState.RenderTarget[0].BlendOp = D3D12_BLEND_OP_ADD;
|
||||
psoDesc.BlendState.RenderTarget[0].SrcBlendAlpha = D3D12_BLEND_ONE;
|
||||
psoDesc.BlendState.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_ZERO;
|
||||
psoDesc.BlendState.RenderTarget[0].BlendOpAlpha = D3D12_BLEND_OP_ADD;
|
||||
psoDesc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
|
||||
|
||||
if (!gPipelineState.Initialize(device, psoDesc)) {
|
||||
Log("[ERROR] Failed to initialize pipeline state");
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<Vertex> vertices;
|
||||
std::vector<UINT32> indices;
|
||||
GenerateSphere(vertices, indices, 1.0f, 32);
|
||||
gIndexCount = (UINT)indices.size();
|
||||
Log("[INFO] Generated %d vertices, %d indices", vertices.size(), indices.size());
|
||||
|
||||
if (!gVertexBuffer.InitializeWithData(device, gCommandList.GetCommandList(), vertices.data(), (UINT)(sizeof(Vertex) * vertices.size()), D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER)) {
|
||||
Log("[ERROR] Failed to initialize vertex buffer");
|
||||
return false;
|
||||
}
|
||||
gVertexBuffer.SetStride(sizeof(Vertex));
|
||||
gVertexBuffer.SetBufferType(BufferType::Vertex);
|
||||
|
||||
if (!gIndexBuffer.InitializeWithData(device, gCommandList.GetCommandList(), indices.data(), (UINT)(sizeof(UINT32) * indices.size()), D3D12_RESOURCE_STATE_INDEX_BUFFER)) {
|
||||
Log("[ERROR] Failed to initialize index buffer");
|
||||
return false;
|
||||
}
|
||||
gIndexBuffer.SetBufferType(BufferType::Index);
|
||||
|
||||
PerspectiveMatrix(gProjectionMatrix, 45.0f * 3.14159f / 180.0f, (float)gWidth / (float)gHeight, 0.1f, 100.0f);
|
||||
|
||||
float eye[3] = { 0.0f, 0.0f, 3.0f };
|
||||
float target[3] = { 0.0f, 0.0f, 0.0f };
|
||||
float up[3] = { 0.0f, 1.0f, 0.0f };
|
||||
LookAtMatrix(gViewMatrix, eye, target, up);
|
||||
|
||||
IdentityMatrix(gModelMatrix);
|
||||
MultiplyMatrix(gTempMatrix, gViewMatrix, gModelMatrix);
|
||||
MultiplyMatrix(gMVPMatrix, gProjectionMatrix, gTempMatrix);
|
||||
TransposeMatrix(gTransposedMatrix, gMVPMatrix);
|
||||
|
||||
gMVPBuffer.InitializeWithData(device, gCommandList.GetCommandList(), gTransposedMatrix, sizeof(gTransposedMatrix), D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER);
|
||||
|
||||
if (!LoadTexture("Res/Image/earth.png", gDiffuseTexture, gDiffuseSRV, device, gSRVHeap, gCommandList.GetCommandList(), gCommandAllocator, gCommandQueue)) {
|
||||
Log("[ERROR] Failed to load texture");
|
||||
return false;
|
||||
}
|
||||
|
||||
Log("[INFO] D3D12 initialized successfully");
|
||||
return true;
|
||||
}
|
||||
|
||||
void WaitForGPU() {
|
||||
gCommandQueue.WaitForIdle();
|
||||
}
|
||||
|
||||
void ExecuteCommandList() {
|
||||
gCommandList.Close();
|
||||
void* commandLists[] = { gCommandList.GetCommandList() };
|
||||
gCommandQueue.ExecuteCommandLists(1, commandLists);
|
||||
}
|
||||
|
||||
void BeginRender() {
|
||||
gCurrentRTIndex = gSwapChain.GetCurrentBackBufferIndex();
|
||||
|
||||
D3D12Texture& currentBackBuffer = gSwapChain.GetBackBuffer(gCurrentRTIndex);
|
||||
gCommandList.TransitionBarrier(currentBackBuffer.GetResource(),
|
||||
ResourceStates::Present, ResourceStates::RenderTarget);
|
||||
|
||||
CPUDescriptorHandle rtvCpuHandle = gRTVHeap.GetCPUDescriptorHandle(gCurrentRTIndex);
|
||||
CPUDescriptorHandle dsvCpuHandle = gDSVHeap.GetCPUDescriptorHandle(0);
|
||||
D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = { rtvCpuHandle.ptr };
|
||||
D3D12_CPU_DESCRIPTOR_HANDLE dsvHandle = { dsvCpuHandle.ptr };
|
||||
|
||||
gCommandList.SetRenderTargetsHandle(1, &rtvHandle, &dsvHandle);
|
||||
|
||||
Viewport viewport = { 0.0f, 0.0f, (float)gWidth, (float)gHeight, 0.0f, 1.0f };
|
||||
Rect scissorRect = { 0, 0, gWidth, gHeight };
|
||||
gCommandList.SetViewport(viewport);
|
||||
gCommandList.SetScissorRect(scissorRect);
|
||||
|
||||
float clearColor[] = { 0.0f, 0.0f, 1.0f, 1.0f };
|
||||
gCommandList.ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr);
|
||||
gCommandList.ClearDepthStencilView(dsvHandle, D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL, 1.0f, 0, 0, nullptr);
|
||||
}
|
||||
|
||||
void EndRender() {
|
||||
D3D12Texture& currentBackBuffer = gSwapChain.GetBackBuffer(gCurrentRTIndex);
|
||||
gCommandList.TransitionBarrier(currentBackBuffer.GetResource(),
|
||||
ResourceStates::RenderTarget, ResourceStates::Present);
|
||||
}
|
||||
|
||||
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) {
|
||||
Logger::Get().Initialize();
|
||||
Logger::Get().AddSink(std::make_unique<ConsoleLogSink>());
|
||||
Logger::Get().SetMinimumLevel(LogLevel::Debug);
|
||||
|
||||
Log("[INFO] D3D12 Sphere Test Starting");
|
||||
|
||||
WNDCLASSEX wc = {};
|
||||
wc.cbSize = sizeof(WNDCLASSEX);
|
||||
wc.style = CS_HREDRAW | CS_VREDRAW;
|
||||
wc.lpfnWndProc = WindowProc;
|
||||
wc.hInstance = hInstance;
|
||||
wc.lpszClassName = L"D3D12SphereTest";
|
||||
|
||||
if (!RegisterClassEx(&wc)) {
|
||||
Log("[ERROR] Failed to register window class");
|
||||
return -1;
|
||||
}
|
||||
|
||||
RECT rect = { 0, 0, gWidth, gHeight };
|
||||
AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE);
|
||||
|
||||
gHWND = CreateWindowEx(0, L"D3D12SphereTest", L"D3D12 Sphere Test",
|
||||
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
|
||||
rect.right - rect.left, rect.bottom - rect.top,
|
||||
NULL, NULL, hInstance, NULL);
|
||||
|
||||
if (!gHWND) {
|
||||
Log("[ERROR] Failed to create window");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!InitD3D12()) {
|
||||
Log("[ERROR] Failed to initialize D3D12");
|
||||
return -1;
|
||||
}
|
||||
|
||||
ShowWindow(gHWND, nShowCmd);
|
||||
UpdateWindow(gHWND);
|
||||
|
||||
MSG msg = {};
|
||||
int frameCount = 0;
|
||||
const int targetFrameCount = 30;
|
||||
|
||||
while (true) {
|
||||
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
|
||||
if (msg.message == WM_QUIT) {
|
||||
break;
|
||||
}
|
||||
TranslateMessage(&msg);
|
||||
DispatchMessage(&msg);
|
||||
} else {
|
||||
if (frameCount > 0) {
|
||||
gCommandQueue.WaitForPreviousFrame();
|
||||
}
|
||||
|
||||
gCommandAllocator.Reset();
|
||||
gCommandList.Reset();
|
||||
|
||||
BeginRender();
|
||||
|
||||
gCommandList.SetRootSignature(gRootSignature.GetRootSignature());
|
||||
gCommandList.SetPipelineState(gPipelineState.GetPipelineState());
|
||||
|
||||
ID3D12DescriptorHeap* heaps[] = { gSRVHeap.GetDescriptorHeap() };
|
||||
gCommandList.SetDescriptorHeaps(1, heaps);
|
||||
gCommandList.SetGraphicsRootConstantBufferView(0, gMVPBuffer.GetResource()->GetGPUVirtualAddress());
|
||||
gCommandList.SetGraphicsRootDescriptorTable(1, gSRVHeap.GetGPUDescriptorHandleForHeapStart());
|
||||
|
||||
gCommandList.SetPrimitiveTopology(PrimitiveTopology::TriangleList);
|
||||
gCommandList.SetVertexBuffer(0, gVertexBuffer.GetResource(), 0, gVertexBuffer.GetStride());
|
||||
gCommandList.SetIndexBuffer(gIndexBuffer.GetResource(), 0, Format::R32_UInt);
|
||||
Log("[DEBUG] DrawIndexed with %d indices", gIndexCount);
|
||||
gCommandList.DrawIndexed(gIndexCount, 1, 0, 0, 0);
|
||||
|
||||
frameCount++;
|
||||
|
||||
if (frameCount >= targetFrameCount) {
|
||||
ExecuteCommandList();
|
||||
WaitForGPU();
|
||||
|
||||
bool screenshotResult = D3D12Screenshot::Capture(
|
||||
gDevice,
|
||||
gCommandQueue,
|
||||
gSwapChain.GetBackBuffer(gCurrentRTIndex),
|
||||
"sphere.ppm"
|
||||
);
|
||||
if (screenshotResult) {
|
||||
Log("[INFO] Screenshot saved to sphere.ppm");
|
||||
} else {
|
||||
Log("[ERROR] Screenshot failed");
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
EndRender();
|
||||
ExecuteCommandList();
|
||||
gSwapChain.Present(0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
gCommandList.Shutdown();
|
||||
gCommandAllocator.Shutdown();
|
||||
gSwapChain.Shutdown();
|
||||
gDevice.Shutdown();
|
||||
|
||||
Logger::Get().Shutdown();
|
||||
|
||||
Log("[INFO] D3D12 Sphere Test Finished");
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user