jp9000/obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

clang-format: Apply formatting

Browse Source 
Code submissions have continually suffered from formatting
inconsistencies that constantly have to be addressed.  Using
clang-format simplifies this by making code formatting more consistent,
and allows automation of the code formatting so that maintainers can
focus more on the code itself instead of code formatting.
This commit is contained in:
jp9000
2019-06-22 22:13:45 -07:00
parent 53615ee10f
commit f53df7da64
567 changed files with 34068 additions and 32903 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
libobs-d3d11/d3d11-duplicator.cpp
View File

@@ -19,7 +19,7 @@
#include <map>
static inline bool get_monitor(gs_device_t *device, int monitor_idx,
IDXGIOutput **dxgiOutput)
IDXGIOutput **dxgiOutput)
{
HRESULT hr;
@@ -44,7 +44,7 @@ void gs_duplicator::Start()
throw "Invalid monitor index";
hr = output->QueryInterface(__uuidof(IDXGIOutput1),
(void**)output1.Assign());
(void **)output1.Assign());
if (FAILED(hr))
throw HRError("Failed to query IDXGIOutput1", hr);
@@ -54,11 +54,11 @@ void gs_duplicator::Start()
}
gs_duplicator::gs_duplicator(gs_device_t *device_, int monitor_idx)
: gs_obj (device_, gs_type::gs_duplicator),
texture (nullptr),
idx (monitor_idx),
refs (1),
updated (false)
: gs_obj(device_, gs_type::gs_duplicator),
texture(nullptr),
idx(monitor_idx),
refs(1),
updated(false)
{
Start();
}
@@ -71,7 +71,8 @@ gs_duplicator::~gs_duplicator()
extern "C" {
EXPORT bool device_get_duplicator_monitor_info(gs_device_t *device,
int monitor_idx, struct gs_monitor_info *info)
int monitor_idx,
struct gs_monitor_info *info)
{
DXGI_OUTPUT_DESC desc;
HRESULT hr;
@@ -87,8 +88,10 @@ EXPORT bool device_get_duplicator_monitor_info(gs_device_t *device,
throw HRError("GetDesc failed", hr);
} catch (HRError error) {
blog(LOG_ERROR, "device_get_duplicator_monitor_info: "
"%s (%08lX)", error.str, error.hr);
blog(LOG_ERROR,
"device_get_duplicator_monitor_info: "
"%s (%08lX)",
error.str, error.hr);
return false;
}
@@ -119,7 +122,7 @@ EXPORT bool device_get_duplicator_monitor_info(gs_device_t *device,
return true;
}
static std::map<int, gs_duplicator*> instances;
static std::map<int, gs_duplicator *> instances;
void reset_duplicators(void)
{
@@ -129,7 +132,7 @@ void reset_duplicators(void)
}
EXPORT gs_duplicator_t *device_duplicator_create(gs_device_t *device,
int monitor_idx)
int monitor_idx)
{
gs_duplicator *duplicator = nullptr;
@@ -145,13 +148,12 @@ EXPORT gs_duplicator_t *device_duplicator_create(gs_device_t *device,
instances[monitor_idx] = duplicator;
} catch (const char *error) {
blog(LOG_DEBUG, "device_duplicator_create: %s",
error);
blog(LOG_DEBUG, "device_duplicator_create: %s", error);
return nullptr;
} catch (HRError error) {
blog(LOG_DEBUG, "device_duplicator_create: %s (%08lX)",
error.str, error.hr);
error.str, error.hr);
return nullptr;
}
@@ -171,20 +173,17 @@ static inline void copy_texture(gs_duplicator_t *d, ID3D11Texture2D *tex)
D3D11_TEXTURE2D_DESC desc;
tex->GetDesc(&desc);
if (!d->texture ||
d->texture->width != desc.Width ||
if (!d->texture || d->texture->width != desc.Width ||
d->texture->height != desc.Height) {
delete d->texture;
d->texture = (gs_texture_2d*)gs_texture_create(
desc.Width, desc.Height,
ConvertDXGITextureFormat(desc.Format), 1,
nullptr, 0);
d->texture = (gs_texture_2d *)gs_texture_create(
desc.Width, desc.Height,
ConvertDXGITextureFormat(desc.Format), 1, nullptr, 0);
}
if (!!d->texture)
d->device->context->CopyResource(d->texture->texture,
tex);
d->device->context->CopyResource(d->texture->texture, tex);
}
EXPORT bool gs_duplicator_update_frame(gs_duplicator_t *d)
@@ -209,16 +208,20 @@ EXPORT bool gs_duplicator_update_frame(gs_duplicator_t *d)
return true;
} else if (FAILED(hr)) {
blog(LOG_ERROR, "gs_duplicator_update_frame: Failed to update "
"frame (%08lX)", hr);
blog(LOG_ERROR,
"gs_duplicator_update_frame: Failed to update "
"frame (%08lX)",
hr);
return true;
}
hr = res->QueryInterface(__uuidof(ID3D11Texture2D),
(void**)tex.Assign());
(void **)tex.Assign());
if (FAILED(hr)) {
blog(LOG_ERROR, "gs_duplicator_update_frame: Failed to query "
"ID3D11Texture2D (%08lX)", hr);
blog(LOG_ERROR,
"gs_duplicator_update_frame: Failed to query "
"ID3D11Texture2D (%08lX)",
hr);
d->duplicator->ReleaseFrame();
return true;
}
@@ -233,5 +236,4 @@ EXPORT gs_texture_t *gs_duplicator_get_texture(gs_duplicator_t *duplicator)
{
return duplicator->texture;
}
}

30
libobs-d3d11/d3d11-indexbuffer.cpp
View File

