public/gpu-screen-recorder-ui
1
0
Fork 0
mirror of https://repo.dec05eba.com/gpu-screen-recorder-ui synced 2026-03-31 09:17:04 +09:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add widgets for settings page, add list to auto position widgets

Browse Source
This commit is contained in:
dec05eba
2024-08-02 23:38:23 +02:00
parent 7c4af06d95
commit 2869ef7cec
18 changed files with 348 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
TODO
View File

@@ -11,3 +11,5 @@ Maybe change design to have black triangles appear and get larger until they fil
DISPLAY gamescope-0
Colorscheme should follow graphics card in use. On nvidia use nvidia green, on intel use intel blue and on amd use amd red.
Optimize list/page when having a few items in it (dont use vector<unique_ptr<Widget>>).

2
depends/mglpp

Submodule depends/mglpp updated: a0971b0a12...171b42c390

2
include/gui/Button.hpp
View File

@@ -16,7 +16,7 @@ namespace gsr {
bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
void draw(mgl::Window &window, mgl::vec2f offset) override;
mgl::vec2f get_size() const { return size; }
mgl::vec2f get_size() override { return size; }
std::function<void()> on_click;
private:

2
include/gui/ComboBox.hpp
View File

@@ -17,7 +17,7 @@ namespace gsr {
void add_item(const std::string &text, const std::string &id);
mgl::vec2f get_size();
mgl::vec2f get_size() override;
private:
void update_if_dirty();
private:

2
include/gui/DropdownButton.hpp
View File

@@ -22,7 +22,7 @@ namespace gsr {
void set_activated(bool activated);
mgl::vec2f get_size();
mgl::vec2f get_size() override;
std::function<void(const std::string &id)> on_click;
private:

2
include/gui/Label.hpp
View File

@@ -16,7 +16,7 @@ namespace gsr {
bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
void draw(mgl::Window &window, mgl::vec2f offset) override;
mgl::vec2f get_size();
mgl::vec2f get_size() override;
private:
mgl::Text text;
};

28
include/gui/List.hpp Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
#include "Widget.hpp"
#include <vector>
#include <memory>
namespace gsr {
class List : public Widget {
public:
enum class Orientation {
VERTICAL,
HORIZONTAL
};
List(Orientation orientation);
List(const List&) = delete;
List& operator=(const List&) = delete;
bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
void draw(mgl::Window &window, mgl::vec2f offset) override;
void add_widget(std::unique_ptr<Widget> widget);
mgl::vec2f get_size() override;
protected:
std::vector<std::unique_ptr<Widget>> widgets;
Orientation orientation;
};
}

2
include/gui/ScrollablePage.hpp
View File

@@ -12,7 +12,7 @@ namespace gsr {
bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
void draw(mgl::Window &window, mgl::vec2f offset) override;
mgl::vec2f get_size() const { return size; }
mgl::vec2f get_size() override { return size; }
private:
float get_border_size(mgl::Window &window) const;
private:

2
include/gui/StaticPage.hpp
View File

@@ -12,7 +12,7 @@ namespace gsr {
bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
void draw(mgl::Window &window, mgl::vec2f offset) override;
mgl::vec2f get_size() const { return size; }
mgl::vec2f get_size() override { return size; }
private:
mgl::vec2f size;
};

9
include/gui/Widget.hpp
View File

@@ -11,6 +11,8 @@ namespace gsr {
class Widget {
friend class StaticPage;
friend class ScrollablePage;
friend class List;
friend class Page;
public:
Widget();
Widget(const Widget&) = delete;
@@ -23,8 +25,13 @@ namespace gsr {
virtual void set_position(mgl::vec2f position);
virtual mgl::vec2f get_position() const;
virtual mgl::vec2f get_size() = 0;
protected:
void set_widget_as_selected_in_parent();
void remove_widget_as_selected_in_parent();
protected:
mgl::vec2f position;
bool move_to_top = false;
Widget *parent_widget = nullptr;
Widget *selected_child_widget = nullptr;
};
}

7
src/gui/ComboBox.cpp
View File

@@ -33,6 +33,7 @@ namespace gsr {
if(mgl::FloatRect(pos - mgl::vec2f(padding_left, padding_top), item_size).contains(mouse_pos)) {
selected_item = i;
show_dropdown = false;
remove_widget_as_selected_in_parent();
return false;
}
pos.y += text_bounds.size.y + padding_top + padding_bottom;
@@ -42,9 +43,13 @@ namespace gsr {
if(mgl::FloatRect(draw_pos, item_size).contains(mouse_pos)) {
show_dropdown = !show_dropdown;
if(show_dropdown)
move_to_top = true;
set_widget_as_selected_in_parent();
else
remove_widget_as_selected_in_parent();
return false;
} else {
show_dropdown = false;
remove_widget_as_selected_in_parent();
}
}
return true;

13
src/gui/DropdownButton.cpp
View File

@@ -37,9 +37,20 @@ namespace gsr {
}
} else if(event.type == mgl::Event::MouseButtonPressed) {
const bool clicked_inside = mouse_inside;
if(show_dropdown && clicked_inside && mouse_inside_item == -1) {
show_dropdown = false;
remove_widget_as_selected_in_parent();
return false;
}
show_dropdown = clicked_inside;
if(show_dropdown)
move_to_top = true;
set_widget_as_selected_in_parent();
else
remove_widget_as_selected_in_parent();
if(mouse_inside_item >= 0 && mouse_inside_item < (int)items.size()) {
if(on_click)
on_click(items[mouse_inside_item].id);

85
src/gui/List.cpp Normal file
View File

@@ -0,0 +1,85 @@
#include "../../include/gui/List.hpp"
namespace gsr {
// TODO: Make this modifiable, multiple by window size.
// TODO: Add homogeneous option, using a specified max size of this list.
static const mgl::vec2f spacing(30.0f, 10.0f);
List::List(Orientation orientation) : orientation(orientation) {}
bool List::on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f) {
if(selected_child_widget) {
if(!selected_child_widget->on_event(event, window, mgl::vec2f(0.0f, 0.0f)))
return false;
}
// Process widgets by visibility (backwards)
for(auto it = widgets.rbegin(), end = widgets.rend(); it != end; ++it) {
// Ignore offset because widgets are positioned with offset in ::draw, this solution is simpler
if(it->get() != selected_child_widget) {
if(!(*it)->on_event(event, window, mgl::vec2f(0.0f, 0.0f)))
return false;
}
}
return true;
}
void List::draw(mgl::Window &window, mgl::vec2f offset) {
mgl::vec2f draw_pos = position + offset;
// TODO: Do same vertical/horizontal alignment for items
switch(orientation) {
case Orientation::VERTICAL: {
for(auto &widget : widgets) {
widget->set_position(draw_pos);
if(widget.get() != selected_child_widget)
widget->draw(window, mgl::vec2f(0.0f, 0.0f));
draw_pos.y += widget->get_size().y + spacing.y;
}
break;
}
case Orientation::HORIZONTAL: {
for(auto &widget : widgets) {
widget->set_position(draw_pos);
if(widget.get() != selected_child_widget)
widget->draw(window, mgl::vec2f(0.0f, 0.0f));
draw_pos.x += widget->get_size().x + spacing.x;
}
break;
}
}
if(selected_child_widget)
selected_child_widget->draw(window, mgl::vec2f(0.0f, 0.0f));
}
void List::add_widget(std::unique_ptr<Widget> widget) {
widget->parent_widget = this;
widgets.push_back(std::move(widget));
}
// TODO: Cache result
mgl::vec2f List::get_size() {
mgl::vec2f size;
switch(orientation) {
case Orientation::VERTICAL: {
for(auto &widget : widgets) {
const auto widget_size = widget->get_size();
size.x = std::max(size.x, widget_size.x);
size.y += widget_size.y + spacing.y;
}
break;
}
case Orientation::HORIZONTAL: {
for(auto &widget : widgets) {
const auto widget_size = widget->get_size();
size.x += widget_size.x + spacing.x;
size.y = std::max(size.y, widget_size.y);
}
break;
}
}
return size;
}
}

1
src/gui/Page.cpp
View File

@@ -2,6 +2,7 @@
namespace gsr {
void Page::add_widget(std::unique_ptr<Widget> widget) {
widget->parent_widget = this;
widgets.push_back(std::move(widget));
}
}

18
src/gui/ScrollablePage.cpp
View File

@@ -11,11 +11,18 @@ namespace gsr {
const mgl::vec2f draw_pos = position + offset;
offset = draw_pos + mgl::vec2f(0.0f, get_border_size(window)).floor();
if(selected_child_widget) {
if(!selected_child_widget->on_event(event, window, offset))
return false;
}
// Process widgets by visibility (backwards)
for(auto it = widgets.rbegin(), end = widgets.rend(); it != end; ++it) {
if(it->get() != selected_child_widget) {
if(!(*it)->on_event(event, window, offset))
return false;
}
}
return true;
}
@@ -44,16 +51,13 @@ namespace gsr {
window.draw(border);
for(auto &widget : widgets) {
if(widget->move_to_top) {
widget->move_to_top = false;
std::swap(widget, widgets.back());
}
}
for(auto &widget : widgets) {
if(widget.get() != selected_child_widget)
widget->draw(window, offset);
}
if(selected_child_widget)
selected_child_widget->draw(window, offset);
mgl_window_set_scissor(window.internal_window(), &prev_scissor);
}

18
src/gui/StaticPage.cpp
View File

@@ -9,11 +9,18 @@ namespace gsr {
const mgl::vec2f draw_pos = position + offset;
offset = draw_pos;
if(selected_child_widget) {
if(!selected_child_widget->on_event(event, window, offset))
return false;
}
// Process widgets by visibility (backwards)
for(auto it = widgets.rbegin(), end = widgets.rend(); it != end; ++it) {
if(it->get() != selected_child_widget) {
if(!(*it)->on_event(event, window, offset))
return false;
}
}
return true;
}
@@ -32,16 +39,13 @@ namespace gsr {
mgl_window_set_scissor(window.internal_window(), &new_scissor);
for(auto &widget : widgets) {
if(widget->move_to_top) {
widget->move_to_top = false;
std::swap(widget, widgets.back());
}
}
for(auto &widget : widgets) {
if(widget.get() != selected_child_widget)
widget->draw(window, offset);
}
if(selected_child_widget)
selected_child_widget->draw(window, offset);
mgl_window_set_scissor(window.internal_window(), &prev_scissor);
}
}

14
src/gui/Widget.cpp
View File

@@ -16,4 +16,18 @@ namespace gsr {
mgl::vec2f Widget::get_position() const {
return position;
}
void Widget::set_widget_as_selected_in_parent() {
if(parent_widget) {
parent_widget->selected_child_widget = this;
parent_widget->set_widget_as_selected_in_parent();
}
}
void Widget::remove_widget_as_selected_in_parent() {
if(parent_widget && parent_widget->selected_child_widget == this) {
parent_widget->selected_child_widget = nullptr;
parent_widget->remove_widget_as_selected_in_parent();
}
}
}

302
src/main.cpp
View File

@@ -5,6 +5,7 @@
#include "../include/gui/Button.hpp"
#include "../include/gui/ComboBox.hpp"
#include "../include/gui/Label.hpp"
#include "../include/gui/List.hpp"
#include "../include/Process.hpp"
#include "../include/Theme.hpp"
#include "../include/GsrInfo.hpp"
@@ -181,6 +182,162 @@ static std::string color_to_hex_str(mgl::Color color) {
return result;
}
static void add_widgets_to_settings_page(mgl::Font &title_font, mgl::vec2i window_size, mgl::vec2f settings_page_position, mgl::vec2f settings_page_size, gsr::Page *settings_page, gsr::Page *settings_content_page, const gsr::GsrInfo &gsr_info, const std::vector<gsr::AudioDevice> &audio_devices, std::function<void()> settings_back_button_callback) {
auto back_button = std::make_unique<gsr::Button>(&title_font, "Back", mgl::vec2f(window_size.x / 10, window_size.y / 15), gsr::get_theme().scrollable_page_bg_color);
back_button->set_position(settings_page_position + mgl::vec2f(settings_page_size.x + window_size.x / 50, 0.0f).floor());
back_button->on_click = settings_back_button_callback;
settings_page->add_widget(std::move(back_button));
auto settings_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
settings_list->set_position(mgl::vec2f(50.0f, 50.0f));
{
auto record_area_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
{
record_area_list->add_widget(std::make_unique<gsr::Label>(&title_font, "Record area:", gsr::get_theme().text_color));
auto record_area_box = std::make_unique<gsr::ComboBox>(&title_font);
// TODO: Show options not supported but disable them
if(gsr_info.supported_capture_options.window)
record_area_box->add_item("Window", "window");
if(gsr_info.supported_capture_options.focused)
record_area_box->add_item("Focused window", "focused");
if(gsr_info.supported_capture_options.screen)
record_area_box->add_item("All monitors", "screen");
for(const auto &monitor : gsr_info.supported_capture_options.monitors) {
char name[256];
snprintf(name, sizeof(name), "%s (%dx%d)", monitor.name.c_str(), monitor.size.x, monitor.size.y);
record_area_box->add_item(name, monitor.name);
}
if(gsr_info.supported_capture_options.portal)
record_area_box->add_item("Desktop portal", "portal");
record_area_list->add_widget(std::move(record_area_box));
}
settings_list->add_widget(std::move(record_area_list));
auto audio_devices_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
{
audio_devices_list->add_widget(std::make_unique<gsr::Label>(&title_font, "Audio:", gsr::get_theme().text_color));
auto audio_device_box = std::make_unique<gsr::ComboBox>(&title_font);
for(const auto &audio_device : audio_devices) {
audio_device_box->add_item(audio_device.description, audio_device.name);
}
audio_devices_list->add_widget(std::move(audio_device_box));
}
settings_list->add_widget(std::move(audio_devices_list));
auto quality_list = std::make_unique<gsr::List>(gsr::List::Orientation::HORIZONTAL);
{
auto video_quality_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
{
video_quality_list->add_widget(std::make_unique<gsr::Label>(&title_font, "Video quality:", gsr::get_theme().text_color));
auto video_quality_box = std::make_unique<gsr::ComboBox>(&title_font);
video_quality_box->add_item("Medium", "medium");
video_quality_box->add_item("High (Recommended for live streaming)", "high");
video_quality_box->add_item("Very High (Recommended)", "very_high");
video_quality_box->add_item("Ultra", "ultra");
video_quality_list->add_widget(std::move(video_quality_box));
}
quality_list->add_widget(std::move(video_quality_list));
auto color_range_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
{
color_range_list->add_widget(std::make_unique<gsr::Label>(&title_font, "Color range:", gsr::get_theme().text_color));
auto color_range_box = std::make_unique<gsr::ComboBox>(&title_font);
color_range_box->add_item("Limited", "limited");
color_range_box->add_item("Full", "full");
color_range_list->add_widget(std::move(color_range_box));
}
quality_list->add_widget(std::move(color_range_list));
auto framerate_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
{
framerate_list->add_widget(std::make_unique<gsr::Label>(&title_font, "Frame rate:", gsr::get_theme().text_color));
auto framerate_box = std::make_unique<gsr::ComboBox>(&title_font);
framerate_box->add_item("60", "60");
framerate_box->add_item("30", "30");
framerate_list->add_widget(std::move(framerate_box));
}
quality_list->add_widget(std::move(framerate_list));
}
settings_list->add_widget(std::move(quality_list));
auto codec_list = std::make_unique<gsr::List>(gsr::List::Orientation::HORIZONTAL);
{
auto video_codec_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
{
video_codec_list->add_widget(std::make_unique<gsr::Label>(&title_font, "Video codec:", gsr::get_theme().text_color));
auto video_codec_box = std::make_unique<gsr::ComboBox>(&title_font);
// TODO: Show options not supported but disable them
video_codec_box->add_item("Auto (Recommended)", "auto");
if(gsr_info.supported_video_codecs.h264)
video_codec_box->add_item("H264", "h264");
if(gsr_info.supported_video_codecs.hevc)
video_codec_box->add_item("HEVC", "hevc");
if(gsr_info.supported_video_codecs.av1)
video_codec_box->add_item("AV1", "av1");
if(gsr_info.supported_video_codecs.vp8)
video_codec_box->add_item("VP8", "vp8");
if(gsr_info.supported_video_codecs.vp9)
video_codec_box->add_item("VP9", "vp9");
// TODO: Add hdr options
video_codec_box->add_item("H264 Software Encoder (Slow, not recommended)", "h264_software");
video_codec_list->add_widget(std::move(video_codec_box));
}
codec_list->add_widget(std::move(video_codec_list));
auto audio_codec_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
{
audio_codec_list->add_widget(std::make_unique<gsr::Label>(&title_font, "Audio codec:", gsr::get_theme().text_color));
auto audio_codec_box = std::make_unique<gsr::ComboBox>(&title_font);
audio_codec_box->add_item("Opus (Recommended)", "opus");
audio_codec_box->add_item("AAC", "aac");
audio_codec_list->add_widget(std::move(audio_codec_box));
}
codec_list->add_widget(std::move(audio_codec_list));
}
settings_list->add_widget(std::move(codec_list));
auto framerate_mode_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
{
framerate_mode_list->add_widget(std::make_unique<gsr::Label>(&title_font, "Frame rate mode:", gsr::get_theme().text_color));
auto framerate_mode_box = std::make_unique<gsr::ComboBox>(&title_font);
framerate_mode_box->add_item("Auto (Recommended)", "auto");
framerate_mode_box->add_item("Constant", "cfr");
framerate_mode_box->add_item("Variable", "vfr");
framerate_mode_list->add_widget(std::move(framerate_mode_box));
}
settings_list->add_widget(std::move(framerate_mode_list));
auto file_list = std::make_unique<gsr::List>(gsr::List::Orientation::HORIZONTAL);
{
auto save_directory_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
{
save_directory_list->add_widget(std::make_unique<gsr::Label>(&title_font, "Directory to save the video:", gsr::get_theme().text_color));
auto directory_selection_box = std::make_unique<gsr::ComboBox>(&title_font);
// TODO:
directory_selection_box->add_item("/home/dec05eba/Videos", "mp4");
save_directory_list->add_widget(std::move(directory_selection_box));
}
file_list->add_widget(std::move(save_directory_list));
auto container_list = std::make_unique<gsr::List>(gsr::List::Orientation::VERTICAL);
{
container_list->add_widget(std::make_unique<gsr::Label>(&title_font, "Container:", gsr::get_theme().text_color));
auto container_box = std::make_unique<gsr::ComboBox>(&title_font);
container_box->add_item("mp4", "mp4");
container_box->add_item("mkv", "matroska");
container_box->add_item("flv", "flv");
container_box->add_item("mov", "mov");
container_box->add_item("ts", "mpegts");
container_box->add_item("m3u8", "hls");
container_list->add_widget(std::move(container_box));
}
file_list->add_widget(std::move(container_list));
}
settings_list->add_widget(std::move(file_list));
}
settings_content_page->add_widget(std::move(settings_list));
}
int main(int argc, char **argv) {
if(argc != 1)
usage();
@@ -566,153 +723,10 @@ int main(int argc, char **argv) {
current_page = &front_page;
};
const mgl::vec2f page_widget_spacing{window_size.x / 100.0f, window_size.y / 40.0f};
for(int i = 0; i < num_settings_pages; ++i) {
mgl::vec2f settings_page_widget_pos{50.0f, 50.0f};
gsr::Page *settings_page = settings_pages[i];
gsr::Page *settings_content_page = settings_content_pages[i];
auto back_button = std::make_unique<gsr::Button>(&title_font, "Back", mgl::vec2f(window_size.x / 10, window_size.y / 15), gsr::get_theme().scrollable_page_bg_color);
back_button->set_position(settings_page_position + mgl::vec2f(settings_page_size.x + window_size.x / 50, 0.0f).floor());
back_button->on_click = settings_back_button_callback;
settings_page->add_widget(std::move(back_button));
auto record_area_label = std::make_unique<gsr::Label>(&title_font, "Record area:", gsr::get_theme().text_color);
record_area_label->set_position(settings_page_widget_pos);
settings_page_widget_pos.y += record_area_label->get_size().y + page_widget_spacing.y / 3;
auto record_area_box = std::make_unique<gsr::ComboBox>(&title_font);
record_area_box->set_position(settings_page_widget_pos);
// TODO: Show options not supported but disable them
if(gsr_info.supported_capture_options.window)
record_area_box->add_item("Window", "window");
if(gsr_info.supported_capture_options.focused)
record_area_box->add_item("Focused window", "focused");
if(gsr_info.supported_capture_options.screen)
record_area_box->add_item("All monitors", "screen");
for(const auto &monitor : gsr_info.supported_capture_options.monitors) {
char name[256];
snprintf(name, sizeof(name), "%s (%dx%d)", monitor.name.c_str(), monitor.size.x, monitor.size.y);
record_area_box->add_item(name, monitor.name);
}
if(gsr_info.supported_capture_options.portal)
record_area_box->add_item("Desktop portal", "portal");
settings_page_widget_pos.y += record_area_box->get_size().y + page_widget_spacing.y;
auto audio_device_box = std::make_unique<gsr::ComboBox>(&title_font);
audio_device_box->set_position(settings_page_widget_pos);
for(const auto &audio_device : audio_devices) {
audio_device_box->add_item(audio_device.description, audio_device.name);
}
settings_page_widget_pos.y += audio_device_box->get_size().y + page_widget_spacing.y;
auto framerate_label = std::make_unique<gsr::Label>(&title_font, "Frame rate:", gsr::get_theme().text_color);
framerate_label->set_position(settings_page_widget_pos);
settings_page_widget_pos.y += framerate_label->get_size().y + page_widget_spacing.y / 3;
auto framerate_box = std::make_unique<gsr::ComboBox>(&title_font);
framerate_box->set_position(settings_page_widget_pos);
framerate_box->add_item("60", "60");
framerate_box->add_item("30", "30");
settings_page_widget_pos.y += framerate_box->get_size().y + page_widget_spacing.y;
auto video_quality_label = std::make_unique<gsr::Label>(&title_font, "Video quality:", gsr::get_theme().text_color);
video_quality_label->set_position(settings_page_widget_pos);
const auto video_quality_label_pos = video_quality_label->get_position();
settings_page_widget_pos.y += video_quality_label->get_size().y + page_widget_spacing.y / 3;
auto video_quality_box = std::make_unique<gsr::ComboBox>(&title_font);
video_quality_box->set_position(settings_page_widget_pos);
video_quality_box->add_item("Medium", "medium");
video_quality_box->add_item("High (Recommended for live streaming)", "high");
video_quality_box->add_item("Very High (Recommended)", "very_high");
video_quality_box->add_item("Ultra", "ultra");
const auto video_quality_box_pos = video_quality_box->get_position();
const mgl::vec2f video_quality_box_size = video_quality_box->get_size();
settings_page_widget_pos.y += video_quality_box_size.y + page_widget_spacing.y;
auto color_range_label = std::make_unique<gsr::Label>(&title_font, "Color range:", gsr::get_theme().text_color);
color_range_label->set_position(video_quality_label_pos + mgl::vec2f(video_quality_box_size.x + page_widget_spacing.x, 0.0f).floor());
auto color_range_box = std::make_unique<gsr::ComboBox>(&title_font);
color_range_box->set_position(video_quality_box_pos + mgl::vec2f(video_quality_box_size.x + page_widget_spacing.x, 0.0f).floor());
color_range_box->add_item("Limited", "limited");
color_range_box->add_item("Full", "full");
auto video_codec_label = std::make_unique<gsr::Label>(&title_font, "Video codec:", gsr::get_theme().text_color);
video_codec_label->set_position(settings_page_widget_pos);
settings_page_widget_pos.y += video_codec_label->get_size().y + page_widget_spacing.y / 3;
auto video_codec_box = std::make_unique<gsr::ComboBox>(&title_font);
video_codec_box->set_position(settings_page_widget_pos);
// TODO: Show options not supported but disable them
video_codec_box->add_item("Auto (Recommended)", "auto");
if(gsr_info.supported_video_codecs.h264)
video_codec_box->add_item("H264", "h264");
if(gsr_info.supported_video_codecs.hevc)
video_codec_box->add_item("HEVC", "hevc");
if(gsr_info.supported_video_codecs.av1)
video_codec_box->add_item("AV1", "av1");
if(gsr_info.supported_video_codecs.vp8)
video_codec_box->add_item("VP8", "vp8");
if(gsr_info.supported_video_codecs.vp9)
video_codec_box->add_item("VP9", "vp9");
// TODO: Add hdr options
video_codec_box->add_item("H264 Software Encoder (Slow, not recommended)", "h264_software");
settings_page_widget_pos.y += video_codec_box->get_size().y + page_widget_spacing.y;
auto audio_codec_label = std::make_unique<gsr::Label>(&title_font, "Audio codec:", gsr::get_theme().text_color);
audio_codec_label->set_position(settings_page_widget_pos);
settings_page_widget_pos.y += audio_codec_label->get_size().y + page_widget_spacing.y / 3;
auto audio_codec_box = std::make_unique<gsr::ComboBox>(&title_font);
audio_codec_box->set_position(settings_page_widget_pos);
audio_codec_box->add_item("Opus (Recommended)", "opus");
audio_codec_box->add_item("AAC", "aac");
settings_page_widget_pos.y += audio_codec_box->get_size().y + page_widget_spacing.y;
auto framerate_mode_label = std::make_unique<gsr::Label>(&title_font, "Frame rate mode:", gsr::get_theme().text_color);
framerate_mode_label->set_position(settings_page_widget_pos);
settings_page_widget_pos.y += framerate_mode_label->get_size().y + page_widget_spacing.y / 3;
auto framerate_mode_box = std::make_unique<gsr::ComboBox>(&title_font);
framerate_mode_box->set_position(settings_page_widget_pos);
framerate_mode_box->add_item("Auto (Recommended)", "auto");
framerate_mode_box->add_item("Constant", "cfr");
framerate_mode_box->add_item("Variable", "vfr");
settings_page_widget_pos.y += framerate_mode_box->get_size().y + page_widget_spacing.y;
auto container_label = std::make_unique<gsr::Label>(&title_font, "Container:", gsr::get_theme().text_color);
container_label->set_position(settings_page_widget_pos);
settings_page_widget_pos.y += container_label->get_size().y + page_widget_spacing.y / 3;
auto container_box = std::make_unique<gsr::ComboBox>(&title_font);
container_box->set_position(settings_page_widget_pos);
container_box->add_item("mp4", "mp4");
container_box->add_item("mkv", "matroska");
container_box->add_item("flv", "flv");
container_box->add_item("mov", "mov");
container_box->add_item("ts", "mpegts");
container_box->add_item("m3u8", "hls");
settings_page_widget_pos.y += container_box->get_size().y + page_widget_spacing.y;
settings_content_page->add_widget(std::move(record_area_label));
settings_content_page->add_widget(std::move(record_area_box));
settings_content_page->add_widget(std::move(audio_device_box));
settings_content_page->add_widget(std::move(framerate_label));
settings_content_page->add_widget(std::move(framerate_box));
settings_content_page->add_widget(std::move(video_quality_label));
settings_content_page->add_widget(std::move(video_quality_box));
settings_content_page->add_widget(std::move(color_range_label));
settings_content_page->add_widget(std::move(color_range_box));
settings_content_page->add_widget(std::move(video_codec_label));
settings_content_page->add_widget(std::move(video_codec_box));
settings_content_page->add_widget(std::move(audio_codec_label));
settings_content_page->add_widget(std::move(audio_codec_box));
settings_content_page->add_widget(std::move(framerate_mode_label));
settings_content_page->add_widget(std::move(framerate_mode_box));
settings_content_page->add_widget(std::move(container_label));
settings_content_page->add_widget(std::move(container_box));
add_widgets_to_settings_page(title_font, window_size, settings_page_position, settings_page_size, settings_page, settings_content_page, gsr_info, audio_devices, settings_back_button_callback);
}
mgl::Texture close_texture;