mirror of
https://gitlab.winehq.org/wine/vkd3d.git
synced 2025-09-12 18:50:22 -07:00
578 lines
21 KiB
C
578 lines
21 KiB
C
![]() |
/*
|
||
|
* Copyright 2025 Henri Verbeet
|
||
|
*
|
||
|
* This library is free software; you can redistribute it and/or
|
||
|
* modify it under the terms of the GNU Lesser General Public
|
||
|
* License as published by the Free Software Foundation; either
|
||
|
* version 2.1 of the License, or (at your option) any later version.
|
||
|
*
|
||
|
* This library is distributed in the hope that it will be useful,
|
||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
|
* Lesser General Public License for more details.
|
||
|
*
|
||
|
* You should have received a copy of the GNU Lesser General Public
|
||
|
* License along with this library; if not, write to the Free Software
|
||
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
||
|
*/
|
||
|
|
||
|
#define INITGUID
|
||
|
#define _GNU_SOURCE
|
||
|
#include <sys/time.h>
|
||
|
#include <assert.h>
|
||
|
#include <stdio.h>
|
||
|
#include "demo.h"
|
||
|
|
||
|
#include "teapot.h"
|
||
|
|
||
|
DEMO_EMBED(teapot_hlsl, "teapot.hlsl");
|
||
|
|
||
|
struct teapot_fence
|
||
|
{
|
||
|
ID3D12Fence *fence;
|
||
|
UINT64 value;
|
||
|
};
|
||
|
|
||
|
struct teapot_cb_data
|
||
|
{
|
||
|
struct demo_matrix mvp_matrix;
|
||
|
float level;
|
||
|
};
|
||
|
|
||
|
struct teapot
|
||
|
{
|
||
|
struct demo demo;
|
||
|
|
||
|
struct demo_window *window;
|
||
|
|
||
|
unsigned int width, height;
|
||
|
unsigned int tessellation_level;
|
||
|
float theta, phi;
|
||
|
|
||
|
D3D12_VIEWPORT vp;
|
||
|
D3D12_RECT scissor_rect;
|
||
|
|
||
|
ID3D12Device *device;
|
||
|
ID3D12CommandQueue *command_queue;
|
||
|
struct demo_swapchain *swapchain;
|
||
|
struct
|
||
|
{
|
||
|
ID3D12Resource *render_target;
|
||
|
ID3D12CommandAllocator *command_allocator;
|
||
|
ID3D12GraphicsCommandList *command_list;
|
||
|
} *swapchain_images;
|
||
|
ID3D12DescriptorHeap *rtv_heap;
|
||
|
unsigned int rtv_descriptor_size;
|
||
|
|
||
|
ID3D12RootSignature *root_signature;
|
||
|
ID3D12PipelineState *pipeline_state;
|
||
|
ID3D12Resource *cb, *vb, *ib;
|
||
|
D3D12_VERTEX_BUFFER_VIEW vbv;
|
||
|
D3D12_INDEX_BUFFER_VIEW ibv;
|
||
|
|
||
|
unsigned int rt_idx;
|
||
|
struct teapot_fence fence;
|
||
|
|
||
|
struct teapot_cb_data *cb_data;
|
||
|
};
|
||
|
|
||
|
static void teapot_populate_command_list(struct teapot *teapot,
|
||
|
ID3D12GraphicsCommandList *command_list, unsigned int rt_idx)
|
||
|
{
|
||
|
size_t rotate_idx_count, flip_idx_count;
|
||
|
D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle;
|
||
|
D3D12_RESOURCE_BARRIER barrier;
|
||
|
HRESULT hr;
|
||
|
|
||
|
hr = ID3D12GraphicsCommandList_Reset(command_list,
|
||
|
teapot->swapchain_images[rt_idx].command_allocator, teapot->pipeline_state);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, teapot->root_signature);
|
||
|
ID3D12GraphicsCommandList_SetGraphicsRootConstantBufferView(command_list, 0,
|
||
|
ID3D12Resource_GetGPUVirtualAddress(teapot->cb));
|
||
|
|
||
|
ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &teapot->vp);
|
||
|
ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &teapot->scissor_rect);
|
||
|
|
||
|
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
|
||
|
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
|
||
|
barrier.Transition.pResource = teapot->swapchain_images[rt_idx].render_target;
|
||
|
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
|
||
|
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
|
||
|
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
|
||
|
ID3D12GraphicsCommandList_ResourceBarrier(command_list, 1, &barrier);
|
||
|
|
||
|
rtv_handle = ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(teapot->rtv_heap);
|
||
|
rtv_handle.ptr += rt_idx * teapot->rtv_descriptor_size;
|
||
|
ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &rtv_handle, FALSE, NULL);
|
||
|
|
||
|
ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, rtv_handle,
|
||
|
(float[]){1.00f * 0.1f, 0.69f * 0.1f, 0.00f, 1.0f}, 0, NULL);
|
||
|
ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST);
|
||
|
ID3D12GraphicsCommandList_IASetIndexBuffer(command_list, &teapot->ibv);
|
||
|
ID3D12GraphicsCommandList_IASetVertexBuffers(command_list, 0, 1, &teapot->vbv);
|
||
|
|
||
|
rotate_idx_count = ARRAY_SIZE(teapot_rotate_patches) * 16;
|
||
|
ID3D12GraphicsCommandList_DrawIndexedInstanced(command_list, rotate_idx_count, 4, 0, 0, 0);
|
||
|
flip_idx_count = ARRAY_SIZE(teapot_flip_patches) * 16;
|
||
|
ID3D12GraphicsCommandList_DrawIndexedInstanced(command_list, flip_idx_count, 2, rotate_idx_count, 0, 0);
|
||
|
|
||
|
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
|
||
|
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
|
||
|
ID3D12GraphicsCommandList_ResourceBarrier(command_list, 1, &barrier);
|
||
|
|
||
|
hr = ID3D12GraphicsCommandList_Close(command_list);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
}
|
||
|
|
||
|
static void teapot_populate_command_lists(struct teapot *teapot)
|
||
|
{
|
||
|
HRESULT hr;
|
||
|
size_t i;
|
||
|
|
||
|
for (i = 0; i < demo_swapchain_get_back_buffer_count(teapot->swapchain); ++i)
|
||
|
{
|
||
|
hr = ID3D12CommandAllocator_Reset(teapot->swapchain_images[i].command_allocator);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
teapot_populate_command_list(teapot, teapot->swapchain_images[i].command_list, i);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void teapot_wait_for_previous_frame(struct teapot *teapot)
|
||
|
{
|
||
|
struct teapot_fence *fence = &teapot->fence;
|
||
|
const UINT64 v = fence->value++;
|
||
|
HRESULT hr;
|
||
|
|
||
|
hr = ID3D12CommandQueue_Signal(teapot->command_queue, fence->fence, v);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
hr = ID3D12Fence_SetEventOnCompletion(fence->fence, v, NULL);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
teapot->rt_idx = demo_swapchain_get_current_back_buffer_index(teapot->swapchain);
|
||
|
}
|
||
|
|
||
|
static void teapot_update_mvp(struct teapot *teapot)
|
||
|
{
|
||
|
struct demo_vec3 up = {0.0f, 0.0f, teapot->theta < 0.0f ? -1.0f : 1.0f};
|
||
|
struct demo_vec3 ref = {0.0f, 0.0f, 1.5f};
|
||
|
struct demo_matrix projection, world;
|
||
|
struct demo_vec3 eye;
|
||
|
float r = 25.0f;
|
||
|
|
||
|
eye.z = 1.5 + r * cosf(teapot->theta);
|
||
|
r *= sinf(teapot->theta);
|
||
|
eye.y = r * sinf(teapot->phi);
|
||
|
eye.x = r * cosf(teapot->phi);
|
||
|
|
||
|
demo_matrix_perspective_rh(&projection, 2.0f, 2.0f * teapot->height / teapot->width, 5.0f, 160.0f);
|
||
|
demo_matrix_look_at_rh(&world, &eye, &ref, &up);
|
||
|
demo_matrix_multiply(&teapot->cb_data->mvp_matrix, &world, &projection);
|
||
|
}
|
||
|
|
||
|
static void teapot_render_frame(struct teapot *teapot)
|
||
|
{
|
||
|
ID3D12CommandQueue_ExecuteCommandLists(teapot->command_queue, 1,
|
||
|
(ID3D12CommandList **)&teapot->swapchain_images[teapot->rt_idx].command_list);
|
||
|
demo_swapchain_present(teapot->swapchain);
|
||
|
teapot_wait_for_previous_frame(teapot);
|
||
|
}
|
||
|
|
||
|
static void teapot_destroy_pipeline(struct teapot *teapot)
|
||
|
{
|
||
|
unsigned int i;
|
||
|
|
||
|
ID3D12DescriptorHeap_Release(teapot->rtv_heap);
|
||
|
for (i = 0; i < demo_swapchain_get_back_buffer_count(teapot->swapchain); ++i)
|
||
|
{
|
||
|
ID3D12CommandAllocator_Release(teapot->swapchain_images[i].command_allocator);
|
||
|
ID3D12Resource_Release(teapot->swapchain_images[i].render_target);
|
||
|
}
|
||
|
free(teapot->swapchain_images);
|
||
|
demo_swapchain_destroy(teapot->swapchain);
|
||
|
ID3D12CommandQueue_Release(teapot->command_queue);
|
||
|
ID3D12Device_Release(teapot->device);
|
||
|
}
|
||
|
|
||
|
static void teapot_load_pipeline(struct teapot *teapot)
|
||
|
{
|
||
|
struct demo_swapchain_desc swapchain_desc;
|
||
|
D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle;
|
||
|
D3D12_DESCRIPTOR_HEAP_DESC heap_desc;
|
||
|
D3D12_COMMAND_QUEUE_DESC queue_desc;
|
||
|
unsigned int i, rt_count;
|
||
|
HRESULT hr;
|
||
|
|
||
|
hr = D3D12CreateDevice(NULL, D3D_FEATURE_LEVEL_11_0, &IID_ID3D12Device, (void **)&teapot->device);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
memset(&queue_desc, 0, sizeof(queue_desc));
|
||
|
queue_desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
|
||
|
queue_desc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
|
||
|
hr = ID3D12Device_CreateCommandQueue(teapot->device, &queue_desc,
|
||
|
&IID_ID3D12CommandQueue, (void **)&teapot->command_queue);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
swapchain_desc.buffer_count = 2;
|
||
|
swapchain_desc.format = DXGI_FORMAT_B8G8R8A8_UNORM;
|
||
|
swapchain_desc.width = teapot->width;
|
||
|
swapchain_desc.height = teapot->height;
|
||
|
teapot->swapchain = demo_swapchain_create(teapot->command_queue, teapot->window, &swapchain_desc);
|
||
|
assert(teapot->swapchain);
|
||
|
rt_count = demo_swapchain_get_back_buffer_count(teapot->swapchain);
|
||
|
teapot->swapchain_images = calloc(rt_count, sizeof(*teapot->swapchain_images));
|
||
|
assert(teapot->swapchain_images);
|
||
|
teapot->rt_idx = demo_swapchain_get_current_back_buffer_index(teapot->swapchain);
|
||
|
|
||
|
memset(&heap_desc, 0, sizeof(heap_desc));
|
||
|
heap_desc.NumDescriptors = rt_count;
|
||
|
heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
|
||
|
heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
|
||
|
hr = ID3D12Device_CreateDescriptorHeap(teapot->device, &heap_desc,
|
||
|
&IID_ID3D12DescriptorHeap, (void **)&teapot->rtv_heap);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
teapot->rtv_descriptor_size = ID3D12Device_GetDescriptorHandleIncrementSize(teapot->device,
|
||
|
D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
|
||
|
rtv_handle = ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(teapot->rtv_heap);
|
||
|
for (i = 0; i < rt_count; ++i)
|
||
|
{
|
||
|
teapot->swapchain_images[i].render_target = demo_swapchain_get_back_buffer(teapot->swapchain, i);
|
||
|
ID3D12Device_CreateRenderTargetView(teapot->device,
|
||
|
teapot->swapchain_images[i].render_target, NULL, rtv_handle);
|
||
|
rtv_handle.ptr += teapot->rtv_descriptor_size;
|
||
|
hr = ID3D12Device_CreateCommandAllocator(teapot->device, D3D12_COMMAND_LIST_TYPE_DIRECT,
|
||
|
&IID_ID3D12CommandAllocator, (void **)&teapot->swapchain_images[i].command_allocator);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void teapot_fence_destroy(struct teapot_fence *teapot_fence)
|
||
|
{
|
||
|
ID3D12Fence_Release(teapot_fence->fence);
|
||
|
}
|
||
|
|
||
|
static void teapot_destroy_assets(struct teapot *teapot)
|
||
|
{
|
||
|
unsigned int i;
|
||
|
|
||
|
teapot_fence_destroy(&teapot->fence);
|
||
|
ID3D12Resource_Release(teapot->ib);
|
||
|
ID3D12Resource_Release(teapot->vb);
|
||
|
ID3D12Resource_Unmap(teapot->cb, 0, NULL);
|
||
|
ID3D12Resource_Release(teapot->cb);
|
||
|
for (i = 0; i < demo_swapchain_get_back_buffer_count(teapot->swapchain); ++i)
|
||
|
{
|
||
|
ID3D12GraphicsCommandList_Release(teapot->swapchain_images[i].command_list);
|
||
|
}
|
||
|
ID3D12PipelineState_Release(teapot->pipeline_state);
|
||
|
ID3D12RootSignature_Release(teapot->root_signature);
|
||
|
}
|
||
|
|
||
|
static void teapot_fence_create(struct teapot_fence *fence, ID3D12Device *device)
|
||
|
{
|
||
|
HRESULT hr;
|
||
|
|
||
|
hr = ID3D12Device_CreateFence(device, 0, D3D12_FENCE_FLAG_NONE,
|
||
|
&IID_ID3D12Fence, (void **)&fence->fence);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
fence->value = 1;
|
||
|
}
|
||
|
|
||
|
static void teapot_load_mesh(struct teapot *teapot)
|
||
|
{
|
||
|
D3D12_RESOURCE_DESC resource_desc;
|
||
|
D3D12_HEAP_PROPERTIES heap_desc;
|
||
|
struct demo_patch *patches;
|
||
|
struct demo_vec3 *vertices;
|
||
|
size_t patch_count;
|
||
|
HRESULT hr;
|
||
|
|
||
|
patch_count = ARRAY_SIZE(teapot_rotate_patches) + ARRAY_SIZE(teapot_flip_patches);
|
||
|
|
||
|
heap_desc.Type = D3D12_HEAP_TYPE_UPLOAD;
|
||
|
heap_desc.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
|
||
|
heap_desc.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
|
||
|
heap_desc.CreationNodeMask = 1;
|
||
|
heap_desc.VisibleNodeMask = 1;
|
||
|
|
||
|
resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
|
||
|
resource_desc.Alignment = 0;
|
||
|
resource_desc.Width = sizeof(teapot_control_points);
|
||
|
resource_desc.Height = 1;
|
||
|
resource_desc.DepthOrArraySize = 1;
|
||
|
resource_desc.MipLevels = 1;
|
||
|
resource_desc.Format = DXGI_FORMAT_UNKNOWN;
|
||
|
resource_desc.SampleDesc.Count = 1;
|
||
|
resource_desc.SampleDesc.Quality = 0;
|
||
|
resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
|
||
|
resource_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
|
||
|
|
||
|
hr = ID3D12Device_CreateCommittedResource(teapot->device, &heap_desc, D3D12_HEAP_FLAG_NONE, &resource_desc,
|
||
|
D3D12_RESOURCE_STATE_GENERIC_READ, NULL, &IID_ID3D12Resource, (void **)&teapot->vb);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
resource_desc.Width = patch_count * sizeof(*patches);
|
||
|
hr = ID3D12Device_CreateCommittedResource(teapot->device, &heap_desc, D3D12_HEAP_FLAG_NONE, &resource_desc,
|
||
|
D3D12_RESOURCE_STATE_GENERIC_READ, NULL, &IID_ID3D12Resource, (void **)&teapot->ib);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
hr = ID3D12Resource_Map(teapot->vb, 0, &(D3D12_RANGE){0, 0}, (void **)&vertices);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
hr = ID3D12Resource_Map(teapot->ib, 0, &(D3D12_RANGE){0, 0}, (void **)&patches);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
memcpy(vertices, teapot_control_points, sizeof(teapot_control_points));
|
||
|
memcpy(patches, teapot_rotate_patches, sizeof(teapot_rotate_patches));
|
||
|
memcpy(&patches[ARRAY_SIZE(teapot_rotate_patches)], teapot_flip_patches, sizeof(teapot_flip_patches));
|
||
|
|
||
|
ID3D12Resource_Unmap(teapot->ib, 0, NULL);
|
||
|
ID3D12Resource_Unmap(teapot->vb, 0, NULL);
|
||
|
|
||
|
teapot->vbv.BufferLocation = ID3D12Resource_GetGPUVirtualAddress(teapot->vb);
|
||
|
teapot->vbv.StrideInBytes = sizeof(*teapot_control_points);
|
||
|
teapot->vbv.SizeInBytes = sizeof(teapot_control_points);
|
||
|
|
||
|
teapot->ibv.BufferLocation = ID3D12Resource_GetGPUVirtualAddress(teapot->ib);
|
||
|
teapot->ibv.SizeInBytes = patch_count * sizeof(*patches);
|
||
|
teapot->ibv.Format = DXGI_FORMAT_R16_UINT;
|
||
|
}
|
||
|
|
||
|
static void teapot_load_assets(struct teapot *teapot)
|
||
|
{
|
||
|
D3D12_ROOT_SIGNATURE_DESC root_signature_desc;
|
||
|
D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc;
|
||
|
D3D12_ROOT_PARAMETER root_parameters[1];
|
||
|
D3D12_RESOURCE_DESC resource_desc;
|
||
|
D3D12_HEAP_PROPERTIES heap_desc;
|
||
|
ID3DBlob *vs, *hs, *ds, *ps;
|
||
|
unsigned int i;
|
||
|
HRESULT hr;
|
||
|
|
||
|
static const D3D12_INPUT_ELEMENT_DESC il_desc[] =
|
||
|
{
|
||
|
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0},
|
||
|
};
|
||
|
|
||
|
root_parameters[0].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
|
||
|
root_parameters[0].Descriptor.ShaderRegister = 0;
|
||
|
root_parameters[0].Descriptor.RegisterSpace = 0;
|
||
|
root_parameters[0].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
|
||
|
|
||
|
memset(&root_signature_desc, 0, sizeof(root_signature_desc));
|
||
|
root_signature_desc.NumParameters = 1;
|
||
|
root_signature_desc.pParameters = root_parameters;
|
||
|
root_signature_desc.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT
|
||
|
| D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS
|
||
|
| D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS
|
||
|
| D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS;
|
||
|
hr = demo_create_root_signature(teapot->device, &root_signature_desc, &teapot->root_signature);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
hr = D3DCompile(teapot_hlsl, teapot_hlsl_size, "teapot.hlsl",
|
||
|
NULL, NULL, "vs_main", "vs_5_0", 0, 0, &vs, NULL);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
hr = D3DCompile(teapot_hlsl, teapot_hlsl_size, "teapot.hlsl",
|
||
|
NULL, NULL, "hs_main", "hs_5_0", 0, 0, &hs, NULL);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
hr = D3DCompile(teapot_hlsl, teapot_hlsl_size, "teapot.hlsl",
|
||
|
NULL, NULL, "ds_main", "ds_5_0", 0, 0, &ds, NULL);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
hr = D3DCompile(teapot_hlsl, teapot_hlsl_size, "teapot.hlsl",
|
||
|
NULL, NULL, "ps_main", "ps_5_0", 0, 0, &ps, NULL);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
memset(&pso_desc, 0, sizeof(pso_desc));
|
||
|
pso_desc.InputLayout.pInputElementDescs = il_desc;
|
||
|
pso_desc.InputLayout.NumElements = ARRAY_SIZE(il_desc);
|
||
|
pso_desc.pRootSignature = teapot->root_signature;
|
||
|
pso_desc.VS.pShaderBytecode = ID3D10Blob_GetBufferPointer(vs);
|
||
|
pso_desc.VS.BytecodeLength = ID3D10Blob_GetBufferSize(vs);
|
||
|
pso_desc.HS.pShaderBytecode = ID3D10Blob_GetBufferPointer(hs);
|
||
|
pso_desc.HS.BytecodeLength = ID3D10Blob_GetBufferSize(hs);
|
||
|
pso_desc.DS.pShaderBytecode = ID3D10Blob_GetBufferPointer(ds);
|
||
|
pso_desc.DS.BytecodeLength = ID3D10Blob_GetBufferSize(ds);
|
||
|
pso_desc.PS.pShaderBytecode = ID3D10Blob_GetBufferPointer(ps);
|
||
|
pso_desc.PS.BytecodeLength = ID3D10Blob_GetBufferSize(ps);
|
||
|
|
||
|
demo_rasterizer_desc_init_default(&pso_desc.RasterizerState);
|
||
|
pso_desc.RasterizerState.FillMode = D3D12_FILL_MODE_WIREFRAME;
|
||
|
pso_desc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
|
||
|
pso_desc.RasterizerState.FrontCounterClockwise = TRUE;
|
||
|
demo_blend_desc_init_default(&pso_desc.BlendState);
|
||
|
pso_desc.SampleMask = UINT_MAX;
|
||
|
pso_desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH;
|
||
|
pso_desc.NumRenderTargets = 1;
|
||
|
pso_desc.RTVFormats[0] = DXGI_FORMAT_B8G8R8A8_UNORM;
|
||
|
pso_desc.SampleDesc.Count = 1;
|
||
|
hr = ID3D12Device_CreateGraphicsPipelineState(teapot->device, &pso_desc,
|
||
|
&IID_ID3D12PipelineState, (void **)&teapot->pipeline_state);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
ID3D10Blob_Release(ps);
|
||
|
ID3D10Blob_Release(ds);
|
||
|
ID3D10Blob_Release(hs);
|
||
|
ID3D10Blob_Release(vs);
|
||
|
|
||
|
for (i = 0; i < demo_swapchain_get_back_buffer_count(teapot->swapchain); ++i)
|
||
|
{
|
||
|
hr = ID3D12Device_CreateCommandList(teapot->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT,
|
||
|
teapot->swapchain_images[i].command_allocator, teapot->pipeline_state,
|
||
|
&IID_ID3D12GraphicsCommandList, (void **)&teapot->swapchain_images[i].command_list);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
hr = ID3D12GraphicsCommandList_Close(teapot->swapchain_images[i].command_list);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
}
|
||
|
|
||
|
heap_desc.Type = D3D12_HEAP_TYPE_UPLOAD;
|
||
|
heap_desc.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
|
||
|
heap_desc.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
|
||
|
heap_desc.CreationNodeMask = 1;
|
||
|
heap_desc.VisibleNodeMask = 1;
|
||
|
|
||
|
resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
|
||
|
resource_desc.Alignment = 0;
|
||
|
resource_desc.Width = sizeof(*teapot->cb_data);
|
||
|
resource_desc.Height = 1;
|
||
|
resource_desc.DepthOrArraySize = 1;
|
||
|
resource_desc.MipLevels = 1;
|
||
|
resource_desc.Format = DXGI_FORMAT_UNKNOWN;
|
||
|
resource_desc.SampleDesc.Count = 1;
|
||
|
resource_desc.SampleDesc.Quality = 0;
|
||
|
resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
|
||
|
resource_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
|
||
|
|
||
|
hr = ID3D12Device_CreateCommittedResource(teapot->device, &heap_desc, D3D12_HEAP_FLAG_NONE, &resource_desc,
|
||
|
D3D12_RESOURCE_STATE_GENERIC_READ, NULL, &IID_ID3D12Resource, (void **)&teapot->cb);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
|
||
|
hr = ID3D12Resource_Map(teapot->cb, 0, &(D3D12_RANGE){0, 0}, (void **)&teapot->cb_data);
|
||
|
assert(SUCCEEDED(hr));
|
||
|
teapot_update_mvp(teapot);
|
||
|
teapot->cb_data->level = teapot->tessellation_level;
|
||
|
|
||
|
teapot_load_mesh(teapot);
|
||
|
|
||
|
teapot_fence_create(&teapot->fence, teapot->device);
|
||
|
teapot_wait_for_previous_frame(teapot);
|
||
|
}
|
||
|
|
||
|
static void teapot_key_press(struct demo_window *window, demo_key key, void *user_data)
|
||
|
{
|
||
|
struct teapot *teapot = user_data;
|
||
|
|
||
|
switch (key)
|
||
|
{
|
||
|
case '-':
|
||
|
case DEMO_KEY_KP_SUBTRACT:
|
||
|
if (teapot->tessellation_level > 1)
|
||
|
teapot->cb_data->level = --teapot->tessellation_level;
|
||
|
break;
|
||
|
case '=':
|
||
|
case DEMO_KEY_KP_ADD:
|
||
|
if (teapot->tessellation_level < D3D12_TESSELLATOR_MAX_TESSELLATION_FACTOR)
|
||
|
teapot->cb_data->level = ++teapot->tessellation_level;
|
||
|
break;
|
||
|
case DEMO_KEY_ESCAPE:
|
||
|
demo_window_destroy(window);
|
||
|
break;
|
||
|
case DEMO_KEY_LEFT:
|
||
|
teapot->phi -= M_PI / 36.0f;
|
||
|
if (teapot->phi < -M_PI)
|
||
|
teapot->phi += 2.0f * M_PI;
|
||
|
teapot_update_mvp(teapot);
|
||
|
break;
|
||
|
case DEMO_KEY_RIGHT:
|
||
|
teapot->phi += M_PI / 36.0f;
|
||
|
if (teapot->phi > M_PI)
|
||
|
teapot->phi -= 2.0f * M_PI;
|
||
|
teapot_update_mvp(teapot);
|
||
|
break;
|
||
|
case DEMO_KEY_UP:
|
||
|
teapot->theta -= M_PI / 36.0f;
|
||
|
if (teapot->theta < -M_PI)
|
||
|
teapot->theta += 2.0f * M_PI;
|
||
|
teapot_update_mvp(teapot);
|
||
|
break;
|
||
|
case DEMO_KEY_DOWN:
|
||
|
teapot->theta += M_PI / 36.0f;
|
||
|
if (teapot->theta > M_PI)
|
||
|
teapot->theta -= 2.0f * M_PI;
|
||
|
teapot_update_mvp(teapot);
|
||
|
break;
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void teapot_expose(struct demo_window *window, void *user_data)
|
||
|
{
|
||
|
teapot_render_frame(user_data);
|
||
|
}
|
||
|
|
||
|
static void teapot_idle(struct demo *demo, void *user_data)
|
||
|
{
|
||
|
teapot_render_frame(user_data);
|
||
|
}
|
||
|
|
||
|
static int teapot_main(void)
|
||
|
{
|
||
|
unsigned int width = 800, height = 600;
|
||
|
struct teapot teapot;
|
||
|
double dpi_x, dpi_y;
|
||
|
|
||
|
memset(&teapot, 0, sizeof(teapot));
|
||
|
if (!demo_init(&teapot.demo, &teapot))
|
||
|
return EXIT_FAILURE;
|
||
|
demo_set_idle_func(&teapot.demo, teapot_idle);
|
||
|
|
||
|
demo_get_dpi(&teapot.demo, &dpi_x, &dpi_y);
|
||
|
width *= dpi_x / 96.0;
|
||
|
height *= dpi_y / 96.0;
|
||
|
teapot.window = demo_window_create(&teapot.demo, "vkd3d teapot", width, height, &teapot);
|
||
|
demo_window_set_key_press_func(teapot.window, teapot_key_press);
|
||
|
demo_window_set_expose_func(teapot.window, teapot_expose);
|
||
|
|
||
|
teapot.width = width;
|
||
|
teapot.height = height;
|
||
|
teapot.tessellation_level = 4;
|
||
|
|
||
|
teapot.theta = M_PI / 2.0f;
|
||
|
teapot.phi = -M_PI / 4.0f;
|
||
|
|
||
|
teapot.vp.Width = width;
|
||
|
teapot.vp.Height = height;
|
||
|
teapot.vp.MaxDepth = 1.0f;
|
||
|
|
||
|
teapot.scissor_rect.right = width;
|
||
|
teapot.scissor_rect.bottom = height;
|
||
|
|
||
|
teapot_load_pipeline(&teapot);
|
||
|
teapot_load_assets(&teapot);
|
||
|
teapot_populate_command_lists(&teapot);
|
||
|
|
||
|
printf("vkd3d-teapot: Running on \"%s\" using %s.\n",
|
||
|
demo_swapchain_get_device_name(teapot.swapchain), demo_get_platform_name());
|
||
|
demo_process_events(&teapot.demo);
|
||
|
|
||
|
teapot_wait_for_previous_frame(&teapot);
|
||
|
teapot_destroy_assets(&teapot);
|
||
|
teapot_destroy_pipeline(&teapot);
|
||
|
demo_cleanup(&teapot.demo);
|
||
|
|
||
|
return EXIT_SUCCESS;
|
||
|
}
|
||
|
|
||
|
#ifdef _WIN32
|
||
|
/* Do not trigger -Wmissing-prototypes. */
|
||
|
int wmain(void);
|
||
|
|
||
|
int wmain(void)
|
||
|
#else
|
||
|
int main(void)
|
||
|
#endif
|
||
|
{
|
||
|
return teapot_main();
|
||
|
}
|