etc
/
obs-StreamFX
mirror of https://github.com/Xaymar/obs-StreamFX
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

gs: Rename to snake_case instead of PascalCase 

This should prevent mishaps with upper/lowercase typos and fits in better with the C++ standard code, which is also in snake_case.
This commit is contained in:
Michael Fabian 'Xaymar' Dirks 2018-03-20 12:43:37 +01:00
parent 9f518764b6
commit 2adfa5765c
27 changed files with 428 additions and 428 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
source/filter-blur.cpp
View File

@ -50,8 +50,8 @@ enum ColorFormat : uint64_t {
// Global Data // Global Data
const size_t MaxKernelSize = 25; const size_t MaxKernelSize = 25;
std::map<std::string, std::shared_ptr<GS::Effect>> g_effects; std::map<std::string, std::shared_ptr<gs::effect>> g_effects;
std::vector<std::shared_ptr<GS::Texture>> g_gaussianKernels; std::vector<std::shared_ptr<gs::texture>> g_gaussianKernels;
double_t bilateral(double_t x, double_t o) { double_t bilateral(double_t x, double_t o) {
return 0.39894 * exp(-0.5 * (x * x) / (o * o)) / o; return 0.39894 * exp(-0.5 * (x * x) / (o * o)) / o;
@ -85,7 +85,7 @@ static void GenerateGaussianKernelTextures() {
const uint8_t** pdata = const_cast<const uint8_t**>(&data); const uint8_t** pdata = const_cast<const uint8_t**>(&data);
try { try {
std::shared_ptr<GS::Texture> tex = std::make_shared<GS::Texture>((uint32_t)textureBufferSize, 1, std::shared_ptr<gs::texture> tex = std::make_shared<gs::texture>((uint32_t)textureBufferSize, 1,
gs_color_format::GS_R32F, 1, pdata, 0); gs_color_format::GS_R32F, 1, pdata, 0);
g_gaussianKernels[n] = tex; g_gaussianKernels[n] = tex;
} catch (std::runtime_error ex) { } catch (std::runtime_error ex) {
@ -121,7 +121,7 @@ Filter::Blur::Blur() {
}; };
for (auto& kv : effects) { for (auto& kv : effects) {
try { try {
std::shared_ptr<GS::Effect> effect = std::make_shared<GS::Effect>(kv.second); std::shared_ptr<gs::effect> effect = std::make_shared<gs::effect>(kv.second);
g_effects.insert(std::make_pair(kv.first, effect)); g_effects.insert(std::make_pair(kv.first, effect));
} catch (std::runtime_error ex) { } catch (std::runtime_error ex) {
P_LOG_ERROR("<filter-blur> Loading effect '%s' (path: '%s') failed with error(s): %s", P_LOG_ERROR("<filter-blur> Loading effect '%s' (path: '%s') failed with error(s): %s",
@ -623,7 +623,7 @@ bool Filter::Blur::Instance::apply_gaussian_param() {
if (m_type != Type::Gaussian) if (m_type != Type::Gaussian)
return false; return false;
std::shared_ptr<GS::Texture> tex; std::shared_ptr<gs::texture> tex;
if ((m_size - 1) < MaxKernelSize) { if ((m_size - 1) < MaxKernelSize) {
tex = g_gaussianKernels[size_t(m_size - 1)]; tex = g_gaussianKernels[size_t(m_size - 1)];
result = result && gs_set_param_texture(m_effect->GetObject(), "kernel", tex->GetObject()); result = result && gs_set_param_texture(m_effect->GetObject(), "kernel", tex->GetObject());

2
source/filter-blur.h
View File

@ -93,7 +93,7 @@ namespace Filter {
obs_source_t *m_source; obs_source_t *m_source;
gs_texrender_t *m_primaryRT, *m_secondaryRT; gs_texrender_t *m_primaryRT, *m_secondaryRT;
gs_texrender_t *m_rtHorizontal, *m_rtVertical; gs_texrender_t *m_rtHorizontal, *m_rtVertical;
std::shared_ptr<GS::Effect> m_effect; std::shared_ptr<gs::effect> m_effect;
// Blur // Blur
Type m_type; Type m_type;

216
source/filter-custom-shader.cpp
View File

@ -147,7 +147,7 @@ bool Filter::CustomShader::modified_properties(obs_properties_t *pr, obs_propert
Instance* ptr = static_cast<Instance*>(obs_properties_get_param(pr)); Instance* ptr = static_cast<Instance*>(obs_properties_get_param(pr));
for (Instance::Parameter& prm : ptr->m_effectParameters) { for (Instance::Parameter& prm : ptr->m_effectParameters) {
switch (prm.type) { switch (prm.type) {
case GS::EffectParameter::Type::Texture: case gs::effect_parameter::type::Texture:
bool isSource = obs_data_get_int(data, prm.uiNames[0].c_str()) == 1; bool isSource = obs_data_get_int(data, prm.uiNames[0].c_str()) == 1;
obs_property_set_visible(obs_properties_get(pr, prm.uiNames[1].c_str()), isSource); obs_property_set_visible(obs_properties_get(pr, prm.uiNames[1].c_str()), isSource);
obs_property_set_visible(obs_properties_get(pr, prm.uiNames[2].c_str()), !isSource); obs_property_set_visible(obs_properties_get(pr, prm.uiNames[2].c_str()), !isSource);
@ -205,7 +205,7 @@ Filter::CustomShader::Instance::Instance(obs_data_t *data, obs_source_t *source)
m_effect.lastCheck = 0; m_effect.lastCheck = 0;
m_effect.effect = nullptr; m_effect.effect = nullptr;
m_renderTarget = std::make_unique<GS::RenderTarget>(GS_RGBA, GS_ZS_NONE); m_renderTarget = std::make_unique<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
m_activeTime = 0.0f; m_activeTime = 0.0f;
m_renderTime = 0.0f; m_renderTime = 0.0f;
@ -220,7 +220,7 @@ void Filter::CustomShader::Instance::update(obs_data_t *data) {
if (shaderType == ShaderType::Text) { if (shaderType == ShaderType::Text) {
const char* shaderText = obs_data_get_string(data, S_CONTENT_TEXT); const char* shaderText = obs_data_get_string(data, S_CONTENT_TEXT);
try { try {
m_effect.effect = std::make_unique<GS::Effect>(shaderText, "Text Shader"); m_effect.effect = std::make_unique<gs::effect>(shaderText, "Text Shader");
} catch (std::runtime_error& ex) { } catch (std::runtime_error& ex) {
const char* filterName = obs_source_get_name(m_source); const char* filterName = obs_source_get_name(m_source);
P_LOG_ERROR("[%s] Shader loading failed with error(s): %s", filterName, ex.what()); P_LOG_ERROR("[%s] Shader loading failed with error(s): %s", filterName, ex.what());
@ -230,81 +230,81 @@ void Filter::CustomShader::Instance::update(obs_data_t *data) {
} }
m_effectParameters.clear(); m_effectParameters.clear();
if (m_effect.effect && m_effect.effect->CountParameters() > 0) { if (m_effect.effect && m_effect.effect->count_parameters() > 0) {
for (auto p : m_effect.effect->GetParameters()) { for (auto p : m_effect.effect->get_parameters()) {
std::string p_name = p.GetName(); std::string p_name = p.get_name();
std::string p_desc = p_name; std::string p_desc = p_name;
if (IsSpecialParameter(p_name, p.GetType())) if (IsSpecialParameter(p_name, p.get_type()))
continue; continue;
Parameter prm; Parameter prm;
prm.name = p_name; prm.name = p_name;
prm.type = p.GetType(); prm.type = p.get_type();
switch (p.GetType()) { switch (p.get_type()) {
case GS::EffectParameter::Type::Boolean: case gs::effect_parameter::type::Boolean:
{ {
prm.uiNames.push_back(p_name); prm.uiNames.push_back(p_name);
prm.uiDescriptions.push_back(p_desc); prm.uiDescriptions.push_back(p_desc);
prm.value.b = obs_data_get_bool(data, p_name.c_str()); prm.value.b = obs_data_get_bool(data, p_name.c_str());
break; break;
} }
case GS::EffectParameter::Type::Float: case gs::effect_parameter::type::Float:
case GS::EffectParameter::Type::Float2: case gs::effect_parameter::type::Float2:
case GS::EffectParameter::Type::Float3: case gs::effect_parameter::type::Float3:
case GS::EffectParameter::Type::Float4: case gs::effect_parameter::type::Float4:
{ {
{ {
prm.uiNames.push_back(p_name + "0"); prm.uiNames.push_back(p_name + "0");
prm.uiDescriptions.push_back(p_desc + "[0]"); prm.uiDescriptions.push_back(p_desc + "[0]");
prm.value.f[0] = (float_t)obs_data_get_double(data, prm.uiNames.back().c_str()); prm.value.f[0] = (float_t)obs_data_get_double(data, prm.uiNames.back().c_str());
} }
if (p.GetType() >= GS::EffectParameter::Type::Float2) { if (p.get_type() >= gs::effect_parameter::type::Float2) {
prm.uiNames.push_back(p_name + "1"); prm.uiNames.push_back(p_name + "1");
prm.uiDescriptions.push_back(p_desc + "[1]"); prm.uiDescriptions.push_back(p_desc + "[1]");
prm.value.f[1] = (float_t)obs_data_get_double(data, prm.uiNames.back().c_str()); prm.value.f[1] = (float_t)obs_data_get_double(data, prm.uiNames.back().c_str());
} }
if (p.GetType() >= GS::EffectParameter::Type::Float3) { if (p.get_type() >= gs::effect_parameter::type::Float3) {
prm.uiNames.push_back(p_name + "2"); prm.uiNames.push_back(p_name + "2");
prm.uiDescriptions.push_back(p_desc + "[2]"); prm.uiDescriptions.push_back(p_desc + "[2]");
prm.value.f[2] = (float_t)obs_data_get_double(data, prm.uiNames.back().c_str()); prm.value.f[2] = (float_t)obs_data_get_double(data, prm.uiNames.back().c_str());
} }
if (p.GetType() >= GS::EffectParameter::Type::Float4) { if (p.get_type() >= gs::effect_parameter::type::Float4) {
prm.uiNames.push_back(p_name + "3"); prm.uiNames.push_back(p_name + "3");
prm.uiDescriptions.push_back(p_desc + "[3]"); prm.uiDescriptions.push_back(p_desc + "[3]");
prm.value.f[3] = (float_t)obs_data_get_double(data, prm.uiNames.back().c_str()); prm.value.f[3] = (float_t)obs_data_get_double(data, prm.uiNames.back().c_str());
} }
break; break;
} }
case GS::EffectParameter::Type::Integer: case gs::effect_parameter::type::Integer:
case GS::EffectParameter::Type::Integer2: case gs::effect_parameter::type::Integer2:
case GS::EffectParameter::Type::Integer3: case gs::effect_parameter::type::Integer3:
case GS::EffectParameter::Type::Integer4: case gs::effect_parameter::type::Integer4:
{ {
{ {
prm.uiNames.push_back(p_name + "0"); prm.uiNames.push_back(p_name + "0");
prm.uiDescriptions.push_back(p_desc + "[0]"); prm.uiDescriptions.push_back(p_desc + "[0]");
prm.value.i[0] = (int32_t)obs_data_get_int(data, prm.uiNames.back().c_str()); prm.value.i[0] = (int32_t)obs_data_get_int(data, prm.uiNames.back().c_str());
} }
if (p.GetType() >= GS::EffectParameter::Type::Integer2) { if (p.get_type() >= gs::effect_parameter::type::Integer2) {
prm.uiNames.push_back(p_name + "1"); prm.uiNames.push_back(p_name + "1");
prm.uiDescriptions.push_back(p_desc + "[1]"); prm.uiDescriptions.push_back(p_desc + "[1]");
prm.value.i[1] = (int32_t)obs_data_get_int(data, prm.uiNames.back().c_str()); prm.value.i[1] = (int32_t)obs_data_get_int(data, prm.uiNames.back().c_str());
} }
if (p.GetType() >= GS::EffectParameter::Type::Integer3) { if (p.get_type() >= gs::effect_parameter::type::Integer3) {
prm.uiNames.push_back(p_name + "2"); prm.uiNames.push_back(p_name + "2");
prm.uiDescriptions.push_back(p_desc + "[2]"); prm.uiDescriptions.push_back(p_desc + "[2]");
prm.value.i[2] = (int32_t)obs_data_get_int(data, prm.uiNames.back().c_str()); prm.value.i[2] = (int32_t)obs_data_get_int(data, prm.uiNames.back().c_str());
} }
if (p.GetType() >= GS::EffectParameter::Type::Integer4) { if (p.get_type() >= gs::effect_parameter::type::Integer4) {
prm.uiNames.push_back(p_name + "3"); prm.uiNames.push_back(p_name + "3");
prm.uiDescriptions.push_back(p_desc + "[3]"); prm.uiDescriptions.push_back(p_desc + "[3]");
prm.value.i[3] = (int32_t)obs_data_get_int(data, prm.uiNames.back().c_str()); prm.value.i[3] = (int32_t)obs_data_get_int(data, prm.uiNames.back().c_str());
} }
break; break;
} }
case GS::EffectParameter::Type::Texture: case gs::effect_parameter::type::Texture:
{ {
prm.uiNames.push_back(p_name + "_type"); prm.uiNames.push_back(p_name + "_type");
prm.uiDescriptions.push_back(p_desc + " Type"); prm.uiDescriptions.push_back(p_desc + " Type");
@ -328,28 +328,28 @@ void Filter::CustomShader::Instance::update(obs_data_t *data) {
for (Parameter& prm : m_effectParameters) { for (Parameter& prm : m_effectParameters) {
switch (prm.type) { switch (prm.type) {
case GS::EffectParameter::Type::Boolean: case gs::effect_parameter::type::Boolean:
prm.value.b = obs_data_get_bool(data, prm.uiNames[0].c_str()); prm.value.b = obs_data_get_bool(data, prm.uiNames[0].c_str());
break; break;
case GS::EffectParameter::Type::Float4: case gs::effect_parameter::type::Float4:
prm.value.f[3] = (float_t)obs_data_get_double(data, prm.uiNames[3].c_str()); prm.value.f[3] = (float_t)obs_data_get_double(data, prm.uiNames[3].c_str());
case GS::EffectParameter::Type::Float3: case gs::effect_parameter::type::Float3:
prm.value.f[2] = (float_t)obs_data_get_double(data, prm.uiNames[2].c_str()); prm.value.f[2] = (float_t)obs_data_get_double(data, prm.uiNames[2].c_str());
case GS::EffectParameter::Type::Float2: case gs::effect_parameter::type::Float2:
prm.value.f[1] = (float_t)obs_data_get_double(data, prm.uiNames[1].c_str()); prm.value.f[1] = (float_t)obs_data_get_double(data, prm.uiNames[1].c_str());
case GS::EffectParameter::Type::Float: case gs::effect_parameter::type::Float:
prm.value.f[0] = (float_t)obs_data_get_double(data, prm.uiNames[0].c_str()); prm.value.f[0] = (float_t)obs_data_get_double(data, prm.uiNames[0].c_str());
break; break;
case GS::EffectParameter::Type::Integer4: case gs::effect_parameter::type::Integer4:
prm.value.i[3] = (int32_t)obs_data_get_int(data, prm.uiNames[3].c_str()); prm.value.i[3] = (int32_t)obs_data_get_int(data, prm.uiNames[3].c_str());
case GS::EffectParameter::Type::Integer3: case gs::effect_parameter::type::Integer3:
prm.value.i[2] = (int32_t)obs_data_get_int(data, prm.uiNames[2].c_str()); prm.value.i[2] = (int32_t)obs_data_get_int(data, prm.uiNames[2].c_str());
case GS::EffectParameter::Type::Integer2: case gs::effect_parameter::type::Integer2:
prm.value.i[1] = (int32_t)obs_data_get_int(data, prm.uiNames[1].c_str()); prm.value.i[1] = (int32_t)obs_data_get_int(data, prm.uiNames[1].c_str());
case GS::EffectParameter::Type::Integer: case gs::effect_parameter::type::Integer:
prm.value.i[0] = (int32_t)obs_data_get_int(data, prm.uiNames[0].c_str()); prm.value.i[0] = (int32_t)obs_data_get_int(data, prm.uiNames[0].c_str());
break; break;
case GS::EffectParameter::Type::Texture: case gs::effect_parameter::type::Texture:
prm.value.textureIsSource = obs_data_get_int(data, prm.uiNames[0].c_str()) == 1; prm.value.textureIsSource = obs_data_get_int(data, prm.uiNames[0].c_str()) == 1;
std::string nName = obs_data_get_string(data, prm.uiNames[1].c_str()); std::string nName = obs_data_get_string(data, prm.uiNames[1].c_str());
if (nName != prm.value.source.name) { if (nName != prm.value.source.name) {
@ -413,7 +413,7 @@ void Filter::CustomShader::Instance::video_render(gs_effect_t *effect) {
// Render original source to texture. // Render original source to texture.
{ {
auto op = m_renderTarget->Render(baseW, baseH); auto op = m_renderTarget->render(baseW, baseH);
vec4 black; vec4_zero(&black); vec4 black; vec4_zero(&black);
gs_ortho(0, (float_t)baseW, 0, (float_t)baseH, 0, 1); gs_ortho(0, (float_t)baseW, 0, (float_t)baseH, 0, 1);
gs_clear(GS_CLEAR_COLOR, &black, 0, 0); gs_clear(GS_CLEAR_COLOR, &black, 0, 0);
@ -422,7 +422,7 @@ void Filter::CustomShader::Instance::video_render(gs_effect_t *effect) {
effect ? effect : obs_get_base_effect(OBS_EFFECT_DEFAULT), baseW, baseH); effect ? effect : obs_get_base_effect(OBS_EFFECT_DEFAULT), baseW, baseH);
} }
} }
gs_texture_t* sourceTexture = m_renderTarget->GetTextureObject(); gs_texture_t* sourceTexture = m_renderTarget->get_object();
if (!sourceTexture) { if (!sourceTexture) {
obs_source_skip_video_filter(m_source); obs_source_skip_video_filter(m_source);
return; return;
@ -430,54 +430,54 @@ void Filter::CustomShader::Instance::video_render(gs_effect_t *effect) {
// Apply Parameters // Apply Parameters
try { try {
if (m_effect.effect->HasParameter("ViewSize", GS::EffectParameter::Type::Float2)) if (m_effect.effect->has_parameter("ViewSize", gs::effect_parameter::type::Float2))
m_effect.effect->GetParameter("ViewSize").SetFloat2(float_t(baseW), float_t(baseH)); m_effect.effect->get_parameter("ViewSize").set_float2(float_t(baseW), float_t(baseH));
if (m_effect.effect->HasParameter("ViewSizeI", GS::EffectParameter::Type::Integer2)) if (m_effect.effect->has_parameter("ViewSizeI", gs::effect_parameter::type::Integer2))
m_effect.effect->GetParameter("ViewSizeI").SetInteger2(baseW, baseH); m_effect.effect->get_parameter("ViewSizeI").set_int2(baseW, baseH);
if (m_effect.effect->HasParameter("Time", GS::EffectParameter::Type::Float)) if (m_effect.effect->has_parameter("Time", gs::effect_parameter::type::Float))
m_effect.effect->GetParameter("Time").SetFloat(m_renderTime); m_effect.effect->get_parameter("Time").set_float(m_renderTime);
if (m_effect.effect->HasParameter("TimeActive", GS::EffectParameter::Type::Float)) if (m_effect.effect->has_parameter("TimeActive", gs::effect_parameter::type::Float))
m_effect.effect->GetParameter("TimeActive").SetFloat(m_activeTime); m_effect.effect->get_parameter("TimeActive").set_float(m_activeTime);
/// "image" Specials /// "image" Specials
if (m_effect.effect->HasParameter("image_Size", GS::EffectParameter::Type::Float2)) if (m_effect.effect->has_parameter("image_Size", gs::effect_parameter::type::Float2))
m_effect.effect->GetParameter("image_Size").SetFloat2(float_t(baseW), float_t(baseH)); m_effect.effect->get_parameter("image_Size").set_float2(float_t(baseW), float_t(baseH));
if (m_effect.effect->HasParameter("image_SizeI", GS::EffectParameter::Type::Float2)) if (m_effect.effect->has_parameter("image_SizeI", gs::effect_parameter::type::Float2))
m_effect.effect->GetParameter("image_SizeI").SetInteger2(baseW, baseH); m_effect.effect->get_parameter("image_SizeI").set_int2(baseW, baseH);
if (m_effect.effect->HasParameter("image_Texel", GS::EffectParameter::Type::Float2)) if (m_effect.effect->has_parameter("image_Texel", gs::effect_parameter::type::Float2))
m_effect.effect->GetParameter("image_Texel").SetFloat2(1.0f / float_t(baseW), 1.0f / float_t(baseH)); m_effect.effect->get_parameter("image_Texel").set_float2(1.0f / float_t(baseW), 1.0f / float_t(baseH));
for (Parameter& prm : m_effectParameters) { for (Parameter& prm : m_effectParameters) {
GS::EffectParameter eprm = m_effect.effect->GetParameter(prm.name); gs::effect_parameter eprm = m_effect.effect->get_parameter(prm.name);
switch (prm.type) { switch (prm.type) {
case GS::EffectParameter::Type::Boolean: case gs::effect_parameter::type::Boolean:
eprm.SetBoolean(prm.value.b); eprm.set_bool(prm.value.b);
break; break;
case GS::EffectParameter::Type::Integer: case gs::effect_parameter::type::Integer:
eprm.SetInteger(prm.value.i[0]); eprm.set_int(prm.value.i[0]);
break; break;
case GS::EffectParameter::Type::Integer2: case gs::effect_parameter::type::Integer2:
eprm.SetInteger2(prm.value.i[0], prm.value.i[1]); eprm.set_int2(prm.value.i[0], prm.value.i[1]);
break; break;
case GS::EffectParameter::Type::Integer3: case gs::effect_parameter::type::Integer3:
eprm.SetInteger3(prm.value.i[0], prm.value.i[1], prm.value.i[2]); eprm.set_int3(prm.value.i[0], prm.value.i[1], prm.value.i[2]);
break; break;
case GS::EffectParameter::Type::Integer4: case gs::effect_parameter::type::Integer4:
eprm.SetInteger4(prm.value.i[0], prm.value.i[1], prm.value.i[2], prm.value.i[3]); eprm.set_int4(prm.value.i[0], prm.value.i[1], prm.value.i[2], prm.value.i[3]);
break; break;
case GS::EffectParameter::Type::Float: case gs::effect_parameter::type::Float:
eprm.SetFloat(prm.value.f[0]); eprm.set_float(prm.value.f[0]);
break; break;
case GS::EffectParameter::Type::Float2: case gs::effect_parameter::type::Float2:
eprm.SetFloat2(prm.value.f[0], prm.value.f[1]); eprm.set_float2(prm.value.f[0], prm.value.f[1]);
break; break;
case GS::EffectParameter::Type::Float3: case gs::effect_parameter::type::Float3:
eprm.SetFloat3(prm.value.f[0], prm.value.f[1], prm.value.f[2]); eprm.set_float3(prm.value.f[0], prm.value.f[1], prm.value.f[2]);
break; break;
case GS::EffectParameter::Type::Float4: case gs::effect_parameter::type::Float4:
eprm.SetFloat4(prm.value.f[0], prm.value.f[1], prm.value.f[2], prm.value.f[3]); eprm.set_float4(prm.value.f[0], prm.value.f[1], prm.value.f[2], prm.value.f[3]);
break; break;
case GS::EffectParameter::Type::Texture: case gs::effect_parameter::type::Texture:
if (prm.value.textureIsSource) { if (prm.value.textureIsSource) {
if (prm.value.source.rendertarget && prm.value.source.source) { if (prm.value.source.rendertarget && prm.value.source.source) {
uint32_t w, h; uint32_t w, h;
@ -490,11 +490,11 @@ void Filter::CustomShader::Instance::video_render(gs_effect_t *effect) {
gs_clear(GS_CLEAR_COLOR, &black, 0, 0); gs_clear(GS_CLEAR_COLOR, &black, 0, 0);
obs_source_video_render(prm.value.source.source); obs_source_video_render(prm.value.source.source);
} }
eprm.SetTexture(prm.value.source.rendertarget->GetTextureObject()); eprm.set_texture(prm.value.source.rendertarget->GetTextureObject());
} }
} else { } else {
if (prm.value.file.texture) { if (prm.value.file.texture) {
eprm.SetTexture(prm.value.file.texture); eprm.set_texture(prm.value.file.texture);
} }
} }
break; break;
@ -508,7 +508,7 @@ void Filter::CustomShader::Instance::video_render(gs_effect_t *effect) {
gs_reset_blend_state(); gs_reset_blend_state();
gs_enable_depth_test(false); gs_enable_depth_test(false);
while (gs_effect_loop(m_effect.effect->GetObject(), "Draw")) { while (gs_effect_loop(m_effect.effect->get_object(), "Draw")) {
obs_source_draw(sourceTexture, 0, 0, baseW, baseH, false); obs_source_draw(sourceTexture, 0, 0, baseW, baseH, false);
} }
} }
@ -530,34 +530,34 @@ void Filter::CustomShader::Instance::get_properties(obs_properties_t *pr) {
for (Parameter& prm : m_effectParameters) { for (Parameter& prm : m_effectParameters) {
switch (prm.type) { switch (prm.type) {
case GS::EffectParameter::Type::Boolean: case gs::effect_parameter::type::Boolean:
obs_properties_add_bool(pr, prm.uiNames[0].c_str(), prm.uiDescriptions[0].c_str()); obs_properties_add_bool(pr, prm.uiNames[0].c_str(), prm.uiDescriptions[0].c_str());
break; break;
case GS::EffectParameter::Type::Float: case gs::effect_parameter::type::Float:
case GS::EffectParameter::Type::Float2: case gs::effect_parameter::type::Float2:
case GS::EffectParameter::Type::Float3: case gs::effect_parameter::type::Float3:
case GS::EffectParameter::Type::Float4: case gs::effect_parameter::type::Float4:
obs_properties_add_float(pr, prm.uiNames[0].c_str(), prm.uiDescriptions[0].c_str(), FLT_MIN, FLT_MAX, FLT_EPSILON); obs_properties_add_float(pr, prm.uiNames[0].c_str(), prm.uiDescriptions[0].c_str(), FLT_MIN, FLT_MAX, FLT_EPSILON);
if (prm.type >= GS::EffectParameter::Type::Float2) if (prm.type >= gs::effect_parameter::type::Float2)
obs_properties_add_float(pr, prm.uiNames[1].c_str(), prm.uiDescriptions[1].c_str(), FLT_MIN, FLT_MAX, FLT_EPSILON); obs_properties_add_float(pr, prm.uiNames[1].c_str(), prm.uiDescriptions[1].c_str(), FLT_MIN, FLT_MAX, FLT_EPSILON);
if (prm.type >= GS::EffectParameter::Type::Float3) if (prm.type >= gs::effect_parameter::type::Float3)
obs_properties_add_float(pr, prm.uiNames[2].c_str(), prm.uiDescriptions[2].c_str(), FLT_MIN, FLT_MAX, FLT_EPSILON); obs_properties_add_float(pr, prm.uiNames[2].c_str(), prm.uiDescriptions[2].c_str(), FLT_MIN, FLT_MAX, FLT_EPSILON);
if (prm.type >= GS::EffectParameter::Type::Float4) if (prm.type >= gs::effect_parameter::type::Float4)
obs_properties_add_float(pr, prm.uiNames[3].c_str(), prm.uiDescriptions[3].c_str(), FLT_MIN, FLT_MAX, FLT_EPSILON); obs_properties_add_float(pr, prm.uiNames[3].c_str(), prm.uiDescriptions[3].c_str(), FLT_MIN, FLT_MAX, FLT_EPSILON);
break; break;
case GS::EffectParameter::Type::Integer: case gs::effect_parameter::type::Integer:
case GS::EffectParameter::Type::Integer2: case gs::effect_parameter::type::Integer2:
case GS::EffectParameter::Type::Integer3: case gs::effect_parameter::type::Integer3:
case GS::EffectParameter::Type::Integer4: case gs::effect_parameter::type::Integer4:
obs_properties_add_int(pr, prm.uiNames[0].c_str(), prm.uiDescriptions[0].c_str(), INT_MIN, INT_MAX, 1); obs_properties_add_int(pr, prm.uiNames[0].c_str(), prm.uiDescriptions[0].c_str(), INT_MIN, INT_MAX, 1);
if (prm.type >= GS::EffectParameter::Type::Integer2) if (prm.type >= gs::effect_parameter::type::Integer2)
obs_properties_add_int(pr, prm.uiNames[1].c_str(), prm.uiDescriptions[1].c_str(), INT_MIN, INT_MAX, 1); obs_properties_add_int(pr, prm.uiNames[1].c_str(), prm.uiDescriptions[1].c_str(), INT_MIN, INT_MAX, 1);
if (prm.type >= GS::EffectParameter::Type::Integer3) if (prm.type >= gs::effect_parameter::type::Integer3)
obs_properties_add_int(pr, prm.uiNames[2].c_str(), prm.uiDescriptions[2].c_str(), INT_MIN, INT_MAX, 1); obs_properties_add_int(pr, prm.uiNames[2].c_str(), prm.uiDescriptions[2].c_str(), INT_MIN, INT_MAX, 1);
if (prm.type >= GS::EffectParameter::Type::Integer4) if (prm.type >= gs::effect_parameter::type::Integer4)
obs_properties_add_int(pr, prm.uiNames[3].c_str(), prm.uiDescriptions[3].c_str(), INT_MIN, INT_MAX, 1); obs_properties_add_int(pr, prm.uiNames[3].c_str(), prm.uiDescriptions[3].c_str(), INT_MIN, INT_MAX, 1);
break; break;
case GS::EffectParameter::Type::Texture: case gs::effect_parameter::type::Texture:
obs_property * pt = obs_properties_add_list(pr, obs_property * pt = obs_properties_add_list(pr,
prm.uiNames[0].c_str(), prm.uiNames[0].c_str(),
prm.uiDescriptions[0].c_str(), prm.uiDescriptions[0].c_str(),
@ -635,7 +635,7 @@ void Filter::CustomShader::Instance::CheckShaderFile(std::string file, float_t t
shaderContent[sz] = '\0'; shaderContent[sz] = '\0';
} }
m_effect.effect = std::make_unique<GS::Effect>(shaderContent.data(), m_effect.path); m_effect.effect = std::make_unique<gs::effect>(shaderContent.data(), m_effect.path);
} catch (std::runtime_error& ex) { } catch (std::runtime_error& ex) {
const char* filterName = obs_source_get_name(m_source); const char* filterName = obs_source_get_name(m_source);
P_LOG_ERROR("[%s] Shader loading failed with error(s): %s", filterName, ex.what()); P_LOG_ERROR("[%s] Shader loading failed with error(s): %s", filterName, ex.what());
@ -650,7 +650,7 @@ std::string Filter::CustomShader::Instance::GetShaderFile() {
void Filter::CustomShader::Instance::CheckTextures(float_t time) { void Filter::CustomShader::Instance::CheckTextures(float_t time) {
for (Parameter& prm : m_effectParameters) { for (Parameter& prm : m_effectParameters) {
if (prm.type != GS::EffectParameter::Type::Texture) if (prm.type != gs::effect_parameter::type::Texture)
continue; continue;
if (prm.value.textureIsSource) { if (prm.value.textureIsSource) {
@ -664,7 +664,7 @@ void Filter::CustomShader::Instance::CheckTextures(float_t time) {
// Ensure that a render target exists. // Ensure that a render target exists.
if (!prm.value.source.rendertarget) if (!prm.value.source.rendertarget)
prm.value.source.rendertarget = std::make_shared<GS::RenderTarget>(GS_RGBA, GS_ZS_NONE); prm.value.source.rendertarget = std::make_shared<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
// Finally check if the source property was modified or is empty. // Finally check if the source property was modified or is empty.
if (prm.value.source.dirty || !prm.value.source.source) { if (prm.value.source.dirty || !prm.value.source.source) {
@ -711,7 +711,7 @@ void Filter::CustomShader::Instance::CheckTextures(float_t time) {
if (doRefresh) { if (doRefresh) {
prm.value.file.dirty = false; prm.value.file.dirty = false;
try { try {
prm.value.file.texture = std::make_shared<GS::Texture>(prm.value.file.path); prm.value.file.texture = std::make_shared<gs::texture>(prm.value.file.path);
} catch (std::runtime_error& ex) { } catch (std::runtime_error& ex) {
const char* filterName = obs_source_get_name(m_source); const char* filterName = obs_source_get_name(m_source);
P_LOG_ERROR("[%s] Loading texture file '%s' failed with error(s): %s", P_LOG_ERROR("[%s] Loading texture file '%s' failed with error(s): %s",
@ -722,19 +722,19 @@ void Filter::CustomShader::Instance::CheckTextures(float_t time) {
} }
} }
bool Filter::CustomShader::Instance::IsSpecialParameter(std::string name, GS::EffectParameter::Type type) { bool Filter::CustomShader::Instance::IsSpecialParameter(std::string name, gs::effect_parameter::type type) {
std::pair<std::string, GS::EffectParameter::Type> reservedParameters[] = { std::pair<std::string, gs::effect_parameter::type> reservedParameters[] = {
{ "ViewProj", GS::EffectParameter::Type::Matrix }, { "ViewProj", gs::effect_parameter::type::Matrix },
{ "ViewSize", GS::EffectParameter::Type::Float2 }, { "ViewSize", gs::effect_parameter::type::Float2 },
{ "ViewSizeI", GS::EffectParameter::Type::Integer2 }, { "ViewSizeI", gs::effect_parameter::type::Integer2 },
{ "Time", GS::EffectParameter::Type::Float }, { "Time", gs::effect_parameter::type::Float },
{ "TimeActive", GS::EffectParameter::Type::Float }, { "TimeActive", gs::effect_parameter::type::Float },
{ "image", GS::EffectParameter::Type::Texture } { "image", gs::effect_parameter::type::Texture }
}; };
std::pair<std::string, GS::EffectParameter::Type> textureParameters[] = { std::pair<std::string, gs::effect_parameter::type> textureParameters[] = {
{ "Size", GS::EffectParameter::Type::Float2 }, { "Size", gs::effect_parameter::type::Float2 },
{ "SizeI", GS::EffectParameter::Type::Integer2 }, { "SizeI", gs::effect_parameter::type::Integer2 },
{ "Texel", GS::EffectParameter::Type::Float2 } { "Texel", gs::effect_parameter::type::Float2 }
}; };
for (auto& kv : reservedParameters) { for (auto& kv : reservedParameters) {
@ -750,8 +750,8 @@ bool Filter::CustomShader::Instance::IsSpecialParameter(std::string name, GS::Ef
secondPart = name.substr(posUnderscore + 1); secondPart = name.substr(posUnderscore + 1);
try { try {
GS::EffectParameter prm = m_effect.effect->GetParameter(firstPart); gs::effect_parameter prm = m_effect.effect->get_parameter(firstPart);
if (prm.GetType() == GS::EffectParameter::Type::Texture) { if (prm.get_type() == gs::effect_parameter::type::Texture) {
for (auto& kv : reservedParameters) { for (auto& kv : reservedParameters) {
if ((secondPart == kv.first) && (type == kv.second)) if ((secondPart == kv.first) && (type == kv.second))
return true; return true;

12
source/filter-custom-shader.h
View File

@ -70,12 +70,12 @@ namespace Filter {
std::string GetShaderFile(); std::string GetShaderFile();
void CheckTextures(float_t time); void CheckTextures(float_t time);
bool IsSpecialParameter(std::string name, GS::EffectParameter::Type type); bool IsSpecialParameter(std::string name, gs::effect_parameter::type type);
private: private:
obs_source_t * m_source; obs_source_t * m_source;
bool m_isActive = true; bool m_isActive = true;
std::unique_ptr<GS::RenderTarget> m_renderTarget; std::unique_ptr<gs::rendertarget> m_renderTarget;
float_t m_activeTime, m_renderTime; float_t m_activeTime, m_renderTime;
@ -85,12 +85,12 @@ namespace Filter {
time_t createTime, modifiedTime; time_t createTime, modifiedTime;
size_t size; size_t size;
float_t lastCheck; float_t lastCheck;
std::unique_ptr<GS::Effect> effect; std::unique_ptr<gs::effect> effect;
} m_effect; } m_effect;
struct Parameter { struct Parameter {
std::string name; std::string name;
GS::EffectParameter::Type type; gs::effect_parameter::type type;
std::vector<std::string> uiNames; std::vector<std::string> uiNames;
std::vector<std::string> uiDescriptions; std::vector<std::string> uiDescriptions;
@ -106,7 +106,7 @@ namespace Filter {
bool dirty = false; bool dirty = false;
std::string name; std::string name;
obs_source_t* source = nullptr; obs_source_t* source = nullptr;
std::shared_ptr<GS::RenderTarget> rendertarget; std::shared_ptr<gs::rendertarget> rendertarget;
} source; } source;
struct File { struct File {
bool dirty = false; bool dirty = false;
@ -114,7 +114,7 @@ namespace Filter {
time_t createTime, modifiedTime; time_t createTime, modifiedTime;
size_t fileSize; size_t fileSize;
float_t lastCheck; float_t lastCheck;
std::shared_ptr<GS::Texture> texture; std::shared_ptr<gs::texture> texture;
} file; } file;
} value; } value;
}; };

12
source/filter-shape.cpp
View File

@ -255,8 +255,8 @@ void Filter::Shape::video_render(void *ptr, gs_effect_t *effect) {
Filter::Shape::Instance::Instance(obs_data_t *data, obs_source_t *context) Filter::Shape::Instance::Instance(obs_data_t *data, obs_source_t *context)
: context(context) { : context(context) {
obs_enter_graphics(); obs_enter_graphics();
m_vertexHelper = new GS::VertexBuffer(maximumPoints); m_vertexHelper = new gs::vertex_buffer(maximumPoints);
m_vertexHelper->SetUVLayers(1); m_vertexHelper->set_uv_layers(1);
m_texRender = gs_texrender_create(GS_RGBA, GS_Z32F); m_texRender = gs_texrender_create(GS_RGBA, GS_Z32F);
obs_leave_graphics(); obs_leave_graphics();
@ -271,9 +271,9 @@ Filter::Shape::Instance::~Instance() {
void Filter::Shape::Instance::update(obs_data_t *data) { void Filter::Shape::Instance::update(obs_data_t *data) {
uint32_t points = (uint32_t)obs_data_get_int(data, P_SHAPE_POINTS); uint32_t points = (uint32_t)obs_data_get_int(data, P_SHAPE_POINTS);
m_vertexHelper->Resize(points); m_vertexHelper->resize(points);
for (uint32_t point = 0; point < points; point++) { for (uint32_t point = 0; point < points; point++) {
GS::Vertex v = m_vertexHelper->At(point); gs::vertex v = m_vertexHelper->at(point);
{ {
auto strings = cache.find(std::make_pair(point, auto strings = cache.find(std::make_pair(point,
P_SHAPE_POINT_X)); P_SHAPE_POINT_X));
@ -311,7 +311,7 @@ void Filter::Shape::Instance::update(obs_data_t *data) {
} }
drawmode = (gs_draw_mode)obs_data_get_int(data, P_SHAPE_MODE); drawmode = (gs_draw_mode)obs_data_get_int(data, P_SHAPE_MODE);
obs_enter_graphics(); obs_enter_graphics();
m_vertexBuffer = m_vertexHelper->Update(); m_vertexBuffer = m_vertexHelper->update();
obs_leave_graphics(); obs_leave_graphics();
} }
@ -386,7 +386,7 @@ void Filter::Shape::Instance::video_render(gs_effect_t *effect) {
tex); tex);
gs_load_vertexbuffer(m_vertexBuffer); gs_load_vertexbuffer(m_vertexBuffer);
gs_load_indexbuffer(nullptr); gs_load_indexbuffer(nullptr);
gs_draw(drawmode, 0, (uint32_t)m_vertexHelper->Size()); gs_draw(drawmode, 0, (uint32_t)m_vertexHelper->size());
} }
gs_matrix_pop(); gs_matrix_pop();

2
source/filter-shape.h
View File

@ -78,7 +78,7 @@ namespace Filter {
private: private:
obs_source_t *context; obs_source_t *context;
gs_effect_t *customEffect; gs_effect_t *customEffect;
GS::VertexBuffer *m_vertexHelper; gs::vertex_buffer *m_vertexHelper;
gs_vertbuffer_t *m_vertexBuffer; gs_vertbuffer_t *m_vertexBuffer;
gs_draw_mode drawmode; gs_draw_mode drawmode;
gs_texrender_t *m_texRender; gs_texrender_t *m_texRender;

16
source/filter-transform.cpp
View File

@ -304,9 +304,9 @@ Filter::Transform::Instance::Instance(obs_data_t *data, obs_source_t *context) :
obs_enter_graphics(); obs_enter_graphics();
m_texRender = gs_texrender_create(GS_RGBA, GS_ZS_NONE); m_texRender = gs_texrender_create(GS_RGBA, GS_ZS_NONE);
m_shapeRender = gs_texrender_create(GS_RGBA, GS_ZS_NONE); m_shapeRender = gs_texrender_create(GS_RGBA, GS_ZS_NONE);
m_vertexHelper = new GS::VertexBuffer(4); m_vertexHelper = new gs::vertex_buffer(4);
m_vertexHelper->SetUVLayers(1); m_vertexHelper->set_uv_layers(1);
m_vertexHelper->Resize(4); m_vertexHelper->resize(4);
obs_leave_graphics(); obs_leave_graphics();
update(data); update(data);
@ -465,7 +465,7 @@ void Filter::Transform::Instance::video_render(gs_effect_t *paramEffect) {
/// Generate mesh /// Generate mesh
{ {
GS::Vertex vtx = m_vertexHelper->At(0); gs::vertex vtx = m_vertexHelper->at(0);
*vtx.color = 0xFFFFFFFF; *vtx.color = 0xFFFFFFFF;
vec4_set(vtx.uv[0], 0, 0, 0, 0); vec4_set(vtx.uv[0], 0, 0, 0, 0);
vec3_set(vtx.position, vec3_set(vtx.position,
@ -474,7 +474,7 @@ void Filter::Transform::Instance::video_render(gs_effect_t *paramEffect) {
vec3_transform(vtx.position, vtx.position, &ident); vec3_transform(vtx.position, vtx.position, &ident);
} }
{ {
GS::Vertex vtx = m_vertexHelper->At(1); gs::vertex vtx = m_vertexHelper->at(1);
*vtx.color = 0xFFFFFFFF; *vtx.color = 0xFFFFFFFF;
vec4_set(vtx.uv[0], 1, 0, 0, 0); vec4_set(vtx.uv[0], 1, 0, 0, 0);
vec3_set(vtx.position, vec3_set(vtx.position,
@ -483,7 +483,7 @@ void Filter::Transform::Instance::video_render(gs_effect_t *paramEffect) {
vec3_transform(vtx.position, vtx.position, &ident); vec3_transform(vtx.position, vtx.position, &ident);
} }
{ {
GS::Vertex vtx = m_vertexHelper->At(2); gs::vertex vtx = m_vertexHelper->at(2);
*vtx.color = 0xFFFFFFFF; *vtx.color = 0xFFFFFFFF;
vec4_set(vtx.uv[0], 0, 1, 0, 0); vec4_set(vtx.uv[0], 0, 1, 0, 0);
vec3_set(vtx.position, vec3_set(vtx.position,
@ -492,7 +492,7 @@ void Filter::Transform::Instance::video_render(gs_effect_t *paramEffect) {
vec3_transform(vtx.position, vtx.position, &ident); vec3_transform(vtx.position, vtx.position, &ident);
} }
{ {
GS::Vertex vtx = m_vertexHelper->At(3); gs::vertex vtx = m_vertexHelper->at(3);
*vtx.color = 0xFFFFFFFF; *vtx.color = 0xFFFFFFFF;
vec4_set(vtx.uv[0], 1, 1, 0, 0); vec4_set(vtx.uv[0], 1, 1, 0, 0);
vec3_set(vtx.position, vec3_set(vtx.position,
@ -501,7 +501,7 @@ void Filter::Transform::Instance::video_render(gs_effect_t *paramEffect) {
vec3_transform(vtx.position, vtx.position, &ident); vec3_transform(vtx.position, vtx.position, &ident);
} }
m_vertexBuffer = m_vertexHelper->Update(); m_vertexBuffer = m_vertexHelper->update();
if (!m_vertexBuffer) { if (!m_vertexBuffer) {
obs_source_skip_video_filter(m_sourceContext); obs_source_skip_video_filter(m_sourceContext);
return; return;

2
source/filter-transform.h
View File

@ -65,7 +65,7 @@ namespace Filter {
private: private:
obs_source_t *m_sourceContext; obs_source_t *m_sourceContext;
GS::VertexBuffer *m_vertexHelper; gs::vertex_buffer *m_vertexHelper;
gs_vertbuffer_t *m_vertexBuffer; gs_vertbuffer_t *m_vertexBuffer;
gs_texrender_t *m_texRender, *m_shapeRender; gs_texrender_t *m_texRender, *m_shapeRender;

6
source/gfx-source-texture.cpp
View File

@ -26,7 +26,7 @@ gfx::SourceTexture::~SourceTexture() {
} }
gfx::SourceTexture::SourceTexture() { gfx::SourceTexture::SourceTexture() {
m_rt = std::make_shared<GS::RenderTarget>(GS_RGBA, GS_ZS_NONE); m_rt = std::make_shared<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
} }
obs_source_t* gfx::SourceTexture::GetObject() { obs_source_t* gfx::SourceTexture::GetObject() {
@ -49,7 +49,7 @@ gfx::SourceTexture::SourceTexture(obs_source_t* src) : SourceTexture() {
} }
} }
std::shared_ptr<GS::Texture> gfx::SourceTexture::Render(size_t width, size_t height) { std::shared_ptr<gs::texture> gfx::SourceTexture::Render(size_t width, size_t height) {
if (!m_source) { if (!m_source) {
throw std::invalid_argument("Missing source to render."); throw std::invalid_argument("Missing source to render.");
} }
@ -68,7 +68,7 @@ std::shared_ptr<GS::Texture> gfx::SourceTexture::Render(size_t width, size_t hei
obs_source_video_render(m_source); obs_source_video_render(m_source);
} }
std::shared_ptr<GS::Texture> tex; std::shared_ptr<gs::texture> tex;
m_rt->GetTexture(tex); m_rt->GetTexture(tex);
return tex; return tex;
} }

4
source/gfx-source-texture.h
View File

@ -25,7 +25,7 @@
namespace gfx { namespace gfx {
class SourceTexture { class SourceTexture {
obs_source_t* m_source; obs_source_t* m_source;
std::shared_ptr<GS::RenderTarget> m_rt; std::shared_ptr<gs::rendertarget> m_rt;
SourceTexture(); SourceTexture();
public: public:
@ -36,6 +36,6 @@ namespace gfx {
obs_source_t* GetObject(); obs_source_t* GetObject();
std::shared_ptr<GS::Texture> Render(size_t width, size_t height); std::shared_ptr<gs::texture> Render(size_t width, size_t height);
}; };
} }

144
source/gs-effect.cpp
View File

@ -26,11 +26,11 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
GS::Effect::Effect() { gs::effect::effect() {
m_effect = nullptr; m_effect = nullptr;
} }
GS::Effect::Effect(std::string file) { gs::effect::effect(std::string file) {
obs_enter_graphics(); obs_enter_graphics();
char* errorMessage = nullptr; char* errorMessage = nullptr;
m_effect = gs_effect_create_from_file(file.c_str(), &errorMessage); m_effect = gs_effect_create_from_file(file.c_str(), &errorMessage);
@ -46,7 +46,7 @@ GS::Effect::Effect(std::string file) {
obs_leave_graphics(); obs_leave_graphics();
} }
GS::Effect::Effect(std::string code, std::string name) { gs::effect::effect(std::string code, std::string name) {
obs_enter_graphics(); obs_enter_graphics();
char* errorMessage = nullptr; char* errorMessage = nullptr;
m_effect = gs_effect_create(code.c_str(), name.c_str(), &errorMessage); m_effect = gs_effect_create(code.c_str(), name.c_str(), &errorMessage);
@ -62,57 +62,57 @@ GS::Effect::Effect(std::string code, std::string name) {
obs_leave_graphics(); obs_leave_graphics();
} }
GS::Effect::~Effect() { gs::effect::~effect() {
obs_enter_graphics(); obs_enter_graphics();
gs_effect_destroy(m_effect); gs_effect_destroy(m_effect);
obs_leave_graphics(); obs_leave_graphics();
} }
gs_effect_t* GS::Effect::GetObject() { gs_effect_t* gs::effect::get_object() {
return m_effect; return m_effect;
} }
size_t GS::Effect::CountParameters() { size_t gs::effect::count_parameters() {
return (size_t)gs_effect_get_num_params(m_effect); return (size_t)gs_effect_get_num_params(m_effect);
} }
std::list<GS::EffectParameter> GS::Effect::GetParameters() { std::list<gs::effect_parameter> gs::effect::get_parameters() {
size_t num = gs_effect_get_num_params(m_effect); size_t num = gs_effect_get_num_params(m_effect);
std::list<GS::EffectParameter> ps; std::list<gs::effect_parameter> ps;
for (size_t idx = 0; idx < num; idx++) { for (size_t idx = 0; idx < num; idx++) {
ps.emplace_back(GetParameter(idx)); ps.emplace_back(get_parameter(idx));
} }
return ps; return ps;
} }
GS::EffectParameter GS::Effect::GetParameter(size_t idx) { gs::effect_parameter gs::effect::get_parameter(size_t idx) {
gs_eparam_t* param = gs_effect_get_param_by_idx(m_effect, idx); gs_eparam_t* param = gs_effect_get_param_by_idx(m_effect, idx);
if (!param) if (!param)
throw std::invalid_argument("parameter with index not found"); throw std::invalid_argument("parameter with index not found");
return EffectParameter(param); return effect_parameter(param);
} }
bool GS::Effect::HasParameter(std::string name) { bool gs::effect::has_parameter(std::string name) {
gs_eparam_t* param = gs_effect_get_param_by_name(m_effect, name.c_str()); gs_eparam_t* param = gs_effect_get_param_by_name(m_effect, name.c_str());
return (param != nullptr); return (param != nullptr);
} }
bool GS::Effect::HasParameter(std::string name, EffectParameter::Type type) { bool gs::effect::has_parameter(std::string name, effect_parameter::type type) {
gs_eparam_t* param = gs_effect_get_param_by_name(m_effect, name.c_str()); gs_eparam_t* param = gs_effect_get_param_by_name(m_effect, name.c_str());
if (param == nullptr) if (param == nullptr)
return false; return false;
GS::EffectParameter eprm(param); gs::effect_parameter eprm(param);
return eprm.GetType() == type; return eprm.get_type() == type;
} }
GS::EffectParameter GS::Effect::GetParameter(std::string name) { gs::effect_parameter gs::effect::get_parameter(std::string name) {
gs_eparam_t* param = gs_effect_get_param_by_name(m_effect, name.c_str()); gs_eparam_t* param = gs_effect_get_param_by_name(m_effect, name.c_str());
if (!param) if (!param)
throw std::invalid_argument("parameter with name not found"); throw std::invalid_argument("parameter with name not found");
return EffectParameter(param); return effect_parameter(param);
} }
GS::EffectParameter::EffectParameter(gs_eparam_t* param) { gs::effect_parameter::effect_parameter(gs_eparam_t* param) {
if (!param) if (!param)
throw std::invalid_argument("param is null"); throw std::invalid_argument("param is null");
@ -120,164 +120,164 @@ GS::EffectParameter::EffectParameter(gs_eparam_t* param) {
gs_effect_get_param_info(m_param, &m_paramInfo); gs_effect_get_param_info(m_param, &m_paramInfo);
} }
std::string GS::EffectParameter::GetName() { std::string gs::effect_parameter::get_name() {
return m_paramInfo.name; return m_paramInfo.name;
} }
GS::EffectParameter::Type GS::EffectParameter::GetType() { gs::effect_parameter::type gs::effect_parameter::get_type() {
switch (m_paramInfo.type) { switch (m_paramInfo.type) {
case GS_SHADER_PARAM_BOOL: case GS_SHADER_PARAM_BOOL:
return Type::Boolean; return type::Boolean;
case GS_SHADER_PARAM_FLOAT: case GS_SHADER_PARAM_FLOAT:
return Type::Float; return type::Float;
case GS_SHADER_PARAM_VEC2: case GS_SHADER_PARAM_VEC2:
return Type::Float2; return type::Float2;
case GS_SHADER_PARAM_VEC3: case GS_SHADER_PARAM_VEC3:
return Type::Float3; return type::Float3;
case GS_SHADER_PARAM_VEC4: case GS_SHADER_PARAM_VEC4:
return Type::Float4; return type::Float4;
case GS_SHADER_PARAM_INT: case GS_SHADER_PARAM_INT:
return Type::Integer; return type::Integer;
case GS_SHADER_PARAM_INT2: case GS_SHADER_PARAM_INT2:
return Type::Integer2; return type::Integer2;
case GS_SHADER_PARAM_INT3: case GS_SHADER_PARAM_INT3:
return Type::Integer3; return type::Integer3;
case GS_SHADER_PARAM_INT4: case GS_SHADER_PARAM_INT4:
return Type::Integer4; return type::Integer4;
case GS_SHADER_PARAM_MATRIX4X4: case GS_SHADER_PARAM_MATRIX4X4:
return Type::Matrix; return type::Matrix;
case GS_SHADER_PARAM_TEXTURE: case GS_SHADER_PARAM_TEXTURE:
return Type::Texture; return type::Texture;
//case GS_SHADER_PARAM_STRING: //case GS_SHADER_PARAM_STRING:
// return Type::String; // return Type::String;
default: default:
case GS_SHADER_PARAM_UNKNOWN: case GS_SHADER_PARAM_UNKNOWN:
return Type::Unknown; return type::Unknown;
} }
} }
void GS::EffectParameter::SetBoolean(bool v) { void gs::effect_parameter::set_bool(bool v) {
if (GetType() != Type::Boolean) if (get_type() != type::Boolean)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_bool(m_param, v); gs_effect_set_bool(m_param, v);
} }
void GS::EffectParameter::SetBooleanArray(bool v[], size_t sz) { void gs::effect_parameter::set_bool_array(bool v[], size_t sz) {
if (GetType() != Type::Boolean) if (get_type() != type::Boolean)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_val(m_param, v, sz); gs_effect_set_val(m_param, v, sz);
} }
void GS::EffectParameter::SetFloat(float_t x) { void gs::effect_parameter::set_float(float_t x) {
if (GetType() != Type::Float) if (get_type() != type::Float)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_float(m_param, x); gs_effect_set_float(m_param, x);
} }
void GS::EffectParameter::SetFloat2(vec2& v) { void gs::effect_parameter::set_float2(vec2& v) {
if (GetType() != Type::Float2) if (get_type() != type::Float2)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_vec2(m_param, &v); gs_effect_set_vec2(m_param, &v);
} }
void GS::EffectParameter::SetFloat2(float_t x, float_t y) { void gs::effect_parameter::set_float2(float_t x, float_t y) {
if (GetType() != Type::Float2) if (get_type() != type::Float2)
throw std::bad_cast(); throw std::bad_cast();
vec2 v = { x, y }; vec2 v = { x, y };
gs_effect_set_vec2(m_param, &v); gs_effect_set_vec2(m_param, &v);
} }
void GS::EffectParameter::SetFloat3(vec3& v) { void gs::effect_parameter::set_float3(vec3& v) {
if (GetType() != Type::Float3) if (get_type() != type::Float3)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_vec3(m_param, &v); gs_effect_set_vec3(m_param, &v);
} }
void GS::EffectParameter::SetFloat3(float_t x, float_t y, float_t z) { void gs::effect_parameter::set_float3(float_t x, float_t y, float_t z) {
if (GetType() != Type::Float3) if (get_type() != type::Float3)
throw std::bad_cast(); throw std::bad_cast();
vec3 v = { x, y, z }; vec3 v = { x, y, z };
gs_effect_set_vec3(m_param, &v); gs_effect_set_vec3(m_param, &v);
} }
void GS::EffectParameter::SetFloat4(vec4& v) { void gs::effect_parameter::set_float4(vec4& v) {
if (GetType() != Type::Float4) if (get_type() != type::Float4)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_vec4(m_param, &v); gs_effect_set_vec4(m_param, &v);
} }
void GS::EffectParameter::SetFloat4(float_t x, float_t y, float_t z, float_t w) { void gs::effect_parameter::set_float4(float_t x, float_t y, float_t z, float_t w) {
if (GetType() != Type::Float4) if (get_type() != type::Float4)
throw std::bad_cast(); throw std::bad_cast();
vec4 v = { x, y, z, w }; vec4 v = { x, y, z, w };
gs_effect_set_vec4(m_param, &v); gs_effect_set_vec4(m_param, &v);
} }
void GS::EffectParameter::SetFloatArray(float_t v[], size_t sz) { void gs::effect_parameter::set_float_array(float_t v[], size_t sz) {
if ((GetType() != Type::Float) && (GetType() != Type::Float2) && (GetType() != Type::Float3) && (GetType() != Type::Float4)) if ((get_type() != type::Float) && (get_type() != type::Float2) && (get_type() != type::Float3) && (get_type() != type::Float4))
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_val(m_param, v, sizeof(float_t) * sz); gs_effect_set_val(m_param, v, sizeof(float_t) * sz);
} }
void GS::EffectParameter::SetInteger(int32_t x) { void gs::effect_parameter::set_int(int32_t x) {
if (GetType() != Type::Integer) if (get_type() != type::Integer)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_int(m_param, x); gs_effect_set_int(m_param, x);
} }
void GS::EffectParameter::SetInteger2(int32_t x, int32_t y) { void gs::effect_parameter::set_int2(int32_t x, int32_t y) {
if (GetType() != Type::Integer2) if (get_type() != type::Integer2)
throw std::bad_cast(); throw std::bad_cast();
int32_t v[] = { x, y }; int32_t v[] = { x, y };
gs_effect_set_val(m_param, v, sizeof(int) * 2); gs_effect_set_val(m_param, v, sizeof(int) * 2);
} }
void GS::EffectParameter::SetInteger3(int32_t x, int32_t y, int32_t z) { void gs::effect_parameter::set_int3(int32_t x, int32_t y, int32_t z) {
if (GetType() != Type::Integer3) if (get_type() != type::Integer3)
throw std::bad_cast(); throw std::bad_cast();
int32_t v[] = { x, y, z }; int32_t v[] = { x, y, z };
gs_effect_set_val(m_param, v, sizeof(int) * 3); gs_effect_set_val(m_param, v, sizeof(int) * 3);
} }
void GS::EffectParameter::SetInteger4(int32_t x, int32_t y, int32_t z, int32_t w) { void gs::effect_parameter::set_int4(int32_t x, int32_t y, int32_t z, int32_t w) {
if (GetType() != Type::Integer4) if (get_type() != type::Integer4)
throw std::bad_cast(); throw std::bad_cast();
int32_t v[] = { x, y, z, w }; int32_t v[] = { x, y, z, w };
gs_effect_set_val(m_param, v, sizeof(int) * 4); gs_effect_set_val(m_param, v, sizeof(int) * 4);
} }
void GS::EffectParameter::SetIntegerArray(int32_t v[], size_t sz) { void gs::effect_parameter::set_int_array(int32_t v[], size_t sz) {
if ((GetType() != Type::Integer) && (GetType() != Type::Integer2) && (GetType() != Type::Integer3) && (GetType() != Type::Integer4)) if ((get_type() != type::Integer) && (get_type() != type::Integer2) && (get_type() != type::Integer3) && (get_type() != type::Integer4))
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_val(m_param, v, sizeof(int) * sz); gs_effect_set_val(m_param, v, sizeof(int) * sz);
} }
void GS::EffectParameter::SetMatrix(matrix4& v) { void gs::effect_parameter::set_matrix(matrix4& v) {
if (GetType() != Type::Matrix) if (get_type() != type::Matrix)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_matrix4(m_param, &v); gs_effect_set_matrix4(m_param, &v);
} }
void GS::EffectParameter::SetTexture(std::shared_ptr<GS::Texture> v) { void gs::effect_parameter::set_texture(std::shared_ptr<gs::texture> v) {
if (GetType() != Type::Texture) if (get_type() != type::Texture)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_texture(m_param, v->GetObject()); gs_effect_set_texture(m_param, v->GetObject());
} }
void GS::EffectParameter::SetTexture(gs_texture_t* v) { void gs::effect_parameter::set_texture(gs_texture_t* v) {
if (GetType() != Type::Texture) if (get_type() != type::Texture)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_texture(m_param, v); gs_effect_set_texture(m_param, v);
} }
void GS::EffectParameter::SetSampler(std::shared_ptr<GS::Sampler> v) { void gs::effect_parameter::set_sampler(std::shared_ptr<gs::sampler> v) {
if (GetType() != Type::Texture) if (get_type() != type::Texture)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_next_sampler(m_param, v->GetObject()); gs_effect_set_next_sampler(m_param, v->GetObject());
} }
void GS::EffectParameter::SetSampler(gs_sampler_state* v) { void gs::effect_parameter::set_sampler(gs_sampler_state* v) {
if (GetType() != Type::Texture) if (get_type() != type::Texture)
throw std::bad_cast(); throw std::bad_cast();
gs_effect_set_next_sampler(m_param, v); gs_effect_set_next_sampler(m_param, v);
} }

76
source/gs-effect.h
View File

@ -35,10 +35,10 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
namespace GS { namespace gs {
class EffectParameter { class effect_parameter {
public: public:
enum class Type : uint8_t { enum class type : uint8_t {
Unknown, Unknown,
Boolean, Boolean,
Float, Float,
@ -55,52 +55,52 @@ namespace GS {
}; };
public: public:
EffectParameter(gs_eparam_t* param); effect_parameter(gs_eparam_t* param);
std::string GetName(); std::string get_name();
Type GetType(); type get_type();
void SetBoolean(bool v); void set_bool(bool v);
void SetBooleanArray(bool v[], size_t sz); void set_bool_array(bool v[], size_t sz);
void SetFloat(float_t x); void set_float(float_t x);
void SetFloat2(vec2& v); void set_float2(vec2& v);
void SetFloat2(float_t x, float_t y); void set_float2(float_t x, float_t y);
void SetFloat3(vec3& v); void set_float3(vec3& v);
void SetFloat3(float_t x, float_t y, float_t z); void set_float3(float_t x, float_t y, float_t z);
void SetFloat4(vec4& v); void set_float4(vec4& v);
void SetFloat4(float_t x, float_t y, float_t z, float_t w); void set_float4(float_t x, float_t y, float_t z, float_t w);
void SetFloatArray(float_t v[], size_t sz); void set_float_array(float_t v[], size_t sz);
void SetInteger(int32_t x); void set_int(int32_t x);
void SetInteger2(int32_t x, int32_t y); void set_int2(int32_t x, int32_t y);
void SetInteger3(int32_t x, int32_t y, int32_t z); void set_int3(int32_t x, int32_t y, int32_t z);
void SetInteger4(int32_t x, int32_t y, int32_t z, int32_t w); void set_int4(int32_t x, int32_t y, int32_t z, int32_t w);
void SetIntegerArray(int32_t v[], size_t sz); void set_int_array(int32_t v[], size_t sz);
void SetMatrix(matrix4& v); void set_matrix(matrix4& v);
void SetTexture(std::shared_ptr<GS::Texture> v); void set_texture(std::shared_ptr<gs::texture> v);
void SetTexture(gs_texture_t* v); void set_texture(gs_texture_t* v);
void SetSampler(std::shared_ptr<GS::Sampler> v); void set_sampler(std::shared_ptr<gs::sampler> v);
void SetSampler(gs_sampler_state* v); void set_sampler(gs_sampler_state* v);
private: private:
gs_eparam_t* m_param; gs_eparam_t* m_param;
gs_effect_param_info m_paramInfo; gs_effect_param_info m_paramInfo;
}; };
class Effect { class effect {
public: public:
Effect(); effect();
Effect(std::string file); effect(std::string file);
Effect(std::string code, std::string name); effect(std::string code, std::string name);
virtual ~Effect(); virtual ~effect();
gs_effect_t* GetObject(); gs_effect_t* get_object();
size_t CountParameters(); size_t count_parameters();
std::list<EffectParameter> GetParameters(); std::list<effect_parameter> get_parameters();
EffectParameter GetParameter(size_t idx); effect_parameter get_parameter(size_t idx);
EffectParameter GetParameter(std::string name); effect_parameter get_parameter(std::string name);
bool HasParameter(std::string name); bool has_parameter(std::string name);
bool HasParameter(std::string name, EffectParameter::Type type); bool has_parameter(std::string name, effect_parameter::type type);
protected: protected:
gs_effect_t* m_effect; gs_effect_t* m_effect;

14
source/gs-indexbuffer.cpp
View File

@ -26,7 +26,7 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
GS::IndexBuffer::IndexBuffer(uint32_t maximumVertices) { gs::index_buffer::index_buffer(uint32_t maximumVertices) {
this->reserve(maximumVertices); this->reserve(maximumVertices);
obs_enter_graphics(); obs_enter_graphics();
@ -34,27 +34,27 @@ GS::IndexBuffer::IndexBuffer(uint32_t maximumVertices) {
obs_leave_graphics(); obs_leave_graphics();
} }
GS::IndexBuffer::IndexBuffer() : IndexBuffer(MAXIMUM_VERTICES) {} gs::index_buffer::index_buffer() : index_buffer(MAXIMUM_VERTICES) {}
GS::IndexBuffer::IndexBuffer(IndexBuffer& other) : IndexBuffer((uint32_t)other.size()) { gs::index_buffer::index_buffer(index_buffer& other) : index_buffer((uint32_t)other.size()) {
std::copy(other.begin(), other.end(), this->end()); std::copy(other.begin(), other.end(), this->end());
} }
GS::IndexBuffer::IndexBuffer(std::vector<uint32_t>& other) : IndexBuffer((uint32_t)other.size()) { gs::index_buffer::index_buffer(std::vector<uint32_t>& other) : index_buffer((uint32_t)other.size()) {
std::copy(other.begin(), other.end(), this->end()); std::copy(other.begin(), other.end(), this->end());
} }
GS::IndexBuffer::~IndexBuffer() { gs::index_buffer::~index_buffer() {
obs_enter_graphics(); obs_enter_graphics();
gs_indexbuffer_destroy(m_indexBuffer); gs_indexbuffer_destroy(m_indexBuffer);
obs_leave_graphics(); obs_leave_graphics();
} }
gs_indexbuffer_t* GS::IndexBuffer::get() { gs_indexbuffer_t* gs::index_buffer::get() {
return get(true); return get(true);
} }
gs_indexbuffer_t* GS::IndexBuffer::get(bool refreshGPU) { gs_indexbuffer_t* gs::index_buffer::get(bool refreshGPU) {
if (refreshGPU) { if (refreshGPU) {
obs_enter_graphics(); obs_enter_graphics();
gs_indexbuffer_flush(m_indexBuffer); gs_indexbuffer_flush(m_indexBuffer);

14
source/gs-indexbuffer.h
View File

@ -27,14 +27,14 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
namespace GS { namespace gs {
class IndexBuffer : public std::vector<uint32_t> { class index_buffer : public std::vector<uint32_t> {
public: public:
IndexBuffer(uint32_t maximumVertices); index_buffer(uint32_t maximumVertices);
IndexBuffer(); index_buffer();
IndexBuffer(IndexBuffer& other); index_buffer(index_buffer& other);
IndexBuffer(std::vector<uint32_t>& other); index_buffer(std::vector<uint32_t>& other);
virtual ~IndexBuffer(); virtual ~index_buffer();
gs_indexbuffer_t* get(); gs_indexbuffer_t* get();

2
source/gs-limits.h
View File

@ -20,7 +20,7 @@
#pragma once #pragma once
#include <inttypes.h> #include <inttypes.h>
namespace GS { namespace gs {
static const uint32_t MAXIMUM_VERTICES = 0xFFFFFFu; static const uint32_t MAXIMUM_VERTICES = 0xFFFFFFu;
static const uint32_t MAXIMUM_UVW_LAYERS = 8u; static const uint32_t MAXIMUM_UVW_LAYERS = 8u;
} }

26
source/gs-rendertarget.cpp
View File

@ -26,43 +26,43 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
GS::RenderTarget::RenderTarget(gs_color_format colorFormat, gs_zstencil_format zsFormat) { gs::rendertarget::rendertarget(gs_color_format colorFormat, gs_zstencil_format zsFormat) {
m_isBeingRendered = false; m_isBeingRendered = false;
obs_enter_graphics(); obs_enter_graphics();
m_renderTarget = gs_texrender_create(colorFormat, zsFormat); m_renderTarget = gs_texrender_create(colorFormat, zsFormat);
obs_leave_graphics(); obs_leave_graphics();
} }
GS::RenderTarget::~RenderTarget() { gs::rendertarget::~rendertarget() {
obs_enter_graphics(); obs_enter_graphics();
gs_texrender_destroy(m_renderTarget); gs_texrender_destroy(m_renderTarget);
obs_leave_graphics(); obs_leave_graphics();
} }
GS::RenderTargetOp GS::RenderTarget::Render(uint32_t width, uint32_t height) { gs::rendertarget_op gs::rendertarget::render(uint32_t width, uint32_t height) {
return { this, width, height }; return { this, width, height };
} }
gs_texture_t* GS::RenderTarget::GetTextureObject() { gs_texture_t* gs::rendertarget::get_object() {
obs_enter_graphics(); obs_enter_graphics();
gs_texture_t* tex = gs_texrender_get_texture(m_renderTarget); gs_texture_t* tex = gs_texrender_get_texture(m_renderTarget);
obs_leave_graphics(); obs_leave_graphics();
return tex; return tex;
} }
void GS::RenderTarget::GetTexture(GS::Texture& tex) { void gs::rendertarget::get_texture(gs::texture& tex) {
tex = GS::Texture(GetTextureObject(), false); tex = gs::texture(get_object(), false);
} }
void GS::RenderTarget::GetTexture(std::shared_ptr<GS::Texture>& tex) { void gs::rendertarget::get_texture(std::shared_ptr<gs::texture>& tex) {
tex = std::make_shared<GS::Texture>(GetTextureObject(), false); tex = std::make_shared<gs::texture>(get_object(), false);
} }
void GS::RenderTarget::GetTexture(std::unique_ptr<GS::Texture>& tex) { void gs::rendertarget::get_texture(std::unique_ptr<gs::texture>& tex) {
tex = std::make_unique<GS::Texture>(GetTextureObject(), false); tex = std::make_unique<gs::texture>(get_object(), false);
} }
GS::RenderTargetOp::RenderTargetOp(GS::RenderTarget* rt, uint32_t width, uint32_t height) : m_renderTarget(rt) { gs::rendertarget_op::rendertarget_op(gs::rendertarget* rt, uint32_t width, uint32_t height) : m_renderTarget(rt) {
if (m_renderTarget == nullptr) if (m_renderTarget == nullptr)
throw std::invalid_argument("rt"); throw std::invalid_argument("rt");
if (m_renderTarget->m_isBeingRendered) if (m_renderTarget->m_isBeingRendered)
@ -77,12 +77,12 @@ GS::RenderTargetOp::RenderTargetOp(GS::RenderTarget* rt, uint32_t width, uint32_
m_renderTarget->m_isBeingRendered = true; m_renderTarget->m_isBeingRendered = true;
} }
GS::RenderTargetOp::RenderTargetOp(GS::RenderTargetOp&& r) { gs::rendertarget_op::rendertarget_op(gs::rendertarget_op&& r) {
this->m_renderTarget = r.m_renderTarget; this->m_renderTarget = r.m_renderTarget;
r.m_renderTarget = nullptr; r.m_renderTarget = nullptr;
} }
GS::RenderTargetOp::~RenderTargetOp() { gs::rendertarget_op::~rendertarget_op() {
if (m_renderTarget == nullptr) if (m_renderTarget == nullptr)
return; return;
obs_enter_graphics(); obs_enter_graphics();

34
source/gs-rendertarget.h
View File

@ -28,38 +28,38 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
namespace GS { namespace gs {
class RenderTarget { class rendertarget {
friend class RenderTargetOp; friend class rendertarget_op;
public: public:
RenderTarget(gs_color_format colorFormat, gs_zstencil_format zsFormat); rendertarget(gs_color_format colorFormat, gs_zstencil_format zsFormat);
virtual ~RenderTarget(); virtual ~rendertarget();
gs_texture_t* GetTextureObject(); gs_texture_t* get_object();
void GetTexture(GS::Texture& tex); void get_texture(gs::texture& tex);
void GetTexture(std::shared_ptr<GS::Texture>& tex); void get_texture(std::shared_ptr<gs::texture>& tex);
void GetTexture(std::unique_ptr<GS::Texture>& tex); void get_texture(std::unique_ptr<gs::texture>& tex);
GS::RenderTargetOp Render(uint32_t width, uint32_t height); gs::rendertarget_op render(uint32_t width, uint32_t height);
protected: protected:
gs_texrender_t* m_renderTarget; gs_texrender_t* m_renderTarget;
bool m_isBeingRendered; bool m_isBeingRendered;
}; };
class RenderTargetOp { class rendertarget_op {
public: public:
RenderTargetOp(GS::RenderTarget* rt, uint32_t width, uint32_t height); rendertarget_op(gs::rendertarget* rt, uint32_t width, uint32_t height);
virtual ~RenderTargetOp(); virtual ~rendertarget_op();
// Move Constructor // Move Constructor
RenderTargetOp(GS::RenderTargetOp&&); rendertarget_op(gs::rendertarget_op&&);
// Copy Constructor // Copy Constructor
RenderTargetOp(const GS::RenderTargetOp&) = delete; rendertarget_op(const gs::rendertarget_op&) = delete;
RenderTargetOp& operator=(const GS::RenderTargetOp& r) = delete; rendertarget_op& operator=(const gs::rendertarget_op& r) = delete;
protected: protected:
GS::RenderTarget* m_renderTarget; gs::rendertarget* m_renderTarget;
}; };
} }

38
source/gs-sampler.cpp
View File

@ -19,77 +19,77 @@
#include "gs-sampler.h" #include "gs-sampler.h"
GS::Sampler::Sampler() { gs::sampler::sampler() {
m_dirty = true; m_dirty = true;
m_samplerInfo = { GS_FILTER_LINEAR, GS_ADDRESS_WRAP, GS_ADDRESS_WRAP, GS_ADDRESS_WRAP, 1, 0 }; m_samplerInfo = { GS_FILTER_LINEAR, GS_ADDRESS_WRAP, GS_ADDRESS_WRAP, GS_ADDRESS_WRAP, 1, 0 };
m_samplerState = nullptr; m_samplerState = nullptr;
} }
GS::Sampler::~Sampler() { gs::sampler::~sampler() {
if (m_samplerState) if (m_samplerState)
gs_samplerstate_destroy(m_samplerState); gs_samplerstate_destroy(m_samplerState);
} }
void GS::Sampler::SetSampleFilter(gs_sample_filter v) { void gs::sampler::set_filter(gs_sample_filter v) {
m_dirty = true; m_dirty = true;
m_samplerInfo.filter = v; m_samplerInfo.filter = v;
} }
gs_sample_filter GS::Sampler::GetSampleFilter() { gs_sample_filter gs::sampler::get_filter() {
return m_samplerInfo.filter; return m_samplerInfo.filter;
} }
void GS::Sampler::SetAddressModeU(gs_address_mode v) { void gs::sampler::set_address_mode_u(gs_address_mode v) {
m_dirty = true; m_dirty = true;
m_samplerInfo.address_u = v; m_samplerInfo.address_u = v;
} }
gs_address_mode GS::Sampler::GetAddressModeU() { gs_address_mode gs::sampler::get_address_mode_u() {
return m_samplerInfo.address_u; return m_samplerInfo.address_u;
} }
void GS::Sampler::SetAddressModeV(gs_address_mode v) { void gs::sampler::set_address_mode_v(gs_address_mode v) {
m_dirty = true; m_dirty = true;
m_samplerInfo.address_v = v; m_samplerInfo.address_v = v;
} }
gs_address_mode GS::Sampler::GetAddressModeV() { gs_address_mode gs::sampler::get_address_mode_v() {
return m_samplerInfo.address_v; return m_samplerInfo.address_v;
} }
void GS::Sampler::SetAddressModeW(gs_address_mode v) { void gs::sampler::set_address_mode_w(gs_address_mode v) {
m_dirty = true; m_dirty = true;
m_samplerInfo.address_w = v; m_samplerInfo.address_w = v;
} }
gs_address_mode GS::Sampler::GetAddressModeW() { gs_address_mode gs::sampler::get_address_mode_w() {
return m_samplerInfo.address_w; return m_samplerInfo.address_w;
} }
void GS::Sampler::SetMaxAnisotropy(int v) { void gs::sampler::set_max_anisotropy(int v) {
m_dirty = true; m_dirty = true;
m_samplerInfo.max_anisotropy = v; m_samplerInfo.max_anisotropy = v;
} }
int GS::Sampler::GetMaxAnisotropy() { int gs::sampler::get_max_anisotropy() {
return m_samplerInfo.max_anisotropy; return m_samplerInfo.max_anisotropy;
} }
void GS::Sampler::SetBorderColor(uint32_t v) { void gs::sampler::set_border_color(uint32_t v) {
m_dirty = true; m_dirty = true;
m_samplerInfo.border_color = v; m_samplerInfo.border_color = v;
} }
void GS::Sampler::SetBorderColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a) { void gs::sampler::set_border_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
m_dirty = true; m_dirty = true;
m_samplerInfo.border_color = a << 24 | r << 16 | g << 8 | b; m_samplerInfo.border_color = a << 24 | r << 16 | g << 8 | b;
} }
uint32_t GS::Sampler::GetBorderColor() { uint32_t gs::sampler::get_border_color() {
return m_samplerInfo.border_color; return m_samplerInfo.border_color;
} }
uint8_t GS::Sampler::GetBorderColor(bool r, bool g, bool b, bool a) { uint8_t gs::sampler::get_border_color(bool r, bool g, bool b, bool a) {
if (a) if (a)
return (m_samplerInfo.border_color >> 24) & 0xFF; return (m_samplerInfo.border_color >> 24) & 0xFF;
if (r) if (r)
@ -101,15 +101,15 @@ uint8_t GS::Sampler::GetBorderColor(bool r, bool g, bool b, bool a) {
return 0; return 0;
} }
gs_sampler_state* GS::Sampler::Refresh() { gs_sampler_state* gs::sampler::refresh() {
gs_samplerstate_destroy(m_samplerState); gs_samplerstate_destroy(m_samplerState);
m_samplerState = gs_samplerstate_create(&m_samplerInfo); m_samplerState = gs_samplerstate_create(&m_samplerInfo);
m_dirty = false; m_dirty = false;
return m_samplerState; return m_samplerState;
} }
gs_sampler_state* GS::Sampler::GetObject() { gs_sampler_state* gs::sampler::get_object() {
if (m_dirty) if (m_dirty)
return Refresh(); return refresh();
return m_samplerState; return m_samplerState;
} }

40
source/gs-sampler.h
View File

@ -26,35 +26,35 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
namespace GS { namespace gs {
class Sampler { class sampler {
public: public:
Sampler(); sampler();
~Sampler(); ~sampler();
void SetSampleFilter(gs_sample_filter v); void set_filter(gs_sample_filter v);
gs_sample_filter GetSampleFilter(); gs_sample_filter get_filter();
void SetAddressModeU(gs_address_mode v); void set_address_mode_u(gs_address_mode v);
gs_address_mode GetAddressModeU(); gs_address_mode get_address_mode_u();
void SetAddressModeV(gs_address_mode v); void set_address_mode_v(gs_address_mode v);
gs_address_mode GetAddressModeV(); gs_address_mode get_address_mode_v();
void SetAddressModeW(gs_address_mode v); void set_address_mode_w(gs_address_mode v);
gs_address_mode GetAddressModeW(); gs_address_mode get_address_mode_w();
void SetMaxAnisotropy(int v); void set_max_anisotropy(int v);
int GetMaxAnisotropy(); int get_max_anisotropy();
void SetBorderColor(uint32_t v); void set_border_color(uint32_t v);
void SetBorderColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a); void set_border_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
uint32_t GetBorderColor(); uint32_t get_border_color();
uint8_t GetBorderColor(bool r, bool g, bool b, bool a); uint8_t get_border_color(bool r, bool g, bool b, bool a);
gs_sampler_state* Refresh(); gs_sampler_state* refresh();
gs_sampler_state* GetObject(); gs_sampler_state* get_object();
private: private:
bool m_dirty; bool m_dirty;

28
source/gs-texture.cpp
View File

@ -29,7 +29,7 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
GS::Texture::Texture(uint32_t width, uint32_t height, gs_color_format format, uint32_t mip_levels, const uint8_t **mip_data, uint32_t flags) { gs::texture::texture(uint32_t width, uint32_t height, gs_color_format format, uint32_t mip_levels, const uint8_t **mip_data, uint32_t flags) {
if (width == 0) if (width == 0)
throw std::logic_error("width must be at least 1"); throw std::logic_error("width must be at least 1");
if (height == 0) if (height == 0)
@ -39,7 +39,7 @@ GS::Texture::Texture(uint32_t width, uint32_t height, gs_color_format format, ui
if (!mip_data) if (!mip_data)
throw std::logic_error("mip_data is invalid"); throw std::logic_error("mip_data is invalid");
if (mip_levels > 1 || flags & Flags::BuildMipMaps) { if (mip_levels > 1 || flags & flags::BuildMipMaps) {
bool isPOT = (pow(2, (int64_t)floor(log(width) / log(2))) == width) bool isPOT = (pow(2, (int64_t)floor(log(width) / log(2))) == width)
&& (pow(2, (int64_t)floor(log(height) / log(2))) == height); && (pow(2, (int64_t)floor(log(height) / log(2))) == height);
if (!isPOT) if (!isPOT)
@ -47,14 +47,14 @@ GS::Texture::Texture(uint32_t width, uint32_t height, gs_color_format format, ui
} }
obs_enter_graphics(); obs_enter_graphics();
m_texture = gs_texture_create(width, height, format, mip_levels, mip_data, (flags & Flags::Dynamic) ? GS_DYNAMIC : 0 | (flags & Flags::BuildMipMaps) ? GS_BUILD_MIPMAPS : 0); m_texture = gs_texture_create(width, height, format, mip_levels, mip_data, (flags & flags::Dynamic) ? GS_DYNAMIC : 0 | (flags & flags::BuildMipMaps) ? GS_BUILD_MIPMAPS : 0);
obs_leave_graphics(); obs_leave_graphics();
if (!m_texture) if (!m_texture)
throw std::runtime_error("Failed to create texture."); throw std::runtime_error("Failed to create texture.");
} }
GS::Texture::Texture(uint32_t width, uint32_t height, uint32_t depth, gs_color_format format, uint32_t mip_levels, const uint8_t **mip_data, uint32_t flags) { gs::texture::texture(uint32_t width, uint32_t height, uint32_t depth, gs_color_format format, uint32_t mip_levels, const uint8_t **mip_data, uint32_t flags) {
if (width == 0) if (width == 0)
throw std::logic_error("width must be at least 1"); throw std::logic_error("width must be at least 1");
if (height == 0) if (height == 0)
@ -66,7 +66,7 @@ GS::Texture::Texture(uint32_t width, uint32_t height, uint32_t depth, gs_color_f
if (!mip_data) if (!mip_data)
throw std::logic_error("mip_data is invalid"); throw std::logic_error("mip_data is invalid");
if (mip_levels > 1 || flags & Flags::BuildMipMaps) { if (mip_levels > 1 || flags & flags::BuildMipMaps) {
bool isPOT = (pow(2, (int64_t)floor(log(width) / log(2))) == width) bool isPOT = (pow(2, (int64_t)floor(log(width) / log(2))) == width)
&& (pow(2, (int64_t)floor(log(height) / log(2))) == height) && (pow(2, (int64_t)floor(log(height) / log(2))) == height)
&& (pow(2, (int64_t)floor(log(depth) / log(2))) == depth); && (pow(2, (int64_t)floor(log(depth) / log(2))) == depth);
@ -75,14 +75,14 @@ GS::Texture::Texture(uint32_t width, uint32_t height, uint32_t depth, gs_color_f
} }
obs_enter_graphics(); obs_enter_graphics();
m_texture = gs_voltexture_create(width, height, depth, format, mip_levels, mip_data, (flags & Flags::Dynamic) ? GS_DYNAMIC : 0 | (flags & Flags::BuildMipMaps) ? GS_BUILD_MIPMAPS : 0); m_texture = gs_voltexture_create(width, height, depth, format, mip_levels, mip_data, (flags & flags::Dynamic) ? GS_DYNAMIC : 0 | (flags & flags::BuildMipMaps) ? GS_BUILD_MIPMAPS : 0);
obs_leave_graphics(); obs_leave_graphics();
if (!m_texture) if (!m_texture)
throw std::runtime_error("Failed to create texture."); throw std::runtime_error("Failed to create texture.");
} }
GS::Texture::Texture(uint32_t size, gs_color_format format, uint32_t mip_levels, const uint8_t **mip_data, uint32_t flags) { gs::texture::texture(uint32_t size, gs_color_format format, uint32_t mip_levels, const uint8_t **mip_data, uint32_t flags) {
if (size == 0) if (size == 0)
throw std::logic_error("size must be at least 1"); throw std::logic_error("size must be at least 1");
if (mip_levels == 0) if (mip_levels == 0)
@ -90,21 +90,21 @@ GS::Texture::Texture(uint32_t size, gs_color_format format, uint32_t mip_levels,
if (!mip_data) if (!mip_data)
throw std::logic_error("mip_data is invalid"); throw std::logic_error("mip_data is invalid");
if (mip_levels > 1 || flags & Flags::BuildMipMaps) { if (mip_levels > 1 || flags & flags::BuildMipMaps) {
bool isPOT = (pow(2, (int64_t)floor(log(size) / log(2))) == size); bool isPOT = (pow(2, (int64_t)floor(log(size) / log(2))) == size);
if (!isPOT) if (!isPOT)
throw std::logic_error("mip mapping requires power of two dimensions"); throw std::logic_error("mip mapping requires power of two dimensions");
} }
obs_enter_graphics(); obs_enter_graphics();
m_texture = gs_cubetexture_create(size, format, mip_levels, mip_data, (flags & Flags::Dynamic) ? GS_DYNAMIC : 0 | (flags & Flags::BuildMipMaps) ? GS_BUILD_MIPMAPS : 0); m_texture = gs_cubetexture_create(size, format, mip_levels, mip_data, (flags & flags::Dynamic) ? GS_DYNAMIC : 0 | (flags & flags::BuildMipMaps) ? GS_BUILD_MIPMAPS : 0);
obs_leave_graphics(); obs_leave_graphics();
if (!m_texture) if (!m_texture)
throw std::runtime_error("Failed to create texture."); throw std::runtime_error("Failed to create texture.");
} }
GS::Texture::Texture(std::string file) { gs::texture::texture(std::string file) {
struct stat st; struct stat st;
if (os_stat(file.c_str(), &st) != 0) if (os_stat(file.c_str(), &st) != 0)
throw std::ios_base::failure(file); throw std::ios_base::failure(file);
@ -117,7 +117,7 @@ GS::Texture::Texture(std::string file) {
throw std::runtime_error("Failed to load texture."); throw std::runtime_error("Failed to load texture.");
} }
GS::Texture::Texture(Texture& other) { gs::texture::texture(texture& other) {
throw std::logic_error("not yet implemented"); throw std::logic_error("not yet implemented");
//obs_enter_graphics(); //obs_enter_graphics();
//switch (gs_get_texture_type(other.m_texture)) { //switch (gs_get_texture_type(other.m_texture)) {
@ -177,7 +177,7 @@ GS::Texture::Texture(Texture& other) {
//obs_leave_graphics(); //obs_leave_graphics();
} }
GS::Texture::~Texture() { gs::texture::~texture() {
if (m_isOwner && m_texture) { if (m_isOwner && m_texture) {
obs_enter_graphics(); obs_enter_graphics();
switch (gs_get_texture_type(m_texture)) { switch (gs_get_texture_type(m_texture)) {
@ -196,12 +196,12 @@ GS::Texture::~Texture() {
m_texture = nullptr; m_texture = nullptr;
} }
void GS::Texture::Load(int unit) { void gs::texture::load(int unit) {
obs_enter_graphics(); obs_enter_graphics();
gs_load_texture(m_texture, unit); gs_load_texture(m_texture, unit);
obs_leave_graphics(); obs_leave_graphics();
} }
gs_texture_t* GS::Texture::GetObject() { gs_texture_t* gs::texture::get_object() {
return m_texture; return m_texture;
} }

28
source/gs-texture.h
View File

@ -27,20 +27,20 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
namespace GS { namespace gs {
class Texture { class texture {
protected: protected:
gs_texture_t * m_texture; gs_texture_t * m_texture;
bool m_isOwner = true; bool m_isOwner = true;
public: public:
enum Type : uint8_t { enum type : uint8_t {
Normal, Normal,
Volume, Volume,
Cube Cube
}; };
enum Flags : uint32_t { enum flags : uint32_t {
Dynamic, Dynamic,
BuildMipMaps, BuildMipMaps,
}; };
@ -58,7 +58,7 @@ namespace GS {
* \param mip_data * \param mip_data
* \param flags * \param flags
*/ */
Texture(uint32_t width, uint32_t height, gs_color_format format, uint32_t mip_levels, texture(uint32_t width, uint32_t height, gs_color_format format, uint32_t mip_levels,
const uint8_t **mip_data, uint32_t flags); const uint8_t **mip_data, uint32_t flags);
/*! /*!
@ -74,7 +74,7 @@ namespace GS {
* \param mip_data * \param mip_data
* \param flags * \param flags
*/ */
Texture(uint32_t width, uint32_t height, uint32_t depth, gs_color_format format, uint32_t mip_levels, texture(uint32_t width, uint32_t height, uint32_t depth, gs_color_format format, uint32_t mip_levels,
const uint8_t **mip_data, uint32_t flags); const uint8_t **mip_data, uint32_t flags);
/*! /*!
@ -88,7 +88,7 @@ namespace GS {
* \param mip_data * \param mip_data
* \param flags * \param flags
*/ */
Texture(uint32_t size, gs_color_format format, uint32_t mip_levels, const uint8_t **mip_data, texture(uint32_t size, gs_color_format format, uint32_t mip_levels, const uint8_t **mip_data,
uint32_t flags); uint32_t flags);
/*! /*!
@ -101,12 +101,12 @@ namespace GS {
* *
* \param file File to create the texture from. * \param file File to create the texture from.
*/ */
Texture(std::string file); texture(std::string file);
/*! /*!
* \brief Create a texture from an existing gs_texture_t object. * \brief Create a texture from an existing gs_texture_t object.
*/ */
Texture(gs_texture_t* tex, bool takeOwnership = false) : m_texture(tex), m_isOwner(takeOwnership) {} texture(gs_texture_t* tex, bool takeOwnership = false) : m_texture(tex), m_isOwner(takeOwnership) {}
/*! /*!
* \brief Copy an existing texture * \brief Copy an existing texture
@ -117,12 +117,12 @@ namespace GS {
* \param other * \param other
* \return * \return
*/ */
Texture(Texture& other); texture(texture& other);
/*! /*!
* \brief Default constructor * \brief Default constructor
*/ */
Texture() : m_texture(nullptr) {} texture() : m_texture(nullptr) {}
/*! /*!
* \brief Destructor * \brief Destructor
@ -131,7 +131,7 @@ namespace GS {
* *
* \return * \return
*/ */
virtual ~Texture(); virtual ~texture();
/*! /*!
* \brief * \brief
@ -141,7 +141,7 @@ namespace GS {
* \param unit * \param unit
* \return void * \return void
*/ */
void Load(int unit); void load(int unit);
/*! /*!
* \brief * \brief
@ -150,6 +150,6 @@ namespace GS {
* *
* \return gs_texture_t* * \return gs_texture_t*
*/ */
gs_texture_t* GetObject(); gs_texture_t* get_object();
}; };
} }

6
source/gs-vertex.cpp
View File

@ -20,7 +20,7 @@
#include "gs-vertex.h" #include "gs-vertex.h"
#include "util-memory.h" #include "util-memory.h"
GS::Vertex::Vertex() { gs::vertex::vertex() {
this->hasStore = true; this->hasStore = true;
this->store = util::malloc_aligned(16, sizeof(vec3) * 3 + sizeof(uint32_t) + sizeof(vec4)*MAXIMUM_UVW_LAYERS); this->store = util::malloc_aligned(16, sizeof(vec3) * 3 + sizeof(uint32_t) + sizeof(vec4)*MAXIMUM_UVW_LAYERS);
this->position = reinterpret_cast<vec3*>(store); this->position = reinterpret_cast<vec3*>(store);
@ -32,12 +32,12 @@ GS::Vertex::Vertex() {
this->color = reinterpret_cast<uint32_t*>(reinterpret_cast<char*>(store) + (16 * (3 + MAXIMUM_UVW_LAYERS))); this->color = reinterpret_cast<uint32_t*>(reinterpret_cast<char*>(store) + (16 * (3 + MAXIMUM_UVW_LAYERS)));
} }
GS::Vertex::~Vertex() { gs::vertex::~vertex() {
if (hasStore) if (hasStore)
util::free_aligned(store); util::free_aligned(store);
} }
GS::Vertex::Vertex(vec3* p, vec3* n, vec3* t, uint32_t* col, vec4* uvs[MAXIMUM_UVW_LAYERS]) gs::vertex::vertex(vec3* p, vec3* n, vec3* t, uint32_t* col, vec4* uvs[MAXIMUM_UVW_LAYERS])
: position(p), normal(n), tangent(t), color(col) { : position(p), normal(n), tangent(t), color(col) {
if (uvs != nullptr) { if (uvs != nullptr) {
for (size_t idx = 0; idx < MAXIMUM_UVW_LAYERS; idx++) { for (size_t idx = 0; idx < MAXIMUM_UVW_LAYERS; idx++) {

10
source/gs-vertex.h
View File

@ -28,17 +28,17 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
namespace GS { namespace gs {
struct Vertex { struct vertex {
vec3* position; vec3* position;
vec3* normal; vec3* normal;
vec3* tangent; vec3* tangent;
uint32_t* color; uint32_t* color;
vec4* uv[MAXIMUM_UVW_LAYERS]; vec4* uv[MAXIMUM_UVW_LAYERS];
Vertex(); vertex();
Vertex(vec3* p, vec3* n, vec3* t, uint32_t* col, vec4* uv[MAXIMUM_UVW_LAYERS]); vertex(vec3* p, vec3* n, vec3* t, uint32_t* col, vec4* uv[MAXIMUM_UVW_LAYERS]);
~Vertex(); ~vertex();
private: private:
bool hasStore; bool hasStore;

50
source/gs-vertexbuffer.cpp
View File

@ -27,7 +27,7 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
GS::VertexBuffer::~VertexBuffer() { gs::vertex_buffer::~vertex_buffer() {
if (m_positions) { if (m_positions) {
util::free_aligned(m_positions); util::free_aligned(m_positions);
m_positions = nullptr; m_positions = nullptr;
@ -69,7 +69,7 @@ GS::VertexBuffer::~VertexBuffer() {
} }
} }
GS::VertexBuffer::VertexBuffer(uint32_t maximumVertices) { gs::vertex_buffer::vertex_buffer(uint32_t maximumVertices) {
if (maximumVertices > MAXIMUM_VERTICES) { if (maximumVertices > MAXIMUM_VERTICES) {
throw std::out_of_range("maximumVertices out of range"); throw std::out_of_range("maximumVertices out of range");
} }
@ -109,10 +109,10 @@ GS::VertexBuffer::VertexBuffer(uint32_t maximumVertices) {
} }
} }
GS::VertexBuffer::VertexBuffer(gs_vertbuffer_t* vb) { gs::vertex_buffer::vertex_buffer(gs_vertbuffer_t* vb) {
gs_vb_data* vbd = gs_vertexbuffer_get_data(vb); gs_vb_data* vbd = gs_vertexbuffer_get_data(vb);
VertexBuffer((uint32_t)vbd->num); vertex_buffer((uint32_t)vbd->num);
this->SetUVLayers((uint32_t)vbd->num_tex); this->set_uv_layers((uint32_t)vbd->num_tex);
if (vbd->points != nullptr) if (vbd->points != nullptr)
std::memcpy(m_positions, vbd->points, vbd->num * sizeof(vec3)); std::memcpy(m_positions, vbd->points, vbd->num * sizeof(vec3));
@ -141,7 +141,7 @@ GS::VertexBuffer::VertexBuffer(gs_vertbuffer_t* vb) {
} }
GS::VertexBuffer::VertexBuffer(VertexBuffer const& other) : VertexBuffer(other.m_capacity) { gs::vertex_buffer::vertex_buffer(vertex_buffer const& other) : vertex_buffer(other.m_capacity) {
// Copy Constructor // Copy Constructor
std::memcpy(m_positions, other.m_positions, m_capacity * sizeof(vec3)); std::memcpy(m_positions, other.m_positions, m_capacity * sizeof(vec3));
std::memcpy(m_normals, other.m_normals, m_capacity * sizeof(vec3)); std::memcpy(m_normals, other.m_normals, m_capacity * sizeof(vec3));
@ -152,7 +152,7 @@ GS::VertexBuffer::VertexBuffer(VertexBuffer const& other) : VertexBuffer(other.m
} }
} }
GS::VertexBuffer::VertexBuffer(VertexBuffer const&& other) { gs::vertex_buffer::vertex_buffer(vertex_buffer const&& other) {
// Move Constructor // Move Constructor
m_capacity = other.m_capacity; m_capacity = other.m_capacity;
m_size = other.m_size; m_size = other.m_size;
@ -168,7 +168,7 @@ GS::VertexBuffer::VertexBuffer(VertexBuffer const&& other) {
m_layerdata = other.m_layerdata; m_layerdata = other.m_layerdata;
} }
void GS::VertexBuffer::operator=(VertexBuffer const&& other) { void gs::vertex_buffer::operator=(vertex_buffer const&& other) {
// Move Assignment // Move Assignment
/// First self-destruct (semi-destruct itself). /// First self-destruct (semi-destruct itself).
if (m_positions) { if (m_positions) {
@ -226,69 +226,69 @@ void GS::VertexBuffer::operator=(VertexBuffer const&& other) {
m_layerdata = other.m_layerdata; m_layerdata = other.m_layerdata;
} }
void GS::VertexBuffer::Resize(uint32_t new_size) { void gs::vertex_buffer::resize(uint32_t new_size) {
if (new_size > m_capacity) { if (new_size > m_capacity) {
throw std::out_of_range("new_size out of range"); throw std::out_of_range("new_size out of range");
} }
m_size = new_size; m_size = new_size;
} }
uint32_t GS::VertexBuffer::Size() { uint32_t gs::vertex_buffer::size() {
return m_size; return m_size;
} }
bool GS::VertexBuffer::Empty() { bool gs::vertex_buffer::empty() {
return m_size == 0; return m_size == 0;
} }
const GS::Vertex GS::VertexBuffer::At(uint32_t idx) { const gs::vertex gs::vertex_buffer::at(uint32_t idx) {
if ((idx < 0) || (idx >= m_size)) { if ((idx < 0) || (idx >= m_size)) {
throw std::out_of_range("idx out of range"); throw std::out_of_range("idx out of range");
} }
GS::Vertex vtx(&m_positions[idx], &m_normals[idx], &m_tangents[idx], &m_colors[idx], nullptr); gs::vertex vtx(&m_positions[idx], &m_normals[idx], &m_tangents[idx], &m_colors[idx], nullptr);
for (size_t n = 0; n < MAXIMUM_UVW_LAYERS; n++) { for (size_t n = 0; n < MAXIMUM_UVW_LAYERS; n++) {
vtx.uv[n] = &m_uvs[n][idx]; vtx.uv[n] = &m_uvs[n][idx];
} }
return vtx; return vtx;
} }
const GS::Vertex GS::VertexBuffer::operator[](uint32_t const pos) { const gs::vertex gs::vertex_buffer::operator[](uint32_t const pos) {
return At(pos); return at(pos);
} }
void GS::VertexBuffer::SetUVLayers(uint32_t layers) { void gs::vertex_buffer::set_uv_layers(uint32_t layers) {
m_layers = layers; m_layers = layers;
} }
uint32_t GS::VertexBuffer::GetUVLayers() { uint32_t gs::vertex_buffer::get_uv_layers() {
return m_layers; return m_layers;
} }
vec3* GS::VertexBuffer::GetPositions() { vec3* gs::vertex_buffer::get_positions() {
return m_positions; return m_positions;
} }
vec3* GS::VertexBuffer::GetNormals() { vec3* gs::vertex_buffer::get_normals() {
return m_normals; return m_normals;
} }
vec3* GS::VertexBuffer::GetTangents() { vec3* gs::vertex_buffer::get_tangents() {
return m_tangents; return m_tangents;
} }
uint32_t* GS::VertexBuffer::GetColors() { uint32_t* gs::vertex_buffer::get_colors() {
return m_colors; return m_colors;
} }
vec4* GS::VertexBuffer::GetUVLayer(size_t idx) { vec4* gs::vertex_buffer::get_uv_layer(size_t idx) {
if ((idx < 0) || (idx >= m_layers)) { if ((idx < 0) || (idx >= m_layers)) {
throw std::out_of_range("idx out of range"); throw std::out_of_range("idx out of range");
} }
return m_uvs[idx]; return m_uvs[idx];
} }
gs_vertbuffer_t* GS::VertexBuffer::Update(bool refreshGPU) { gs_vertbuffer_t* gs::vertex_buffer::update(bool refreshGPU) {
if (!refreshGPU) if (!refreshGPU)
return m_vertexbuffer; return m_vertexbuffer;
@ -326,6 +326,6 @@ gs_vertbuffer_t* GS::VertexBuffer::Update(bool refreshGPU) {
return m_vertexbuffer; return m_vertexbuffer;
} }
gs_vertbuffer_t* GS::VertexBuffer::Update() { gs_vertbuffer_t* gs::vertex_buffer::update() {
return Update(true); return update(true);
} }

48
source/gs-vertexbuffer.h
View File

@ -30,25 +30,25 @@ extern "C" {
#pragma warning( pop ) #pragma warning( pop )
} }
namespace GS { namespace gs {
class VertexBuffer { class vertex_buffer {
public: public:
#pragma region Constructor & Destructor #pragma region Constructor & Destructor
virtual ~VertexBuffer(); virtual ~vertex_buffer();
/*! /*!
* \brief Create a Vertex Buffer with a specific number of Vertices. * \brief Create a Vertex Buffer with a specific number of Vertices.
* *
* \param maximumVertices Maximum amount of vertices to store. * \param maximumVertices Maximum amount of vertices to store.
*/ */
VertexBuffer(uint32_t maximumVertices); vertex_buffer(uint32_t maximumVertices);
/*! /*!
* \brief Create a Vertex Buffer with the maximum number of Vertices. * \brief Create a Vertex Buffer with the maximum number of Vertices.
* *
* \param maximumVertices Maximum amount of vertices to store. * \param maximumVertices Maximum amount of vertices to store.
*/ */
VertexBuffer() : VertexBuffer(MAXIMUM_VERTICES) {}; vertex_buffer() : vertex_buffer(MAXIMUM_VERTICES) {};
/*! /*!
* \brief Create a copy of a Vertex Buffer * \brief Create a copy of a Vertex Buffer
@ -56,7 +56,7 @@ namespace GS {
* *
* \param other The Vertex Buffer to copy * \param other The Vertex Buffer to copy
*/ */
VertexBuffer(gs_vertbuffer_t* other); vertex_buffer(gs_vertbuffer_t* other);
#pragma endregion Constructor & Destructor #pragma endregion Constructor & Destructor
@ -69,7 +69,7 @@ namespace GS {
* *
* \param other * \param other
*/ */
VertexBuffer(VertexBuffer const& other); vertex_buffer(vertex_buffer const& other);
/*! /*!
* \brief Copy Assignment * \brief Copy Assignment
@ -77,7 +77,7 @@ namespace GS {
* *
* \param other * \param other
*/ */
void operator=(VertexBuffer const& other) = delete; void operator=(vertex_buffer const& other) = delete;
// Move Constructor & Assignments // Move Constructor & Assignments
@ -87,7 +87,7 @@ namespace GS {
* *
* \param other * \param other
*/ */
VertexBuffer(VertexBuffer const&& other); vertex_buffer(vertex_buffer const&& other);
/*! /*!
* \brief Move Assignment * \brief Move Assignment
@ -95,24 +95,24 @@ namespace GS {
* *
* \param other * \param other
*/ */
void operator=(VertexBuffer const&& other); void operator=(vertex_buffer const&& other);
#pragma endregion Copy/Move Constructors #pragma endregion Copy/Move Constructors
void Resize(uint32_t new_size); void resize(uint32_t new_size);
uint32_t Size(); uint32_t size();
bool Empty(); bool empty();
const GS::Vertex At(uint32_t idx); const gs::vertex at(uint32_t idx);
const GS::Vertex operator[](uint32_t const pos); const gs::vertex operator[](uint32_t const pos);
void SetUVLayers(uint32_t layers); void set_uv_layers(uint32_t layers);
uint32_t GetUVLayers(); uint32_t get_uv_layers();
/*! /*!
* \brief Directly access the positions buffer * \brief Directly access the positions buffer
@ -120,7 +120,7 @@ namespace GS {
* *
* \return A <vec3*> that points at the first vertex's position. * \return A <vec3*> that points at the first vertex's position.
*/ */
vec3* GetPositions(); vec3* get_positions();
/*! /*!
* \brief Directly access the normals buffer * \brief Directly access the normals buffer
@ -128,7 +128,7 @@ namespace GS {
* *
* \return A <vec3*> that points at the first vertex's normal. * \return A <vec3*> that points at the first vertex's normal.
*/ */
vec3* GetNormals(); vec3* get_normals();
/*! /*!
* \brief Directly access the tangents buffer * \brief Directly access the tangents buffer
@ -136,7 +136,7 @@ namespace GS {
* *
* \return A <vec3*> that points at the first vertex's tangent. * \return A <vec3*> that points at the first vertex's tangent.
*/ */
vec3* GetTangents(); vec3* get_tangents();
/*! /*!
* \brief Directly access the colors buffer * \brief Directly access the colors buffer
@ -144,7 +144,7 @@ namespace GS {
* *
* \return A <uint32_t*> that points at the first vertex's color. * \return A <uint32_t*> that points at the first vertex's color.
*/ */
uint32_t* GetColors(); uint32_t* get_colors();
/*! /*!
* \brief Directly access the uv buffer * \brief Directly access the uv buffer
@ -152,12 +152,12 @@ namespace GS {
* *
* \return A <vec4*> that points at the first vertex's uv. * \return A <vec4*> that points at the first vertex's uv.
*/ */
vec4* GetUVLayer(size_t idx); vec4* get_uv_layer(size_t idx);
#pragma region Update / Grab GS object #pragma region Update / Grab GS object
gs_vertbuffer_t* Update(); gs_vertbuffer_t* update();
gs_vertbuffer_t* Update(bool refreshGPU); gs_vertbuffer_t* update(bool refreshGPU);
#pragma endregion Update / Grab GS object #pragma endregion Update / Grab GS object
private: private:

10
source/source-mirror.cpp
View File

@ -203,8 +203,8 @@ Source::Mirror::Mirror(obs_data_t* data, obs_source_t* src) {
m_rescale = false; m_rescale = false;
m_width = m_height = 1; m_width = m_height = 1;
m_renderTargetScale = std::make_unique<GS::RenderTarget>(GS_RGBA, GS_ZS_NONE); m_renderTargetScale = std::make_unique<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
m_sampler = std::make_shared<GS::Sampler>(); m_sampler = std::make_shared<gs::sampler>();
m_scalingEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT); m_scalingEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT);
update(data); update(data);
@ -323,7 +323,7 @@ void Source::Mirror::video_render(gs_effect_t* effect) {
sh = obs_source_get_height(m_mirrorSource->GetObject()); sh = obs_source_get_height(m_mirrorSource->GetObject());
// Store original Source Texture // Store original Source Texture
std::shared_ptr<GS::Texture> tex = m_mirrorSource->Render(sw, sh); std::shared_ptr<gs::texture> tex = m_mirrorSource->Render(sw, sh);
gs_eparam_t *scale_param = gs_effect_get_param_by_name(m_scalingEffect, "base_dimension_i"); gs_eparam_t *scale_param = gs_effect_get_param_by_name(m_scalingEffect, "base_dimension_i");
if (scale_param) { if (scale_param) {
@ -337,7 +337,7 @@ void Source::Mirror::video_render(gs_effect_t* effect) {
if (m_keepOriginalSize) { if (m_keepOriginalSize) {
{ {
vec4 black; vec4_zero(&black); vec4 black; vec4_zero(&black);
auto op = m_renderTargetScale->Render(m_width, m_height); auto op = m_renderTargetScale->render(m_width, m_height);
gs_ortho(0, (float_t)m_width, 0, (float_t)m_height, 0, 1); gs_ortho(0, (float_t)m_width, 0, (float_t)m_height, 0, 1);
gs_clear(GS_CLEAR_COLOR, &black, 0, 0); gs_clear(GS_CLEAR_COLOR, &black, 0, 0);
while (gs_effect_loop(m_scalingEffect, "Draw")) { while (gs_effect_loop(m_scalingEffect, "Draw")) {
@ -349,7 +349,7 @@ void Source::Mirror::video_render(gs_effect_t* effect) {
while (gs_effect_loop(obs_get_base_effect(OBS_EFFECT_DEFAULT), "Draw")) { while (gs_effect_loop(obs_get_base_effect(OBS_EFFECT_DEFAULT), "Draw")) {
gs_eparam_t* image = gs_effect_get_param_by_name(obs_get_base_effect(OBS_EFFECT_DEFAULT), "image"); gs_eparam_t* image = gs_effect_get_param_by_name(obs_get_base_effect(OBS_EFFECT_DEFAULT), "image");
gs_effect_set_next_sampler(image, m_sampler->GetObject()); gs_effect_set_next_sampler(image, m_sampler->GetObject());
obs_source_draw(m_renderTargetScale->GetTextureObject(), 0, 0, sw, sh, false); obs_source_draw(m_renderTargetScale->get_object(), 0, 0, sw, sh, false);
} }
} else { } else {
while (gs_effect_loop(m_scalingEffect, "Draw")) { while (gs_effect_loop(m_scalingEffect, "Draw")) {

4
source/source-mirror.h
View File

@ -58,8 +58,8 @@ namespace Source {
bool m_rescale = false; bool m_rescale = false;
bool m_keepOriginalSize = false; bool m_keepOriginalSize = false;
uint32_t m_width, m_height; uint32_t m_width, m_height;
std::unique_ptr<GS::RenderTarget> m_renderTargetScale; std::unique_ptr<gs::rendertarget> m_renderTargetScale;
std::shared_ptr<GS::Sampler> m_sampler; std::shared_ptr<gs::sampler> m_sampler;
gs_effect_t* m_scalingEffect = nullptr; gs_effect_t* m_scalingEffect = nullptr;
std::unique_ptr<gfx::SourceTexture> m_mirrorSource; std::unique_ptr<gfx::SourceTexture> m_mirrorSource;