mirror/blah
1
0
Fork 0
mirror of https://github.com/NoelFB/blah.git synced 2025-04-05 00:16:05 +08:00
Code Issues Packages Projects Releases Wiki Activity
c89535e328
blah/src/internal/blah_renderer_d3d11.cpp

1660 lines
43 KiB
C++
Raw Blame History

#ifdef BLAH_RENDERER_D3D11
// TODO:
// Note the D3D11 Implementation is still a work-in-progress
#include "blah_renderer.h"
#include "blah_internal.h"
#include "blah_platform.h"
#include <blah_common.h>
#include <cstdio>
#include <cstring>
#include <cstddef>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <d3d11.h>
#include <d3dcompiler.h>
// shorthand to our internal state
#define RENDERER ((Renderer_D3D11*)Internal::renderer)
namespace Blah
{
const char* d3d11_batch_shader = ""
"cbuffer constants : register(b0)\n"
"{\n"
" row_major float4x4 u_matrix;\n"
"}\n"
"struct vs_in\n"
"{\n"
" float2 position : POS;\n"
" float2 texcoord : TEX;\n"
" float4 color : COL;\n"
" float4 mask : MASK;\n"
"};\n"
"struct vs_out\n"
"{\n"
" float4 position : SV_POSITION;\n"
" float2 texcoord : TEX;\n"
" float4 color : COL;\n"
" float4 mask : MASK;\n"
"};\n"
"Texture2D u_texture : register(t0);\n"
"SamplerState u_texture_sampler : register(s0);\n"
"vs_out vs_main(vs_in input)\n"
"{\n"
" vs_out output;\n"
" output.position = mul(float4(input.position, 0.0f, 1.0f), u_matrix);\n"
" output.texcoord = input.texcoord;\n"
" output.color = input.color;\n"
" output.mask = input.mask;\n"
" return output;\n"
"}\n"
"float4 ps_main(vs_out input) : SV_TARGET\n"
"{\n"
" float4 color = u_texture.Sample(u_texture_sampler, input.texcoord);\n"
" return\n"
" input.mask.x * color * input.color + \n"
" input.mask.y * color.a * input.color + \n"
" input.mask.z * input.color;\n"
"}\n";
const ShaderData d3d11_batch_shader_data = {
d3d11_batch_shader,
d3d11_batch_shader,
{
{ "POS", 0 },
{ "TEX", 0 },
{ "COL", 0 },
{ "MASK", 0 },
}
};
class D3D11_Shader;
class Renderer_D3D11 : public Renderer
{
public:
// main resources
ID3D11Device* device = nullptr;
ID3D11DeviceContext* context = nullptr;
IDXGISwapChain* swap_chain = nullptr;
ID3D11RenderTargetView* backbuffer_view = nullptr;
ID3D11DepthStencilView* backbuffer_depth_view = nullptr;
// last backbuffer size
Point drawable_size;
Point last_window_size;
struct StoredInputLayout
{
u32 shader_hash;
VertexFormat format;
ID3D11InputLayout* layout;
};
struct StoredBlendState
{
BlendMode blend;
ID3D11BlendState* state;
};
struct StoredRasterizer
{
Cull cull;
bool has_scissor;
ID3D11RasterizerState* state;
};
struct StoredSampler
{
TextureSampler sampler;
ID3D11SamplerState* state;
};
struct StoredDepthStencil
{
Compare depth;
ID3D11DepthStencilState* state;
};
Vector<StoredInputLayout> layout_cache;
Vector<StoredBlendState> blend_cache;
Vector<StoredRasterizer> rasterizer_cache;
Vector<StoredSampler> sampler_cache;
Vector<StoredDepthStencil> depthstencil_cache;
bool init() override;
void shutdown() override;
void update() override;
void before_render() override;
void after_render() override;
bool get_draw_size(int* w, int* h) override;
void render(const DrawCall& pass) override;
void clear_backbuffer(Color color, float depth, u8 stencil, ClearMask mask) override;
TextureRef create_texture(int width, int height, TextureFormat format) override;
TargetRef create_target(int width, int height, const TextureFormat* attachments, int attachment_count) override;
ShaderRef create_shader(const ShaderData* data) override;
MeshRef create_mesh() override;
ID3D11InputLayout* get_layout(D3D11_Shader* shader, const VertexFormat& format);
ID3D11BlendState* get_blend(const BlendMode& blend);
ID3D11RasterizerState* get_rasterizer(const DrawCall& pass);
ID3D11SamplerState* get_sampler(const TextureSampler& sampler);
ID3D11DepthStencilState* get_depthstencil(const DrawCall& pass);
};
// Utility Methods
D3D11_BLEND_OP blend_op(BlendOp op);
D3D11_BLEND blend_factor(BlendFactor factor);
bool reflect_uniforms(Vector<UniformInfo>& append_uniforms_to, Vector<ID3D11Buffer*>& append_buffers_to, ID3DBlob* shader, ShaderType shader_type);
void apply_uniforms(D3D11_Shader* shader, const MaterialRef& material, ShaderType type);
class D3D11_Texture : public Texture
{
private:
int m_width;
int m_height;
TextureFormat m_format;
DXGI_FORMAT m_dxgi_format;
bool m_is_framebuffer;
int m_size;
public:
ID3D11Texture2D* texture = nullptr;
ID3D11Texture2D* staging = nullptr;
ID3D11ShaderResourceView* view = nullptr;
D3D11_Texture(int width, int height, TextureFormat format, bool is_framebuffer)
{
m_width = width;
m_height = height;
m_format = format;
m_is_framebuffer = is_framebuffer;
m_size = 0;
D3D11_TEXTURE2D_DESC desc = { 0 };
desc.Width = width;
desc.Height = height;
desc.MipLevels = 1;
desc.ArraySize = 1;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
bool is_depth_stencil = false;
switch (format)
{
case TextureFormat::R:
desc.Format = DXGI_FORMAT_R8_UNORM;
m_size = width * height;
break;
case TextureFormat::RG:
desc.Format = DXGI_FORMAT_R8G8_UNORM;
m_size = width * height * 2;
break;
case TextureFormat::RGBA:
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
m_size = width * height * 4;
break;
case TextureFormat::DepthStencil:
desc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
m_size = width * height * 4;
is_depth_stencil = true;
break;
case TextureFormat::None:
case TextureFormat::Count:
break;
}
if (!is_depth_stencil)
desc.BindFlags |= D3D11_BIND_SHADER_RESOURCE;
else
desc.BindFlags |= D3D11_BIND_DEPTH_STENCIL;
if (is_framebuffer && !is_depth_stencil)
desc.BindFlags |= D3D11_BIND_RENDER_TARGET;
m_dxgi_format = desc.Format;
auto hr = RENDERER->device->CreateTexture2D(&desc, NULL, &texture);
if (!SUCCEEDED(hr))
{
if (texture)
texture->Release();
texture = nullptr;
return;
}
if (!is_depth_stencil)
{
hr = RENDERER->device->CreateShaderResourceView(texture, NULL, &view);
if (!SUCCEEDED(hr))
{
texture->Release();
texture = nullptr;
}
}
}
~D3D11_Texture()
{
if (texture)
texture->Release();
texture = nullptr;
if (staging)
staging->Release();
staging = nullptr;
if (view)
view->Release();
view = nullptr;
}
int width() const override
{
return m_width;
}
int height() const override
{
return m_height;
}
TextureFormat format() const override
{
return m_format;
}
void set_data(const u8* data) override
{
// bounds
D3D11_BOX box;
box.left = 0;
box.right = m_width;
box.top = 0;
box.bottom = m_height;
box.front = 0;
box.back = 1;
// set data
RENDERER->context->UpdateSubresource(
texture,
0,
&box,
data,
m_size / m_height,
0);
}
void get_data(u8* data) override
{
HRESULT hr;
// create staging texture
if (!staging)
{
D3D11_TEXTURE2D_DESC desc;
desc.Width = m_width;
desc.Height = m_height;
desc.MipLevels = 1;
desc.ArraySize = 1;
desc.Format = m_dxgi_format;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.Usage = D3D11_USAGE_STAGING;
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
desc.MiscFlags = 0;
hr = RENDERER->device->CreateTexture2D(&desc, NULL, &staging);
if (!SUCCEEDED(hr))
{
BLAH_ASSERT(false, "Failed to create staging texture to get data");
return;
}
}
D3D11_BOX box;
box.left = 0;
box.right = m_width;
box.bottom = m_height;
box.top = 0;
box.front = 0;
box.back = 1;
// copy data to staging texture
RENDERER->context->CopySubresourceRegion(
staging, 0,
0, 0, 0,
texture, 0,
&box);
// get data
D3D11_MAPPED_SUBRESOURCE map;
hr = RENDERER->context->Map(staging, 0, D3D11_MAP_READ, 0, &map);
if (!SUCCEEDED(hr))
{
BLAH_ASSERT(false, "Failed to get texture data");
return;
}
int bytes_per_pixel = m_size / (m_width * m_height);
int bytes_per_row = m_width * bytes_per_pixel;
for (int y = 0; y < m_height; y++)
memcpy(data + y * bytes_per_row, (unsigned char*)map.pData + map.RowPitch * y, bytes_per_row);
RENDERER->context->Unmap(staging, 0);
}
bool is_framebuffer() const override
{
return m_is_framebuffer;
}
};
class D3D11_Target : public Target
{
private:
Attachments m_attachments;
public:
StackVector<ID3D11RenderTargetView*, Attachments::capacity - 1> color_views;
ID3D11DepthStencilView* depth_view = nullptr;
D3D11_Target(int width, int height, const TextureFormat* attachments, int attachment_count)
{
for (int i = 0; i < attachment_count; i++)
{
auto tex = new D3D11_Texture(width, height, attachments[i], true);
m_attachments.push_back(TextureRef(tex));
if (attachments[i] == TextureFormat::DepthStencil)
{
RENDERER->device->CreateDepthStencilView(tex->texture, nullptr, &depth_view);
}
else
{
ID3D11RenderTargetView* view = nullptr;
RENDERER->device->CreateRenderTargetView(tex->texture, nullptr, &view);
color_views.push_back(view);
}
}
}
~D3D11_Target()
{
for (auto& it : color_views)
it->Release();
color_views.clear();
if (depth_view)
depth_view->Release();
depth_view = nullptr;
}
Attachments& textures() override
{
return m_attachments;
}
const Attachments& textures() const override
{
return m_attachments;
}
void clear(Color color, float depth, u8 stencil, ClearMask mask) override
{
float col[4] = { color.r / 255.0f, color.g / 255.0f, color.b / 255.0f, color.a / 255.0f };
if (((int)mask & (int)ClearMask::Color) == (int)ClearMask::Color)
{
for (int i = 0; i < color_views.size(); i++)
RENDERER->context->ClearRenderTargetView(color_views[i], col);
}
if (depth_view)
{
UINT flags = 0;
if (((int)mask & (int)ClearMask::Depth) == (int)ClearMask::Depth)
flags |= D3D11_CLEAR_DEPTH;
if (((int)mask & (int)ClearMask::Stencil) == (int)ClearMask::Stencil)
flags |= D3D11_CLEAR_STENCIL;
if (flags != 0)
RENDERER->context->ClearDepthStencilView(depth_view, flags, depth, stencil);
}
}
};
class D3D11_Shader : public Shader
{
public:
ID3D11VertexShader* vertex = nullptr;
ID3D11PixelShader* fragment = nullptr;
ID3DBlob* vertex_blob = nullptr;
ID3DBlob* fragment_blob = nullptr;
Vector<ID3D11Buffer*> vertex_uniform_buffers;
Vector<ID3D11Buffer*> fragment_uniform_buffers;
Vector<Vector<float>> vertex_uniform_values;
Vector<Vector<float>> fragment_uniform_values;
StackVector<ShaderData::HLSL_Attribute, 16> attributes;
Vector<UniformInfo> uniform_list;
u32 hash = 0;
bool valid = false;
D3D11_Shader(const ShaderData* data)
{
UINT flags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_DEBUG;
ID3DBlob* error_blob = nullptr;
HRESULT hr;
// compile vertex shader
{
hr = D3DCompile(
data->vertex.cstr(),
data->vertex.length(),
nullptr,
nullptr,
nullptr,
"vs_main",
"vs_5_0",
flags,
0,
&vertex_blob,
&error_blob);
if (FAILED(hr))
{
Log::error("%s", (char*)error_blob->GetBufferPointer());
error_blob->Release();
return;
}
}
// compile fragment shader
{
hr = D3DCompile(
data->fragment.cstr(),
data->fragment.length(),
nullptr,
nullptr,
nullptr,
"ps_main",
"ps_5_0",
flags,
0,
&fragment_blob,
&error_blob);
if (FAILED(hr))
{
Log::error("%s", (char*)error_blob->GetBufferPointer());
error_blob->Release();
return;
}
}
// create vertex shader
{
hr = RENDERER->device->CreateVertexShader(
vertex_blob->GetBufferPointer(),
vertex_blob->GetBufferSize(),
NULL,
&vertex);
if (!SUCCEEDED(hr))
return;
}
// create fragment shader
{
hr = RENDERER->device->CreatePixelShader(
fragment_blob->GetBufferPointer(),
fragment_blob->GetBufferSize(),
NULL,
&fragment);
if (!SUCCEEDED(hr))
return;
}
// get uniforms
reflect_uniforms(uniform_list, vertex_uniform_buffers, vertex_blob, ShaderType::Vertex);
reflect_uniforms(uniform_list, fragment_uniform_buffers, fragment_blob, ShaderType::Fragment);
// combine uniforms that were in both
for (int i = 0; i < uniform_list.size(); i++)
{
for (int j = i + 1; j < uniform_list.size(); j++)
{
if (strcmp(uniform_list[i].name, uniform_list[j].name) == 0)
{
if (uniform_list[i].type == uniform_list[j].type)
{
uniform_list[i].shader = (ShaderType)((int)uniform_list[i].shader | (int)uniform_list[j].shader);
uniform_list.erase(j);
j--;
}
}
}
}
// create CPU uniform buffers, so we don't need to create them during rendering
vertex_uniform_values.expand(vertex_uniform_buffers.size());
fragment_uniform_values.expand(fragment_uniform_buffers.size());
// copy HLSL attributes
attributes = data->hlsl_attributes;
// store hash
hash = 5381;
for (auto& it : attributes)
{
for (size_t i = 0, n = strlen(it.semantic_name); i < n; i++)
hash = ((hash << 5) + hash) + it.semantic_name[i];
hash = (it.semantic_index << 5) + hash;
}
// Shader is ready for use!
valid = true;
}
~D3D11_Shader() override
{
if (vertex)
vertex->Release();
vertex = nullptr;
if (vertex_blob)
vertex_blob->Release();
vertex_blob = nullptr;
if (fragment)
fragment->Release();
fragment = nullptr;
if (fragment_blob)
fragment_blob->Release();
fragment_blob = nullptr;
for (auto& it : vertex_uniform_buffers)
it->Release();
vertex_uniform_buffers.clear();
for (auto& it : fragment_uniform_buffers)
it->Release();
fragment_uniform_buffers.clear();
}
Vector<UniformInfo>& uniforms() override
{
return uniform_list;
}
const Vector<UniformInfo>& uniforms() const override
{
return uniform_list;
}
};
class D3D11_Mesh : public Mesh
{
private:
i64 m_vertex_count = 0;
i64 m_vertex_capacity = 0;
i64 m_index_count = 0;
i64 m_index_capacity = 0;
public:
ID3D11Buffer* vertex_buffer = nullptr;
VertexFormat vertex_format;
ID3D11Buffer* index_buffer = nullptr;
IndexFormat index_format = IndexFormat::UInt16;
int index_stride = 0;
D3D11_Mesh()
{
}
~D3D11_Mesh()
{
if (vertex_buffer)
vertex_buffer->Release();
vertex_buffer = nullptr;
if (index_buffer)
index_buffer->Release();
index_buffer = nullptr;
}
void index_data(IndexFormat format, const void* indices, i64 count) override
{
m_index_count = count;
if (index_format != format || !index_buffer || m_index_count > m_index_capacity)
{
index_stride = 0;
index_format = format;
m_index_capacity = max(m_index_capacity, m_index_count);
switch (format)
{
case IndexFormat::UInt16: index_stride = sizeof(i16); break;
case IndexFormat::UInt32: index_stride = sizeof(i32); break;
}
if (m_index_capacity > 0 && indices)
{
// release existing buffer
if (index_buffer)
index_buffer->Release();
index_buffer = nullptr;
// buffer description
D3D11_BUFFER_DESC desc = { 0 };
desc.ByteWidth = (UINT)(index_stride * m_index_capacity);
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
// buffer data
D3D11_SUBRESOURCE_DATA data = { 0 };
data.pSysMem = indices;
// create
auto hr = RENDERER->device->CreateBuffer(&desc, &data, &index_buffer);
BLAH_ASSERT(SUCCEEDED(hr), "Failed to update Index Data");
}
}
else if (indices)
{
D3D11_MAPPED_SUBRESOURCE map;
auto hr = RENDERER->context->Map(index_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &map);
BLAH_ASSERT(SUCCEEDED(hr), "Failed to update Index Data");
if (SUCCEEDED(hr))
{
memcpy(map.pData, indices, index_stride * count);
RENDERER->context->Unmap(index_buffer, 0);
}
}
}
void vertex_data(const VertexFormat& format, const void* vertices, i64 count) override
{
m_vertex_count = count;
// recreate buffer if we've changed
if (vertex_format.stride != format.stride || !vertex_buffer || m_vertex_count > m_vertex_capacity)
{
m_vertex_capacity = max(m_vertex_capacity, m_vertex_count);
vertex_format = format;
// discard old buffer
if (vertex_buffer)
vertex_buffer->Release();
vertex_buffer = nullptr;
if (m_vertex_capacity > 0 && vertices)
{
// buffer description
D3D11_BUFFER_DESC desc = { 0 };
desc.ByteWidth = (UINT)(format.stride * m_vertex_capacity);
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
// buffer data
D3D11_SUBRESOURCE_DATA data = { 0 };
data.pSysMem = vertices;
// create
auto hr = RENDERER->device->CreateBuffer(&desc, &data, &vertex_buffer);
BLAH_ASSERT(SUCCEEDED(hr), "Failed to update Vertex Data");
}
}
// otherwise just update it
else if (vertices)
{
D3D11_MAPPED_SUBRESOURCE map;
auto hr = RENDERER->context->Map(vertex_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &map);
BLAH_ASSERT(SUCCEEDED(hr), "Failed to update Vertex Data");
if (SUCCEEDED(hr))
{
memcpy(map.pData, vertices, vertex_format.stride * count);
RENDERER->context->Unmap(vertex_buffer, 0);
}
}
}
void instance_data(const VertexFormat& format, const void* instances, i64 count) override
{
}
i64 index_count() const override
{
return m_index_count;
}
i64 vertex_count() const override
{
return m_vertex_count;
}
i64 instance_count() const override
{
return 0;
}
};
bool Renderer_D3D11::init()
{
last_window_size = App::get_size();
// Define Swap Chain
DXGI_SWAP_CHAIN_DESC desc = {};
desc.BufferDesc.RefreshRate.Numerator = 0;
desc.BufferDesc.RefreshRate.Denominator = 1;
desc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
desc.BufferCount = 1;
desc.OutputWindow = (HWND)Internal::platform->d3d11_get_hwnd();
desc.Windowed = true;
// Creation Flags
UINT flags = D3D11_CREATE_DEVICE_SINGLETHREADED;
#if defined(DEBUG) || defined(_DEBUG)
flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
// Create D3D device & context & swap chain
D3D_FEATURE_LEVEL feature_level;
HRESULT hr = D3D11CreateDeviceAndSwapChain(
NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
flags,
NULL,
0,
D3D11_SDK_VERSION,
&desc,
&swap_chain,
&device,
&feature_level,
&context);
// Exit out if it's not OK
if (!SUCCEEDED(hr) || !swap_chain || !device || !context)
return false;
// Get the backbuffer
ID3D11Texture2D* frame_buffer = nullptr;
swap_chain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&frame_buffer);
if (frame_buffer)
{
D3D11_TEXTURE2D_DESC desc;
frame_buffer->GetDesc(&desc);
drawable_size = Point(desc.Width, desc.Height);
device->CreateRenderTargetView(frame_buffer, nullptr, &backbuffer_view);
frame_buffer->Release();
}
// TODO:
// create a depth backbuffer
// Store Features
info.type = RendererType::D3D11;
info.instancing = true;
info.max_texture_size = D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION;
info.origin_bottom_left = false;
// Print Driver Info
{
IDXGIDevice* dxgi_device;
IDXGIAdapter* dxgi_adapter;
DXGI_ADAPTER_DESC adapter_desc;
hr = device->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgi_device);
if (SUCCEEDED(hr))
{
dxgi_device->GetAdapter(&dxgi_adapter);
dxgi_adapter->GetDesc(&adapter_desc);
Log::info("D3D11 %ls", adapter_desc.Description);
dxgi_device->Release();
dxgi_adapter->Release();
}
else
{
Log::info("D3D11");
}
}
// create default sprite batch shader
default_batcher_shader = Shader::create(d3d11_batch_shader_data);
return true;
}
void Renderer_D3D11::shutdown()
{
// release cached objects
for (auto& it : blend_cache)
it.state->Release();
for (auto& it : depthstencil_cache)
it.state->Release();
for (auto& it : layout_cache)
it.layout->Release();
for (auto& it : rasterizer_cache)
it.state->Release();
for (auto& it : sampler_cache)
it.state->Release();
// release main devices
if (backbuffer_view)
backbuffer_view->Release();
if (backbuffer_depth_view)
backbuffer_depth_view->Release();
swap_chain->Release();
context->ClearState();
context->Flush();
context->Release();
device->Release();
}
void Renderer_D3D11::update()
{
}
void Renderer_D3D11::before_render()
{
HRESULT hr;
auto next_window_size = App::get_size();
if (last_window_size != next_window_size)
{
last_window_size = next_window_size;
// release old buffer
if (backbuffer_view)
backbuffer_view->Release();
// perform resize
hr = swap_chain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_B8G8R8A8_UNORM, 0);
BLAH_ASSERT(SUCCEEDED(hr), "Failed to update Backbuffer on Resize");
// get the new buffer
ID3D11Texture2D* frame_buffer = nullptr;
hr = swap_chain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&frame_buffer);
if (SUCCEEDED(hr) && frame_buffer)
{
// get backbuffer drawable size
D3D11_TEXTURE2D_DESC desc;
frame_buffer->GetDesc(&desc);
drawable_size = Point(desc.Width, desc.Height);
// create view
hr = device->CreateRenderTargetView(frame_buffer, nullptr, &backbuffer_view);
BLAH_ASSERT(SUCCEEDED(hr), "Failed to update Backbuffer on Resize");
frame_buffer->Release();
}
}
}
bool Renderer_D3D11::get_draw_size(int* w, int* h)
{
*w = drawable_size.x;
*h = drawable_size.y;
return true;
}
void Renderer_D3D11::after_render()
{
auto vsync = App::get_flag(Flags::VSync);
auto hr = swap_chain->Present(vsync ? 1 : 0, 0);
BLAH_ASSERT(SUCCEEDED(hr), "Failed to Present swap chain");
}
TextureRef Renderer_D3D11::create_texture(int width, int height, TextureFormat format)
{
auto result = new D3D11_Texture(width, height, format, false);
if (result->texture)
return TextureRef(result);
delete result;
return TextureRef();
}
TargetRef Renderer_D3D11::create_target(int width, int height, const TextureFormat* attachments, int attachment_count)
{
return TargetRef(new D3D11_Target(width, height, attachments, attachment_count));
}
ShaderRef Renderer_D3D11::create_shader(const ShaderData* data)
{
auto result = new D3D11_Shader(data);
if (result->valid)
return ShaderRef(result);
delete result;
return ShaderRef();
}
MeshRef Renderer_D3D11::create_mesh()
{
return MeshRef(new D3D11_Mesh());
}
void Renderer_D3D11::render(const DrawCall& pass)
{
auto ctx = context;
auto mesh = (D3D11_Mesh*)pass.mesh.get();
auto shader = (D3D11_Shader*)(pass.material->shader().get());
// OM
{
// Set the Target
if (pass.target == App::backbuffer() || !pass.target)
{
ctx->OMSetRenderTargets(1, &backbuffer_view, backbuffer_depth_view);
}
else
{
auto target = (D3D11_Target*)(pass.target.get());
ctx->OMSetRenderTargets(target->color_views.size(), target->color_views.begin(), target->depth_view);
}
// Depth
{
auto depthstencil = get_depthstencil(pass);
if (depthstencil)
ctx->OMSetDepthStencilState(depthstencil, 0);
}
// Blend Mode
{
auto blend = get_blend(pass.blend);
if (blend)
{
auto color = Color::from_rgba(pass.blend.rgba);
float factor[4]{ color.r / 255.0f, color.g / 255.0f, color.b / 255.0f, color.a / 255.0f };
auto mask = 0xffffffff;
ctx->OMSetBlendState(blend, factor, mask);
}
else
{
// if we failed to create a blend mode for some reason
ctx->OMSetBlendState(nullptr, nullptr, 0);
}
}
}
// IA
{
// We draw triangles
ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// Assign Layout
auto layout = get_layout(shader, mesh->vertex_format);
ctx->IASetInputLayout(layout);
// Assign Vertex Buffer
{
UINT stride = mesh->vertex_format.stride;
UINT offset = 0;
ctx->IASetVertexBuffers(
0,
1,
&mesh->vertex_buffer,
&stride,
&offset);
}
// Assign Index Buffer
{
DXGI_FORMAT format = DXGI_FORMAT_R16_UINT;
switch (mesh->index_format)
{
case IndexFormat::UInt16: format = DXGI_FORMAT_R16_UINT; break;
case IndexFormat::UInt32: format = DXGI_FORMAT_R32_UINT; break;
}
ctx->IASetIndexBuffer(mesh->index_buffer, format, 0);
}
}
// VS
{
apply_uniforms(shader, pass.material, ShaderType::Vertex);
ctx->VSSetShader(shader->vertex, nullptr, 0);
ctx->VSSetConstantBuffers(0, shader->vertex_uniform_buffers.size(), shader->vertex_uniform_buffers.begin());
}
// PS
{
apply_uniforms(shader, pass.material, ShaderType::Fragment);
ctx->PSSetShader(shader->fragment, nullptr, 0);
ctx->PSSetConstantBuffers(0, shader->fragment_uniform_buffers.size(), shader->fragment_uniform_buffers.begin());
// Fragment Shader Textures
auto& textures = pass.material->textures();
for (int i = 0; i < textures.size(); i++)
{
if (textures[i])
{
// Assign the Texture
auto view = ((D3D11_Texture*)textures[i].get())->view;
ctx->PSSetShaderResources(i, 1, &view);
}
}
// Fragment Shader Samplers
auto& samplers = pass.material->samplers();
for (int i = 0; i < samplers.size(); i++)
{
auto sampler = get_sampler(samplers[i]);
if (sampler)
ctx->PSSetSamplers(i, 1, &sampler);
}
}
// RS
{
// Set the Viewport
{
D3D11_VIEWPORT viewport = {
pass.viewport.x, pass.viewport.y,
pass.viewport.w, pass.viewport.h,
0.0f, 1.0f };
ctx->RSSetViewports(1, &viewport);
}
// Scissor Rect
if (pass.has_scissor)
{
D3D11_RECT scissor = {
(int)pass.scissor.x, (int)pass.scissor.y,
(int)pass.scissor.x + (int)pass.scissor.w, (int)pass.scissor.y + (int)pass.scissor.h };
ctx->RSSetScissorRects(1, &scissor);
}
else
{
ctx->RSSetScissorRects(0, nullptr);
}
// Rasterizer
{
auto rasterizer = get_rasterizer(pass);
if (rasterizer)
ctx->RSSetState(rasterizer);
}
}
// Draw
{
if (mesh->instance_count() <= 0)
{
ctx->DrawIndexed(
static_cast<UINT>(pass.index_count),
static_cast<UINT>(pass.index_start), 0);
}
else
{
// TODO:
// Draw Instanced data
BLAH_ASSERT(false, "Instanced Drawing not implemented yet");
}
}
// UnBind Shader Resources
{
auto& textures = pass.material->textures();
ID3D11ShaderResourceView* view = nullptr;
for (int i = 0; i < textures.size(); i++)
ctx->PSSetShaderResources(i, 1, &view);
}
}
void Renderer_D3D11::clear_backbuffer(Color color, float depth, u8 stencil, ClearMask mask)
{
if (((int)mask & (int)ClearMask::Color) == (int)ClearMask::Color)
{
float clear[4] = { color.r / 255.0f, color.g / 255.0f, color.b / 255.0f, color.a / 255.0f };
context->ClearRenderTargetView(backbuffer_view, clear);
}
if (backbuffer_depth_view)
{
UINT flags = 0;
if (((int)mask & (int)ClearMask::Depth) == (int)ClearMask::Depth)
flags |= D3D11_CLEAR_DEPTH;
if (((int)mask & (int)ClearMask::Stencil) == (int)ClearMask::Stencil)
flags |= D3D11_CLEAR_STENCIL;
if (flags != 0)
context->ClearDepthStencilView(backbuffer_depth_view, flags, depth, stencil);
}
}
// Utility Methods
D3D11_BLEND_OP blend_op(BlendOp op)
{
switch (op)
{
case BlendOp::Add: return D3D11_BLEND_OP_ADD;
case BlendOp::Subtract: return D3D11_BLEND_OP_SUBTRACT;
case BlendOp::ReverseSubtract: return D3D11_BLEND_OP_REV_SUBTRACT;
case BlendOp::Min: return D3D11_BLEND_OP_MIN;
case BlendOp::Max: return D3D11_BLEND_OP_MAX;
}
return D3D11_BLEND_OP_ADD;
}
D3D11_BLEND blend_factor(BlendFactor factor)
{
switch (factor)
{
case BlendFactor::Zero: return D3D11_BLEND_ZERO;
case BlendFactor::One: return D3D11_BLEND_ONE;
case BlendFactor::SrcColor: return D3D11_BLEND_SRC_COLOR;
case BlendFactor::OneMinusSrcColor: return D3D11_BLEND_INV_SRC_COLOR;
case BlendFactor::DstColor: return D3D11_BLEND_DEST_COLOR;
case BlendFactor::OneMinusDstColor: return D3D11_BLEND_INV_DEST_COLOR;
case BlendFactor::SrcAlpha: return D3D11_BLEND_SRC_ALPHA;
case BlendFactor::OneMinusSrcAlpha: return D3D11_BLEND_INV_SRC_ALPHA;
case BlendFactor::DstAlpha: return D3D11_BLEND_DEST_ALPHA;
case BlendFactor::OneMinusDstAlpha: return D3D11_BLEND_INV_DEST_ALPHA;
case BlendFactor::ConstantColor: return D3D11_BLEND_BLEND_FACTOR;
case BlendFactor::OneMinusConstantColor: return D3D11_BLEND_INV_BLEND_FACTOR;
case BlendFactor::ConstantAlpha: return D3D11_BLEND_BLEND_FACTOR;
case BlendFactor::OneMinusConstantAlpha: return D3D11_BLEND_INV_BLEND_FACTOR;
case BlendFactor::SrcAlphaSaturate: return D3D11_BLEND_SRC_ALPHA_SAT;
case BlendFactor::Src1Color: return D3D11_BLEND_SRC1_COLOR;
case BlendFactor::OneMinusSrc1Color: return D3D11_BLEND_INV_SRC1_COLOR;
case BlendFactor::Src1Alpha: return D3D11_BLEND_SRC1_ALPHA;
case BlendFactor::OneMinusSrc1Alpha: return D3D11_BLEND_INV_SRC1_ALPHA;
}
return D3D11_BLEND_ZERO;
}
bool reflect_uniforms(Vector<UniformInfo>& append_uniforms_to, Vector<ID3D11Buffer*>& append_buffers_to, ID3DBlob* shader, ShaderType shader_type)
{
ID3D11ShaderReflection* reflector = nullptr;
D3DReflect(shader->GetBufferPointer(), shader->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&reflector);
D3D11_SHADER_DESC shader_desc;
reflector->GetDesc(&shader_desc);
for (UINT i = 0; i < shader_desc.BoundResources; i++)
{
D3D11_SHADER_INPUT_BIND_DESC desc;
reflector->GetResourceBindingDesc(i, &desc);
if (desc.Type == D3D_SIT_TEXTURE && desc.Dimension == D3D_SRV_DIMENSION_TEXTURE2D)
{
auto uniform = append_uniforms_to.expand();
uniform->name = desc.Name;
uniform->shader = shader_type;
uniform->register_index = desc.BindPoint;
uniform->buffer_index = 0;
uniform->array_length = max(1, desc.BindCount);
uniform->type = UniformType::Texture2D;
}
else if (desc.Type == D3D_SIT_SAMPLER)
{
auto uniform = append_uniforms_to.expand();
uniform->name = desc.Name;
uniform->shader = shader_type;
uniform->register_index = desc.BindPoint;
uniform->buffer_index = 0;
uniform->array_length = max(1, desc.BindCount);
uniform->type = UniformType::Sampler2D;
}
}
for (UINT i = 0; i < shader_desc.ConstantBuffers; i++)
{
D3D11_SHADER_BUFFER_DESC desc;
auto cb = reflector->GetConstantBufferByIndex(i);
cb->GetDesc(&desc);
// create the constant buffer for assigning data later
{
D3D11_BUFFER_DESC buffer_desc = {};
buffer_desc.ByteWidth = desc.Size;
buffer_desc.Usage = D3D11_USAGE_DYNAMIC;
buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
ID3D11Buffer* buffer;
RENDERER->device->CreateBuffer(&buffer_desc, nullptr, &buffer);
append_buffers_to.push_back(buffer);
}
// get the uniforms
for (UINT j = 0; j < desc.Variables; j++)
{
D3D11_SHADER_VARIABLE_DESC var_desc;
D3D11_SHADER_TYPE_DESC type_desc;
auto var = cb->GetVariableByIndex(j);
var->GetDesc(&var_desc);
auto type = var->GetType();
type->GetDesc(&type_desc);
auto uniform = append_uniforms_to.expand();
uniform->name = var_desc.Name;
uniform->shader = shader_type;
uniform->register_index = 0;
uniform->buffer_index = i;
uniform->array_length = max(1, type_desc.Elements);
uniform->type = UniformType::None;
if (type_desc.Type == D3D_SVT_FLOAT)
{
if (type_desc.Rows == 1)
{
if (type_desc.Columns == 1)
uniform->type = UniformType::Float;
else if (type_desc.Columns == 2)
uniform->type = UniformType::Float2;
else if (type_desc.Columns == 3)
uniform->type = UniformType::Float3;
else if (type_desc.Columns == 4)
uniform->type = UniformType::Float4;
}
else if (type_desc.Rows == 2 && type_desc.Columns == 3)
{
uniform->type = UniformType::Mat3x2;
}
else if (type_desc.Rows == 4 && type_desc.Columns == 4)
{
uniform->type = UniformType::Mat4x4;
}
}
}
}
return true;
}
void apply_uniforms(D3D11_Shader* shader, const MaterialRef& material, ShaderType type)
{
auto& buffers = (type == ShaderType::Vertex ? shader->vertex_uniform_buffers : shader->fragment_uniform_buffers);
auto& values = (type == ShaderType::Vertex ? shader->vertex_uniform_values : shader->fragment_uniform_values);
for (int i = 0; i < buffers.size(); i++)
{
// clear previous values
values[i].clear();
// build block
const float* data = material->data();
for (auto& it : shader->uniforms())
{
if (it.type == UniformType::None ||
it.type == UniformType::Texture2D ||
it.type == UniformType::Sampler2D)
continue;
int size = 0;
switch (it.type)
{
case UniformType::None: break;
case UniformType::Texture2D: break;
case UniformType::Sampler2D: break;
case UniformType::Float: size = 1; break;
case UniformType::Float2: size = 2; break;
case UniformType::Float3: size = 3; break;
case UniformType::Float4: size = 4; break;
case UniformType::Mat3x2: size = 6; break;
case UniformType::Mat4x4: size = 16; break;
}
int length = size * it.array_length;
if (it.buffer_index == i && ((int)it.shader & (int)type) != 0)
{
// HLSL uniforms can not pass 16-byte (4-float) boundaries, therefore potentially add padding to the buffer so we align to 16 bytes
// For example, if we have filled in 6 floats, our remaining space will be 2. If the next value is larger than 2 floats, we will
// need to move to the next 16-byte (4-float) boundary (in this case 2 floats to begin at 8 floats).
// see: https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-packing-rules
int remaining = 4 - values[i].size() % 4;
if (remaining != 4 && remaining + length > 4)
values[i].expand(remaining);
auto start = values[i].expand(length);
memcpy(start, data, sizeof(float) * length);
}
data += length;
}
// apply block
if (buffers[i])
{
D3D11_MAPPED_SUBRESOURCE map;
RENDERER->context->Map(buffers[i], 0, D3D11_MAP_WRITE_DISCARD, 0, &map);
memcpy(map.pData, values[i].begin(), values[i].size() * sizeof(float));
RENDERER->context->Unmap(buffers[i], 0);
}
}
}
ID3D11InputLayout* Renderer_D3D11::get_layout(D3D11_Shader* shader, const VertexFormat& format)
{
// find existing
for (auto& it : layout_cache)
{
if (it.shader_hash == shader->hash && it.format.stride == format.stride && it.format.attributes.size() == format.attributes.size())
{
bool same_format = true;
for (int n = 0; same_format && n < format.attributes.size(); n++)
if (it.format.attributes[n].index != format.attributes[n].index ||
it.format.attributes[n].type != format.attributes[n].type ||
it.format.attributes[n].normalized != format.attributes[n].normalized)
same_format = false;
if (same_format)
return it.layout;
}
}
// create a new one
Vector<D3D11_INPUT_ELEMENT_DESC> desc;
for (int i = 0; i < shader->attributes.size(); i++)
{
auto it = desc.expand();
it->SemanticName = shader->attributes[i].semantic_name;
it->SemanticIndex = shader->attributes[i].semantic_index;
if (!format.attributes[i].normalized)
{
switch (format.attributes[i].type)
{
case VertexType::None: break;
case VertexType::Float: it->Format = DXGI_FORMAT_R32_FLOAT; break;
case VertexType::Float2: it->Format = DXGI_FORMAT_R32G32_FLOAT; break;
case VertexType::Float3: it->Format = DXGI_FORMAT_R32G32B32_FLOAT; break;
case VertexType::Float4: it->Format = DXGI_FORMAT_R32G32B32A32_FLOAT; break;
case VertexType::Byte4: it->Format = DXGI_FORMAT_R8G8B8A8_SINT; break;
case VertexType::UByte4: it->Format = DXGI_FORMAT_R8G8B8A8_UINT; break;
case VertexType::Short2: it->Format = DXGI_FORMAT_R16G16_SINT; break;
case VertexType::UShort2: it->Format = DXGI_FORMAT_R16G16_UINT; break;
case VertexType::Short4: it->Format = DXGI_FORMAT_R16G16B16A16_SINT; break;
case VertexType::UShort4: it->Format = DXGI_FORMAT_R16G16B16A16_UINT; break;
}
}
else
{
switch (format.attributes[i].type)
{
case VertexType::None: break;
case VertexType::Float: it->Format = DXGI_FORMAT_R32_FLOAT; break;
case VertexType::Float2: it->Format = DXGI_FORMAT_R32G32_FLOAT; break;
case VertexType::Float3: it->Format = DXGI_FORMAT_R32G32B32_FLOAT; break;
case VertexType::Float4: it->Format = DXGI_FORMAT_R32G32B32A32_FLOAT; break;
case VertexType::Byte4: it->Format = DXGI_FORMAT_R8G8B8A8_SNORM; break;
case VertexType::UByte4: it->Format = DXGI_FORMAT_R8G8B8A8_UNORM; break;
case VertexType::Short2: it->Format = DXGI_FORMAT_R16G16_SNORM; break;
case VertexType::UShort2: it->Format = DXGI_FORMAT_R16G16_UNORM; break;
case VertexType::Short4: it->Format = DXGI_FORMAT_R16G16B16A16_SNORM; break;
case VertexType::UShort4: it->Format = DXGI_FORMAT_R16G16B16A16_UNORM; break;
}
}
it->InputSlot = 0;
it->AlignedByteOffset = (i == 0 ? 0 : D3D11_APPEND_ALIGNED_ELEMENT);
it->InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
it->InstanceDataStepRate = 0;
}
ID3D11InputLayout* layout = nullptr;
auto hr = device->CreateInputLayout(
desc.begin(),
desc.size(),
shader->vertex_blob->GetBufferPointer(),
shader->vertex_blob->GetBufferSize(),
&layout);
if (SUCCEEDED(hr))
{
auto entry = layout_cache.expand();
entry->shader_hash = shader->hash;
entry->format = format;
entry->layout = layout;
return layout;
}
return nullptr;
}
ID3D11BlendState* Renderer_D3D11::get_blend(const BlendMode& blend)
{
for (auto& it : blend_cache)
if (it.blend == blend)
return it.state;
D3D11_BLEND_DESC desc = { 0 };
desc.AlphaToCoverageEnable = 0;
desc.IndependentBlendEnable = 0;
desc.RenderTarget[0].BlendEnable = !(
blend.color_src == BlendFactor::One && blend.color_dst == BlendFactor::Zero &&
blend.alpha_src == BlendFactor::One && blend.alpha_dst == BlendFactor::Zero
);
desc.RenderTarget[0].RenderTargetWriteMask = 0;
if (((int)blend.mask & (int)BlendMask::Red) == (int)BlendMask::Red)
desc.RenderTarget[0].RenderTargetWriteMask |= D3D11_COLOR_WRITE_ENABLE_RED;
if (((int)blend.mask & (int)BlendMask::Green) == (int)BlendMask::Green)
desc.RenderTarget[0].RenderTargetWriteMask |= D3D11_COLOR_WRITE_ENABLE_GREEN;
if (((int)blend.mask & (int)BlendMask::Blue) == (int)BlendMask::Blue)
desc.RenderTarget[0].RenderTargetWriteMask |= D3D11_COLOR_WRITE_ENABLE_BLUE;
if (((int)blend.mask & (int)BlendMask::Alpha) == (int)BlendMask::Alpha)
desc.RenderTarget[0].RenderTargetWriteMask |= D3D11_COLOR_WRITE_ENABLE_ALPHA;
if (desc.RenderTarget[0].BlendEnable)
{
desc.RenderTarget[0].BlendOp = blend_op(blend.color_op);
desc.RenderTarget[0].SrcBlend = blend_factor(blend.color_src);
desc.RenderTarget[0].DestBlend = blend_factor(blend.color_dst);
desc.RenderTarget[0].BlendOpAlpha = blend_op(blend.alpha_op);
desc.RenderTarget[0].SrcBlendAlpha = blend_factor(blend.alpha_src);
desc.RenderTarget[0].DestBlendAlpha = blend_factor(blend.alpha_dst);
}
for (int i = 1; i < 8; i++)
desc.RenderTarget[i] = desc.RenderTarget[0];
ID3D11BlendState* blend_state = nullptr;
auto hr = RENDERER->device->CreateBlendState(&desc, &blend_state);
if (SUCCEEDED(hr))
{
auto entry = blend_cache.expand();
entry->blend = blend;
entry->state = blend_state;
return blend_state;
}
return nullptr;
}
ID3D11SamplerState* Renderer_D3D11::get_sampler(const TextureSampler& sampler)
{
for (auto& it : sampler_cache)
if (it.sampler == sampler)
return it.state;
D3D11_SAMPLER_DESC desc = {};
desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
switch (sampler.filter)
{
case TextureFilter::None: break;
case TextureFilter::Nearest: desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; break;
case TextureFilter::Linear: desc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; break;
}
switch (sampler.wrap_x)
{
case TextureWrap::None: break;
case TextureWrap::Clamp: desc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; break;
case TextureWrap::Repeat: desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; break;
}
switch (sampler.wrap_y)
{
case TextureWrap::None: break;
case TextureWrap::Clamp: desc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; break;
case TextureWrap::Repeat: desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; break;
}
ID3D11SamplerState* result;
auto hr = RENDERER->device->CreateSamplerState(&desc, &result);
if (SUCCEEDED(hr))
{
auto entry = sampler_cache.expand();
entry->sampler = sampler;
entry->state = result;
return result;
}
return nullptr;
}
ID3D11RasterizerState* Renderer_D3D11::get_rasterizer(const DrawCall& pass)
{
for (auto& it : rasterizer_cache)
if (it.cull == pass.cull && it.has_scissor == pass.has_scissor)
return it.state;
D3D11_RASTERIZER_DESC desc = {};
desc.FillMode = D3D11_FILL_SOLID;
desc.CullMode = D3D11_CULL_NONE;
switch (pass.cull)
{
case Cull::None: desc.CullMode = D3D11_CULL_NONE; break;
case Cull::Front: desc.CullMode = D3D11_CULL_FRONT; break;
case Cull::Back: desc.CullMode = D3D11_CULL_BACK; break;
}
desc.FrontCounterClockwise = true;
desc.DepthBias = 0;
desc.DepthBiasClamp = 0;
desc.SlopeScaledDepthBias = 0;
desc.DepthClipEnable = false;
desc.ScissorEnable = pass.has_scissor;
desc.MultisampleEnable = false;
desc.AntialiasedLineEnable = false;
ID3D11RasterizerState* result;
auto hr = RENDERER->device->CreateRasterizerState(&desc, &result);
if (SUCCEEDED(hr))
{
auto entry = rasterizer_cache.expand();
entry->cull = pass.cull;
entry->has_scissor = pass.has_scissor;
entry->state = result;
return result;
}
return nullptr;
}
ID3D11DepthStencilState* Renderer_D3D11::get_depthstencil(const DrawCall& pass)
{
for (auto& it : depthstencil_cache)
if (it.depth == pass.depth)
return it.state;
D3D11_DEPTH_STENCIL_DESC desc = {};
desc.DepthEnable = pass.depth != Compare::None;
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
desc.DepthFunc = D3D11_COMPARISON_NEVER;
switch (pass.depth)
{
case Compare::None: desc.DepthFunc = D3D11_COMPARISON_NEVER; break;
case Compare::Always: desc.DepthFunc = D3D11_COMPARISON_ALWAYS; break;
case Compare::Never: desc.DepthFunc = D3D11_COMPARISON_NEVER; break;
case Compare::Less: desc.DepthFunc = D3D11_COMPARISON_LESS; break;
case Compare::Equal: desc.DepthFunc = D3D11_COMPARISON_EQUAL; break;
case Compare::LessOrEqual: desc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL; break;
case Compare::Greater: desc.DepthFunc = D3D11_COMPARISON_GREATER; break;
case Compare::NotEqual: desc.DepthFunc = D3D11_COMPARISON_NOT_EQUAL; break;
case Compare::GreaterOrEqual: desc.DepthFunc = D3D11_COMPARISON_GREATER_EQUAL; break;
}
ID3D11DepthStencilState* result;
auto hr = RENDERER->device->CreateDepthStencilState(&desc, &result);
if (SUCCEEDED(hr))
{
auto entry = depthstencil_cache.expand();
entry->depth = pass.depth;
entry->state = result;
return result;
}
return nullptr;
}
}
Blah::Renderer* Blah::Renderer::try_make_d3d11()
{
return new Blah::Renderer_D3D11();
}
#else // BLAH_RENDERER_D3D11
#include "blah_RENDERER.h"
Blah::Renderer* Blah::Renderer::try_make_d3d11()
{
return nullptr;
}
#endif
Reference in New Issue View Git Blame Copy Permalink