lagertonne/yolobs-studio
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

New upstream version 24.0.1+dfsg1

Browse source
This commit is contained in:
Sebastian Ramacher 2019-09-22 23:19:10 +02:00
parent b14f9eae6d
commit 5a730d6ec3
842 changed files with 42245 additions and 33385 deletions
Download patch file Download diff file Expand all files Collapse all files

64
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;
@ -86,9 +87,11 @@ EXPORT bool device_get_duplicator_monitor_info(gs_device_t *device,
if (FAILED(hr))
throw HRError("GetDesc failed", hr);
} catch (HRError error) {
blog(LOG_ERROR, "device_get_duplicator_monitor_info: "
"%s (%08lX)", error.str, error.hr);
} catch (const HRError &error) {
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) {
} catch (const 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();

157
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);
@ -224,6 +225,29 @@ void gs_swap_chain::Rebuild(ID3D11Device *dev)
Init();
}
void gs_timer::Rebuild(ID3D11Device *dev)
{
D3D11_QUERY_DESC desc;
desc.Query = D3D11_QUERY_TIMESTAMP;
desc.MiscFlags = 0;
HRESULT hr = dev->CreateQuery(&desc, &query_begin);
if (FAILED(hr))
throw HRError("Failed to create timer", hr);
hr = dev->CreateQuery(&desc, &query_end);
if (FAILED(hr))
throw HRError("Failed to create timer", hr);
}
void gs_timer_range::Rebuild(ID3D11Device *dev)
{
D3D11_QUERY_DESC desc;
desc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT;
desc.MiscFlags = 0;
HRESULT hr = dev->CreateQuery(&desc, &query_disjoint);
if (FAILED(hr))
throw HRError("Failed to create timer", hr);
}
void SavedBlendState::Rebuild(ID3D11Device *dev)
{
HRESULT hr = dev->CreateBlendState(&bd, &state);
@ -245,8 +269,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 +290,40 @@ 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;
case gs_type::gs_timer:
((gs_timer *)obj)->Release();
break;
case gs_type::gs_timer_range:
((gs_timer_range *)obj)->Release();
break;
}
@ -320,10 +349,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 +363,49 @@ 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;
case gs_type::gs_timer:
((gs_timer *)obj)->Rebuild(dev);
break;
case gs_type::gs_timer_range:
((gs_timer_range *)obj)->Rebuild(dev);
break;
}
@ -406,7 +440,6 @@ try {
} catch (const char *error) {
bcrash("Failed to recreate D3D11: %s", error);
} catch (HRError error) {
bcrash("Failed to recreate D3D11: %s (%08lX)",
error.str, error.hr);
} catch (const HRError &error) {
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));

130
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,29 +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);
hr = device->device->CreateInputLayout(layoutData.data(),
(UINT)layoutData.size(),
data.data(), data.size(), layout.Assign());
if (FAILED(hr))
throw HRError("Failed to create input layout", hr);
const UINT layoutSize = (UINT)layoutData.size();
if (layoutSize > 0) {
hr = device->device->CreateInputLayout(layoutData.data(),
(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);
@ -98,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);
}
@ -131,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:
@ -164,7 +176,7 @@ void gs_shader::BuildConstantBuffer()
constantSize = alignMax;
}
param.pos = constantSize;
param.pos = constantSize;
constantSize += size;
}
@ -173,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);
}
@ -189,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;
@ -198,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);
@ -215,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())
@ -235,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;
}
}
@ -267,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);
@ -282,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);
@ -324,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)
@ -332,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;
@ -346,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)
@ -407,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)
@ -419,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)

80
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"};
static const char *semanticOutputNames[] =
{"SV_Position", "NORMAL", "COLOR", "TANGENT", "TEXCOORD"};
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,21 +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) {
AddInputLayoutVar(var, layout);
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);
}
}
@ -133,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)
@ -147,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);
@ -163,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)
@ -181,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);
@ -197,6 +203,8 @@ void ShaderProcessor::BuildSamplers(vector<unique_ptr<ShaderSampler>> &samplers)
void ShaderProcessor::BuildString(string &outputString)
{
stringstream output;
output << "static const bool obs_glsl_compile = false;\n\n";
cf_token *token = cf_preprocessor_get_tokens(&parser.cfp.pp);
while (token->type != CFTOKEN_NONE) {
/* cheaply just replace specific tokens */
@ -214,6 +222,8 @@ void ShaderProcessor::BuildString(string &outputString)
throw "texture_rect is not supported in D3D";
else if (strref_cmp(&token->str, "sampler_state") == 0)
output << "SamplerState";
else if (strref_cmp(&token->str, "VERTEXID") == 0)
output << "SV_VertexID";
else
output.write(token->str.array, token->str.len);

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))

1027
libobs-d3d11/d3d11-subsystem.cpp
View file

File diff suppressed because it is too large Load diff

674
libobs-d3d11/d3d11-subsystem.hpp
View file

File diff suppressed because it is too large Load diff

166
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 = 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();
}