id
int64 0
755k
| file_name
stringlengths 3
109
| file_path
stringlengths 13
185
| content
stringlengths 31
9.38M
| size
int64 31
9.38M
| language
stringclasses 1
value | extension
stringclasses 11
values | total_lines
int64 1
340k
| avg_line_length
float64 2.18
149k
| max_line_length
int64 7
2.22M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 6
65
| repo_stars
int64 100
47.3k
| repo_forks
int64 0
12k
| repo_open_issues
int64 0
3.4k
| repo_license
stringclasses 9
values | repo_extraction_date
stringclasses 92
values | exact_duplicates_redpajama
bool 2
classes | near_duplicates_redpajama
bool 2
classes | exact_duplicates_githubcode
bool 2
classes | exact_duplicates_stackv2
bool 1
class | exact_duplicates_stackv1
bool 2
classes | near_duplicates_githubcode
bool 2
classes | near_duplicates_stackv1
bool 2
classes | near_duplicates_stackv2
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
5,715
|
game_list_delegate.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/game_list_delegate.h
|
#pragma once
#include "table_item_delegate.h"
class game_list_delegate : public table_item_delegate
{
public:
explicit game_list_delegate(QObject* parent);
void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override;
};
| 272
|
C++
|
.h
| 8
| 32.375
| 108
| 0.808429
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,716
|
basic_mouse_settings_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/basic_mouse_settings_dialog.h
|
#pragma once
#include "Emu/Io/MouseHandler.h"
#include <QButtonGroup>
#include <QPushButton>
#include <QDialog>
#include <QDialogButtonBox>
#include <QMouseEvent>
#include <QTimer>
#include <unordered_map>
class basic_mouse_settings_dialog : public QDialog
{
Q_OBJECT
public:
basic_mouse_settings_dialog(QWidget* parent = nullptr);
private:
void reset_config();
void on_button_click(int id);
void reactivate_buttons();
// Buttons
QDialogButtonBox* m_button_box = nullptr;
QButtonGroup* m_buttons = nullptr;
std::unordered_map<int, QPushButton*> m_push_buttons;
int m_button_id = -1;
// Backup for standard button palette
QPalette m_palette;
// Remap Timer
static constexpr int MAX_SECONDS = 5;
int m_seconds = MAX_SECONDS;
QTimer m_remap_timer;
protected:
void mouseReleaseEvent(QMouseEvent* event) override;
bool eventFilter(QObject* object, QEvent* event) override;
};
| 900
|
C++
|
.h
| 33
| 25.393939
| 59
| 0.780374
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,717
|
screenshot_manager_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/screenshot_manager_dialog.h
|
#pragma once
#include "flow_widget.h"
#include <QDialog>
#include <QFutureWatcher>
#include <QPixmap>
#include <QSize>
#include <QEvent>
#include <array>
class screenshot_manager_dialog : public QDialog
{
Q_OBJECT
public:
screenshot_manager_dialog(QWidget* parent = nullptr);
~screenshot_manager_dialog();
bool eventFilter(QObject* watched, QEvent* event) override;
Q_SIGNALS:
void signal_entry_parsed(const QString& path);
void signal_icon_preview(const QString& path);
public Q_SLOTS:
void update_icon(const QPixmap& pixmap);
private Q_SLOTS:
void add_entry(const QString& path);
void show_preview(const QString& path);
protected:
void showEvent(QShowEvent* event) override;
private:
void reload();
bool m_abort_parsing = false;
const std::array<int, 1> m_parsing_threads{0};
QFutureWatcher<void> m_parsing_watcher;
flow_widget* m_flow_widget = nullptr;
QSize m_icon_size;
QPixmap m_placeholder;
};
| 930
|
C++
|
.h
| 34
| 25.5
| 60
| 0.781674
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,718
|
trophy_notification_helper.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/trophy_notification_helper.h
|
#pragma once
#include "util/types.hpp"
#include "Emu/Cell/Modules/sceNpTrophy.h"
#include <QWindow>
#include <vector>
class trophy_notification_helper : public TrophyNotificationBase
{
public:
explicit trophy_notification_helper(QWindow* game_window) : m_game_window(game_window) { }
s32 ShowTrophyNotification(const SceNpTrophyDetails& trophy, const std::vector<uchar>& trophy_icon_buffer) override;
private:
QWindow* m_game_window;
};
| 443
|
C++
|
.h
| 13
| 32.615385
| 117
| 0.805621
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,719
|
main_window.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/main_window.h
|
#pragma once
#ifdef HAS_QT_WIN_STUFF
#include <QWinThumbnailToolBar>
#include <QWinThumbnailToolButton>
#endif
#include <QActionGroup>
#include <QMainWindow>
#include <QIcon>
#include <QList>
#include <QUrl>
#include <QMimeData>
#include "update_manager.h"
#include "settings.h"
#include "shortcut_handler.h"
#include "Emu/config_mode.h"
#include <memory>
class log_frame;
class debugger_frame;
class game_list_frame;
class gui_settings;
class emu_settings;
class persistent_settings;
class kernel_explorer;
class system_cmd_dialog;
class gui_pad_thread;
struct gui_game_info;
enum class game_boot_result : u32;
namespace compat
{
struct package_info;
}
namespace Ui
{
class main_window;
}
class main_window : public QMainWindow
{
Q_OBJECT
std::unique_ptr<Ui::main_window> ui;
bool m_is_list_mode = true;
bool m_save_slider_pos = false;
bool m_requested_show_logs_on_exit = false;
int m_other_slider_pos = 0;
QIcon m_app_icon;
QIcon m_icon_play;
QIcon m_icon_pause;
QIcon m_icon_restart;
QIcon m_icon_fullscreen_on;
QIcon m_icon_fullscreen_off;
#ifdef HAS_QT_WIN_STUFF
QIcon m_icon_thumb_play;
QIcon m_icon_thumb_pause;
QIcon m_icon_thumb_stop;
QIcon m_icon_thumb_restart;
QWinThumbnailToolBar *m_thumb_bar = nullptr;
QWinThumbnailToolButton *m_thumb_playPause = nullptr;
QWinThumbnailToolButton *m_thumb_stop = nullptr;
QWinThumbnailToolButton *m_thumb_restart = nullptr;
#endif
enum class drop_type
{
drop_error,
drop_rap_edat_pkg,
drop_pup,
drop_psf,
drop_dir,
drop_game,
drop_rrc
};
public:
explicit main_window(std::shared_ptr<gui_settings> gui_settings, std::shared_ptr<emu_settings> emu_settings, std::shared_ptr<persistent_settings> persistent_settings, QWidget *parent = nullptr);
~main_window();
bool Init(bool with_cli_boot);
QIcon GetAppIcon() const;
bool OnMissingFw();
bool InstallPackages(QStringList file_paths = {}, bool from_boot = false);
void InstallPup(QString file_path = "");
Q_SIGNALS:
void RequestLanguageChange(const QString& language);
void RequestGlobalStylesheetChange();
void RequestDialogRepaint();
void NotifyEmuSettingsChange();
void NotifyWindowCloseEvent(bool closed);
void NotifyShortcutHandlers();
public Q_SLOTS:
void OnEmuStop();
void OnEmuRun(bool start_playtime);
void OnEmuResume() const;
void OnEmuPause() const;
void OnEmuReady() const;
void OnEnableDiscEject(bool enabled) const;
void OnEnableDiscInsert(bool enabled) const;
void OnAddBreakpoint(u32 addr) const;
void RepaintGui();
void RetranslateUI(const QStringList& language_codes, const QString& language);
private Q_SLOTS:
void OnPlayOrPause();
void Boot(const std::string& path, const std::string& title_id = "", bool direct = false, bool refresh_list = false, cfg_mode config_mode = cfg_mode::custom, const std::string& config_path = "");
void BootElf();
void BootTest();
void BootGame();
void BootVSH();
void BootSavestate();
void BootRsxCapture(std::string path = "");
void DecryptSPRXLibraries();
static void show_boot_error(game_boot_result status);
void SaveWindowState() const;
void SetIconSizeActions(int idx) const;
void ResizeIcons(int index);
void RemoveHDD1Caches();
void RemoveAllCaches();
void RemoveSavestates();
void CleanUpGameList();
void RemoveFirmwareCache();
void CreateFirmwareCache();
void handle_shortcut(gui::shortcuts::shortcut shortcut_key, const QKeySequence& key_sequence);
void update_gui_pad_thread();
protected:
void closeEvent(QCloseEvent *event) override;
void mouseDoubleClickEvent(QMouseEvent *event) override;
void dropEvent(QDropEvent* event) override;
void dragEnterEvent(QDragEnterEvent* event) override;
void dragMoveEvent(QDragMoveEvent* event) override;
void dragLeaveEvent(QDragLeaveEvent* event) override;
private:
void ConfigureGuiFromSettings();
void RepaintToolBarIcons();
void RepaintThumbnailIcons();
void CreateActions();
void CreateConnects();
void CreateDockWindows();
void EnableMenus(bool enabled) const;
void ShowTitleBars(bool show) const;
void ShowOptionalGamePreparations(const QString& title, const QString& message, std::map<std::string, QString> game_path);
static bool InstallFileInExData(const std::string& extension, const QString& path, const std::string& filename);
bool HandlePackageInstallation(QStringList file_paths, bool from_boot);
void HandlePupInstallation(const QString& file_path, const QString& dir_path = "");
void ExtractPup();
void ExtractTar();
void ExtractMSELF();
QList<QUrl> m_drop_file_url_list;
u64 m_drop_file_timestamp = umax;
drop_type m_drop_file_cached_drop_type = drop_type::drop_error;
drop_type IsValidFile(const QMimeData& md, QStringList* drop_paths = nullptr);
void AddGamesFromDirs(QStringList&& paths);
QAction* CreateRecentAction(const q_string_pair& entry, const uint& sc_idx);
void BootRecentAction(const QAction* act);
void AddRecentAction(const q_string_pair& entry);
void UpdateLanguageActions(const QStringList& language_codes, const QString& language);
void UpdateFilterActions();
static QString GetCurrentTitle();
q_pair_list m_rg_entries;
QList<QAction*> m_recent_game_acts;
std::shared_ptr<gui_game_info> m_selected_game;
QActionGroup* m_icon_size_act_group = nullptr;
QActionGroup* m_list_mode_act_group = nullptr;
QActionGroup* m_category_visible_act_group = nullptr;
// Dockable widget frames
QMainWindow *m_mw = nullptr;
log_frame* m_log_frame = nullptr;
debugger_frame* m_debugger_frame = nullptr;
game_list_frame* m_game_list_frame = nullptr;
kernel_explorer* m_kernel_explorer = nullptr;
system_cmd_dialog* m_system_cmd_dialog = nullptr;
std::shared_ptr<gui_settings> m_gui_settings;
std::shared_ptr<emu_settings> m_emu_settings;
std::shared_ptr<persistent_settings> m_persistent_settings;
update_manager m_updater;
QAction* m_download_menu_action = nullptr;
shortcut_handler* m_shortcut_handler = nullptr;
std::unique_ptr<gui_pad_thread> m_gui_pad_thread;
};
| 5,956
|
C++
|
.h
| 172
| 32.604651
| 196
| 0.785652
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,720
|
pad_settings_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/pad_settings_dialog.h
|
#pragma once
#include <QButtonGroup>
#include <QDialog>
#include <QLabel>
#include <QTimer>
#include <QComboBox>
#include <mutex>
#include "Emu/Io/PadHandler.h"
#include "Emu/Io/pad_config.h"
#include "Emu/GameInfo.h"
#include "Utilities/Thread.h"
#include "pad_device_info.h"
class gui_settings;
class PadHandlerBase;
namespace Ui
{
class pad_settings_dialog;
}
class pad_settings_dialog : public QDialog
{
Q_OBJECT
const int MAX_PLAYERS = 7;
enum button_ids
{
id_pad_begin, // begin
id_pad_lstick_left,
id_pad_lstick_down,
id_pad_lstick_right,
id_pad_lstick_up,
id_pad_left,
id_pad_down,
id_pad_right,
id_pad_up,
id_pad_l1,
id_pad_l2,
id_pad_l3,
id_pad_start,
id_pad_select,
id_pad_ps,
id_pad_r1,
id_pad_r2,
id_pad_r3,
id_pad_square,
id_pad_cross,
id_pad_circle,
id_pad_triangle,
id_pad_rstick_left,
id_pad_rstick_down,
id_pad_rstick_right,
id_pad_rstick_up,
id_pressure_intensity, // Special button for pressure intensity
id_analog_limiter, // Special button for analog limiter
id_pad_end, // end
id_led,
id_reset_parameters,
id_blacklist,
id_refresh,
id_add_config_file
};
struct pad_button
{
cfg::string* cfg_text = nullptr;
std::string keys;
QString text;
void insert_key(const std::string& key, bool append_key);
};
const QString Disconnected_suffix = tr(" (disconnected)");
public:
explicit pad_settings_dialog(std::shared_ptr<gui_settings> gui_settings, QWidget* parent = nullptr, const GameInfo* game = nullptr);
~pad_settings_dialog();
private Q_SLOTS:
void OnPadButtonClicked(int id);
void OnTabChanged(int index);
void RefreshHandlers();
void ChangeHandler();
void ChangeConfig(const QString& config_file);
void ChangeDevice(int index);
void HandleDeviceClassChange(u32 class_id) const;
void AddConfigFile();
/** Update the current player config with the GUI values. */
void ApplyCurrentPlayerConfig(int new_player_id);
void RefreshPads();
private:
std::unique_ptr<Ui::pad_settings_dialog> ui;
std::string m_title_id;
std::shared_ptr<gui_settings> m_gui_settings;
// Tooltips
QString m_description;
QHash<QObject*, QString> m_descriptions;
// Capabilities
bool m_enable_buttons{ false };
bool m_enable_rumble{ false };
bool m_enable_deadzones{ false };
bool m_enable_led{ false };
bool m_enable_battery{ false };
bool m_enable_battery_led{ false };
bool m_enable_motion{ false };
bool m_enable_pressure_intensity_button{ true };
bool m_enable_analog_limiter_button{ true };
// Button Mapping
QButtonGroup* m_pad_buttons = nullptr;
atomic_t<u32> m_button_id = button_ids::id_pad_begin;
std::map<int /*id*/, pad_button /*info*/> m_cfg_entries;
std::map<int /*id*/, std::string> m_duplicate_buttons;
// Real time stick values
int m_lx = 0;
int m_ly = 0;
int m_rx = 0;
int m_ry = 0;
// Rumble
s32 m_min_force = 0;
s32 m_max_force = 0;
// Backup for standard button palette
QPalette m_palette;
// Pad Handlers
std::shared_ptr<PadHandlerBase> m_handler;
std::mutex m_handler_mutex;
std::string m_device_name;
std::string m_buddy_device_name;
std::string m_config_file;
QTimer m_timer_pad_refresh;
int m_last_player_id = 0;
// Remap Timer
static constexpr int MAX_SECONDS = 5;
int m_seconds = MAX_SECONDS;
QTimer m_remap_timer;
bool m_enable_multi_binding = false;
// Mouse Move
QPoint m_last_pos;
// Input timer. Updates the GUI with input values
QTimer m_timer_input;
std::mutex m_input_mutex;
struct input_callback_data
{
PadHandlerBase::connection status = PadHandlerBase::connection::disconnected;
bool has_new_data = false;
u32 button_id = button_ids::id_pad_begin;
u16 val = 0;
std::string name;
std::string pad_name;
u32 battery_level = 0;
std::array<int, 6> preview_values{};
} m_input_callback_data;
// Input thread. Its Callback handles the input
std::unique_ptr<named_thread<std::function<void()>>> m_input_thread;
enum class input_thread_state { paused, pausing, active };
atomic_t<input_thread_state> m_input_thread_state{input_thread_state::paused};
void start_input_thread();
void pause_input_thread();
void SaveExit();
void CancelExit();
// Set vibrate data while keeping the current color
void SetPadData(u32 large_motor, u32 small_motor, bool led_battery_indicator = false);
/** Update all the Button Labels with current button mapping */
void UpdateLabels(bool is_reset = false);
pad_device_info get_pad_info(QComboBox* combo, int index);
void switch_pad_info(int index, pad_device_info info, bool is_connected);
void SwitchPadInfo(const std::string& name, bool is_connected);
/** Enable/Disable Buttons while trying to remap an other */
void SwitchButtons(bool is_enabled);
/** Resets the view to default. Resets the Remap Timer */
void ReactivateButtons();
void InitButtons();
void ReloadButtons();
/** Repaints a stick deadzone preview label */
void RepaintPreviewLabel(QLabel* label, int deadzone, int anti_deadzone, int desired_width, int x, int y, int squircle, double multiplier) const;
QString GetLocalizedPadHandler(const QString& original, pad_handler handler);
QString GetLocalizedPadName(pad_handler handler, const QString& original, usz index);
/** Checks if the port at the given index is already reserved by the application as custom controller (ldd pad) */
bool GetIsLddPad(u32 index) const;
/** Returns the current player index */
u32 GetPlayerIndex() const;
/** Returns the current player config */
cfg_pad& GetPlayerConfig() const;
/** Sets the device name (member and config) */
void SetDeviceName(const std::string& name);
/** Gets the device name from config */
std::string GetDeviceName() const;
/** Resizes the dialog. We need to do this because the main scroll area can't determine the size on its own. */
void ResizeDialog();
/** Register a widget for tooltips */
void SubscribeTooltip(QObject* object, const QString& tooltip);
/** Used to keep all tooltip subscriptions in one place. */
void SubscribeTooltips();
protected:
void showEvent(QShowEvent* event) override;
/** Handle keyboard handler input */
void keyPressEvent(QKeyEvent *keyEvent) override;
void mouseReleaseEvent(QMouseEvent *event) override;
void mouseMoveEvent(QMouseEvent *event) override;
void wheelEvent(QWheelEvent *event) override;
bool eventFilter(QObject* object, QEvent* event) override;
void closeEvent(QCloseEvent* event) override;
};
| 6,436
|
C++
|
.h
| 194
| 30.778351
| 146
| 0.74802
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,721
|
richtext_item_delegate.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/richtext_item_delegate.h
|
#pragma once
#include <QAbstractTextDocumentLayout>
#include <QApplication>
#include <QStyledItemDelegate>
#include <QTextDocument>
#include <QPainter>
class richtext_item_delegate : public QStyledItemDelegate
{
private:
QTextDocument* m_document;
public:
explicit richtext_item_delegate(QObject* parent = nullptr)
: QStyledItemDelegate(parent)
, m_document(new QTextDocument(this))
{
}
void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override
{
painter->save();
// Initialize style option
QStyleOptionViewItem opt = option;
initStyleOption(&opt, index);
// Setup the QTextDocument with our HTML
m_document->setHtml(opt.text);
opt.text.clear();
// Get the available style
QStyle* style = opt.widget ? opt.widget->style() : QApplication::style();
// Draw our widget if available
style->drawControl(QStyle::CE_ItemViewItem, &opt, painter, opt.widget);
// Adjust our painter parameters with some magic that looks good.
// This is necessary so that we don't draw on top of the optional widget.
// If you're not happy with this code don't hesitate to contact Megamouse
#ifdef __linux__
static constexpr int margin_adjustement = 12;
#else
static constexpr int margin_adjustement = 4;
#endif
const int margin = (option.rect.height() - opt.fontMetrics.height() - margin_adjustement);
QRect text_rect = style->subElementRect(QStyle::SE_ItemViewItemText, &opt, nullptr);
if (index.column() != 0)
{
text_rect.adjust(5, 0, 0, 0);
}
text_rect.setTop(text_rect.top() + margin);
painter->translate(text_rect.topLeft());
#ifndef __linux__
painter->setClipRect(text_rect.translated(-text_rect.topLeft()));
#endif
// Create a context for our painter
QAbstractTextDocumentLayout::PaintContext context;
// Apply the styled palette
context.palette = opt.palette;
// Draw the text
m_document->documentLayout()->draw(painter, context);
painter->restore();
}
};
| 1,983
|
C++
|
.h
| 57
| 32.140351
| 107
| 0.752096
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,722
|
shortcut_utils.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/shortcut_utils.h
|
#pragma once
namespace gui::utils
{
enum shortcut_location
{
desktop,
applications,
#ifdef _WIN32
rpcs3_shortcuts,
#endif
};
bool create_shortcut(const std::string& name,
const std::string& serial,
const std::string& target_cli_args,
const std::string& description,
const std::string& src_icon_path,
const std::string& target_icon_dir,
shortcut_location shortcut_location);
}
| 520
|
C++
|
.h
| 19
| 18.789474
| 59
| 0.57515
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,724
|
debugger_list.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/debugger_list.h
|
#pragma once
#include "util/types.hpp"
#include <QListWidget>
#include <memory>
class breakpoint_handler;
class CPUDisAsm;
class cpu_thread;
class gui_settings;
class QLabel;
class debugger_list : public QListWidget
{
Q_OBJECT
public:
u32 m_pc = 0;
u32 m_start_addr = 0;
u32 m_item_count = 30;
u32 m_selected_instruction = -1;
bool m_follow_thread = true; // If true, follow the selected thread to wherever it goes in code
bool m_showing_selected_instruction = false;
bool m_dirty_flag = false;
QColor m_color_bp;
QColor m_color_pc;
QColor m_text_color_bp;
QColor m_text_color_pc;
Q_SIGNALS:
void BreakpointRequested(u32 loc, bool only_add = false);
public:
debugger_list(QWidget* parent, std::shared_ptr<gui_settings> settings, breakpoint_handler* handler);
void UpdateCPUData(std::shared_ptr<CPUDisAsm> disasm);
void EnableThreadFollowing(bool enable = true);
public Q_SLOTS:
void ShowAddress(u32 addr, bool select_addr = true, bool direct = false);
void RefreshView();
protected:
void keyPressEvent(QKeyEvent* event) override;
void mouseDoubleClickEvent(QMouseEvent* event) override;
void wheelEvent(QWheelEvent* event) override;
void resizeEvent(QResizeEvent* event) override;
void showEvent(QShowEvent* event) override;
void hideEvent(QHideEvent* event) override;
void scroll(s32 steps);
void create_rsx_command_detail(u32 pc);
private:
/**
* It really upsetted me I had to copy this code to make debugger_list/frame not circularly dependent.
*/
u32 GetStartAddress(u32 address);
bool IsSpu() const;
std::shared_ptr<gui_settings> m_gui_settings;
breakpoint_handler* m_ppu_breakpoint_handler;
cpu_thread* m_cpu = nullptr;
std::shared_ptr<CPUDisAsm> m_disasm;
QDialog* m_cmd_detail = nullptr;
QLabel* m_detail_label = nullptr;
};
| 1,779
|
C++
|
.h
| 55
| 30.509091
| 102
| 0.778426
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,725
|
welcome_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/welcome_dialog.h
|
#pragma once
#include <QDialog>
namespace Ui
{
class welcome_dialog;
}
class gui_settings;
class welcome_dialog : public QDialog
{
Q_OBJECT
public:
explicit welcome_dialog(std::shared_ptr<gui_settings> gui_settings, bool is_manual_show, QWidget* parent = nullptr);
~welcome_dialog();
bool does_user_want_dark_theme() const
{
return m_user_wants_dark_theme;
}
private:
std::unique_ptr<Ui::welcome_dialog> ui;
std::shared_ptr<gui_settings> m_gui_settings;
bool m_user_wants_dark_theme = false;
};
| 513
|
C++
|
.h
| 22
| 21.5
| 117
| 0.764948
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,726
|
config_adapter.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/config_adapter.h
|
#pragma once
#include "emu_settings_type.h"
#include "util/yaml.hpp"
// Helper methods to interact with YAML and the config settings.
namespace cfg_adapter
{
YAML::Node get_node(const YAML::Node& node, const cfg_location::const_iterator begin, const cfg_location::const_iterator end);
/** Syntactic sugar to get a setting at a given config location. */
YAML::Node get_node(const YAML::Node& node, const cfg_location& location);
/** Returns possible options for values for some particular setting.*/
std::vector<std::string> get_options(const cfg_location& location);
/** Returns dynamic property for some particular setting.*/
bool get_is_dynamic(emu_settings_type type);
/** Returns the string for a given setting.*/
std::string get_setting_name(emu_settings_type type);
}
| 789
|
C++
|
.h
| 16
| 47.375
| 127
| 0.764016
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,727
|
shortcut_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/shortcut_dialog.h
|
#pragma once
#include "gui_settings.h"
#include <QDialog>
namespace Ui
{
class shortcut_dialog;
}
class shortcut_dialog : public QDialog
{
Q_OBJECT
public:
explicit shortcut_dialog(const std::shared_ptr<gui_settings> gui_settings, QWidget* parent = nullptr);
~shortcut_dialog();
Q_SIGNALS:
void saved();
private:
void save();
Ui::shortcut_dialog* ui;
std::shared_ptr<gui_settings> m_gui_settings;
std::map<QString, QString> m_values;
private Q_SLOTS:
void handle_change(const QKeySequence& keySequence);
};
| 526
|
C++
|
.h
| 23
| 21.043478
| 103
| 0.773279
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,728
|
log_frame.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/log_frame.h
|
#pragma once
#include "Utilities/File.h"
#include "util/logs.hpp"
#include "custom_dock_widget.h"
#include "find_dialog.h"
#include <memory>
#include <QTabWidget>
#include <QPlainTextEdit>
#include <QActionGroup>
class gui_settings;
class log_frame : public custom_dock_widget
{
Q_OBJECT
public:
explicit log_frame(std::shared_ptr<gui_settings> _gui_settings, QWidget* parent = nullptr);
/** Repaint log colors after new stylesheet was applied */
void RepaintTextColors();
public Q_SLOTS:
/** Loads from settings. Public so that main_window can call this easily. */
void LoadSettings();
Q_SIGNALS:
void LogFrameClosed();
void PerformGoToOnDebugger(const QString& text_argument, bool is_address, bool test_only = false, std::shared_ptr<bool> signal_accepted = nullptr);
protected:
/** Override inherited method from Qt to allow signalling when close happened.*/
void closeEvent(QCloseEvent* event) override;
bool eventFilter(QObject* object, QEvent* event) override;
private Q_SLOTS:
void UpdateUI();
private:
void SetLogLevel(logs::level lev) const;
void SetTTYLogging(bool val) const;
void CreateAndConnectActions();
QTabWidget* m_tabWidget = nullptr;
std::unique_ptr<find_dialog> m_find_dialog;
QTimer* m_timer = nullptr;
std::vector<QColor> m_color;
QColor m_color_stack;
QPlainTextEdit* m_log = nullptr;
std::string m_old_log_text;
QString m_old_tty_text;
QString m_log_text;
std::string m_tty_buf;
usz m_tty_limited_read = 0;
usz m_log_counter{};
usz m_tty_counter{};
bool m_stack_log{};
bool m_stack_tty{};
bool m_ansi_tty{};
logs::level m_old_log_level{};
fs::file m_tty_file;
QWidget* m_tty_container = nullptr;
QPlainTextEdit* m_tty = nullptr;
QLineEdit* m_tty_input = nullptr;
int m_tty_channel = -1;
QAction* m_clear_act = nullptr;
QAction* m_clear_tty_act = nullptr;
QAction* m_perform_goto_on_debugger = nullptr;
QAction* m_perform_goto_thread_on_debugger = nullptr;
QActionGroup* m_log_level_acts = nullptr;
QAction* m_nothing_act = nullptr;
QAction* m_fatal_act = nullptr;
QAction* m_error_act = nullptr;
QAction* m_todo_act = nullptr;
QAction* m_success_act = nullptr;
QAction* m_warning_act = nullptr;
QAction* m_notice_act = nullptr;
QAction* m_trace_act = nullptr;
QAction* m_stack_act_log = nullptr;
QAction* m_stack_act_tty = nullptr;
QAction* m_ansi_act_tty = nullptr;
QAction* m_stack_act_err = nullptr;
QAction* m_show_prefix_act = nullptr;
QAction* m_tty_act = nullptr;
QActionGroup* m_tty_channel_acts = nullptr;
std::shared_ptr<gui_settings> m_gui_settings;
};
| 2,569
|
C++
|
.h
| 77
| 31.311688
| 148
| 0.751721
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,729
|
fatal_error_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/fatal_error_dialog.h
|
#pragma once
#include <QMessageBox>
#include <string_view>
class fatal_error_dialog : public QMessageBox
{
Q_OBJECT
public:
explicit fatal_error_dialog(std::string_view text, bool is_html, bool include_help_text);
};
| 223
|
C++
|
.h
| 9
| 23.111111
| 90
| 0.790476
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,730
|
game_list_grid_item.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/game_list_grid_item.h
|
#pragma once
#include "flow_widget_item.h"
#include "movie_item_base.h"
#include "game_list_base.h"
#include <QLabel>
class game_list_grid_item : public flow_widget_item, public movie_item_base
{
Q_OBJECT
public:
game_list_grid_item(QWidget* parent, game_info game, const QString& title);
void set_icon_size(const QSize& size);
void set_icon(const QPixmap& pixmap);
void adjust_size();
const game_info& game() const
{
return m_game;
}
void show_title(bool visible);
void polish_style() override;
bool event(QEvent* event) override;
private:
QSize m_icon_size{};
QLabel* m_icon_label{};
QLabel* m_title_label{};
game_info m_game{};
};
| 661
|
C++
|
.h
| 26
| 23.384615
| 76
| 0.7424
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,731
|
uuid.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/uuid.h
|
#pragma once
namespace gui
{
namespace utils
{
std::string get_uuid_path();
std::string make_uuid();
std::string load_uuid();
bool validate_uuid(const std::string& uuid);
bool save_uuid(const std::string& uuid);
bool create_new_uuid(std::string& uuid);
void log_uuid();
}
}
| 294
|
C++
|
.h
| 14
| 18.571429
| 46
| 0.703971
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,732
|
rpcn_settings_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/rpcn_settings_dialog.h
|
#pragma once
#include <optional>
#include <QDialog>
#include <QLineEdit>
#include <QListWidget>
#include "Emu/NP/rpcn_client.h"
class rpcn_settings_dialog : public QDialog
{
Q_OBJECT
public:
rpcn_settings_dialog(QWidget* parent = nullptr);
};
class rpcn_account_dialog : public QDialog
{
Q_OBJECT
public:
rpcn_account_dialog(QWidget* parent = nullptr);
private:
void refresh_combobox();
private:
QComboBox* cbx_servers = nullptr;
};
class rpcn_add_server_dialog : public QDialog
{
Q_OBJECT
public:
rpcn_add_server_dialog(QWidget* parent = nullptr);
const std::optional<std::pair<std::string, std::string>>& get_new_server() const;
private:
std::optional<std::pair<std::string, std::string>> m_new_server;
};
class rpcn_ask_username_dialog : public QDialog
{
Q_OBJECT
public:
rpcn_ask_username_dialog(QWidget* parent, const QString& description);
const std::optional<std::string>& get_username() const;
private:
std::optional<std::string> m_username;
};
class rpcn_ask_password_dialog : public QDialog
{
Q_OBJECT
public:
rpcn_ask_password_dialog(QWidget* parent, const QString& description);
const std::optional<std::string>& get_password() const;
private:
std::optional<std::string> m_password;
};
class rpcn_ask_email_dialog : public QDialog
{
Q_OBJECT
public:
rpcn_ask_email_dialog(QWidget* parent, const QString& description);
const std::optional<std::string>& get_email() const;
private:
std::optional<std::string> m_email;
};
class rpcn_ask_token_dialog : public QDialog
{
Q_OBJECT
public:
rpcn_ask_token_dialog(QWidget* parent, const QString& description);
const std::optional<std::string>& get_token() const;
private:
std::optional<std::string> m_token;
};
class rpcn_account_edit_dialog : public QDialog
{
Q_OBJECT
public:
rpcn_account_edit_dialog(QWidget* parent = nullptr);
private:
bool save_config();
private Q_SLOTS:
void resend_token();
void change_password();
protected:
QLineEdit *m_edit_username, *m_edit_token;
};
class rpcn_friends_dialog : public QDialog
{
Q_OBJECT
public:
rpcn_friends_dialog(QWidget* parent = nullptr);
~rpcn_friends_dialog();
void callback_handler(rpcn::NotificationType ntype, const std::string& username, bool status);
bool is_ok() const;
private:
void add_update_list(QListWidget* list, const QString& name, const QIcon& icon, const QVariant& data);
void remove_list(QListWidget* list, const QString& name);
private Q_SLOTS:
void add_update_friend(const QString& name, bool status);
void remove_friend(const QString& name);
void add_query(const QString& name);
Q_SIGNALS:
void signal_add_update_friend(const QString& name, bool status);
void signal_remove_friend(const QString& name);
void signal_add_query(const QString& name);
private:
QIcon m_icon_online;
QIcon m_icon_offline;
QIcon m_icon_blocked;
QIcon m_icon_request_received;
QIcon m_icon_request_sent;
// list of friends
QListWidget* m_lst_friends = nullptr;
// list of friend requests sent by/to the current user
QListWidget* m_lst_requests = nullptr;
// list of people blocked by the user
QListWidget* m_lst_blocks = nullptr;
// list of players in history
QListWidget* m_lst_history = nullptr;
std::shared_ptr<rpcn::rpcn_client> m_rpcn;
bool m_rpcn_ok = false;
};
| 3,256
|
C++
|
.h
| 116
| 26.310345
| 103
| 0.767995
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,733
|
log_viewer.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/log_viewer.h
|
#pragma once
#include "find_dialog.h"
#include <QPlainTextEdit>
#include <QDropEvent>
#include <bitset>
#include <memory>
class LogHighlighter;
class gui_settings;
class log_viewer : public QWidget
{
Q_OBJECT
public:
explicit log_viewer(std::shared_ptr<gui_settings> gui_settings);
void show_log();
private Q_SLOTS:
void show_context_menu(const QPoint& pos);
private:
void set_text_and_keep_position(const QString& text);
void filter_log();
bool is_valid_file(const QMimeData& md, bool save = false);
std::shared_ptr<gui_settings> m_gui_settings;
QString m_path_last;
QString m_filter_term;
QString m_full_log;
QPlainTextEdit* m_log_text;
LogHighlighter* m_log_highlighter;
std::unique_ptr<find_dialog> m_find_dialog;
std::bitset<32> m_log_levels = std::bitset<32>(0b11111111u);
bool m_show_timestamps = true;
bool m_show_threads = true;
bool m_last_actions_only = false;
protected:
void dropEvent(QDropEvent* ev) override;
void dragEnterEvent(QDragEnterEvent* ev) override;
void dragMoveEvent(QDragMoveEvent* ev) override;
void dragLeaveEvent(QDragLeaveEvent* ev) override;
bool eventFilter(QObject* object, QEvent* event) override;
};
| 1,170
|
C++
|
.h
| 38
| 28.921053
| 65
| 0.780749
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,734
|
elf_memory_dumping_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/elf_memory_dumping_dialog.h
|
#pragma once
#include "util/types.hpp"
#include "gui_settings.h"
#include <QListWidget>
#include <QLineEdit>
#include <QDialog>
#include <memory>
class elf_memory_dumping_dialog : public QDialog
{
Q_OBJECT
public:
explicit elf_memory_dumping_dialog(u32 ppu_debugger_pc, std::shared_ptr<gui_settings> _gui_settings, QWidget* parent = nullptr);
protected:
void add_new_segment();
void remove_segment();
void save_to_file();
std::shared_ptr<gui_settings> m_gui_settings;
// UI variables needed in higher scope
QListWidget* m_seg_list = nullptr;
QLineEdit* m_ls_address_input = nullptr;
QLineEdit* m_segment_size_input = nullptr;
QLineEdit* m_ppu_address_input = nullptr;
QLineEdit* m_segment_flags_input = nullptr;
};
| 736
|
C++
|
.h
| 24
| 28.791667
| 129
| 0.768137
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,735
|
custom_dock_widget.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/custom_dock_widget.h
|
#pragma once
#include <QDockWidget>
#include <QStyleOption>
#include <QPainter>
class custom_dock_widget : public QDockWidget
{
private:
std::shared_ptr<QWidget> m_title_bar_widget;
bool m_is_title_bar_visible = true;
public:
explicit custom_dock_widget(const QString &title, QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags())
: QDockWidget(title, parent, flags)
{
m_title_bar_widget.reset(titleBarWidget());
connect(this, &QDockWidget::topLevelChanged, [this](bool/* topLevel*/)
{
SetTitleBarVisible(m_is_title_bar_visible);
style()->unpolish(this);
style()->polish(this);
});
}
void SetTitleBarVisible(bool visible)
{
if (visible || isFloating())
{
if (m_title_bar_widget.get() != titleBarWidget())
{
setTitleBarWidget(m_title_bar_widget.get());
QMargins margins = widget()->contentsMargins();
margins.setTop(0);
widget()->setContentsMargins(margins);
}
}
else
{
setTitleBarWidget(new QWidget());
QMargins margins = widget()->contentsMargins();
margins.setTop(1);
widget()->setContentsMargins(margins);
}
m_is_title_bar_visible = visible;
}
protected:
void paintEvent(QPaintEvent* event) override
{
// We need to repaint the dock widgets as plain widgets in floating mode.
// Source: https://stackoverflow.com/questions/10272091/cannot-add-a-background-image-to-a-qdockwidget
if (isFloating())
{
QStyleOption opt;
opt.initFrom(this);
QPainter p(this);
style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
return;
}
// Use inherited method for docked mode because otherwise the dock would lose the title etc.
QDockWidget::paintEvent(event);
}
};
| 1,692
|
C++
|
.h
| 59
| 25.677966
| 122
| 0.723077
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,736
|
vfs_dialog_tab.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/vfs_dialog_tab.h
|
#pragma once
#include "vfs_dialog_path_widget.h"
#include <memory>
namespace cfg
{
class string;
}
class gui_settings;
class vfs_dialog_tab : public vfs_dialog_path_widget
{
Q_OBJECT
public:
explicit vfs_dialog_tab(const QString& name, gui_save list_location, cfg::string* cfg_node, std::shared_ptr<gui_settings> _gui_settings, QWidget* parent = nullptr);
void set_settings() const;
private:
cfg::string* m_cfg_node;
};
| 433
|
C++
|
.h
| 17
| 23.705882
| 165
| 0.767157
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,737
|
camera_settings_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/camera_settings_dialog.h
|
#pragma once
#include <QCamera>
#include <QDialog>
#include <QMediaCaptureSession>
namespace Ui
{
class camera_settings_dialog;
}
class camera_settings_dialog : public QDialog
{
Q_OBJECT
public:
camera_settings_dialog(QWidget* parent = nullptr);
virtual ~camera_settings_dialog();
private Q_SLOTS:
void handle_camera_change(int index);
void handle_settings_change(int index);
private:
void load_config();
void save_config();
std::unique_ptr<Ui::camera_settings_dialog> ui;
std::unique_ptr<QCamera> m_camera;
std::unique_ptr<QMediaCaptureSession> m_media_capture_session;
};
| 592
|
C++
|
.h
| 24
| 22.916667
| 63
| 0.789661
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,738
|
gui_save.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/gui_save.h
|
#pragma once
#include <QString>
#include <QVariant>
struct gui_save
{
QString key;
QString name;
QVariant def;
gui_save()
{
key = "";
name = "";
def = QVariant();
}
gui_save(const QString& k, const QString& n, const QVariant& d)
{
key = k;
name = n;
def = d;
}
bool operator==(const gui_save& rhs) const noexcept
{
return key == rhs.key && name == rhs.name && def == rhs.def;
}
};
| 412
|
C++
|
.h
| 25
| 14.24
| 64
| 0.638743
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,739
|
qt_utils.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/qt_utils.h
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
#include <QDir>
#include <QComboBox>
#include <QFont>
#include <QIcon>
#include <QLabel>
#include <QTableWidget>
#include <QHeaderView>
#include <QTreeWidgetItem>
#include <QPainter>
#include <QFutureWatcher>
#include <QGuiApplication>
#include <QStyleHints>
#include <string>
#include <map>
namespace gui
{
namespace utils
{
class circle_pixmap : public QPixmap
{
public:
circle_pixmap(const QColor& color, qreal pixel_ratio)
: QPixmap(pixel_ratio * 16, pixel_ratio * 16)
{
fill(Qt::transparent);
QPainter painter(this);
setDevicePixelRatio(pixel_ratio);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(Qt::NoPen);
painter.setBrush(color);
painter.drawEllipse(0, 0, width(), height());
painter.end();
}
};
template<typename T>
static QSet<T> list_to_set(const QList<T>& list)
{
return QSet<T>(list.begin(), list.end());
}
// Creates a frame geometry rectangle with target width and height that's centered inside the base,
// while still considering screen boundaries.
QRect create_centered_window_geometry(const QScreen* screen, const QRect& base, s32 target_width, s32 target_height);
// Creates a square pixmap while keeping the original aspect ratio of the image.
bool create_square_pixmap(QPixmap& pixmap, int target_size);
// Returns a custom colored QPixmap based on another QPixmap.
// use colorize_all to repaint every opaque pixel with the chosen color
// use_special_masks is only used for pixmaps with multiple predefined colors
QPixmap get_colorized_pixmap(const QPixmap& old_pixmap, const QColor& old_color, const QColor& new_color, bool use_special_masks = false, bool colorize_all = false);
// Returns a custom colored QIcon based on another QIcon.
// use colorize_all to repaint every opaque pixel with the chosen color
// use_special_masks is only used for icons with multiple predefined colors
QIcon get_colorized_icon(const QIcon& old_icon, const QColor& old_color, const QColor& new_color, bool use_special_masks = false, bool colorize_all = false);
QIcon get_colorized_icon(const QIcon& old_icon, const QColor& old_color, const std::map<QIcon::Mode, QColor>& new_colors, bool use_special_masks = false, bool colorize_all = false);
// Returns a list of all base names of files in dir whose complete file names contain one of the given name_filters
QStringList get_dir_entries(const QDir& dir, const QStringList& name_filters, bool full_path = false);
// Returns the foreground color of QLabel with respect to the current light/dark mode.
QColor get_foreground_color();
// Returns the background color of QLabel with respect to the current light/dark mode.
QColor get_background_color();
// Returns the color specified by its color_role for the QLabels with object_name
QColor get_label_color(const QString& object_name, const QColor& fallback_light, const QColor& fallback_dark, QPalette::ColorRole color_role = QPalette::WindowText);
// Returns the font of the QLabels with object_name
QFont get_label_font(const QString& object_name);
// Returns the width of the text
int get_label_width(const QString& text, const QFont* font = nullptr);
// Returns the color for richtext <a> links.
QColor get_link_color(const QString& name = "richtext_link_color");
// Returns the color string for richtext <a> links.
QString get_link_color_string(const QString& name = "richtext_link_color");
// Returns the style for richtext <a> links. e.g. style="color: #123456;"
QString get_link_style(const QString& name = "richtext_link_color");
template <typename T>
void set_font_size(T& qobj, int size)
{
QFont font = qobj.font();
font.setPointSize(size);
qobj.setFont(font);
}
// Returns a scaled, centered QPixmap
QPixmap get_centered_pixmap(QPixmap pixmap, const QSize& icon_size, int offset_x, int offset_y, qreal device_pixel_ratio, Qt::TransformationMode mode);
// Returns a scaled, centered QPixmap
QPixmap get_centered_pixmap(const QString& path, const QSize& icon_size, int offset_x, int offset_y, qreal device_pixel_ratio, Qt::TransformationMode mode);
// Returns the part of the image loaded from path that is inside the bounding box of its opaque areas
QImage get_opaque_image_area(const QString& path);
// Workaround: resize the dropdown combobox items
void resize_combo_box_view(QComboBox* combo);
// Recalculates a table's item count based on the available visible space and fills it with empty items
void update_table_item_count(QTableWidget* table);
// Opens an image in a new window with original size
void show_windowed_image(const QImage& img, const QString& title = "");
// Loads the app icon from path and embeds it centered into an empty square icon
QIcon get_app_icon_from_path(const std::string& path, const std::string& title_id);
// Open a path in the explorer and mark the file
void open_dir(const std::string& spath);
// Open a path in the explorer and mark the file
void open_dir(const QString& path);
// Finds a child of a QTreeWidgetItem with given text
QTreeWidgetItem* find_child(QTreeWidgetItem* parent, const QString& text);
// Finds all children of a QTreeWidgetItem that match the given criteria
void find_children_by_data(QTreeWidgetItem* parent, std::vector<QTreeWidgetItem*>& children, const std::vector<std::pair<int /*role*/, QVariant /*data*/>>& criteria, bool recursive);
// Constructs and adds a child to a QTreeWidgetItem
QTreeWidgetItem* add_child(QTreeWidgetItem* parent, const QString& text, int column = 0);
// Removes all children of a QTreeWidgetItem
void remove_children(QTreeWidgetItem* parent);
// Removes all children of a QTreeWidgetItem that don't match the given criteria
void remove_children(QTreeWidgetItem* parent, const std::vector<std::pair<int /*role*/, QVariant /*data*/>>& criteria, bool recursive);
// Sort a QTreeWidget (currently only column 0)
void sort_tree(QTreeWidget* tree, Qt::SortOrder sort_order, bool recursive);
// Convert an arbitrary count of bytes to a readable format using global units (KB, MB...)
QString format_byte_size(usz size);
static inline Qt::ColorScheme color_scheme()
{
return QGuiApplication::styleHints()->colorScheme();
}
static inline bool dark_mode_active()
{
return color_scheme() == Qt::ColorScheme::Dark;
}
template <typename T>
void stop_future_watcher(QFutureWatcher<T>& watcher, bool cancel, std::shared_ptr<atomic_t<bool>> cancel_flag = nullptr)
{
if (watcher.isSuspended() || watcher.isRunning())
{
watcher.resume();
if (cancel)
{
watcher.cancel();
// We use an optional cancel flag since the QFutureWatcher::canceled signal seems to be very unreliable
if (cancel_flag)
{
*cancel_flag = true;
}
}
watcher.waitForFinished();
}
}
} // utils
} // gui
| 6,983
|
C++
|
.h
| 141
| 46.099291
| 184
| 0.745037
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,740
|
config_checker.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/config_checker.h
|
#pragma once
#include <QDialog>
class config_checker : public QDialog
{
Q_OBJECT
public:
config_checker(QWidget* parent, const QString& path, bool is_log);
bool check_config(QString content, QString& result, bool is_log);
};
| 232
|
C++
|
.h
| 9
| 24
| 67
| 0.776256
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,741
|
save_data_list_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/save_data_list_dialog.h
|
#pragma once
#include "util/types.hpp"
#include "Emu/Memory/vm.h"
#include "Emu/Cell/Modules/cellSaveData.h"
#include "Emu/RSX/Overlays/overlays.h"
#include <QTableWidget>
#include <QDialog>
#include <QLabel>
#include <vector>
#include <memory>
class gui_settings;
class persistent_settings;
//Display a list of SaveData. Would need to be initialized.
//Can also be used as a Save Data Chooser.
class save_data_list_dialog : public QDialog
{
Q_OBJECT
public:
explicit save_data_list_dialog(const std::vector<SaveDataEntry>& entries, s32 focusedEntry, u32 op, vm::ptr<CellSaveDataListSet>, QWidget* parent = nullptr);
s32 GetSelection() const;
protected:
void mouseDoubleClickEvent(QMouseEvent* ev) override;
private Q_SLOTS:
void OnEntryInfo();
void OnSort(int logicalIndex);
private:
void UpdateSelectionLabel();
void UpdateList();
s32 m_entry = rsx::overlays::user_interface::selection_code::new_save;
QLabel* m_entry_label = nullptr;
QTableWidget* m_list = nullptr;
std::vector<SaveDataEntry> m_save_entries;
std::shared_ptr<gui_settings> m_gui_settings;
std::shared_ptr<persistent_settings> m_persistent_settings;
int m_sort_column = 0;
bool m_sort_ascending = true;
};
| 1,204
|
C++
|
.h
| 37
| 30.72973
| 158
| 0.782307
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,742
|
settings.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/settings.h
|
#pragma once
#include <QSettings>
#include <QDir>
#include <QVariant>
#include <QSize>
#include <memory>
#include "gui_save.h"
typedef QPair<QString, QString> q_string_pair;
typedef QPair<QString, QSize> q_size_pair;
typedef QList<q_string_pair> q_pair_list;
typedef QList<q_size_pair> q_size_list;
namespace gui
{
const QString savedata = "SaveData";
const QString users = "Users";
}
// Parent Class for GUI settings
class settings : public QObject
{
Q_OBJECT
public:
explicit settings(QObject* parent = nullptr);
~settings();
void sync();
QString GetSettingsDir() const;
QVariant GetValue(const QString& key, const QString& name, const QVariant& def) const;
QVariant GetValue(const gui_save& entry) const;
static QVariant List2Var(const q_pair_list& list);
static q_pair_list Var2List(const QVariant& var);
public Q_SLOTS:
/** Remove entry */
void RemoveValue(const QString& key, const QString& name, bool sync = true) const;
void RemoveValue(const gui_save& entry, bool sync = true) const;
/** Write value to entry */
void SetValue(const gui_save& entry, const QVariant& value, bool sync = true) const;
void SetValue(const QString& key, const QVariant& value, bool sync = true) const;
void SetValue(const QString& key, const QString& name, const QVariant& value, bool sync = true) const;
protected:
static QString ComputeSettingsDir();
std::unique_ptr<QSettings> m_settings;
QDir m_settings_dir;
};
| 1,440
|
C++
|
.h
| 42
| 32.452381
| 103
| 0.762283
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,743
|
patch_creator_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/patch_creator_dialog.h
|
#pragma once
#include "Utilities/bin_patch.h"
#include <QDialog>
#include <QComboBox>
#include <QKeyEvent>
namespace Ui
{
class patch_creator_dialog;
}
class patch_creator_dialog : public QDialog
{
Q_OBJECT
public:
explicit patch_creator_dialog(QWidget* parent = nullptr);
~patch_creator_dialog();
private:
std::unique_ptr<Ui::patch_creator_dialog> ui;
QFont mMonoFont;
QColor mValidColor;
QColor mInvalidColor;
bool m_valid = true; // Will be invalidated immediately
QRegularExpressionValidator* m_offset_validator = nullptr;
enum class move_direction
{
up,
down
};
void add_instruction(int row);
void remove_instructions();
void move_instructions(int src_row, int rows_to_move, int distance, move_direction dir);
bool can_move_instructions(QModelIndexList& selection, move_direction dir);
static void init_patch_type_bombo_box(QComboBox* combo_box, patch_type set_type, bool searchable);
QComboBox* create_patch_type_bombo_box(patch_type set_type) const;
void update_validator(int index, QComboBox* combo_box, QLineEdit* line_edit) const;
private Q_SLOTS:
void show_table_menu(const QPoint& pos);
void validate(const QString& patch);
void generate_yml(const QString& text = {});
void export_patch();
protected:
bool eventFilter(QObject* object, QEvent* event) override;
};
| 1,316
|
C++
|
.h
| 42
| 29.357143
| 99
| 0.783677
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,744
|
qt_camera_video_sink.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/qt_camera_video_sink.h
|
#pragma once
#include "util/atomic.hpp"
#include "util/types.hpp"
#include <QVideoFrame>
#include <QVideoSink>
#include <QImage>
#include <array>
class qt_camera_video_sink final : public QVideoSink
{
public:
qt_camera_video_sink(bool front_facing, QObject *parent = nullptr);
virtual ~qt_camera_video_sink();
bool present(const QVideoFrame& frame);
void set_format(s32 format, u32 bytesize);
void set_resolution(u32 width, u32 height);
void set_mirrored(bool mirrored);
u64 frame_number() const;
void get_image(u8* buf, u64 size, u32& width, u32& height, u64& frame_number, u64& bytes_read);
private:
u32 read_index() const;
bool m_front_facing = false;
bool m_mirrored = false; // Set by cellCamera
s32 m_format = 2; // CELL_CAMERA_RAW8, set by cellCamera
u32 m_bytesize = 0;
u32 m_width = 640;
u32 m_height = 480;
std::mutex m_mutex;
atomic_t<u64> m_frame_number{0};
u32 m_write_index{0};
struct image_buffer
{
u64 frame_number = 0;
u32 width = 0;
u32 height = 0;
std::vector<u8> data;
};
std::array<image_buffer, 2> m_image_buffer;
};
| 1,080
|
C++
|
.h
| 38
| 26.342105
| 96
| 0.729389
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,745
|
cheat_manager.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/cheat_manager.h
|
#pragma once
#include "util/types.hpp"
#include <QDialog>
#include <QTableWidget>
#include <QListWidget>
#include <QLineEdit>
#include <QComboBox>
#include <QPushButton>
#include <string>
#include <vector>
#include <map>
#include "Utilities/cheat_info.h"
class cheat_engine
{
public:
cheat_engine();
bool exist(const std::string& game, const u32 offset) const;
void add(const std::string& game, const std::string& description, const cheat_type type, const u32 offset, const std::string& red_script);
cheat_info* get(const std::string& game, const u32 offset);
bool erase(const std::string& game, const u32 offset);
void import_cheats_from_str(const std::string& str_cheats);
std::string export_cheats_to_str() const;
void save() const;
// Static functions to find/get/set values in ps3 memory
static bool resolve_script(u32& final_offset, const u32 offset, const std::string& red_script);
template <typename T>
static std::vector<u32> search(const T value, const std::vector<u32>& to_filter);
template <typename T>
static T get_value(const u32 offset, bool& success);
template <typename T>
static bool set_value(const u32 offset, const T value);
static bool is_addr_safe(const u32 offset);
static u32 reverse_lookup(const u32 addr, const u32 max_offset, const u32 max_depth, const u32 cur_depth = 0);
std::map<std::string, std::map<u32, cheat_info>> cheats;
private:
const std::string m_cheats_filename = "cheats.yml";
};
class cheat_manager_dialog : public QDialog
{
Q_OBJECT
public:
cheat_manager_dialog(QWidget* parent = nullptr);
~cheat_manager_dialog();
static cheat_manager_dialog* get_dlg(QWidget* parent = nullptr);
cheat_manager_dialog(cheat_manager_dialog const&) = delete;
void operator=(cheat_manager_dialog const&) = delete;
protected:
void update_cheat_list();
void do_the_search();
template <typename T>
T convert_from_QString(const QString& str, bool& success);
template <typename T>
bool convert_and_search();
template <typename T>
std::pair<bool, bool> convert_and_set(u32 offset);
protected:
QTableWidget* tbl_cheats = nullptr;
QListWidget* lst_search = nullptr;
QLineEdit* edt_value_final = nullptr;
QPushButton* btn_apply = nullptr;
QLineEdit* edt_cheat_search_value = nullptr;
QComboBox* cbx_cheat_search_type = nullptr;
QPushButton* btn_filter_results = nullptr;
u32 current_offset{};
std::vector<u32> offsets_found;
cheat_engine g_cheat;
private:
static cheat_manager_dialog* inst;
QString get_localized_cheat_type(cheat_type type);
};
| 2,532
|
C++
|
.h
| 70
| 34.142857
| 139
| 0.763136
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,746
|
trophy_notification_frame.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/trophy_notification_frame.h
|
#pragma once
#include "Emu/Cell/Modules/sceNpTrophy.h"
#include <QWidget>
class trophy_notification_frame : public QWidget
{
Q_OBJECT
public:
trophy_notification_frame(const std::vector<uchar>& imgBuffer, const SceNpTrophyDetails& trophy, int height);
};
| 261
|
C++
|
.h
| 9
| 27.333333
| 110
| 0.806452
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,747
|
rsx_debugger.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/rsx_debugger.h
|
#pragma once
#include "util/types.hpp"
#include <QDialog>
#include <QGroupBox>
#include <QImage>
#include <QLabel>
#include <QLineEdit>
#include <QEvent>
#include <QListWidget>
#include <QTableWidget>
#include <QTabWidget>
#include <memory>
class gui_settings;
class QPoint;
class Buffer : public QGroupBox
{
Q_OBJECT
const QSize Panel_Size = QSize(320, 180);
const QSize Texture_Size = QSize(320, 180);
u32 m_id;
bool m_isTex;
QImage m_image;
QLabel* m_canvas;
QSize m_image_size;
u32 m_window_counter = 1;
public:
std::vector<u8> cache;
Buffer(bool isTex, u32 id, const QString& name, QWidget* parent = nullptr);
void showImage(QImage&& image);
void ShowWindowed();
void ShowContextMenu(const QPoint& pos);
};
class rsx_debugger : public QDialog
{
Q_OBJECT
QTableWidget* m_list_captured_frame;
QTableWidget* m_list_captured_draw_calls;
QListWidget* m_list_index_buffer;
QTabWidget* m_tw_rsx;
const QString enabled_textures_text = tr(" Enabled Textures Indices: ");
Buffer* m_buffer_colorA;
Buffer* m_buffer_colorB;
Buffer* m_buffer_colorC;
Buffer* m_buffer_colorD;
Buffer* m_buffer_depth;
Buffer* m_buffer_stencil;
Buffer* m_buffer_tex;
QLabel* m_enabled_textures_label;
QLabel* m_text_transform_program;
QLabel* m_text_shader_program;
u32 m_cur_texture = 0;
u32 m_texture_format_override = 0;
std::shared_ptr<gui_settings> m_gui_settings;
public:
explicit rsx_debugger(std::shared_ptr<gui_settings> gui_settings, QWidget* parent = nullptr);
~rsx_debugger() = default;
void UpdateInformation() const;
void GetMemory() const;
void GetBuffers() const;
public Q_SLOTS:
virtual void OnClickDrawCalls();
protected:
void closeEvent(QCloseEvent* event) override;
void keyPressEvent(QKeyEvent* event) override;
bool eventFilter(QObject* object, QEvent* event) override;
private:
void PerformJump(u32 address);
};
| 1,872
|
C++
|
.h
| 68
| 25.573529
| 94
| 0.771044
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,748
|
vfs_dialog_usb_tab.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/vfs_dialog_usb_tab.h
|
#pragma once
#include "util/types.hpp"
#include "gui_settings.h"
#include <QTableWidget>
#include <QLabel>
#include <memory>
namespace cfg
{
class device_entry;
}
class vfs_dialog_usb_tab : public QWidget
{
Q_OBJECT
public:
explicit vfs_dialog_usb_tab(cfg::device_entry* cfg_node, std::shared_ptr<gui_settings> _gui_settings, QWidget* parent = nullptr);
void set_settings() const;
// Reset this tab without saving the settings yet
void reset() const;
protected:
void mouseDoubleClickEvent(QMouseEvent* ev) override;
private:
void show_usb_input_dialog(int index);
void show_context_menu(const QPoint& pos);
void double_clicked_slot(QTableWidgetItem* item);
cfg::device_entry* m_cfg_node;
std::shared_ptr<gui_settings> m_gui_settings;
QTableWidget* m_usb_table;
};
| 789
|
C++
|
.h
| 28
| 26.285714
| 130
| 0.777036
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,749
|
pkg_install_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/pkg_install_dialog.h
|
#pragma once
#include <QDialog>
#include <QListWidget>
namespace compat
{
struct package_info;
}
class game_compatibility;
class pkg_install_dialog : public QDialog
{
Q_OBJECT
public:
explicit pkg_install_dialog(const QStringList& paths, game_compatibility* compat, QWidget* parent = nullptr);
std::vector<compat::package_info> GetPathsToInstall() const;
private:
void MoveItem(int offset) const;
QListWidget* m_dir_list;
};
| 438
|
C++
|
.h
| 18
| 22.611111
| 110
| 0.801453
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,750
|
user_account.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/user_account.h
|
#pragma once
#include "util/types.hpp"
#include <map>
#include <string>
// Do not confuse this with the "user" in Emu/System.h.
// That user is read from config.yml, and it only represents the currently "logged in" user.
// The user_account class will represent all users in the home directory for the User Manager dialog.
// Selecting a user account in this dialog and saving writes it to config.yml.
class user_account
{
public:
explicit user_account(const std::string& user_id = "00000001");
std::string GetUserId() const { return m_user_id; }
std::string GetUserDir() const { return m_user_dir; }
std::string GetUsername() const { return m_username; }
static std::map<u32, user_account> GetUserAccounts(const std::string& base_dir);
private:
std::string m_user_id;
std::string m_user_dir;
std::string m_username;
};
| 834
|
C++
|
.h
| 21
| 38.047619
| 101
| 0.750929
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,751
|
vfs_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/vfs_dialog.h
|
#pragma once
#include <QDialog>
class gui_settings;
class vfs_dialog : public QDialog
{
Q_OBJECT
public:
explicit vfs_dialog(std::shared_ptr<gui_settings> _gui_settings, QWidget* parent = nullptr);
private:
std::shared_ptr<gui_settings> m_gui_settings;
};
| 263
|
C++
|
.h
| 11
| 22.272727
| 93
| 0.778226
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,752
|
recvmessage_dialog_frame.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/recvmessage_dialog_frame.h
|
#pragma once
#include <QObject>
#include <QListWidget>
#include "util/types.hpp"
#include "custom_dialog.h"
#include "Emu/NP/rpcn_client.h"
struct recvmessage_signal_struct
{
std::shared_ptr<std::pair<std::string, message_data>> msg;
u64 msg_id;
};
Q_DECLARE_METATYPE(recvmessage_signal_struct);
class recvmessage_dialog_frame : public QObject, public RecvMessageDialogBase
{
Q_OBJECT
public:
recvmessage_dialog_frame() = default;
~recvmessage_dialog_frame();
error_code Exec(SceNpBasicMessageMainType type, SceNpBasicMessageRecvOptions options, SceNpBasicMessageRecvAction& recv_result, u64& chosen_msg_id) override;
void callback_handler(const std::shared_ptr<std::pair<std::string, message_data>> new_msg, u64 msg_id) override;
private:
void add_message(const std::shared_ptr<std::pair<std::string, message_data>>& msg, u64 msg_id);
Q_SIGNALS:
void signal_new_message(const recvmessage_signal_struct msg_and_id);
private Q_SLOTS:
void slot_new_message(const recvmessage_signal_struct msg_and_id);
private:
custom_dialog* m_dialog = nullptr;
QListWidget* m_lst_messages = nullptr;
};
| 1,108
|
C++
|
.h
| 30
| 35.2
| 158
| 0.790262
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,753
|
call_stack_list.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/call_stack_list.h
|
#pragma once
#include "util/types.hpp"
#include <QListWidget>
#include <vector>
class cpu_thread;
class CPUDisAsm;
class call_stack_list : public QListWidget
{
Q_OBJECT
public:
explicit call_stack_list(QWidget* parent);
protected:
void mouseDoubleClickEvent(QMouseEvent* ev) override;
Q_SIGNALS:
void RequestShowAddress(u32 addr, bool select_addr = true, bool force = false);
public Q_SLOTS:
void HandleUpdate(const std::vector<std::pair<u32, u32>>& call_stack);
private Q_SLOTS:
void ShowItemAddress();
private:
void keyPressEvent(QKeyEvent* event) override;
};
| 579
|
C++
|
.h
| 22
| 24.590909
| 80
| 0.79562
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,754
|
debugger_frame.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/debugger_frame.h
|
#pragma once
#include "util/types.hpp"
#include "custom_dock_widget.h"
#include <QSplitter>
#include <QPlainTextEdit>
#include <QPushButton>
#include <QComboBox>
#include <memory>
#include <vector>
#include <any>
#include <functional>
class CPUDisAsm;
class cpu_thread;
class gui_settings;
class debugger_list;
class breakpoint_list;
class breakpoint_handler;
class call_stack_list;
namespace rsx
{
class thread;
}
namespace utils
{
class shm;
}
enum class system_state : u32;
class instruction_editor_dialog;
class register_editor_dialog;
class debugger_frame : public custom_dock_widget
{
Q_OBJECT
const QString NoThreadString = tr("No Thread");
const QString RunString = tr("Run");
const QString PauseString = tr("Pause");
debugger_list* m_debugger_list;
QSplitter* m_right_splitter;
QFont m_mono;
QPlainTextEdit* m_misc_state;
QPlainTextEdit* m_regs;
QPushButton* m_go_to_addr;
QPushButton* m_go_to_pc;
QPushButton* m_btn_step;
QPushButton* m_btn_step_over;
QPushButton* m_btn_run;
QComboBox* m_choice_units;
QTimer* m_update;
QSplitter* m_splitter;
u64 m_threads_created = -1;
u64 m_threads_deleted = -1;
system_state m_emu_state{};
u64 m_emulation_id{};
u32 m_last_pc = -1;
std::vector<char> m_last_query_state;
std::string m_last_reg_state;
std::any m_dump_reg_func_data;
std::vector<std::function<cpu_thread*()>> m_threads_info;
u32 m_last_step_over_breakpoint = -1;
u64 m_ui_update_ctr = 0;
u64 m_ui_fast_update_permission_deadline = 0;
bool m_thread_list_pending_update = false;
std::shared_ptr<CPUDisAsm> m_disasm; // Only shared to allow base/derived functionality
std::shared_ptr<cpu_thread> m_cpu;
rsx::thread* m_rsx = nullptr;
std::shared_ptr<utils::shm> m_spu_disasm_memory;
u32 m_spu_disasm_origin_eal = 0;
u32 m_spu_disasm_pc = 0;
bool m_is_spu_disasm_mode = false;
breakpoint_list* m_breakpoint_list;
breakpoint_handler* m_ppu_breakpoint_handler;
call_stack_list* m_call_stack_list;
instruction_editor_dialog* m_inst_editor = nullptr;
register_editor_dialog* m_reg_editor = nullptr;
QDialog* m_goto_dialog = nullptr;
QDialog* m_spu_disasm_dialog = nullptr;
std::shared_ptr<gui_settings> m_gui_settings;
cpu_thread* get_cpu();
std::function<cpu_thread*()> make_check_cpu(cpu_thread* cpu, bool unlocked = false);
void open_breakpoints_settings();
public:
explicit debugger_frame(std::shared_ptr<gui_settings> settings, QWidget *parent = nullptr);
void SaveSettings() const;
void ChangeColors() const;
void UpdateUI();
void UpdateUnitList();
void DoUpdate();
void WritePanels();
void EnableButtons(bool enable);
void ShowGotoAddressDialog();
void PerformGoToRequest(const QString& text_argument);
void PerformGoToThreadRequest(const QString& text_argument);
void PerformAddBreakpointRequest(u32 addr);
u64 EvaluateExpression(const QString& expression);
void ClearBreakpoints() const; // Fallthrough method into breakpoint_list.
void ClearCallStack();
/** Needed so key press events work when other objects are selected in debugger_frame. */
bool eventFilter(QObject* object, QEvent* event) override;
protected:
/** Override inherited method from Qt to allow signalling when close happened.*/
void closeEvent(QCloseEvent* event) override;
void showEvent(QShowEvent* event) override;
void hideEvent(QHideEvent* event) override;
void keyPressEvent(QKeyEvent* event) override;
Q_SIGNALS:
void DebugFrameClosed();
void CallStackUpdateRequested(const std::vector<std::pair<u32, u32>>& call_stack);
public Q_SLOTS:
void DoStep(bool step_over = false);
private Q_SLOTS:
void OnSelectUnit();
void OnSelectSPUDisassembler();
void ShowPC(bool user_requested = false);
void EnableUpdateTimer(bool enable) const;
void RunBtnPress();
};
Q_DECLARE_METATYPE(u32)
| 3,770
|
C++
|
.h
| 116
| 30.577586
| 92
| 0.773642
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,755
|
infinity_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/infinity_dialog.h
|
#pragma once
#include <optional>
#include "util/types.hpp"
#include <QDialog>
#include <QLineEdit>
#include <QVBoxLayout>
class figure_creator_dialog : public QDialog
{
Q_OBJECT
public:
explicit figure_creator_dialog(QWidget* parent, u8 slot);
QString get_file_path() const;
protected:
QString m_file_path;
private:
bool create_blank_figure(u32 character, u8 series);
};
class infinity_dialog : public QDialog
{
Q_OBJECT
public:
explicit infinity_dialog(QWidget* parent);
~infinity_dialog();
static infinity_dialog* get_dlg(QWidget* parent);
infinity_dialog(infinity_dialog const&) = delete;
void operator=(infinity_dialog const&) = delete;
protected:
void clear_figure(u8 slot);
void create_figure(u8 slot);
void load_figure(u8 slot);
void load_figure_path(u8 slot, const QString& path);
protected:
std::array<QLineEdit*, 9> m_edit_figures{};
static std::array<std::optional<u32>, 9> figure_slots;
private:
void add_figure_slot(QVBoxLayout* vbox_group, QString name, u8 slot);
static infinity_dialog* inst;
};
| 1,042
|
C++
|
.h
| 38
| 25.605263
| 70
| 0.775202
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,756
|
emu_settings.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/emu_settings.h
|
#pragma once
#include "util/types.hpp"
#include "util/yaml.hpp"
#include "microphone_creator.h"
#include "midi_creator.h"
#include "render_creator.h"
#include "emu_settings_type.h"
#include <QButtonGroup>
#include <QCheckBox>
#include <QStringList>
#include <QComboBox>
#include <QSpinBox>
#include <QDateTimeEdit>
#include <string>
#include <vector>
namespace cfg
{
class _base;
}
constexpr auto qstr = QString::fromStdString;
class emu_settings : public QObject
{
/** A settings class for Emulator specific settings. This class is a refactored version of the wx version. It is much nicer
*
*/
Q_OBJECT
public:
std::set<emu_settings_type> m_broken_types; // list of broken settings
/** Creates a settings object which reads in the config.yml file at rpcs3/bin/%path%/config.yml
* Settings are only written when SaveSettings is called.
*/
emu_settings();
bool Init();
/** Connects a combo box with the target settings type*/
void EnhanceComboBox(QComboBox* combobox, emu_settings_type type, bool is_ranged = false, bool use_max = false, int max = 0, bool sorted = false, bool strict = true);
/** Connects a check box with the target settings type*/
void EnhanceCheckBox(QCheckBox* checkbox, emu_settings_type type);
/** Connects a date time edit box with the target settings type*/
void EnhanceDateTimeEdit(QDateTimeEdit* date_time_edit, emu_settings_type type, const QString& format, bool use_calendar, bool as_offset_from_now, int offset_update_time=0);
/** Connects a slider with the target settings type*/
void EnhanceSlider(QSlider* slider, emu_settings_type type);
/** Connects an integer spin box with the target settings type*/
void EnhanceSpinBox(QSpinBox* spinbox, emu_settings_type type, const QString& prefix = "", const QString& suffix = "");
/** Connects a double spin box with the target settings type*/
void EnhanceDoubleSpinBox(QDoubleSpinBox* spinbox, emu_settings_type type, const QString& prefix = "", const QString& suffix = "");
/** Connects a line edit with the target settings type*/
void EnhanceLineEdit(QLineEdit* edit, emu_settings_type type);
/** Connects a button group with the target settings type*/
void EnhanceRadioButton(QButtonGroup* button_group, emu_settings_type type);
std::vector<std::string> GetLibrariesControl();
void SaveSelectedLibraries(const std::vector<std::string>& libs);
/** Returns the valid options for a given setting.*/
static std::vector<std::string> GetSettingOptions(emu_settings_type type);
/** Returns the valid options for a given setting.*/
static QStringList GetQStringSettingOptions(emu_settings_type type);
/** Returns the default value of the setting type.*/
std::string GetSettingDefault(emu_settings_type type) const;
/** Returns the value of the setting type.*/
std::string GetSetting(emu_settings_type type) const;
/** Sets the setting type to a given value.*/
void SetSetting(emu_settings_type type, const std::string& val) const;
/** Try to find the settings type for a given string.*/
emu_settings_type FindSettingsType(const cfg::_base* node) const;
/** Gets all the renderer info for gpu settings.*/
render_creator* m_render_creator = nullptr;
/** Gets a list of all the microphones available.*/
microphone_creator m_microphone_creator;
/** Gets a list of all the midi devices available.*/
midi_creator m_midi_creator;
/** Loads the settings from path.*/
void LoadSettings(const std::string& title_id = "", bool create_config_from_global = true);
/** Fixes all registered invalid settings after asking the user for permission.*/
void OpenCorrectionDialog(QWidget* parent = Q_NULLPTR);
/** Get a localized and therefore freely adjustable version of the string used in config.yml.*/
QString GetLocalizedSetting(const QString& original, emu_settings_type type, int index, bool strict) const;
/** Get a localized and therefore freely adjustable version of the string used in config.yml.*/
std::string GetLocalizedSetting(const std::string& original, emu_settings_type type, int index, bool strict) const;
/** Get a localized and therefore freely adjustable version of the string used in config.yml.*/
std::string GetLocalizedSetting(const cfg::_base* node, u32 index) const;
/** Validates the settings and logs unused entries or cleans up the yaml*/
bool ValidateSettings(bool cleanup);
/** Resets the current settings to the global default. This includes all connected widgets. */
void RestoreDefaults();
Q_SIGNALS:
void RestoreDefaultsSignal();
public Q_SLOTS:
/** Writes the unsaved settings to file. Used in settings dialog on accept.*/
void SaveSettings() const;
private:
YAML::Node m_default_settings; // The default settings as a YAML node.
YAML::Node m_current_settings; // The current settings as a YAML node.
std::string m_title_id;
};
| 4,824
|
C++
|
.h
| 93
| 49.752688
| 174
| 0.766297
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,757
|
system_cmd_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/system_cmd_dialog.h
|
#pragma once
#include <QDialog>
#include <QComboBox>
#include <QLineEdit>
class system_cmd_dialog : public QDialog
{
Q_OBJECT
public:
system_cmd_dialog(QWidget* parent = nullptr);
~system_cmd_dialog();
private Q_SLOTS:
void send_command();
void send_custom_command();
private:
void send_cmd(qulonglong status, qulonglong param) const;
qulonglong hex_value(QString text, bool& ok) const;
QLineEdit* m_value_input = nullptr;
QLineEdit* m_custom_command_input = nullptr;
QComboBox* m_command_box = nullptr;
};
| 523
|
C++
|
.h
| 20
| 24.35
| 58
| 0.772636
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,758
|
input_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/input_dialog.h
|
#pragma once
#include <QDialog>
#include <QDialogButtonBox>
class QLabel;
class QLineEdit;
class QValidator;
class input_dialog : public QDialog
{
Q_OBJECT
public:
input_dialog(int max_length, const QString& text, const QString& title, const QString& label, const QString& placeholder, QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags());
~input_dialog();
void set_label_text(const QString& text) const;
void set_validator(const QValidator* validator) const;
void set_clear_button_enabled(bool enable) const;
void set_input_font(const QFont& font, bool fix_width, char sample = '\0') const;
void set_button_enabled(QDialogButtonBox::StandardButton id, bool enabled) const;
QString get_input_text() const;
private:
QLabel* m_label = nullptr;
QLineEdit* m_input = nullptr;
QDialogButtonBox* m_button_box = nullptr;
QString m_text;
Q_SIGNALS:
void text_changed(const QString& text);
};
| 918
|
C++
|
.h
| 26
| 33.5
| 189
| 0.776271
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,759
|
stylesheets.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/stylesheets.h
|
#pragma once
#include <QString>
namespace gui
{
namespace stylesheets
{
const QString default_style_sheet
(
// main window toolbar search
"QLineEdit#mw_searchbar { padding: 0 1em; background: #fdfdfd; selection-background-color: #148aff; margin: .8em; color:#000000; }"
// main window toolbar slider
"QSlider#sizeSlider { color: #505050; background: #F0F0F0; }"
"QSlider#sizeSlider::handle:horizontal { border: 0em smooth rgba(227, 227, 227, 255); border-radius: .58em; background: #404040; width: 1.2em; margin: -.5em 0; }"
"QSlider#sizeSlider::groove:horizontal { border-radius: .15em; background: #5b5b5b; height: .3em; }"
// main window toolbar
"QToolBar#mw_toolbar { background-color: #F0F0F0; border: none; }"
"QToolBar#mw_toolbar::separator { background-color: rgba(207, 207, 207, 235); width: 0.125em; margin-top: 0.250em; margin-bottom: 0.250em; }"
"QToolButton:disabled { color: #787878; }"
// main window toolbar icon color
"QLabel#toolbar_icon_color { color: #5b5b5b; }"
// thumbnail icon color
"QLabel#thumbnail_icon_color { color: rgba(0, 100, 231, 255); }"
// game list icon color
"QLabel#gamelist_icon_background_color { color: rgba(240, 240, 240, 255); }"
// game grid
"#game_list_grid #flow_widget_content { background: #fff; }"
"#game_list_grid_item { background: #fff; }"
"#game_list_grid_item[selected=\"true\"] { background: #148aff; }"
"#game_list_grid_item:focus { background: #148aff; }"
"#game_list_grid_item:hover { background: #94c9ff; }"
"#game_list_grid_item:hover:focus { background: #007fff; }"
"#game_list_grid_item #game_list_grid_item_title_label { color: rgba(51, 51, 51, 255); font-weight: 600; font-size: 8pt; font-family: Lucida Grande; border: 0em solid white; }"
// game grid hover and focus: we need to handle properties differently when using descendants
"#game_list_grid_item[selected=\"true\"] #game_list_grid_item_title_label { color: #fff; }"
"#game_list_grid_item[hover=\"true\"] #game_list_grid_item_title_label { color: #fff; }"
"#game_list_grid_item[focus=\"true\"] #game_list_grid_item_title_label { color: #fff; }"
// save manager icon color
"QLabel#save_manager_icon_background_color { color: rgba(240, 240, 240, 255); }"
// trophy manager icon color
"QLabel#trophy_manager_icon_background_color { color: rgba(240, 240, 240, 255); }"
// tables
"QTableWidget { alternate-background-color: #f2f2f2; background-color: #fff; border: none; }"
"QTableView::item { border-left: 0.063em solid white; border-right: 0.063em solid white; padding-left:0.313em; }"
"QTableView::item:selected { background-color: #148aff; color: #fff; }"
// table headers
"QHeaderView::section { padding-left: .5em; padding-right: .5em; padding-top: .4em; padding-bottom: -.1em; border: 0.063em solid #ffffff; }"
"QHeaderView::section:hover { background: #e3e3e3; padding-left: .5em; padding-right: .5em; padding-top: .4em; padding-bottom: -.1em; border: 0.063em solid #ffffff; }"
// dock widget
"QDockWidget{ background: transparent; color: black; }"
"[floating=\"true\"]{ background: white; }"
"QDockWidget::title{ background: #e3e3e3; border: none; padding-top: 0.2em; padding-left: 0.2em; }"
"QDockWidget::close-button, QDockWidget::float-button{ background-color: #e3e3e3; }"
// log frame tty
"QPlainTextEdit#tty_frame { background-color: #ffffff; }"
"QLabel#tty_text { color: #000000; }"
// log frame log
"QPlainTextEdit#log_frame { background-color: #ffffff; }"
"QLabel#log_level_always { color: #107896; }"
"QLabel#log_level_fatal { color: #ff00ff; }"
"QLabel#log_level_error { color: #C02F1D; }"
"QLabel#log_level_todo { color: #ff6000; }"
"QLabel#log_level_success { color: #008000; }"
"QLabel#log_level_warning { color: #BA8745; }"
"QLabel#log_level_notice { color: #000000; }"
"QLabel#log_level_trace { color: #808080; }"
"QLabel#log_stack { color: #000000; }"
// about dialog
"QWidget#header_section { background-color: #ffffff; }"
// kernel explorer
"QDialog#kernel_explorer { background-color: rgba(240, 240, 240, 255); }"
// memory viewer
"QDialog#memory_viewer { background-color: rgba(240, 240, 240, 255); }"
"QLabel#memory_viewer_address_panel { color: rgba(75, 135, 150, 255); background-color: rgba(240, 240, 240, 255); }"
"QLabel#memory_viewer_hex_panel { color: #000000; background-color: rgba(240, 240, 240, 255); }"
"QLabel#memory_viewer_ascii_panel { color: #000000; background-color: rgba(240, 240, 240, 255); }"
// debugger frame
"QLabel#debugger_frame_breakpoint { color: #000000; background-color: #ffff00; }"
"QLabel#debugger_frame_pc { color: #000000; background-color: #00ff00; }"
// rsx debugger
"QLabel#rsx_debugger_display_buffer { background-color: rgba(240, 240, 240, 255); }"
// pad settings
"QLabel#l_controller { color: #434343; }"
// Top menu bar (Workaround for transparent menus in Qt 6.7.3)
"QMenu { color: #000; background-color: #F0F0F0; alternate-background-color: #f2f2f2; }"
"QMenu::item:selected { background: #90C8F6; }"
"QMenu::item:disabled { color: #787878; }"
);
}
}
| 5,212
|
C++
|
.h
| 89
| 54.573034
| 179
| 0.684902
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,760
|
trophy_manager_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/trophy_manager_dialog.h
|
#pragma once
#include "Loader/TROPUSR.h"
#include <QWidget>
#include <QComboBox>
#include <QFutureWatcher>
#include <QLabel>
#include <QPixmap>
#include <QTableWidget>
#include <QSlider>
#include <QSplitter>
#include <memory>
#include <mutex>
#include <unordered_map>
class game_list;
class gui_settings;
class TROPUSRLoader;
struct GameTrophiesData
{
std::unique_ptr<TROPUSRLoader> trop_usr;
trophy_xml_document trop_config; // I'd like to use unique but the protocol inside of the function passes around shared pointers..
std::unordered_map<int, QPixmap> trophy_images; // Cache trophy images to avoid loading from disk as much as possible.
std::unordered_map<int, QString> trophy_image_paths;
std::string game_name;
std::string path;
};
class trophy_manager_dialog : public QWidget
{
Q_OBJECT
public:
explicit trophy_manager_dialog(std::shared_ptr<gui_settings> gui_settings);
~trophy_manager_dialog() override;
void RepaintUI(bool restore_layout = true);
public Q_SLOTS:
void HandleRepaintUiRequest();
private Q_SLOTS:
void ResizeGameIcons();
void ResizeTrophyIcons();
void ApplyFilter();
void ShowTrophyTableContextMenu(const QPoint& pos);
void ShowGameTableContextMenu(const QPoint& pos);
Q_SIGNALS:
void GameIconReady(int index, const QPixmap& pixmap);
void TrophyIconReady(int index, const QPixmap& pixmap);
private:
/** Loads a trophy folder.
Returns true if successful. Does not attempt to install if failure occurs, like sceNpTrophy.
*/
bool LoadTrophyFolderToDB(const std::string& trop_name);
/** Populate the trophy database (multithreaded). */
void StartTrophyLoadThreads();
/** Fills game table with information.
Takes results from LoadTrophyFolderToDB and puts it into the UI.
*/
void PopulateGameTable();
/** Fills trophy table with information.
Takes results from LoadTrophyFolderToDB and puts it into the UI.
*/
void PopulateTrophyTable();
void ReadjustGameTable() const;
void ReadjustTrophyTable() const;
void WaitAndAbortGameRepaintThreads();
void WaitAndAbortTrophyRepaintThreads();
void closeEvent(QCloseEvent *event) override;
bool eventFilter(QObject *object, QEvent *event) override;
static QDateTime TickToDateTime(u64 tick);
static u64 DateTimeToTick(QDateTime date_time);
std::shared_ptr<gui_settings> m_gui_settings;
std::vector<std::unique_ptr<GameTrophiesData>> m_trophies_db; //! Holds all the trophy information.
std::mutex m_trophies_db_mtx;
QComboBox* m_game_combo; //! Lets you choose a game
QLabel* m_game_progress; //! Shows you the current game's progress
QSplitter* m_splitter; //! Contains the game and trophy tables
game_list* m_trophy_table; //! UI element to display trophy stuff.
game_list* m_game_table; //! UI element to display games.
QList<QAction*> m_trophy_column_acts;
QList<QAction*> m_game_column_acts;
bool m_show_hidden_trophies = false;
bool m_show_unlocked_trophies = true;
bool m_show_locked_trophies = true;
bool m_show_bronze_trophies = true;
bool m_show_silver_trophies = true;
bool m_show_gold_trophies = true;
bool m_show_platinum_trophies = true;
std::string m_trophy_dir;
int m_icon_height = 75;
bool m_save_icon_height = false;
QSlider* m_icon_slider = nullptr;
int m_game_icon_size_index = 25;
QSize m_game_icon_size = QSize(m_game_icon_size_index, m_game_icon_size_index);
bool m_save_game_icon_size = false;
QSlider* m_game_icon_slider = nullptr;
QColor m_game_icon_color;
};
| 3,438
|
C++
|
.h
| 93
| 35
| 131
| 0.778079
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,761
|
breakpoint_handler.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/breakpoint_handler.h
|
#pragma once
#include "util/types.hpp"
#include <set>
enum class breakpoint_types
{
bp_read = 0x1,
bp_write = 0x2,
bp_exec = 0x4,
};
/*
* This class acts as a layer between the UI and Emu for breakpoints.
*/
class breakpoint_handler
{
public:
breakpoint_handler() = default;
~breakpoint_handler() = default;
/**
* Returns true iff breakpoint exists at loc.
* TODO: Add arg for flags, gameid, and maybe even thread if it should be thread local breakpoint.... breakpoint struct is probably what'll happen
*/
bool HasBreakpoint(u32 loc) const;
/**
* Returns true if added successfully. TODO: flags
*/
bool AddBreakpoint(u32 loc);
/**
* Returns true if removed breakpoint at loc successfully.
*/
bool RemoveBreakpoint(u32 loc);
private:
// TODO : generalize to hold multiple games and handle flags.Probably do : std::map<std::string (gameid), std::set<breakpoint>>.
// Although, externally, they'll only be accessed by loc (I think) so a map of maps may also do?
std::set<u32> m_breakpoints; //! Holds all breakpoints.
};
| 1,047
|
C++
|
.h
| 35
| 28.085714
| 146
| 0.739044
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,762
|
screenshot_preview.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/screenshot_preview.h
|
#pragma once
#include <QImage>
#include <QLabel>
class screenshot_preview : public QLabel
{
Q_OBJECT
public:
screenshot_preview(const QString& filepath, QWidget* parent = nullptr);
protected:
void resizeEvent(QResizeEvent* event) override;
private Q_SLOTS:
void show_context_menu(const QPoint& pos);
private:
void scale(const QSize& size);
QString m_filepath;
QImage m_image;
double m_factor = 1.0;
bool m_stretch = false;
};
| 442
|
C++
|
.h
| 19
| 21.421053
| 72
| 0.78125
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,763
|
memory_viewer_panel.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/memory_viewer_panel.h
|
#pragma once
#include "util/types.hpp"
#include "Utilities/Thread.h"
#include <QDialog>
#include <QLineEdit>
#include <QLabel>
#include <QFont>
#include <QFontDatabase>
#include <string>
class QLineEdit;
class QCheckBox;
class QComboBox;
class QLabel;
class QThread;
class QHBoxLayout;
class QKeyEvent;
class cpu_thread;
class CPUDisAsm;
namespace utils
{
class shm;
}
namespace rsx
{
class thread;
}
enum search_mode : unsigned
{
no_mode = 1,
clear_modes = 2,
as_string = 4,
as_hex = 8,
as_f64 = 16,
as_f32 = 32,
as_inst = 64,
as_regex_inst = 128,
as_fake_spu_inst = 256,
as_regex_fake_spu_inst = 512,
search_mode_last = 1024,
};
class memory_viewer_panel final : public QDialog
{
Q_OBJECT
public:
memory_viewer_panel(QWidget* parent, std::shared_ptr<CPUDisAsm> disasm, u32 addr = 0, std::function<cpu_thread*()> func = []() -> cpu_thread* { return {}; });
~memory_viewer_panel();
enum class color_format : int
{
RGB,
ARGB,
RGBA,
ABGR,
G8,
G32MAX
};
Q_ENUM(color_format)
protected:
void wheelEvent(QWheelEvent* event) override;
void resizeEvent(QResizeEvent* event) override;
private:
u32 m_addr = 0;
u32 m_colcount = 0;
u32 m_rowcount = 0;
u32 m_min_height = 0;
QLineEdit* m_addr_line = nullptr;
QLabel* m_mem_addr = nullptr;
QLabel* m_mem_hex = nullptr;
QLabel* m_mem_ascii = nullptr;
QFontMetrics* m_fontMetrics = nullptr;
static constexpr int c_pad_memory_labels = 15;
QLineEdit* m_search_line = nullptr;
QCheckBox* m_chkbox_case_insensitive = nullptr;
QComboBox* m_cbox_input_mode = nullptr;
QHBoxLayout* m_hbox_mem_panel = nullptr;
QThread* m_search_thread = nullptr;
const std::function<cpu_thread*()> m_get_cpu;
const thread_class m_type;
const std::add_pointer_t<rsx::thread> m_rsx;
const std::shared_ptr<utils::shm> m_spu_shm;
const u32 m_addr_mask;
std::shared_ptr<CPUDisAsm> m_disasm;
const void* m_ptr = nullptr;
usz m_size = 0;
search_mode m_modes{};
std::string getHeaderAtAddr(u32 addr) const;
void scroll(s32 steps);
void* to_ptr(u32 addr, u32 size = 1) const;
void SetPC(const uint pc);
void ShowMemory();
void ShowImage(QWidget* parent, u32 addr, color_format format, u32 width, u32 height, bool flipv) const;
u64 OnSearch(std::string wstr, u32 mode);
void keyPressEvent(QKeyEvent* event) override;
};
// Lifetime management with IDM
struct memory_viewer_handle
{
static constexpr u32 id_base = 1;
static constexpr u32 id_step = 1;
static constexpr u32 id_count = 2048;
SAVESTATE_INIT_POS(33); // Of course not really used
template <typename... Args> requires (std::is_constructible_v<memory_viewer_panel, Args&&...>)
memory_viewer_handle(Args&&... args)
: m_mvp(new memory_viewer_panel(std::forward<Args>(args)...))
{
}
~memory_viewer_handle() { m_mvp->close(); m_mvp->deleteLater(); }
private:
const std::add_pointer_t<memory_viewer_panel> m_mvp;
};
| 2,943
|
C++
|
.h
| 109
| 25.009174
| 159
| 0.71612
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,764
|
persistent_settings.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/persistent_settings.h
|
#pragma once
#include "settings.h"
namespace gui
{
namespace persistent
{
// File name
const QString persistent_file_name = "persistent_settings";
// Entry names
const QString playtime = "Playtime";
const QString last_played = "LastPlayed";
const QString notes = "Notes";
const QString titles = "Titles";
// Date format
const QString last_played_date_format_old = "MMMM d yyyy";
const QString last_played_date_format_new = "MMMM d, yyyy";
const QString last_played_date_with_time_of_day_format = "MMMM d, yyyy HH:mm";
const Qt::DateFormat last_played_date_format = Qt::DateFormat::ISODate;
// GUI Saves
const gui_save save_notes = gui_save(savedata, "notes", QVariantMap());
const gui_save active_user = gui_save(users, "active_user", "");
}
}
// Provides a persistent settings class that won't be affected by settings dialog changes
class persistent_settings : public settings
{
Q_OBJECT
public:
explicit persistent_settings(QObject* parent = nullptr);
QString GetCurrentUser(const QString& fallback) const;
public Q_SLOTS:
void SetPlaytime(const QString& serial, quint64 playtime, bool sync);
void AddPlaytime(const QString& serial, quint64 elapsed, bool sync);
quint64 GetPlaytime(const QString& serial);
void SetLastPlayed(const QString& serial, const QString& date, bool sync);
QString GetLastPlayed(const QString& serial);
private:
std::map<QString, quint64> m_playtime;
std::map<QString, QString> m_last_played;
};
| 1,551
|
C++
|
.h
| 40
| 36.45
| 89
| 0.721519
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,765
|
auto_pause_settings_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/auto_pause_settings_dialog.h
|
#pragma once
#include "util/types.hpp"
#include <QDialog>
#include <QLabel>
#include <QTableWidget>
#include <QLineEdit>
#include <vector>
class auto_pause_settings_dialog : public QDialog
{
Q_OBJECT
enum
{
id_add,
id_remove,
id_config,
};
std::vector<u32> m_entries;
QTableWidget *m_pause_list;
public:
explicit auto_pause_settings_dialog(QWidget* parent);
void UpdateList();
void LoadEntries();
void SaveEntries();
public Q_SLOTS:
void OnRemove();
private Q_SLOTS:
void ShowContextMenu(const QPoint &pos);
void keyPressEvent(QKeyEvent *event) override;
};
class AutoPauseConfigDialog : public QDialog
{
Q_OBJECT
u32 m_entry;
u32* m_presult;
bool m_newEntry;
QLineEdit* m_id;
QLabel* m_current_converted;
auto_pause_settings_dialog* m_apsd;
public:
explicit AutoPauseConfigDialog(QWidget* parent, auto_pause_settings_dialog* apsd, bool newEntry, u32* entry);
private Q_SLOTS:
void OnOk();
void OnCancel();
void OnUpdateValue() const;
};
| 979
|
C++
|
.h
| 45
| 19.844444
| 110
| 0.773564
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,766
|
category.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/category.h
|
#pragma once
#include <QString>
#include <QStringList>
enum Category
{
Disc_Game,
HDD_Game,
PS1_Game,
PS2_Game,
PSP_Game,
Home,
Media,
Data,
Unknown_Cat,
Others,
};
namespace cat
{
const QString cat_app_music = "AM";
const QString cat_app_photo = "AP";
const QString cat_app_store = "AS";
const QString cat_app_tv = "AT";
const QString cat_app_video = "AV";
const QString cat_bc_video = "BV";
const QString cat_web_tv = "WT";
const QString cat_home = "HM";
const QString cat_network = "CB";
const QString cat_store_fe = "SF";
const QString cat_disc_game = "DG";
const QString cat_hdd_game = "HG";
const QString cat_ps2_game = "2P";
const QString cat_ps2_inst = "2G";
const QString cat_ps1_game = "1P";
const QString cat_psp_game = "PP";
const QString cat_psp_mini = "MN";
const QString cat_psp_rema = "PE";
const QString cat_ps3_data = "GD";
const QString cat_ps2_data = "2D";
const QString cat_ps3_save = "SD";
const QString cat_psp_save = "MS";
const QString cat_ps3_os = "/OS";
const QString cat_unknown = "Unknown";
const QStringList ps2_games = { cat_ps2_game, cat_ps2_inst };
const QStringList psp_games = { cat_psp_game, cat_psp_mini, cat_psp_rema };
const QStringList media = { cat_app_photo, cat_app_video, cat_bc_video, cat_app_music, cat_app_store, cat_app_tv, cat_web_tv };
const QStringList data = { cat_ps3_data, cat_ps2_data, cat_ps3_save, cat_psp_save };
const QStringList others = { cat_network, cat_store_fe, cat_ps3_os };
}
| 1,517
|
C++
|
.h
| 48
| 29.666667
| 128
| 0.688312
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,767
|
screenshot_item.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/screenshot_item.h
|
#pragma once
#include "flow_widget_item.h"
#include <QLabel>
#include <QThread>
class screenshot_item : public flow_widget_item
{
Q_OBJECT
public:
screenshot_item(QWidget* parent);
virtual ~screenshot_item();
QString icon_path;
QSize icon_size;
QLabel* label{};
private:
std::unique_ptr<QThread> m_thread;
Q_SIGNALS:
void signal_icon_update(const QPixmap& pixmap);
};
| 382
|
C++
|
.h
| 18
| 19.444444
| 48
| 0.773743
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,768
|
settings_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/settings_dialog.h
|
#pragma once
#include "emu_settings.h"
#include <QDialog>
#include <QLabel>
#include <QSlider>
#include <memory>
class gui_settings;
struct GameInfo;
namespace Ui
{
class settings_dialog;
}
class settings_dialog : public QDialog
{
Q_OBJECT
public:
explicit settings_dialog(std::shared_ptr<gui_settings> gui_settings, std::shared_ptr<emu_settings> emu_settings, const int& tab_index = 0, QWidget* parent = nullptr, const GameInfo* game = nullptr, bool create_cfg_from_global_cfg = true);
~settings_dialog();
int exec() override;
Q_SIGNALS:
void GuiStylesheetRequest();
void GuiRepaintRequest();
void EmuSettingsApplied();
void signal_restore_dependant_defaults();
private:
void EnhanceSlider(emu_settings_type settings_type, QSlider* slider, QLabel* label, const QString& label_text) const;
// Snapping of sliders when moved with mouse
void SnapSlider(QSlider* slider, int interval);
QSlider* m_current_slider = nullptr;
std::set<QObject*> m_snap_sliders;
// Gui tab
void AddStylesheets();
void ApplyStylesheet(bool reset);
QString m_current_stylesheet;
// Gpu tab
QString m_old_renderer;
// Audio tab
std::array<QComboBox*, 4> m_mics_combo{};
// IO tab
std::array<QComboBox*, 3> m_midi_type_combo{};
std::array<QComboBox*, 3> m_midi_device_combo{};
int m_tab_index = 0;
std::unique_ptr<Ui::settings_dialog> ui;
std::shared_ptr<gui_settings> m_gui_settings;
std::shared_ptr<emu_settings> m_emu_settings;
// Discord
bool m_use_discord = false;
QString m_discord_state;
// Descriptions
std::vector<std::pair<QLabel*, QString>> m_description_labels;
QHash<QObject*, QString> m_descriptions;
void SubscribeDescription(QLabel* description);
void SubscribeTooltip(QObject* object, const QString& tooltip);
bool eventFilter(QObject* object, QEvent* event) override;
void closeEvent(QCloseEvent* event) override;
// Countries
void refresh_countrybox();
};
| 1,904
|
C++
|
.h
| 58
| 30.844828
| 239
| 0.76612
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,769
|
instruction_editor_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/instruction_editor_dialog.h
|
#pragma once
#include "util/types.hpp"
#include <QDialog>
#include <QLineEdit>
#include <QLabel>
class CPUDisAsm;
class cpu_thread;
class QCheckBox;
class instruction_editor_dialog : public QDialog
{
Q_OBJECT
private:
u32 m_pc;
u8* m_cpu_offset;
std::shared_ptr<CPUDisAsm> m_disasm; // shared in order to allow an incomplete type
QLineEdit* m_instr;
QLabel* m_preview;
QLabel* m_func_info = nullptr;
QCheckBox* m_apply_for_spu_group = nullptr;
const std::function<cpu_thread*()> m_get_cpu;
public:
instruction_editor_dialog(QWidget *parent, u32 _pc, CPUDisAsm* _disasm, std::function<cpu_thread*()> func);
void updatePreview() const;
};
| 656
|
C++
|
.h
| 24
| 25.541667
| 108
| 0.761218
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,770
|
osk_dialog_frame.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/osk_dialog_frame.h
|
#pragma once
#include "util/types.hpp"
#include "Emu/Cell/Modules/cellOskDialog.h"
#include <QObject>
#include <string>
class custom_dialog;
class osk_dialog_frame : public QObject, public OskDialogBase
{
Q_OBJECT
public:
osk_dialog_frame() = default;
~osk_dialog_frame();
void Create(const osk_params& params) override;
void Close(s32 status) override;
void Clear(bool clear_all_data) override;
void SetText(const std::u16string& text) override;
void Insert(const std::u16string& text) override;
private:
void SetOskText(const QString& text);
custom_dialog* m_dialog = nullptr;
QString m_text_old;
};
| 621
|
C++
|
.h
| 22
| 26.363636
| 61
| 0.780034
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,771
|
custom_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/custom_dialog.h
|
#pragma once
#include <QDialog>
#include <QKeyEvent>
class custom_dialog : public QDialog
{
Q_OBJECT
public:
explicit custom_dialog(bool disableCancel, QWidget* parent = nullptr);
bool m_disable_cancel;
private:
void keyPressEvent(QKeyEvent* event) override;
void closeEvent(QCloseEvent* event) override;
};
| 317
|
C++
|
.h
| 13
| 22.692308
| 71
| 0.806667
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,772
|
user_manager_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/user_manager_dialog.h
|
#pragma once
#include "util/types.hpp"
#include "user_account.h"
#include <QDialog>
#include <QTableWidget>
#include <string>
#include <memory>
#include <map>
class gui_settings;
class persistent_settings;
class user_manager_dialog : public QDialog
{
Q_OBJECT
public:
explicit user_manager_dialog(std::shared_ptr<gui_settings> gui_settings, std::shared_ptr<persistent_settings> persistent_settings, QWidget* parent = nullptr);
Q_SIGNALS:
void OnUserLoginSuccess();
private Q_SLOTS:
void OnUserLogin();
void OnUserCreate();
void OnUserRemove();
void OnUserRename();
void OnSort(int logicalIndex);
protected:
void mouseDoubleClickEvent(QMouseEvent* ev) override;
private:
void Init();
void UpdateTable(bool mark_only = false);
static void GenerateUser(const std::string& user_id, const std::string& username);
static bool ValidateUsername(const QString& text_to_validate);
void ShowContextMenu(const QPoint &pos);
void closeEvent(QCloseEvent* event) override;
bool eventFilter(QObject* object, QEvent* event) override;
u32 GetUserKey() const;
QTableWidget* m_table = nullptr;
std::string m_active_user;
std::map<u32, user_account> m_user_list;
std::shared_ptr<gui_settings> m_gui_settings;
std::shared_ptr<persistent_settings> m_persistent_settings;
int m_sort_column = 1;
bool m_sort_ascending = true;
};
| 1,343
|
C++
|
.h
| 42
| 30.047619
| 159
| 0.786159
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,773
|
breakpoint_list.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/breakpoint_list.h
|
#pragma once
#include "util/types.hpp"
#include <QListWidget>
class CPUDisAsm;
class cpu_thread;
class breakpoint_handler;
class breakpoint_list : public QListWidget
{
Q_OBJECT
public:
breakpoint_list(QWidget* parent, breakpoint_handler* handler);
void UpdateCPUData(std::shared_ptr<CPUDisAsm> disasm);
void ClearBreakpoints();
bool AddBreakpoint(u32 pc);
void RemoveBreakpoint(u32 addr);
QColor m_text_color_bp;
QColor m_color_bp;
protected:
void mouseDoubleClickEvent(QMouseEvent* ev) override;
Q_SIGNALS:
void RequestShowAddress(u32 addr, bool select_addr = true, bool force = false);
public Q_SLOTS:
void HandleBreakpointRequest(u32 loc, bool add_only);
private Q_SLOTS:
void OnBreakpointListDoubleClicked();
void OnBreakpointListRightClicked(const QPoint &pos);
void OnBreakpointListDelete();
private:
breakpoint_handler* m_ppu_breakpoint_handler;
QMenu* m_context_menu = nullptr;
QAction* m_delete_action;
std::shared_ptr<CPUDisAsm> m_disasm = nullptr;
};
| 990
|
C++
|
.h
| 33
| 28.151515
| 80
| 0.806758
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,774
|
patch_manager_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/patch_manager_dialog.h
|
#pragma once
#include <QDialog>
#include <QTreeWidgetItem>
#include <QDragMoveEvent>
#include <QMimeData>
#include "Utilities/bin_patch.h"
#include <unordered_map>
namespace Ui
{
class patch_manager_dialog;
}
class downloader;
class gui_settings;
class patch_manager_dialog : public QDialog
{
Q_OBJECT
struct gui_patch_info
{
QString hash;
QString title;
QString serial;
QString app_version;
QString author;
QString notes;
QString description;
QString patch_version;
QString config_value_key;
std::map<QString, QVariant> config_values;
};
const QString tr_all_titles = tr("All titles - Warning: These patches apply to all games!");
const QString tr_all_serials = tr("All serials");
const QString tr_all_versions = tr("All versions");
public:
explicit patch_manager_dialog(std::shared_ptr<gui_settings> gui_settings, std::unordered_map<std::string, std::set<std::string>> games, const std::string& title_id, const std::string& version, QWidget* parent = nullptr);
~patch_manager_dialog();
int exec() override;
private Q_SLOTS:
void filter_patches(const QString& term);
void handle_item_selected(QTreeWidgetItem* current, QTreeWidgetItem* previous);
void handle_item_changed(QTreeWidgetItem* item, int column);
void handle_config_value_changed(double value);
void handle_custom_context_menu_requested(const QPoint& pos);
void handle_show_owned_games_only(Qt::CheckState state);
private:
void refresh(bool restore_layout = false);
void load_patches(bool show_error);
void populate_tree();
void save_config() const;
void update_patch_info(const gui_patch_info& info) const;
static bool is_valid_file(const QMimeData& md, QStringList* drop_paths = nullptr);
void download_update(bool automatic, bool auto_accept);
bool handle_json(const QByteArray& data);
std::shared_ptr<gui_settings> m_gui_settings;
bool m_expand_current_match = false;
QString m_search_version;
std::unordered_map<std::string, std::set<std::string>> m_owned_games;
bool m_show_owned_games_only = false;
patch_engine::patch_map m_map;
downloader* m_downloader = nullptr;
bool m_download_automatic = false;
bool m_download_auto_accept = false;
std::unique_ptr<Ui::patch_manager_dialog> ui;
protected:
void dropEvent(QDropEvent* event) override;
void dragEnterEvent(QDragEnterEvent* event) override;
void dragMoveEvent(QDragMoveEvent* event) override;
void dragLeaveEvent(QDragLeaveEvent* event) override;
void closeEvent(QCloseEvent* event) override;
};
| 2,498
|
C++
|
.h
| 69
| 34.072464
| 221
| 0.7781
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,775
|
midi_creator.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/midi_creator.h
|
#pragma once
#include "util/types.hpp"
#include "Emu/Io/midi_config_types.h"
#include <QObject>
#include <QStringList>
class midi_creator : public QObject
{
Q_OBJECT
public:
midi_creator();
QString get_none();
std::string set_device(u32 num, const midi_device& device);
void parse_devices(const std::string& list);
void refresh_list();
QStringList get_midi_list() const;
std::array<midi_device, max_midi_devices> get_selection_list() const;
private:
QStringList m_midi_list;
std::array<midi_device, max_midi_devices> m_sel_list;
};
| 547
|
C++
|
.h
| 20
| 25.6
| 70
| 0.760536
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,776
|
vfs_tool_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/vfs_tool_dialog.h
|
#pragma once
#include <QDialog>
namespace Ui
{
class vfs_tool_dialog;
}
class vfs_tool_dialog : public QDialog
{
Q_OBJECT
public:
vfs_tool_dialog(QWidget *parent);
virtual ~vfs_tool_dialog();
private:
std::unique_ptr<Ui::vfs_tool_dialog> ui;
private Q_SLOTS:
void handle_vfs_path(const QString& path);
};
| 317
|
C++
|
.h
| 17
| 16.941176
| 43
| 0.765306
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,778
|
flow_layout.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/flow_layout.h
|
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** BSD License Usage
** Alternatively, you may use this file under the terms of the BSD license
** as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of The Qt Company Ltd nor the names of its
** contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#pragma once
#include <QLayout>
#include <QRect>
#include <QStyle>
class flow_layout : public QLayout
{
public:
struct position
{
int row{};
int col{};
};
explicit flow_layout(QWidget* parent, int margin = -1, bool dynamic_spacing = false, int hSpacing = -1, int vSpacing = -1);
explicit flow_layout(int margin = -1, bool dynamic_spacing = false, int hSpacing = -1, int vSpacing = -1);
~flow_layout();
void clear();
const QList<QLayoutItem*>& item_list() const { return m_item_list; }
const QList<position>& positions() const { return m_positions; }
int rows() const { return m_rows; }
int cols() const { return m_cols; }
void addItem(QLayoutItem* item) override;
Qt::Orientations expandingDirections() const override;
bool hasHeightForWidth() const override;
int heightForWidth(int) const override;
int count() const override;
QLayoutItem* itemAt(int index) const override;
QSize minimumSize() const override;
void setGeometry(const QRect& rect) override;
QSize sizeHint() const override;
QLayoutItem* takeAt(int index) override;
private:
int horizontalSpacing() const;
int verticalSpacing() const;
int doLayout(const QRect& rect, bool testOnly) const;
int smartSpacing(QStyle::PixelMetric pm) const;
QList<QLayoutItem*> m_item_list;
bool m_dynamic_spacing{};
int m_h_space_initial{-1};
int m_v_space_initial{-1};
mutable int m_h_space{-1};
mutable int m_v_space{-1};
mutable QList<position> m_positions;
mutable int m_rows{};
mutable int m_cols{};
};
| 3,954
|
C++
|
.h
| 94
| 40.56383
| 124
| 0.728902
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,779
|
cg_disasm_window.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/cg_disasm_window.h
|
#pragma once
#include "util/types.hpp"
#include <QTextEdit>
#include <QDropEvent>
#include <memory>
class AsmHighlighter;
class GlslHighlighter;
class gui_settings;
class cg_disasm_window : public QWidget
{
Q_OBJECT
private Q_SLOTS:
void ShowContextMenu(const QPoint &pos);
private:
void ShowDisasm() const;
bool IsValidFile(const QMimeData& md, bool save = false);
QString m_path_last;
QTextEdit* m_disasm_text;
QTextEdit* m_glsl_text;
std::shared_ptr<gui_settings> m_gui_settings;
AsmHighlighter* sh_asm;
GlslHighlighter* sh_glsl;
public:
explicit cg_disasm_window(std::shared_ptr<gui_settings> xSettings);
protected:
void dropEvent(QDropEvent* ev) override;
void dragEnterEvent(QDragEnterEvent* ev) override;
void dragMoveEvent(QDragMoveEvent* ev) override;
void dragLeaveEvent(QDragLeaveEvent* ev) override;
};
| 842
|
C++
|
.h
| 30
| 26.166667
| 68
| 0.80375
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,780
|
movie_item_base.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/movie_item_base.h
|
#pragma once
#include "movie_item_base.h"
#include "util/atomic.hpp"
#include "Utilities/mutex.h"
#include <QMovie>
#include <QThread>
#include <QBuffer>
#include <QMediaPlayer>
#include <QVideoSink>
#include <QVideoFrame>
#include <QPixmap>
#include <memory>
#include <functional>
using icon_callback_t = std::function<void(const QVideoFrame&)>;
using icon_load_callback_t = std::function<void(int)>;
using size_calc_callback_t = std::function<void()>;
class movie_item_base
{
public:
movie_item_base();
virtual ~movie_item_base();
void init_pointers();
void set_active(bool active);
[[nodiscard]] bool get_active() const
{
return m_active;
}
void set_movie_path(QString path)
{
m_movie_path = std::move(path);
}
void init_movie();
void stop_movie();
QPixmap get_movie_image(const QVideoFrame& frame) const;
void call_icon_func() const;
void set_icon_func(const icon_callback_t& func);
void call_icon_load_func(int index);
void set_icon_load_func(const icon_load_callback_t& func);
void call_size_calc_func();
void set_size_calc_func(const size_calc_callback_t& func);
void wait_for_icon_loading(bool abort);
void wait_for_size_on_disk_loading(bool abort);
bool icon_loading() const
{
return m_icon_loading;
}
bool size_on_disk_loading() const
{
return m_size_on_disk_loading;
}
[[nodiscard]] std::shared_ptr<atomic_t<bool>> icon_loading_aborted() const
{
return m_icon_loading_aborted;
}
[[nodiscard]] std::shared_ptr<atomic_t<bool>> size_on_disk_loading_aborted() const
{
return m_size_on_disk_loading_aborted;
}
shared_mutex pixmap_mutex;
protected:
QString m_movie_path;
QByteArray m_movie_data{};
std::unique_ptr<QBuffer> m_movie_buffer;
std::unique_ptr<QMediaPlayer> m_media_player;
std::shared_ptr<QVideoSink> m_video_sink;
std::shared_ptr<QMovie> m_movie;
private:
std::unique_ptr<QThread> m_icon_load_thread;
std::unique_ptr<QThread> m_size_calc_thread;
bool m_active = false;
atomic_t<bool> m_size_on_disk_loading = false;
atomic_t<bool> m_icon_loading = false;
size_calc_callback_t m_size_calc_callback = nullptr;
icon_load_callback_t m_icon_load_callback = nullptr;
icon_callback_t m_icon_callback = nullptr;
std::shared_ptr<atomic_t<bool>> m_icon_loading_aborted;
std::shared_ptr<atomic_t<bool>> m_size_on_disk_loading_aborted;
};
| 2,329
|
C++
|
.h
| 78
| 27.782051
| 83
| 0.747869
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,781
|
pad_led_settings_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/pad_led_settings_dialog.h
|
#pragma once
#include <QDialog>
#include "ui_pad_led_settings_dialog.h"
namespace Ui
{
class pad_led_settings_dialog;
}
class pad_led_settings_dialog : public QDialog
{
Q_OBJECT
public:
explicit pad_led_settings_dialog(QDialog* parent, int colorR, int colorG, int colorB, bool has_rgb, bool has_player_led, bool player_led_enabled, bool has_battery, bool has_battery_led, bool led_low_battery_blink, bool led_battery_indicator, int led_battery_indicator_brightness);
~pad_led_settings_dialog();
struct led_settings
{
int color_r = 255;
int color_g = 255;
int color_b = 255;
bool player_led_enabled = true;
bool low_battery_blink = true;
bool battery_indicator = false;
int battery_indicator_brightness = 50;
};
Q_SIGNALS:
void pass_led_settings(const led_settings& settings);
private Q_SLOTS:
void update_slider_label(int val) const;
void battery_indicator_checked(bool checked) const;
private:
void redraw_color_sample() const;
void read_form_values();
std::unique_ptr<Ui::pad_led_settings_dialog> ui;
led_settings m_initial;
led_settings m_new;
};
| 1,088
|
C++
|
.h
| 35
| 29
| 281
| 0.765326
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,782
|
progress_indicator.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/progress_indicator.h
|
#pragma once
#include <QWindow>
#ifdef HAS_QT_WIN_STUFF
#include <QWinTaskbarButton>
#endif
class progress_indicator
{
public:
progress_indicator(int minimum, int maximum);
~progress_indicator();
void show(QWindow* window);
void hide();
int value() const;
void set_value(int value);
void set_range(int minimum, int maximum);
void reset();
void signal_failure();
private:
#ifdef HAS_QT_WIN_STUFF
std::unique_ptr<QWinTaskbarButton> m_tb_button;
#else
int m_value = 0;
int m_minimum = 0;
int m_maximum = 100;
#if HAVE_QTDBUS
void update_progress(int progress, bool progress_visible, bool urgent);
#endif
#endif
};
| 633
|
C++
|
.h
| 29
| 20.068966
| 72
| 0.765101
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,783
|
pad_motion_settings_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/pad_motion_settings_dialog.h
|
#pragma once
#include "ui_pad_motion_settings_dialog.h"
#include "pad_device_info.h"
#include "Emu/Io/PadHandler.h"
#include "Utilities/Thread.h"
#include <QDialog>
#include <QTimer>
#include <QLabel>
#include <QCheckBox>
#include <QComboBox>
#include <QSpinBox>
#include <unordered_map>
namespace Ui
{
class pad_motion_settings_dialog;
}
class pad_motion_settings_dialog : public QDialog
{
Q_OBJECT
public:
explicit pad_motion_settings_dialog(QDialog* parent, std::shared_ptr<PadHandlerBase> handler, cfg_player* cfg);
~pad_motion_settings_dialog();
private Q_SLOTS:
void change_device(int index);
private:
void switch_buddy_pad_info(int index, pad_device_info info, bool is_connected);
void start_input_thread();
void pause_input_thread();
std::unique_ptr<Ui::pad_motion_settings_dialog> ui;
std::shared_ptr<PadHandlerBase> m_handler;
std::string m_device_name;
cfg_player* m_cfg = nullptr;
std::mutex m_config_mutex;
std::unordered_map<u32, std::string> m_motion_axis_list;
// Input thread. Its Callback handles the input
std::unique_ptr<named_thread<std::function<void()>>> m_input_thread;
enum class input_thread_state { paused, pausing, active };
atomic_t<input_thread_state> m_input_thread_state{input_thread_state::paused};
struct motion_callback_data
{
bool success = false;
bool has_new_data = false;
std::string pad_name;
std::array<u16, 4> preview_values{{ DEFAULT_MOTION_X, DEFAULT_MOTION_Y, DEFAULT_MOTION_Z, DEFAULT_MOTION_G}};;
} m_motion_callback_data;
QTimer m_timer_input;
std::mutex m_input_mutex;
std::array<QSlider*, 4> m_preview_sliders;
std::array<QLabel*, 4> m_preview_labels;
std::array<QComboBox*, 4> m_axis_names;
std::array<QCheckBox*, 4> m_mirrors;
std::array<QSpinBox*, 4> m_shifts;
std::array<cfg_sensor*, 4> m_config_entries;
const QString Disconnected_suffix = tr(" (disconnected)");
};
| 1,871
|
C++
|
.h
| 55
| 32.109091
| 112
| 0.75388
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,784
|
movie_item.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/movie_item.h
|
#pragma once
#include "movie_item_base.h"
#include <QTableWidgetItem>
class movie_item : public QTableWidgetItem, public movie_item_base
{
public:
movie_item();
movie_item(const QString& text, int type = Type);
movie_item(const QIcon& icon, const QString& text, int type = Type);
};
| 289
|
C++
|
.h
| 10
| 27.3
| 69
| 0.76087
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,785
|
game_list_base.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/game_list_base.h
|
#pragma once
#include "movie_item_base.h"
#include "game_compatibility.h"
#include "Emu/GameInfo.h"
#include <QIcon>
#include <QPixmap>
#include <QWidget>
/* Having the icons associated with the game info simplifies logic internally */
struct gui_game_info
{
GameInfo info{};
QString localized_category;
compat::status compat;
QPixmap icon;
QPixmap pxmap;
bool hasCustomConfig = false;
bool hasCustomPadConfig = false;
bool has_hover_gif = false;
bool has_hover_pam = false;
movie_item_base* item = nullptr;
};
typedef std::shared_ptr<gui_game_info> game_info;
Q_DECLARE_METATYPE(game_info)
class game_list_base
{
public:
game_list_base();
virtual void clear_list(){};
virtual void populate(
[[maybe_unused]] const std::vector<game_info>& game_data,
[[maybe_unused]] const std::map<QString, QString>& notes_map,
[[maybe_unused]] const std::map<QString, QString>& title_map,
[[maybe_unused]] const std::string& selected_item_id,
[[maybe_unused]] bool play_hover_movies){};
void set_icon_size(QSize size) { m_icon_size = std::move(size); }
void set_icon_color(QColor color) { m_icon_color = std::move(color); }
void set_draw_compat_status_to_grid(bool enabled) { m_draw_compat_status_to_grid = enabled; }
virtual void repaint_icons(std::vector<game_info>& game_data, const QColor& icon_color, const QSize& icon_size, qreal device_pixel_ratio);
// Returns the visible version string in the game list
static std::string GetGameVersion(const game_info& game);
/** Sets the custom config icon. */
static QIcon GetCustomConfigIcon(const game_info& game);
protected:
void IconLoadFunction(game_info game, qreal device_pixel_ratio, std::shared_ptr<atomic_t<bool>> cancel);
QPixmap PaintedPixmap(const QPixmap& icon, qreal device_pixel_ratio, bool paint_config_icon = false, bool paint_pad_config_icon = false, const QColor& compatibility_color = {}) const;
QColor GetGridCompatibilityColor(const QString& string) const;
std::function<void(const game_info&)> m_icon_ready_callback{};
bool m_draw_compat_status_to_grid{};
bool m_is_list_layout{};
QSize m_icon_size{};
QColor m_icon_color{};
};
| 2,134
|
C++
|
.h
| 52
| 39.057692
| 184
| 0.752657
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,787
|
downloader.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/downloader.h
|
#pragma once
#include <QObject>
#include "util/atomic.hpp"
namespace rpcs3
{
namespace curl
{
class curl_handle;
}
}
class progress_dialog;
class downloader : public QObject
{
Q_OBJECT
public:
explicit downloader(QWidget* parent = nullptr);
~downloader();
void start(const std::string& url, bool follow_location, bool show_progress_dialog, const QString& progress_dialog_title = "", bool keep_progress_dialog_open = false, int expected_size = -1);
usz update_buffer(char* data, usz size);
void update_progress_dialog(const QString& title) const;
void close_progress_dialog();
progress_dialog* get_progress_dialog() const;
private Q_SLOTS:
void handle_buffer_update(int size, int max) const;
Q_SIGNALS:
void signal_download_error(const QString& error);
void signal_download_finished(const QByteArray& data);
void signal_download_canceled();
void signal_buffer_update(int size, int max);
private:
QWidget* m_parent = nullptr;
std::unique_ptr<rpcs3::curl::curl_handle> m_curl;
QByteArray m_curl_buf;
atomic_t<bool> m_curl_abort = false;
atomic_t<bool> m_curl_success = false;
double m_actual_download_size = -1.0;
progress_dialog* m_progress_dialog = nullptr;
atomic_t<bool> m_keep_progress_dialog_open = false;
QString m_progress_dialog_title;
QThread* m_thread = nullptr;
};
| 1,316
|
C++
|
.h
| 41
| 30.073171
| 192
| 0.766059
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,788
|
microphone_creator.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/microphone_creator.h
|
#pragma once
#include "util/types.hpp"
#include <QString>
#include <QStringList>
#include <QObject>
#include <array>
#include <string>
class microphone_creator : public QObject
{
Q_OBJECT
public:
microphone_creator();
QString get_none();
std::string set_device(u32 num, const QString& text);
void parse_devices(const std::string& list);
void refresh_list();
QStringList get_microphone_list() const;
std::array<std::string, 4> get_selection_list() const;
private:
QStringList m_microphone_list;
std::array<std::string, 4> m_sel_list;
};
| 552
|
C++
|
.h
| 22
| 23.363636
| 55
| 0.76145
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,789
|
progress_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/progress_dialog.h
|
#pragma once
#include "progress_indicator.h"
#include <QProgressDialog>
class progress_dialog : public QProgressDialog
{
public:
progress_dialog(const QString& windowTitle, const QString& labelText, const QString& cancelButtonText, int minimum, int maximum, bool delete_on_close, QWidget* parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags());
~progress_dialog();
void SetRange(int min, int max);
void SetValue(int progress);
void SetDeleteOnClose();
void SignalFailure() const;
void show_progress_indicator();
void setVisible(bool visible) override;
private:
std::unique_ptr<progress_indicator> m_progress_indicator;
};
| 645
|
C++
|
.h
| 17
| 36.058824
| 224
| 0.792605
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,790
|
save_manager_dialog.h
|
RPCS3_rpcs3/rpcs3/rpcs3qt/save_manager_dialog.h
|
#pragma once
#include "Emu/Cell/Modules/cellSaveData.h"
#include <QDialog>
#include <QLabel>
#include <QPushButton>
#include <QTableWidget>
#include <QPixmap>
class gui_settings;
class persistent_settings;
class save_manager_dialog : public QDialog
{
Q_OBJECT
public:
/**
* Class which will handle the managing of saves from all games.
* You may think I should just modify save_data_list_dialog. But, that wouldn't be ideal long term since that class will be refactored into an overlay.
* Plus, there's the added complexity of an additional way in which the dialog will spawn differently.
* There'll be some duplicated code. But, in the future, there'll be no duplicated code. So, I don't care.
*/
explicit save_manager_dialog(std::shared_ptr<gui_settings> gui_settings, std::shared_ptr<persistent_settings> persistent_settings, std::string dir = "", QWidget* parent = nullptr);
public Q_SLOTS:
void HandleRepaintUiRequest();
private Q_SLOTS:
void OnEntryRemove(int row, bool user_interaction);
void OnEntriesRemove();
void OnSort(int logicalIndex);
void SetIconSize(int size);
void UpdateDetails();
void text_changed(const QString& text);
Q_SIGNALS:
void IconReady(int index, const QPixmap& new_icon);
private:
void Init();
void UpdateList();
void UpdateIcons();
void ShowContextMenu(const QPoint &pos);
void WaitForRepaintThreads(bool abort);
void closeEvent(QCloseEvent* event) override;
std::vector<SaveDataEntry> GetSaveEntries(const std::string& base_dir);
QTableWidget* m_list = nullptr;
std::string m_dir;
std::vector<SaveDataEntry> m_save_entries;
std::shared_ptr<gui_settings> m_gui_settings;
std::shared_ptr<persistent_settings> m_persistent_settings;
int m_sort_column = 1;
bool m_sort_ascending = true;
QSize m_icon_size;
QColor m_icon_color;
QLabel* m_details_icon = nullptr;
QLabel* m_details_title = nullptr;
QLabel* m_details_subtitle = nullptr;
QLabel* m_details_modified = nullptr;
QLabel* m_details_details = nullptr;
QLabel* m_details_note = nullptr;
QPushButton* m_button_delete = nullptr;
QPushButton* m_button_folder = nullptr;
};
| 2,110
|
C++
|
.h
| 57
| 35.087719
| 181
| 0.775
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,791
|
localized_string_id.h
|
RPCS3_rpcs3/rpcs3/Emu/localized_string_id.h
|
#pragma once
enum class localized_string_id
{
INVALID,
RSX_OVERLAYS_TROPHY_BRONZE,
RSX_OVERLAYS_TROPHY_SILVER,
RSX_OVERLAYS_TROPHY_GOLD,
RSX_OVERLAYS_TROPHY_PLATINUM,
RSX_OVERLAYS_COMPILING_SHADERS,
RSX_OVERLAYS_COMPILING_PPU_MODULES,
RSX_OVERLAYS_MSG_DIALOG_YES,
RSX_OVERLAYS_MSG_DIALOG_NO,
RSX_OVERLAYS_MSG_DIALOG_CANCEL,
RSX_OVERLAYS_MSG_DIALOG_OK,
RSX_OVERLAYS_SAVE_DIALOG_TITLE,
RSX_OVERLAYS_SAVE_DIALOG_DELETE,
RSX_OVERLAYS_SAVE_DIALOG_LOAD,
RSX_OVERLAYS_SAVE_DIALOG_SAVE,
RSX_OVERLAYS_OSK_DIALOG_ACCEPT,
RSX_OVERLAYS_OSK_DIALOG_CANCEL,
RSX_OVERLAYS_OSK_DIALOG_SPACE,
RSX_OVERLAYS_OSK_DIALOG_BACKSPACE,
RSX_OVERLAYS_OSK_DIALOG_SHIFT,
RSX_OVERLAYS_OSK_DIALOG_ENTER_TEXT,
RSX_OVERLAYS_OSK_DIALOG_ENTER_PASSWORD,
RSX_OVERLAYS_MEDIA_DIALOG_TITLE,
RSX_OVERLAYS_MEDIA_DIALOG_TITLE_PHOTO_IMPORT,
RSX_OVERLAYS_MEDIA_DIALOG_EMPTY,
RSX_OVERLAYS_LIST_SELECT,
RSX_OVERLAYS_LIST_CANCEL,
RSX_OVERLAYS_LIST_DENY,
RSX_OVERLAYS_PRESSURE_INTENSITY_TOGGLED_OFF,
RSX_OVERLAYS_PRESSURE_INTENSITY_TOGGLED_ON,
RSX_OVERLAYS_ANALOG_LIMITER_TOGGLED_OFF,
RSX_OVERLAYS_ANALOG_LIMITER_TOGGLED_ON,
RSX_OVERLAYS_MOUSE_AND_KEYBOARD_EMULATED,
RSX_OVERLAYS_MOUSE_AND_KEYBOARD_PAD,
CELL_GAME_ERROR_BROKEN_GAMEDATA,
CELL_GAME_ERROR_BROKEN_HDDGAME,
CELL_GAME_ERROR_BROKEN_EXIT_GAMEDATA,
CELL_GAME_ERROR_BROKEN_EXIT_HDDGAME,
CELL_GAME_ERROR_NOSPACE,
CELL_GAME_ERROR_NOSPACE_EXIT,
CELL_GAME_ERROR_DIR_NAME,
CELL_GAME_DATA_EXIT_BROKEN,
CELL_HDD_GAME_EXIT_BROKEN,
CELL_HDD_GAME_CHECK_NOSPACE,
CELL_HDD_GAME_CHECK_BROKEN,
CELL_HDD_GAME_CHECK_NODATA,
CELL_HDD_GAME_CHECK_INVALID,
CELL_GAMEDATA_CHECK_NOSPACE,
CELL_GAMEDATA_CHECK_BROKEN,
CELL_GAMEDATA_CHECK_NODATA,
CELL_GAMEDATA_CHECK_INVALID,
CELL_MSG_DIALOG_ERROR_DEFAULT,
CELL_MSG_DIALOG_ERROR_80010001,
CELL_MSG_DIALOG_ERROR_80010002,
CELL_MSG_DIALOG_ERROR_80010003,
CELL_MSG_DIALOG_ERROR_80010004,
CELL_MSG_DIALOG_ERROR_80010005,
CELL_MSG_DIALOG_ERROR_80010006,
CELL_MSG_DIALOG_ERROR_80010007,
CELL_MSG_DIALOG_ERROR_80010008,
CELL_MSG_DIALOG_ERROR_80010009,
CELL_MSG_DIALOG_ERROR_8001000A,
CELL_MSG_DIALOG_ERROR_8001000B,
CELL_MSG_DIALOG_ERROR_8001000C,
CELL_MSG_DIALOG_ERROR_8001000D,
CELL_MSG_DIALOG_ERROR_8001000F,
CELL_MSG_DIALOG_ERROR_80010010,
CELL_MSG_DIALOG_ERROR_80010011,
CELL_MSG_DIALOG_ERROR_80010012,
CELL_MSG_DIALOG_ERROR_80010013,
CELL_MSG_DIALOG_ERROR_80010014,
CELL_MSG_DIALOG_ERROR_80010015,
CELL_MSG_DIALOG_ERROR_80010016,
CELL_MSG_DIALOG_ERROR_80010017,
CELL_MSG_DIALOG_ERROR_80010018,
CELL_MSG_DIALOG_ERROR_80010019,
CELL_MSG_DIALOG_ERROR_8001001A,
CELL_MSG_DIALOG_ERROR_8001001B,
CELL_MSG_DIALOG_ERROR_8001001C,
CELL_MSG_DIALOG_ERROR_8001001D,
CELL_MSG_DIALOG_ERROR_8001001E,
CELL_MSG_DIALOG_ERROR_8001001F,
CELL_MSG_DIALOG_ERROR_80010020,
CELL_MSG_DIALOG_ERROR_80010021,
CELL_MSG_DIALOG_ERROR_80010022,
CELL_MSG_DIALOG_ERROR_80010023,
CELL_MSG_DIALOG_ERROR_80010024,
CELL_MSG_DIALOG_ERROR_80010025,
CELL_MSG_DIALOG_ERROR_80010026,
CELL_MSG_DIALOG_ERROR_80010027,
CELL_MSG_DIALOG_ERROR_80010028,
CELL_MSG_DIALOG_ERROR_80010029,
CELL_MSG_DIALOG_ERROR_8001002A,
CELL_MSG_DIALOG_ERROR_8001002B,
CELL_MSG_DIALOG_ERROR_8001002C,
CELL_MSG_DIALOG_ERROR_8001002D,
CELL_MSG_DIALOG_ERROR_8001002E,
CELL_MSG_DIALOG_ERROR_8001002F,
CELL_MSG_DIALOG_ERROR_80010030,
CELL_MSG_DIALOG_ERROR_80010031,
CELL_MSG_DIALOG_ERROR_80010032,
CELL_MSG_DIALOG_ERROR_80010033,
CELL_MSG_DIALOG_ERROR_80010034,
CELL_MSG_DIALOG_ERROR_80010035,
CELL_MSG_DIALOG_ERROR_80010036,
CELL_MSG_DIALOG_ERROR_80010037,
CELL_MSG_DIALOG_ERROR_80010038,
CELL_MSG_DIALOG_ERROR_80010039,
CELL_MSG_DIALOG_ERROR_8001003A,
CELL_MSG_DIALOG_ERROR_8001003B,
CELL_MSG_DIALOG_ERROR_8001003C,
CELL_MSG_DIALOG_ERROR_8001003D,
CELL_MSG_DIALOG_ERROR_8001003E,
CELL_OSK_DIALOG_TITLE,
CELL_OSK_DIALOG_BUSY,
CELL_SAVEDATA_CB_BROKEN,
CELL_SAVEDATA_CB_FAILURE,
CELL_SAVEDATA_CB_NO_DATA,
CELL_SAVEDATA_CB_NO_SPACE,
CELL_SAVEDATA_NO_DATA,
CELL_SAVEDATA_NEW_SAVED_DATA_TITLE,
CELL_SAVEDATA_NEW_SAVED_DATA_SUB_TITLE,
CELL_SAVEDATA_SAVE_CONFIRMATION,
CELL_SAVEDATA_DELETE_CONFIRMATION,
CELL_SAVEDATA_DELETE_SUCCESS,
CELL_SAVEDATA_DELETE,
CELL_SAVEDATA_SAVE,
CELL_SAVEDATA_LOAD,
CELL_SAVEDATA_OVERWRITE,
CELL_SAVEDATA_AUTOSAVE,
CELL_SAVEDATA_AUTOLOAD,
CELL_CROSS_CONTROLLER_MSG,
CELL_CROSS_CONTROLLER_FW_MSG,
CELL_NP_RECVMESSAGE_DIALOG_TITLE,
CELL_NP_RECVMESSAGE_DIALOG_TITLE_INVITE,
CELL_NP_RECVMESSAGE_DIALOG_TITLE_ADD_FRIEND,
CELL_NP_RECVMESSAGE_DIALOG_FROM,
CELL_NP_RECVMESSAGE_DIALOG_SUBJECT,
CELL_NP_SENDMESSAGE_DIALOG_TITLE,
CELL_NP_SENDMESSAGE_DIALOG_TITLE_INVITE,
CELL_NP_SENDMESSAGE_DIALOG_TITLE_ADD_FRIEND,
CELL_NP_SENDMESSAGE_DIALOG_CONFIRMATION,
CELL_NP_SENDMESSAGE_DIALOG_CONFIRMATION_INVITE,
CELL_NP_SENDMESSAGE_DIALOG_CONFIRMATION_ADD_FRIEND,
RECORDING_ABORTED,
RPCN_NO_ERROR,
RPCN_ERROR_INVALID_INPUT,
RPCN_ERROR_WOLFSSL,
RPCN_ERROR_RESOLVE,
RPCN_ERROR_CONNECT,
RPCN_ERROR_LOGIN_ERROR,
RPCN_ERROR_ALREADY_LOGGED,
RPCN_ERROR_INVALID_LOGIN,
RPCN_ERROR_INVALID_PASSWORD,
RPCN_ERROR_INVALID_TOKEN,
RPCN_ERROR_INVALID_PROTOCOL_VERSION,
RPCN_ERROR_UNKNOWN,
RPCN_SUCCESS_LOGGED_ON,
RPCN_FRIEND_REQUEST_RECEIVED,
RPCN_FRIEND_ADDED,
RPCN_FRIEND_LOST,
RPCN_FRIEND_LOGGED_IN,
RPCN_FRIEND_LOGGED_OUT,
HOME_MENU_TITLE,
HOME_MENU_EXIT_GAME,
HOME_MENU_RESTART,
HOME_MENU_RESUME,
HOME_MENU_FRIENDS,
HOME_MENU_FRIENDS_REQUESTS,
HOME_MENU_FRIENDS_BLOCKED,
HOME_MENU_FRIENDS_STATUS_ONLINE,
HOME_MENU_FRIENDS_STATUS_OFFLINE,
HOME_MENU_FRIENDS_STATUS_BLOCKED,
HOME_MENU_FRIENDS_REQUEST_SENT,
HOME_MENU_FRIENDS_REQUEST_RECEIVED,
HOME_MENU_FRIENDS_BLOCK_USER_MSG,
HOME_MENU_FRIENDS_UNBLOCK_USER_MSG,
HOME_MENU_FRIENDS_REMOVE_USER_MSG,
HOME_MENU_FRIENDS_ACCEPT_REQUEST_MSG,
HOME_MENU_FRIENDS_CANCEL_REQUEST_MSG,
HOME_MENU_FRIENDS_REJECT_REQUEST_MSG,
HOME_MENU_FRIENDS_REJECT_REQUEST,
HOME_MENU_FRIENDS_NEXT_LIST,
HOME_MENU_SETTINGS,
HOME_MENU_SETTINGS_SAVE,
HOME_MENU_SETTINGS_SAVE_BUTTON,
HOME_MENU_SETTINGS_DISCARD,
HOME_MENU_SETTINGS_DISCARD_BUTTON,
HOME_MENU_SETTINGS_AUDIO,
HOME_MENU_SETTINGS_AUDIO_MASTER_VOLUME,
HOME_MENU_SETTINGS_AUDIO_BACKEND,
HOME_MENU_SETTINGS_AUDIO_BUFFERING,
HOME_MENU_SETTINGS_AUDIO_BUFFER_DURATION,
HOME_MENU_SETTINGS_AUDIO_TIME_STRETCHING,
HOME_MENU_SETTINGS_AUDIO_TIME_STRETCHING_THRESHOLD,
HOME_MENU_SETTINGS_VIDEO,
HOME_MENU_SETTINGS_VIDEO_FRAME_LIMIT,
HOME_MENU_SETTINGS_VIDEO_ANISOTROPIC_OVERRIDE,
HOME_MENU_SETTINGS_VIDEO_OUTPUT_SCALING,
HOME_MENU_SETTINGS_VIDEO_RCAS_SHARPENING,
HOME_MENU_SETTINGS_VIDEO_STRETCH_TO_DISPLAY,
HOME_MENU_SETTINGS_INPUT,
HOME_MENU_SETTINGS_INPUT_BACKGROUND_INPUT,
HOME_MENU_SETTINGS_INPUT_KEEP_PADS_CONNECTED,
HOME_MENU_SETTINGS_INPUT_SHOW_PS_MOVE_CURSOR,
HOME_MENU_SETTINGS_INPUT_CAMERA_FLIP,
HOME_MENU_SETTINGS_INPUT_PAD_MODE,
HOME_MENU_SETTINGS_INPUT_PAD_SLEEP,
HOME_MENU_SETTINGS_ADVANCED,
HOME_MENU_SETTINGS_ADVANCED_PREFERRED_SPU_THREADS,
HOME_MENU_SETTINGS_ADVANCED_MAX_CPU_PREEMPTIONS,
HOME_MENU_SETTINGS_ADVANCED_ACCURATE_RSX_RESERVATION_ACCESS,
HOME_MENU_SETTINGS_ADVANCED_SLEEP_TIMERS_ACCURACY,
HOME_MENU_SETTINGS_ADVANCED_MAX_SPURS_THREADS,
HOME_MENU_SETTINGS_ADVANCED_DRIVER_WAKE_UP_DELAY,
HOME_MENU_SETTINGS_ADVANCED_VBLANK_FREQUENCY,
HOME_MENU_SETTINGS_ADVANCED_VBLANK_NTSC,
HOME_MENU_SETTINGS_OVERLAYS,
HOME_MENU_SETTINGS_OVERLAYS_SHOW_TROPHY_POPUPS,
HOME_MENU_SETTINGS_OVERLAYS_SHOW_RPCN_POPUPS,
HOME_MENU_SETTINGS_OVERLAYS_SHOW_SHADER_COMPILATION_HINT,
HOME_MENU_SETTINGS_OVERLAYS_SHOW_PPU_COMPILATION_HINT,
HOME_MENU_SETTINGS_OVERLAYS_SHOW_AUTO_SAVE_LOAD_HINT,
HOME_MENU_SETTINGS_OVERLAYS_SHOW_PRESSURE_INTENSITY_TOGGLE_HINT,
HOME_MENU_SETTINGS_OVERLAYS_SHOW_ANALOG_LIMITER_TOGGLE_HINT,
HOME_MENU_SETTINGS_OVERLAYS_SHOW_MOUSE_AND_KB_TOGGLE_HINT,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE_FRAMERATE_GRAPH,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE_FRAMETIME_GRAPH,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_DETAIL_LEVEL,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FRAMERATE_DETAIL_LEVEL,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FRAMETIME_DETAIL_LEVEL,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FRAMERATE_DATAPOINT_COUNT,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FRAMETIME_DATAPOINT_COUNT,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_UPDATE_INTERVAL,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_POSITION,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_CENTER_X,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_CENTER_Y,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_X,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_Y,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FONT_SIZE,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_OPACITY,
HOME_MENU_SETTINGS_DEBUG,
HOME_MENU_SETTINGS_DEBUG_OVERLAY,
HOME_MENU_SETTINGS_DEBUG_INPUT_OVERLAY,
HOME_MENU_SETTINGS_DEBUG_DISABLE_VIDEO_OUTPUT,
HOME_MENU_SETTINGS_DEBUG_TEXTURE_LOD_BIAS,
HOME_MENU_SCREENSHOT,
HOME_MENU_SAVESTATE,
HOME_MENU_SAVESTATE_AND_EXIT,
HOME_MENU_RELOAD_SAVESTATE,
HOME_MENU_RECORDING,
PROGRESS_DIALOG_PROGRESS,
PROGRESS_DIALOG_PROGRESS_ANALYZING,
PROGRESS_DIALOG_REMAINING,
PROGRESS_DIALOG_DONE,
PROGRESS_DIALOG_FILE,
PROGRESS_DIALOG_MODULE,
PROGRESS_DIALOG_OF,
PROGRESS_DIALOG_PLEASE_WAIT,
PROGRESS_DIALOG_STOPPING_PLEASE_WAIT,
PROGRESS_DIALOG_SCANNING_PPU_EXECUTABLE,
PROGRESS_DIALOG_ANALYZING_PPU_EXECUTABLE,
PROGRESS_DIALOG_SCANNING_PPU_MODULES,
PROGRESS_DIALOG_LOADING_PPU_MODULES,
PROGRESS_DIALOG_COMPILING_PPU_MODULES,
PROGRESS_DIALOG_LINKING_PPU_MODULES,
PROGRESS_DIALOG_APPLYING_PPU_CODE,
PROGRESS_DIALOG_BUILDING_SPU_CACHE,
EMULATION_PAUSED_RESUME_WITH_START,
EMULATION_RESUMING,
EMULATION_FROZEN,
SAVESTATE_FAILED_DUE_TO_VDEC,
SAVESTATE_FAILED_DUE_TO_SAVEDATA,
SAVESTATE_FAILED_DUE_TO_SPU,
SAVESTATE_FAILED_DUE_TO_MISSING_SPU_SETTING,
};
| 9,788
|
C++
|
.h
| 281
| 32.790036
| 66
| 0.82162
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,792
|
system_utils.hpp
|
RPCS3_rpcs3/rpcs3/Emu/system_utils.hpp
|
#pragma once
#include "util/types.hpp"
#include <string>
namespace rpcs3::utils
{
u32 get_max_threads();
void configure_logs(bool force_enable = false);
u32 check_user(const std::string& user);
bool install_pkg(const std::string& path);
std::string get_emu_dir();
std::string get_games_dir();
std::string get_hdd0_dir();
std::string get_hdd1_dir();
std::string get_cache_dir();
std::string get_cache_dir(std::string_view module_path);
std::string get_rap_file_path(const std::string_view& rap);
bool verify_c00_unlock_edat(const std::string_view& content_id, bool fast = false);
std::string get_sfo_dir_from_game_path(const std::string& game_path, const std::string& title_id = "");
std::string get_custom_config_dir();
std::string get_custom_config_path(const std::string& identifier);
std::string get_input_config_root();
std::string get_input_config_dir(const std::string& title_id = "");
std::string get_custom_input_config_path(const std::string& title_id);
}
| 992
|
C++
|
.h
| 24
| 39.208333
| 104
| 0.732013
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,793
|
games_config.h
|
RPCS3_rpcs3/rpcs3/Emu/games_config.h
|
#pragma once
#include "Utilities/mutex.h"
#include <map>
class games_config
{
public:
games_config();
virtual ~games_config();
void set_save_on_dirty(bool enabled) { m_save_on_dirty = enabled; }
const std::map<std::string, std::string> get_games() const;
bool is_dirty() const { return m_dirty; }
std::string get_path(const std::string& title_id) const;
enum class result
{
failure,
success,
exists
};
result add_game(const std::string& key, const std::string& path);
result add_external_hdd_game(const std::string& key, std::string& path);
result remove_game(const std::string& key);
bool save();
private:
bool save_nl();
void load();
std::map<std::string, std::string> m_games;
mutable shared_mutex m_mutex;
bool m_dirty = false;
bool m_save_on_dirty = true;
};
| 798
|
C++
|
.h
| 30
| 24.466667
| 73
| 0.71805
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,794
|
perf_monitor.hpp
|
RPCS3_rpcs3/rpcs3/Emu/perf_monitor.hpp
|
#pragma once
#include "util/types.hpp"
struct perf_monitor
{
void operator()();
~perf_monitor();
static constexpr auto thread_name = "Performance Sensor"sv;
};
| 166
|
C++
|
.h
| 8
| 19
| 60
| 0.754839
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,795
|
localized_string.h
|
RPCS3_rpcs3/rpcs3/Emu/localized_string.h
|
#pragma once
#include <string>
#include "localized_string_id.h"
std::string get_localized_string(localized_string_id id, const char* args = "");
std::u32string get_localized_u32string(localized_string_id id, const char* args = "");
| 234
|
C++
|
.h
| 5
| 45.4
| 86
| 0.757709
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,796
|
savestate_utils.hpp
|
RPCS3_rpcs3/rpcs3/Emu/savestate_utils.hpp
|
#pragma once
#include "util/serialization_ext.hpp"
struct version_entry
{
u16 type;
u16 version;
ENABLE_BITWISE_SERIALIZATION;
};
struct hle_locks_t
{
atomic_t<s64> lock_val{0};
enum states : s64
{
waiting_for_evaluation = -1,
finalized = -2,
};
[[noreturn]] void lock();
bool try_lock();
void unlock();
bool try_finalize(std::function<bool()> test);
};
bool load_and_check_reserved(utils::serial& ar, usz size);
bool is_savestate_version_compatible(const std::vector<version_entry>& data, bool is_boot_check);
std::vector<version_entry> get_savestate_versioning_data(fs::file&& file, std::string_view filepath);
bool is_savestate_compatible(fs::file&& file, std::string_view filepath);
std::vector<version_entry> read_used_savestate_versions();
std::string get_savestate_file(std::string_view title_id, std::string_view boot_path, s64 abs_id, s64 rel_id);
| 879
|
C++
|
.h
| 27
| 30.740741
| 110
| 0.747929
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,797
|
perf_meter.hpp
|
RPCS3_rpcs3/rpcs3/Emu/perf_meter.hpp
|
#pragma once
#include "util/types.hpp"
#include "util/logs.hpp"
#include "util/tsc.hpp"
#include "system_config.h"
#include <array>
#include <cmath>
LOG_CHANNEL(perf_log, "PERF");
// TODO: constexpr with the help of bitcast
template <auto Name>
inline const auto perf_name = []
{
constexpr auto short_name = Name;
std::array<char, sizeof(Name) + 1> result{};
std::memcpy(result.data(), &short_name, sizeof(Name));
return result;
}();
class perf_stat_base
{
atomic_t<u64> m_log[66]{};
protected:
// Print accumulated values
void print(const char* name) const noexcept;
// Accumulate values from a thread
void push(u64 ns[66]) noexcept;
// Get end time; accumulate value to the TLS
static void push(u64 data[66], u64 start_time, const char* name) noexcept;
// Register TLS storage for stats
static void add(u64 ns[66], const char* name) noexcept;
// Unregister TLS storage and drain its data
static void remove(u64 ns[66], const char* name) noexcept;
public:
perf_stat_base() noexcept = default;
perf_stat_base(const perf_stat_base&) = delete;
perf_stat_base& operator =(const perf_stat_base&) = delete;
~perf_stat_base() {}
// Collect all data, report it, and clean
static void report() noexcept;
};
// Object that prints event length stats at the end
template <auto ShortName>
class perf_stat final : public perf_stat_base
{
static inline thread_local struct perf_stat_local
{
// Local non-atomic values for increments
u64 m_log[66]{};
perf_stat_local() noexcept
{
perf_stat_base::add(m_log, perf_name<ShortName>.data());
}
~perf_stat_local()
{
perf_stat_base::remove(m_log, perf_name<ShortName>.data());
}
} g_tls_perf_stat;
public:
static FORCE_INLINE SAFE_BUFFERS(void) push(u64 start_time) noexcept
{
perf_stat_base::push(g_tls_perf_stat.m_log, start_time, perf_name<ShortName>.data());
}
};
// Object that prints event length at the end
template <auto ShortName, auto... SubEvents>
class perf_meter
{
// Initialize array (possibly only 1 element) with timestamp
u64 m_timestamps[1 + sizeof...(SubEvents)];
public:
FORCE_INLINE SAFE_BUFFERS() perf_meter() noexcept
{
restart();
}
FORCE_INLINE SAFE_BUFFERS() perf_meter(int) noexcept
{
std::fill(std::begin(m_timestamps), std::end(m_timestamps), 0);
}
FORCE_INLINE SAFE_BUFFERS(operator bool) () const noexcept
{
return m_timestamps[0] != 0;
}
// Copy first timestamp
template <auto SN, auto... S>
FORCE_INLINE SAFE_BUFFERS() perf_meter(const perf_meter<SN, S...>& r) noexcept
{
m_timestamps[0] = r.get();
std::memset(m_timestamps + 1, 0, sizeof(m_timestamps) - sizeof(u64));
}
template <auto SN, auto... S>
SAFE_BUFFERS() perf_meter(perf_meter<SN, S...>&& r) noexcept
{
m_timestamps[0] = r.get();
r.reset();
}
// Copy first timestamp
template <auto SN, auto... S>
SAFE_BUFFERS(perf_meter&) operator =(const perf_meter<SN, S...>& r) noexcept
{
m_timestamps[0] = r.get();
return *this;
}
template <auto SN, auto... S>
SAFE_BUFFERS(perf_meter&) operator =(perf_meter<SN, S...>& r) noexcept
{
m_timestamps[0] = r.get();
r.reset();
return *this;
}
// Push subevent data in array
template <auto Event, usz Index = 0>
SAFE_BUFFERS(void) push() noexcept
{
// TODO: should use more efficient search with type comparison, then value comparison, or pattern matching
if constexpr (std::array<bool, sizeof...(SubEvents)>{(SubEvents == Event)...}[Index])
{
// Push actual timestamp into an array
m_timestamps[Index + 1] = utils::get_tsc();
}
else if constexpr (Index < sizeof...(SubEvents))
{
// Proceed search recursively
push<Event, Index + 1>();
}
}
// Obtain initial timestamp
u64 get() const noexcept
{
return m_timestamps[0];
}
// Disable this counter
FORCE_INLINE SAFE_BUFFERS(void) reset() noexcept
{
m_timestamps[0] = 0;
}
// Re-initialize first timestamp
FORCE_INLINE SAFE_BUFFERS(void) restart() noexcept
{
m_timestamps[0] = utils::get_tsc();
std::memset(m_timestamps + 1, 0, sizeof(m_timestamps) - sizeof(u64));
}
SAFE_BUFFERS() ~perf_meter()
{
// Disabled counter
if (!m_timestamps[0]) [[unlikely]]
{
return;
}
if (!g_cfg.core.perf_report) [[likely]]
{
return;
}
// Register perf stat in nanoseconds
perf_stat<ShortName>::push(m_timestamps[0]);
// TODO: handle push(), currently ignored
}
};
| 4,364
|
C++
|
.h
| 156
| 25.570513
| 108
| 0.701653
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
5,798
|
system_config.h
|
RPCS3_rpcs3/rpcs3/Emu/system_config.h
|
#pragma once
#include "config_mode.h"
#include "system_config_types.h"
#include "Utilities/Config.h"
enum CellNetCtlState : s32;
enum CellSysutilLicenseArea : s32;
enum CellSysutilLang : s32;
enum CellKbMappingType : s32;
struct cfg_root : cfg::node
{
struct node_core : cfg::node
{
private:
/** We don't wanna include the sysinfo header here */
static bool enable_tsx_by_default();
public:
node_core(cfg::node* _this) : cfg::node(_this, "Core") {}
cfg::_enum<ppu_decoder_type> ppu_decoder{ this, "PPU Decoder", ppu_decoder_type::llvm };
cfg::_int<1, 8> ppu_threads{ this, "PPU Threads", 2 }; // Amount of PPU threads running simultaneously (must be 2)
cfg::_bool ppu_debug{ this, "PPU Debug" };
cfg::_bool ppu_call_history{ this, "PPU Calling History" }; // Enable PPU calling history recording
cfg::_bool llvm_logs{ this, "Save LLVM logs" };
cfg::string llvm_cpu{ this, "Use LLVM CPU" };
cfg::_int<0, 1024> llvm_threads{ this, "Max LLVM Compile Threads", 0 };
cfg::_bool ppu_llvm_greedy_mode{ this, "PPU LLVM Greedy Mode", false, false };
cfg::_bool llvm_precompilation{ this, "LLVM Precompilation", true };
cfg::_enum<thread_scheduler_mode> thread_scheduler{this, "Thread Scheduler Mode", thread_scheduler_mode::os};
cfg::_bool set_daz_and_ftz{ this, "Set DAZ and FTZ", false };
cfg::_enum<spu_decoder_type> spu_decoder{ this, "SPU Decoder", spu_decoder_type::llvm };
cfg::uint<0, 100> spu_reservation_busy_waiting_percentage{ this, "SPU Reservation Busy Waiting Percentage", 0, true };
cfg::uint<0, 101> spu_getllar_busy_waiting_percentage{ this, "SPU GETLLAR Busy Waiting Percentage", 100, true };
cfg::_bool spu_debug{ this, "SPU Debug" };
cfg::_bool mfc_debug{ this, "MFC Debug" };
cfg::_int<0, 6> preferred_spu_threads{ this, "Preferred SPU Threads", 0, true }; // Number of hardware threads dedicated to heavy simultaneous spu tasks
cfg::_int<0, 16> spu_delay_penalty{ this, "SPU delay penalty", 3 }; // Number of milliseconds to block a thread if a virtual 'core' isn't free
cfg::_bool spu_loop_detection{ this, "SPU loop detection", false }; // Try to detect wait loops and trigger thread yield
cfg::_int<1, 6> max_spurs_threads{ this, "Max SPURS Threads", 6, true }; // HACK. If less then 6, max number of running SPURS threads in each thread group.
cfg::_enum<spu_block_size_type> spu_block_size{ this, "SPU Block Size", spu_block_size_type::safe };
cfg::_bool spu_accurate_dma{ this, "Accurate SPU DMA", false };
cfg::_bool spu_accurate_reservations{ this, "Accurate SPU Reservations", true };
cfg::_bool accurate_cache_line_stores{ this, "Accurate Cache Line Stores", false };
cfg::_bool rsx_accurate_res_access{this, "Accurate RSX reservation access", false, true};
struct fifo_setting : public cfg::_enum<rsx_fifo_mode>
{
using _enum = cfg::_enum<rsx_fifo_mode>;
using _enum::_enum;
explicit operator bool() const
{
return get() != rsx_fifo_mode::fast;
}
};
fifo_setting rsx_fifo_accuracy{this, "RSX FIFO Accuracy", rsx_fifo_mode::fast };
cfg::_bool spu_verification{ this, "SPU Verification", true }; // Should be enabled
cfg::_bool spu_cache{ this, "SPU Cache", true };
cfg::_bool spu_prof{ this, "SPU Profiler", false };
cfg::uint<0, 16> mfc_transfers_shuffling{ this, "MFC Commands Shuffling Limit", 0 };
cfg::uint<0, 10000> mfc_transfers_timeout{ this, "MFC Commands Timeout", 0, true };
cfg::_bool mfc_shuffling_in_steps{ this, "MFC Commands Shuffling In Steps", false, true };
cfg::_enum<tsx_usage> enable_TSX{ this, "Enable TSX", enable_tsx_by_default() ? tsx_usage::enabled : tsx_usage::disabled }; // Enable TSX. Forcing this on Haswell/Broadwell CPUs should be used carefully
cfg::_enum<xfloat_accuracy> spu_xfloat_accuracy{ this, "XFloat Accuracy", xfloat_accuracy::approximate, false };
cfg::_int<-1, 14> ppu_128_reservations_loop_max_length{ this, "Accurate PPU 128-byte Reservation Op Max Length", 0, true }; // -1: Always accurate, 0: Never accurate, 1-14: max accurate loop length
cfg::_int<-64, 64> stub_ppu_traps{ this, "Stub PPU Traps", 0, true }; // Hack, skip PPU traps for rare cases where the trap is continueable (specify relative instructions to skip)
cfg::_bool full_width_avx512{ this, "Full Width AVX-512", true };
cfg::_bool ppu_llvm_nj_fixup{ this, "PPU LLVM Java Mode Handling", true }; // Partially respect current Java Mode for alti-vec ops by PPU LLVM
cfg::_bool use_accurate_dfma{ this, "Use Accurate DFMA", true }; // Enable accurate double-precision FMA for CPUs which do not support it natively
cfg::_bool ppu_set_sat_bit{ this, "PPU Set Saturation Bit", false }; // Accuracy. If unset, completely disable saturation flag handling.
cfg::_bool ppu_use_nj_bit{ this, "PPU Accurate Non-Java Mode", false }; // Accuracy. If set, accurately emulate NJ flag. Implies NJ fixup.
cfg::_bool ppu_fix_vnan{ this, "PPU Fixup Vector NaN Values", false }; // Accuracy. Partial.
cfg::_bool ppu_set_vnan{ this, "PPU Accurate Vector NaN Values", false }; // Accuracy. Implies ppu_fix_vnan.
cfg::_bool ppu_set_fpcc{ this, "PPU Set FPCC Bits", false }; // Accuracy.
cfg::_bool debug_console_mode{ this, "Debug Console Mode", false }; // Debug console emulation, not recommended
cfg::_bool hook_functions{ this, "Hook static functions" };
cfg::set_entry libraries_control{ this, "Libraries Control" }; // Override HLE/LLE behaviour of selected libs
cfg::_bool hle_lwmutex{ this, "HLE lwmutex" }; // Force alternative lwmutex/lwcond implementation
cfg::uint64 spu_llvm_lower_bound{ this, "SPU LLVM Lower Bound" };
cfg::uint64 spu_llvm_upper_bound{ this, "SPU LLVM Upper Bound", 0xffffffffffffffff };
cfg::uint64 tx_limit1_ns{this, "TSX Transaction First Limit", 800}; // In nanoseconds
cfg::uint64 tx_limit2_ns{this, "TSX Transaction Second Limit", 2000}; // In nanoseconds
cfg::_int<10, 3000> clocks_scale{ this, "Clocks scale", 100 }; // Changing this from 100 (percentage) may affect game speed in unexpected ways
cfg::uint<0, 3000> spu_wakeup_delay{ this, "SPU Wake-Up Delay", 0, true };
cfg::uint<0, (1 << 6) - 1> spu_wakeup_delay_mask{ this, "SPU Wake-Up Delay Thread Mask", (1 << 6) - 1, true };
cfg::uint<0, 400> max_cpu_preempt_count_per_frame{ this, "Max CPU Preempt Count", 0, true };
cfg::_bool allow_rsx_cpu_preempt{ this, "Allow RSX CPU Preemptions", true, true };
#if defined (__linux__) || defined (__APPLE__)
cfg::_enum<sleep_timers_accuracy_level> sleep_timers_accuracy{ this, "Sleep Timers Accuracy", sleep_timers_accuracy_level::_as_host, true };
#else
cfg::_enum<sleep_timers_accuracy_level> sleep_timers_accuracy{ this, "Sleep Timers Accuracy", sleep_timers_accuracy_level::_usleep, true };
#endif
cfg::_int<-1000, 1500> usleep_addend{ this, "Usleep Time Addend", 0, true };
cfg::uint64 perf_report_threshold{this, "Performance Report Threshold", 500, true}; // In µs, 0.5ms = default, 0 = everything
cfg::_bool perf_report{this, "Enable Performance Report", false, true}; // Show certain perf-related logs
cfg::_bool external_debugger{this, "Assume External Debugger"};
} core{ this };
struct node_vfs : cfg::node
{
node_vfs(cfg::node* _this) : cfg::node(_this, "VFS") {}
cfg::_bool host_root{ this, "Enable /host_root/" };
cfg::_bool init_dirs{ this, "Initialize Directories", true };
cfg::_bool limit_cache_size{ this, "Limit disk cache size", false };
cfg::_int<0, 10240> cache_max_size{ this, "Disk cache maximum size (MB)", 5120 };
cfg::_bool empty_hdd0_tmp{ this, "Empty /dev_hdd0/tmp/", true };
} vfs{ this };
struct node_video : cfg::node
{
node_video(cfg::node* _this) : cfg::node(_this, "Video") {}
#ifdef __APPLE__
cfg::_enum<video_renderer> renderer{ this, "Renderer", video_renderer::vulkan };
#else
cfg::_enum<video_renderer> renderer{ this, "Renderer", video_renderer::opengl };
#endif
cfg::_enum<video_resolution> resolution{ this, "Resolution", video_resolution::_720p };
cfg::_enum<video_aspect> aspect_ratio{ this, "Aspect ratio", video_aspect::_16_9 };
cfg::_enum<frame_limit_type> frame_limit{ this, "Frame limit", frame_limit_type::_auto, true };
cfg::_float<0, 1000> second_frame_limit{ this, "Second Frame Limit", 0, true }; // 0 disables its effect
cfg::_enum<msaa_level> antialiasing_level{ this, "MSAA", msaa_level::_auto };
cfg::_enum<shader_mode> shadermode{ this, "Shader Mode", shader_mode::async_recompiler };
cfg::_enum<gpu_preset_level> shader_precision{ this, "Shader Precision", gpu_preset_level::high };
cfg::_bool write_color_buffers{ this, "Write Color Buffers" };
cfg::_bool write_depth_buffer{ this, "Write Depth Buffer" };
cfg::_bool read_color_buffers{ this, "Read Color Buffers" };
cfg::_bool read_depth_buffer{ this, "Read Depth Buffer" };
cfg::_bool handle_tiled_memory{ this, "Handle RSX Memory Tiling", false, true };
cfg::_bool log_programs{ this, "Log shader programs" };
cfg::_bool vsync{ this, "VSync" };
cfg::_bool debug_output{ this, "Debug output" };
cfg::_bool overlay{ this, "Debug overlay", false, true };
cfg::_bool renderdoc_compatiblity{ this, "Renderdoc Compatibility Mode" };
cfg::_bool use_gpu_texture_scaling{ this, "Use GPU texture scaling", false };
cfg::_bool stretch_to_display_area{ this, "Stretch To Display Area", false, true };
cfg::_bool force_high_precision_z_buffer{ this, "Force High Precision Z buffer" };
cfg::_bool strict_rendering_mode{ this, "Strict Rendering Mode" };
cfg::_bool disable_zcull_queries{ this, "Disable ZCull Occlusion Queries", false, true };
cfg::_bool disable_video_output{ this, "Disable Video Output", false, true };
cfg::_bool disable_vertex_cache{ this, "Disable Vertex Cache", false };
cfg::_bool disable_FIFO_reordering{ this, "Disable FIFO Reordering", false };
cfg::_bool frame_skip_enabled{ this, "Enable Frame Skip", false, true };
cfg::_bool force_cpu_blit_processing{ this, "Force CPU Blit", false, true }; // Debugging option
cfg::_bool disable_on_disk_shader_cache{ this, "Disable On-Disk Shader Cache", false };
cfg::_bool disable_vulkan_mem_allocator{ this, "Disable Vulkan Memory Allocator", false };
cfg::_bool full_rgb_range_output{ this, "Use full RGB output range", true, true }; // Video out dynamic range
cfg::_bool strict_texture_flushing{ this, "Strict Texture Flushing", false };
cfg::_bool multithreaded_rsx{ this, "Multithreaded RSX", false };
cfg::_bool relaxed_zcull_sync{ this, "Relaxed ZCULL Sync", false };
cfg::_bool force_hw_MSAA_resolve{ this, "Force Hardware MSAA Resolve", false, true };
cfg::_enum<stereo_render_mode_options> stereo_render_mode{ this, "3D Display Mode", stereo_render_mode_options::disabled };
cfg::_bool debug_program_analyser{ this, "Debug Program Analyser", false };
cfg::_bool precise_zpass_count{ this, "Accurate ZCULL stats", true };
cfg::_int<1, 8> consecutive_frames_to_draw{ this, "Consecutive Frames To Draw", 1, true};
cfg::_int<1, 8> consecutive_frames_to_skip{ this, "Consecutive Frames To Skip", 1, true};
cfg::_int<25, 800> resolution_scale_percent{ this, "Resolution Scale", 100 };
cfg::uint<0, 16> anisotropic_level_override{ this, "Anisotropic Filter Override", 0, true };
cfg::_float<-32, 32> texture_lod_bias{ this, "Texture LOD Bias Addend", 0, true };
cfg::_int<1, 1024> min_scalable_dimension{ this, "Minimum Scalable Dimension", 16 };
cfg::_int<0, 16> shader_compiler_threads_count{ this, "Shader Compiler Threads", 0 };
cfg::_int<0, 30000000> driver_recovery_timeout{ this, "Driver Recovery Timeout", 1000000, true };
cfg::uint<0, 16667> driver_wakeup_delay{ this, "Driver Wake-Up Delay", 1, true };
cfg::_int<1, 3000> vblank_rate{ this, "Vblank Rate", 60, true }; // Changing this from 60 may affect game speed in unexpected ways
cfg::_bool vblank_ntsc{ this, "Vblank NTSC Fixup", false, true };
cfg::_bool decr_memory_layout{ this, "DECR memory layout", false}; // Force enable increased allowed main memory range as DECR console
cfg::_bool host_label_synchronization{ this, "Allow Host GPU Labels", false };
cfg::_bool disable_msl_fast_math{ this, "Disable MSL Fast Math", false };
cfg::_enum<output_scaling_mode> output_scaling{ this, "Output Scaling Mode", output_scaling_mode::bilinear, true };
struct node_vk : cfg::node
{
node_vk(cfg::node* _this) : cfg::node(_this, "Vulkan") {}
cfg::string adapter{ this, "Adapter" };
cfg::_bool force_fifo{ this, "Force FIFO present mode" };
cfg::_bool force_primitive_restart{ this, "Force primitive restart flag" };
cfg::_enum<vk_exclusive_fs_mode> exclusive_fullscreen_mode{ this, "Exclusive Fullscreen Mode", vk_exclusive_fs_mode::unspecified};
cfg::_bool asynchronous_texture_streaming{ this, "Asynchronous Texture Streaming 2", false };
cfg::uint<0, 100> rcas_sharpening_intensity{ this, "FidelityFX CAS Sharpening Intensity", 50, true };
cfg::_enum<vk_gpu_scheduler_mode> asynchronous_scheduler{ this, "Asynchronous Queue Scheduler", vk_gpu_scheduler_mode::safe };
cfg::uint<256, 65536> vram_allocation_limit{ this, "VRAM allocation limit (MB)", 65536, false };
} vk{ this };
struct node_perf_overlay : cfg::node
{
node_perf_overlay(cfg::node* _this) : cfg::node(_this, "Performance Overlay") {}
cfg::_bool perf_overlay_enabled{ this, "Enabled", false, true };
cfg::_bool framerate_graph_enabled{ this, "Enable Framerate Graph", false, true };
cfg::_bool frametime_graph_enabled{ this, "Enable Frametime Graph", false, true };
cfg::uint<2, 6000> framerate_datapoint_count{ this, "Framerate datapoints", 50, true };
cfg::uint<2, 6000> frametime_datapoint_count{ this, "Frametime datapoints", 170, true };
cfg::_enum<detail_level> level{ this, "Detail level", detail_level::medium, true };
cfg::_enum<perf_graph_detail_level> framerate_graph_detail_level{ this, "Framerate graph detail level", perf_graph_detail_level::show_all, true };
cfg::_enum<perf_graph_detail_level> frametime_graph_detail_level{ this, "Frametime graph detail level", perf_graph_detail_level::show_all, true };
cfg::uint<1, 1000> update_interval{ this, "Metrics update interval (ms)", 350, true };
cfg::uint<4, 36> font_size{ this, "Font size (px)", 10, true };
cfg::_enum<screen_quadrant> position{ this, "Position", screen_quadrant::top_left, true };
cfg::string font{ this, "Font", "n023055ms.ttf", true };
cfg::uint<0, 1280> margin_x{ this, "Horizontal Margin (px)", 50, true }; // horizontal distance to the screen border relative to the screen_quadrant in px
cfg::uint<0, 720> margin_y{ this, "Vertical Margin (px)", 50, true }; // vertical distance to the screen border relative to the screen_quadrant in px
cfg::_bool center_x{ this, "Center Horizontally", false, true };
cfg::_bool center_y{ this, "Center Vertically", false, true };
cfg::uint<0, 100> opacity{ this, "Opacity (%)", 70, true };
cfg::string color_body{ this, "Body Color (hex)", "#FFE138FF", true };
cfg::string background_body{ this, "Body Background (hex)", "#002339FF", true };
cfg::string color_title{ this, "Title Color (hex)", "#F26C24FF", true };
cfg::string background_title{ this, "Title Background (hex)", "#00000000", true };
} perf_overlay{ this };
struct node_shader_preloading_dialog : cfg::node
{
node_shader_preloading_dialog(cfg::node* _this) : cfg::node(_this, "Shader Loading Dialog") {}
cfg::_bool use_custom_background{ this, "Allow custom background", true, true };
cfg::uint<0, 100> darkening_strength{ this, "Darkening effect strength", 30, true };
cfg::uint<0, 100> blur_strength{ this, "Blur effect strength", 0, true };
} shader_preloading_dialog{ this };
} video{ this };
struct node_audio : cfg::node
{
node_audio(cfg::node* _this) : cfg::node(_this, "Audio") {}
cfg::_enum<audio_renderer> renderer{ this, "Renderer", audio_renderer::cubeb, true };
cfg::_enum<audio_provider> provider{ this, "Audio Provider", audio_provider::cell_audio, false };
cfg::_enum<audio_avport> rsxaudio_port{ this, "RSXAudio Avport", audio_avport::hdmi_0, true };
cfg::_bool dump_to_file{ this, "Dump to file", false, true };
cfg::_bool convert_to_s16{ this, "Convert to 16 bit", false, true };
cfg::_enum<audio_format> format{ this, "Audio Format", audio_format::stereo, false };
cfg::uint<0, 0xFF> formats{ this, "Audio Formats", static_cast<u32>(audio_format_flag::lpcm_2_48khz), false };
cfg::_enum<audio_channel_layout> channel_layout{ this, "Audio Channel Layout", audio_channel_layout::automatic, false };
cfg::string audio_device{ this, "Audio Device", "@@@default@@@", true };
cfg::_int<0, 200> volume{ this, "Master Volume", 100, true };
cfg::_bool enable_buffering{ this, "Enable Buffering", true, true };
cfg::_int <4, 250> desired_buffer_duration{ this, "Desired Audio Buffer Duration", 100, true };
cfg::_bool enable_time_stretching{ this, "Enable Time Stretching", false, true };
cfg::_bool disable_sampling_skip{ this, "Disable Sampling Skip", false, true };
cfg::_int<0, 100> time_stretching_threshold{ this, "Time Stretching Threshold", 75, true };
cfg::_enum<microphone_handler> microphone_type{ this, "Microphone Type", microphone_handler::null };
cfg::string microphone_devices{ this, "Microphone Devices", "@@@@@@@@@@@@" };
cfg::_enum<music_handler> music{ this, "Music Handler", music_handler::qt };
} audio{ this };
struct node_io : cfg::node
{
node_io(cfg::node* _this) : cfg::node(_this, "Input/Output") {}
cfg::_enum<keyboard_handler> keyboard{ this, "Keyboard", keyboard_handler::null };
cfg::_enum<mouse_handler> mouse{ this, "Mouse", mouse_handler::basic };
cfg::_enum<camera_handler> camera{ this, "Camera", camera_handler::null };
cfg::_enum<fake_camera_type> camera_type{ this, "Camera type", fake_camera_type::unknown };
cfg::_enum<camera_flip> camera_flip_option{ this, "Camera flip", camera_flip::none, true };
cfg::string camera_id{ this, "Camera ID", "Default", true };
cfg::_enum<move_handler> move{ this, "Move", move_handler::null, true };
cfg::_enum<buzz_handler> buzz{ this, "Buzz emulated controller", buzz_handler::null };
cfg::_enum<turntable_handler> turntable{this, "Turntable emulated controller", turntable_handler::null};
cfg::_enum<ghltar_handler> ghltar{this, "GHLtar emulated controller", ghltar_handler::null};
cfg::_enum<pad_handler_mode> pad_mode{this, "Pad handler mode", pad_handler_mode::single_threaded, true};
cfg::_bool keep_pads_connected{this, "Keep pads connected", false, true};
cfg::uint<0, 100'000> pad_sleep{this, "Pad handler sleep (microseconds)", 1'000, true};
cfg::_bool background_input_enabled{this, "Background input enabled", true, true};
cfg::_bool show_move_cursor{this, "Show move cursor", false, true};
cfg::_bool lock_overlay_input_to_player_one{this, "Lock overlay input to player one", false, true};
cfg::string midi_devices{this, "Emulated Midi devices", "ßßß@@@ßßß@@@ßßß@@@"};
cfg::_bool load_sdl_mappings{ this, "Load SDL GameController Mappings", true };
cfg::_bool debug_overlay{ this, "IO Debug overlay", false, true };
} io{ this };
struct node_sys : cfg::node
{
static std::string get_random_system_name();
node_sys(cfg::node* _this) : cfg::node(_this, "System") {}
cfg::_enum<CellSysutilLicenseArea> license_area{ this, "License Area", CellSysutilLicenseArea{1} }; // CELL_SYSUTIL_LICENSE_AREA_A
cfg::_enum<CellSysutilLang> language{ this, "Language", CellSysutilLang{1} }; // CELL_SYSUTIL_LANG_ENGLISH_US
cfg::_enum<CellKbMappingType> keyboard_type{ this, "Keyboard Type", CellKbMappingType{0} }; // CELL_KB_MAPPING_101 = US
cfg::_enum<enter_button_assign> enter_button_assignment{ this, "Enter button assignment", enter_button_assign::cross };
cfg::_int<-60*60*24*365*100LL, 60*60*24*365*100LL> console_time_offset{ this, "Console time offset (s)", 0 }; // console time offset, limited to +/-100years
cfg::string system_name{this, "System Name", get_random_system_name()};
cfg::uint<0, umax> console_psid_high{this, "PSID high"};
cfg::uint<0, umax> console_psid_low{this, "PSID low"};
cfg::string hdd_model{this, "HDD Model Name", ""};
cfg::string hdd_serial{this, "HDD Serial Number", ""};
} sys{ this };
struct node_net : cfg::node
{
node_net(cfg::node* _this) : cfg::node(_this, "Net") {}
cfg::_enum<np_internet_status> net_active{this, "Internet enabled", np_internet_status::disabled};
cfg::string ip_address{this, "IP address", "0.0.0.0"};
cfg::string bind_address{this, "Bind address", "0.0.0.0"};
cfg::string dns{this, "DNS address", "8.8.8.8"};
cfg::string swap_list{this, "IP swap list", ""};
cfg::_bool upnp_enabled{this, "UPNP Enabled", false};
cfg::_enum<np_psn_status> psn_status{this, "PSN status", np_psn_status::disabled};
cfg::string country{this, "PSN Country", "us"};
} net{this};
struct node_savestate : cfg::node
{
node_savestate(cfg::node* _this) : cfg::node(_this, "Savestate") {}
cfg::_bool start_paused{ this, "Start Paused", false }; // Pause on first frame
cfg::_bool suspend_emu{ this, "Suspend Emulation Savestate Mode", false }; // Close emulation when saving, delete save after loading
cfg::_bool compatible_mode{ this, "Compatible Savestate Mode", false }; // SPU emulation optimized for savestate compatibility (off by default for performance reasons)
cfg::_bool state_inspection_mode{ this, "Inspection Mode Savestates" }; // Save memory stored in executable files, thus allowing to view state without any files (for debugging)
cfg::_bool save_disc_game_data{ this, "Save Disc Game Data", false };
} savestate{this};
struct node_misc : cfg::node
{
node_misc(cfg::node* _this) : cfg::node(_this, "Miscellaneous") {}
cfg::_bool autostart{ this, "Automatically start games after boot", true, true };
cfg::_bool autoexit{ this, "Exit RPCS3 when process finishes", false, true };
cfg::_bool autopause{ this, "Pause emulation on RPCS3 focus loss", false, true };
cfg::_bool start_fullscreen{ this, "Start games in fullscreen mode", false, true };
cfg::_bool prevent_display_sleep{ this, "Prevent display sleep while running games", true, true };
cfg::_bool show_trophy_popups{ this, "Show trophy popups", true, true };
cfg::_bool show_rpcn_popups{ this, "Show RPCN popups", true, true };
cfg::_bool show_shader_compilation_hint{ this, "Show shader compilation hint", true, true };
cfg::_bool show_ppu_compilation_hint{ this, "Show PPU compilation hint", true, true };
cfg::_bool show_pressure_intensity_toggle_hint{ this, "Show pressure intensity toggle hint", true, true };
cfg::_bool show_analog_limiter_toggle_hint{ this, "Show analog limiter toggle hint", true, true };
cfg::_bool show_mouse_and_keyboard_toggle_hint{ this, "Show mouse and keyboard toggle hint", true, true };
cfg::_bool show_autosave_autoload_hint{ this, "Show autosave/autoload hint", false, true };
cfg::_bool use_native_interface{ this, "Use native user interface", true };
cfg::string gdb_server{ this, "GDB Server", "127.0.0.1:2345" };
cfg::_bool silence_all_logs{ this, "Silence All Logs", false, true };
cfg::string title_format{ this, "Window Title Format", "FPS: %F | %R | %V | %T [%t]", true };
cfg::_bool pause_during_home_menu{this, "Pause Emulation During Home Menu", false, false };
} misc{ this };
cfg::log_entry log{ this, "Log" };
std::string name{};
};
extern cfg_root g_cfg;
extern cfg_root g_backup_cfg;
| 23,424
|
C++
|
.h
| 315
| 71.263492
| 204
| 0.701878
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,799
|
system_config_types.h
|
RPCS3_rpcs3/rpcs3/Emu/system_config_types.h
|
#pragma once
enum class ppu_decoder_type : unsigned
{
_static,
llvm,
};
enum class spu_decoder_type : unsigned
{
_static,
dynamic,
asmjit,
llvm,
};
enum class spu_block_size_type
{
safe,
mega,
giga,
};
enum class sleep_timers_accuracy_level
{
_as_host,
_usleep,
_all_timers,
};
enum class keyboard_handler
{
null,
basic,
};
enum class mouse_handler
{
null,
basic,
raw
};
enum class video_renderer
{
null,
opengl,
vulkan,
};
enum class audio_renderer
{
null,
#ifdef _WIN32
xaudio,
#endif
cubeb,
#ifdef HAVE_FAUDIO
faudio,
#endif
};
enum class audio_provider
{
none,
cell_audio,
rsxaudio
};
enum class audio_avport
{
hdmi_0,
hdmi_1,
avmulti,
spdif_0,
spdif_1
};
enum class audio_format
{
stereo,
surround_5_1,
surround_7_1,
automatic,
manual,
};
enum class audio_format_flag : unsigned
{
lpcm_2_48khz = 0x00000000, // Linear PCM 2 Ch. 48 kHz (always available)
lpcm_5_1_48khz = 0x00000001, // Linear PCM 5.1 Ch. 48 kHz
lpcm_7_1_48khz = 0x00000002, // Linear PCM 7.1 Ch. 48 kHz
ac3 = 0x00000004, // Dolby Digital 5.1 Ch.
dts = 0x00000008, // DTS 5.1 Ch.
};
enum class audio_channel_layout
{
automatic,
mono,
stereo,
stereo_lfe,
quadraphonic,
quadraphonic_lfe,
surround_5_1,
surround_7_1,
};
enum class music_handler
{
null,
qt
};
enum class camera_handler
{
null,
fake,
qt
};
enum class camera_flip
{
none,
horizontal,
vertical,
both
};
enum class fake_camera_type
{
unknown,
eyetoy,
eyetoy2,
uvc1_1,
};
enum class move_handler
{
null,
fake,
mouse,
raw_mouse,
#ifdef HAVE_LIBEVDEV
gun
#endif
};
enum class buzz_handler
{
null,
one_controller,
two_controllers,
};
enum class turntable_handler
{
null,
one_controller,
two_controllers,
};
enum class ghltar_handler
{
null,
one_controller,
two_controllers,
};
enum class microphone_handler
{
null,
standard,
singstar,
real_singstar,
rocksmith,
};
enum class pad_handler_mode
{
single_threaded, // All pad handlers run on the same thread sequentially.
multi_threaded // Each pad handler has its own thread.
};
enum class video_resolution
{
_1080p,
_1080i,
_720p,
_480p,
_480i,
_576p,
_576i,
_1600x1080p,
_1440x1080p,
_1280x1080p,
_960x1080p,
};
enum class video_aspect
{
_4_3,
_16_9,
};
enum class frame_limit_type
{
none,
_30,
_50,
_60,
_120,
display_rate,
_auto,
_ps3,
infinite,
};
enum class msaa_level
{
none,
_auto
};
enum class detail_level
{
none,
minimal,
low,
medium,
high,
};
enum class screen_quadrant
{
top_left,
top_right,
bottom_left,
bottom_right
};
enum class rsx_fifo_mode : unsigned
{
fast,
atomic,
atomic_ordered,
as_ps3,
};
enum class tsx_usage
{
disabled,
enabled,
forced,
};
enum class enter_button_assign
{
circle, // CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CIRCLE
cross // CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS
};
enum class np_internet_status
{
disabled,
enabled,
};
enum np_psn_status
{
disabled,
psn_fake,
psn_rpcn,
};
enum class shader_mode
{
recompiler,
async_recompiler,
async_with_interpreter,
interpreter_only
};
enum class vk_exclusive_fs_mode
{
unspecified,
disable,
enable
};
enum class vk_gpu_scheduler_mode
{
safe,
fast
};
enum class thread_scheduler_mode
{
os,
old,
alt
};
enum class perf_graph_detail_level
{
minimal,
show_min_max,
show_one_percent_avg,
show_all
};
enum class zcull_precision_level
{
precise,
approximate,
relaxed,
undefined
};
enum class gpu_preset_level
{
ultra,
high,
low,
_auto
};
enum class output_scaling_mode
{
nearest,
bilinear,
fsr
};
enum class stereo_render_mode_options
{
disabled,
side_by_side,
over_under,
interlaced,
anaglyph_red_green,
anaglyph_red_blue,
anaglyph_red_cyan,
anaglyph_magenta_cyan,
anaglyph_trioscopic,
anaglyph_amber_blue,
};
enum class xfloat_accuracy
{
accurate,
approximate,
relaxed, // Approximate accuracy for only the "FCGT", "FNMS", "FREST" AND "FRSQEST" instructions
inaccurate
};
| 3,957
|
C++
|
.h
| 311
| 11.028939
| 97
| 0.750416
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,800
|
title.h
|
RPCS3_rpcs3/rpcs3/Emu/title.h
|
#pragma once
#include <string>
namespace rpcs3
{
struct title_format_data
{
std::string format;
std::string title;
std::string title_id;
std::string renderer;
std::string vulkan_adapter;
double fps = .0;
};
std::string get_formatted_title(const title_format_data& title_data);
}
| 298
|
C++
|
.h
| 15
| 17.6
| 70
| 0.739286
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,801
|
System.h
|
RPCS3_rpcs3/rpcs3/Emu/System.h
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
#include "util/shared_ptr.hpp"
#include "Utilities/bit_set.h"
#include "config_mode.h"
#include "games_config.h"
#include <functional>
#include <memory>
#include <string>
#include <vector>
#include <set>
#include "Emu/Cell/timers.hpp"
void init_fxo_for_exec(utils::serial*, bool);
enum class localized_string_id;
enum class video_renderer;
class spu_thread;
template <typename T>
class named_thread;
namespace cfg
{
class _base;
}
enum class system_state : u32
{
stopped,
stopping,
running,
paused,
frozen, // paused but cannot resume
ready,
starting,
};
enum class game_boot_result : u32
{
no_errors,
generic_error,
nothing_to_boot,
wrong_disc_location,
invalid_file_or_folder,
invalid_bdvd_folder,
install_failed,
decryption_error,
file_creation_error,
firmware_missing,
unsupported_disc_type,
savestate_corrupted,
savestate_version_unsupported,
still_running,
already_added,
};
constexpr bool is_error(game_boot_result res)
{
return res != game_boot_result::no_errors;
}
struct EmuCallbacks
{
std::function<void(std::function<void()>, atomic_t<u32>*)> call_from_main_thread;
std::function<void(bool)> on_run; // (start_playtime) continuing or going ingame, so start the clock
std::function<void()> on_pause;
std::function<void()> on_resume;
std::function<void()> on_stop;
std::function<void()> on_ready;
std::function<bool()> on_missing_fw;
std::function<void(std::shared_ptr<atomic_t<bool>>, int)> on_emulation_stop_no_response;
std::function<void(std::shared_ptr<atomic_t<bool>>, stx::shared_ptr<utils::serial>, stx::atomic_ptr<std::string>*, std::shared_ptr<void>)> on_save_state_progress;
std::function<void(bool enabled)> enable_disc_eject;
std::function<void(bool enabled)> enable_disc_insert;
std::function<bool(bool, std::function<void()>)> try_to_quit; // (force_quit, on_exit) Try to close RPCS3
std::function<void(s32, s32)> handle_taskbar_progress; // (type, value) type: 0 for reset, 1 for increment, 2 for set_limit, 3 for set_value
std::function<void()> init_kb_handler;
std::function<void()> init_mouse_handler;
std::function<void(std::string_view title_id)> init_pad_handler;
std::function<void()> update_emu_settings;
std::function<void()> save_emu_settings;
std::function<std::unique_ptr<class GSFrameBase>()> get_gs_frame;
std::function<std::shared_ptr<class camera_handler_base>()> get_camera_handler;
std::function<std::shared_ptr<class music_handler_base>()> get_music_handler;
std::function<void(utils::serial*)> init_gs_render;
std::function<std::shared_ptr<class AudioBackend>()> get_audio;
std::function<std::shared_ptr<class audio_device_enumerator>(u64)> get_audio_enumerator; // (audio_renderer)
std::function<std::shared_ptr<class MsgDialogBase>()> get_msg_dialog;
std::function<std::shared_ptr<class OskDialogBase>()> get_osk_dialog;
std::function<std::unique_ptr<class SaveDialogBase>()> get_save_dialog;
std::function<std::shared_ptr<class SendMessageDialogBase>()> get_sendmessage_dialog;
std::function<std::shared_ptr<class RecvMessageDialogBase>()> get_recvmessage_dialog;
std::function<std::unique_ptr<class TrophyNotificationBase>()> get_trophy_notification_dialog;
std::function<std::string(localized_string_id, const char*)> get_localized_string;
std::function<std::u32string(localized_string_id, const char*)> get_localized_u32string;
std::function<std::string(const cfg::_base*, u32)> get_localized_setting;
std::function<void(const std::string&)> play_sound;
std::function<bool(const std::string&, std::string&, s32&, s32&, s32&)> get_image_info; // (filename, sub_type, width, height, CellSearchOrientation)
std::function<bool(const std::string&, s32, s32, s32&, s32&, u8*, bool)> get_scaled_image; // (filename, target_width, target_height, width, height, dst, force_fit)
std::string(*resolve_path)(std::string_view) = [](std::string_view arg){ return std::string{arg}; }; // Resolve path using Qt
std::function<std::vector<std::string>()> get_font_dirs;
std::function<bool(const std::vector<std::string>&)> on_install_pkgs;
std::function<void(u32)> add_breakpoint;
};
namespace utils
{
struct serial;
};
class Emulator final
{
atomic_t<system_state> m_state{system_state::stopped};
EmuCallbacks m_cb;
atomic_t<u64> m_pause_start_time{0}; // set when paused
atomic_t<u64> m_pause_amend_time{0}; // increased when resumed
atomic_t<u64> m_stop_ctr{1}; // Increments when emulation is stopped
atomic_t<bool> m_emu_state_close_pending = false;
games_config m_games_config;
video_renderer m_default_renderer;
std::string m_default_graphics_adapter;
cfg_mode m_config_mode = cfg_mode::custom;
std::string m_config_path;
std::string m_path;
std::string m_path_old;
std::string m_path_original;
std::string m_title_id;
std::string m_title;
std::string m_app_version;
std::string m_hash;
std::string m_cat;
std::string m_dir;
std::string m_sfo_dir;
std::string m_game_dir{"PS3_GAME"};
std::string m_usr{"00000001"};
u32 m_usrid{1};
std::shared_ptr<utils::serial> m_ar;
// This flag should be adjusted before each Kill() or each BootGame() and similar because:
// 1. It forces an application to boot immediately by calling Run() in Load().
// 2. It signifies that we don't want to exit on Kill(), for example if we want to transition to another application.
bool m_force_boot = false;
bool m_has_gui = true;
bool m_state_inspection_savestate = false;
usz m_tty_file_init_pos = umax;
std::vector<std::shared_ptr<atomic_t<u32>>> m_pause_msgs_refs;
std::vector<std::function<void()>> m_postponed_init_code;
void ExecPostponedInitCode()
{
for (auto&& func : ::as_rvalue(std::move(m_postponed_init_code)))
{
func();
}
}
enum class SaveStateExtentionFlags1 : u8
{
SupportsMenuOpenResume,
ShouldCloseMenu,
__bitset_enum_max,
};
bs_t<SaveStateExtentionFlags1> m_savestate_extension_flags1{};
public:
static constexpr std::string_view game_id_boot_prefix = "%RPCS3_GAMEID%:";
static constexpr std::string_view vfs_boot_prefix = "%RPCS3_VFS%:";
Emulator() = default;
void SetCallbacks(EmuCallbacks&& cb)
{
m_cb = std::move(cb);
}
const auto& GetCallbacks() const
{
return m_cb;
}
// Call from the GUI thread
void CallFromMainThread(std::function<void()>&& func, atomic_t<u32>* wake_up = nullptr, bool track_emu_state = true, u64 stop_ctr = umax,
std::source_location src_loc = std::source_location::current()) const;
// Blocking call from the GUI thread
void BlockingCallFromMainThread(std::function<void()>&& func, std::source_location src_loc = std::source_location::current()) const;
enum class stop_counter_t : u64{};
// Returns a different value each time we start a new emulation.
stop_counter_t GetEmulationIdentifier() const
{
return stop_counter_t{+m_stop_ctr};
}
void CallFromMainThread(std::function<void()>&& func, stop_counter_t counter,
std::source_location src_loc = std::source_location::current()) const
{
CallFromMainThread(std::move(func), nullptr, true, static_cast<u64>(counter), src_loc);
}
void PostponeInitCode(std::function<void()>&& func)
{
m_postponed_init_code.emplace_back(std::move(func));
}
/** Set emulator mode to running unconditionnaly.
* Required to execute various part (PPUInterpreter, memory manager...) outside of rpcs3.
*/
void SetTestMode()
{
m_state = system_state::running;
}
void Init();
std::vector<std::string> argv;
std::vector<std::string> envp;
std::vector<u8> data;
std::vector<u128> klic;
std::string disc;
std::string hdd1;
std::function<void(u32)> init_mem_containers;
std::function<void()> after_kill_callback;
u32 m_boot_source_type = 0; // CELL_GAME_GAMETYPE_SYS
const u32& GetBootSourceType() const
{
return m_boot_source_type;
}
const std::string& GetBoot() const
{
return m_path;
}
const std::string& GetLastBoot() const
{
return m_path_original;
}
const std::string& GetTitleID() const
{
return m_title_id;
}
const std::string& GetTitle() const
{
return m_title;
}
const std::string GetTitleAndTitleID() const
{
return m_title + (m_title_id.empty() ? "" : " [" + m_title_id + "]");
}
const std::string& GetAppVersion() const
{
return m_app_version;
}
const std::string& GetExecutableHash() const
{
return m_hash;
}
void SetExecutableHash(std::string hash) { m_hash = std::move(hash); }
const std::string& GetCat() const
{
return m_cat;
}
const std::string& GetFakeCat() const;
const std::string& GetDir() const
{
return m_dir;
}
const std::string GetSfoDir(bool prefer_disc_sfo) const;
// String for GUI dialogs.
const std::string& GetUsr() const
{
return m_usr;
}
const games_config& GetGamesConfig() const
{
return m_games_config;
}
// Get deserialization manager
utils::serial* DeserialManager() const;
// u32 for cell.
u32 GetUsrId() const
{
return m_usrid;
}
void SetUsr(const std::string& user);
std::string GetBackgroundPicturePath() const;
u64 GetPauseTime() const
{
return m_pause_amend_time;
}
const std::string& GetUsedConfig() const
{
return m_config_path;
}
bool IsChildProcess() const
{
return m_config_mode == cfg_mode::continuous;
}
game_boot_result BootGame(const std::string& path, const std::string& title_id = "", bool direct = false, cfg_mode config_mode = cfg_mode::custom, const std::string& config_path = "");
bool BootRsxCapture(const std::string& path);
void SetForceBoot(bool force_boot);
game_boot_result Load(const std::string& title_id = "", bool is_disc_patch = false, usz recursion_count = 0);
void Run(bool start_playtime);
void RunPPU();
void FixGuestTime();
void FinalizeRunRequest();
private:
struct savestate_stage
{
bool prepared = false;
std::vector<std::pair<std::shared_ptr<named_thread<spu_thread>>, u32>> paused_spus;
};
public:
bool Pause(bool freeze_emulation = false, bool show_resume_message = true);
void Resume();
void GracefulShutdown(bool allow_autoexit = true, bool async_op = false, bool savestate = false);
void Kill(bool allow_autoexit = true, bool savestate = false, savestate_stage* stage = nullptr);
game_boot_result Restart(bool graceful = true);
bool Quit(bool force_quit);
static void CleanUp();
bool IsRunning() const { return m_state == system_state::running; }
bool IsPaused() const { return m_state >= system_state::paused; } // ready/starting are also considered paused by this function
bool IsStopped() const { return m_state <= system_state::stopping; }
bool IsReady() const { return m_state == system_state::ready; }
bool IsStarting() const { return m_state == system_state::starting; }
auto GetStatus(bool fixup = true) const { system_state state = m_state; return fixup && state == system_state::frozen ? system_state::paused : fixup && state == system_state::stopping ? system_state::stopped : state; }
bool HasGui() const { return m_has_gui; }
void SetHasGui(bool has_gui) { m_has_gui = has_gui; }
void SetDefaultRenderer(video_renderer renderer) { m_default_renderer = renderer; }
void SetDefaultGraphicsAdapter(std::string adapter) { m_default_graphics_adapter = std::move(adapter); }
std::string GetFormattedTitle(double fps) const;
void ConfigurePPUCache() const;
std::set<std::string> GetGameDirs() const;
u32 AddGamesFromDir(const std::string& path);
game_boot_result AddGame(const std::string& path);
game_boot_result AddGameToYml(const std::string& path);
u32 RemoveGames(const std::vector<std::string>& title_id_list, bool save_on_disk = true);
game_boot_result RemoveGameFromYml(const std::string& title_id);
// Check if path is inside the specified directory
bool IsPathInsideDir(std::string_view path, std::string_view dir) const;
game_boot_result VerifyPathCasing(std::string_view path, std::string_view dir, bool from_dir) const;
void EjectDisc();
game_boot_result InsertDisc(const std::string& path);
static game_boot_result GetElfPathFromDir(std::string& elf_path, const std::string& path);
static void GetBdvdDir(std::string& bdvd_dir, std::string& sfb_dir, std::string& game_dir, const std::string& elf_dir);
friend void init_fxo_for_exec(utils::serial*, bool);
static bool IsVsh();
static bool IsValidSfb(const std::string& path);
static void SaveSettings(const std::string& settings, const std::string& title_id);
};
extern Emulator Emu;
extern bool g_log_all_errors;
extern bool g_use_rtm;
extern u64 g_rtm_tx_limit1;
extern u64 g_rtm_tx_limit2;
| 12,501
|
C++
|
.h
| 331
| 35.55287
| 219
| 0.737652
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,802
|
IPC_config.h
|
RPCS3_rpcs3/rpcs3/Emu/IPC_config.h
|
#pragma once
#include "Utilities/Config.h"
struct cfg_ipc : cfg::node
{
cfg::_bool ipc_server_enabled{ this, "IPC Server enabled", false };
cfg::_int<1025, 65535> ipc_port{ this, "IPC Port", 28012 };
void load();
void save() const;
bool get_server_enabled() const;
int get_port() const;
void set_server_enabled(const bool enabled);
void set_port(const int port);
private:
static std::string get_path();
};
extern cfg_ipc g_cfg_ipc;
| 448
|
C++
|
.h
| 16
| 26
| 68
| 0.72
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,803
|
IdManager.h
|
RPCS3_rpcs3/rpcs3/Emu/IdManager.h
|
#pragma once
#include "util/types.hpp"
#include "Utilities/mutex.h"
#include <memory>
#include <vector>
#include <map>
#include <typeinfo>
#include "util/serialization.hpp"
#include "util/fixed_typemap.hpp"
extern stx::manual_typemap<void, 0x20'00000, 128> g_fixed_typemap;
constexpr auto* g_fxo = &g_fixed_typemap;
enum class thread_state : u32;
extern u16 serial_breathe_and_tag(utils::serial& ar, std::string_view name, bool tag_bit);
// Helper namespace
namespace id_manager
{
// Common global mutex
extern shared_mutex g_mutex;
template <typename T>
constexpr std::pair<u32, u32> get_invl_range()
{
return {0, 0};
}
template <typename T> requires requires () { T::id_invl_range; }
constexpr std::pair<u32, u32> get_invl_range()
{
return T::id_invl_range;
}
template <typename T>
consteval bool get_force_lowest_id()
{
return false;
}
template <typename T> requires requires () { bool{T::id_lowest}; }
consteval bool get_force_lowest_id()
{
return T::id_lowest;
}
template <typename T>
concept IdmCompatible = requires () { +T::id_base, +T::id_step, +T::id_count; };
template <typename T>
concept IdmBaseCompatible = (std::is_final_v<T> ? IdmCompatible<T> : !!(requires () { +T::id_step, +T::id_count; }));
template <typename T>
concept IdmSavable = IdmBaseCompatible<T> && T::savestate_init_pos != 0 && (requires () { std::declval<T>().save(std::declval<stx::exact_t<utils::serial&>>()); });
// Last allocated ID for constructors
extern thread_local u32 g_id;
// ID traits
template <typename T>
struct id_traits
{
static_assert(IdmCompatible<T>, "ID object must specify: id_base, id_step, id_count");
static constexpr u32 base = T::id_base; // First ID (N = 0)
static constexpr u32 step = T::id_step; // Any ID: N * id_setp + id_base
static constexpr u32 count = T::id_count; // Limit: N < id_count
static constexpr u32 invalid = -+!base; // Invalid ID sample
static constexpr std::pair<u32, u32> invl_range = get_invl_range<T>();
static constexpr bool uses_lowest_id = get_force_lowest_id<T>();
static_assert(u32{count} && u32{step} && u64{step} * (count - 1) + base < u32{umax} + u64{base != 0 ? 1 : 0}, "ID traits: invalid object range");
// TODO: Add more conditions
static_assert(!invl_range.second || (u64{invl_range.second} + invl_range.first <= 32 /*....*/ ));
};
static constexpr u32 get_index(u32 id, u32 base, u32 step, u32 count, std::pair<u32, u32> invl_range)
{
u32 mask_out = ((1u << invl_range.second) - 1) << invl_range.first;
// Note: if id is lower than base, diff / step will be higher than count
u32 diff = (id & ~mask_out) - base;
if (diff % step)
{
// id is invalid, return invalid index
return count;
}
// Get actual index
return diff / step;
}
// ID traits
template <typename T, typename = void>
struct id_traits_load_func
{
static constexpr std::shared_ptr<void>(*load)(utils::serial&) = [](utils::serial& ar) -> std::shared_ptr<void>
{
if constexpr (std::is_constructible_v<T, stx::exact_t<const stx::launch_retainer&>, stx::exact_t<utils::serial&>>)
{
return std::make_shared<T>(stx::launch_retainer{}, stx::exact_t<utils::serial&>(ar));
}
else
{
return std::make_shared<T>(stx::exact_t<utils::serial&>(ar));
}
};
};
template <typename T>
struct id_traits_load_func<T, std::void_t<decltype(&T::load)>>
{
static constexpr std::shared_ptr<void>(*load)(utils::serial&) = [](utils::serial& ar) -> std::shared_ptr<void>
{
return T::load(stx::exact_t<utils::serial&>(ar));
};
};
template <typename T, typename = void>
struct id_traits_savable_func
{
static constexpr bool(*savable)(void*) = [](void*) -> bool { return true; };
};
template <typename T>
struct id_traits_savable_func<T, std::void_t<decltype(&T::savable)>>
{
static constexpr bool(*savable)(void* ptr) = [](void* ptr) -> bool { return static_cast<const T*>(ptr)->savable(); };
};
struct dummy_construct
{
dummy_construct() {}
dummy_construct(utils::serial&){}
void save(utils::serial&) {}
static constexpr u32 id_base = 1, id_step = 1, id_count = 1;
static constexpr double savestate_init_pos = 0;
};
struct typeinfo;
// Use a vector instead of map to reduce header dependencies in this commonly used header
std::vector<std::pair<u128, typeinfo>>& get_typeinfo_map();
struct typeinfo
{
public:
std::shared_ptr<void>(*load)(utils::serial&);
void(*save)(utils::serial&, void*);
bool(*savable)(void* ptr);
u32 base;
u32 step;
u32 count;
bool uses_lowest_id;
std::pair<u32, u32> invl_range;
// Get type index
template <typename T>
static inline u32 get_index()
{
return stx::typeindex<id_manager::typeinfo, T>();
}
// Unique type ID within the same container: we use id_base if nothing else was specified
template <typename T>
static consteval u32 get_type()
{
return T::id_base;
}
// Specified type ID for containers which their types may be sharing an overlapping IDs range
template <typename T> requires requires () { u32{T::id_type}; }
static consteval u32 get_type()
{
return T::id_type;
}
template <typename T>
static typeinfo make_typeinfo()
{
typeinfo info{};
using C = std::conditional_t<IdmCompatible<T> && IdmSavable<T>, T, dummy_construct>;
using Type = std::conditional_t<IdmCompatible<T>, T, dummy_construct>;
if constexpr (std::is_same_v<C, T>)
{
info =
{
+id_traits_load_func<C>::load,
+[](utils::serial& ar, void* obj) { static_cast<C*>(obj)->save(ar); },
+id_traits_savable_func<C>::savable,
id_traits<C>::base, id_traits<C>::step, id_traits<C>::count, id_traits<C>::uses_lowest_id, id_traits<C>::invl_range,
};
const u128 key = u128{get_type<C>()} << 64 | std::bit_cast<u64>(C::savestate_init_pos);
for (const auto& tinfo : get_typeinfo_map())
{
if (!(tinfo.first ^ key))
{
ensure(!std::memcmp(&info, &tinfo.second, sizeof(info)));
return info;
}
}
// id_base must be unique within all the objects with the same initialization posistion by definition of id_map with multiple types
get_typeinfo_map().emplace_back(key, info);
}
else
{
info =
{
nullptr,
nullptr,
nullptr,
id_traits<Type>::base, id_traits<Type>::step, id_traits<Type>::count, id_traits<Type>::uses_lowest_id, id_traits<Type>::invl_range,
};
}
return info;
}
};
// ID value with additional type stored
class id_key
{
u32 m_value; // ID value
u32 m_base; // ID base (must be unique for each type in the same container)
public:
id_key() = default;
id_key(u32 value, u32 type)
: m_value(value)
, m_base(type)
{
}
u32 value() const
{
return m_value;
}
u32 type() const
{
return m_base;
}
operator u32() const
{
return m_value;
}
};
template <typename T>
struct id_map
{
static_assert(IdmBaseCompatible<T>, "Please specify IDM compatible type.");
std::vector<std::pair<id_key, std::shared_ptr<void>>> vec{}, private_copy{};
shared_mutex mutex{}; // TODO: Use this instead of global mutex
id_map() noexcept
{
// Preallocate memory
vec.reserve(T::id_count);
}
// Order it directly before the source type's position
static constexpr double savestate_init_pos_original = T::savestate_init_pos;
static constexpr double savestate_init_pos = std::bit_cast<double>(std::bit_cast<u64>(savestate_init_pos_original) - 1);
id_map(utils::serial& ar) noexcept requires IdmSavable<T>
{
vec.resize(T::id_count);
usz highest = 0;
while (true)
{
const u16 tag = serial_breathe_and_tag(ar, g_fxo->get_name<id_map<T>>(), false);
if (tag >> 15)
{
// End
break;
}
// ID, type hash
const u32 id = ar.pop<u32>();
const u128 type_init_pos = u128{ar.pop<u32>()} << 64 | std::bit_cast<u64>(T::savestate_init_pos);
const typeinfo* info = nullptr;
// Search load functions for the one of this type (see make_typeinfo() for explenation about key composition reasoning)
for (const auto& typeinfo : get_typeinfo_map())
{
if (!(typeinfo.first ^ type_init_pos))
{
info = std::addressof(typeinfo.second);
}
}
ensure(info);
// Construct each object from information collected
// Simulate construction semantics (idm::last_id() value)
g_id = id;
const usz object_index = get_index(id, info->base, info->step, info->count, info->invl_range);
auto& obj = ::at32(vec, object_index);
ensure(!obj.second);
highest = std::max<usz>(highest, object_index + 1);
obj.first = id_key(id, static_cast<u32>(static_cast<u64>(type_init_pos >> 64)));
obj.second = info->load(ar);
}
vec.resize(highest);
}
void save(utils::serial& ar) requires IdmSavable<T>
{
for (const auto& p : vec)
{
if (!p.second) continue;
const u128 type_init_pos = u128{p.first.type()} << 64 | std::bit_cast<u64>(T::savestate_init_pos);
const typeinfo* info = nullptr;
// Search load functions for the one of this type (see make_typeinfo() for explenation about key composition reasoning)
for (const auto& typeinfo : get_typeinfo_map())
{
if (!(typeinfo.first ^ type_init_pos))
{
ensure(!std::exchange(info, std::addressof(typeinfo.second)));
}
}
// Save each object with needed information
if (info && info->savable(p.second.get()))
{
// Create a tag for each object
serial_breathe_and_tag(ar, g_fxo->get_name<id_map<T>>(), false);
ar(p.first.value(), p.first.type());
info->save(ar, p.second.get());
}
}
// End sequence with tag bit set
serial_breathe_and_tag(ar, g_fxo->get_name<id_map<T>>(), true);
}
id_map& operator=(thread_state state) noexcept requires (std::is_assignable_v<T&, thread_state>)
{
private_copy.clear();
if (!vec.empty() || !private_copy.empty())
{
reader_lock lock(g_mutex);
// Save all entries
private_copy = vec;
}
// Signal or join threads
for (const auto& [key, ptr] : private_copy)
{
if (ptr)
{
*static_cast<T*>(ptr.get()) = state;
}
}
return *this;
}
};
}
// Object manager for emulated process. Multiple objects of specified arbitrary type are given unique IDs.
class idm
{
template <typename T>
static constexpr u32 get_index(u32 id)
{
using traits = id_manager::id_traits<T>;
return id_manager::get_index(id, traits::base, traits::step, traits::count, traits::invl_range);
}
// Helper
template <typename F>
struct function_traits;
template <typename F, typename R, typename A1, typename A2>
struct function_traits<R (F::*)(A1, A2&) const>
{
using object_type = A2;
using result_type = R;
};
template <typename F, typename R, typename A1, typename A2>
struct function_traits<R (F::*)(A1, A2&)>
{
using object_type = A2;
using result_type = R;
};
// Helper type: pointer + return value propagated
template <typename T, typename RT>
struct return_pair
{
std::shared_ptr<T> ptr;
RT ret;
explicit operator bool() const
{
return ptr.operator bool();
}
T& operator*() const
{
return *ptr;
}
T* operator->() const
{
return ptr.get();
}
};
// Unsafe specialization (not refcounted)
template <typename T, typename RT>
struct return_pair<T*, RT>
{
T* ptr;
RT ret;
explicit operator bool() const
{
return ptr != nullptr;
}
T& operator*() const
{
return *ptr;
}
T* operator->() const
{
return ptr;
}
};
using map_data = std::pair<id_manager::id_key, std::shared_ptr<void>>;
// Prepare new ID (returns nullptr if out of resources)
static map_data* allocate_id(std::vector<map_data>& vec, u32 type_id, u32 dst_id, u32 base, u32 step, u32 count, bool uses_lowest_id, std::pair<u32, u32> invl_range);
// Get object by internal index if exists (additionally check type if types are not equal)
template <typename T, typename Type>
static map_data* find_index(u32 index, u32 id)
{
static_assert(PtrSame<T, Type>, "Invalid ID type combination");
auto& vec = g_fxo->get<id_manager::id_map<T>>().vec;
if (index >= vec.size())
{
return nullptr;
}
auto& data = vec[index];
if (data.second)
{
if (std::is_same_v<T, Type> || data.first.type() == get_type<Type>())
{
if (!id_manager::id_traits<Type>::invl_range.second || data.first.value() == id)
{
return &data;
}
}
}
return nullptr;
}
// Find ID
template <typename T, typename Type>
static map_data* find_id(u32 id)
{
static_assert(PtrSame<T, Type>, "Invalid ID type combination");
const u32 index = get_index<Type>(id);
return find_index<T, Type>(index, id);
}
// Allocate new ID (or use fixed ID) and assign the object from the provider()
template <typename T, typename Type, typename F>
static map_data* create_id(F&& provider, u32 id = id_manager::id_traits<Type>::invalid)
{
static_assert(PtrSame<T, Type>, "Invalid ID type combination");
// ID traits
using traits = id_manager::id_traits<Type>;
// Ensure make_typeinfo() is used for this type
[[maybe_unused]] auto& td = stx::typedata<id_manager::typeinfo, Type>();
// Allocate new id
std::lock_guard lock(id_manager::g_mutex);
auto& map = g_fxo->get<id_manager::id_map<T>>();
if (auto* place = allocate_id(map.vec, get_type<Type>(), id, traits::base, traits::step, traits::count, traits::uses_lowest_id, traits::invl_range))
{
// Get object, store it
place->second = provider();
if (place->second)
{
return place;
}
}
return nullptr;
}
public:
// Remove all objects of a type
template <typename T>
static inline void clear()
{
std::lock_guard lock(id_manager::g_mutex);
g_fxo->get<id_manager::id_map<T>>().vec.clear();
}
// Get last ID (updated in create_id/allocate_id)
static inline u32 last_id()
{
return id_manager::g_id;
}
// Get type ID that is meant to be unique within the same container
template <typename T>
static consteval u32 get_type()
{
return id_manager::typeinfo::get_type<T>();
}
// Add a new ID of specified type with specified constructor arguments (returns object or nullptr)
template <typename T, typename Make = T, typename... Args> requires (std::is_constructible_v<Make, Args&&...>)
static inline std::shared_ptr<Make> make_ptr(Args&&... args)
{
if (auto pair = create_id<T, Make>([&] { return std::make_shared<Make>(std::forward<Args>(args)...); }))
{
return {pair->second, static_cast<Make*>(pair->second.get())};
}
return nullptr;
}
// Add a new ID of specified type with specified constructor arguments (returns id)
template <typename T, typename Make = T, typename... Args> requires (std::is_constructible_v<Make, Args&&...>)
static inline u32 make(Args&&... args)
{
if (auto pair = create_id<T, Make>([&] { return std::make_shared<Make>(std::forward<Args>(args)...); }))
{
return pair->first;
}
return id_manager::id_traits<Make>::invalid;
}
// Add a new ID for an object returned by provider()
template <typename T, typename Made = T, typename F> requires (std::is_invocable_v<F&&>)
static inline u32 import(F&& provider, u32 id = id_manager::id_traits<Made>::invalid)
{
if (auto pair = create_id<T, Made>(std::forward<F>(provider), id))
{
return pair->first;
}
return id_manager::id_traits<Made>::invalid;
}
// Add a new ID for an existing object provided (returns new id)
template <typename T, typename Made = T>
static inline u32 import_existing(std::shared_ptr<T> ptr, u32 id = id_manager::id_traits<Made>::invalid)
{
return import<T, Made>([&] { return std::move(ptr); }, id);
}
// Access the ID record without locking (unsafe)
template <typename T, typename Get = T>
static inline map_data* find_unlocked(u32 id)
{
return find_id<T, Get>(id);
}
// Check the ID without locking (can be called from other method)
template <typename T, typename Get = T>
static inline Get* check_unlocked(u32 id)
{
if (const auto found = find_id<T, Get>(id))
{
return static_cast<Get*>(found->second.get());
}
return nullptr;
}
// Check the ID
template <typename T, typename Get = T>
static inline Get* check(u32 id)
{
reader_lock lock(id_manager::g_mutex);
return check_unlocked<T, Get>(id);
}
// Check the ID, access object under shared lock
template <typename T, typename Get = T, typename F, typename FRT = std::invoke_result_t<F, Get&>>
static inline std::conditional_t<std::is_void_v<FRT>, Get*, return_pair<Get*, FRT>> check(u32 id, F&& func)
{
const u32 index = get_index<Get>(id);
if (index >= id_manager::id_traits<Get>::count)
{
return {};
}
reader_lock lock(id_manager::g_mutex);
if (const auto found = find_index<T, Get>(index, id))
{
const auto ptr = static_cast<Get*>(found->second.get());
if constexpr (!std::is_void_v<FRT>)
{
return return_pair<Get*, FRT>{ptr, func(*ptr)};
}
else
{
func(*ptr);
return ptr;
}
}
return {};
}
// Get the object without locking (can be called from other method)
template <typename T, typename Get = T>
static inline std::shared_ptr<Get> get_unlocked(u32 id)
{
const auto found = find_id<T, Get>(id);
if (found == nullptr) [[unlikely]]
{
return nullptr;
}
return std::static_pointer_cast<Get>(found->second);
}
// Get the object
template <typename T, typename Get = T>
static inline std::shared_ptr<Get> get(u32 id)
{
reader_lock lock(id_manager::g_mutex);
return get_unlocked<T, Get>(id);
}
// Get the object, access object under reader lock
template <typename T, typename Get = T, typename F, typename FRT = std::invoke_result_t<F, Get&>>
static inline std::conditional_t<std::is_void_v<FRT>, std::shared_ptr<Get>, return_pair<Get, FRT>> get(u32 id, F&& func)
{
const u32 index = get_index<Get>(id);
if (index >= id_manager::id_traits<Get>::count)
{
return {nullptr};
}
reader_lock lock(id_manager::g_mutex);
const auto found = find_index<T, Get>(index, id);
if (found == nullptr) [[unlikely]]
{
return {nullptr};
}
const auto ptr = static_cast<Get*>(found->second.get());
if constexpr (std::is_void_v<FRT>)
{
func(*ptr);
return {found->second, ptr};
}
else
{
return {{found->second, ptr}, func(*ptr)};
}
}
static constexpr std::false_type unlocked{};
// Access all objects of specified type. Returns the number of objects processed.
// If function result evaluates to true, stop and return the object and the value.
template <typename T, typename... Get, typename F, typename Lock = std::true_type>
static inline auto select(F&& func, Lock = {})
{
static_assert((PtrSame<T, Get> && ...), "Invalid ID type combination");
[[maybe_unused]] std::conditional_t<!!Lock(), reader_lock, const shared_mutex&> lock(id_manager::g_mutex);
using func_traits = function_traits<decltype(&decltype(std::function(std::declval<F>()))::operator())>;
using object_type = typename func_traits::object_type;
using result_type = typename func_traits::result_type;
static_assert(PtrSame<object_type, T>, "Invalid function argument type combination");
std::conditional_t<std::is_void_v<result_type>, u32, return_pair<object_type, result_type>> result{};
for (auto& id : g_fxo->get<id_manager::id_map<T>>().vec)
{
if (auto ptr = static_cast<object_type*>(id.second.get()))
{
if (sizeof...(Get) == 0 || ((id.first.type() == get_type<Get>()) || ...))
{
if constexpr (std::is_void_v<result_type>)
{
func(id.first, *ptr);
result++;
}
else if ((result.ret = func(id.first, *ptr)))
{
result.ptr = {id.second, ptr};
break;
}
}
}
}
return result;
}
// Remove the ID
template <typename T, typename Get = T>
static inline bool remove(u32 id)
{
std::shared_ptr<void> ptr;
{
std::lock_guard lock(id_manager::g_mutex);
if (const auto found = find_id<T, Get>(id))
{
ptr = std::move(found->second);
}
else
{
return false;
}
}
return true;
}
// Remove the ID if matches the weak/shared ptr
template <typename T, typename Get = T, typename Ptr>
static inline bool remove_verify(u32 id, Ptr sptr)
{
std::shared_ptr<void> ptr;
{
std::lock_guard lock(id_manager::g_mutex);
if (const auto found = find_id<T, Get>(id); found &&
(!found->second.owner_before(sptr) && !sptr.owner_before(found->second)))
{
ptr = std::move(found->second);
}
else
{
return false;
}
}
return true;
}
// Remove the ID and return the object
template <typename T, typename Get = T>
static inline std::shared_ptr<Get> withdraw(u32 id)
{
std::shared_ptr<Get> ptr;
{
std::lock_guard lock(id_manager::g_mutex);
if (const auto found = find_id<T, Get>(id))
{
ptr = std::static_pointer_cast<Get>(::as_rvalue(std::move(found->second)));
}
}
return ptr;
}
// Remove the ID after accessing the object under writer lock, return the object and propagate return value
template <typename T, typename Get = T, typename F, typename FRT = std::invoke_result_t<F, Get&>>
static inline std::conditional_t<std::is_void_v<FRT>, std::shared_ptr<Get>, return_pair<Get, FRT>> withdraw(u32 id, F&& func)
{
const u32 index = get_index<Get>(id);
if (index >= id_manager::id_traits<Get>::count)
{
return {nullptr};
}
std::unique_lock lock(id_manager::g_mutex);
if (const auto found = find_index<T, Get>(index, id))
{
const auto _ptr = static_cast<Get*>(found->second.get());
if constexpr (std::is_void_v<FRT>)
{
func(*_ptr);
return std::static_pointer_cast<Get>(::as_rvalue(std::move(found->second)));
}
else
{
FRT ret = func(*_ptr);
if (ret)
{
// If return value evaluates to true, don't delete the object (error code)
return {{found->second, _ptr}, std::move(ret)};
}
return {std::static_pointer_cast<Get>(::as_rvalue(std::move(found->second))), std::move(ret)};
}
}
return {nullptr};
}
};
| 22,059
|
C++
|
.h
| 695
| 28.290647
| 167
| 0.664653
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,804
|
system_progress.hpp
|
RPCS3_rpcs3/rpcs3/Emu/system_progress.hpp
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
struct alignas(16) progress_dialog_string_t
{
const char* m_text;
u32 m_user_count;
u32 m_update_id;
operator const char*() const noexcept
{
return m_text;
}
};
extern atomic_t<progress_dialog_string_t> g_progr_text;
extern atomic_t<u32> g_progr_ftotal;
extern atomic_t<u32> g_progr_fdone;
extern atomic_t<u64> g_progr_ftotal_bits;
extern atomic_t<u64> g_progr_fknown_bits;
extern atomic_t<u32> g_progr_ptotal;
extern atomic_t<u32> g_progr_pdone;
extern atomic_t<bool> g_system_progress_canceled;
extern atomic_t<bool> g_system_progress_stopping;
// Initialize progress dialog (can be recursive)
class scoped_progress_dialog final
{
private:
std::string m_text; // Saved current value
std::string m_prev; // Saved previous value
u32 m_prev_id;
u32 m_id;
public:
scoped_progress_dialog(const std::string& text) noexcept
{
ensure(!text.empty());
m_text = text;
std::tie(m_prev, m_prev_id, m_id) = g_progr_text.atomic_op([this](progress_dialog_string_t& progr)
{
std::string old = progr.m_text ? progr.m_text : std::string();
progr.m_user_count++;
progr.m_update_id++;
progr.m_text = m_text.c_str();
ensure(progr.m_user_count > 1 || old.empty()); // Ensure it was empty before first use
return std::make_tuple(std::move(old), progr.m_update_id - 1, progr.m_update_id);
});
}
scoped_progress_dialog(const scoped_progress_dialog&) = delete;
scoped_progress_dialog& operator=(const scoped_progress_dialog&) = delete;
scoped_progress_dialog& operator=(const std::string& text) noexcept
{
ensure(!text.empty());
m_text = text;
// This method is destroying the previous value and replacing it with a new one
std::tie(m_prev, m_prev_id, m_id) = g_progr_text.atomic_op([this](progress_dialog_string_t& progr)
{
if (m_id == progr.m_update_id)
{
progr.m_update_id = m_prev_id;
progr.m_text = m_prev.c_str();
}
std::string old = progr.m_text ? progr.m_text : std::string();
progr.m_text = m_text.c_str();
progr.m_update_id++;
ensure(progr.m_user_count > 0);
return std::make_tuple(std::move(old), progr.m_update_id - 1, progr.m_update_id);
});
return *this;
}
~scoped_progress_dialog() noexcept
{
g_progr_text.atomic_op([this](progress_dialog_string_t& progr)
{
if (progr.m_user_count-- == 1)
{
// Clean text only on last user
progr.m_text = nullptr;
progr.m_update_id = 0;
}
else if (m_id == progr.m_update_id)
{
// Restore text only if no other updates were made by other threads
progr.m_text = m_prev.c_str();
progr.m_update_id = m_prev_id;
}
});
}
};
struct progress_dialog_server
{
void operator()();
~progress_dialog_server();
static constexpr auto thread_name = "Progress Dialog Server"sv;
};
struct progress_dialog_workaround
{
// We don't want to show the native dialog during gameplay.
atomic_t<bool> show_overlay_message_only = false;
};
| 2,970
|
C++
|
.h
| 97
| 27.876289
| 100
| 0.69972
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,805
|
cache_utils.hpp
|
RPCS3_rpcs3/rpcs3/Emu/cache_utils.hpp
|
#pragma once
namespace rpcs3::cache
{
std::string get_ppu_cache();
void limit_cache_size();
}
| 97
|
C++
|
.h
| 6
| 14.666667
| 29
| 0.744444
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| true
| true
| true
| false
|
5,806
|
config_mode.h
|
RPCS3_rpcs3/rpcs3/Emu/config_mode.h
|
#pragma once
enum class cfg_mode
{
custom, // Prefer regular custom config. Fall back to global config.
custom_selection, // Use user-selected custom config. Fall back to global config.
global, // Use global config.
config_override, // Use config override. This does not use the global VFS settings! Fall back to global config.
continuous, // Use same config as on last boot. Fall back to global config.
default_config // Use the default values of the config entries.
};
| 508
|
C++
|
.h
| 10
| 49.1
| 113
| 0.720322
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,807
|
GDB.h
|
RPCS3_rpcs3/rpcs3/Emu/GDB.h
|
#pragma once
#include "Utilities/Thread.h"
#include <memory>
#include <string>
struct gdb_cmd;
class cpu_thread;
class ppu_thread;
class gdb_thread
{
static const u64 ALL_THREADS = 0xffffffffffffffff;
static const u64 ANY_THREAD = 0;
int server_socket = -1;
int client_socket = -1;
std::weak_ptr<cpu_thread> selected_thread{};
u64 continue_ops_thread_id = ANY_THREAD;
u64 general_ops_thread_id = ANY_THREAD;
//initialize server socket and start listening
void start_server();
//read at most cnt bytes to buf, returns number of bytes actually read
int read(void* buf, int cnt) const;
//reads one character
char read_char();
//reads pairs of hex characters and returns their integer value
u8 read_hexbyte();
// Tries to read command, returns false on error
bool try_read_cmd(gdb_cmd& out_cmd);
//reads commands until receiveing one with valid checksum
//in case of other exception (i.e. wrong first char of command)
//it will log exception text and return false
//in that case best for caller would be to stop reading, because
//chance of getting correct command is low
bool read_cmd(gdb_cmd& out_cmd);
//send cnt bytes from buf to client
void send(const char* buf, int cnt) const;
//send character to client
void send_char(char c);
//acknowledge packet, either as accepted or declined
void ack(bool accepted);
//sends command body cmd to client
void send_cmd(const std::string& cmd);
//sends command to client until receives positive acknowledgement
//returns false in case some error happened, and command wasn't sent
bool send_cmd_ack(const std::string& cmd);
//appends encoded char c to string str, and returns checksum. encoded byte can occupy 2 bytes
static u8 append_encoded_char(char c, std::string& str);
//convert u8 to 2 byte hexademical representation
static std::string to_hexbyte(u8 i);
//choose thread, support ALL_THREADS and ANY_THREAD values, returns true if some thread was selected
bool select_thread(u64 id);
//returns register value as hex string by register id (in gdb), in case of wrong id returns empty string
static std::string get_reg(ppu_thread* thread, u32 rid);
//sets register value to hex string by register id (in gdb), in case of wrong id returns false
static bool set_reg(ppu_thread* thread, u32 rid, const std::string& value);
//returns size of register with id rid in bytes, zero if invalid rid is provided
static u32 get_reg_size(ppu_thread* thread, u32 rid);
//send reason of stop, returns false if sending response failed
bool send_reason();
void wait_with_interrupts();
//commands
bool cmd_extended_mode(gdb_cmd& cmd);
bool cmd_reason(gdb_cmd& cmd);
bool cmd_supported(gdb_cmd& cmd);
bool cmd_thread_info(gdb_cmd& cmd);
bool cmd_current_thread(gdb_cmd& cmd);
bool cmd_read_register(gdb_cmd& cmd);
bool cmd_write_register(gdb_cmd& cmd);
bool cmd_read_memory(gdb_cmd& cmd);
bool cmd_write_memory(gdb_cmd& cmd);
bool cmd_read_all_registers(gdb_cmd& cmd);
bool cmd_write_all_registers(gdb_cmd& cmd);
bool cmd_set_thread_ops(gdb_cmd& cmd);
bool cmd_attached_to_what(gdb_cmd& cmd);
static bool cmd_kill(gdb_cmd& cmd);
bool cmd_continue_support(gdb_cmd& cmd);
bool cmd_vcont(gdb_cmd& cmd);
bool cmd_set_breakpoint(gdb_cmd& cmd);
bool cmd_remove_breakpoint(gdb_cmd& cmd);
public:
bool from_breakpoint = true;
bool paused = false;
u64 pausedBy = 0;
gdb_thread() noexcept;
~gdb_thread();
gdb_thread(const gdb_thread&) = delete;
gdb_thread& operator=(const gdb_thread&) = delete;
void operator()();
void pause_from(cpu_thread* t);
static constexpr auto thread_name = "GDB Server"sv;
};
using gdb_server = named_thread<gdb_thread>;
| 3,652
|
C++
|
.h
| 90
| 38.544444
| 105
| 0.75585
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,808
|
vfs_config.h
|
RPCS3_rpcs3/rpcs3/Emu/vfs_config.h
|
#pragma once
#include "Utilities/Config.h"
struct cfg_vfs : cfg::node
{
std::string get(const cfg::string& _cfg, std::string_view emu_dir = {}) const;
void load();
void save() const;
static std::string get_path();
cfg::string emulator_dir{ this, "$(EmulatorDir)" }; // Default (empty): taken from fs::get_config_dir()
cfg::string dev_hdd0{ this, "/dev_hdd0/", "$(EmulatorDir)dev_hdd0/" };
cfg::string dev_hdd1{ this, "/dev_hdd1/", "$(EmulatorDir)dev_hdd1/" };
cfg::string dev_flash{ this, "/dev_flash/", "$(EmulatorDir)dev_flash/" };
cfg::string dev_flash2{ this, "/dev_flash2/", "$(EmulatorDir)dev_flash2/" };
cfg::string dev_flash3{ this, "/dev_flash3/", "$(EmulatorDir)dev_flash3/" };
cfg::string dev_bdvd{ this, "/dev_bdvd/", "$(EmulatorDir)dev_bdvd/" }; // Only mounted in some special cases
cfg::string games_dir{ this, "/games/", "$(EmulatorDir)games/" }; // Not mounted
cfg::string app_home{ this, "/app_home/" }; // Not mounted
cfg::device_entry dev_usb{ this, "/dev_usb***/",
{
{ "/dev_usb000", cfg::device_info{.path = "$(EmulatorDir)dev_usb000/"} }
}};
std::string get_dev_flash() const
{
return get(dev_flash);
}
std::string get_dev_flash2() const
{
return get(dev_flash2);
}
std::string get_dev_flash3() const
{
return get(dev_flash3);
}
cfg::device_info get_device(const cfg::device_entry& _cfg, std::string_view key, std::string_view emu_dir = {}) const;
private:
std::string get(const std::string& _cfg, const std::string& def, std::string_view emu_dir) const;
cfg::device_info get_device_info(const cfg::device_entry& _cfg, std::string_view key, std::string_view emu_dir = {}) const;
};
extern cfg_vfs g_cfg_vfs;
| 1,680
|
C++
|
.h
| 39
| 40.820513
| 124
| 0.671367
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,809
|
IPC_socket.h
|
RPCS3_rpcs3/rpcs3/Emu/IPC_socket.h
|
#pragma once
#include "Utilities/Thread.h"
#include "util/logs.hpp"
#include "Emu/Memory/vm.h"
#include "../pine/pine_server.h"
LOG_CHANNEL(IPC);
namespace IPC_socket
{
class IPC_impl
{
protected:
template <u32 Size = 1>
static bool check_addr(u32 addr, u8 flags = vm::page_readable)
{
return vm::check_addr<Size>(addr, flags);
}
static const u8& read8(u32 addr);
static void write8(u32 addr, u8 value);
static const be_t<u16>& read16(u32 addr);
static void write16(u32 addr, be_t<u16> value);
static const be_t<u32>& read32(u32 addr);
static void write32(u32 addr, be_t<u32> value);
static const be_t<u64>& read64(u32 addr);
static void write64(u32 addr, be_t<u64> value);
template<typename... Args>
static void error(const const_str& fmt, Args&&... args)
{
IPC.error(fmt, std::forward<Args>(args)...);
}
static int get_port();
static pine::EmuStatus get_status();
static const std::string& get_title();
static const std::string& get_title_ID();
static const std::string& get_executable_hash();
static const std::string& get_app_version();
static std::string get_version_and_branch();
public:
static auto constexpr thread_name = "IPC Server"sv;
IPC_impl& operator=(thread_state);
};
class IPC_server_manager
{
using IPC_server = named_thread<pine::pine_server<IPC_socket::IPC_impl>>;
std::unique_ptr<IPC_server> m_ipc_server;
int m_old_port = 0;
public:
explicit IPC_server_manager(bool enabled);
void set_server_enabled(bool enabled);
};
}
| 1,527
|
C++
|
.h
| 50
| 27.84
| 75
| 0.711656
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,810
|
GameInfo.h
|
RPCS3_rpcs3/rpcs3/Emu/GameInfo.h
|
#pragma once
#include "util/types.hpp"
#include <string>
struct GameInfo
{
std::string path;
std::string icon_path;
std::string movie_path;
std::string name;
std::string serial;
std::string app_ver;
std::string version;
std::string category;
std::string fw;
u32 attr = 0;
u32 bootable = 0;
u32 parental_lvl = 0;
u32 sound_format = 0;
u32 resolution = 0;
u64 size_on_disk = umax;
};
| 402
|
C++
|
.h
| 21
| 17.190476
| 25
| 0.723404
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,811
|
IPC.h
|
RPCS3_rpcs3/rpcs3/Emu/IPC.h
|
#pragma once
#include <memory>
#include <unordered_map>
#include "Utilities/mutex.h"
// IPC manager for objects of type T and IPC keys of type K.
template <typename T, typename K>
class ipc_manager final
{
std::unordered_map<K, std::shared_ptr<T>> m_map;
mutable shared_mutex m_mutex;
public:
// Add new object if specified ipc_key is not used
// .first: added new object?, .second: what's at m_map[key] after this function if (peek_ptr || added new object) is true
template <typename F>
std::pair<bool, std::shared_ptr<T>> add(const K& ipc_key, F&& provider, bool peek_ptr = true)
{
std::lock_guard lock(m_mutex);
// Get object location
std::shared_ptr<T>& ptr = m_map[ipc_key];
const bool existed = ptr.operator bool();
if (!existed)
{
// Call a function which must return the object
ptr = provider();
}
const bool added = !existed && ptr;
return {added, (peek_ptr || added) ? ptr : nullptr};
}
// Unregister specified ipc_key, may return true even if the object doesn't exist anymore
bool remove(const K& ipc_key)
{
std::lock_guard lock(m_mutex);
return m_map.erase(ipc_key) != 0;
}
// Get object with specified ipc_key
std::shared_ptr<T> get(const K& ipc_key) const
{
reader_lock lock(m_mutex);
const auto found = m_map.find(ipc_key);
if (found != m_map.end())
{
return found->second;
}
return nullptr;
}
// Check whether the object actually exists
bool check(const K& ipc_key) const
{
reader_lock lock(m_mutex);
const auto found = m_map.find(ipc_key);
return found != m_map.end();
}
};
| 1,577
|
C++
|
.h
| 53
| 27.132075
| 122
| 0.694758
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,812
|
VFS.h
|
RPCS3_rpcs3/rpcs3/Emu/VFS.h
|
#pragma once
#include <vector>
#include <string>
#include <string_view>
struct lv2_fs_mount_point;
struct vfs_directory;
namespace vfs
{
// Mount VFS device
bool mount(std::string_view vpath, std::string_view path, bool is_dir = true);
// Unmount VFS device
bool unmount(std::string_view vpath);
// Convert VFS path to fs path, optionally listing directories mounted in it
std::string get(std::string_view vpath, std::vector<std::string>* out_dir = nullptr, std::string* out_path = nullptr);
// Convert fs path to VFS path
std::string retrieve(std::string_view path, const vfs_directory* node = nullptr, std::vector<std::string_view>* mount_path = nullptr);
// Escape VFS name by replacing non-portable characters with surrogates
std::string escape(std::string_view name, bool escape_slash = false);
// Invert escape operation
std::string unescape(std::string_view name);
// Functions in this namespace operate on host filepaths, similar to fs::
namespace host
{
// For internal use (don't use)
std::string hash_path(const std::string& path, const std::string& dev_root, std::string_view prefix = {});
// Call fs::rename with retry on access error
bool rename(const std::string& from, const std::string& to, const lv2_fs_mount_point* mp, bool overwrite, bool lock = true);
// Delete file without deleting its contents, emulated with MoveFileEx on Windows
bool unlink(const std::string& path, const std::string& dev_root);
// Delete folder contents using rename, done atomically if remove_root is true
bool remove_all(const std::string& path, const std::string& dev_root, const lv2_fs_mount_point* mp, bool remove_root = true, bool lock = true, bool force_atomic = false);
}
}
| 1,720
|
C++
|
.h
| 33
| 49.787879
| 172
| 0.744478
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,813
|
PPUDisAsm.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/PPUDisAsm.h
|
#pragma once
#include "Emu/Cell/PPCDisAsm.h"
#include "Emu/Cell/PPUOpcodes.h"
class PPUDisAsm final : public PPCDisAsm
{
public:
PPUDisAsm(cpu_disasm_mode mode, const u8* offset) : PPCDisAsm(mode, offset)
{
}
private:
u32 DisAsmBranchTarget(const s32 imm) override
{
return dump_pc + (imm & ~3);
}
constexpr const char* get_partial_BI_field(u32 bi)
{
switch (bi % 4)
{
case 0x0: return "lt";
case 0x1: return "gt";
case 0x2: return "eq";
case 0x3: return "so";
default: fmt::throw_exception("Unreachable");
}
}
private:
void DisAsm_V4(std::string_view op, u32 v0, u32 v1, u32 v2, u32 v3)
{
fmt::append(last_opcode, "%-*s v%d,v%d,v%d,v%d", PadOp(), op, v0, v1, v2, v3);
}
void DisAsm_V3_UIMM(std::string_view op, u32 v0, u32 v1, u32 v2, u32 uimm)
{
fmt::append(last_opcode, "%-*s v%d,v%d,v%d,%s", PadOp(), op, v0, v1, v2, uimm);
}
void DisAsm_V3(std::string_view op, u32 v0, u32 v1, u32 v2)
{
fmt::append(last_opcode, "%-*s v%d,v%d,v%d", PadOp(), op, v0, v1, v2);
}
void DisAsm_V2_UIMM(std::string_view op, u32 v0, u32 v1, u32 uimm)
{
fmt::append(last_opcode, "%-*s v%d,v%d,%s", PadOp(), op, v0, v1, uimm);
}
void DisAsm_V2(std::string_view op, u32 v0, u32 v1)
{
fmt::append(last_opcode, "%-*s v%d,v%d", PadOp(), op, v0, v1);
}
void DisAsm_V1_SIMM(std::string_view op, u32 v0, s32 simm)
{
fmt::append(last_opcode, "%-*s v%d,%s", PadOp(), op, v0, SignedHex(simm));
}
void DisAsm_V1(std::string_view op, u32 v0)
{
fmt::append(last_opcode, "%-*s v%d", PadOp(), op, v0);
}
void DisAsm_V1_R2(std::string_view op, u32 v0, u32 r1, u32 r2)
{
fmt::append(last_opcode, "%-*s v%d,r%d,r%d", PadOp(), op, v0, r1, r2);
}
void DisAsm_CR1_F2_RC(std::string_view op, u32 cr0, u32 f0, u32 f1, u32 rc)
{
fmt::append(last_opcode, "%-*s cr%d,f%d,f%d", PadOp(op, rc ? 1 : 0), op, cr0, f0, f1);
insert_char_if(op, !!rc);
}
void DisAsm_CR1_F2(std::string_view op, u32 cr0, u32 f0, u32 f1)
{
DisAsm_CR1_F2_RC(op, cr0, f0, f1, false);
}
void DisAsm_INT1_R2(std::string_view op, u32 i0, u32 r0, u32 r1)
{
fmt::append(last_opcode, "%-*s %d,r%d,r%d", PadOp(), op, i0, r0, r1);
}
void DisAsm_INT1_R1_IMM(std::string_view op, u32 i0, u32 r0, s32 imm0)
{
fmt::append(last_opcode, "%-*s %d,r%d,%s", PadOp(), op, i0, r0, SignedHex(imm0));
}
void DisAsm_INT1_R1_RC(std::string_view op, u32 i0, u32 r0, u32 rc)
{
fmt::append(last_opcode, "%-*s %d,r%d", PadOp(op, rc ? 1 : 0), op, i0, r0);
insert_char_if(op, !!rc);
}
void DisAsm_INT1_R1(std::string_view op, u32 i0, u32 r0)
{
DisAsm_INT1_R1_RC(op, i0, r0, false);
}
void DisAsm_F4_RC(std::string_view op, u32 f0, u32 f1, u32 f2, u32 f3, u32 rc)
{
fmt::append(last_opcode, "%-*s f%d,f%d,f%d,f%d", PadOp(op, rc ? 1 : 0), op, f0, f1, f2, f3);
insert_char_if(op, !!rc);
}
void DisAsm_F3_RC(std::string_view op, u32 f0, u32 f1, u32 f2, u32 rc)
{
fmt::append(last_opcode, "%-*s f%d,f%d,f%d", PadOp(op, rc ? 1 : 0), op, f0, f1, f2);
insert_char_if(op, !!rc);
}
void DisAsm_F3(std::string_view op, u32 f0, u32 f1, u32 f2)
{
DisAsm_F3_RC(op, f0, f1, f2, false);
}
void DisAsm_F2_RC(std::string_view op, u32 f0, u32 f1, u32 rc)
{
fmt::append(last_opcode, "%-*s f%d,f%d", PadOp(op, rc ? 1 : 0), op, f0, f1);
insert_char_if(op, !!rc);
}
void DisAsm_F2(std::string_view op, u32 f0, u32 f1)
{
DisAsm_F2_RC(op, f0, f1, false);
}
void DisAsm_F1_R2(std::string_view op, u32 f0, u32 r0, u32 r1)
{
if (m_mode == cpu_disasm_mode::compiler_elf)
{
fmt::append(last_opcode, "%-*s f%d,r%d,r%d", PadOp(), op, f0, r0, r1);
return;
}
fmt::append(last_opcode, "%-*s f%d,r%d(r%d)", PadOp(), op, f0, r0, r1);
}
void DisAsm_F1_IMM_R1_RC(std::string_view op, u32 f0, s32 imm0, u32 r0, u32 rc)
{
if (m_mode == cpu_disasm_mode::compiler_elf)
{
fmt::append(last_opcode, "%-*s f%d,r%d,%s", PadOp(op, rc ? 1 : 0), op, f0, r0, SignedHex(imm0));
insert_char_if(op, !!rc);
return;
}
fmt::append(last_opcode, "%-*s f%d,%s(r%d)", PadOp(op, rc ? 1 : 0), op, f0, SignedHex(imm0), r0);
insert_char_if(op, !!rc);
}
void DisAsm_F1_IMM_R1(std::string_view op, u32 f0, s32 imm0, u32 r0)
{
DisAsm_F1_IMM_R1_RC(op, f0, imm0, r0, false);
}
void DisAsm_F1_RC(std::string_view op, u32 f0, u32 rc)
{
fmt::append(last_opcode, "%-*s f%d", PadOp(op, rc ? 1 : 0), op, f0);
insert_char_if(op, !!rc);
}
void DisAsm_R1_RC(std::string_view op, u32 r0, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d", PadOp(op, rc ? 1 : 0), op, r0);
insert_char_if(op, !!rc);
}
void DisAsm_R1(std::string_view op, u32 r0)
{
DisAsm_R1_RC(op, r0, false);
}
void DisAsm_R2_OE_RC(std::string_view op, u32 r0, u32 r1, u32 _oe, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d", PadOp(op, (rc ? 1 : 0) + (_oe ? 1 : 0)), op, r0, r1);
insert_char_if(insert_char_if(op, !!_oe, 'o'), !!rc, '.');
}
void DisAsm_R2_RC(std::string_view op, u32 r0, u32 r1, u32 rc)
{
DisAsm_R2_OE_RC(op, r0, r1, false, rc);
}
void DisAsm_R2(std::string_view op, u32 r0, u32 r1)
{
DisAsm_R2_RC(op, r0, r1, false);
}
void DisAsm_R3_OE_RC(std::string_view op, u32 r0, u32 r1, u32 r2, u32 _oe, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d,r%d", PadOp(op, (rc ? 1 : 0) + (_oe ? 1 : 0)), op, r0, r1, r2);
insert_char_if(insert_char_if(op, !!_oe, 'o'), !!rc, '.');
}
void DisAsm_R3_INT2_RC(std::string_view op, u32 r0, u32 r1, u32 r2, s32 i0, s32 i1, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d,r%d,%d,%d", PadOp(op, rc ? 1 : 0), op, r0, r1, r2, i0, i1);
insert_char_if(op, !!rc);
}
void DisAsm_R3_RC(std::string_view op, u32 r0, u32 r1, u32 r2, u32 rc)
{
DisAsm_R3_OE_RC(op, r0, r1, r2, false, rc);
}
void DisAsm_R3(std::string_view op, u32 r0, u32 r1, u32 r2)
{
DisAsm_R3_RC(op, r0, r1, r2, false);
}
void DisAsm_R2_INT3_RC(std::string_view op, u32 r0, u32 r1, s32 i0, s32 i1, s32 i2, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d,%d,%d,%d", PadOp(op, rc ? 1 : 0), op, r0, r1, i0, i1, i2);
insert_char_if(op, !!rc);
}
void DisAsm_R2_INT3(std::string_view op, u32 r0, u32 r1, s32 i0, s32 i1, s32 i2)
{
DisAsm_R2_INT3_RC(op, r0, r1, i0, i1, i2, false);
}
void DisAsm_R2_INT2_RC(std::string_view op, u32 r0, u32 r1, s32 i0, s32 i1, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d,%d,%d", PadOp(op, rc ? 1 : 0), op, r0, r1, i0, i1);
insert_char_if(op, !!rc);
}
void DisAsm_R2_INT2(std::string_view op, u32 r0, u32 r1, s32 i0, s32 i1)
{
DisAsm_R2_INT2_RC(op, r0, r1, i0, i1, false);
}
void DisAsm_R2_INT1_RC(std::string_view op, u32 r0, u32 r1, s32 i0, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d,%d", PadOp(op, rc ? 1 : 0), op, r0, r1, i0);
insert_char_if(op, !!rc);
}
void DisAsm_R2_INT1(std::string_view op, u32 r0, u32 r1, s32 i0)
{
DisAsm_R2_INT1_RC(op, r0, r1, i0, false);
}
void DisAsm_R2_IMM(std::string_view op, u32 r0, u32 r1, s32 imm0)
{
if (m_mode == cpu_disasm_mode::compiler_elf)
{
fmt::append(last_opcode, "%-*s r%d,r%d,%s", PadOp(), op, r0, r1, SignedHex(imm0));
return;
}
fmt::append(last_opcode, "%-*s r%d,%s(r%d)", PadOp(), op, r0, SignedHex(imm0), r1);
}
void DisAsm_R1_IMM(std::string_view op, u32 r0, s32 imm0)
{
fmt::append(last_opcode, "%-*s r%d,%s", PadOp(), op, r0, SignedHex(imm0));
}
void DisAsm_IMM_R1(std::string_view op, s32 imm0, u32 r0)
{
fmt::append(last_opcode, "%-*s %d,r%d #%x", PadOp(), op, imm0, r0, imm0);
}
void DisAsm_CR1_R1_IMM(std::string_view op, u32 cr0, u32 r0, s32 imm0)
{
fmt::append(last_opcode, "%-*s cr%d,r%d,%s", PadOp(), op, cr0, r0, SignedHex(imm0));
}
void DisAsm_CR1_R2_RC(std::string_view op, u32 cr0, u32 r0, u32 r1, u32 rc)
{
fmt::append(last_opcode, "%-*s cr%d,r%d,r%d", PadOp(op, rc ? 1 : 0), op, cr0, r0, r1);
insert_char_if(op, !!rc);
}
void DisAsm_CR1_R1(std::string_view op, u32 cr0, u32 r0)
{
fmt::append(last_opcode, "%-*s cr%d,r%d", PadOp(), op, cr0, r0);
}
void DisAsm_R1_CR1(std::string_view op, u32 r0, u32 cr0)
{
fmt::append(last_opcode, "%-*s r%d,cr%d", PadOp(), op, r0, cr0);
}
void DisAsm_CR1_R2(std::string_view op, u32 cr0, u32 r0, u32 r1)
{
DisAsm_CR1_R2_RC(op, cr0, r0, r1, false);
}
void DisAsm_CR2(std::string_view op, u32 cr0, u32 cr1)
{
fmt::append(last_opcode, "%-*s cr%d,cr%d", PadOp(), op, cr0, cr1);
}
void DisAsm_BI1(std::string_view op, const int i0)
{
fmt::append(last_opcode, "%-*s cr%d[%s]", PadOp(), op, i0 / 4, get_partial_BI_field(i0));
}
void DisAsm_BI2(std::string_view op, const int i0, const int i1)
{
fmt::append(last_opcode, "%-*s cr%d[%s],cr%d[%s]", PadOp(), op, i0 / 4, get_partial_BI_field(i0), i1 / 4, get_partial_BI_field(i1));
}
void DisAsm_BI3(std::string_view op, const int i0, const int i1, const int i2)
{
fmt::append(last_opcode, "%-*s cr%d[%s],cr%d[%s],cr%d[%s]", PadOp(), op,
i0 / 4, get_partial_BI_field(i0), i1 / 4, get_partial_BI_field(i1), i2 / 4, get_partial_BI_field(i2));
}
void DisAsm_INT3(std::string_view op, const int i0, const int i1, const int i2)
{
fmt::append(last_opcode, "%-*s %d,%d,%d", PadOp(), op, i0, i1, i2);
}
void DisAsm_INT1(std::string_view op, const int i0)
{
fmt::append(last_opcode, "%-*s %d", PadOp(), op, i0);
}
void DisAsm_BRANCH(std::string_view op, const int pc)
{
fmt::append(last_opcode, "%-*s 0x%x", PadOp(), op, DisAsmBranchTarget(pc));
}
void DisAsm_BRANCH_A(std::string_view op, const int pc)
{
fmt::append(last_opcode, "%-*s 0x%x", PadOp(), op, pc);
}
void DisAsm_B2_BRANCH(std::string_view op, u32 b0, u32 b1, const int pc)
{
fmt::append(last_opcode, "%-*s %d,%d,0x%x ", PadOp(), op, b0, b1, DisAsmBranchTarget(pc));
}
void DisAsm_CR_BRANCH(std::string_view op, u32 cr, const int pc)
{
fmt::append(last_opcode, "%-*s cr%d,0x%x ", PadOp(), op, cr, DisAsmBranchTarget(pc));
}
void DisAsm_CR_BRANCH_A(std::string_view op, u32 cr, const int pc)
{
fmt::append(last_opcode, "%-*s cr%d,0x%x ", PadOp(), op, cr, pc);
}
void DisAsm_BI_BRANCH(std::string_view op, u32 bi, const int pc)
{
fmt::append(last_opcode, "%-*s cr%d[%s],0x%x ", PadOp(), op, bi / 4, get_partial_BI_field(bi), DisAsmBranchTarget(pc));
}
void DisAsm_BI_BRANCH_A(std::string_view op, u32 bi, const int pc)
{
fmt::append(last_opcode, "%-*s cr%d[%s],0x%x ", PadOp(), op, bi / 4, get_partial_BI_field(bi), pc);
}
public:
u32 disasm(u32 pc) override;
std::pair<const void*, usz> get_memory_span() const override;
std::unique_ptr<CPUDisAsm> copy_type_erased() const override;
enum class const_op
{
none,
form, // Cosntant formation
xor_mask, // Constant XOR mask applied (used with CMPI/CMPLI instructions, covers their limit of 16-bit immediates)
};
std::pair<const_op, u64> try_get_const_op_gpr_value(u32 reg, u32 pc = -1, u32 TTL = 10) const;
std::pair<bool, u64> try_get_const_gpr_value(u32 reg, u32 pc = -1) const
{
auto [op, res] = try_get_const_op_gpr_value(reg, pc);
return {op == const_op::form, res};
}
std::pair<bool, u64> try_get_const_xor_gpr_value(u32 reg, u32 pc = -1) const
{
auto [op, res] = try_get_const_op_gpr_value(reg, pc);
return {op == const_op::xor_mask, res};
}
void MFVSCR(ppu_opcode_t op);
void MTVSCR(ppu_opcode_t op);
void VADDCUW(ppu_opcode_t op);
void VADDFP(ppu_opcode_t op);
void VADDSBS(ppu_opcode_t op);
void VADDSHS(ppu_opcode_t op);
void VADDSWS(ppu_opcode_t op);
void VADDUBM(ppu_opcode_t op);
void VADDUBS(ppu_opcode_t op);
void VADDUHM(ppu_opcode_t op);
void VADDUHS(ppu_opcode_t op);
void VADDUWM(ppu_opcode_t op);
void VADDUWS(ppu_opcode_t op);
void VAND(ppu_opcode_t op);
void VANDC(ppu_opcode_t op);
void VAVGSB(ppu_opcode_t op);
void VAVGSH(ppu_opcode_t op);
void VAVGSW(ppu_opcode_t op);
void VAVGUB(ppu_opcode_t op);
void VAVGUH(ppu_opcode_t op);
void VAVGUW(ppu_opcode_t op);
void VCFSX(ppu_opcode_t op);
void VCFUX(ppu_opcode_t op);
void VCMPBFP(ppu_opcode_t op);
void VCMPBFP_(ppu_opcode_t op) { return VCMPBFP(op); }
void VCMPEQFP(ppu_opcode_t op);
void VCMPEQFP_(ppu_opcode_t op) { return VCMPEQFP(op); }
void VCMPEQUB(ppu_opcode_t op);
void VCMPEQUB_(ppu_opcode_t op) { return VCMPEQUB(op); }
void VCMPEQUH(ppu_opcode_t op);
void VCMPEQUH_(ppu_opcode_t op) { return VCMPEQUH(op); }
void VCMPEQUW(ppu_opcode_t op);
void VCMPEQUW_(ppu_opcode_t op) { return VCMPEQUW(op); }
void VCMPGEFP(ppu_opcode_t op);
void VCMPGEFP_(ppu_opcode_t op) { return VCMPGEFP(op); }
void VCMPGTFP(ppu_opcode_t op);
void VCMPGTFP_(ppu_opcode_t op) { return VCMPGTFP(op); }
void VCMPGTSB(ppu_opcode_t op);
void VCMPGTSB_(ppu_opcode_t op) { return VCMPGTSB(op); }
void VCMPGTSH(ppu_opcode_t op);
void VCMPGTSH_(ppu_opcode_t op) { return VCMPGTSH(op); }
void VCMPGTSW(ppu_opcode_t op);
void VCMPGTSW_(ppu_opcode_t op) { return VCMPGTSW(op); }
void VCMPGTUB(ppu_opcode_t op);
void VCMPGTUB_(ppu_opcode_t op) { return VCMPGTUB(op); }
void VCMPGTUH(ppu_opcode_t op);
void VCMPGTUH_(ppu_opcode_t op) { return VCMPGTUH(op); }
void VCMPGTUW(ppu_opcode_t op);
void VCMPGTUW_(ppu_opcode_t op) { return VCMPGTUW(op); }
void VCTSXS(ppu_opcode_t op);
void VCTUXS(ppu_opcode_t op);
void VEXPTEFP(ppu_opcode_t op);
void VLOGEFP(ppu_opcode_t op);
void VMADDFP(ppu_opcode_t op);
void VMAXFP(ppu_opcode_t op);
void VMAXSB(ppu_opcode_t op);
void VMAXSH(ppu_opcode_t op);
void VMAXSW(ppu_opcode_t op);
void VMAXUB(ppu_opcode_t op);
void VMAXUH(ppu_opcode_t op);
void VMAXUW(ppu_opcode_t op);
void VMHADDSHS(ppu_opcode_t op);
void VMHRADDSHS(ppu_opcode_t op);
void VMINFP(ppu_opcode_t op);
void VMINSB(ppu_opcode_t op);
void VMINSH(ppu_opcode_t op);
void VMINSW(ppu_opcode_t op);
void VMINUB(ppu_opcode_t op);
void VMINUH(ppu_opcode_t op);
void VMINUW(ppu_opcode_t op);
void VMLADDUHM(ppu_opcode_t op);
void VMRGHB(ppu_opcode_t op);
void VMRGHH(ppu_opcode_t op);
void VMRGHW(ppu_opcode_t op);
void VMRGLB(ppu_opcode_t op);
void VMRGLH(ppu_opcode_t op);
void VMRGLW(ppu_opcode_t op);
void VMSUMMBM(ppu_opcode_t op);
void VMSUMSHM(ppu_opcode_t op);
void VMSUMSHS(ppu_opcode_t op);
void VMSUMUBM(ppu_opcode_t op);
void VMSUMUHM(ppu_opcode_t op);
void VMSUMUHS(ppu_opcode_t op);
void VMULESB(ppu_opcode_t op);
void VMULESH(ppu_opcode_t op);
void VMULEUB(ppu_opcode_t op);
void VMULEUH(ppu_opcode_t op);
void VMULOSB(ppu_opcode_t op);
void VMULOSH(ppu_opcode_t op);
void VMULOUB(ppu_opcode_t op);
void VMULOUH(ppu_opcode_t op);
void VNMSUBFP(ppu_opcode_t op);
void VNOR(ppu_opcode_t op);
void VOR(ppu_opcode_t op);
void VPERM(ppu_opcode_t op);
void VPKPX(ppu_opcode_t op);
void VPKSHSS(ppu_opcode_t op);
void VPKSHUS(ppu_opcode_t op);
void VPKSWSS(ppu_opcode_t op);
void VPKSWUS(ppu_opcode_t op);
void VPKUHUM(ppu_opcode_t op);
void VPKUHUS(ppu_opcode_t op);
void VPKUWUM(ppu_opcode_t op);
void VPKUWUS(ppu_opcode_t op);
void VREFP(ppu_opcode_t op);
void VRFIM(ppu_opcode_t op);
void VRFIN(ppu_opcode_t op);
void VRFIP(ppu_opcode_t op);
void VRFIZ(ppu_opcode_t op);
void VRLB(ppu_opcode_t op);
void VRLH(ppu_opcode_t op);
void VRLW(ppu_opcode_t op);
void VRSQRTEFP(ppu_opcode_t op);
void VSEL(ppu_opcode_t op);
void VSL(ppu_opcode_t op);
void VSLB(ppu_opcode_t op);
void VSLDOI(ppu_opcode_t op);
void VSLH(ppu_opcode_t op);
void VSLO(ppu_opcode_t op);
void VSLW(ppu_opcode_t op);
void VSPLTB(ppu_opcode_t op);
void VSPLTH(ppu_opcode_t op);
void VSPLTISB(ppu_opcode_t op);
void VSPLTISH(ppu_opcode_t op);
void VSPLTISW(ppu_opcode_t op);
void VSPLTW(ppu_opcode_t op);
void VSR(ppu_opcode_t op);
void VSRAB(ppu_opcode_t op);
void VSRAH(ppu_opcode_t op);
void VSRAW(ppu_opcode_t op);
void VSRB(ppu_opcode_t op);
void VSRH(ppu_opcode_t op);
void VSRO(ppu_opcode_t op);
void VSRW(ppu_opcode_t op);
void VSUBCUW(ppu_opcode_t op);
void VSUBFP(ppu_opcode_t op);
void VSUBSBS(ppu_opcode_t op);
void VSUBSHS(ppu_opcode_t op);
void VSUBSWS(ppu_opcode_t op);
void VSUBUBM(ppu_opcode_t op);
void VSUBUBS(ppu_opcode_t op);
void VSUBUHM(ppu_opcode_t op);
void VSUBUHS(ppu_opcode_t op);
void VSUBUWM(ppu_opcode_t op);
void VSUBUWS(ppu_opcode_t op);
void VSUMSWS(ppu_opcode_t op);
void VSUM2SWS(ppu_opcode_t op);
void VSUM4SBS(ppu_opcode_t op);
void VSUM4SHS(ppu_opcode_t op);
void VSUM4UBS(ppu_opcode_t op);
void VUPKHPX(ppu_opcode_t op);
void VUPKHSB(ppu_opcode_t op);
void VUPKHSH(ppu_opcode_t op);
void VUPKLPX(ppu_opcode_t op);
void VUPKLSB(ppu_opcode_t op);
void VUPKLSH(ppu_opcode_t op);
void VXOR(ppu_opcode_t op);
void TDI(ppu_opcode_t op);
void TWI(ppu_opcode_t op);
void MULLI(ppu_opcode_t op);
void SUBFIC(ppu_opcode_t op);
void CMPLI(ppu_opcode_t op);
void CMPI(ppu_opcode_t op);
void ADDIC(ppu_opcode_t op);
void ADDI(ppu_opcode_t op);
void ADDIS(ppu_opcode_t op);
void BC(ppu_opcode_t op);
void SC(ppu_opcode_t op);
void B(ppu_opcode_t op);
void MCRF(ppu_opcode_t op);
void BCLR(ppu_opcode_t op);
void CRNOR(ppu_opcode_t op);
void CRANDC(ppu_opcode_t op);
void ISYNC(ppu_opcode_t op);
void CRXOR(ppu_opcode_t op);
void CRNAND(ppu_opcode_t op);
void CRAND(ppu_opcode_t op);
void CREQV(ppu_opcode_t op);
void CRORC(ppu_opcode_t op);
void CROR(ppu_opcode_t op);
void BCCTR(ppu_opcode_t op);
void RLWIMI(ppu_opcode_t op);
void RLWINM(ppu_opcode_t op);
void RLWNM(ppu_opcode_t op);
void ORI(ppu_opcode_t op);
void ORIS(ppu_opcode_t op);
void XORI(ppu_opcode_t op);
void XORIS(ppu_opcode_t op);
void ANDI(ppu_opcode_t op);
void ANDIS(ppu_opcode_t op);
void RLDICL(ppu_opcode_t op);
void RLDICR(ppu_opcode_t op);
void RLDIC(ppu_opcode_t op);
void RLDIMI(ppu_opcode_t op);
void RLDCL(ppu_opcode_t op);
void RLDCR(ppu_opcode_t op);
void CMP(ppu_opcode_t op);
void TW(ppu_opcode_t op);
void LVSL(ppu_opcode_t op);
void LVEBX(ppu_opcode_t op);
void SUBFC(ppu_opcode_t op);
void ADDC(ppu_opcode_t op);
void MULHDU(ppu_opcode_t op);
void MULHWU(ppu_opcode_t op);
void MFOCRF(ppu_opcode_t op);
void LWARX(ppu_opcode_t op);
void LDX(ppu_opcode_t op);
void LWZX(ppu_opcode_t op);
void SLW(ppu_opcode_t op);
void CNTLZW(ppu_opcode_t op);
void SLD(ppu_opcode_t op);
void AND(ppu_opcode_t op);
void CMPL(ppu_opcode_t op);
void LVSR(ppu_opcode_t op);
void LVEHX(ppu_opcode_t op);
void SUBF(ppu_opcode_t op);
void LDUX(ppu_opcode_t op);
void DCBST(ppu_opcode_t op);
void LWZUX(ppu_opcode_t op);
void CNTLZD(ppu_opcode_t op);
void ANDC(ppu_opcode_t op);
void TD(ppu_opcode_t op);
void LVEWX(ppu_opcode_t op);
void MULHD(ppu_opcode_t op);
void MULHW(ppu_opcode_t op);
void LDARX(ppu_opcode_t op);
void DCBF(ppu_opcode_t op);
void LBZX(ppu_opcode_t op);
void LVX(ppu_opcode_t op);
void NEG(ppu_opcode_t op);
void LBZUX(ppu_opcode_t op);
void NOR(ppu_opcode_t op);
void STVEBX(ppu_opcode_t op);
void SUBFE(ppu_opcode_t op);
void ADDE(ppu_opcode_t op);
void MTOCRF(ppu_opcode_t op);
void STDX(ppu_opcode_t op);
void STWCX(ppu_opcode_t op);
void STWX(ppu_opcode_t op);
void STVEHX(ppu_opcode_t op);
void STDUX(ppu_opcode_t op);
void STWUX(ppu_opcode_t op);
void STVEWX(ppu_opcode_t op);
void SUBFZE(ppu_opcode_t op);
void ADDZE(ppu_opcode_t op);
void STDCX(ppu_opcode_t op);
void STBX(ppu_opcode_t op);
void STVX(ppu_opcode_t op);
void SUBFME(ppu_opcode_t op);
void MULLD(ppu_opcode_t op);
void ADDME(ppu_opcode_t op);
void MULLW(ppu_opcode_t op);
void DCBTST(ppu_opcode_t op);
void STBUX(ppu_opcode_t op);
void ADD(ppu_opcode_t op);
void DCBT(ppu_opcode_t op);
void LHZX(ppu_opcode_t op);
void EQV(ppu_opcode_t op);
void ECIWX(ppu_opcode_t op);
void LHZUX(ppu_opcode_t op);
void XOR(ppu_opcode_t op);
void MFSPR(ppu_opcode_t op);
void LWAX(ppu_opcode_t op);
void DST(ppu_opcode_t op);
void LHAX(ppu_opcode_t op);
void LVXL(ppu_opcode_t op);
void MFTB(ppu_opcode_t op);
void LWAUX(ppu_opcode_t op);
void DSTST(ppu_opcode_t op);
void LHAUX(ppu_opcode_t op);
void STHX(ppu_opcode_t op);
void ORC(ppu_opcode_t op);
void ECOWX(ppu_opcode_t op);
void STHUX(ppu_opcode_t op);
void OR(ppu_opcode_t op);
void DIVDU(ppu_opcode_t op);
void DIVWU(ppu_opcode_t op);
void MTSPR(ppu_opcode_t op);
void DCBI(ppu_opcode_t op);
void NAND(ppu_opcode_t op);
void STVXL(ppu_opcode_t op);
void DIVD(ppu_opcode_t op);
void DIVW(ppu_opcode_t op);
void LVLX(ppu_opcode_t op);
void LDBRX(ppu_opcode_t op);
void LSWX(ppu_opcode_t op);
void LWBRX(ppu_opcode_t op);
void LFSX(ppu_opcode_t op);
void SRW(ppu_opcode_t op);
void SRD(ppu_opcode_t op);
void LVRX(ppu_opcode_t op);
void LSWI(ppu_opcode_t op);
void LFSUX(ppu_opcode_t op);
void SYNC(ppu_opcode_t op);
void LFDX(ppu_opcode_t op);
void LFDUX(ppu_opcode_t op);
void STVLX(ppu_opcode_t op);
void STDBRX(ppu_opcode_t op);
void STSWX(ppu_opcode_t op);
void STWBRX(ppu_opcode_t op);
void STFSX(ppu_opcode_t op);
void STVRX(ppu_opcode_t op);
void STFSUX(ppu_opcode_t op);
void STSWI(ppu_opcode_t op);
void STFDX(ppu_opcode_t op);
void STFDUX(ppu_opcode_t op);
void LVLXL(ppu_opcode_t op);
void LHBRX(ppu_opcode_t op);
void SRAW(ppu_opcode_t op);
void SRAD(ppu_opcode_t op);
void LVRXL(ppu_opcode_t op);
void DSS(ppu_opcode_t op);
void SRAWI(ppu_opcode_t op);
void SRADI(ppu_opcode_t op);
void EIEIO(ppu_opcode_t op);
void STVLXL(ppu_opcode_t op);
void STHBRX(ppu_opcode_t op);
void EXTSH(ppu_opcode_t op);
void STVRXL(ppu_opcode_t op);
void EXTSB(ppu_opcode_t op);
void STFIWX(ppu_opcode_t op);
void EXTSW(ppu_opcode_t op);
void ICBI(ppu_opcode_t op);
void DCBZ(ppu_opcode_t op);
void LWZ(ppu_opcode_t op);
void LWZU(ppu_opcode_t op);
void LBZ(ppu_opcode_t op);
void LBZU(ppu_opcode_t op);
void STW(ppu_opcode_t op);
void STWU(ppu_opcode_t op);
void STB(ppu_opcode_t op);
void STBU(ppu_opcode_t op);
void LHZ(ppu_opcode_t op);
void LHZU(ppu_opcode_t op);
void LHA(ppu_opcode_t op);
void LHAU(ppu_opcode_t op);
void STH(ppu_opcode_t op);
void STHU(ppu_opcode_t op);
void LMW(ppu_opcode_t op);
void STMW(ppu_opcode_t op);
void LFS(ppu_opcode_t op);
void LFSU(ppu_opcode_t op);
void LFD(ppu_opcode_t op);
void LFDU(ppu_opcode_t op);
void STFS(ppu_opcode_t op);
void STFSU(ppu_opcode_t op);
void STFD(ppu_opcode_t op);
void STFDU(ppu_opcode_t op);
void LD(ppu_opcode_t op);
void LDU(ppu_opcode_t op);
void LWA(ppu_opcode_t op);
void STD(ppu_opcode_t op);
void STDU(ppu_opcode_t op);
void FDIVS(ppu_opcode_t op);
void FSUBS(ppu_opcode_t op);
void FADDS(ppu_opcode_t op);
void FSQRTS(ppu_opcode_t op);
void FRES(ppu_opcode_t op);
void FMULS(ppu_opcode_t op);
void FMADDS(ppu_opcode_t op);
void FMSUBS(ppu_opcode_t op);
void FNMSUBS(ppu_opcode_t op);
void FNMADDS(ppu_opcode_t op);
void MTFSB1(ppu_opcode_t op);
void MCRFS(ppu_opcode_t op);
void MTFSB0(ppu_opcode_t op);
void MTFSFI(ppu_opcode_t op);
void MFFS(ppu_opcode_t op);
void MTFSF(ppu_opcode_t op);
void FCMPU(ppu_opcode_t op);
void FRSP(ppu_opcode_t op);
void FCTIW(ppu_opcode_t op);
void FCTIWZ(ppu_opcode_t op);
void FDIV(ppu_opcode_t op);
void FSUB(ppu_opcode_t op);
void FADD(ppu_opcode_t op);
void FSQRT(ppu_opcode_t op);
void FSEL(ppu_opcode_t op);
void FMUL(ppu_opcode_t op);
void FRSQRTE(ppu_opcode_t op);
void FMSUB(ppu_opcode_t op);
void FMADD(ppu_opcode_t op);
void FNMSUB(ppu_opcode_t op);
void FNMADD(ppu_opcode_t op);
void FCMPO(ppu_opcode_t op);
void FNEG(ppu_opcode_t op);
void FMR(ppu_opcode_t op);
void FNABS(ppu_opcode_t op);
void FABS(ppu_opcode_t op);
void FCTID(ppu_opcode_t op);
void FCTIDZ(ppu_opcode_t op);
void FCFID(ppu_opcode_t op);
void UNK(ppu_opcode_t op);
void SUBFCO(ppu_opcode_t op) { return SUBFC(op); }
void ADDCO(ppu_opcode_t op) { return ADDC(op); }
void SUBFO(ppu_opcode_t op) { return SUBF(op); }
void NEGO(ppu_opcode_t op) { return NEG(op); }
void SUBFEO(ppu_opcode_t op) { return SUBFE(op); }
void ADDEO(ppu_opcode_t op) { return ADDE(op); }
void SUBFZEO(ppu_opcode_t op) { return SUBFZE(op); }
void ADDZEO(ppu_opcode_t op) { return ADDZE(op); }
void SUBFMEO(ppu_opcode_t op) { return SUBFME(op); }
void MULLDO(ppu_opcode_t op) { return MULLD(op); }
void ADDMEO(ppu_opcode_t op) { return ADDME(op); }
void MULLWO(ppu_opcode_t op) { return MULLW(op); }
void ADDO(ppu_opcode_t op) { return ADD(op); }
void DIVDUO(ppu_opcode_t op) { return DIVDU(op); }
void DIVWUO(ppu_opcode_t op) { return DIVWU(op); }
void DIVDO(ppu_opcode_t op) { return DIVD(op); }
void DIVWO(ppu_opcode_t op) { return DIVW(op); }
void SUBFCO_(ppu_opcode_t op) { return SUBFC(op); }
void ADDCO_(ppu_opcode_t op) { return ADDC(op); }
void SUBFO_(ppu_opcode_t op) { return SUBF(op); }
void NEGO_(ppu_opcode_t op) { return NEG(op); }
void SUBFEO_(ppu_opcode_t op) { return SUBFE(op); }
void ADDEO_(ppu_opcode_t op) { return ADDE(op); }
void SUBFZEO_(ppu_opcode_t op) { return SUBFZE(op); }
void ADDZEO_(ppu_opcode_t op) { return ADDZE(op); }
void SUBFMEO_(ppu_opcode_t op) { return SUBFME(op); }
void MULLDO_(ppu_opcode_t op) { return MULLD(op); }
void ADDMEO_(ppu_opcode_t op) { return ADDME(op); }
void MULLWO_(ppu_opcode_t op) { return MULLW(op); }
void ADDO_(ppu_opcode_t op) { return ADD(op); }
void DIVDUO_(ppu_opcode_t op) { return DIVDU(op); }
void DIVWUO_(ppu_opcode_t op) { return DIVWU(op); }
void DIVDO_(ppu_opcode_t op) { return DIVD(op); }
void DIVWO_(ppu_opcode_t op) { return DIVW(op); }
void RLWIMI_(ppu_opcode_t op) { return RLWIMI(op); }
void RLWINM_(ppu_opcode_t op) { return RLWINM(op); }
void RLWNM_(ppu_opcode_t op) { return RLWNM(op); }
void RLDICL_(ppu_opcode_t op) { return RLDICL(op); }
void RLDICR_(ppu_opcode_t op) { return RLDICR(op); }
void RLDIC_(ppu_opcode_t op) { return RLDIC(op); }
void RLDIMI_(ppu_opcode_t op) { return RLDIMI(op); }
void RLDCL_(ppu_opcode_t op) { return RLDCL(op); }
void RLDCR_(ppu_opcode_t op) { return RLDCR(op); }
void SUBFC_(ppu_opcode_t op) { return SUBFC(op); }
void MULHDU_(ppu_opcode_t op) { return MULHDU(op); }
void ADDC_(ppu_opcode_t op) { return ADDC(op); }
void MULHWU_(ppu_opcode_t op) { return MULHWU(op); }
void SLW_(ppu_opcode_t op) { return SLW(op); }
void CNTLZW_(ppu_opcode_t op) { return CNTLZW(op); }
void SLD_(ppu_opcode_t op) { return SLD(op); }
void AND_(ppu_opcode_t op) { return AND(op); }
void SUBF_(ppu_opcode_t op) { return SUBF(op); }
void CNTLZD_(ppu_opcode_t op) { return CNTLZD(op); }
void ANDC_(ppu_opcode_t op) { return ANDC(op); }
void MULHD_(ppu_opcode_t op) { return MULHD(op); }
void MULHW_(ppu_opcode_t op) { return MULHW(op); }
void NEG_(ppu_opcode_t op) { return NEG(op); }
void NOR_(ppu_opcode_t op) { return NOR(op); }
void SUBFE_(ppu_opcode_t op) { return SUBFE(op); }
void ADDE_(ppu_opcode_t op) { return ADDE(op); }
void SUBFZE_(ppu_opcode_t op) { return SUBFZE(op); }
void ADDZE_(ppu_opcode_t op) { return ADDZE(op); }
void MULLD_(ppu_opcode_t op) { return MULLD(op); }
void SUBFME_(ppu_opcode_t op) { return SUBFME(op); }
void ADDME_(ppu_opcode_t op) { return ADDME(op); }
void MULLW_(ppu_opcode_t op) { return MULLW(op); }
void ADD_(ppu_opcode_t op) { return ADD(op); }
void EQV_(ppu_opcode_t op) { return EQV(op); }
void XOR_(ppu_opcode_t op) { return XOR(op); }
void ORC_(ppu_opcode_t op) { return ORC(op); }
void OR_(ppu_opcode_t op) { return OR(op); }
void DIVDU_(ppu_opcode_t op) { return DIVDU(op); }
void DIVWU_(ppu_opcode_t op) { return DIVWU(op); }
void NAND_(ppu_opcode_t op) { return NAND(op); }
void DIVD_(ppu_opcode_t op) { return DIVD(op); }
void DIVW_(ppu_opcode_t op) { return DIVW(op); }
void SRW_(ppu_opcode_t op) { return SRW(op); }
void SRD_(ppu_opcode_t op) { return SRD(op); }
void SRAW_(ppu_opcode_t op) { return SRAW(op); }
void SRAD_(ppu_opcode_t op) { return SRAD(op); }
void SRAWI_(ppu_opcode_t op) { return SRAWI(op); }
void SRADI_(ppu_opcode_t op) { return SRADI(op); }
void EXTSH_(ppu_opcode_t op) { return EXTSH(op); }
void EXTSB_(ppu_opcode_t op) { return EXTSB(op); }
void EXTSW_(ppu_opcode_t op) { return EXTSW(op); }
void FDIVS_(ppu_opcode_t op) { return FDIVS(op); }
void FSUBS_(ppu_opcode_t op) { return FSUBS(op); }
void FADDS_(ppu_opcode_t op) { return FADDS(op); }
void FSQRTS_(ppu_opcode_t op) { return FSQRTS(op); }
void FRES_(ppu_opcode_t op) { return FRES(op); }
void FMULS_(ppu_opcode_t op) { return FMULS(op); }
void FMADDS_(ppu_opcode_t op) { return FMADDS(op); }
void FMSUBS_(ppu_opcode_t op) { return FMSUBS(op); }
void FNMSUBS_(ppu_opcode_t op) { return FNMSUBS(op); }
void FNMADDS_(ppu_opcode_t op) { return FNMADDS(op); }
void MTFSB1_(ppu_opcode_t op) { return MTFSB1(op); }
void MTFSB0_(ppu_opcode_t op) { return MTFSB0(op); }
void MTFSFI_(ppu_opcode_t op) { return MTFSFI(op); }
void MFFS_(ppu_opcode_t op) { return MFFS(op); }
void MTFSF_(ppu_opcode_t op) { return MTFSF(op); }
void FRSP_(ppu_opcode_t op) { return FRSP(op); }
void FCTIW_(ppu_opcode_t op) { return FCTIW(op); }
void FCTIWZ_(ppu_opcode_t op) { return FCTIWZ(op); }
void FDIV_(ppu_opcode_t op) { return FDIV(op); }
void FSUB_(ppu_opcode_t op) { return FSUB(op); }
void FADD_(ppu_opcode_t op) { return FADD(op); }
void FSQRT_(ppu_opcode_t op) { return FSQRT(op); }
void FSEL_(ppu_opcode_t op) { return FSEL(op); }
void FMUL_(ppu_opcode_t op) { return FMUL(op); }
void FRSQRTE_(ppu_opcode_t op) { return FRSQRTE(op); }
void FMSUB_(ppu_opcode_t op) { return FMSUB(op); }
void FMADD_(ppu_opcode_t op) { return FMADD(op); }
void FNMSUB_(ppu_opcode_t op) { return FNMSUB(op); }
void FNMADD_(ppu_opcode_t op) { return FNMADD(op); }
void FNEG_(ppu_opcode_t op) { return FNEG(op); }
void FMR_(ppu_opcode_t op) { return FMR(op); }
void FNABS_(ppu_opcode_t op) { return FNABS(op); }
void FABS_(ppu_opcode_t op) { return FABS(op); }
void FCTID_(ppu_opcode_t op) { return FCTID(op); }
void FCTIDZ_(ppu_opcode_t op) { return FCTIDZ(op); }
void FCFID_(ppu_opcode_t op) { return FCFID(op); }
};
| 29,537
|
C++
|
.h
| 830
| 33.439759
| 134
| 0.673568
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,814
|
SPUASMJITRecompiler.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/SPUASMJITRecompiler.h
|
#pragma once
#include "Utilities/JIT.h"
#include "SPURecompiler.h"
#include <functional>
union v128;
// SPU ASMJIT Recompiler
class spu_recompiler : public spu_recompiler_base
{
public:
spu_recompiler();
virtual void init() override;
virtual spu_function_t compile(spu_program&&) override;
private:
// ASMJIT runtime
::jit_runtime m_asmrt;
u32 m_base;
// emitter:
asmjit::x86::Assembler* c;
// arguments:
const asmjit::x86::Gp* cpu;
const asmjit::x86::Gp* ls;
const asmjit::x86::Gp* rip;
const asmjit::x86::Gp* pc0;
// Native args or temp variables:
const asmjit::x86::Gp* arg0;
const asmjit::x86::Gp* arg1;
const asmjit::x86::Gp* qw0;
const asmjit::x86::Gp* qw1;
// temporary:
const asmjit::x86::Gp* addr;
std::array<const asmjit::x86::Xmm*, 16> vec;
// workload for the end of function:
std::vector<std::function<void()>> after;
std::vector<std::function<void()>> consts;
// Function return label
asmjit::Label label_stop;
// Indirect branch dispatch table
asmjit::Label instr_table;
// All valid instruction labels
std::map<u32, asmjit::Label> instr_labels;
// All emitted 128-bit consts
std::map<std::pair<u64, u64>, asmjit::Label> xmm_consts;
class XmmLink
{
const asmjit::x86::Xmm* m_var;
public:
XmmLink(const asmjit::x86::Xmm*& xmm_var)
: m_var(xmm_var)
{
xmm_var = nullptr;
}
XmmLink(XmmLink&&) = default; // MoveConstructible + delete copy constructor and copy/move operators
operator const asmjit::x86::Xmm&() const
{
return *m_var;
}
};
enum class XmmType
{
Int,
Float,
Double,
};
XmmLink XmmAlloc();
XmmLink XmmGet(s8 reg, XmmType type);
asmjit::x86::Mem XmmConst(const v128& data);
asmjit::x86::Mem get_pc(u32 addr);
void branch_fixed(u32 target, bool absolute = false);
void branch_indirect(spu_opcode_t op, bool jt = false, bool ret = true);
void branch_set_link(u32 target);
void fall(spu_opcode_t op);
public:
void UNK(spu_opcode_t op);
void STOP(spu_opcode_t op);
void LNOP(spu_opcode_t op);
void SYNC(spu_opcode_t op);
void DSYNC(spu_opcode_t op);
void MFSPR(spu_opcode_t op);
void RDCH(spu_opcode_t op);
void RCHCNT(spu_opcode_t op);
void SF(spu_opcode_t op);
void OR(spu_opcode_t op);
void BG(spu_opcode_t op);
void SFH(spu_opcode_t op);
void NOR(spu_opcode_t op);
void ABSDB(spu_opcode_t op);
void ROT(spu_opcode_t op);
void ROTM(spu_opcode_t op);
void ROTMA(spu_opcode_t op);
void SHL(spu_opcode_t op);
void ROTH(spu_opcode_t op);
void ROTHM(spu_opcode_t op);
void ROTMAH(spu_opcode_t op);
void SHLH(spu_opcode_t op);
void ROTI(spu_opcode_t op);
void ROTMI(spu_opcode_t op);
void ROTMAI(spu_opcode_t op);
void SHLI(spu_opcode_t op);
void ROTHI(spu_opcode_t op);
void ROTHMI(spu_opcode_t op);
void ROTMAHI(spu_opcode_t op);
void SHLHI(spu_opcode_t op);
void A(spu_opcode_t op);
void AND(spu_opcode_t op);
void CG(spu_opcode_t op);
void AH(spu_opcode_t op);
void NAND(spu_opcode_t op);
void AVGB(spu_opcode_t op);
void MTSPR(spu_opcode_t op);
void WRCH(spu_opcode_t op);
void BIZ(spu_opcode_t op);
void BINZ(spu_opcode_t op);
void BIHZ(spu_opcode_t op);
void BIHNZ(spu_opcode_t op);
void STOPD(spu_opcode_t op);
void STQX(spu_opcode_t op);
void BI(spu_opcode_t op);
void BISL(spu_opcode_t op);
void IRET(spu_opcode_t op);
void BISLED(spu_opcode_t op);
void HBR(spu_opcode_t op);
void GB(spu_opcode_t op);
void GBH(spu_opcode_t op);
void GBB(spu_opcode_t op);
void FSM(spu_opcode_t op);
void FSMH(spu_opcode_t op);
void FSMB(spu_opcode_t op);
void FREST(spu_opcode_t op);
void FRSQEST(spu_opcode_t op);
void LQX(spu_opcode_t op);
void ROTQBYBI(spu_opcode_t op);
void ROTQMBYBI(spu_opcode_t op);
void SHLQBYBI(spu_opcode_t op);
void CBX(spu_opcode_t op);
void CHX(spu_opcode_t op);
void CWX(spu_opcode_t op);
void CDX(spu_opcode_t op);
void ROTQBI(spu_opcode_t op);
void ROTQMBI(spu_opcode_t op);
void SHLQBI(spu_opcode_t op);
void ROTQBY(spu_opcode_t op);
void ROTQMBY(spu_opcode_t op);
void SHLQBY(spu_opcode_t op);
void ORX(spu_opcode_t op);
void CBD(spu_opcode_t op);
void CHD(spu_opcode_t op);
void CWD(spu_opcode_t op);
void CDD(spu_opcode_t op);
void ROTQBII(spu_opcode_t op);
void ROTQMBII(spu_opcode_t op);
void SHLQBII(spu_opcode_t op);
void ROTQBYI(spu_opcode_t op);
void ROTQMBYI(spu_opcode_t op);
void SHLQBYI(spu_opcode_t op);
void NOP(spu_opcode_t op);
void CGT(spu_opcode_t op);
void XOR(spu_opcode_t op);
void CGTH(spu_opcode_t op);
void EQV(spu_opcode_t op);
void CGTB(spu_opcode_t op);
void SUMB(spu_opcode_t op);
void HGT(spu_opcode_t op);
void CLZ(spu_opcode_t op);
void XSWD(spu_opcode_t op);
void XSHW(spu_opcode_t op);
void CNTB(spu_opcode_t op);
void XSBH(spu_opcode_t op);
void CLGT(spu_opcode_t op);
void ANDC(spu_opcode_t op);
void FCGT(spu_opcode_t op);
void DFCGT(spu_opcode_t op);
void FA(spu_opcode_t op);
void FS(spu_opcode_t op);
void FM(spu_opcode_t op);
void CLGTH(spu_opcode_t op);
void ORC(spu_opcode_t op);
void FCMGT(spu_opcode_t op);
void DFCMGT(spu_opcode_t op);
void DFA(spu_opcode_t op);
void DFS(spu_opcode_t op);
void DFM(spu_opcode_t op);
void CLGTB(spu_opcode_t op);
void HLGT(spu_opcode_t op);
void DFMA(spu_opcode_t op);
void DFMS(spu_opcode_t op);
void DFNMS(spu_opcode_t op);
void DFNMA(spu_opcode_t op);
void CEQ(spu_opcode_t op);
void MPYHHU(spu_opcode_t op);
void ADDX(spu_opcode_t op);
void SFX(spu_opcode_t op);
void CGX(spu_opcode_t op);
void BGX(spu_opcode_t op);
void MPYHHA(spu_opcode_t op);
void MPYHHAU(spu_opcode_t op);
void FSCRRD(spu_opcode_t op);
void FESD(spu_opcode_t op);
void FRDS(spu_opcode_t op);
void FSCRWR(spu_opcode_t op);
void DFTSV(spu_opcode_t op);
void FCEQ(spu_opcode_t op);
void DFCEQ(spu_opcode_t op);
void MPY(spu_opcode_t op);
void MPYH(spu_opcode_t op);
void MPYHH(spu_opcode_t op);
void MPYS(spu_opcode_t op);
void CEQH(spu_opcode_t op);
void FCMEQ(spu_opcode_t op);
void DFCMEQ(spu_opcode_t op);
void MPYU(spu_opcode_t op);
void CEQB(spu_opcode_t op);
void FI(spu_opcode_t op);
void HEQ(spu_opcode_t op);
void CFLTS(spu_opcode_t op);
void CFLTU(spu_opcode_t op);
void CSFLT(spu_opcode_t op);
void CUFLT(spu_opcode_t op);
void BRZ(spu_opcode_t op);
void STQA(spu_opcode_t op);
void BRNZ(spu_opcode_t op);
void BRHZ(spu_opcode_t op);
void BRHNZ(spu_opcode_t op);
void STQR(spu_opcode_t op);
void BRA(spu_opcode_t op);
void LQA(spu_opcode_t op);
void BRASL(spu_opcode_t op);
void BR(spu_opcode_t op);
void FSMBI(spu_opcode_t op);
void BRSL(spu_opcode_t op);
void LQR(spu_opcode_t op);
void IL(spu_opcode_t op);
void ILHU(spu_opcode_t op);
void ILH(spu_opcode_t op);
void IOHL(spu_opcode_t op);
void ORI(spu_opcode_t op);
void ORHI(spu_opcode_t op);
void ORBI(spu_opcode_t op);
void SFI(spu_opcode_t op);
void SFHI(spu_opcode_t op);
void ANDI(spu_opcode_t op);
void ANDHI(spu_opcode_t op);
void ANDBI(spu_opcode_t op);
void AI(spu_opcode_t op);
void AHI(spu_opcode_t op);
void STQD(spu_opcode_t op);
void LQD(spu_opcode_t op);
void XORI(spu_opcode_t op);
void XORHI(spu_opcode_t op);
void XORBI(spu_opcode_t op);
void CGTI(spu_opcode_t op);
void CGTHI(spu_opcode_t op);
void CGTBI(spu_opcode_t op);
void HGTI(spu_opcode_t op);
void CLGTI(spu_opcode_t op);
void CLGTHI(spu_opcode_t op);
void CLGTBI(spu_opcode_t op);
void HLGTI(spu_opcode_t op);
void MPYI(spu_opcode_t op);
void MPYUI(spu_opcode_t op);
void CEQI(spu_opcode_t op);
void CEQHI(spu_opcode_t op);
void CEQBI(spu_opcode_t op);
void HEQI(spu_opcode_t op);
void HBRA(spu_opcode_t op);
void HBRR(spu_opcode_t op);
void ILA(spu_opcode_t op);
void SELB(spu_opcode_t op);
void SHUFB(spu_opcode_t op);
void MPYA(spu_opcode_t op);
void FNMS(spu_opcode_t op);
void FMA(spu_opcode_t op);
void FMS(spu_opcode_t op);
};
| 7,779
|
C++
|
.h
| 273
| 26.377289
| 102
| 0.71654
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,815
|
PPUCallback.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/PPUCallback.h
|
#pragma once
#include "Emu/Cell/PPUThread.h"
#include "util/v128.hpp"
struct ppu_func_opd_t;
namespace ppu_cb_detail
{
enum _func_arg_type
{
ARG_GENERAL,
ARG_FLOAT,
ARG_VECTOR,
ARG_STACK,
ARG_CONTEXT,
ARG_UNKNOWN,
};
// Current implementation can handle only fixed amount of stack arguments.
// This constant can be increased if necessary.
// It's possible to calculate suitable stack frame size in template, but too complicated.
static const auto FIXED_STACK_FRAME_SIZE = 0x90;
template<typename T, _func_arg_type type, u32 g_count, u32 f_count, u32 v_count>
struct _func_arg
{
static_assert(type == ARG_GENERAL, "Unknown callback argument type");
static_assert(!std::is_pointer_v<T>, "Invalid callback argument type (pointer)");
static_assert(!std::is_reference_v<T>, "Invalid callback argument type (reference)");
static_assert(sizeof(T) <= 8, "Invalid callback argument type for ARG_GENERAL");
static inline void set_value(ppu_thread& CPU, const T& arg)
{
CPU.gpr[g_count + 2] = ppu_gpr_cast(arg);
}
};
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct _func_arg<T, ARG_FLOAT, g_count, f_count, v_count>
{
static_assert(sizeof(T) <= 8, "Invalid callback argument type for ARG_FLOAT");
static inline void set_value(ppu_thread& CPU, const T& arg)
{
CPU.fpr[f_count] = static_cast<T>(arg);
}
};
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct _func_arg<T, ARG_VECTOR, g_count, f_count, v_count>
{
static_assert(std::is_same_v<std::decay_t<T>, v128>, "Invalid callback argument type for ARG_VECTOR");
static inline void set_value(ppu_thread& CPU, const T& arg)
{
CPU.vr[v_count + 1] = arg;
}
};
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct _func_arg<T, ARG_STACK, g_count, f_count, v_count>
{
static_assert(alignof(T) <= 16, "Unsupported callback argument type alignment for ARG_STACK");
static inline void set_value(ppu_thread& CPU, const T& arg)
{
const s64 stack_pos = (g_count - 1) * 0x8 + 0x30 - FIXED_STACK_FRAME_SIZE;
static_assert(stack_pos < 0, "TODO: Increase FIXED_STACK_FRAME_SIZE (arg count limit broken)");
vm::write64(CPU.gpr[1] + stack_pos, ppu_gpr_cast(arg)); // TODO
}
};
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct _func_arg<T, ARG_CONTEXT, g_count, f_count, v_count>
{
static_assert(std::is_same_v<std::decay_t<T>, ppu_thread>, "Invalid callback argument type for ARG_CONTEXT");
FORCE_INLINE static void set_value(ppu_thread&, const T&)
{
}
};
template<u32 g_count, u32 f_count, u32 v_count>
FORCE_INLINE static bool _bind_func_args(ppu_thread&)
{
// terminator
return false;
}
template<u32 g_count, u32 f_count, u32 v_count, typename T1, typename... T>
FORCE_INLINE static bool _bind_func_args(ppu_thread& CPU, T1 arg1, T... args)
{
const bool is_float = std::is_floating_point_v<T1>;
const bool is_vector = std::is_same_v<std::decay_t<T1>, v128>;
const bool is_context = std::is_same_v<std::decay_t<T1>, ppu_thread>;
const bool is_general = !is_float && !is_vector && !is_context;
const _func_arg_type t =
is_general ? (g_count >= 8 ? ARG_STACK : ARG_GENERAL) :
is_float ? (f_count >= 13 ? ARG_STACK : ARG_FLOAT) :
is_vector ? (v_count >= 12 ? ARG_STACK : ARG_VECTOR) :
is_context ? ARG_CONTEXT :
ARG_UNKNOWN;
const u32 g = g_count + (is_general || is_float ? 1 : is_vector ? (g_count & 1) + 2 : 0);
const u32 f = f_count + is_float;
const u32 v = v_count + is_vector;
_func_arg<T1, t, g, f, v>::set_value(CPU, arg1);
// return true if stack was used
return _bind_func_args<g, f, v>(CPU, args...) || (t == ARG_STACK);
}
template<typename T, _func_arg_type type>
struct _func_res
{
static_assert(type == ARG_GENERAL, "Unknown callback result type");
static_assert(sizeof(T) <= 8, "Invalid callback result type for ARG_GENERAL");
FORCE_INLINE static T get_value(const ppu_thread& CPU)
{
return ppu_gpr_cast<T>(CPU.gpr[3]);
}
};
template<typename T>
struct _func_res<T, ARG_FLOAT>
{
static_assert(sizeof(T) <= 8, "Invalid callback result type for ARG_FLOAT");
FORCE_INLINE static T get_value(const ppu_thread& CPU)
{
return static_cast<T>(CPU.fpr[1]);
}
};
template<typename T>
struct _func_res<T, ARG_VECTOR>
{
static_assert(std::is_same_v<std::decay_t<T>, v128>, "Invalid callback result type for ARG_VECTOR");
FORCE_INLINE static T get_value(const ppu_thread& CPU)
{
return CPU.vr[2];
}
};
template<typename RT, typename... T>
struct _func_caller
{
FORCE_INLINE static RT call(ppu_thread& CPU, u32 pc, u32 rtoc, T... args)
{
_func_caller<void, T...>::call(CPU, pc, rtoc, args...);
static_assert(!std::is_pointer_v<RT>, "Invalid callback result type (pointer)");
static_assert(!std::is_reference_v<RT>, "Invalid callback result type (reference)");
const bool is_float = std::is_floating_point_v<RT>;
const bool is_vector = std::is_same_v<std::decay_t<RT>, v128>;
const _func_arg_type t = is_float ? ARG_FLOAT : (is_vector ? ARG_VECTOR : ARG_GENERAL);
return _func_res<RT, t>::get_value(CPU);
}
};
template<typename... T>
struct _func_caller<void, T...>
{
FORCE_INLINE static void call(ppu_thread& CPU, u32 pc, u32 rtoc, T... args)
{
const u64 old_r1 = CPU.gpr[1];
CPU.gpr[1] &= -16; // Ensure 16-byte alignment
const bool stack = _bind_func_args<0, 0, 0, T...>(CPU, args...);
CPU.gpr[1] -= stack ? FIXED_STACK_FRAME_SIZE : 0x70; // create reserved area
CPU.fast_call(pc, rtoc);
CPU.gpr[1] = old_r1;
}
};
}
namespace vm
{
template<typename AT, typename RT, typename... T>
FORCE_INLINE RT _ptr_base<RT(T...), AT>::operator()(ppu_thread& CPU, T... args) const
{
const auto data = vm::_ptr<ppu_func_opd_t>(vm::cast(m_addr));
const u32 pc = data->addr;
const u32 rtoc = data->rtoc;
return ppu_cb_detail::_func_caller<RT, T...>::call(CPU, pc, rtoc, args...);
}
template<typename AT, typename RT, typename... T>
FORCE_INLINE const ppu_func_opd_t& _ptr_base<RT(T...), AT>::opd() const
{
return vm::_ref<ppu_func_opd_t>(vm::cast(m_addr));
}
}
template<typename RT, typename... T> inline RT cb_call(ppu_thread& CPU, u32 pc, u32 rtoc, T... args)
{
return ppu_cb_detail::_func_caller<RT, T...>::call(CPU, pc, rtoc, args...);
}
| 6,329
|
C++
|
.h
| 170
| 34.394118
| 111
| 0.676845
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,816
|
PPUInterpreter.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/PPUInterpreter.h
|
#pragma once
#include "PPUOpcodes.h"
class ppu_thread;
using ppu_intrp_func_t = void(*)(ppu_thread& ppu_, ppu_opcode_t op, be_t<u32>* this_op, struct ppu_intrp_func* next_fn);
struct ppu_intrp_func
{
ppu_intrp_func_t fn;
};
template <typename IT>
struct ppu_interpreter_t;
namespace asmjit
{
struct ppu_builder;
}
struct ppu_interpreter_rt_base
{
protected:
std::unique_ptr<ppu_interpreter_t<ppu_intrp_func_t>> ptrs;
ppu_interpreter_rt_base() noexcept;
ppu_interpreter_rt_base(const ppu_interpreter_rt_base&) = delete;
ppu_interpreter_rt_base& operator=(const ppu_interpreter_rt_base&) = delete;
virtual ~ppu_interpreter_rt_base();
};
struct ppu_interpreter_rt : ppu_interpreter_rt_base
{
ppu_interpreter_rt() noexcept;
ppu_intrp_func_t decode(u32 op) const noexcept;
private:
ppu_decoder<ppu_interpreter_t<ppu_intrp_func_t>, ppu_intrp_func_t> table;
};
| 878
|
C++
|
.h
| 30
| 27.466667
| 120
| 0.763789
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,817
|
PPCDisAsm.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/PPCDisAsm.h
|
#pragma once
#include "Emu/CPU/CPUDisAsm.h"
class PPCDisAsm : public CPUDisAsm
{
protected:
PPCDisAsm(cpu_disasm_mode mode, const u8* offset, u32 start_pc = 0) : CPUDisAsm(mode, offset, start_pc)
{
}
virtual u32 DisAsmBranchTarget(const s32 imm) override = 0;
usz insert_char_if(usz pos, bool insert, char c)
{
if (!insert)
{
return pos;
}
ensure(std::exchange(last_opcode[pos], c) == ' ' && last_opcode[pos + 1] == ' ');
return pos + 1;
}
usz insert_char_if(std::string_view op, bool insert, char c = '.')
{
return insert_char_if(op.size(), insert, c);
}
void DisAsm_V4(std::string_view op, u32 v0, u32 v1, u32 v2, u32 v3)
{
fmt::append(last_opcode, "%-*s v%d,v%d,v%d,v%d", PadOp(), op, v0, v1, v2, v3);
}
void DisAsm_V3_UIMM(std::string_view op, u32 v0, u32 v1, u32 v2, u32 uimm)
{
fmt::append(last_opcode, "%-*s v%d,v%d,v%d,%s", PadOp(), op, v0, v1, v2, uimm);
}
void DisAsm_V3(std::string_view op, u32 v0, u32 v1, u32 v2)
{
fmt::append(last_opcode, "%-*s v%d,v%d,v%d", PadOp(), op, v0, v1, v2);
}
void DisAsm_V2_UIMM(std::string_view op, u32 v0, u32 v1, u32 uimm)
{
fmt::append(last_opcode, "%-*s v%d,v%d,%s", PadOp(), op, v0, v1, uimm);
}
void DisAsm_V2(std::string_view op, u32 v0, u32 v1)
{
fmt::append(last_opcode, "%-*s v%d,v%d", PadOp(), op, v0, v1);
}
void DisAsm_V1_SIMM(std::string_view op, u32 v0, s32 simm)
{
fmt::append(last_opcode, "%-*s v%d,%s", PadOp(), op, v0, SignedHex(simm));
}
void DisAsm_V1(std::string_view op, u32 v0)
{
fmt::append(last_opcode, "%-*s v%d", PadOp(), op, v0);
}
void DisAsm_V1_R2(std::string_view op, u32 v0, u32 r1, u32 r2)
{
fmt::append(last_opcode, "%-*s v%d,r%d,r%d", PadOp(), op, v0, r1, r2);
}
void DisAsm_CR1_F2_RC(std::string_view op, u32 cr0, u32 f0, u32 f1, u32 rc)
{
fmt::append(last_opcode, "%-*s cr%d,f%d,f%d", PadOp(op, rc ? 1 : 0), op, cr0, f0, f1);
insert_char_if(op, !!rc);
}
void DisAsm_CR1_F2(std::string_view op, u32 cr0, u32 f0, u32 f1)
{
DisAsm_CR1_F2_RC(op, cr0, f0, f1, false);
}
void DisAsm_INT1_R2(std::string_view op, u32 i0, u32 r0, u32 r1)
{
fmt::append(last_opcode, "%-*s %d,r%d,r%d", PadOp(), op, i0, r0, r1);
}
void DisAsm_INT1_R1_IMM(std::string_view op, u32 i0, u32 r0, s32 imm0)
{
fmt::append(last_opcode, "%-*s %d,r%d,%s", PadOp(), op, i0, r0, SignedHex(imm0));
}
void DisAsm_INT1_R1_RC(std::string_view op, u32 i0, u32 r0, u32 rc)
{
fmt::append(last_opcode, "%-*s %d,r%d", PadOp(op, rc ? 1 : 0), op, i0, r0);
insert_char_if(op, !!rc);
}
void DisAsm_INT1_R1(std::string_view op, u32 i0, u32 r0)
{
DisAsm_INT1_R1_RC(op, i0, r0, false);
}
void DisAsm_F4_RC(std::string_view op, u32 f0, u32 f1, u32 f2, u32 f3, u32 rc)
{
fmt::append(last_opcode, "%-*s f%d,f%d,f%d,f%d", PadOp(op, rc ? 1 : 0), op, f0, f1, f2, f3);
insert_char_if(op, !!rc);
}
void DisAsm_F3_RC(std::string_view op, u32 f0, u32 f1, u32 f2, u32 rc)
{
fmt::append(last_opcode, "%-*s f%d,f%d,f%d", PadOp(op, rc ? 1 : 0), op, f0, f1, f2);
insert_char_if(op, !!rc);
}
void DisAsm_F3(std::string_view op, u32 f0, u32 f1, u32 f2)
{
DisAsm_F3_RC(op, f0, f1, f2, false);
}
void DisAsm_F2_RC(std::string_view op, u32 f0, u32 f1, u32 rc)
{
fmt::append(last_opcode, "%-*s f%d,f%d", PadOp(op, rc ? 1 : 0), op, f0, f1);
insert_char_if(op, !!rc);
}
void DisAsm_F2(std::string_view op, u32 f0, u32 f1)
{
DisAsm_F2_RC(op, f0, f1, false);
}
void DisAsm_F1_R2(std::string_view op, u32 f0, u32 r0, u32 r1)
{
if(m_mode == cpu_disasm_mode::compiler_elf)
{
fmt::append(last_opcode, "%-*s f%d,r%d,r%d", PadOp(), op, f0, r0, r1);
return;
}
fmt::append(last_opcode, "%-*s f%d,r%d(r%d)", PadOp(), op, f0, r0, r1);
}
void DisAsm_F1_IMM_R1_RC(std::string_view op, u32 f0, s32 imm0, u32 r0, u32 rc)
{
if(m_mode == cpu_disasm_mode::compiler_elf)
{
fmt::append(last_opcode, "%-*s f%d,r%d,%s", PadOp(op, rc ? 1 : 0), op, f0, r0, SignedHex(imm0));
insert_char_if(op, !!rc);
return;
}
fmt::append(last_opcode, "%-*s f%d,%s(r%d)", PadOp(op, rc ? 1 : 0), op, f0, SignedHex(imm0), r0);
insert_char_if(op, !!rc);
}
void DisAsm_F1_IMM_R1(std::string_view op, u32 f0, s32 imm0, u32 r0)
{
DisAsm_F1_IMM_R1_RC(op, f0, imm0, r0, false);
}
void DisAsm_F1_RC(std::string_view op, u32 f0, u32 rc)
{
fmt::append(last_opcode, "%-*s f%d", PadOp(op, rc ? 1 : 0), op, f0);
insert_char_if(op, !!rc);
}
void DisAsm_R1_RC(std::string_view op, u32 r0, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d", PadOp(op, rc ? 1 : 0), op, r0);
insert_char_if(op, !!rc);
}
void DisAsm_R1(std::string_view op, u32 r0)
{
DisAsm_R1_RC(op, r0, false);
}
void DisAsm_R2_OE_RC(std::string_view op, u32 r0, u32 r1, u32 oe, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d", PadOp(op, (rc ? 1 : 0) + (oe ? 1 : 0)), op, r0, r1);
insert_char_if(insert_char_if(op, !!oe, 'o'), !!rc, '.');
}
void DisAsm_R2_RC(std::string_view op, u32 r0, u32 r1, u32 rc)
{
DisAsm_R2_OE_RC(op, r0, r1, false, rc);
}
void DisAsm_R2(std::string_view op, u32 r0, u32 r1)
{
DisAsm_R2_RC(op, r0, r1, false);
}
void DisAsm_R3_OE_RC(std::string_view op, u32 r0, u32 r1, u32 r2, u32 oe, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d,r%d", PadOp(op, (rc ? 1 : 0) + (oe ? 1 : 0)), op, r0, r1, r2);
insert_char_if(insert_char_if(op, !!oe, 'o'), !!rc, '.');
}
void DisAsm_R3_INT2_RC(std::string_view op, u32 r0, u32 r1, u32 r2, s32 i0, s32 i1, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d,r%d,%d,%d", PadOp(op, rc ? 1 : 0), op, r0, r1, r2, i0, i1);
insert_char_if(op, !!rc);
}
void DisAsm_R3_RC(std::string_view op, u32 r0, u32 r1, u32 r2, u32 rc)
{
DisAsm_R3_OE_RC(op, r0, r1, r2, false, rc);
}
void DisAsm_R3(std::string_view op, u32 r0, u32 r1, u32 r2)
{
DisAsm_R3_RC(op, r0, r1, r2, false);
}
void DisAsm_R2_INT3_RC(std::string_view op, u32 r0, u32 r1, s32 i0, s32 i1, s32 i2, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d,%d,%d,%d", PadOp(op, rc ? 1 : 0), op, r0, r1, i0, i1, i2);
insert_char_if(op, !!rc);
}
void DisAsm_R2_INT3(std::string_view op, u32 r0, u32 r1, s32 i0, s32 i1, s32 i2)
{
DisAsm_R2_INT3_RC(op, r0, r1, i0, i1, i2, false);
}
void DisAsm_R2_INT2_RC(std::string_view op, u32 r0, u32 r1, s32 i0, s32 i1, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d,%d,%d", PadOp(op, rc ? 1 : 0), op, r0, r1, i0, i1);
insert_char_if(op, !!rc);
}
void DisAsm_R2_INT2(std::string_view op, u32 r0, u32 r1, s32 i0, s32 i1)
{
DisAsm_R2_INT2_RC(op, r0, r1, i0, i1, false);
}
void DisAsm_R2_INT1_RC(std::string_view op, u32 r0, u32 r1, s32 i0, u32 rc)
{
fmt::append(last_opcode, "%-*s r%d,r%d,%d", PadOp(op, rc ? 1 : 0), op, r0, r1, i0);
insert_char_if(op, !!rc);
}
void DisAsm_R2_INT1(std::string_view op, u32 r0, u32 r1, s32 i0)
{
DisAsm_R2_INT1_RC(op, r0, r1, i0, false);
}
void DisAsm_R2_IMM(std::string_view op, u32 r0, u32 r1, s32 imm0)
{
if(m_mode == cpu_disasm_mode::compiler_elf)
{
fmt::append(last_opcode, "%-*s r%d,r%d,%s", PadOp(), op, r0, r1, SignedHex(imm0));
return;
}
fmt::append(last_opcode, "%-*s r%d,%s(r%d)", PadOp(), op, r0, SignedHex(imm0), r1);
}
void DisAsm_R1_IMM(std::string_view op, u32 r0, s32 imm0)
{
fmt::append(last_opcode, "%-*s r%d,%s", PadOp(), op, r0, SignedHex(imm0));
}
void DisAsm_IMM_R1(std::string_view op, s32 imm0, u32 r0)
{
fmt::append(last_opcode, "%-*s %d,r%d #%x", PadOp(), op, imm0, r0, imm0);
}
void DisAsm_CR1_R1_IMM(std::string_view op, u32 cr0, u32 r0, s32 imm0)
{
fmt::append(last_opcode, "%-*s cr%d,r%d,%s", PadOp(), op, cr0, r0, SignedHex(imm0));
}
void DisAsm_CR1_R2_RC(std::string_view op, u32 cr0, u32 r0, u32 r1, u32 rc)
{
fmt::append(last_opcode, "%-*s cr%d,r%d,r%d", PadOp(op, rc ? 1 : 0), op, cr0, r0, r1);
insert_char_if(op, !!rc);
}
void DisAsm_CR1_R2(std::string_view op, u32 cr0, u32 r0, u32 r1)
{
DisAsm_CR1_R2_RC(op, cr0, r0, r1, false);
}
void DisAsm_CR2(std::string_view op, u32 cr0, u32 cr1)
{
fmt::append(last_opcode, "%-*s cr%d,cr%d", PadOp(), op, cr0, cr1);
}
void DisAsm_INT3(std::string_view op, s32 i0, s32 i1, s32 i2)
{
fmt::append(last_opcode, "%-*s %d,%d,%d", PadOp(), op, i0, i1, i2);
}
void DisAsm_INT1(std::string_view op, s32 i0)
{
fmt::append(last_opcode, "%-*s %d", PadOp(), op, i0);
}
void DisAsm_BRANCH(std::string_view op, s32 pc)
{
fmt::append(last_opcode, "%-*s 0x%x", PadOp(), op, DisAsmBranchTarget(pc));
}
void DisAsm_BRANCH_A(std::string_view op, s32 pc)
{
fmt::append(last_opcode, "%-*s 0x%x", PadOp(), op, pc);
}
void DisAsm_B2_BRANCH(std::string_view op, u32 b0, u32 b1, s32 pc)
{
fmt::append(last_opcode, "%-*s %d,%d,0x%x ", PadOp(), op, b0, b1, DisAsmBranchTarget(pc));
}
void DisAsm_CR_BRANCH(std::string_view op, u32 cr, s32 pc)
{
fmt::append(last_opcode, "%-*s cr%d,0x%x ", PadOp(), op, cr, DisAsmBranchTarget(pc));
}
void DisAsm_CR_BRANCH_HINT(std::string_view op, u32 cr, u32 bh)
{
fmt::append(last_opcode, "%-*s cr%d,0x%x ", PadOp(), op, cr, bh);
}
};
| 8,962
|
C++
|
.h
| 262
| 31.816794
| 104
| 0.611623
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.