@@ -21,14 +21,14 @@ void gs_index_buffer::InitBuffer()
{
HRESULT hr;
memset(&bd, 0, sizeof(bd));
memset(&bd, 0, sizeof(bd));
memset(&srd, 0, sizeof(srd));
bd.Usage = dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
bd.Usage = dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
bd.CPUAccessFlags = dynamic ? D3D11_CPU_ACCESS_WRITE : 0;
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.ByteWidth = UINT(indexSize * num);
srd.pSysMem = indices.data;
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.ByteWidth = UINT(indexSize * num);
srd.pSysMem = indices.data;
hr = device->device->CreateBuffer(&bd, &srd, indexBuffer.Assign());
if (FAILED(hr))
@@ -36,16 +36,20 @@ void gs_index_buffer::InitBuffer()
}
gs_index_buffer::gs_index_buffer(gs_device_t *device, enum gs_index_type type,
void *indices, size_t num, uint32_t flags)
: gs_obj (device, gs_type::gs_index_buffer),
dynamic ((flags & GS_DYNAMIC) != 0),
type (type),
num (num),
indices (indices)
void *indices, size_t num, uint32_t flags)
: gs_obj(device, gs_type::gs_index_buffer),
dynamic((flags & GS_DYNAMIC) != 0),
type(type),
num(num),
indices(indices)
{
switch (type) {
case GS_UNSIGNED_SHORT: indexSize = 2; break;
case GS_UNSIGNED_LONG: indexSize = 4; break;
case GS_UNSIGNED_SHORT:
indexSize = 2;
break;
case GS_UNSIGNED_LONG:
indexSize = 4;
break;
}
InitBuffer();

120
libobs-d3d11/d3d11-rebuild.cpp
View File

@@ -33,23 +33,23 @@ void gs_index_buffer::Rebuild(ID3D11Device *dev)
void gs_texture_2d::RebuildSharedTextureFallback()
{
td = {};
td.Width = 2;
td.Height = 2;
td.MipLevels = 1;
td.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
td.ArraySize = 1;
td = {};
td.Width = 2;
td.Height = 2;
td.MipLevels = 1;
td.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
td.ArraySize = 1;
td.SampleDesc.Count = 1;
td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
width = td.Width;
height = td.Height;
width = td.Width;
height = td.Height;
dxgiFormat = td.Format;
levels = 1;
levels = 1;
resourceDesc = {};
resourceDesc.Format = td.Format;
resourceDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
resourceDesc.Format = td.Format;
resourceDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
resourceDesc.Texture2D.MipLevels = 1;
isShared = false;
@@ -60,18 +60,19 @@ void gs_texture_2d::Rebuild(ID3D11Device *dev)
HRESULT hr;
if (isShared) {
hr = dev->OpenSharedResource((HANDLE)(uintptr_t)sharedHandle,
__uuidof(ID3D11Texture2D), (void**)&texture);
__uuidof(ID3D11Texture2D),
(void **)&texture);
if (FAILED(hr)) {
blog(LOG_WARNING, "Failed to rebuild shared texture: ",
"0x%08lX", hr);
blog(LOG_WARNING,
"Failed to rebuild shared texture: ", "0x%08lX",
hr);
RebuildSharedTextureFallback();
}
}
if (!isShared) {
hr = dev->CreateTexture2D(&td,
data.size() ? srd.data() : nullptr,
&texture);
hr = dev->CreateTexture2D(
&td, data.size() ? srd.data() : nullptr, &texture);
if (FAILED(hr))
throw HRError("Failed to create 2D texture", hr);
}
@@ -85,7 +86,7 @@ void gs_texture_2d::Rebuild(ID3D11Device *dev)
if (isGDICompatible) {
hr = texture->QueryInterface(__uuidof(IDXGISurface1),
(void**)&gdiSurface);
(void **)&gdiSurface);
if (FAILED(hr))
throw HRError("Failed to create GDI surface", hr);
}
@@ -172,12 +173,13 @@ void gs_sampler_state::Rebuild(ID3D11Device *dev)
void gs_vertex_shader::Rebuild(ID3D11Device *dev)
{
HRESULT hr;
hr = dev->CreateVertexShader(data.data(), data.size(), nullptr, &shader);
hr = dev->CreateVertexShader(data.data(), data.size(), nullptr,
&shader);
if (FAILED(hr))
throw HRError("Failed to create vertex shader", hr);
hr = dev->CreateInputLayout(layoutData.data(), (UINT)layoutData.size(),
data.data(), data.size(), &layout);
data.data(), data.size(), &layout);
if (FAILED(hr))
throw HRError("Failed to create input layout", hr);
@@ -197,9 +199,8 @@ void gs_vertex_shader::Rebuild(ID3D11Device *dev)
void gs_pixel_shader::Rebuild(ID3D11Device *dev)
{
HRESULT hr;
hr = dev->CreatePixelShader(data.data(), data.size(), nullptr,
&shader);
hr = dev->CreatePixelShader(data.data(), data.size(), nullptr, &shader);
if (FAILED(hr))
throw HRError("Failed to create pixel shader", hr);
@@ -245,8 +246,7 @@ void SavedRasterState::Rebuild(ID3D11Device *dev)
throw HRError("Failed to create rasterizer state", hr);
}
const static D3D_FEATURE_LEVEL featureLevels[] =
{
const static D3D_FEATURE_LEVEL featureLevels[] = {
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
@@ -267,34 +267,34 @@ try {
while (obj) {
switch (obj->obj_type) {
case gs_type::gs_vertex_buffer:
((gs_vertex_buffer*)obj)->Release();
((gs_vertex_buffer *)obj)->Release();
break;
case gs_type::gs_index_buffer:
((gs_index_buffer*)obj)->Release();
((gs_index_buffer *)obj)->Release();
break;
case gs_type::gs_texture_2d:
((gs_texture_2d*)obj)->Release();
((gs_texture_2d *)obj)->Release();
break;
case gs_type::gs_zstencil_buffer:
((gs_zstencil_buffer*)obj)->Release();
((gs_zstencil_buffer *)obj)->Release();
break;
case gs_type::gs_stage_surface:
((gs_stage_surface*)obj)->Release();
((gs_stage_surface *)obj)->Release();
break;
case gs_type::gs_sampler_state:
((gs_sampler_state*)obj)->Release();
((gs_sampler_state *)obj)->Release();
break;
case gs_type::gs_vertex_shader:
((gs_vertex_shader*)obj)->Release();
((gs_vertex_shader *)obj)->Release();
break;
case gs_type::gs_pixel_shader:
((gs_pixel_shader*)obj)->Release();
((gs_pixel_shader *)obj)->Release();
break;
case gs_type::gs_duplicator:
((gs_duplicator*)obj)->Release();
((gs_duplicator *)obj)->Release();
break;
case gs_type::gs_swap_chain:
((gs_swap_chain*)obj)->Release();
((gs_swap_chain *)obj)->Release();
break;
}
@@ -320,10 +320,11 @@ try {
InitFactory(adpIdx);
uint32_t createFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
hr = D3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN,
nullptr, createFlags, featureLevels,
sizeof(featureLevels) / sizeof(D3D_FEATURE_LEVEL),
D3D11_SDK_VERSION, &device, nullptr, &context);
hr = D3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr,
createFlags, featureLevels,
sizeof(featureLevels) /
sizeof(D3D_FEATURE_LEVEL),
D3D11_SDK_VERSION, &device, nullptr, &context);
if (FAILED(hr))
throw HRError("Failed to create device", hr);
@@ -333,45 +334,43 @@ try {
while (obj) {
switch (obj->obj_type) {
case gs_type::gs_vertex_buffer:
((gs_vertex_buffer*)obj)->Rebuild();
((gs_vertex_buffer *)obj)->Rebuild();
break;
case gs_type::gs_index_buffer:
((gs_index_buffer*)obj)->Rebuild(dev);
((gs_index_buffer *)obj)->Rebuild(dev);
break;
case gs_type::gs_texture_2d:
{
gs_texture_2d *tex = (gs_texture_2d*)obj;
if (!tex->nv12) {
tex->Rebuild(dev);
} else if (!tex->chroma) {
tex->RebuildNV12_Y(dev);
}
case gs_type::gs_texture_2d: {
gs_texture_2d *tex = (gs_texture_2d *)obj;
if (!tex->nv12) {
tex->Rebuild(dev);
} else if (!tex->chroma) {
tex->RebuildNV12_Y(dev);
}
break;
} break;
case gs_type::gs_zstencil_buffer:
((gs_zstencil_buffer*)obj)->Rebuild(dev);
((gs_zstencil_buffer *)obj)->Rebuild(dev);
break;
case gs_type::gs_stage_surface:
((gs_stage_surface*)obj)->Rebuild(dev);
((gs_stage_surface *)obj)->Rebuild(dev);
break;
case gs_type::gs_sampler_state:
((gs_sampler_state*)obj)->Rebuild(dev);
((gs_sampler_state *)obj)->Rebuild(dev);
break;
case gs_type::gs_vertex_shader:
((gs_vertex_shader*)obj)->Rebuild(dev);
((gs_vertex_shader *)obj)->Rebuild(dev);
break;
case gs_type::gs_pixel_shader:
((gs_pixel_shader*)obj)->Rebuild(dev);
((gs_pixel_shader *)obj)->Rebuild(dev);
break;
case gs_type::gs_duplicator:
try {
((gs_duplicator*)obj)->Start();
((gs_duplicator *)obj)->Start();
} catch (...) {
((gs_duplicator*)obj)->Release();
((gs_duplicator *)obj)->Release();
}
break;
case gs_type::gs_swap_chain:
((gs_swap_chain*)obj)->Rebuild(dev);
((gs_swap_chain *)obj)->Rebuild(dev);
break;
}
@@ -407,6 +406,5 @@ try {
bcrash("Failed to recreate D3D11: %s", error);
} catch (HRError error) {
bcrash("Failed to recreate D3D11: %s (%08lX)",
error.str, error.hr);
bcrash("Failed to recreate D3D11: %s (%08lX)", error.str, error.hr);
}

38
libobs-d3d11/d3d11-samplerstate.cpp
View File

@@ -20,21 +20,26 @@
#include "d3d11-subsystem.hpp"
static inline D3D11_TEXTURE_ADDRESS_MODE ConvertGSAddressMode(
gs_address_mode mode)
static inline D3D11_TEXTURE_ADDRESS_MODE
ConvertGSAddressMode(gs_address_mode mode)
{
switch (mode) {
case GS_ADDRESS_WRAP: return D3D11_TEXTURE_ADDRESS_WRAP;
case GS_ADDRESS_CLAMP: return D3D11_TEXTURE_ADDRESS_CLAMP;
case GS_ADDRESS_MIRROR: return D3D11_TEXTURE_ADDRESS_MIRROR;
case GS_ADDRESS_BORDER: return D3D11_TEXTURE_ADDRESS_BORDER;
case GS_ADDRESS_MIRRORONCE: return D3D11_TEXTURE_ADDRESS_MIRROR_ONCE;
case GS_ADDRESS_WRAP:
return D3D11_TEXTURE_ADDRESS_WRAP;
case GS_ADDRESS_CLAMP:
return D3D11_TEXTURE_ADDRESS_CLAMP;
case GS_ADDRESS_MIRROR:
return D3D11_TEXTURE_ADDRESS_MIRROR;
case GS_ADDRESS_BORDER:
return D3D11_TEXTURE_ADDRESS_BORDER;
case GS_ADDRESS_MIRRORONCE:
return D3D11_TEXTURE_ADDRESS_MIRROR_ONCE;
}
return D3D11_TEXTURE_ADDRESS_WRAP;
}
static inline D3D11_FILTER ConvertGSFilter( gs_sample_filter filter)
static inline D3D11_FILTER ConvertGSFilter(gs_sample_filter filter)
{
switch (filter) {
case GS_FILTER_POINT:
@@ -61,21 +66,20 @@ static inline D3D11_FILTER ConvertGSFilter( gs_sample_filter filter)
}
gs_sampler_state::gs_sampler_state(gs_device_t *device,
const gs_sampler_info *info)
: gs_obj (device, gs_type::gs_sampler_state),
info (*info)
const gs_sampler_info *info)
: gs_obj(device, gs_type::gs_sampler_state), info(*info)
{
HRESULT hr;
vec4 v4;
memset(&sd, 0, sizeof(sd));
sd.AddressU = ConvertGSAddressMode(info->address_u);
sd.AddressV = ConvertGSAddressMode(info->address_v);
sd.AddressW = ConvertGSAddressMode(info->address_w);
sd.AddressU = ConvertGSAddressMode(info->address_u);
sd.AddressV = ConvertGSAddressMode(info->address_v);
sd.AddressW = ConvertGSAddressMode(info->address_w);
sd.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
sd.Filter = ConvertGSFilter(info->filter);
sd.MaxAnisotropy = info->max_anisotropy;
sd.MaxLOD = FLT_MAX;
sd.Filter = ConvertGSFilter(info->filter);
sd.MaxAnisotropy = info->max_anisotropy;
sd.MaxLOD = FLT_MAX;
vec4_from_rgba(&v4, info->border_color);
memcpy(sd.BorderColor, v4.ptr, sizeof(v4));

121
libobs-d3d11/d3d11-shader.cpp
View File

@@ -23,7 +23,7 @@
#include <graphics/matrix4.h>
void gs_vertex_shader::GetBuffersExpected(
const vector<D3D11_INPUT_ELEMENT_DESC> &inputs)
const vector<D3D11_INPUT_ELEMENT_DESC> &inputs)
{
for (size_t i = 0; i < inputs.size(); i++) {
const D3D11_INPUT_ELEMENT_DESC &input = inputs[i];
@@ -39,17 +39,17 @@ void gs_vertex_shader::GetBuffersExpected(
}
gs_vertex_shader::gs_vertex_shader(gs_device_t *device, const char *file,
const char *shaderString)
: gs_shader (device, gs_type::gs_vertex_shader, GS_SHADER_VERTEX),
hasNormals (false),
hasColors (false),
hasTangents (false),
nTexUnits (0)
const char *shaderString)
: gs_shader(device, gs_type::gs_vertex_shader, GS_SHADER_VERTEX),
hasNormals(false),
hasColors(false),
hasTangents(false),
nTexUnits(0)
{
ShaderProcessor processor(device);
ShaderProcessor processor(device);
ComPtr<ID3D10Blob> shaderBlob;
string outputString;
HRESULT hr;
string outputString;
HRESULT hr;
processor.Process(shaderString, file);
processor.BuildString(outputString);
@@ -63,32 +63,33 @@ gs_vertex_shader::gs_vertex_shader(gs_device_t *device, const char *file,
data.resize(shaderBlob->GetBufferSize());
memcpy(&data[0], shaderBlob->GetBufferPointer(), data.size());
hr = device->device->CreateVertexShader(data.data(), data.size(),
NULL, shader.Assign());
hr = device->device->CreateVertexShader(data.data(), data.size(), NULL,
shader.Assign());
if (FAILED(hr))
throw HRError("Failed to create vertex shader", hr);
const UINT layoutSize = (UINT)layoutData.size();
if (layoutSize > 0) {
hr = device->device->CreateInputLayout(layoutData.data(),
(UINT)layoutSize,
data.data(), data.size(), layout.Assign());
(UINT)layoutSize,
data.data(), data.size(),
layout.Assign());
if (FAILED(hr))
throw HRError("Failed to create input layout", hr);
}
viewProj = gs_shader_get_param_by_name(this, "ViewProj");
world = gs_shader_get_param_by_name(this, "World");
world = gs_shader_get_param_by_name(this, "World");
}
gs_pixel_shader::gs_pixel_shader(gs_device_t *device, const char *file,
const char *shaderString)
const char *shaderString)
: gs_shader(device, gs_type::gs_pixel_shader, GS_SHADER_PIXEL)
{
ShaderProcessor processor(device);
ShaderProcessor processor(device);
ComPtr<ID3D10Blob> shaderBlob;
string outputString;
HRESULT hr;
string outputString;
HRESULT hr;
processor.Process(shaderString, file);
processor.BuildString(outputString);
@@ -101,8 +102,8 @@ gs_pixel_shader::gs_pixel_shader(gs_device_t *device, const char *file,
data.resize(shaderBlob->GetBufferSize());
memcpy(&data[0], shaderBlob->GetBufferPointer(), data.size());
hr = device->device->CreatePixelShader(data.data(), data.size(),
NULL, shader.Assign());
hr = device->device->CreatePixelShader(data.data(), data.size(), NULL,
shader.Assign());
if (FAILED(hr))
throw HRError("Failed to create pixel shader", hr);
}
@@ -134,20 +135,28 @@ void gs_shader::BuildConstantBuffer()
{
for (size_t i = 0; i < params.size(); i++) {
gs_shader_param &param = params[i];
size_t size = 0;
size_t size = 0;
switch (param.type) {
case GS_SHADER_PARAM_BOOL:
case GS_SHADER_PARAM_INT:
case GS_SHADER_PARAM_FLOAT: size = sizeof(float); break;
case GS_SHADER_PARAM_FLOAT:
size = sizeof(float);
break;
case GS_SHADER_PARAM_INT2:
case GS_SHADER_PARAM_VEC2: size = sizeof(vec2); break;
case GS_SHADER_PARAM_VEC2:
size = sizeof(vec2);
break;
case GS_SHADER_PARAM_INT3:
case GS_SHADER_PARAM_VEC3: size = sizeof(float)*3; break;
case GS_SHADER_PARAM_VEC3:
size = sizeof(float) * 3;
break;
case GS_SHADER_PARAM_INT4:
case GS_SHADER_PARAM_VEC4: size = sizeof(vec4); break;
case GS_SHADER_PARAM_VEC4:
size = sizeof(vec4);
break;
case GS_SHADER_PARAM_MATRIX4X4:
size = sizeof(float)*4*4;
size = sizeof(float) * 4 * 4;
break;
case GS_SHADER_PARAM_TEXTURE:
case GS_SHADER_PARAM_STRING:
@@ -167,7 +176,7 @@ void gs_shader::BuildConstantBuffer()
constantSize = alignMax;
}
param.pos = constantSize;
param.pos = constantSize;
constantSize += size;
}
@@ -176,13 +185,13 @@ void gs_shader::BuildConstantBuffer()
if (constantSize) {
HRESULT hr;
bd.ByteWidth = (constantSize+15)&0xFFFFFFF0; /* align */
bd.Usage = D3D11_USAGE_DYNAMIC;
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.ByteWidth = (constantSize + 15) & 0xFFFFFFF0; /* align */
bd.Usage = D3D11_USAGE_DYNAMIC;
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
hr = device->device->CreateBuffer(&bd, NULL,
constants.Assign());
constants.Assign());
if (FAILED(hr))
throw HRError("Failed to create constant buffer", hr);
}
@@ -192,7 +201,7 @@ void gs_shader::BuildConstantBuffer()
}
void gs_shader::Compile(const char *shaderString, const char *file,
const char *target, ID3D10Blob **shader)
const char *target, ID3D10Blob **shader)
{
ComPtr<ID3D10Blob> errorsBlob;
HRESULT hr;
@@ -201,9 +210,9 @@ void gs_shader::Compile(const char *shaderString, const char *file,
throw "No shader string specified";
hr = device->d3dCompile(shaderString, strlen(shaderString), file, NULL,
NULL, "main", target,
D3D10_SHADER_OPTIMIZATION_LEVEL1, 0,
shader, errorsBlob.Assign());
NULL, "main", target,
D3D10_SHADER_OPTIMIZATION_LEVEL1, 0, shader,
errorsBlob.Assign());
if (FAILED(hr)) {
if (errorsBlob != NULL && errorsBlob->GetBufferSize())
throw ShaderError(errorsBlob, hr);
@@ -218,18 +227,19 @@ void gs_shader::Compile(const char *shaderString, const char *file,
return;
hr = device->d3dDisassemble((*shader)->GetBufferPointer(),
(*shader)->GetBufferSize(), 0, nullptr, &asmBlob);
(*shader)->GetBufferSize(), 0, nullptr,
&asmBlob);
if (SUCCEEDED(hr) && !!asmBlob && asmBlob->GetBufferSize()) {
blog(LOG_INFO, "=============================================");
blog(LOG_INFO, "Disassembly output for shader '%s':\n%s",
file, asmBlob->GetBufferPointer());
blog(LOG_INFO, "Disassembly output for shader '%s':\n%s", file,
asmBlob->GetBufferPointer());
}
#endif
}
inline void gs_shader::UpdateParam(vector<uint8_t> &constData,
gs_shader_param &param, bool &upload)
gs_shader_param &param, bool &upload)
{
if (param.type != GS_SHADER_PARAM_TEXTURE) {
if (!param.curValue.size())
@@ -238,30 +248,29 @@ inline void gs_shader::UpdateParam(vector<uint8_t> &constData,
/* padding in case the constant needs to start at a new
* register */
if (param.pos > constData.size()) {
uint8_t zero = 0;
uint8_t zero = 0;
constData.insert(constData.end(),
param.pos - constData.size(), zero);
param.pos - constData.size(), zero);
}
constData.insert(constData.end(),
param.curValue.begin(),
param.curValue.end());
constData.insert(constData.end(), param.curValue.begin(),
param.curValue.end());
if (param.changed) {
upload = true;
param.changed = false;
}
} else if (param.curValue.size() == sizeof(gs_texture_t*)) {
} else if (param.curValue.size() == sizeof(gs_texture_t *)) {
gs_texture_t *tex;
memcpy(&tex, param.curValue.data(), sizeof(gs_texture_t*));
memcpy(&tex, param.curValue.data(), sizeof(gs_texture_t *));
device_load_texture(device, tex, param.textureID);
if (param.nextSampler) {
ID3D11SamplerState *state = param.nextSampler->state;
device->context->PSSetSamplers(param.textureID, 1,
&state);
&state);
param.nextSampler = nullptr;
}
}
@@ -270,7 +279,7 @@ inline void gs_shader::UpdateParam(vector<uint8_t> &constData,
void gs_shader::UploadParams()
{
vector<uint8_t> constData;
bool upload = false;
bool upload = false;
constData.reserve(constantSize);
@@ -285,7 +294,7 @@ void gs_shader::UploadParams()
HRESULT hr;
hr = device->context->Map(constants, 0, D3D11_MAP_WRITE_DISCARD,
0, &map);
0, &map);
if (FAILED(hr))
throw HRError("Could not lock constant buffer", hr);
@@ -327,7 +336,7 @@ gs_sparam_t *gs_shader_get_viewproj_matrix(const gs_shader_t *shader)
if (shader->type != GS_SHADER_VERTEX)
return NULL;
return static_cast<const gs_vertex_shader*>(shader)->viewProj;
return static_cast<const gs_vertex_shader *>(shader)->viewProj;
}
gs_sparam_t *gs_shader_get_world_matrix(const gs_shader_t *shader)
@@ -335,11 +344,11 @@ gs_sparam_t *gs_shader_get_world_matrix(const gs_shader_t *shader)
if (shader->type != GS_SHADER_VERTEX)
return NULL;
return static_cast<const gs_vertex_shader*>(shader)->world;
return static_cast<const gs_vertex_shader *>(shader)->world;
}
void gs_shader_get_param_info(const gs_sparam_t *param,
struct gs_shader_param_info *info)
struct gs_shader_param_info *info)
{
if (!param)
return;
@@ -349,7 +358,7 @@ void gs_shader_get_param_info(const gs_sparam_t *param,
}
static inline void shader_setval_inline(gs_shader_param *param,
const void *data, size_t size)
const void *data, size_t size)
{
assert(param);
if (!param)
@@ -410,7 +419,7 @@ void gs_shader_set_vec4(gs_sparam_t *param, const struct vec4 *val)
void gs_shader_set_texture(gs_sparam_t *param, gs_texture_t *val)
{
shader_setval_inline(param, &val, sizeof(gs_texture_t*));
shader_setval_inline(param, &val, sizeof(gs_texture_t *));
}
void gs_shader_set_val(gs_sparam_t *param, const void *val, size_t size)
@@ -422,7 +431,7 @@ void gs_shader_set_default(gs_sparam_t *param)
{
if (param->defaultValue.size())
shader_setval_inline(param, param->defaultValue.data(),
param->defaultValue.size());
param->defaultValue.size());
}
void gs_shader_set_next_sampler(gs_sparam_t *param, gs_samplerstate_t *sampler)

73
libobs-d3d11/d3d11-shaderprocessor.cpp
View File

@@ -21,14 +21,14 @@
#include <sstream>
using namespace std;
static const char *semanticInputNames[] =
{"POSITION", "NORMAL", "COLOR", "TANGENT", "TEXCOORD", "VERTEXID"};
static const char *semanticOutputNames[] =
{"SV_Position", "NORMAL", "COLOR", "TANGENT", "TEXCOORD", "VERTEXID"};
static const char *semanticInputNames[] = {"POSITION", "NORMAL", "COLOR",
"TANGENT", "TEXCOORD", "VERTEXID"};
static const char *semanticOutputNames[] = {
"SV_Position", "NORMAL", "COLOR", "TANGENT", "TEXCOORD", "VERTEXID"};
static const char *ConvertSemanticName(const char *name)
{
const size_t num = sizeof(semanticInputNames) / sizeof(const char*);
const size_t num = sizeof(semanticInputNames) / sizeof(const char *);
for (size_t i = 0; i < num; i++) {
if (strcmp(name, semanticInputNames[i]) == 0)
return semanticOutputNames[i];
@@ -37,8 +37,7 @@ static const char *ConvertSemanticName(const char *name)
throw "Unknown Semantic Name";
}
static void GetSemanticInfo(shader_var *var, const char *&name,
uint32_t &index)
static void GetSemanticInfo(shader_var *var, const char *&name, uint32_t &index)
{
const char *mapping = var->mapping;
const char *indexStr = mapping;
@@ -48,12 +47,12 @@ static void GetSemanticInfo(shader_var *var, const char *&name,
index = (*indexStr) ? strtol(indexStr, NULL, 10) : 0;
string nameStr;
nameStr.assign(mapping, indexStr-mapping);
nameStr.assign(mapping, indexStr - mapping);
name = ConvertSemanticName(nameStr.c_str());
}
static void AddInputLayoutVar(shader_var *var,
vector<D3D11_INPUT_ELEMENT_DESC> &layout)
vector<D3D11_INPUT_ELEMENT_DESC> &layout)
{
D3D11_INPUT_ELEMENT_DESC ied;
const char *semanticName;
@@ -62,25 +61,31 @@ static void AddInputLayoutVar(shader_var *var,
GetSemanticInfo(var, semanticName, semanticIndex);
memset(&ied, 0, sizeof(ied));
ied.SemanticName = semanticName;
ied.SemanticIndex = semanticIndex;
ied.SemanticName = semanticName;
ied.SemanticIndex = semanticIndex;
ied.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
if (strcmp(var->mapping, "COLOR") == 0) {
ied.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
} else if (strcmp(var->mapping, "POSITION") == 0 ||
strcmp(var->mapping, "NORMAL") == 0 ||
strcmp(var->mapping, "TANGENT") == 0) {
} else if (strcmp(var->mapping, "POSITION") == 0 ||
strcmp(var->mapping, "NORMAL") == 0 ||
strcmp(var->mapping, "TANGENT") == 0) {
ied.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
} else if (astrcmp_n(var->mapping, "TEXCOORD", 8) == 0) {
/* type is always a 'float' type */
switch (var->type[5]) {
case 0: ied.Format = DXGI_FORMAT_R32_FLOAT; break;
case '2': ied.Format = DXGI_FORMAT_R32G32_FLOAT; break;
case 0:
ied.Format = DXGI_FORMAT_R32_FLOAT;
break;
case '2':
ied.Format = DXGI_FORMAT_R32G32_FLOAT;
break;
case '3':
case '4': ied.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; break;
case '4':
ied.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
break;
}
}
@@ -88,7 +93,7 @@ static void AddInputLayoutVar(shader_var *var,
}
static inline bool SetSlot(vector<D3D11_INPUT_ELEMENT_DESC> &layout,
const char *name, uint32_t index, uint32_t &slotIdx)
const char *name, uint32_t index, uint32_t &slotIdx)
{
for (size_t i = 0; i < layout.size(); i++) {
D3D11_INPUT_ELEMENT_DESC &input = layout[i];
@@ -103,22 +108,22 @@ static inline bool SetSlot(vector<D3D11_INPUT_ELEMENT_DESC> &layout,
}
static void BuildInputLayoutFromVars(shader_parser *parser, darray *vars,
vector<D3D11_INPUT_ELEMENT_DESC> &layout)
vector<D3D11_INPUT_ELEMENT_DESC> &layout)
{
shader_var *array = (shader_var*)vars->array;
shader_var *array = (shader_var *)vars->array;
for (size_t i = 0; i < vars->num; i++) {
shader_var *var = array+i;
shader_var *var = array + i;
if (var->mapping) {
if (strcmp(var->mapping, "VERTEXID") != 0)
AddInputLayoutVar(var, layout);
} else {
shader_struct *st = shader_parser_getstruct(parser,
var->type);
shader_struct *st =
shader_parser_getstruct(parser, var->type);
if (st)
BuildInputLayoutFromVars(parser, &st->vars.da,
layout);
layout);
}
}
@@ -134,11 +139,11 @@ static void BuildInputLayoutFromVars(shader_parser *parser, darray *vars,
SetSlot(layout, "TANGENT", 0, slot);
uint32_t index = 0;
while (SetSlot(layout, "TEXCOORD", index++, slot));
while (SetSlot(layout, "TEXCOORD", index++, slot))
;
}
void ShaderProcessor::BuildInputLayout(
vector<D3D11_INPUT_ELEMENT_DESC> &layout)
void ShaderProcessor::BuildInputLayout(vector<D3D11_INPUT_ELEMENT_DESC> &layout)
{
shader_func *func = shader_parser_getfunc(&parser, "main");
if (!func)
@@ -148,11 +153,11 @@ void ShaderProcessor::BuildInputLayout(
}
gs_shader_param::gs_shader_param(shader_var &var, uint32_t &texCounter)
: name (var.name),
type (get_shader_param_type(var.type)),
textureID (texCounter),
arrayCount (var.array_count),
changed (false)
: name(var.name),
type(get_shader_param_type(var.type)),
textureID(texCounter),
arrayCount(var.array_count),
changed(false)
{
defaultValue.resize(var.default_val.num);
memcpy(defaultValue.data(), var.default_val.array, var.default_val.num);
@@ -164,7 +169,7 @@ gs_shader_param::gs_shader_param(shader_var &var, uint32_t &texCounter)
}
static inline void AddParam(shader_var &var, vector<gs_shader_param> &params,
uint32_t &texCounter)
uint32_t &texCounter)
{
if (var.var_type != SHADER_VAR_UNIFORM ||
strcmp(var.type, "sampler") == 0)
@@ -182,7 +187,7 @@ void ShaderProcessor::BuildParams(vector<gs_shader_param> &params)
}
static inline void AddSampler(gs_device_t *device, shader_sampler &sampler,
vector<unique_ptr<ShaderSampler>> &samplers)
vector<unique_ptr<ShaderSampler>> &samplers)
{
gs_sampler_info si;
shader_sampler_convert(&sampler, &si);

8
libobs-d3d11/d3d11-shaderprocessor.hpp
View File

@@ -20,8 +20,8 @@
#include <graphics/shader-parser.h>
struct ShaderParser : shader_parser {
inline ShaderParser() {shader_parser_init(this);}
inline ~ShaderParser() {shader_parser_free(this);}
inline ShaderParser() { shader_parser_init(this); }
inline ~ShaderParser() { shader_parser_free(this); }
};
struct ShaderProcessor {
@@ -34,7 +34,5 @@ struct ShaderProcessor {
void BuildString(string &outputString);
void Process(const char *shader_string, const char *file);
inline ShaderProcessor(gs_device_t *device) : device(device)
{
}
inline ShaderProcessor(gs_device_t *device) : device(device) {}
};

52
libobs-d3d11/d3d11-stagesurf.cpp
View File

@@ -18,24 +18,24 @@
#include "d3d11-subsystem.hpp"
gs_stage_surface::gs_stage_surface(gs_device_t *device, uint32_t width,
uint32_t height, gs_color_format colorFormat)
: gs_obj (device, gs_type::gs_stage_surface),
width (width),
height (height),
format (colorFormat),
dxgiFormat (ConvertGSTextureFormat(colorFormat))
uint32_t height, gs_color_format colorFormat)
: gs_obj(device, gs_type::gs_stage_surface),
width(width),
height(height),
format(colorFormat),
dxgiFormat(ConvertGSTextureFormat(colorFormat))
{
HRESULT hr;
memset(&td, 0, sizeof(td));
td.Width = width;
td.Height = height;
td.MipLevels = 1;
td.ArraySize = 1;
td.Format = dxgiFormat;
td.Width = width;
td.Height = height;
td.MipLevels = 1;
td.ArraySize = 1;
td.Format = dxgiFormat;
td.SampleDesc.Count = 1;
td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
td.Usage = D3D11_USAGE_STAGING;
td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
td.Usage = D3D11_USAGE_STAGING;
hr = device->device->CreateTexture2D(&td, NULL, texture.Assign());
if (FAILED(hr))
@@ -43,24 +43,24 @@ gs_stage_surface::gs_stage_surface(gs_device_t *device, uint32_t width,
}
gs_stage_surface::gs_stage_surface(gs_device_t *device, uint32_t width,
uint32_t height)
: gs_obj (device, gs_type::gs_stage_surface),
width (width),
height (height),
format (GS_UNKNOWN),
dxgiFormat (DXGI_FORMAT_NV12)
uint32_t height)
: gs_obj(device, gs_type::gs_stage_surface),
width(width),
height(height),
format(GS_UNKNOWN),
dxgiFormat(DXGI_FORMAT_NV12)
{
HRESULT hr;
memset(&td, 0, sizeof(td));
td.Width = width;
td.Height = height;
td.MipLevels = 1;
td.ArraySize = 1;
td.Format = dxgiFormat;
td.Width = width;
td.Height = height;
td.MipLevels = 1;
td.ArraySize = 1;
td.Format = dxgiFormat;
td.SampleDesc.Count = 1;
td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
td.Usage = D3D11_USAGE_STAGING;
td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
td.Usage = D3D11_USAGE_STAGING;
hr = device->device->CreateTexture2D(&td, NULL, texture.Assign());
if (FAILED(hr))

846
libobs-d3d11/d3d11-subsystem.cpp
View File

File diff suppressed because it is too large Load Diff

647
libobs-d3d11/d3d11-subsystem.hpp
View File

@@ -62,25 +62,44 @@ static inline uint32_t GetWinVer()
static inline DXGI_FORMAT ConvertGSTextureFormat(gs_color_format format)
{
switch (format) {
case GS_UNKNOWN: return DXGI_FORMAT_UNKNOWN;
case GS_A8: return DXGI_FORMAT_A8_UNORM;
case GS_R8: return DXGI_FORMAT_R8_UNORM;
case GS_RGBA: return DXGI_FORMAT_R8G8B8A8_UNORM;
case GS_BGRX: return DXGI_FORMAT_B8G8R8X8_UNORM;
case GS_BGRA: return DXGI_FORMAT_B8G8R8A8_UNORM;
case GS_R10G10B10A2: return DXGI_FORMAT_R10G10B10A2_UNORM;
case GS_RGBA16: return DXGI_FORMAT_R16G16B16A16_UNORM;
case GS_R16: return DXGI_FORMAT_R16_UNORM;
case GS_RGBA16F: return DXGI_FORMAT_R16G16B16A16_FLOAT;
case GS_RGBA32F: return DXGI_FORMAT_R32G32B32A32_FLOAT;
case GS_RG16F: return DXGI_FORMAT_R16G16_FLOAT;
case GS_RG32F: return DXGI_FORMAT_R32G32_FLOAT;
case GS_R16F: return DXGI_FORMAT_R16_FLOAT;
case GS_R32F: return DXGI_FORMAT_R32_FLOAT;
case GS_DXT1: return DXGI_FORMAT_BC1_UNORM;
case GS_DXT3: return DXGI_FORMAT_BC2_UNORM;
case GS_DXT5: return DXGI_FORMAT_BC3_UNORM;
case GS_R8G8: return DXGI_FORMAT_R8G8_UNORM;
case GS_UNKNOWN:
return DXGI_FORMAT_UNKNOWN;
case GS_A8:
return DXGI_FORMAT_A8_UNORM;
case GS_R8:
return DXGI_FORMAT_R8_UNORM;
case GS_RGBA:
return DXGI_FORMAT_R8G8B8A8_UNORM;
case GS_BGRX:
return DXGI_FORMAT_B8G8R8X8_UNORM;
case GS_BGRA:
return DXGI_FORMAT_B8G8R8A8_UNORM;
case GS_R10G10B10A2:
return DXGI_FORMAT_R10G10B10A2_UNORM;
case GS_RGBA16:
return DXGI_FORMAT_R16G16B16A16_UNORM;
case GS_R16:
return DXGI_FORMAT_R16_UNORM;
case GS_RGBA16F:
return DXGI_FORMAT_R16G16B16A16_FLOAT;
case GS_RGBA32F:
return DXGI_FORMAT_R32G32B32A32_FLOAT;
case GS_RG16F:
return DXGI_FORMAT_R16G16_FLOAT;
case GS_RG32F:
return DXGI_FORMAT_R32G32_FLOAT;
case GS_R16F:
return DXGI_FORMAT_R16_FLOAT;
case GS_R32F:
return DXGI_FORMAT_R32_FLOAT;
case GS_DXT1:
return DXGI_FORMAT_BC1_UNORM;
case GS_DXT3:
return DXGI_FORMAT_BC2_UNORM;
case GS_DXT5:
return DXGI_FORMAT_BC3_UNORM;
case GS_R8G8:
return DXGI_FORMAT_R8G8_UNORM;
}
return DXGI_FORMAT_UNKNOWN;
@@ -89,24 +108,42 @@ static inline DXGI_FORMAT ConvertGSTextureFormat(gs_color_format format)
static inline gs_color_format ConvertDXGITextureFormat(DXGI_FORMAT format)
{
switch ((unsigned long)format) {
case DXGI_FORMAT_A8_UNORM: return GS_A8;
case DXGI_FORMAT_R8_UNORM: return GS_R8;
case DXGI_FORMAT_R8G8_UNORM: return GS_R8G8;
case DXGI_FORMAT_R8G8B8A8_UNORM: return GS_RGBA;
case DXGI_FORMAT_B8G8R8X8_UNORM: return GS_BGRX;
case DXGI_FORMAT_B8G8R8A8_UNORM: return GS_BGRA;
case DXGI_FORMAT_R10G10B10A2_UNORM: return GS_R10G10B10A2;
case DXGI_FORMAT_R16G16B16A16_UNORM: return GS_RGBA16;
case DXGI_FORMAT_R16_UNORM: return GS_R16;
case DXGI_FORMAT_R16G16B16A16_FLOAT: return GS_RGBA16F;
case DXGI_FORMAT_R32G32B32A32_FLOAT: return GS_RGBA32F;
case DXGI_FORMAT_R16G16_FLOAT: return GS_RG16F;
case DXGI_FORMAT_R32G32_FLOAT: return GS_RG32F;
case DXGI_FORMAT_R16_FLOAT: return GS_R16F;
case DXGI_FORMAT_R32_FLOAT: return GS_R32F;
case DXGI_FORMAT_BC1_UNORM: return GS_DXT1;
case DXGI_FORMAT_BC2_UNORM: return GS_DXT3;
case DXGI_FORMAT_BC3_UNORM: return GS_DXT5;
case DXGI_FORMAT_A8_UNORM:
return GS_A8;
case DXGI_FORMAT_R8_UNORM:
return GS_R8;
case DXGI_FORMAT_R8G8_UNORM:
return GS_R8G8;
case DXGI_FORMAT_R8G8B8A8_UNORM:
return GS_RGBA;
case DXGI_FORMAT_B8G8R8X8_UNORM:
return GS_BGRX;
case DXGI_FORMAT_B8G8R8A8_UNORM:
return GS_BGRA;
case DXGI_FORMAT_R10G10B10A2_UNORM:
return GS_R10G10B10A2;
case DXGI_FORMAT_R16G16B16A16_UNORM:
return GS_RGBA16;
case DXGI_FORMAT_R16_UNORM:
return GS_R16;
case DXGI_FORMAT_R16G16B16A16_FLOAT:
return GS_RGBA16F;
case DXGI_FORMAT_R32G32B32A32_FLOAT:
return GS_RGBA32F;
case DXGI_FORMAT_R16G16_FLOAT:
return GS_RG16F;
case DXGI_FORMAT_R32G32_FLOAT:
return GS_RG32F;
case DXGI_FORMAT_R16_FLOAT:
return GS_R16F;
case DXGI_FORMAT_R32_FLOAT:
return GS_R32F;
case DXGI_FORMAT_BC1_UNORM:
return GS_DXT1;
case DXGI_FORMAT_BC2_UNORM:
return GS_DXT3;
case DXGI_FORMAT_BC3_UNORM:
return GS_DXT5;
}
return GS_UNKNOWN;
@@ -115,11 +152,16 @@ static inline gs_color_format ConvertDXGITextureFormat(DXGI_FORMAT format)
static inline DXGI_FORMAT ConvertGSZStencilFormat(gs_zstencil_format format)
{
switch (format) {
case GS_ZS_NONE: return DXGI_FORMAT_UNKNOWN;
case GS_Z16: return DXGI_FORMAT_D16_UNORM;
case GS_Z24_S8: return DXGI_FORMAT_D24_UNORM_S8_UINT;
case GS_Z32F: return DXGI_FORMAT_D32_FLOAT;
case GS_Z32F_S8X24: return DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
case GS_ZS_NONE:
return DXGI_FORMAT_UNKNOWN;
case GS_Z16:
return DXGI_FORMAT_D16_UNORM;
case GS_Z24_S8:
return DXGI_FORMAT_D24_UNORM_S8_UINT;
case GS_Z32F:
return DXGI_FORMAT_D32_FLOAT;
case GS_Z32F_S8X24:
return DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
}
return DXGI_FORMAT_UNKNOWN;
@@ -128,14 +170,22 @@ static inline DXGI_FORMAT ConvertGSZStencilFormat(gs_zstencil_format format)
static inline D3D11_COMPARISON_FUNC ConvertGSDepthTest(gs_depth_test test)
{
switch (test) {
case GS_NEVER: return D3D11_COMPARISON_NEVER;
case GS_LESS: return D3D11_COMPARISON_LESS;
case GS_LEQUAL: return D3D11_COMPARISON_LESS_EQUAL;
case GS_EQUAL: return D3D11_COMPARISON_EQUAL;
case GS_GEQUAL: return D3D11_COMPARISON_GREATER_EQUAL;
case GS_GREATER: return D3D11_COMPARISON_GREATER;
case GS_NOTEQUAL: return D3D11_COMPARISON_NOT_EQUAL;
case GS_ALWAYS: return D3D11_COMPARISON_ALWAYS;
case GS_NEVER:
return D3D11_COMPARISON_NEVER;
case GS_LESS:
return D3D11_COMPARISON_LESS;
case GS_LEQUAL:
return D3D11_COMPARISON_LESS_EQUAL;
case GS_EQUAL:
return D3D11_COMPARISON_EQUAL;
case GS_GEQUAL:
return D3D11_COMPARISON_GREATER_EQUAL;
case GS_GREATER:
return D3D11_COMPARISON_GREATER;
case GS_NOTEQUAL:
return D3D11_COMPARISON_NOT_EQUAL;
case GS_ALWAYS:
return D3D11_COMPARISON_ALWAYS;
}
return D3D11_COMPARISON_NEVER;
@@ -144,12 +194,18 @@ static inline D3D11_COMPARISON_FUNC ConvertGSDepthTest(gs_depth_test test)
static inline D3D11_STENCIL_OP ConvertGSStencilOp(gs_stencil_op_type op)
{
switch (op) {
case GS_KEEP: return D3D11_STENCIL_OP_KEEP;
case GS_ZERO: return D3D11_STENCIL_OP_ZERO;
case GS_REPLACE: return D3D11_STENCIL_OP_REPLACE;
case GS_INCR: return D3D11_STENCIL_OP_INCR;
case GS_DECR: return D3D11_STENCIL_OP_DECR;
case GS_INVERT: return D3D11_STENCIL_OP_INVERT;
case GS_KEEP:
return D3D11_STENCIL_OP_KEEP;
case GS_ZERO:
return D3D11_STENCIL_OP_ZERO;
case GS_REPLACE:
return D3D11_STENCIL_OP_REPLACE;
case GS_INCR:
return D3D11_STENCIL_OP_INCR;
case GS_DECR:
return D3D11_STENCIL_OP_DECR;
case GS_INVERT:
return D3D11_STENCIL_OP_INVERT;
}
return D3D11_STENCIL_OP_KEEP;
@@ -158,17 +214,28 @@ static inline D3D11_STENCIL_OP ConvertGSStencilOp(gs_stencil_op_type op)
static inline D3D11_BLEND ConvertGSBlendType(gs_blend_type type)
{
switch (type) {
case GS_BLEND_ZERO: return D3D11_BLEND_ZERO;
case GS_BLEND_ONE: return D3D11_BLEND_ONE;
case GS_BLEND_SRCCOLOR: return D3D11_BLEND_SRC_COLOR;
case GS_BLEND_INVSRCCOLOR: return D3D11_BLEND_INV_SRC_COLOR;
case GS_BLEND_SRCALPHA: return D3D11_BLEND_SRC_ALPHA;
case GS_BLEND_INVSRCALPHA: return D3D11_BLEND_INV_SRC_ALPHA;
case GS_BLEND_DSTCOLOR: return D3D11_BLEND_DEST_COLOR;
case GS_BLEND_INVDSTCOLOR: return D3D11_BLEND_INV_DEST_COLOR;
case GS_BLEND_DSTALPHA: return D3D11_BLEND_DEST_ALPHA;
case GS_BLEND_INVDSTALPHA: return D3D11_BLEND_INV_DEST_ALPHA;
case GS_BLEND_SRCALPHASAT: return D3D11_BLEND_SRC_ALPHA_SAT;
case GS_BLEND_ZERO:
return D3D11_BLEND_ZERO;
case GS_BLEND_ONE:
return D3D11_BLEND_ONE;
case GS_BLEND_SRCCOLOR:
return D3D11_BLEND_SRC_COLOR;
case GS_BLEND_INVSRCCOLOR:
return D3D11_BLEND_INV_SRC_COLOR;
case GS_BLEND_SRCALPHA:
return D3D11_BLEND_SRC_ALPHA;
case GS_BLEND_INVSRCALPHA:
return D3D11_BLEND_INV_SRC_ALPHA;
case GS_BLEND_DSTCOLOR:
return D3D11_BLEND_DEST_COLOR;
case GS_BLEND_INVDSTCOLOR:
return D3D11_BLEND_INV_DEST_COLOR;
case GS_BLEND_DSTALPHA:
return D3D11_BLEND_DEST_ALPHA;
case GS_BLEND_INVDSTALPHA:
return D3D11_BLEND_INV_DEST_ALPHA;
case GS_BLEND_SRCALPHASAT:
return D3D11_BLEND_SRC_ALPHA_SAT;
}
return D3D11_BLEND_ONE;
@@ -177,9 +244,12 @@ static inline D3D11_BLEND ConvertGSBlendType(gs_blend_type type)
static inline D3D11_CULL_MODE ConvertGSCullMode(gs_cull_mode mode)
{
switch (mode) {
case GS_BACK: return D3D11_CULL_BACK;
case GS_FRONT: return D3D11_CULL_FRONT;
case GS_NEITHER: return D3D11_CULL_NONE;
case GS_BACK:
return D3D11_CULL_BACK;
case GS_FRONT:
return D3D11_CULL_FRONT;
case GS_NEITHER:
return D3D11_CULL_NONE;
}
return D3D11_CULL_BACK;
@@ -188,11 +258,16 @@ static inline D3D11_CULL_MODE ConvertGSCullMode(gs_cull_mode mode)
static inline D3D11_PRIMITIVE_TOPOLOGY ConvertGSTopology(gs_draw_mode mode)
{
switch (mode) {
case GS_POINTS: return D3D11_PRIMITIVE_TOPOLOGY_POINTLIST;
case GS_LINES: return D3D11_PRIMITIVE_TOPOLOGY_LINELIST;
case GS_LINESTRIP: return D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP;
case GS_TRIS: return D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
case GS_TRISTRIP: return D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
case GS_POINTS:
return D3D11_PRIMITIVE_TOPOLOGY_POINTLIST;
case GS_LINES:
return D3D11_PRIMITIVE_TOPOLOGY_LINELIST;
case GS_LINESTRIP:
return D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP;
case GS_TRIS:
return D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
case GS_TRISTRIP:
return D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
}
return D3D11_PRIMITIVE_TOPOLOGY_POINTLIST;
@@ -203,7 +278,7 @@ struct VBDataPtr {
gs_vb_data *data;
inline VBDataPtr(gs_vb_data *data) : data(data) {}
inline ~VBDataPtr() {gs_vbdata_destroy(data);}
inline ~VBDataPtr() { gs_vbdata_destroy(data); }
};
enum class gs_type {
@@ -225,38 +300,32 @@ struct gs_obj {
gs_obj *next;
gs_obj **prev_next;
inline gs_obj() :
device(nullptr),
next(nullptr),
prev_next(nullptr)
{}
inline gs_obj() : device(nullptr), next(nullptr), prev_next(nullptr) {}
gs_obj(gs_device_t *device, gs_type type);
virtual ~gs_obj();
};
struct gs_vertex_buffer : gs_obj {
ComPtr<ID3D11Buffer> vertexBuffer;
ComPtr<ID3D11Buffer> normalBuffer;
ComPtr<ID3D11Buffer> colorBuffer;
ComPtr<ID3D11Buffer> tangentBuffer;
ComPtr<ID3D11Buffer> vertexBuffer;
ComPtr<ID3D11Buffer> normalBuffer;
ComPtr<ID3D11Buffer> colorBuffer;
ComPtr<ID3D11Buffer> tangentBuffer;
vector<ComPtr<ID3D11Buffer>> uvBuffers;
bool dynamic;
VBDataPtr vbd;
size_t numVerts;
bool dynamic;
VBDataPtr vbd;
size_t numVerts;
vector<size_t> uvSizes;
void FlushBuffer(ID3D11Buffer *buffer, void *array,
size_t elementSize);
void FlushBuffer(ID3D11Buffer *buffer, void *array, size_t elementSize);
void MakeBufferList(gs_vertex_shader *shader,
vector<ID3D11Buffer*> &buffers,
vector<uint32_t> &strides);
vector<ID3D11Buffer *> &buffers,
vector<uint32_t> &strides);
void InitBuffer(const size_t elementSize,
const size_t numVerts, void *array,
ID3D11Buffer **buffer);
void InitBuffer(const size_t elementSize, const size_t numVerts,
void *array, ID3D11Buffer **buffer);
void BuildBuffers();
@@ -272,7 +341,7 @@ struct gs_vertex_buffer : gs_obj {
void Rebuild();
gs_vertex_buffer(gs_device_t *device, struct gs_vb_data *data,
uint32_t flags);
uint32_t flags);
};
/* exception-safe RAII wrapper for index buffer data (NOTE: not copy-safe) */
@@ -280,16 +349,16 @@ struct DataPtr {
void *data;
inline DataPtr(void *data) : data(data) {}
inline ~DataPtr() {bfree(data);}
inline ~DataPtr() { bfree(data); }
};
struct gs_index_buffer : gs_obj {
ComPtr<ID3D11Buffer> indexBuffer;
bool dynamic;
gs_index_type type;
size_t indexSize;
size_t num;
DataPtr indices;
bool dynamic;
gs_index_type type;
size_t indexSize;
size_t num;
DataPtr indices;
D3D11_BUFFER_DESC bd = {};
D3D11_SUBRESOURCE_DATA srd = {};
@@ -298,7 +367,7 @@ struct gs_index_buffer : gs_obj {
void Rebuild(ID3D11Device *dev);
inline void Release() {indexBuffer.Release();}
inline void Release() { indexBuffer.Release(); }
gs_index_buffer(gs_device_t *device, enum gs_index_type type,
void *indices, size_t num, uint32_t flags);
@@ -306,7 +375,7 @@ struct gs_index_buffer : gs_obj {
struct gs_texture : gs_obj {
gs_texture_type type;
uint32_t levels;
uint32_t levels;
gs_color_format format;
ComPtr<ID3D11ShaderResourceView> shaderRes;
@@ -315,50 +384,47 @@ struct gs_texture : gs_obj {
void Rebuild(ID3D11Device *dev);
inline gs_texture(gs_texture_type type, uint32_t levels,
gs_color_format format)
: type (type),
levels (levels),
format (format)
gs_color_format format)
: type(type), levels(levels), format(format)
{
}
inline gs_texture(gs_device *device, gs_type obj_type,
gs_texture_type type)
: gs_obj (device, obj_type),
type (type)
gs_texture_type type)
: gs_obj(device, obj_type), type(type)
{
}
inline gs_texture(gs_device *device, gs_type obj_type,
gs_texture_type type,
uint32_t levels, gs_color_format format)
: gs_obj (device, obj_type),
type (type),
levels (levels),
format (format)
gs_texture_type type, uint32_t levels,
gs_color_format format)
: gs_obj(device, obj_type),
type(type),
levels(levels),
format(format)
{
}
};
struct gs_texture_2d : gs_texture {
ComPtr<ID3D11Texture2D> texture;
ComPtr<ID3D11RenderTargetView> renderTarget[6];
ComPtr<IDXGISurface1> gdiSurface;
ComPtr<ID3D11Texture2D> texture;
ComPtr<ID3D11RenderTargetView> renderTarget[6];
ComPtr<IDXGISurface1> gdiSurface;
uint32_t width = 0, height = 0;
uint32_t flags = 0;
DXGI_FORMAT dxgiFormat = DXGI_FORMAT_UNKNOWN;
bool isRenderTarget = false;
bool isGDICompatible = false;
bool isDynamic = false;
bool isShared = false;
bool genMipmaps = false;
uint32_t sharedHandle = GS_INVALID_HANDLE;
uint32_t width = 0, height = 0;
uint32_t flags = 0;
DXGI_FORMAT dxgiFormat = DXGI_FORMAT_UNKNOWN;
bool isRenderTarget = false;
bool isGDICompatible = false;
bool isDynamic = false;
bool isShared = false;
bool genMipmaps = false;
uint32_t sharedHandle = GS_INVALID_HANDLE;
gs_texture_2d *pairedNV12texture = nullptr;
bool nv12 = false;
bool chroma = false;
bool acquired = false;
gs_texture_2d *pairedNV12texture = nullptr;
bool nv12 = false;
bool chroma = false;
bool acquired = false;
vector<vector<uint8_t>> data;
vector<D3D11_SUBRESOURCE_DATA> srd;
@@ -385,29 +451,26 @@ struct gs_texture_2d : gs_texture {
shaderRes.Release();
}
inline gs_texture_2d()
: gs_texture (GS_TEXTURE_2D, 0, GS_UNKNOWN)
{
}
inline gs_texture_2d() : gs_texture(GS_TEXTURE_2D, 0, GS_UNKNOWN) {}
gs_texture_2d(gs_device_t *device, uint32_t width, uint32_t height,
gs_color_format colorFormat, uint32_t levels,
const uint8_t **data, uint32_t flags,
gs_texture_type type, bool gdiCompatible,
bool nv12 = false);
gs_color_format colorFormat, uint32_t levels,
const uint8_t **data, uint32_t flags,
gs_texture_type type, bool gdiCompatible,
bool nv12 = false);
gs_texture_2d(gs_device_t *device, ID3D11Texture2D *nv12,
uint32_t flags);
uint32_t flags);
gs_texture_2d(gs_device_t *device, uint32_t handle);
};
struct gs_zstencil_buffer : gs_obj {
ComPtr<ID3D11Texture2D> texture;
ComPtr<ID3D11Texture2D> texture;
ComPtr<ID3D11DepthStencilView> view;
uint32_t width, height;
uint32_t width, height;
gs_zstencil_format format;
DXGI_FORMAT dxgiFormat;
DXGI_FORMAT dxgiFormat;
D3D11_TEXTURE2D_DESC td = {};
D3D11_DEPTH_STENCIL_VIEW_DESC dsvd = {};
@@ -423,62 +486,57 @@ struct gs_zstencil_buffer : gs_obj {
}
inline gs_zstencil_buffer()
: width (0),
height (0),
dxgiFormat (DXGI_FORMAT_UNKNOWN)
: width(0), height(0), dxgiFormat(DXGI_FORMAT_UNKNOWN)
{
}
gs_zstencil_buffer(gs_device_t *device, uint32_t width, uint32_t height,
gs_zstencil_format format);
gs_zstencil_format format);
};
struct gs_stage_surface : gs_obj {
ComPtr<ID3D11Texture2D> texture;
D3D11_TEXTURE2D_DESC td = {};
uint32_t width, height;
uint32_t width, height;
gs_color_format format;
DXGI_FORMAT dxgiFormat;
DXGI_FORMAT dxgiFormat;
void Rebuild(ID3D11Device *dev);
inline void Release()
{
texture.Release();
}
inline void Release() { texture.Release(); }
gs_stage_surface(gs_device_t *device, uint32_t width, uint32_t height,
gs_color_format colorFormat);
gs_color_format colorFormat);
gs_stage_surface(gs_device_t *device, uint32_t width, uint32_t height);
};
struct gs_sampler_state : gs_obj {
ComPtr<ID3D11SamplerState> state;
D3D11_SAMPLER_DESC sd = {};
gs_sampler_info info;
D3D11_SAMPLER_DESC sd = {};
gs_sampler_info info;
void Rebuild(ID3D11Device *dev);
inline void Release() {state.Release();}
inline void Release() { state.Release(); }
gs_sampler_state(gs_device_t *device, const gs_sampler_info *info);
};
struct gs_shader_param {
string name;
gs_shader_param_type type;
string name;
gs_shader_param_type type;
uint32_t textureID;
struct gs_sampler_state *nextSampler = nullptr;
uint32_t textureID;
struct gs_sampler_state *nextSampler = nullptr;
int arrayCount;
int arrayCount;
size_t pos;
size_t pos;
vector<uint8_t> curValue;
vector<uint8_t> defaultValue;
bool changed;
vector<uint8_t> curValue;
vector<uint8_t> defaultValue;
bool changed;
gs_shader_param(shader_var &var, uint32_t &texCounter);
};
@@ -488,34 +546,31 @@ struct ShaderError {
HRESULT hr;
inline ShaderError(const ComPtr<ID3D10Blob> &errors, HRESULT hr)
: errors (errors),
hr (hr)
: errors(errors), hr(hr)
{
}
};
struct gs_shader : gs_obj {
gs_shader_type type;
gs_shader_type type;
vector<gs_shader_param> params;
ComPtr<ID3D11Buffer> constants;
size_t constantSize;
ComPtr<ID3D11Buffer> constants;
size_t constantSize;
D3D11_BUFFER_DESC bd = {};
vector<uint8_t> data;
D3D11_BUFFER_DESC bd = {};
vector<uint8_t> data;
inline void UpdateParam(vector<uint8_t> &constData,
gs_shader_param &param, bool &upload);
gs_shader_param &param, bool &upload);
void UploadParams();
void BuildConstantBuffer();
void Compile(const char *shaderStr, const char *file,
const char *target, ID3D10Blob **shader);
const char *target, ID3D10Blob **shader);
inline gs_shader(gs_device_t *device, gs_type obj_type,
gs_shader_type type)
: gs_obj (device, obj_type),
type (type),
constantSize (0)
gs_shader_type type)
: gs_obj(device, obj_type), type(type), constantSize(0)
{
}
@@ -523,28 +578,27 @@ struct gs_shader : gs_obj {
};
struct ShaderSampler {
string name;
string name;
gs_sampler_state sampler;
inline ShaderSampler(const char *name, gs_device_t *device,
gs_sampler_info *info)
: name (name),
sampler (device, info)
gs_sampler_info *info)
: name(name), sampler(device, info)
{
}
};
struct gs_vertex_shader : gs_shader {
ComPtr<ID3D11VertexShader> shader;
ComPtr<ID3D11InputLayout> layout;
ComPtr<ID3D11InputLayout> layout;
gs_shader_param *world, *viewProj;
vector<D3D11_INPUT_ELEMENT_DESC> layoutData;
bool hasNormals;
bool hasColors;
bool hasTangents;
bool hasNormals;
bool hasColors;
bool hasTangents;
uint32_t nTexUnits;
void Rebuild(ID3D11Device *dev);
@@ -558,10 +612,13 @@ struct gs_vertex_shader : gs_shader {
inline uint32_t NumBuffersExpected() const
{
uint32_t count = nTexUnits+1;
if (hasNormals) count++;
if (hasColors) count++;
if (hasTangents) count++;
uint32_t count = nTexUnits + 1;
if (hasNormals)
count++;
if (hasColors)
count++;
if (hasTangents)
count++;
return count;
}
@@ -569,7 +626,7 @@ struct gs_vertex_shader : gs_shader {
void GetBuffersExpected(const vector<D3D11_INPUT_ELEMENT_DESC> &inputs);
gs_vertex_shader(gs_device_t *device, const char *file,
const char *shaderString);
const char *shaderString);
};
struct gs_duplicator : gs_obj {
@@ -581,10 +638,7 @@ struct gs_duplicator : gs_obj {
void Start();
inline void Release()
{
duplicator.Release();
}
inline void Release() { duplicator.Release(); }
gs_duplicator(gs_device_t *device, int monitor_idx);
~gs_duplicator();
@@ -616,14 +670,14 @@ struct gs_pixel_shader : gs_shader {
};
struct gs_swap_chain : gs_obj {
uint32_t numBuffers;
HWND hwnd;
gs_init_data initData;
DXGI_SWAP_CHAIN_DESC swapDesc = {};
uint32_t numBuffers;
HWND hwnd;
gs_init_data initData;
DXGI_SWAP_CHAIN_DESC swapDesc = {};
gs_texture_2d target;
gs_zstencil_buffer zs;
ComPtr<IDXGISwapChain> swap;
gs_texture_2d target;
gs_zstencil_buffer zs;
ComPtr<IDXGISwapChain> swap;
void InitTarget(uint32_t cx, uint32_t cy);
void InitZStencilBuffer(uint32_t cx, uint32_t cy);
@@ -643,27 +697,27 @@ struct gs_swap_chain : gs_obj {
};
struct BlendState {
bool blendEnabled;
bool blendEnabled;
gs_blend_type srcFactorC;
gs_blend_type destFactorC;
gs_blend_type srcFactorA;
gs_blend_type destFactorA;
bool redEnabled;
bool greenEnabled;
bool blueEnabled;
bool alphaEnabled;
bool redEnabled;
bool greenEnabled;
bool blueEnabled;
bool alphaEnabled;
inline BlendState()
: blendEnabled (true),
srcFactorC (GS_BLEND_SRCALPHA),
destFactorC (GS_BLEND_INVSRCALPHA),
srcFactorA (GS_BLEND_ONE),
destFactorA (GS_BLEND_INVSRCALPHA),
redEnabled (true),
greenEnabled (true),
blueEnabled (true),
alphaEnabled (true)
: blendEnabled(true),
srcFactorC(GS_BLEND_SRCALPHA),
destFactorC(GS_BLEND_INVSRCALPHA),
srcFactorA(GS_BLEND_ONE),
destFactorA(GS_BLEND_INVSRCALPHA),
redEnabled(true),
greenEnabled(true),
blueEnabled(true),
alphaEnabled(true)
{
}
@@ -675,14 +729,11 @@ struct BlendState {
struct SavedBlendState : BlendState {
ComPtr<ID3D11BlendState> state;
D3D11_BLEND_DESC bd;
D3D11_BLEND_DESC bd;
void Rebuild(ID3D11Device *dev);
inline void Release()
{
state.Release();
}
inline void Release() { state.Release(); }
inline SavedBlendState(const BlendState &val, D3D11_BLEND_DESC &desc)
: BlendState(val), bd(desc)
@@ -697,30 +748,27 @@ struct StencilSide {
gs_stencil_op_type zpass;
inline StencilSide()
: test (GS_ALWAYS),
fail (GS_KEEP),
zfail (GS_KEEP),
zpass (GS_KEEP)
: test(GS_ALWAYS), fail(GS_KEEP), zfail(GS_KEEP), zpass(GS_KEEP)
{
}
};
struct ZStencilState {
bool depthEnabled;
bool depthWriteEnabled;
bool depthEnabled;
bool depthWriteEnabled;
gs_depth_test depthFunc;
bool stencilEnabled;
bool stencilWriteEnabled;
StencilSide stencilFront;
StencilSide stencilBack;
bool stencilEnabled;
bool stencilWriteEnabled;
StencilSide stencilFront;
StencilSide stencilBack;
inline ZStencilState()
: depthEnabled (true),
depthWriteEnabled (true),
depthFunc (GS_LESS),
stencilEnabled (false),
stencilWriteEnabled (true)
: depthEnabled(true),
depthWriteEnabled(true),
depthFunc(GS_LESS),
stencilEnabled(false),
stencilWriteEnabled(true)
{
}
@@ -732,32 +780,24 @@ struct ZStencilState {
struct SavedZStencilState : ZStencilState {
ComPtr<ID3D11DepthStencilState> state;
D3D11_DEPTH_STENCIL_DESC dsd;
D3D11_DEPTH_STENCIL_DESC dsd;
void Rebuild(ID3D11Device *dev);
inline void Release()
{
state.Release();
}
inline void Release() { state.Release(); }
inline SavedZStencilState(const ZStencilState &val,
D3D11_DEPTH_STENCIL_DESC desc)
: ZStencilState (val),
dsd (desc)
D3D11_DEPTH_STENCIL_DESC desc)
: ZStencilState(val), dsd(desc)
{
}
};
struct RasterState {
gs_cull_mode cullMode;
bool scissorEnabled;
bool scissorEnabled;
inline RasterState()
: cullMode (GS_BACK),
scissorEnabled (false)
{
}
inline RasterState() : cullMode(GS_BACK), scissorEnabled(false) {}
inline RasterState(const RasterState &state)
{
@@ -767,19 +807,15 @@ struct RasterState {
struct SavedRasterState : RasterState {
ComPtr<ID3D11RasterizerState> state;
D3D11_RASTERIZER_DESC rd;
D3D11_RASTERIZER_DESC rd;
void Rebuild(ID3D11Device *dev);
inline void Release()
{
state.Release();
}
inline void Release() { state.Release(); }
inline SavedRasterState(const RasterState &val,
D3D11_RASTERIZER_DESC &desc)
: RasterState (val),
rd (desc)
D3D11_RASTERIZER_DESC &desc)
: RasterState(val), rd(desc)
{
}
};
@@ -789,73 +825,72 @@ struct mat4float {
};
struct gs_device {
ComPtr<IDXGIFactory1> factory;
ComPtr<IDXGIAdapter1> adapter;
ComPtr<ID3D11Device> device;
ComPtr<IDXGIFactory1> factory;
ComPtr<IDXGIAdapter1> adapter;
ComPtr<ID3D11Device> device;
ComPtr<ID3D11DeviceContext> context;
uint32_t adpIdx = 0;
bool nv12Supported = false;
uint32_t adpIdx = 0;
bool nv12Supported = false;
gs_texture_2d *curRenderTarget = nullptr;
gs_zstencil_buffer *curZStencilBuffer = nullptr;
int curRenderSide = 0;
gs_texture *curTextures[GS_MAX_TEXTURES];
gs_sampler_state *curSamplers[GS_MAX_TEXTURES];
gs_vertex_buffer *curVertexBuffer = nullptr;
gs_index_buffer *curIndexBuffer = nullptr;
gs_vertex_shader *curVertexShader = nullptr;
gs_pixel_shader *curPixelShader = nullptr;
gs_swap_chain *curSwapChain = nullptr;
gs_texture_2d *curRenderTarget = nullptr;
gs_zstencil_buffer *curZStencilBuffer = nullptr;
int curRenderSide = 0;
gs_texture *curTextures[GS_MAX_TEXTURES];
gs_sampler_state *curSamplers[GS_MAX_TEXTURES];
gs_vertex_buffer *curVertexBuffer = nullptr;
gs_index_buffer *curIndexBuffer = nullptr;
gs_vertex_shader *curVertexShader = nullptr;
gs_pixel_shader *curPixelShader = nullptr;
gs_swap_chain *curSwapChain = nullptr;
gs_vertex_buffer *lastVertexBuffer = nullptr;
gs_vertex_shader *lastVertexShader = nullptr;
gs_vertex_buffer *lastVertexBuffer = nullptr;
gs_vertex_shader *lastVertexShader = nullptr;
bool zstencilStateChanged = true;
bool rasterStateChanged = true;
bool blendStateChanged = true;
ZStencilState zstencilState;
RasterState rasterState;
BlendState blendState;
vector<SavedZStencilState> zstencilStates;
vector<SavedRasterState> rasterStates;
vector<SavedBlendState> blendStates;
ID3D11DepthStencilState *curDepthStencilState = nullptr;
ID3D11RasterizerState *curRasterState = nullptr;
ID3D11BlendState *curBlendState = nullptr;
D3D11_PRIMITIVE_TOPOLOGY curToplogy;
bool zstencilStateChanged = true;
bool rasterStateChanged = true;
bool blendStateChanged = true;
ZStencilState zstencilState;
RasterState rasterState;
BlendState blendState;
vector<SavedZStencilState> zstencilStates;
vector<SavedRasterState> rasterStates;
vector<SavedBlendState> blendStates;
ID3D11DepthStencilState *curDepthStencilState = nullptr;
ID3D11RasterizerState *curRasterState = nullptr;
ID3D11BlendState *curBlendState = nullptr;
D3D11_PRIMITIVE_TOPOLOGY curToplogy;
pD3DCompile d3dCompile = nullptr;
pD3DCompile d3dCompile = nullptr;
#ifdef DISASSEMBLE_SHADERS
pD3DDisassemble d3dDisassemble = nullptr;
pD3DDisassemble d3dDisassemble = nullptr;
#endif
gs_rect viewport;
gs_rect viewport;
vector<mat4float> projStack;
vector<mat4float> projStack;
matrix4 curProjMatrix;
matrix4 curViewMatrix;
matrix4 curViewProjMatrix;
matrix4 curProjMatrix;
matrix4 curViewMatrix;
matrix4 curViewProjMatrix;
gs_obj *first_obj = nullptr;
gs_obj *first_obj = nullptr;
void InitCompiler();
void InitFactory(uint32_t adapterIdx);
void InitDevice(uint32_t adapterIdx);
ID3D11DepthStencilState *AddZStencilState();
ID3D11RasterizerState *AddRasterState();
ID3D11BlendState *AddBlendState();
ID3D11RasterizerState *AddRasterState();
ID3D11BlendState *AddBlendState();
void UpdateZStencilState();
void UpdateRasterState();
void UpdateBlendState();
void LoadVertexBufferData();
inline void CopyTex(ID3D11Texture2D *dst,
uint32_t dst_x, uint32_t dst_y,
gs_texture_t *src, uint32_t src_x, uint32_t src_y,
uint32_t src_w, uint32_t src_h);
inline void CopyTex(ID3D11Texture2D *dst, uint32_t dst_x,
uint32_t dst_y, gs_texture_t *src, uint32_t src_x,
uint32_t src_y, uint32_t src_w, uint32_t src_h);
void UpdateViewProjMatrix();
@@ -868,4 +903,4 @@ struct gs_device {
};
extern "C" EXPORT int device_texture_acquire_sync(gs_texture_t *tex,
uint64_t key, uint32_t ms);
uint64_t key, uint32_t ms);

164
libobs-d3d11/d3d11-texture2d.cpp
View File

@@ -20,11 +20,11 @@
void gs_texture_2d::InitSRD(vector<D3D11_SUBRESOURCE_DATA> &srd)
{
uint32_t rowSizeBytes = width * gs_get_format_bpp(format);
uint32_t texSizeBytes = height * rowSizeBytes / 8;
size_t textures = type == GS_TEXTURE_2D ? 1 : 6;
uint32_t rowSizeBytes = width * gs_get_format_bpp(format);
uint32_t texSizeBytes = height * rowSizeBytes / 8;
size_t textures = type == GS_TEXTURE_2D ? 1 : 6;
uint32_t actual_levels = levels;
size_t curTex = 0;
size_t curTex = 0;
if (!actual_levels)
actual_levels = gs_get_total_levels(width, height);
@@ -37,8 +37,8 @@ void gs_texture_2d::InitSRD(vector<D3D11_SUBRESOURCE_DATA> &srd)
for (uint32_t j = 0; j < actual_levels; j++) {
D3D11_SUBRESOURCE_DATA newSRD;
newSRD.pSysMem = data[curTex++].data();
newSRD.SysMemPitch = newRowSize;
newSRD.pSysMem = data[curTex++].data();
newSRD.SysMemPitch = newRowSize;
newSRD.SysMemSlicePitch = newTexSize;
srd.push_back(newSRD);
@@ -78,8 +78,10 @@ void gs_texture_2d::GetSharedHandle(IDXGIResource *dxgi_res)
hr = dxgi_res->GetSharedHandle(&handle);
if (FAILED(hr)) {
blog(LOG_WARNING, "GetSharedHandle: Failed to "
"get shared handle: %08lX", hr);
blog(LOG_WARNING,
"GetSharedHandle: Failed to "
"get shared handle: %08lX",
hr);
} else {
sharedHandle = (uint32_t)(uintptr_t)handle;
}
@@ -90,16 +92,15 @@ void gs_texture_2d::InitTexture(const uint8_t **data)
HRESULT hr;
memset(&td, 0, sizeof(td));
td.Width = width;
td.Height = height;
td.MipLevels = genMipmaps ? 0 : levels;
td.ArraySize = type == GS_TEXTURE_CUBE ? 6 : 1;
td.Format = nv12 ? DXGI_FORMAT_NV12 : dxgiFormat;
td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
td.Width = width;
td.Height = height;
td.MipLevels = genMipmaps ? 0 : levels;
td.ArraySize = type == GS_TEXTURE_CUBE ? 6 : 1;
td.Format = nv12 ? DXGI_FORMAT_NV12 : dxgiFormat;
td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
td.SampleDesc.Count = 1;
td.CPUAccessFlags = isDynamic ? D3D11_CPU_ACCESS_WRITE : 0;
td.Usage = isDynamic ? D3D11_USAGE_DYNAMIC :
D3D11_USAGE_DEFAULT;
td.CPUAccessFlags = isDynamic ? D3D11_CPU_ACCESS_WRITE : 0;
td.Usage = isDynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
if (type == GS_TEXTURE_CUBE)
td.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE;
@@ -121,13 +122,13 @@ void gs_texture_2d::InitTexture(const uint8_t **data)
}
hr = device->device->CreateTexture2D(&td, data ? srd.data() : NULL,
texture.Assign());
texture.Assign());
if (FAILED(hr))
throw HRError("Failed to create 2D texture", hr);
if (isGDICompatible) {
hr = texture->QueryInterface(__uuidof(IDXGISurface1),
(void**)gdiSurface.Assign());
(void **)gdiSurface.Assign());
if (FAILED(hr))
throw HRError("Failed to create GDI surface", hr);
}
@@ -138,22 +139,24 @@ void gs_texture_2d::InitTexture(const uint8_t **data)
texture->SetEvictionPriority(DXGI_RESOURCE_PRIORITY_MAXIMUM);
hr = texture->QueryInterface(__uuidof(IDXGIResource),
(void**)&dxgi_res);
(void **)&dxgi_res);
if (FAILED(hr)) {
blog(LOG_WARNING, "InitTexture: Failed to query "
"interface: %08lX", hr);
blog(LOG_WARNING,
"InitTexture: Failed to query "
"interface: %08lX",
hr);
} else {
GetSharedHandle(dxgi_res);
if (flags & GS_SHARED_KM_TEX) {
ComPtr<IDXGIKeyedMutex> km;
hr = texture->QueryInterface(
__uuidof(IDXGIKeyedMutex),
(void**)&km);
__uuidof(IDXGIKeyedMutex),
(void **)&km);
if (FAILED(hr)) {
throw HRError("Failed to query "
"IDXGIKeyedMutex",
hr);
"IDXGIKeyedMutex",
hr);
}
km->AcquireSync(0, INFINITE);
@@ -181,7 +184,7 @@ void gs_texture_2d::InitResourceView()
}
hr = device->device->CreateShaderResourceView(texture, &resourceDesc,
shaderRes.Assign());
shaderRes.Assign());
if (FAILED(hr))
throw HRError("Failed to create resource view", hr);
}
@@ -193,27 +196,28 @@ void gs_texture_2d::InitRenderTargets()
D3D11_RENDER_TARGET_VIEW_DESC rtv;
rtv.Format = dxgiFormat;
rtv.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
rtv.Texture2D.MipSlice = 0;
rtv.Texture2D.MipSlice = 0;
hr = device->device->CreateRenderTargetView(texture, &rtv,
renderTarget[0].Assign());
hr = device->device->CreateRenderTargetView(
texture, &rtv, renderTarget[0].Assign());
if (FAILED(hr))
throw HRError("Failed to create render target view",
hr);
hr);
} else {
D3D11_RENDER_TARGET_VIEW_DESC rtv;
rtv.Format = dxgiFormat;
rtv.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
rtv.Texture2DArray.MipSlice = 0;
rtv.Texture2DArray.MipSlice = 0;
rtv.Texture2DArray.ArraySize = 1;
for (UINT i = 0; i < 6; i++) {
rtv.Texture2DArray.FirstArraySlice = i;
hr = device->device->CreateRenderTargetView(texture,
&rtv, renderTarget[i].Assign());
hr = device->device->CreateRenderTargetView(
texture, &rtv, renderTarget[i].Assign());
if (FAILED(hr))
throw HRError("Failed to create cube render "
"target view", hr);
"target view",
hr);
}
}
}
@@ -221,22 +225,22 @@ void gs_texture_2d::InitRenderTargets()
#define SHARED_FLAGS (GS_SHARED_TEX | GS_SHARED_KM_TEX)
gs_texture_2d::gs_texture_2d(gs_device_t *device, uint32_t width,
uint32_t height, gs_color_format colorFormat, uint32_t levels,
const uint8_t **data, uint32_t flags_, gs_texture_type type,
bool gdiCompatible, bool nv12_)
: gs_texture (device, gs_type::gs_texture_2d, type, levels,
colorFormat),
width (width),
height (height),
flags (flags_),
dxgiFormat (ConvertGSTextureFormat(format)),
isRenderTarget ((flags_ & GS_RENDER_TARGET) != 0),
isGDICompatible (gdiCompatible),
isDynamic ((flags_ & GS_DYNAMIC) != 0),
isShared ((flags_ & SHARED_FLAGS) != 0),
genMipmaps ((flags_ & GS_BUILD_MIPMAPS) != 0),
sharedHandle (GS_INVALID_HANDLE),
nv12 (nv12_)
uint32_t height, gs_color_format colorFormat,
uint32_t levels, const uint8_t **data,
uint32_t flags_, gs_texture_type type,
bool gdiCompatible, bool nv12_)
: gs_texture(device, gs_type::gs_texture_2d, type, levels, colorFormat),
width(width),
height(height),
flags(flags_),
dxgiFormat(ConvertGSTextureFormat(format)),
isRenderTarget((flags_ & GS_RENDER_TARGET) != 0),
isGDICompatible(gdiCompatible),
isDynamic((flags_ & GS_DYNAMIC) != 0),
isShared((flags_ & SHARED_FLAGS) != 0),
genMipmaps((flags_ & GS_BUILD_MIPMAPS) != 0),
sharedHandle(GS_INVALID_HANDLE),
nv12(nv12_)
{
InitTexture(data);
InitResourceView();
@@ -246,25 +250,25 @@ gs_texture_2d::gs_texture_2d(gs_device_t *device, uint32_t width,
}
gs_texture_2d::gs_texture_2d(gs_device_t *device, ID3D11Texture2D *nv12tex,
uint32_t flags_)
: gs_texture (device, gs_type::gs_texture_2d, GS_TEXTURE_2D),
isRenderTarget ((flags_ & GS_RENDER_TARGET) != 0),
isDynamic ((flags_ & GS_DYNAMIC) != 0),
isShared ((flags_ & SHARED_FLAGS) != 0),
genMipmaps ((flags_ & GS_BUILD_MIPMAPS) != 0),
nv12 (true)
uint32_t flags_)
: gs_texture(device, gs_type::gs_texture_2d, GS_TEXTURE_2D),
isRenderTarget((flags_ & GS_RENDER_TARGET) != 0),
isDynamic((flags_ & GS_DYNAMIC) != 0),
isShared((flags_ & SHARED_FLAGS) != 0),
genMipmaps((flags_ & GS_BUILD_MIPMAPS) != 0),
nv12(true)
{
texture = nv12tex;
texture->GetDesc(&td);
this->type = GS_TEXTURE_2D;
this->format = GS_R8G8;
this->flags = flags_;
this->levels = 1;
this->device = device;
this->chroma = true;
this->width = td.Width / 2;
this->height = td.Height / 2;
this->type = GS_TEXTURE_2D;
this->format = GS_R8G8;
this->flags = flags_;
this->levels = 1;
this->device = device;
this->chroma = true;
this->width = td.Width / 2;
this->height = td.Height / 2;
this->dxgiFormat = DXGI_FORMAT_R8G8_UNORM;
InitResourceView();
@@ -273,35 +277,35 @@ gs_texture_2d::gs_texture_2d(gs_device_t *device, ID3D11Texture2D *nv12tex,
}
gs_texture_2d::gs_texture_2d(gs_device_t *device, uint32_t handle)
: gs_texture (device, gs_type::gs_texture_2d,
GS_TEXTURE_2D),
isShared (true),
sharedHandle (handle)
: gs_texture(device, gs_type::gs_texture_2d, GS_TEXTURE_2D),
isShared(true),
sharedHandle(handle)
{
HRESULT hr;
hr = device->device->OpenSharedResource((HANDLE)(uintptr_t)handle,
__uuidof(ID3D11Texture2D), (void**)texture.Assign());
__uuidof(ID3D11Texture2D),
(void **)texture.Assign());
if (FAILED(hr))
throw HRError("Failed to open shared 2D texture", hr);
texture->GetDesc(&td);
this->type = GS_TEXTURE_2D;
this->format = ConvertDXGITextureFormat(td.Format);
this->levels = 1;
this->device = device;
this->type = GS_TEXTURE_2D;
this->format = ConvertDXGITextureFormat(td.Format);
this->levels = 1;
this->device = device;
this->width = td.Width;
this->height = td.Height;
this->width = td.Width;
this->height = td.Height;
this->dxgiFormat = td.Format;
memset(&resourceDesc, 0, sizeof(resourceDesc));
resourceDesc.Format = td.Format;
resourceDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
resourceDesc.Format = td.Format;
resourceDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
resourceDesc.Texture2D.MipLevels = 1;
hr = device->device->CreateShaderResourceView(texture, &resourceDesc,
shaderRes.Assign());
shaderRes.Assign());
if (FAILED(hr))
throw HRError("Failed to create shader resource view", hr);
}

65
libobs-d3d11/d3d11-vertexbuffer.cpp
View File

@@ -19,27 +19,27 @@
#include <graphics/vec3.h>
#include "d3d11-subsystem.hpp"
static inline void PushBuffer(vector<ID3D11Buffer*> &buffers,
vector<uint32_t> &strides, ID3D11Buffer *buffer,
size_t elementSize, const char *name)
static inline void PushBuffer(vector<ID3D11Buffer *> &buffers,
vector<uint32_t> &strides, ID3D11Buffer *buffer,
size_t elementSize, const char *name)
{
if (buffer) {
buffers.push_back(buffer);
strides.push_back((uint32_t)elementSize);
} else {
blog(LOG_ERROR, "This vertex shader requires a %s buffer",
name);
name);
}
}
void gs_vertex_buffer::FlushBuffer(ID3D11Buffer *buffer, void *array,
size_t elementSize)
size_t elementSize)
{
D3D11_MAPPED_SUBRESOURCE msr;
HRESULT hr;
if (FAILED(hr = device->context->Map(buffer, 0,
D3D11_MAP_WRITE_DISCARD, 0, &msr)))
if (FAILED(hr = device->context->Map(buffer, 0, D3D11_MAP_WRITE_DISCARD,
0, &msr)))
throw HRError("Failed to map buffer", hr);
memcpy(msr.pData, array, elementSize * vbd.data->num);
@@ -47,46 +47,49 @@ void gs_vertex_buffer::FlushBuffer(ID3D11Buffer *buffer, void *array,
}
void gs_vertex_buffer::MakeBufferList(gs_vertex_shader *shader,
vector<ID3D11Buffer*> &buffers, vector<uint32_t> &strides)
vector<ID3D11Buffer *> &buffers,
vector<uint32_t> &strides)
{
PushBuffer(buffers, strides, vertexBuffer, sizeof(vec3), "point");
if (shader->hasNormals)
PushBuffer(buffers, strides, normalBuffer, sizeof(vec3),
"normal");
"normal");
if (shader->hasColors)
PushBuffer(buffers, strides, colorBuffer, sizeof(uint32_t),
"color");
"color");
if (shader->hasTangents)
PushBuffer(buffers, strides, tangentBuffer, sizeof(vec3),
"tangent");
"tangent");
if (shader->nTexUnits <= uvBuffers.size()) {
for (size_t i = 0; i < shader->nTexUnits; i++) {
buffers.push_back(uvBuffers[i]);
strides.push_back((uint32_t)uvSizes[i]);
}
} else {
blog(LOG_ERROR, "This vertex shader requires at least %u "
"texture buffers.",
(uint32_t)shader->nTexUnits);
blog(LOG_ERROR,
"This vertex shader requires at least %u "
"texture buffers.",
(uint32_t)shader->nTexUnits);
}
}
void gs_vertex_buffer::InitBuffer(const size_t elementSize,
const size_t numVerts, void *array, ID3D11Buffer **buffer)
const size_t numVerts, void *array,
ID3D11Buffer **buffer)
{
D3D11_BUFFER_DESC bd;
D3D11_SUBRESOURCE_DATA srd;
HRESULT hr;
memset(&bd, 0, sizeof(bd));
memset(&bd, 0, sizeof(bd));
memset(&srd, 0, sizeof(srd));
bd.Usage = dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
bd.Usage = dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
bd.CPUAccessFlags = dynamic ? D3D11_CPU_ACCESS_WRITE : 0;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.ByteWidth = UINT(elementSize * numVerts);
srd.pSysMem = array;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.ByteWidth = UINT(elementSize * numVerts);
srd.pSysMem = array;
hr = device->device->CreateBuffer(&bd, &srd, buffer);
if (FAILED(hr))
@@ -96,22 +99,22 @@ void gs_vertex_buffer::InitBuffer(const size_t elementSize,
void gs_vertex_buffer::BuildBuffers()
{
InitBuffer(sizeof(vec3), vbd.data->num, vbd.data->points,
&vertexBuffer);
&vertexBuffer);
if (vbd.data->normals)
InitBuffer(sizeof(vec3), vbd.data->num, vbd.data->normals,
&normalBuffer);
&normalBuffer);
if (vbd.data->tangents)
InitBuffer(sizeof(vec3), vbd.data->num, vbd.data->tangents,
&tangentBuffer);
&tangentBuffer);
if (vbd.data->colors)
InitBuffer(sizeof(uint32_t), vbd.data->num, vbd.data->colors,
&colorBuffer);
&colorBuffer);
for (size_t i = 0; i < vbd.data->num_tex; i++) {
struct gs_tvertarray *tverts = vbd.data->tvarray+i;
struct gs_tvertarray *tverts = vbd.data->tvarray + i;
if (tverts->width != 2 && tverts->width != 4)
throw "Invalid texture vertex size specified";
@@ -120,7 +123,7 @@ void gs_vertex_buffer::BuildBuffers()
ComPtr<ID3D11Buffer> buffer;
InitBuffer(tverts->width * sizeof(float), vbd.data->num,
tverts->array, &buffer);
tverts->array, &buffer);
uvBuffers.push_back(buffer);
uvSizes.push_back(tverts->width * sizeof(float));
@@ -128,11 +131,11 @@ void gs_vertex_buffer::BuildBuffers()
}
gs_vertex_buffer::gs_vertex_buffer(gs_device_t *device, struct gs_vb_data *data,
uint32_t flags)
: gs_obj (device, gs_type::gs_vertex_buffer),
dynamic ((flags & GS_DYNAMIC) != 0),
vbd (data),
numVerts (data->num)
uint32_t flags)
: gs_obj(device, gs_type::gs_vertex_buffer),
dynamic((flags & GS_DYNAMIC) != 0),
vbd(data),
numVerts(data->num)
{
if (!data->num)
throw "Cannot initialize vertex buffer with 0 vertices";

34
libobs-d3d11/d3d11-zstencilbuffer.cpp
View File

@@ -22,37 +22,37 @@ void gs_zstencil_buffer::InitBuffer()
HRESULT hr;
memset(&td, 0, sizeof(td));
td.Width = width;
td.Height = height;
td.MipLevels = 1;
td.ArraySize = 1;
td.Format = dxgiFormat;
td.BindFlags = D3D11_BIND_DEPTH_STENCIL;
td.Width = width;
td.Height = height;
td.MipLevels = 1;
td.ArraySize = 1;
td.Format = dxgiFormat;
td.BindFlags = D3D11_BIND_DEPTH_STENCIL;
td.SampleDesc.Count = 1;
td.Usage = D3D11_USAGE_DEFAULT;
td.Usage = D3D11_USAGE_DEFAULT;
hr = device->device->CreateTexture2D(&td, NULL, texture.Assign());
if (FAILED(hr))
throw HRError("Failed to create depth stencil texture", hr);
memset(&dsvd, 0, sizeof(dsvd));
dsvd.Format = dxgiFormat;
dsvd.Format = dxgiFormat;
dsvd.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
hr = device->device->CreateDepthStencilView(texture, &dsvd,
view.Assign());
view.Assign());
if (FAILED(hr))
throw HRError("Failed to create depth stencil view", hr);
}
gs_zstencil_buffer::gs_zstencil_buffer(gs_device_t *device,
uint32_t width, uint32_t height,
gs_zstencil_format format)
: gs_obj (device, gs_type::gs_zstencil_buffer),
width (width),
height (height),
format (format),
dxgiFormat (ConvertGSZStencilFormat(format))
gs_zstencil_buffer::gs_zstencil_buffer(gs_device_t *device, uint32_t width,
uint32_t height,
gs_zstencil_format format)
: gs_obj(device, gs_type::gs_zstencil_buffer),
width(width),
height(height),
format(format),
dxgiFormat(ConvertGSZStencilFormat(format))
{
InitBuffer();
}