wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2024-11-21 16:46:41 -08:00
Code Issues Packages Projects Releases Wiki Activity

demos/gears: Add a gears demo.

Browse Source
This commit is contained in:
Henri Verbeet 2016-11-02 14:56:13 +01:00
parent cd4f4a2976
commit 20508aee7c
11 changed files with 1115 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
Makefile.am
View File

@ -19,20 +19,27 @@ vkd3d_public_headers = \
include/vkd3d_utils.h \
include/vkd3d_windows.h
spv_gears_shaders = \
demos/gears.vert.spv \
demos/gears_flat.frag.spv \
demos/gears_smooth.frag.spv
spv_triangle_shaders = \
demos/triangle.vert.spv \
demos/triangle.frag.spv
spv_shaders = \
$(spv_gears_shaders) \
$(spv_triangle_shaders)
hlsl_shaders = \
demos/gears.hlsl \
demos/triangle.hlsl
vkd3d_tests = \
tests/d3d12
vkd3d_demos = \
demos/gears \
demos/triangle
vkd3d_demos_headers = \
@ -84,11 +91,18 @@ AM_DEFAULT_SOURCE_EXT = .c
TESTS = $(vkd3d_tests)
tests_d3d12_LDADD = $(LDADD) @PTHREAD_LIBS@
DEMOS_LDADD = libvkd3d.la $(LDADD) @XCB_LIBS@
DEMOS_CFLAGS = @XCB_CFLAGS@
noinst_PROGRAMS = $(vkd3d_demos)
EXTRA_DIST += $(vkd3d_demos_headers)
EXTRA_demos_gears_DEPENDENCIES = $(spv_gears_shaders)
demos_gears_CFLAGS = $(DEMOS_CFLAGS)
demos_gears_LDADD = $(DEMOS_LDADD) -lm
EXTRA_demos_triangle_DEPENDENCIES = $(spv_triangle_shaders)
demos_triangle_CFLAGS = @XCB_CFLAGS@
demos_triangle_LDADD = libvkd3d.la $(LDADD) @XCB_LIBS@
demos_triangle_CFLAGS = $(DEMOS_CFLAGS)
demos_triangle_LDADD = $(DEMOS_LDADD)
VKD3D_V_WIDL = $(vkd3d_v_widl_@AM_V@)
vkd3d_v_widl_ = $(vkd3d_v_widl_@AM_DEFAULT_V@)

1
demos/.gitignore vendored
View File

@ -1,2 +1,3 @@
gears
triangle
*.spv

19
demos/demo.h
View File

