jacob/power_play
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
d4327eb7bb
power_play/src/renderer_d3d11.c

1155 lines
39 KiB
C
Raw Blame History

#include "renderer.h"
#include "sys.h"
#include "memory.h"
#include "arena.h"
#include "scratch.h"
#include "string.h"
#include "math.h"
#include "inc.h"
#include "tar.h"
#include "sprite.h"
#pragma warning(push, 0)
# define UNICODE
# define COBJMACROS
# include <Windows.h>
# include <d3d11.h>
# include <d3dcompiler.h>
# include <dxgidebug.h>
# include <dxgi1_3.h>
#pragma warning(pop)
#pragma comment(lib, "d3d11")
#pragma comment(lib, "dxgi")
#pragma comment(lib, "dxguid")
#pragma comment(lib, "d3dcompiler")
#define MAX_CMD_BUFFERS 1024
/* FIXME: Enable this and resolve unreleased references */
//#define D3D11_DEBUG RTC
#define D3D11_DEBUG 0
#define D3D11_SHADER_DEBUG RTC
struct dx11_shader {
enum shader_kind kind;
u32 vertex_size;
ID3D11InputLayout *input_layout;
ID3D11VertexShader *vs;
ID3D11PixelShader *ps;
};
struct dx11_constant_buffer_data {
struct mat4x4 vp;
};
struct dx11_buffer {
u32 vertex_count;
u32 index_count;
u8 *cpu_vertex_buffer; /* Array of homogeneous vertices (size depends on shader) */
vidx *cpu_index_buffer; /* Array of vertex indices into cpu_vertex_buffer */
struct arena vertex_arena;
struct arena index_arena;
u32 gpu_vertex_buffer_capacity;
u32 gpu_index_buffer_capacity;
ID3D11Buffer *gpu_vertex_buffer;
ID3D11Buffer *gpu_index_buffer;
};
struct renderer_cmd {
struct dx11_shader *shader;
struct renderer_texture texture; /* Overrides sprite if set */
struct sprite_tag sprite;
/* Associated buffer data */
u32 vertex_count;
u32 index_count;
u32 vertex_offset;
u32 index_offset;
b32 offsets_set;
struct renderer_cmd *next;
};
struct cmd_store {
struct renderer_cmd *cmd_first;
struct renderer_cmd *cmd_last;
struct arena arena;
};
struct renderer_cmd_buffer {
struct dx11_buffer buffers[NUM_SHADERS];
struct cmd_store cpu_cmd_store;
struct cmd_store gpu_cmd_store;
b32 valid; /* False if uninitialized (in sparse array) */
};
struct dx11_format {
DXGI_FORMAT format;
u32 pixel_size;
};
struct dx11_texture {
ID3D11Texture2D *texture;
b32 is_backbuffer;
struct dx11_texture *prev;
struct dx11_texture *next;
struct dx11_texture *next_free;
};
INTERNAL void renderer_capture_image_for_profiler(void);
/* ========================== *
* Global state
* ========================== */
struct handle_slot {
u64 idx;
u64 gen;
void *data;
struct handle_slot *next_free;
};
struct handle_store {
struct sys_mutex mutex;
struct arena arena;
struct handle_slot *head_free;
struct handle_slot *array;
u64 count;
};
struct dx11_shader_desc {
char *name_cstr;
u32 vertex_size;
D3D11_INPUT_ELEMENT_DESC input_layout_desc[64]; /* NULL terminated array */
};
GLOBAL struct {
struct arena arena;
struct tar_archive shaders_archive; /* Tar archive including shader sources */
ID3D11Device *dev;
ID3D11DeviceContext *devcon;
IDXGISwapChain1 *swapchain;
struct dx11_texture backbuffer_texture;
ID3D11BlendState *blend_state;
ID3D11RasterizerState *rasterizer_state;
ID3D11DepthStencilState *depth_stencil_state;
ID3D11SamplerState *sampler_state;
ID3D11Buffer *vs_constant_buffer;
/* Texture store */
struct sys_mutex textures_mutex;
struct arena textures_arena;
struct dx11_texture *textures_first;
struct dx11_texture *textures_last;
struct dx11_texture *textures_first_free;
/* Sparse array (cmdbuff.valid) */
struct renderer_cmd_buffer cmdbuffs[MAX_CMD_BUFFERS];
struct dx11_shader shaders[NUM_SHADERS];
struct dx11_shader_desc shader_info[NUM_SHADERS];
} G = ZI, DEBUG_ALIAS(G, G_renderer_d3d11);
/* ========================== *
* Util
* ========================== */
/* Calculate the view projection matrix */
INLINE struct mat4x4 calculate_vp(struct xform view, f32 viewport_width, f32 viewport_height)
{
struct mat4x4 projection = mat4x4_from_ortho(0.0, viewport_width, viewport_height, 0.0, -1.0, 1.0);
struct mat4x4 view4x4 = mat4x4_from_xform(view);
return mat4x4_mul(projection, view4x4);
}
INTERNAL void send_constant_buffer_data(ID3D11Buffer *buffer, struct mat4x4 vp)
{
D3D11_MAPPED_SUBRESOURCE ms;
if (ID3D11DeviceContext_Map(G.devcon, (ID3D11Resource *)buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &ms) != S_OK) {
ASSERT(false);
return;
}
struct dx11_constant_buffer_data *data = (struct dx11_constant_buffer_data *)ms.pData;
MEMCPY(&data->vp, &vp, sizeof(vp));
ID3D11DeviceContext_Unmap(G.devcon, (ID3D11Resource *)buffer, 0);
}
/* ========================== *
* Shader
* ========================== */
/* TODO: don't do fatal error, just don't use shader */
INTERNAL void process_shader_compilation_error(ID3DBlob *error_blob)
{
struct temp_arena scratch = scratch_begin_no_conflict();
struct string error_prefix = string_copy(scratch.arena, STR("Failed to compile shader:\n"));
if (error_blob) {
char *compile_error_cstr = (char *)ID3D10Blob_GetBufferPointer(error_blob);
struct string error_msg = string_cat(scratch.arena, error_prefix, string_from_cstr(compile_error_cstr));
sys_panic(error_msg);
}
scratch_end(scratch);
}
INTERNAL void init_shader_table(void)
{
MEMZERO_ARRAY(G.shader_info);
/* Triangle shader layout */
G.shader_info[SHADER_TRIANGLE] = (struct dx11_shader_desc) {
"shaders/triangle.hlsl",
sizeof(struct triangle_shader_vertex),
{
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
}
};
/* Grid shader layout */
G.shader_info[SHADER_GRID] = (struct dx11_shader_desc) {
"shaders/grid.hlsl",
sizeof(struct grid_shader_vertex),
{
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "THICKNESS", 0, DXGI_FORMAT_R32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "SPACING", 0, DXGI_FORMAT_R32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "OFFSET", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
}
};
}
INTERNAL void shader_init(struct dx11_shader *shader, enum shader_kind kind)
{
__prof;
MEMZERO_STRUCT(shader);
struct temp_arena scratch = scratch_begin_no_conflict();
const struct dx11_shader_desc *shader_desc = &G.shader_info[kind];
shader->kind = kind;
shader->vertex_size = shader_desc->vertex_size;
u32 flags = D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR;
#if D3D11_SHADER_DEBUG
flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS;
#else
flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3;
#endif
/* Compile shader */
ID3DBlob *vs_blob, *ps_blob;
{
struct string name = string_from_cstr(shader_desc->name_cstr);
struct tar_entry *tar_entry = tar_get(&G.shaders_archive, name);
if (!tar_entry) {
sys_panic(string_format(scratch.arena,
STR("Could not find shader \"%F\""),
FMT_STR(name)));
}
struct buffer shader_src = tar_entry->buff;
/* Compile shader */
/* TODO: pre-compile shaders w/ FXC? */
ID3DBlob *error_blob;
HRESULT v_res = D3DCompile(shader_src.data, shader_src.size, NULL, NULL, NULL, "vs_main", "vs_5_0", flags, 0, &vs_blob, &error_blob);
if (FAILED(v_res)) {
process_shader_compilation_error(error_blob);
}
HRESULT p_res = D3DCompile(shader_src.data, shader_src.size, NULL, NULL, NULL, "ps_main", "ps_5_0", flags, 0, &ps_blob, &error_blob);
if (FAILED(p_res)) {
process_shader_compilation_error(error_blob);
}
}
/* Get number of device layout elements from NULL terminated array */
u32 elem_count = 0;
for (; elem_count < ARRAY_COUNT(shader_desc->input_layout_desc); ++elem_count) {
const D3D11_INPUT_ELEMENT_DESC *d = &shader_desc->input_layout_desc[elem_count];
if (d->SemanticName == NULL) {
break;
}
}
/* Create device layout */
ID3D11Device_CreateInputLayout(G.dev, shader_desc->input_layout_desc, elem_count, ID3D10Blob_GetBufferPointer(vs_blob), ID3D10Blob_GetBufferSize(vs_blob), &shader->input_layout);
/* Create shader */
ID3D11Device_CreateVertexShader(G.dev, ID3D10Blob_GetBufferPointer(vs_blob), ID3D10Blob_GetBufferSize(vs_blob), NULL, &shader->vs);
ID3D11Device_CreatePixelShader(G.dev, ID3D10Blob_GetBufferPointer(ps_blob), ID3D10Blob_GetBufferSize(ps_blob), NULL, &shader->ps);
ID3D10Blob_Release(vs_blob);
ID3D10Blob_Release(ps_blob);
scratch_end(scratch);
}
/* ========================== *
* Startup
* ========================== */
struct renderer_startup_receipt renderer_startup(struct sys_window *window)
{
__profscope(initializing_d3d11);
G.arena = arena_alloc(GIGABYTE(64));
/* Initialize texture store */
G.textures_mutex = sys_mutex_alloc();
G.textures_arena = arena_alloc(GIGABYTE(64));
/* Load shader archive */
struct buffer embedded_data = inc_shaders_tar();
if (embedded_data.size > 0) {
G.shaders_archive = tar_parse(&G.arena, embedded_data, STR("shaders/"));
}
/* Initialize shader table */
init_shader_table();
HRESULT hr;
ID3D11Device *device;
ID3D11DeviceContext *context;
IDXGISwapChain1 *swapchain;
/* Create D3D11 device & context */
{
#if D3D11_DEBUG
u32 flags = D3D11_CREATE_DEVICE_DEBUG;
#else
u32 flags = 0;
#endif
D3D_FEATURE_LEVEL levels[] = { D3D_FEATURE_LEVEL_11_0 };
hr = D3D11CreateDevice(
NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
flags,
levels,
ARRAY_COUNT(levels),
D3D11_SDK_VERSION,
&device,
NULL,
&context
);
ASSERT(SUCCEEDED(hr));
}
#if D3D11_DEBUG
/* Enable debug break on API errors */
{
ID3D11InfoQueue *info;
ID3D11Device_QueryInterface(device, &IID_ID3D11InfoQueue, (void **)&info);
ID3D11InfoQueue_SetBreakOnSeverity(info, D3D11_MESSAGE_SEVERITY_CORRUPTION, TRUE);
ID3D11InfoQueue_SetBreakOnSeverity(info, D3D11_MESSAGE_SEVERITY_ERROR, TRUE);
ID3D11InfoQueue_Release(info);
}
/* Enable debug break for DXGI too */
{
IDXGIInfoQueue *dxgiInfo;
hr = DXGIGetDebugInterface1(0, &IID_IDXGIInfoQueue, (void **)&dxgiInfo);
ASSERT(SUCCEEDED(hr));
IDXGIInfoQueue_SetBreakOnSeverity(dxgiInfo, DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION, TRUE);
IDXGIInfoQueue_SetBreakOnSeverity(dxgiInfo, DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR, TRUE);
IDXGIInfoQueue_Release(dxgiInfo);
}
#endif
/* Create swap chain */
{
HWND hwnd = (HWND)sys_window_get_internal_handle(window);
/* Get DXGI device from D3D11 device */
IDXGIDevice *dxgiDevice;
hr = ID3D11Device_QueryInterface(device, &IID_IDXGIDevice, (void **)&dxgiDevice);
ASSERT(SUCCEEDED(hr));
/* Get DXGI adapter from DXGI device */
IDXGIAdapter *dxgiAdapter;
hr = IDXGIDevice_GetAdapter(dxgiDevice, &dxgiAdapter);
ASSERT(SUCCEEDED(hr));
/* Get DXGI factory from DXGI adapter */
IDXGIFactory2 *factory;
hr = IDXGIAdapter_GetParent(dxgiAdapter, &IID_IDXGIFactory2, (void **)&factory);
ASSERT(SUCCEEDED(hr));
DXGI_SWAP_CHAIN_DESC1 desc = {
.Format = DXGI_FORMAT_R8G8B8A8_UNORM,
.SampleDesc = { 1, 0 },
.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT,
.BufferCount = 2,
.Scaling = DXGI_SCALING_NONE,
/* More efficient FLIP presentation model.
* Windows 10 allows to use DXGI_SWAP_EFFECT_FLIP_DISCARD
* For Windows 8 compatibility use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL
* For Windows 7 compatibility use DXGI_SWAP_EFFECT_DISCARD
*/
.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD,
};
hr = IDXGIFactory2_CreateSwapChainForHwnd(factory, (IUnknown *)device, hwnd, &desc, NULL, NULL, &swapchain);
ASSERT(SUCCEEDED(hr));
/* Disable Alt+Enter changing monitor resolution to match window size */
IDXGIFactory_MakeWindowAssociation(factory, hwnd, DXGI_MWA_NO_ALT_ENTER);
IDXGIFactory2_Release(factory);
IDXGIAdapter_Release(dxgiAdapter);
IDXGIDevice_Release(dxgiDevice);
}
if (!SUCCEEDED(hr) || !device || !context || !swapchain) {
/* Renderer initialization failure */
/* TODO: Better message */
sys_panic(STR("Failed to initialize renderer"));
}
G.dev = device;
G.devcon = context;
G.swapchain = swapchain;
/* Create the blending setup */
{
__profscope(create_blend_state);
const f32 blend_factor[4] = { 0.f, 0.f, 0.f, 0.f };
/* TODO: Actually go over these (just want alpha blending/transparency) */
D3D11_BLEND_DESC desc = {
.AlphaToCoverageEnable = false,
.RenderTarget[0].BlendEnable = true,
.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA,
.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA,
.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD,
.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE,
.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA,
.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD,
.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL
};
/* FIXME: Free this? */
ID3D11Device_CreateBlendState(G.dev, &desc, &G.blend_state);
ID3D11DeviceContext_OMSetBlendState(G.devcon, G.blend_state, blend_factor, 0xffffffff);
}
/* Create depth-stencil State */
{
__profscope(create_depth_stencil_state);
/* TODO: Actually go over these (copied from elsewhere) */
D3D11_DEPTH_STENCIL_DESC desc = ZI;
desc.DepthEnable = false;
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
desc.DepthFunc = D3D11_COMPARISON_ALWAYS;
desc.StencilEnable = false;
desc.FrontFace.StencilFailOp = desc.FrontFace.StencilDepthFailOp = desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
desc.BackFace = desc.FrontFace;
/* FIXME: Free this? */
ID3D11Device_CreateDepthStencilState(G.dev, &desc, &G.depth_stencil_state);
ID3D11DeviceContext_OMSetDepthStencilState(G.devcon, G.depth_stencil_state, 0);
}
/* Create the rasterizer state */
{
__profscope(create_rasterizer_state);
D3D11_RASTERIZER_DESC desc = {
.FillMode = D3D11_FILL_SOLID,
.CullMode = D3D11_CULL_NONE,
//.ScissorEnable = true,
.DepthClipEnable = true
};
/* FIXME: Free this? */
ID3D11Device_CreateRasterizerState(G.dev, &desc, &G.rasterizer_state);
ID3D11DeviceContext_RSSetState(G.devcon, G.rasterizer_state);
}
/* Create the sampler state */
{
__profscope(create_sampler_state);
D3D11_SAMPLER_DESC desc = {
//.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR,
.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT,
.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP,
.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP,
.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP,
.MaxAnisotropy = 1,
//.ComparisonFunc = D3D11_COMPARISON_ALWAYS,
.MaxLOD = D3D11_FLOAT32_MAX
};
/* FIXME: Free this? */
ID3D11Device_CreateSamplerState(G.dev, &desc, &G.sampler_state);
ID3D11DeviceContext_PSSetSamplers(G.devcon, 0, 1, &G.sampler_state);
}
/* Create the constant buffer */
{
__profscope(create_const_buffer);
D3D11_BUFFER_DESC desc = {
.ByteWidth = sizeof(struct dx11_constant_buffer_data),
.Usage = D3D11_USAGE_DYNAMIC,
.BindFlags = D3D11_BIND_CONSTANT_BUFFER,
.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE,
.MiscFlags = 0
};
ID3D11Device_CreateBuffer(G.dev, &desc, NULL, &G.vs_constant_buffer);
/* Apparently ByteWidth needs to be in multiples of 16? */
ASSERT(desc.ByteWidth % 16 == 0);
}
/* Init shaders */
for (u32 i = SHADER_NONE + 1; i < NUM_SHADERS; ++i) {
/* Create shader */
shader_init(&G.shaders[i], i);
}
return (struct renderer_startup_receipt) { 0 };
}
/* ========================== *
* Render
* ========================== */
/* TODO: Lock cmdbuff or at least global state? (in-case multi-threaded present).
* Another option is to store a separate device on each cmdbuff?
*
* I'm thinking we may also just need to lock texture modification access while presenting */
INTERNAL void dx11_render(ID3D11RenderTargetView *target, struct renderer_cmd_buffer *cmdbuff, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope)
{
__prof;
ID3D11DeviceContext_OMSetRenderTargets(G.devcon, 1, &target, NULL);
D3D11_VIEWPORT d3d11_viewport = ZI;
d3d11_viewport.Width = viewport.width;
d3d11_viewport.Height = viewport.height;
d3d11_viewport.MinDepth = 0.0f;
d3d11_viewport.MaxDepth = 1.0f;
d3d11_viewport.TopLeftX = viewport.x;
d3d11_viewport.TopLeftY = viewport.y;
ID3D11DeviceContext_RSSetViewports(G.devcon, 1, &d3d11_viewport);
/* Fill and set constant buffer
* NOTE: We're only doing this once per render, rather than once per
* draw call since the only constant right now is VP. */
struct mat4x4 vp_matrix = calculate_vp(view, viewport.width, viewport.height);
send_constant_buffer_data(G.vs_constant_buffer, vp_matrix);
ID3D11DeviceContext_VSSetConstantBuffers(G.devcon, 0, 1, &G.vs_constant_buffer);
ID3D11DeviceContext_PSSetConstantBuffers(G.devcon, 0, 1, &G.vs_constant_buffer);
struct dx11_shader *last_shader = NULL;
struct renderer_cmd *cmd = cmdbuff ? cmdbuff->gpu_cmd_store.cmd_first : NULL;
for (; cmd; cmd = cmd->next) {
struct dx11_shader *shader = cmd->shader;
struct dx11_buffer *buffer = &cmdbuff->buffers[shader->kind];
/* Activate shader */
if (shader != last_shader) {
ID3D11DeviceContext_VSSetShader(G.devcon, shader->vs, 0, 0);
ID3D11DeviceContext_PSSetShader(G.devcon, shader->ps, 0, 0);
ID3D11DeviceContext_IASetInputLayout(G.devcon, shader->input_layout);
last_shader = shader;
}
ID3D11ShaderResourceView *null_srv[1] = { NULL };
switch (shader->kind) {
default:
{
/* Unknown shader */
ASSERT(false);
} break;
case SHADER_TRIANGLE:
{
/* FIXME: Texture refcount needs to be increased here to prevent release mid-render */
ID3D11Texture2D *texture = NULL;
if (cmd->texture.handle) {
/* Load texture if handle is set */
texture = ((struct dx11_texture *)cmd->texture.handle)->texture;
} else {
/* Otherwise load sprite */
struct sprite_texture *sprite_texture = sprite_texture_from_tag_async(sprite_scope, cmd->sprite);
if (sprite_texture->loaded) {
texture = ((struct dx11_texture *)sprite_texture->texture.handle)->texture;
}
}
if (texture) {
/* Bind texture */
D3D11_TEXTURE2D_DESC texture_desc = ZI;
ID3D11Texture2D_GetDesc(texture, &texture_desc);
/* Create SRV */
D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc = { .Format = texture_desc.Format, .ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D, .Texture2D.MipLevels = texture_desc.MipLevels, .Texture2D.MostDetailedMip = 0 };
ID3D11ShaderResourceView *texture_srv = NULL;
ID3D11Device_CreateShaderResourceView(G.dev, (ID3D11Resource *)texture, &srv_desc, &texture_srv);
ID3D11DeviceContext_PSSetShaderResources(G.devcon, 0, 1, &texture_srv);
ID3D11DeviceContext_IASetPrimitiveTopology(G.devcon, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
/* Activate buffer */
u32 zero = 0;
UINT vertex_stride = shader->vertex_size;
ID3D11DeviceContext_IASetVertexBuffers(G.devcon, 0, 1, &buffer->gpu_vertex_buffer, &vertex_stride, &zero);
ID3D11DeviceContext_IASetIndexBuffer(G.devcon, buffer->gpu_index_buffer, DXGI_FORMAT_R32_UINT, zero);
/* Draw */
u32 vertex_offset = cmd->vertex_offset;
u32 index_offset = cmd->index_offset;
u32 index_count = cmd->index_count;
ID3D11DeviceContext_DrawIndexed(G.devcon, index_count, index_offset, vertex_offset);
/* Release SRV */
ID3D11ShaderResourceView_Release(texture_srv);
/* Unbind */
ID3D11DeviceContext_PSSetShaderResources(G.devcon, 0, 1, null_srv);
}
} break;
case SHADER_GRID:
{
ID3D11DeviceContext_IASetPrimitiveTopology(G.devcon, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
/* Activate buffer */
u32 zero = 0;
UINT vertex_stride = shader->vertex_size;
ID3D11DeviceContext_IASetVertexBuffers(G.devcon, 0, 1, &buffer->gpu_vertex_buffer, &vertex_stride, &zero);
ID3D11DeviceContext_IASetIndexBuffer(G.devcon, buffer->gpu_index_buffer, DXGI_FORMAT_R32_UINT, zero);
/* Draw */
u32 vertex_offset = cmd->vertex_offset;
u32 index_offset = cmd->index_offset;
u32 index_count = cmd->index_count;
ID3D11DeviceContext_DrawIndexed(G.devcon, index_count, index_offset, vertex_offset);
} break;
}
}
}
/* ========================== *
* Texture
* ========================== */
INTERNAL struct dx11_format dx11_format_from_renderer_format(enum renderer_texture_format format)
{
LOCAL_PERSIST const struct dx11_format sizes[NUM_RENDERER_TEXTURE_FORMATS] = {
[RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM] = {
.format = DXGI_FORMAT_R8G8B8A8_UNORM,
.pixel_size = 4
}
};
struct dx11_format res = ZI;
if ((u32)format < ARRAY_COUNT(sizes)) {
res = sizes[format];
}
return res;
}
INTERNAL struct dx11_texture *dx11_texture_alloc(enum renderer_texture_format format, u32 flags, struct v2i32 size, void *initial_data)
{
struct dx11_texture *t = NULL;
{
/* Allocate to list */
struct sys_lock lock = sys_mutex_lock_e(&G.textures_mutex);
if (G.textures_first_free) {
t = G.textures_first_free;
G.textures_first_free = t->next_free;
} else {
t = arena_push(&G.textures_arena, struct dx11_texture);
}
MEMZERO_STRUCT(t);
if (!G.textures_first) {
G.textures_first = t;
} else {
G.textures_last->next = t;
}
t->prev = G.textures_last;
G.textures_last = t;
sys_mutex_unlock(&lock);
}
struct dx11_format dx11_format = dx11_format_from_renderer_format(format);
if (dx11_format.format == DXGI_FORMAT_UNKNOWN) {
/* Unknown format */
ASSERT(false);
dx11_format = (struct dx11_format) { .format = DXGI_FORMAT_R8G8B8A8_UNORM, .pixel_size = 4 };
}
u32 bind_flags = D3D11_BIND_SHADER_RESOURCE;
if (flags & RENDERER_TEXTURE_FLAG_TARGET) {
bind_flags |= D3D11_BIND_RENDER_TARGET;
}
D3D11_TEXTURE2D_DESC desc = ZI;
desc.Width = max_i32(size.x, 1);
desc.Height = max_i32(size.y, 1);
desc.MipLevels = 1;
desc.ArraySize = 1;
desc.SampleDesc.Count = 1;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.CPUAccessFlags = 0;
desc.BindFlags = bind_flags;
desc.Format = dx11_format.format;
ID3D11Texture2D *texture = NULL;
if (initial_data) {
D3D11_SUBRESOURCE_DATA subresource_data = { .pSysMem = initial_data, .SysMemPitch = size.x * dx11_format.pixel_size, .SysMemSlicePitch = 0 };
ID3D11Device_CreateTexture2D(G.dev, &desc, &subresource_data, &texture);
} else {
ID3D11Device_CreateTexture2D(G.dev, &desc, NULL, &texture);
}
ASSERT(texture != NULL);
t->texture = texture;
return t;
}
INTERNAL void dx11_texture_release(struct dx11_texture *t)
{
if (!t->is_backbuffer) {
{
/* Free from list */
struct sys_lock lock = sys_mutex_lock_e(&G.textures_mutex);
struct dx11_texture *prev = t->prev;
struct dx11_texture *next = t->next;
if (prev) {
prev->next = next;
}
if (next) {
next->prev = prev;
}
if (G.textures_first == t) {
G.textures_first = next;
}
if (G.textures_last == t) {
G.textures_last = prev;
}
t->next_free = G.textures_first_free;
G.textures_first_free = t;
sys_mutex_unlock(&lock);
}
if (t->texture) {
ID3D11Texture2D_Release(t->texture);
}
}
}
struct renderer_texture renderer_texture_alloc(enum renderer_texture_format format, u32 flags, struct v2i32 size, void *initial_data)
{
__prof;
struct renderer_texture res = ZI;
struct dx11_texture *t = dx11_texture_alloc(format, flags, size, initial_data);
res.handle = (u64)t;
return res;
}
void renderer_texture_release(struct renderer_texture t)
{
__prof;
dx11_texture_release((struct dx11_texture *)t.handle);
}
void renderer_texture_clear(struct renderer_texture target_texture, u32 clear_color)
{
__prof;
ID3D11Texture2D *texture = ((struct dx11_texture *)target_texture.handle)->texture;
ID3D11RenderTargetView *target_view = NULL;
ID3D11Device_CreateRenderTargetView(G.dev, (ID3D11Resource *)texture, NULL, &target_view);
if (target_view) {
f32 r = (f32)((clear_color >> 0) & 0xFF) / 255.0f;
f32 g = (f32)((clear_color >> 8) & 0xFF) / 255.0f;
f32 b = (f32)((clear_color >> 16) & 0xFF) / 255.0f;
f32 a = (f32)((clear_color >> 24) & 0xFF) / 255.0f;
f32 fill[4] = { r, g, b, a };
ID3D11DeviceContext_ClearRenderTargetView(G.devcon, target_view, fill);
}
if (target_view) {
ID3D11RenderTargetView_Release(target_view);
}
}
void renderer_texture_render(struct renderer_texture texture, struct renderer_cmd_buffer *cmdbuff, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope)
{
__prof;
struct dx11_texture *t = (struct dx11_texture *)texture.handle;
ID3D11RenderTargetView *target_view = NULL;
ID3D11Device_CreateRenderTargetView(G.dev, (ID3D11Resource *)t->texture, NULL, &target_view);
if (target_view) {
dx11_render(target_view, cmdbuff, view, viewport, sprite_scope);
}
if (target_view) {
ID3D11RenderTargetView_Release(target_view);
}
}
struct v2i32 renderer_texture_get_size(struct renderer_texture texture)
{
struct v2i32 res = ZI;
D3D11_TEXTURE2D_DESC desc;
ID3D11Texture2D_GetDesc(((struct dx11_texture *)texture.handle)->texture, &desc);
res.x = desc.Width;
res.y = desc.Height;
return res;
}
/* ========================== *
* Backbuffer
* ========================== */
struct renderer_texture renderer_backbuffer_recreate(struct v2i32 size)
{
struct renderer_texture res = ZI;
/* Resize */
if (G.backbuffer_texture.texture != 0) {
ID3D11Texture2D_Release(G.backbuffer_texture.texture);
}
IDXGISwapChain_ResizeBuffers(G.swapchain, 0, size.x, size.y, DXGI_FORMAT_UNKNOWN, 0);
IDXGISwapChain_GetBuffer(G.swapchain, 0, &IID_ID3D11Texture2D, (LPVOID *)&G.backbuffer_texture.texture);
res.handle = (u64)&G.backbuffer_texture;
return res;
}
void renderer_backbuffer_present(i32 vsync)
{
__prof;
{
__profscope(IDXGISwapchain_Present);
IDXGISwapChain1_Present(G.swapchain, vsync, 0);
__profframe(0);
}
renderer_capture_image_for_profiler();
}
/* ========================== *
* Cmd buffer
* ========================== */
struct renderer_cmd_buffer *renderer_cmd_buffer_alloc(void)
{
struct renderer_cmd_buffer *cmdbuff = NULL;
for (u32 i = 0; i < MAX_CMD_BUFFERS; ++i) {
if (!G.cmdbuffs[i].valid) {
cmdbuff = &G.cmdbuffs[i];
break;
}
}
if (!cmdbuff) {
sys_panic(STR("Max renderer cmdbuffs reached"));
return NULL;
}
MEMZERO_STRUCT(cmdbuff);
cmdbuff->cpu_cmd_store.arena = arena_alloc(GIGABYTE(8));
cmdbuff->gpu_cmd_store.arena = arena_alloc(GIGABYTE(8));
cmdbuff->valid = true;
/* Initialize buffers */
for (u32 i = SHADER_NONE + 1; i < ARRAY_COUNT(cmdbuff->buffers); ++i) {
struct dx11_buffer *buffer = &cmdbuff->buffers[i];
buffer->vertex_arena = arena_alloc(GIGABYTE(8));
buffer->index_arena = arena_alloc(GIGABYTE(8));
buffer->cpu_vertex_buffer = arena_dry_push(&buffer->vertex_arena, u8);
buffer->cpu_index_buffer = arena_dry_push(&buffer->index_arena, vidx);
}
return cmdbuff;
}
void renderer_cmd_buffer_release(struct renderer_cmd_buffer *cmdbuff)
{
cmdbuff->valid = false;
arena_release(&cmdbuff->cpu_cmd_store.arena);
arena_release(&cmdbuff->gpu_cmd_store.arena);
/* Destroy buffers */
for (u32 i = SHADER_NONE + 1; i < ARRAY_COUNT(cmdbuff->buffers); ++i) {
struct dx11_buffer *buffer = &cmdbuff->buffers[i];
arena_release(&buffer->vertex_arena);
arena_release(&buffer->index_arena);
/* FIXME: Clear GPU buffers */
}
}
u32 renderer_cmd_buffer_push_vertices(struct renderer_cmd_buffer *cmdbuff, u8 **vertices_out, vidx **indices_out, u32 vertices_count, u32 indices_count)
{
struct renderer_cmd *cmd = cmdbuff->cpu_cmd_store.cmd_last;
if (!cmd) {
/* Tried to draw to cmdbuff with no active draw cmd */
ASSERT(false);
return 0;
}
struct dx11_shader *shader = cmd->shader;
struct dx11_buffer *buffer = &cmdbuff->buffers[shader->kind];
if (!cmd->offsets_set) {
cmd->vertex_offset = buffer->vertex_count;
cmd->index_offset = buffer->index_count;
cmd->offsets_set = true;
}
u32 first_vertex_index = cmd->vertex_count;
cmd->vertex_count += vertices_count;
cmd->index_count += indices_count;
buffer->vertex_count += vertices_count;
buffer->index_count += indices_count;
*vertices_out = arena_push_array(&buffer->vertex_arena, u8, shader->vertex_size * vertices_count);
*indices_out = arena_push_array(&buffer->index_arena, vidx, indices_count);
return first_vertex_index;
}
void renderer_cmd_buffer_ensure_cmd(struct renderer_cmd_buffer *cmdbuff, struct renderer_cmd_parameters *params)
{
struct renderer_cmd *last_cmd = cmdbuff->cpu_cmd_store.cmd_last;
struct renderer_cmd *new_cmd = NULL;
switch (params->kind) {
default:
{
/* Unknown shader kind */
ASSERT(false);
} break;
case SHADER_TRIANGLE:
{
if (!last_cmd
|| last_cmd->shader->kind != SHADER_TRIANGLE
|| (last_cmd->texture.handle != params->texture_params.texture.handle)
|| !sprite_tag_eq(last_cmd->sprite, params->texture_params.sprite)) {
new_cmd = arena_push(&cmdbuff->cpu_cmd_store.arena, struct renderer_cmd);
*new_cmd = (struct renderer_cmd) {
.shader = &G.shaders[SHADER_TRIANGLE],
.texture = params->texture_params.texture,
.sprite = params->texture_params.sprite
};
}
} break;
case SHADER_GRID:
{
if (!last_cmd || last_cmd->shader->kind != SHADER_GRID) {
new_cmd = arena_push(&cmdbuff->cpu_cmd_store.arena, struct renderer_cmd);
*new_cmd = (struct renderer_cmd) {
.shader = &G.shaders[SHADER_GRID],
};
}
} break;
}
if (new_cmd) {
if (!cmdbuff->cpu_cmd_store.cmd_first) {
cmdbuff->cpu_cmd_store.cmd_first = new_cmd;
} else {
last_cmd->next = new_cmd;
}
cmdbuff->cpu_cmd_store.cmd_last = new_cmd;
}
}
void renderer_cmd_buffer_send_to_gpu(struct renderer_cmd_buffer *cmdbuff)
{
__prof;
/* Create / grow vertex buffers */
for (u32 i = 1; i < ARRAY_COUNT(cmdbuff->buffers); ++i) {
struct dx11_buffer *buffer = &cmdbuff->buffers[i];
struct dx11_shader *shader = &G.shaders[i];
u32 vertex_size = shader->vertex_size;
u32 index_size = sizeof(vidx);
if (buffer->vertex_count == 0 || buffer->index_count == 0) {
continue;
}
/* Grow vertex buffer */
if (buffer->gpu_vertex_buffer_capacity < buffer->vertex_count) {
buffer->gpu_vertex_buffer_capacity = buffer->vertex_count + 5000;
D3D11_BUFFER_DESC desc = {
.Usage = D3D11_USAGE_DYNAMIC,
.ByteWidth = buffer->gpu_vertex_buffer_capacity * vertex_size,
.BindFlags = D3D11_BIND_VERTEX_BUFFER,
.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE
};
/* TODO: Assert res >= 0 (success) */
ID3D11Device_CreateBuffer(G.dev, &desc, NULL, &buffer->gpu_vertex_buffer);
}
/* Grow index buffer */
if (buffer->gpu_index_buffer_capacity < buffer->index_count) {
buffer->gpu_index_buffer_capacity = buffer->index_count + 5000;
D3D11_BUFFER_DESC desc = {
.Usage = D3D11_USAGE_DYNAMIC,
.ByteWidth = buffer->gpu_index_buffer_capacity * index_size,
.BindFlags = D3D11_BIND_INDEX_BUFFER,
.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE
};
/* TODO: Assert res >= 0 (success) */
ID3D11Device_CreateBuffer(G.dev, &desc, NULL, &buffer->gpu_index_buffer);
}
/* Fill GPU vertex buffer */
if (buffer->gpu_vertex_buffer) {
D3D11_MAPPED_SUBRESOURCE res;
ID3D11DeviceContext_Map(G.devcon, (ID3D11Resource *)buffer->gpu_vertex_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &res);
MEMCPY(res.pData, buffer->cpu_vertex_buffer, buffer->vertex_count * vertex_size);
ID3D11DeviceContext_Unmap(G.devcon, (ID3D11Resource *)buffer->gpu_vertex_buffer, 0);
}
/* Fill GPU index buffer */
if (buffer->gpu_index_buffer) {
D3D11_MAPPED_SUBRESOURCE res;
ID3D11DeviceContext_Map(G.devcon, (ID3D11Resource *)buffer->gpu_index_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &res);
MEMCPY(res.pData, buffer->cpu_index_buffer, buffer->index_count * index_size);
ID3D11DeviceContext_Unmap(G.devcon, (ID3D11Resource *)buffer->gpu_index_buffer, 0);
}
/* Reset CPU buffers */
buffer->vertex_count = 0;
buffer->index_count = 0;
arena_reset(&buffer->vertex_arena);
arena_reset(&buffer->index_arena);
}
/* Swap CPU cmds to GPU store */
struct cmd_store temp = cmdbuff->gpu_cmd_store;
cmdbuff->gpu_cmd_store = cmdbuff->cpu_cmd_store;
cmdbuff->cpu_cmd_store = temp;
/* Reset CPU cmds */
cmdbuff->cpu_cmd_store.cmd_first = NULL;
cmdbuff->cpu_cmd_store.cmd_last = NULL;
arena_reset(&cmdbuff->cpu_cmd_store.arena);
}
/* ========================== *
* Profiling frame capture
* ========================== */
/* FIXME: enable this */
#if PROFILING && PROFILING_CAPTURE_FRAME_IMAGE
#define CAP_WIDTH 320
#define CAP_HEIGHT 180
struct prof_cap {
ID3D11Texture2D *texture;
struct v2 size;
};
INTERNAL void renderer_capture_image_for_profiler(void)
{
__prof;
/* A rolling window of staging textures is used. This is because trying to
* map a texture immediately after copying the resource will cause the map
* to hang while it waits for the copy to finish.
*
* At the time of writing this code, 5 textures seems to be the sweet spot
* for performance.
*/
static struct prof_cap staging_caps[5] = ZI;
static u32 cap_index = 0;
static b32 ready_to_read = false;
ID3D11Texture2D *backbuffer = NULL;
IDXGISwapChain_GetBuffer(G.swapchain, 0, &IID_ID3D11Texture2D, (LPVOID *)&backbuffer);
struct prof_cap *write_cap = &staging_caps[cap_index];
MEMZERO_STRUCT(write_cap);
{
D3D11_TEXTURE2D_DESC staging_desc;
ID3D11Texture2D_GetDesc(backbuffer, &staging_desc);
staging_desc.Usage = D3D11_USAGE_STAGING;
staging_desc.BindFlags = 0;
staging_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
write_cap->size = V2(staging_desc.Width, staging_desc.Height);
ID3D11Device_CreateTexture2D(G.dev, &staging_desc, NULL, &write_cap->texture);
}
ID3D11DeviceContext_CopyResource(G.devcon, (ID3D11Resource *)write_cap->texture, (ID3D11Resource *)backbuffer);
ID3D11Texture2D_Release(backbuffer);
++cap_index;
if (cap_index >= ARRAY_COUNT(staging_caps)) {
cap_index = 0;
ready_to_read = true;
}
if (ready_to_read) {
struct prof_cap *read_cap = &staging_caps[cap_index];
{
D3D11_MAPPED_SUBRESOURCE res;
ID3D11DeviceContext_Map(G.devcon, (ID3D11Resource *)read_cap->texture, 0, D3D11_MAP_READ, 0, &res);
u32 final_width = CAP_WIDTH;
u32 final_height = CAP_HEIGHT;
f32 width_frequency = (f32)read_cap->size.x / (f32)final_width;
f32 height_frequency = (f32)read_cap->size.y / (f32)final_height;
{
struct temp_arena scratch = scratch_begin_no_conflict();
u32 *source = res.pData;
u32 *dest = arena_push_array(scratch.arena, u32, final_width * final_height);
u32 pitch = res.RowPitch / 4;
for (u32 y = 0; y < final_height; ++y) {
for (u32 x = 0; x < final_width; ++x) {
u32 *pixel = &dest[x + (y * final_width)];
u64 source_x = (u64)(width_frequency * (f32)x);
u64 source_y = (u64)(height_frequency * (f32)y);
*pixel = source[source_x + (source_y * pitch)];
}
}
{
__profscope(prof_frame_image);
__profframeimage(dest, (u16)final_width, (u16)final_height, ARRAY_COUNT(staging_caps) - 1, false);
}
scratch_end(scratch);
}
ID3D11DeviceContext_Unmap(G.devcon, (ID3D11Resource *)read_cap->texture, 0);
}
ID3D11Texture2D_Release(read_cap->texture);
}
}
#else
INTERNAL void renderer_capture_image_for_profiler(void)
{
}
#endif
Reference in New Issue View Git Blame Copy Permalink