@ -47,6 +47,10 @@
#define DEMO_KEY_UNKNOWN 0x0000
#define DEMO_KEY_ESCAPE 0xff1b
#define DEMO_KEY_LEFT 0xff51
#define DEMO_KEY_UP 0xff52
#define DEMO_KEY_RIGHT 0xff53
#define DEMO_KEY_DOWN 0xff54
struct demo_vec3
{
@ -68,6 +72,21 @@ struct demo_swapchain_desc
typedef uint32_t demo_key;
static inline void demo_vec3_set(struct demo_vec3 *v, float x, float y, float z)
{
v->x = x;
v->y = y;
v->z = z;
}
static inline void demo_vec4_set(struct demo_vec4 *v, float x, float y, float z, float w)
{
v->x = x;
v->y = y;
v->z = z;
v->w = w;
}
static inline void demo_rasterizer_desc_init_default(D3D12_RASTERIZER_DESC *desc)
{
desc->FillMode = D3D12_FILL_MODE_SOLID;

55
demos/demo_win32.h
View File

@ -35,6 +35,9 @@ struct demo
ID3DBlob **code, ID3DBlob **errors);
size_t window_count;
bool quit;
void *user_data;
void (*idle_func)(struct demo *demo, void *user_data);
};
struct demo_window
@ -101,8 +104,32 @@ static inline void demo_window_destroy(struct demo_window *window)
static inline demo_key demo_key_from_vkey(DWORD vkey)
{
if (vkey == VK_ESCAPE)
return DEMO_KEY_ESCAPE;
static const struct
{
DWORD vkey;
demo_key demo_key;
}
lookup[] =
{
{VK_ESCAPE, DEMO_KEY_ESCAPE},
{VK_LEFT, DEMO_KEY_LEFT},
{VK_RIGHT, DEMO_KEY_RIGHT},
{VK_UP, DEMO_KEY_UP},
{VK_DOWN, DEMO_KEY_DOWN},
};
unsigned int i;
if (vkey >= '0' && vkey <= '9')
return vkey;
if (vkey >= 'A' && vkey <= 'Z')
return vkey;
for (i = 0; i < ARRAY_SIZE(lookup); ++i)
{
if (lookup[i].vkey == vkey)
return lookup[i].demo_key;
}
return DEMO_KEY_UNKNOWN;
}
@ -149,8 +176,19 @@ static inline void demo_process_events(struct demo *demo)
{
MSG msg = {0};
while (GetMessage(&msg, NULL, 0, 0) != -1)
for (;;)
{
if (!demo->idle_func)
{
if (GetMessageW(&msg, NULL, 0, 0) == -1)
break;
}
else if (!PeekMessageW(&msg, 0, 0, 0, PM_REMOVE))
{
demo->idle_func(demo, demo->user_data);
continue;
}
if (msg.message == WM_QUIT)
break;
TranslateMessage(&msg);
@ -160,7 +198,7 @@ static inline void demo_process_events(struct demo *demo)
}
}
static inline bool demo_init(struct demo *demo)
static inline bool demo_init(struct demo *demo, void *user_data)
{
WNDCLASSEXW wc;
@ -184,7 +222,10 @@ static inline bool demo_init(struct demo *demo)
if (!RegisterClassExW(&wc))
goto fail;
demo->window_count = 0;
demo->quit = false;
demo->user_data = user_data;
demo->idle_func = NULL;
return true;
@ -199,6 +240,12 @@ static inline void demo_cleanup(struct demo *demo)
FreeLibrary(demo->d3dcompiler);
}
static inline void demo_set_idle_func(struct demo *demo,
void (*idle_func)(struct demo *demo, void *user_data))
{
demo->idle_func = idle_func;
}
static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *command_queue,
struct demo_window *window, const struct demo_swapchain_desc *desc)
{

26
demos/demo_xcb.h
View File

@ -41,6 +41,9 @@ struct demo
struct demo_window **windows;
size_t windows_size;
size_t window_count;
void *user_data;
void (*idle_func)(struct demo *demo, void *user_data);
};
struct demo_window
@ -207,8 +210,19 @@ static inline void demo_process_events(struct demo *demo)
xcb_flush(demo->connection);
while (demo->window_count && (event = xcb_wait_for_event(demo->connection)))
while (demo->window_count)
{
if (!demo->idle_func)
{
if (!(event = xcb_wait_for_event(demo->connection)))
break;
}
else if (!(event = xcb_poll_for_event(demo->connection)))
{
demo->idle_func(demo, demo->user_data);
continue;
}
switch (XCB_EVENT_RESPONSE_TYPE(event))
{
case XCB_EXPOSE:
@ -238,7 +252,7 @@ static inline void demo_process_events(struct demo *demo)
}
}
static inline bool demo_init(struct demo *demo)
static inline bool demo_init(struct demo *demo, void *user_data)
{
if (!(demo->connection = xcb_connect(NULL, NULL)))
return false;
@ -254,6 +268,8 @@ static inline bool demo_init(struct demo *demo)
demo->windows = NULL;
demo->windows_size = 0;
demo->window_count = 0;
demo->user_data = user_data;
demo->idle_func = NULL;
return true;
@ -269,6 +285,12 @@ static inline void demo_cleanup(struct demo *demo)
xcb_disconnect(demo->connection);
}
static inline void demo_set_idle_func(struct demo *demo,
void (*idle_func)(struct demo *demo, void *user_data))
{
demo->idle_func = idle_func;
}
static inline DXGI_FORMAT demo_get_srgb_format(DXGI_FORMAT format)
{
switch (format)

888
demos/gears.c Normal file
View File

@ -0,0 +1,888 @@
/*
* Copyright 2016 Henri Verbeet for CodeWeavers
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
/*
* This application contains code derived from glxgears, the license for which
* follows:
*
* Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#define INITGUID
#define _GNU_SOURCE
#include <sys/time.h>
#include <assert.h>
#include <stdio.h>
#include <math.h>
#include "demo.h"
struct cxg_fence
{
ID3D12Fence *fence;
UINT64 value;
HANDLE event;
};
struct cxg_cb_data
{
float mvp_matrix[16];
float normal_matrix[12];
};
struct cxg_instance_data
{
struct demo_vec3 diffuse;
struct demo_vec4 transform;
};
struct cxg_vertex
{
struct demo_vec3 position;
struct demo_vec3 normal;
};
struct cxg_face
{
uint16_t v[3];
};
struct cxg_mesh
{
struct cxg_vertex *vertices;
size_t vertex_count;
struct cxg_face *faces;
size_t flat_face_count;
size_t smooth_face_count;
};
struct cxg_draw
{
size_t vertex_idx;
size_t flat_index_idx;
size_t flat_index_count;
size_t smooth_index_idx;
size_t smooth_index_count;
};
struct cx_gears
{
struct demo demo;
struct demo_window *window;
unsigned int width;
unsigned int height;
float aspect_ratio;
bool animate;
float alpha;
float theta;
float phi;
D3D12_VIEWPORT vp;
D3D12_RECT scissor_rect;
ID3D12Device *device;
ID3D12CommandQueue *command_queue;
struct demo_swapchain *swapchain;
ID3D12DescriptorHeap *rtv_heap, *dsv_heap;
unsigned int rtv_descriptor_size;
ID3D12Resource *render_targets[2];
ID3D12CommandAllocator *command_allocator[2];
ID3D12RootSignature *root_signature;
ID3D12PipelineState *pipeline_state_smooth, *pipeline_state_flat;
ID3D12GraphicsCommandList *command_list[2];
ID3D12Resource *ds, *cb, *vb[2], *ib;
D3D12_VERTEX_BUFFER_VIEW vbv[2];
D3D12_INDEX_BUFFER_VIEW ibv;
unsigned int rt_idx;
struct cxg_fence fence;
struct cxg_cb_data *cb_data;
struct cxg_instance_data *instance_data;
struct cxg_draw draws[3];
};
static void cxg_populate_command_list(struct cx_gears *cxg, unsigned int rt_idx)
{
ID3D12GraphicsCommandList *command_list = cxg->command_list[rt_idx];
static const float clear_colour[] = {0.0f, 0.0f, 0.0f, 1.0f};
D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, dsv_handle;
D3D12_RESOURCE_BARRIER barrier;
HRESULT hr;
size_t i;
hr = ID3D12CommandAllocator_Reset(cxg->command_allocator[rt_idx]);
assert(SUCCEEDED(hr));
hr = ID3D12GraphicsCommandList_Reset(command_list, cxg->command_allocator[rt_idx], cxg->pipeline_state_flat);
assert(SUCCEEDED(hr));
ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, cxg->root_signature);
ID3D12GraphicsCommandList_SetGraphicsRootConstantBufferView(command_list, 0,
ID3D12Resource_GetGPUVirtualAddress(cxg->cb));
ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &cxg->vp);
ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &cxg->scissor_rect);
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrier.Transition.pResource = cxg->render_targets[rt_idx];
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(cxg->rtv_heap);
rtv_handle.ptr += rt_idx * cxg->rtv_descriptor_size;
dsv_handle = ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(cxg->dsv_heap);
ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &rtv_handle, FALSE, &dsv_handle);
ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, rtv_handle, clear_colour, 0, NULL);
ID3D12GraphicsCommandList_ClearDepthStencilView(command_list,
dsv_handle, D3D12_CLEAR_FLAG_DEPTH, 1.0f, 0, 0, NULL);
ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
ID3D12GraphicsCommandList_IASetIndexBuffer(command_list, &cxg->ibv);
ID3D12GraphicsCommandList_IASetVertexBuffers(command_list, 0, 2, cxg->vbv);
for (i = 0; i < ARRAY_SIZE(cxg->draws); ++i)
{
ID3D12GraphicsCommandList_DrawIndexedInstanced(command_list, cxg->draws[i].flat_index_count,
1, cxg->draws[i].flat_index_idx, cxg->draws[i].vertex_idx, i);
ID3D12GraphicsCommandList_SetPipelineState(command_list, cxg->pipeline_state_smooth);
ID3D12GraphicsCommandList_DrawIndexedInstanced(command_list, cxg->draws[i].smooth_index_count,
1, cxg->draws[i].smooth_index_idx, cxg->draws[i].vertex_idx, i);
ID3D12GraphicsCommandList_SetPipelineState(command_list, cxg->pipeline_state_flat);
}
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 cxg_wait_for_previous_frame(struct cx_gears *cxg)
{
struct cxg_fence *fence = &cxg->fence;
const UINT64 v = fence->value;
HRESULT hr;
hr = ID3D12CommandQueue_Signal(cxg->command_queue, fence->fence, v);
assert(SUCCEEDED(hr));
++fence->value;
if (ID3D12Fence_GetCompletedValue(fence->fence) < v)
{
ID3D12Fence_SetEventOnCompletion(fence->fence, v, fence->event);
demo_wait_event(fence->event, INFINITE);
}
cxg->rt_idx = demo_swapchain_get_current_back_buffer_index(cxg->swapchain);
}
static void cxg_update_mvp(struct cx_gears *cxg)
{
float s1 = sinf(cxg->theta);
float c1 = cosf(cxg->theta);
float s2 = sinf(cxg->phi);
float c2 = cosf(cxg->phi);
float z_offset = -40.0f;
float z_max = 60.0f;
float z_min = 5.0f;
float sx = z_min;
float sy = z_min * cxg->aspect_ratio;
float sz = -((z_max + z_min) / (z_max - z_min));
float d = (-2.0f * z_max * z_min) / (z_max - z_min);
unsigned int i, j;
float world[] =
{
c1, s2 * s1, c2 * -s1, 0.0f,
0.0f, c2, s2, 0.0f,
s1, -s2 * c1, c2 * c1, 0.0f,
0.0f, 0.0f, z_offset, 1.0f,
};
float projection[] =
{
sx, 0.0f, 0.0f, 0.0f,
0.0f, sy, 0.0f, 0.0f,
0.0f, 0.0f, sz, -1.0f,
0.0f, 0.0f, d, 0.0f,
};
for (i = 0; i < 4; ++i)
{
for (j = 0; j < 4; ++j)
{
cxg->cb_data->mvp_matrix[i * 4 + j] = projection[j] * world[i * 4]
+ projection[j + 4] * world[i * 4 + 1]
+ projection[j + 8] * world[i * 4 + 2]
+ projection[j + 12] * world[i * 4 + 3];
}
}
memcpy(cxg->cb_data->normal_matrix, world, sizeof(cxg->cb_data->normal_matrix));
}
static void cxg_render_frame(struct cx_gears *cxg)
{
static double t_prev = -1.0;
struct timeval tv;
double dt, t;
float a;
gettimeofday(&tv, NULL);
t = tv.tv_sec + tv.tv_usec / 1000000.0;
if (t_prev < 0.0)
t_prev = t;
dt = t - t_prev;
t_prev = t;
if (cxg->animate)
{
cxg->alpha += (70.0 * M_PI / 180.0) * dt; /* 70°/s */
if (cxg->alpha > 20.0 * M_PI)
cxg->alpha -= 20.0 * M_PI;
}
a = cxg->alpha;
demo_vec4_set(&cxg->instance_data[0].transform, cosf(a), sinf(a), -3.0f, -2.0f);
a = (-2.0f * cxg->alpha) - 9.0f * M_PI / 180.0;
demo_vec4_set(&cxg->instance_data[1].transform, cosf(a), sinf(a), 3.1f, -2.0f);
a = (-2.0f * cxg->alpha) - 25.0f * M_PI / 180.0;
demo_vec4_set(&cxg->instance_data[2].transform, cosf(a), sinf(a), -3.1f, 4.2f);
ID3D12CommandQueue_ExecuteCommandLists(cxg->command_queue, 1,
(ID3D12CommandList **)&cxg->command_list[cxg->rt_idx]);
demo_swapchain_present(cxg->swapchain);
cxg_wait_for_previous_frame(cxg);
}
static void cxg_destroy_pipeline(struct cx_gears *cxg)
{
unsigned int i;
ID3D12CommandAllocator_Release(cxg->command_allocator[1]);
ID3D12CommandAllocator_Release(cxg->command_allocator[0]);
for (i = 0; i < ARRAY_SIZE(cxg->render_targets); ++i)
{
ID3D12Resource_Release(cxg->render_targets[i]);
}
ID3D12DescriptorHeap_Release(cxg->dsv_heap);
ID3D12DescriptorHeap_Release(cxg->rtv_heap);
demo_swapchain_destroy(cxg->swapchain);
ID3D12CommandQueue_Release(cxg->command_queue);
ID3D12Device_Release(cxg->device);
}
static void cxg_load_pipeline(struct cx_gears *cxg)
{
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;
HRESULT hr;
hr = D3D12CreateDevice(NULL, D3D_FEATURE_LEVEL_11_0, &IID_ID3D12Device, (void **)&cxg->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(cxg->device, &queue_desc,
&IID_ID3D12CommandQueue, (void **)&cxg->command_queue);
assert(SUCCEEDED(hr));
swapchain_desc.buffer_count = ARRAY_SIZE(cxg->render_targets);
swapchain_desc.format = DXGI_FORMAT_B8G8R8A8_UNORM;
swapchain_desc.width = cxg->width;
swapchain_desc.height = cxg->height;
cxg->swapchain = demo_swapchain_create(cxg->command_queue, cxg->window, &swapchain_desc);
assert(cxg->swapchain);
cxg->rt_idx = demo_swapchain_get_current_back_buffer_index(cxg->swapchain);
memset(&heap_desc, 0, sizeof(heap_desc));
heap_desc.NumDescriptors = ARRAY_SIZE(cxg->render_targets);
heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
hr = ID3D12Device_CreateDescriptorHeap(cxg->device, &heap_desc,
&IID_ID3D12DescriptorHeap, (void **)&cxg->rtv_heap);
assert(SUCCEEDED(hr));
cxg->rtv_descriptor_size = ID3D12Device_GetDescriptorHandleIncrementSize(cxg->device,
D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
rtv_handle = ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(cxg->rtv_heap);
for (i = 0; i < ARRAY_SIZE(cxg->render_targets); ++i)
{
cxg->render_targets[i] = demo_swapchain_get_back_buffer(cxg->swapchain, i);
ID3D12Device_CreateRenderTargetView(cxg->device, cxg->render_targets[i], NULL, rtv_handle);
rtv_handle.ptr += cxg->rtv_descriptor_size;
}
heap_desc.NumDescriptors = 1;
heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
hr = ID3D12Device_CreateDescriptorHeap(cxg->device, &heap_desc,
&IID_ID3D12DescriptorHeap, (void **)&cxg->dsv_heap);
assert(SUCCEEDED(hr));
hr = ID3D12Device_CreateCommandAllocator(cxg->device, D3D12_COMMAND_LIST_TYPE_DIRECT,
&IID_ID3D12CommandAllocator, (void **)&cxg->command_allocator[0]);
assert(SUCCEEDED(hr));
hr = ID3D12Device_CreateCommandAllocator(cxg->device, D3D12_COMMAND_LIST_TYPE_DIRECT,
&IID_ID3D12CommandAllocator, (void **)&cxg->command_allocator[1]);
assert(SUCCEEDED(hr));
}
static void cxg_fence_destroy(struct cxg_fence *cxg_fence)
{
ID3D12Fence_Release(cxg_fence->fence);
demo_destroy_event(cxg_fence->event);
}
static void cxg_destroy_assets(struct cx_gears *cxg)
{
cxg_fence_destroy(&cxg->fence);
ID3D12Resource_Release(cxg->ib);
ID3D12Resource_Unmap(cxg->vb[1], 0, NULL);
ID3D12Resource_Release(cxg->vb[1]);
ID3D12Resource_Release(cxg->vb[0]);
ID3D12Resource_Unmap(cxg->cb, 0, NULL);
ID3D12Resource_Release(cxg->cb);
ID3D12Resource_Release(cxg->ds);
ID3D12GraphicsCommandList_Release(cxg->command_list[1]);
ID3D12GraphicsCommandList_Release(cxg->command_list[0]);
ID3D12PipelineState_Release(cxg->pipeline_state_smooth);
ID3D12PipelineState_Release(cxg->pipeline_state_flat);
ID3D12RootSignature_Release(cxg->root_signature);
}
static void cxg_fence_create(struct cxg_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;
fence->event = demo_create_event();
assert(fence->event);
}
static void cxg_vertex_set_position(struct cxg_vertex *v, float x, float y, float z)
{
demo_vec3_set(&v->position, x, y, z);
}
static void cxg_vertex_set_normal(struct cxg_vertex *v, float x, float y, float z)
{
demo_vec3_set(&v->normal, x, y, z);
}
static void cxg_mesh_create(ID3D12Device *device, float inner_radius, float outer_radius, float width,
unsigned int tooth_count, float tooth_depth, struct cxg_mesh *mesh)
{
struct cxg_vertex *vertices;
struct cxg_face *faces;
unsigned int i, j;
float r0, r1, r2;
float angle, da;
if (!(vertices = calloc(tooth_count, 12 * sizeof(*vertices))))
return;
if (!(faces = calloc(tooth_count, 20 * sizeof(*faces))))
{
free(vertices);
return;
}
r0 = inner_radius;
r1 = outer_radius - tooth_depth / 2.0f;
r2 = outer_radius + tooth_depth / 2.0f;
da = 2.0f * M_PI / tooth_count / 4.0f;
for (i = 0; i < tooth_count; ++i)
{
struct cxg_vertex *tooth = &vertices[i * 12];
float u, v;
angle = i * 2.0f * M_PI / tooth_count;
cxg_vertex_set_position(&tooth[0], r0 * cosf(angle), r0 * sinf(angle), width * 0.5f);
cxg_vertex_set_normal(&tooth[0], -cosf(angle), -sinf(angle), 0.0f);
cxg_vertex_set_position(&tooth[1], r1 * cosf(angle), r1 * sinf(angle), width * 0.5f);
cxg_vertex_set_normal(&tooth[1], 0.0f, 0.0f, 1.0f);
cxg_vertex_set_position(&tooth[2], r1 * cosf(angle + 3 * da), r1 * sinf(angle + 3 * da), width * 0.5f);
cxg_vertex_set_normal(&tooth[2], 0.0f, 0.0f, 1.0f);
cxg_vertex_set_position(&tooth[3], r2 * cosf(angle + da), r2 * sinf(angle + da), width * 0.5f);
cxg_vertex_set_normal(&tooth[3], cosf(angle), sinf(angle), 0.0f);
cxg_vertex_set_position(&tooth[4], r2 * cosf(angle + 2 * da), r2 * sinf(angle + 2 * da), width * 0.5f);
u = r1 * cosf(angle + 3 * da) - r2 * cosf(angle + 2 * da);
v = r1 * sinf(angle + 3 * da) - r2 * sinf(angle + 2 * da);
cxg_vertex_set_normal(&tooth[4], v, -u, 0.0f);
cxg_vertex_set_position(&tooth[5], r0 * cosf(angle), r0 * sinf(angle), -width * 0.5f);
cxg_vertex_set_normal(&tooth[5], -cosf(angle), -sinf(angle), 0.0f);
cxg_vertex_set_position(&tooth[6], r1 * cosf(angle), r1 * sinf(angle), -width * 0.5f);
cxg_vertex_set_normal(&tooth[6], 0.0f, 0.0f, -1.0f);
cxg_vertex_set_position(&tooth[7], r1 * cosf(angle + 3 * da), r1 * sinf(angle + 3 * da), -width * 0.5f);
cxg_vertex_set_normal(&tooth[7], 0.0f, 0.0f, -1.0f);
cxg_vertex_set_position(&tooth[8], r2 * cosf(angle + da), r2 * sinf(angle + da), -width * 0.5f);
cxg_vertex_set_normal(&tooth[8], 0.0f, 0.0f, -1.0f);
cxg_vertex_set_position(&tooth[9], r2 * cosf(angle + 2 * da), r2 * sinf(angle + 2 * da), -width * 0.5f);
cxg_vertex_set_normal(&tooth[9], 0.0f, 0.0f, -1.0f);
cxg_vertex_set_position(&tooth[10], r1 * cosf(angle), r1 * sinf(angle), width * 0.5f);
u = r2 * cosf(angle + da) - r1 * cosf(angle);
v = r2 * sinf(angle + da) - r1 * sinf(angle);
cxg_vertex_set_normal(&tooth[10], v, -u, 0.0f);
cxg_vertex_set_position(&tooth[11], r1 * cosf(angle + 3 * da), r1 * sinf(angle + 3 * da), width * 0.5f);
cxg_vertex_set_normal(&tooth[11], cosf(angle), sinf(angle), 0.0f);
}
for (i = 0; i < tooth_count; ++i)
{
struct cxg_face *f = &faces[i * 18];
static const struct cxg_face flat_faces[] =
{
/* Front */
{{ 1, 2, 0}},
{{ 1, 3, 4}},
{{ 1, 4, 2}},
{{ 2, 12, 0}},
{{ 2, 13, 12}},
/* Back */
{{ 6, 5, 7}},
{{ 6, 9, 8}},
{{ 6, 7, 9}},
{{ 7, 5, 17}},
{{ 7, 17, 18}},
/* Outward */
{{10, 6, 8}},
{{10, 8, 3}},
{{ 3, 8, 9}},
{{ 3, 9, 4}},
{{ 4, 9, 7}},
{{ 4, 7, 11}},
{{11, 7, 18}},
{{11, 18, 22}},
};
for (j = 0; j < ARRAY_SIZE(flat_faces); ++j)
{
f[j].v[0] = (flat_faces[j].v[0] + i * 12) % (tooth_count * 12);
f[j].v[1] = (flat_faces[j].v[1] + i * 12) % (tooth_count * 12);
f[j].v[2] = (flat_faces[j].v[2] + i * 12) % (tooth_count * 12);
}
}
for (i = 0; i < tooth_count; ++i)
{
struct cxg_face *f = &faces[i * 2 + tooth_count * 18];
static const struct cxg_face smooth_faces[] =
{
/* Inward */
{{ 0, 17, 5}},
{{ 0, 12, 17}},
};
for (j = 0; j < ARRAY_SIZE(smooth_faces); ++j)
{
f[j].v[0] = (smooth_faces[j].v[0] + i * 12) % (tooth_count * 12);
f[j].v[1] = (smooth_faces[j].v[1] + i * 12) % (tooth_count * 12);
f[j].v[2] = (smooth_faces[j].v[2] + i * 12) % (tooth_count * 12);
}
}
mesh->vertices = vertices;
mesh->vertex_count = 12 * tooth_count;
mesh->faces = faces;
mesh->flat_face_count = 18 * tooth_count;
mesh->smooth_face_count = 2 * tooth_count;
}
static void cxg_mesh_destroy(struct cxg_mesh *mesh)
{
free(mesh->faces);
free(mesh->vertices);
}
static void cxg_load_gears(struct cx_gears *cxg)
{
size_t vertex_count, face_count, vertex_idx, face_idx, i;
D3D12_RESOURCE_DESC resource_desc;
D3D12_HEAP_PROPERTIES heap_desc;
D3D12_RANGE read_range = {0, 0};
struct cxg_vertex *vertices;
struct cxg_mesh gears[3];
struct cxg_face *faces;
HRESULT hr;
cxg_mesh_create(cxg->device, 1.0f, 4.0f, 1.0f, 20, 0.7f, &gears[0]);
demo_vec3_set(&cxg->instance_data[0].diffuse, 0.8f, 0.1f, 0.0f);
cxg_mesh_create(cxg->device, 0.5f, 2.0f, 2.0f, 10, 0.7f, &gears[1]);
demo_vec3_set(&cxg->instance_data[1].diffuse, 0.0f, 0.8f, 0.2f);
cxg_mesh_create(cxg->device, 1.3f, 2.0f, 0.5f, 10, 0.7f, &gears[2]);
demo_vec3_set(&cxg->instance_data[2].diffuse, 0.2f, 0.2f, 1.0f);
for (i = 0, vertex_count = 0, face_count = 0; i < ARRAY_SIZE(gears); ++i)
{
vertex_count += gears[i].vertex_count;
face_count += gears[i].flat_face_count + gears[i].smooth_face_count;
}
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 = vertex_count * sizeof(*vertices);
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(cxg->device, &heap_desc, D3D12_HEAP_FLAG_NONE, &resource_desc,
D3D12_RESOURCE_STATE_GENERIC_READ, NULL, &IID_ID3D12Resource, (void **)&cxg->vb[0]);
assert(SUCCEEDED(hr));
resource_desc.Width = face_count * sizeof(*faces);
hr = ID3D12Device_CreateCommittedResource(cxg->device, &heap_desc, D3D12_HEAP_FLAG_NONE, &resource_desc,
D3D12_RESOURCE_STATE_GENERIC_READ, NULL, &IID_ID3D12Resource, (void **)&cxg->ib);
assert(SUCCEEDED(hr));
hr = ID3D12Resource_Map(cxg->vb[0], 0, &read_range, (void **)&vertices);
assert(SUCCEEDED(hr));
hr = ID3D12Resource_Map(cxg->ib, 0, &read_range, (void **)&faces);
assert(SUCCEEDED(hr));
for (i = 0, vertex_idx = 0, face_idx = 0; i < ARRAY_SIZE(gears); ++i)
{
size_t tmp;
cxg->draws[i].vertex_idx = vertex_idx;
memcpy(&vertices[vertex_idx], gears[i].vertices, gears[i].vertex_count * sizeof(*vertices));
vertex_idx += gears[i].vertex_count;
cxg->draws[i].flat_index_idx = 3 * face_idx;
cxg->draws[i].flat_index_count = 3 * gears[i].flat_face_count;
cxg->draws[i].smooth_index_idx = cxg->draws[i].flat_index_idx + cxg->draws[i].flat_index_count;
cxg->draws[i].smooth_index_count = 3 * gears[i].smooth_face_count;
tmp = gears[i].flat_face_count + gears[i].smooth_face_count;
memcpy(&faces[face_idx], gears[i].faces, tmp * sizeof(*faces));
face_idx += tmp;
}
ID3D12Resource_Unmap(cxg->ib, 0, NULL);
ID3D12Resource_Unmap(cxg->vb[0], 0, NULL);
cxg_mesh_destroy(&gears[2]);
cxg_mesh_destroy(&gears[1]);
cxg_mesh_destroy(&gears[0]);
cxg->vbv[0].BufferLocation = ID3D12Resource_GetGPUVirtualAddress(cxg->vb[0]);
cxg->vbv[0].StrideInBytes = sizeof(*vertices);
cxg->vbv[0].SizeInBytes = vertex_count * sizeof(*vertices);
cxg->ibv.BufferLocation = ID3D12Resource_GetGPUVirtualAddress(cxg->ib);
cxg->ibv.SizeInBytes = face_count * sizeof(*faces);
cxg->ibv.Format = DXGI_FORMAT_R16_UINT;
}
static void cxg_load_assets(struct cx_gears *cxg)
{
static const D3D12_INPUT_ELEMENT_DESC il_desc[] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0},
{"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0},
{"DIFFUSE", 0, DXGI_FORMAT_R32G32B32_FLOAT, 1, 0, D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, 1},
{"TRANSFORM", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 12, D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, 1},
};
D3D12_ROOT_SIGNATURE_DESC root_signature_desc;
D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc;
D3D12_CPU_DESCRIPTOR_HANDLE dsv_handle;
D3D12_ROOT_PARAMETER root_parameter;
D3D12_RESOURCE_DESC resource_desc;
D3D12_HEAP_PROPERTIES heap_desc;
D3D12_RANGE read_range = {0, 0};
D3D12_CLEAR_VALUE clear_value;
HRESULT hr;
bool ret;
root_parameter.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
root_parameter.Descriptor.ShaderRegister = 0;
root_parameter.Descriptor.RegisterSpace = 0;
root_parameter.ShaderVisibility = D3D12_SHADER_VISIBILITY_VERTEX;
memset(&root_signature_desc, 0, sizeof(root_signature_desc));
root_signature_desc.NumParameters = 1;
root_signature_desc.pParameters = &root_parameter;
root_signature_desc.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT
| D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS
| D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_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(cxg->device, &root_signature_desc, &cxg->root_signature);
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 = cxg->root_signature;
ret = demo_load_shader(&cxg->demo, L"gears.hlsl", "vs_main", "vs_5_0", "gears.vert.spv", &pso_desc.VS);
assert(ret);
ret = demo_load_shader(&cxg->demo, L"gears.hlsl", "ps_main_flat",
"ps_5_0", "gears_flat.frag.spv", &pso_desc.PS);
assert(ret);
demo_rasterizer_desc_init_default(&pso_desc.RasterizerState);
pso_desc.RasterizerState.FrontCounterClockwise = TRUE;
demo_blend_desc_init_default(&pso_desc.BlendState);
pso_desc.DepthStencilState.DepthEnable = TRUE;
pso_desc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
pso_desc.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS;
pso_desc.DepthStencilState.StencilEnable = FALSE;
pso_desc.SampleMask = UINT_MAX;
pso_desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
pso_desc.NumRenderTargets = 1;
pso_desc.RTVFormats[0] = DXGI_FORMAT_B8G8R8A8_UNORM;
pso_desc.DSVFormat = DXGI_FORMAT_D32_FLOAT;
pso_desc.SampleDesc.Count = 1;
hr = ID3D12Device_CreateGraphicsPipelineState(cxg->device, &pso_desc,
&IID_ID3D12PipelineState, (void **)&cxg->pipeline_state_flat);
assert(SUCCEEDED(hr));
free((void *)pso_desc.PS.pShaderBytecode);
ret = demo_load_shader(&cxg->demo, L"gears.hlsl", "ps_main_smooth",
"ps_5_0", "gears_smooth.frag.spv", &pso_desc.PS);
assert(ret);
hr = ID3D12Device_CreateGraphicsPipelineState(cxg->device, &pso_desc,
&IID_ID3D12PipelineState, (void **)&cxg->pipeline_state_smooth);
assert(SUCCEEDED(hr));
free((void *)pso_desc.PS.pShaderBytecode);
free((void *)pso_desc.VS.pShaderBytecode);
hr = ID3D12Device_CreateCommandList(cxg->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, cxg->command_allocator[0],
cxg->pipeline_state_flat, &IID_ID3D12GraphicsCommandList, (void **)&cxg->command_list[0]);
assert(SUCCEEDED(hr));
hr = ID3D12GraphicsCommandList_Close(cxg->command_list[0]);
assert(SUCCEEDED(hr));
hr = ID3D12Device_CreateCommandList(cxg->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, cxg->command_allocator[1],
cxg->pipeline_state_flat, &IID_ID3D12GraphicsCommandList, (void **)&cxg->command_list[1]);
assert(SUCCEEDED(hr));
hr = ID3D12GraphicsCommandList_Close(cxg->command_list[1]);
assert(SUCCEEDED(hr));
heap_desc.Type = D3D12_HEAP_TYPE_DEFAULT;
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_TEXTURE2D;
resource_desc.Alignment = 0;
resource_desc.Width = cxg->width;
resource_desc.Height = cxg->height;
resource_desc.DepthOrArraySize = 1;
resource_desc.MipLevels = 1;
resource_desc.Format = DXGI_FORMAT_D32_FLOAT;
resource_desc.SampleDesc.Count = 1;
resource_desc.SampleDesc.Quality = 0;
resource_desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
resource_desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
clear_value.Format = DXGI_FORMAT_D32_FLOAT;
clear_value.DepthStencil.Depth = 1.0f;
clear_value.DepthStencil.Stencil = 0;
hr = ID3D12Device_CreateCommittedResource(cxg->device, &heap_desc, D3D12_HEAP_FLAG_NONE, &resource_desc,
D3D12_RESOURCE_STATE_DEPTH_WRITE, &clear_value, &IID_ID3D12Resource, (void **)&cxg->ds);
assert(SUCCEEDED(hr));
dsv_handle = ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(cxg->dsv_heap);
ID3D12Device_CreateDepthStencilView(cxg->device, cxg->ds, NULL, dsv_handle);
heap_desc.Type = D3D12_HEAP_TYPE_UPLOAD;
resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
resource_desc.Width = sizeof(*cxg->cb_data);
resource_desc.Height = 1;
resource_desc.Format = DXGI_FORMAT_UNKNOWN;
resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
resource_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
hr = ID3D12Device_CreateCommittedResource(cxg->device, &heap_desc, D3D12_HEAP_FLAG_NONE, &resource_desc,
D3D12_RESOURCE_STATE_GENERIC_READ, NULL, &IID_ID3D12Resource, (void **)&cxg->cb);
assert(SUCCEEDED(hr));
hr = ID3D12Resource_Map(cxg->cb, 0, &read_range, (void **)&cxg->cb_data);
assert(SUCCEEDED(hr));
cxg_update_mvp(cxg);
resource_desc.Width = 3 * sizeof(*cxg->instance_data);
hr = ID3D12Device_CreateCommittedResource(cxg->device, &heap_desc, D3D12_HEAP_FLAG_NONE, &resource_desc,
D3D12_RESOURCE_STATE_GENERIC_READ, NULL, &IID_ID3D12Resource, (void **)&cxg->vb[1]);
assert(SUCCEEDED(hr));
hr = ID3D12Resource_Map(cxg->vb[1], 0, &read_range, (void **)&cxg->instance_data);
assert(SUCCEEDED(hr));
cxg->vbv[1].BufferLocation = ID3D12Resource_GetGPUVirtualAddress(cxg->vb[1]);
cxg->vbv[1].StrideInBytes = sizeof(*cxg->instance_data);
cxg->vbv[1].SizeInBytes = 3 * sizeof(*cxg->instance_data);
cxg_load_gears(cxg);
cxg_fence_create(&cxg->fence, cxg->device);
cxg_wait_for_previous_frame(cxg);
}
static void cxg_key_press(struct demo_window *window, demo_key key, void *user_data)
{
struct cx_gears *cxg = user_data;
switch (key)
{
case 'a':
case 'A':
cxg->animate = !cxg->animate;
break;
case DEMO_KEY_ESCAPE:
demo_window_destroy(window);
break;
case DEMO_KEY_LEFT:
cxg->theta += M_PI / 36.0f;
cxg_update_mvp(cxg);
break;
case DEMO_KEY_RIGHT:
cxg->theta -= M_PI / 36.0f;
cxg_update_mvp(cxg);
break;
case DEMO_KEY_UP:
cxg->phi += M_PI / 36.0f;
cxg_update_mvp(cxg);
break;
case DEMO_KEY_DOWN:
cxg->phi -= M_PI / 36.0f;
cxg_update_mvp(cxg);
break;
default:
break;
}
}
static void cxg_expose(struct demo_window *window, void *user_data)
{
cxg_render_frame(user_data);
}
static void cxg_idle(struct demo *demo, void *user_data)
{
cxg_render_frame(user_data);
}
static int cxg_main(void)
{
unsigned int width = 300, height = 300;
struct cx_gears cxg;
memset(&cxg, 0, sizeof(cxg));
if (!demo_init(&cxg.demo, &cxg))
return EXIT_FAILURE;
demo_set_idle_func(&cxg.demo, cxg_idle);
cxg.window = demo_window_create(&cxg.demo, "Vkd3d Gears", width, height, &cxg);
demo_window_set_key_press_func(cxg.window, cxg_key_press);
demo_window_set_expose_func(cxg.window, cxg_expose);
cxg.width = width;
cxg.height = height;
cxg.aspect_ratio = (float)width / (float)height;
cxg.animate = true;
cxg.theta = M_PI / 6.0f;
cxg.phi = M_PI / 9.0f;
cxg.vp.Width = width;
cxg.vp.Height = height;
cxg.vp.MaxDepth = 1.0f;
cxg.scissor_rect.right = width;
cxg.scissor_rect.bottom = height;
cxg_load_pipeline(&cxg);
cxg_load_assets(&cxg);
cxg_populate_command_list(&cxg, 0);
cxg_populate_command_list(&cxg, 1);
demo_process_events(&cxg.demo);
cxg_wait_for_previous_frame(&cxg);
cxg_destroy_assets(&cxg);
cxg_destroy_pipeline(&cxg);
demo_cleanup(&cxg.demo);
return EXIT_SUCCESS;
}
#ifdef _WIN32
int wmain(void)
#else
int main(void)
#endif
{
return cxg_main();
}

55
demos/gears.hlsl Normal file
View File

@ -0,0 +1,55 @@
cbuffer gear_block : register(b0)
{
float4x4 mvp_matrix;
float3x3 normal_matrix;
};
struct vs_in
{
float4 position : POSITION;
float3 normal : NORMAL;
float3 diffuse : DIFFUSE;
float4 transform : TRANSFORM;
};
struct vs_out
{
float4 position : SV_POSITION;
float4 colour : COLOR;
};
struct vs_out vs_main(struct vs_in i)
{
const float3 l_pos = float3(5.0, 5.0, 10.0);
float3 dir, normal;
float4 position;
struct vs_out o;
float att;
position.x = i.transform.x * i.position.x - i.transform.y * i.position.y + i.transform.z;
position.y = i.transform.x * i.position.y + i.transform.y * i.position.x + i.transform.w;
position.zw = i.position.zw;
o.position = mul(mvp_matrix, position);
dir = normalize(l_pos - o.position.xyz / o.position.w);
normal.x = i.transform.x * i.normal.x - i.transform.y * i.normal.y;
normal.y = i.transform.x * i.normal.y + i.transform.y * i.normal.x;
normal.z = i.normal.z;
att = 0.2 + dot(dir, normalize(mul(normal_matrix, normal)));
o.colour.xyz = i.diffuse.xyz * att;
o.colour.w = 1.0;
return o;
}
float4 ps_main_smooth(float4 position : SV_POSITION, float4 colour : COLOR) : SV_TARGET
{
return colour;
}
float4 ps_main_flat(float4 position : SV_POSITION, nointerpolation float4 colour : COLOR) : SV_TARGET
{
return colour;
}

40
demos/gears.vert Normal file
View File

@ -0,0 +1,40 @@
#version 150
#extension GL_ARB_separate_shader_objects : enable
layout(location = 0) in vec4 position_in;
layout(location = 1) in vec3 normal_in;
layout(location = 2) in vec3 diffuse_in;
layout(location = 3) in vec4 transform_in;
layout(location = 0) out vec4 colour_out;
uniform gear_block
{
uniform mat4 mvp_matrix;
uniform mat3 normal_matrix;
} gear;
void main()
{
const vec3 l_pos = vec3(5.0, 5.0, 10.0);
vec3 dir, normal;
vec4 position;
float att;
position.x = transform_in.x * position_in.x - transform_in.y * position_in.y + transform_in.z;
position.y = transform_in.x * position_in.y + transform_in.y * position_in.x + transform_in.w;
position.zw = position_in.zw;
gl_Position = gear.mvp_matrix * position;
dir = normalize(l_pos - gl_Position.xyz / gl_Position.w);
normal.x = transform_in.x * normal_in.x - transform_in.y * normal_in.y;
normal.y = transform_in.x * normal_in.y + transform_in.y * normal_in.x;
normal.z = normal_in.z;
att = 0.2 + dot(dir, normalize(gear.normal_matrix * normal));
colour_out.xyz = diffuse_in.xyz * att;
colour_out.w = 1.0;
gl_Position.y = -gl_Position.y;
}

10
demos/gears_flat.frag Normal file
View File

@ -0,0 +1,10 @@
#version 150
#extension GL_ARB_separate_shader_objects : enable
layout(location = 0) flat in vec4 colour_in;
layout(location = 0) out vec4 colour_out;
void main(void)
{
colour_out = colour_in;
}

10
demos/gears_smooth.frag Normal file
View File

@ -0,0 +1,10 @@
#version 150
#extension GL_ARB_separate_shader_objects : enable
layout(location = 0) in vec4 colour_in;
layout(location = 0) out vec4 colour_out;
void main(void)
{
colour_out = colour_in;
}

2
demos/triangle.c
View File

@ -371,7 +371,7 @@ static int cxt_main(void)
memset(&cxt, 0, sizeof(cxt));
if (!demo_init(&cxt.demo))
if (!demo_init(&cxt.demo, NULL))
return EXIT_FAILURE;
cxt.window = demo_window_create(&cxt.demo, "Vkd3d Triangle", width, height, &cxt);